in-memory file system for WASI with support for directories, files, and character devices

Author: andrewmd5

Sources/WASI/CMakeLists.txt

@@ -6,12 +6,19 @@ add_wasmkit_library(WASI
   Platform/File.swift
   Platform/PlatformTypes.swift
   Platform/SandboxPrimitives.swift
+  Platform/HostFileSystem.swift
+  MemoryFileSystem/MemoryFileSystem.swift
+  MemoryFileSystem/MemoryFSNodes.swift
+  MemoryFileSystem/MemoryDirEntry.swift
+  MemoryFileSystem/MemoryFileEntry.swift
+  MemoryFileSystem/MemoryStdioFile.swift
   FileSystem.swift
   GuestMemorySupport.swift
   Clock.swift
   RandomBufferGenerator.swift
   WASI.swift
+  WASIBridgeToMemory.swift
 )
 
 target_link_wasmkit_libraries(WASI PUBLIC
-  WasmTypes SystemExtras)
+  WasmTypes SystemExtras)

Sources/WASI/FileSystem.swift

@@ -83,6 +83,13 @@ enum FdEntry {
             return directory
         }
     }
+    
+    func asFile() -> (any WASIFile)? {
+        if case .file(let entry) = self {
+            return entry
+        }
+        return nil
+    }
 }
 
 /// A table that maps file descriptor to actual resource in host environment
@@ -120,3 +127,55 @@ struct FdTable {
         }
     }
 }
+
+/// Content of a file that can be retrieved from the file system.
+public enum FileContent {
+    case bytes([UInt8])
+    case handle(FileDescriptor)
+}
+
+/// Public protocol for file system providers that users interact with.
+///
+/// This protocol exposes only user-facing methods for managing files and directories.
+public protocol FileSystemProvider {
+    /// Adds a file to the file system with the given byte content.
+    func addFile(at path: String, content: [UInt8]) throws
+    
+    /// Adds a file to the file system with the given string content.
+    func addFile(at path: String, content: String) throws
+    
+    /// Adds a file to the file system backed by a file descriptor handle.
+    func addFile(at path: String, handle: FileDescriptor) throws
+    
+    /// Gets the content of a file at the specified path.
+    func getFile(at path: String) throws -> FileContent
+    
+    /// Removes a file from the file system.
+    func removeFile(at path: String) throws
+}
+
+/// Internal protocol for file system implementations used by WASI.
+///
+/// This protocol contains WASI-specific implementation details that should not
+/// be exposed to library users.
+internal protocol FileSystem {
+    /// Returns the list of pre-opened directory paths.
+    func getPreopenPaths() -> [String]
+    
+    /// Opens a directory and returns a WASIDir implementation.
+    func openDirectory(at path: String) throws -> any WASIDir
+    
+    /// Opens a file or directory from a directory file descriptor.
+    func openAt(
+        dirFd: any WASIDir,
+        path: String,
+        oflags: WASIAbi.Oflags,
+        fsRightsBase: WASIAbi.Rights,
+        fsRightsInheriting: WASIAbi.Rights,
+        fdflags: WASIAbi.Fdflags,
+        symlinkFollow: Bool
+    ) throws -> FdEntry
+    
+    /// Creates a standard I/O file entry for stdin/stdout/stderr.
+    func createStdioFile(fd: FileDescriptor, accessMode: FileAccessMode) -> any WASIFile
+}

Sources/WASI/MemoryFileSystem/MemoryDirEntry.swift

@@ -0,0 +1,153 @@
+import SystemPackage
+
+/// A WASIDir implementation backed by an in-memory directory node.
+internal struct MemoryDirEntry: WASIDir {
+    let preopenPath: String?
+    let dirNode: MemoryDirectoryNode
+    let path: String
+    let fileSystem: MemoryFileSystem
+    
+    func attributes() throws -> WASIAbi.Filestat {
+        return WASIAbi.Filestat(
+            dev: 0, ino: 0, filetype: .DIRECTORY,
+            nlink: 1, size: 0,
+            atim: 0, mtim: 0, ctim: 0
+        )
+    }
+    
+    func fileType() throws -> WASIAbi.FileType {
+        return .DIRECTORY
+    }
+    
+    func status() throws -> WASIAbi.Fdflags {
+        return []
+    }
+    
+    func setTimes(
+        atim: WASIAbi.Timestamp, mtim: WASIAbi.Timestamp,
+        fstFlags: WASIAbi.FstFlags
+    ) throws {
+        // No-op for memory filesystem - timestamps not tracked
+    }
+    
+    func advise(
+        offset: WASIAbi.FileSize, length: WASIAbi.FileSize, advice: WASIAbi.Advice
+    ) throws {
+        // No-op for memory filesystem
+    }
+    
+    func close() throws {
+        // No-op for memory filesystem - no resources to release
+    }
+    
+    func openFile(
+        symlinkFollow: Bool,
+        path: String,
+        oflags: WASIAbi.Oflags,
+        accessMode: FileAccessMode,
+        fdflags: WASIAbi.Fdflags
+    ) throws -> FileDescriptor {
+        // Memory filesystem doesn't return real file descriptors for this method
+        // File opening is handled through the WASI bridge's path_open implementation
+        throw WASIAbi.Errno.ENOTSUP
+    }
+    
+    func createDirectory(atPath path: String) throws {
+        let fullPath = self.path.hasSuffix("/") ? self.path + path : self.path + "/" + path
+        try fileSystem.ensureDirectory(at: fullPath)
+    }
+    
+    func removeDirectory(atPath path: String) throws {
+        try fileSystem.removeNode(in: dirNode, at: path, mustBeDirectory: true)
+    }
+    
+    func removeFile(atPath path: String) throws {
+        try fileSystem.removeNode(in: dirNode, at: path, mustBeDirectory: false)
+    }
+    
+    func symlink(from sourcePath: String, to destPath: String) throws {
+        // Symlinks not supported in memory filesystem
+        throw WASIAbi.Errno.ENOTSUP
+    }
+    
+    func rename(from sourcePath: String, toDir newDir: any WASIDir, to destPath: String) throws {
+        guard let newMemoryDir = newDir as? MemoryDirEntry else {
+            throw WASIAbi.Errno.EXDEV
+        }
+        
+        try fileSystem.rename(
+            from: sourcePath, in: dirNode,
+            to: destPath, in: newMemoryDir.dirNode
+        )
+    }
+    
+    func readEntries(cookie: WASIAbi.DirCookie) throws -> AnyIterator<Result<ReaddirElement, any Error>> {
+        let children = dirNode.listChildren()
+        
+        let iterator = children.enumerated()
+            .dropFirst(Int(cookie))
+            .map { (index, name) -> Result<ReaddirElement, any Error> in
+                return Result(catching: {
+                    let childPath = self.path.hasSuffix("/") ? self.path + name : self.path + "/" + name
+                    guard let childNode = fileSystem.lookup(at: childPath) else {
+                        throw WASIAbi.Errno.ENOENT
+                    }
+                    
+                    let fileType: WASIAbi.FileType
+                    switch childNode.type {
+                    case .directory: fileType = .DIRECTORY
+                    case .file: fileType = .REGULAR_FILE
+                    case .characterDevice: fileType = .CHARACTER_DEVICE
+                    }
+                    
+                    let dirent = WASIAbi.Dirent(
+                        dNext: WASIAbi.DirCookie(index + 1),
+                        dIno: 0,
+                        dirNameLen: WASIAbi.DirNameLen(name.utf8.count),
+                        dType: fileType
+                    )
+                    
+                    return (dirent, name)
+                })
+            }
+            .makeIterator()
+        
+        return AnyIterator(iterator)
+    }
+    
+    func attributes(path: String, symlinkFollow: Bool) throws -> WASIAbi.Filestat {
+        let fullPath = self.path.hasSuffix("/") ? self.path + path : self.path + "/" + path
+        guard let node = fileSystem.lookup(at: fullPath) else {
+            throw WASIAbi.Errno.ENOENT
+        }
+        
+        let fileType: WASIAbi.FileType
+        var size: WASIAbi.FileSize = 0
+        
+        switch node.type {
+        case .directory:
+            fileType = .DIRECTORY
+        case .file:
+            fileType = .REGULAR_FILE
+            if let fileNode = node as? MemoryFileNode {
+                size = WASIAbi.FileSize(fileNode.size)
+            }
+        case .characterDevice:
+            fileType = .CHARACTER_DEVICE
+        }
+        
+        return WASIAbi.Filestat(
+            dev: 0, ino: 0, filetype: fileType,
+            nlink: 1, size: size,
+            atim: 0, mtim: 0, ctim: 0
+        )
+    }
+    
+    func setFilestatTimes(
+        path: String,
+        atim: WASIAbi.Timestamp, mtim: WASIAbi.Timestamp,
+        fstFlags: WASIAbi.FstFlags, symlinkFollow: Bool
+    ) throws {
+        // No-op for memory filesystem - timestamps not tracked
+    }
+}

Sources/WASI/MemoryFileSystem/MemoryFSNodes.swift

@@ -0,0 +1,89 @@
+import SystemPackage
+
+/// Base protocol for all file system nodes in memory.
+internal protocol MemFSNode: AnyObject {
+    var type: MemFSNodeType { get }
+}
+
+/// Types of file system nodes.
+internal enum MemFSNodeType {
+    case directory
+    case file
+    case characterDevice
+}
+
+/// A directory node in the memory file system.
+internal final class MemoryDirectoryNode: MemFSNode {
+    let type: MemFSNodeType = .directory
+    private var children: [String: MemFSNode] = [:]
+    
+    init() {}
+    
+    func getChild(name: String) -> MemFSNode? {
+        return children[name]
+    }
+    
+    func setChild(name: String, node: MemFSNode) {
+        children[name] = node
+    }
+    
+    @discardableResult
+    func removeChild(name: String) -> Bool {
+        return children.removeValue(forKey: name) != nil
+    }
+    
+    func listChildren() -> [String] {
+        return Array(children.keys).sorted()
+    }
+    
+    func childCount() -> Int {
+        return children.count
+    }
+}
+
+/// A regular file node in the memory file system.
+internal final class MemoryFileNode: MemFSNode {
+    let type: MemFSNodeType = .file
+    var content: FileContent
+    
+    init(content: FileContent) {
+        self.content = content
+    }
+    
+    convenience init(bytes: [UInt8]) {
+        self.init(content: .bytes(bytes))
+    }
+    
+    convenience init(handle: FileDescriptor) {
+        self.init(content: .handle(handle))
+    }
+    
+    var size: Int {
+        switch content {
+        case .bytes(let bytes):
+            return bytes.count
+        case .handle(let fd):
+            do {
+                let attrs = try fd.attributes()
+                return Int(attrs.size)
+            } catch {
+                return 0
+            }
+        }
+    }
+}
+
+/// A character device node in the memory file system.
+internal final class MemoryCharacterDeviceNode: MemFSNode {
+    let type: MemFSNodeType = .characterDevice
+    
+    enum Kind {
+        case null
+    }
+    
+    let kind: Kind
+    
+    init(kind: Kind) {
+        self.kind = kind
+    }
+}