fix(wasix-fs): Fix symlink behaviour

lib/virtual-fs/src/mem_fs/filesystem.rs

@@ -254,6 +254,64 @@ impl FileSystem {
 
         Ok(())
     }
+
+    pub fn create_symlink(&self, source: &Path, target: &Path) -> Result<()> {
+        let (inode_of_parent, name_of_symlink) = {
+            let guard = self.inner.read().map_err(|_| FsError::Lock)?;
+            let path = guard.canonicalize_without_inode(target)?;
+            let parent_of_path = path.parent().ok_or(FsError::BaseNotDirectory)?;
+            let name_of_symlink = path
+                .file_name()
+                .ok_or(FsError::InvalidInput)?
+                .to_os_string();
+            let inode_of_parent = match guard.inode_of_parent(parent_of_path)? {
+                InodeResolution::Found(a) => a,
+                InodeResolution::Redirect(fs, mut redirected_path) => {
+                    redirected_path.push(&name_of_symlink);
+                    drop(guard);
+                    let fs_ref: &dyn crate::FileSystem = fs.as_ref();
+                    if let Some(mem_fs) = fs_ref.downcast_ref::<Self>() {
+                        return mem_fs.create_symlink(source, redirected_path.as_path());
+                    }
+                    return Err(FsError::Unsupported);
+                }
+            };
+            (inode_of_parent, name_of_symlink)
+        };
+
+        let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+        if fs.canonicalize(target).is_ok() {
+            return Err(FsError::AlreadyExists);
+        }
+
+        let inode_of_symlink = fs.storage.vacant_entry().key();
+        let real_inode_of_symlink = fs.storage.insert(Node::Symlink(SymlinkNode {
+            inode: inode_of_symlink,
+            name: name_of_symlink,
+            target: source.to_path_buf(),
+            metadata: {
+                let time = time();
+                Metadata {
+                    ft: FileType {
+                        symlink: true,
+                        ..Default::default()
+                    },
+                    accessed: time,
+                    created: time,
+                    modified: time,
+                    len: source.as_os_str().len() as u64,
+                }
+            },
+        }));
+
+        assert_eq!(
+            inode_of_symlink, real_inode_of_symlink,
+            "new symlink inode should have been correctly calculated",
+        );
+
+        fs.add_child_to_node(inode_of_parent, inode_of_symlink)?;
+        Ok(())
+    }
 }
 
 impl crate::FileSystem for FileSystem {
@@ -264,7 +322,10 @@ impl crate::FileSystem for FileSystem {
         // Canonicalize the path.
         let (_, inode_of_directory) = guard.canonicalize(path)?;
         match inode_of_directory {
-            InodeResolution::Found(_) => Err(FsError::InvalidInput),
+            InodeResolution::Found(inode) => match guard.storage.get(inode) {
+                Some(Node::Symlink(SymlinkNode { target, .. })) => Ok(target.clone()),
+                _ => Err(FsError::InvalidInput),
+            },
             InodeResolution::Redirect(fs, path) => fs.readlink(path.as_path()),
         }
     }
@@ -880,6 +941,7 @@ impl FileSystemInner {
                     | Node::ReadOnlyFile(ReadOnlyFileNode { inode, name, .. })
                     | Node::CustomFile(CustomFileNode { inode, name, .. })
                     | Node::ArcFile(ArcFileNode { inode, name, .. })
+                    | Node::Symlink(SymlinkNode { inode, name, .. })
                         if name.as_os_str() == name_of_file =>
                     {
                         Some(Some((nth, InodeResolution::Found(*inode))))
@@ -1084,6 +1146,7 @@ impl fmt::Debug for FileSystemInner {
                         Node::ReadOnlyFile { .. } => "ro-file",
                         Node::ArcFile { .. } => "arc-file",
                         Node::CustomFile { .. } => "custom-file",
+                        Node::Symlink { .. } => "symlink",
                         Node::Directory { .. } => "dir",
                         Node::ArcDirectory { .. } => "arc-dir",
                     },

lib/virtual-fs/src/mem_fs/mod.rs

@@ -85,13 +85,22 @@ struct ArcDirectoryNode {
     metadata: Metadata,
 }
 
+#[derive(Debug)]
+struct SymlinkNode {
+    inode: Inode,
+    name: OsString,
+    target: PathBuf,
+    metadata: Metadata,
+}
+
 #[derive(Debug)]
 enum Node {
     File(FileNode),
     OffloadedFile(OffloadedFileNode),
     ReadOnlyFile(ReadOnlyFileNode),
     ArcFile(ArcFileNode),
     CustomFile(CustomFileNode),
+    Symlink(SymlinkNode),
     Directory(DirectoryNode),
     ArcDirectory(ArcDirectoryNode),
 }
@@ -104,6 +113,7 @@ impl Node {
             Self::ReadOnlyFile(ReadOnlyFileNode { inode, .. }) => inode,
             Self::ArcFile(ArcFileNode { inode, .. }) => inode,
             Self::CustomFile(CustomFileNode { inode, .. }) => inode,
+            Self::Symlink(SymlinkNode { inode, .. }) => inode,
             Self::Directory(DirectoryNode { inode, .. }) => inode,
             Self::ArcDirectory(ArcDirectoryNode { inode, .. }) => inode,
         }
@@ -116,6 +126,7 @@ impl Node {
             Self::ReadOnlyFile(ReadOnlyFileNode { name, .. }) => name.as_os_str(),
             Self::ArcFile(ArcFileNode { name, .. }) => name.as_os_str(),
             Self::CustomFile(CustomFileNode { name, .. }) => name.as_os_str(),
+            Self::Symlink(SymlinkNode { name, .. }) => name.as_os_str(),
             Self::Directory(DirectoryNode { name, .. }) => name.as_os_str(),
             Self::ArcDirectory(ArcDirectoryNode { name, .. }) => name.as_os_str(),
         }
@@ -128,6 +139,7 @@ impl Node {
             Self::ReadOnlyFile(ReadOnlyFileNode { metadata, .. }) => metadata,
             Self::ArcFile(ArcFileNode { metadata, .. }) => metadata,
             Self::CustomFile(CustomFileNode { metadata, .. }) => metadata,
+            Self::Symlink(SymlinkNode { metadata, .. }) => metadata,
             Self::Directory(DirectoryNode { metadata, .. }) => metadata,
             Self::ArcDirectory(ArcDirectoryNode { metadata, .. }) => metadata,
         }
@@ -140,6 +152,7 @@ impl Node {
             Self::ReadOnlyFile(ReadOnlyFileNode { metadata, .. }) => metadata,
             Self::ArcFile(ArcFileNode { metadata, .. }) => metadata,
             Self::CustomFile(CustomFileNode { metadata, .. }) => metadata,
+            Self::Symlink(SymlinkNode { metadata, .. }) => metadata,
             Self::Directory(DirectoryNode { metadata, .. }) => metadata,
             Self::ArcDirectory(ArcDirectoryNode { metadata, .. }) => metadata,
         }
@@ -152,6 +165,7 @@ impl Node {
             Self::ReadOnlyFile(ReadOnlyFileNode { name, .. }) => *name = new_name,
             Self::ArcFile(ArcFileNode { name, .. }) => *name = new_name,
             Self::CustomFile(CustomFileNode { name, .. }) => *name = new_name,
+            Self::Symlink(SymlinkNode { name, .. }) => *name = new_name,
             Self::Directory(DirectoryNode { name, .. }) => *name = new_name,
             Self::ArcDirectory(ArcDirectoryNode { name, .. }) => *name = new_name,
         }

lib/virtual-fs/src/tmp_fs.rs

@@ -58,6 +58,10 @@ impl TmpFileSystem {
     pub fn canonicalize_unchecked(&self, path: &Path) -> Result<PathBuf> {
         self.fs.canonicalize_unchecked(path)
     }
+
+    pub fn create_symlink(&self, source: &Path, target: &Path) -> Result<()> {
+        self.fs.create_symlink(source, target)
+    }
 }
 
 impl FileSystem for TmpFileSystem {