Merge pull request #139 from SamTebbs33/feature/virtual-fs

Virtual filesystem

src/kernel/vfs.zig

@@ -0,0 +1,736 @@
+const std = @import("std");
+const testing = std.testing;
+const TailQueue = std.TailQueue;
+const ArrayList = std.ArrayList;
+const Allocator = std.mem.Allocator;
+
+/// Flags specifying what to do when opening a file or directory
+const OpenFlags = enum {
+    /// Create a directory if it doesn't exist
+    CREATE_DIR,
+    /// Create a file if it doesn't exist
+    CREATE_FILE,
+    /// Do not create a file or directory
+    NO_CREATION,
+};
+
+/// A filesystem node that could either be a directory or a file
+pub const Node = union(enum) {
+    /// The file node if this represents a file
+    File: FileNode,
+    /// The dir node if this represents a directory
+    Dir: DirNode,
+    const Self = @This();
+
+    ///
+    /// Check if this node is a directory
+    ///
+    /// Arguments:
+    ///     IN self: Self - The node being checked
+    ///
+    /// Return: bool
+    ///     True if this is a directory else false
+    ///
+    pub fn isDir(self: Self) bool {
+        return switch (self) {
+            .Dir => true,
+            .File => false,
+        };
+    }
+
+    ///
+    /// Check if this node is a file
+    ///
+    /// Arguments:
+    ///     IN self: Self - The node being checked
+    ///
+    /// Return: bool
+    ///     True if this is a file else false
+    ///
+    pub fn isFile(self: Self) bool {
+        return switch (self) {
+            .File => true,
+            .Dir => false,
+        };
+    }
+};
+
+/// The functions of a filesystem
+pub const FileSystem = struct {
+    const Self = @This();
+
+    ///
+    /// Close an open file, performing any last operations required to save data etc.
+    ///
+    /// Arguments:
+    ///     IN self: *const FileSystem - The filesystem in question being operated on.
+    ///     IN node: *const FileNode - The file being closed
+    ///
+    const Close = fn (self: *const Self, node: *const FileNode) void;
+
+    ///
+    /// Read from an open file
+    ///
+    /// Arguments:
+    ///     IN self: *const FileSystem - The filesystem in question being operated on
+    ///     IN node: *const FileNode - The file being read from
+    ///     IN len: usize - The number of bytes to read from the file
+    ///
+    /// Return: []u8
+    ///     The data read as a slice of bytes. The length will be <= len, including 0 if there was no data to read
+    ///
+    /// Error: Allocator.Error
+    ///     Allocator.Error.OutOfMemory - There wasn't enough memory to fulfill the request
+    ///
+    const Read = fn (self: *const Self, node: *const FileNode, len: usize) Allocator.Error![]u8;
+
+    ///
+    /// Write to an open file
+    ///
+    /// Arguments:
+    ///     IN self: *const FileSystem - The filesystem in question being operated on
+    ///     IN node: *const FileNode - The file being read from
+    ///     IN bytes: []u8 - The bytes to write to the file
+    ///
+    /// Error: Allocator.Error
+    ///     Allocator.Error.OutOfMemory - There wasn't enough memory to fulfill the request
+    ///
+    const Write = fn (self: *const Self, node: *const FileNode, bytes: []const u8) Allocator.Error!void;
+
+    ///
+    /// Open a file/dir within the filesystem. The result can then be used for write, read or close operations
+    ///
+    /// Arguments:
+    ///     IN self: *const FileSystem - The filesystem in question being operated on
+    ///     IN node: *const DirNode - The directory under which to open the file/dir from
+    ///     IN name: []const u8 - The name of the file to open
+    ///     IN flags: OpenFlags - The flags to consult when opening the file
+    ///
+    /// Return: *const Node
+    ///     The node representing the file/dir opened
+    ///
+    /// Error: Allocator.Error || Error
+    ///     Allocator.Error.OutOfMemory - There wasn't enough memory to fulfill the request
+    ///     Error.NoSuchFileOrDir - The file/dir by that name doesn't exist and the flags didn't specify to create it
+    ///
+    const Open = fn (self: *const Self, node: *const DirNode, name: []const u8, flags: OpenFlags) (Allocator.Error || Error)!*Node;
+
+    ///
+    /// Get the node representing the root of the filesystem. Used when mounting to bind the mount point to the root of the mounted fs
+    ///
+    /// Arguments:
+    ///     IN self: *const Self - The filesystem to get the root node for
+    ///
+    /// Return: *const DirNode
+    ///     The root directory node
+    ///
+    const GetRootNode = fn (self: *const Self) *const DirNode;
+
+    /// The close function
+    close: Close,
+
+    /// The read function
+    read: Read,
+
+    /// The write function
+    write: Write,
+
+    /// The open function
+    open: Open,
+
+    /// The function for retrieving the root node
+    getRootNode: GetRootNode,
+
+    /// Points to a usize field within the underlying filesystem so that the close, read, write and open functions can access its low-level implementation using @fieldParentPtr. For example, this could point to a usize field within a FAT32 filesystem data structure, which stores all the data and state that is needed in order to interact with a physical disk
+    /// The value of instance is reserved for future use and so should be left as 0
+    instance: *usize,
+};
+
+/// A node representing a file within a filesystem
+pub const FileNode = struct {
+    /// The filesystem that handles operations on this file
+    fs: *const FileSystem,
+
+    /// See the documentation for FileSystem.Read
+    pub fn read(self: *const FileNode, len: usize) Allocator.Error![]u8 {
+        return self.fs.read(self.fs, self, len);
+    }
+
+    /// See the documentation for FileSystem.Close
+    pub fn close(self: *const FileNode) void {
+        return self.fs.close(self.fs, self);
+    }
+
+    /// See the documentation for FileSystem.Write
+    pub fn write(self: *const FileNode, bytes: []const u8) Allocator.Error!void {
+        return self.fs.write(self.fs, self, bytes);
+    }
+};
+
+/// A node representing a directory within a filesystem
+pub const DirNode = struct {
+    /// The filesystem that handles operations on this directory
+    fs: *const FileSystem,
+
+    /// The directory that this directory is mounted to, else null
+    mount: ?*const DirNode,
+
+    /// See the documentation for FileSystem.Open
+    pub fn open(self: *const DirNode, name: []const u8, flags: OpenFlags) (Allocator.Error || Error)!*Node {
+        var fs = self.fs;
+        var node = self;
+        if (self.mount) |mnt| {
+            fs = mnt.fs;
+            node = mnt;
+        }
+        return fs.open(fs, node, name, flags);
+    }
+};
+
+/// Errors that can be thrown by filesystem functions
+pub const Error = error{
+    /// The file or directory requested doesn't exist in the filesystem
+    NoSuchFileOrDir,
+
+    /// The parent of a requested file or directory isn't a directory itself
+    NotADirectory,
+
+    /// The requested file is actually a directory
+    IsADirectory,
+
+    /// The path provided is not absolute
+    NotAbsolutePath,
+
+    /// The flags provided are invalid for the requested operation
+    InvalidFlags,
+};
+
+/// Errors that can be thrown when attempting to mount
+pub const MountError = error{
+    /// The directory being mounted to a filesystem is already mounted to something
+    DirAlreadyMounted,
+};
+
+/// The separator used between segments of a file path
+pub const SEPARATOR: u8 = '/';
+
+/// The root of the system's top-level filesystem
+var root: *Node = undefined;
+
+///
+/// Traverse the specified path from the root and open the file/dir corresponding to that path. If the file/dir doesn't exist it can be created by specifying the open flags
+///
+/// Arguments:
+///     IN path: []const u8 - The path to traverse. Must be absolute (see isAbsolute)
+///     IN flags: OpenFlags - The flags that specify if the file/dir should be created if it doesn't exist
+///
+/// Return: *const Node
+///     The node that exists at the path starting at the system root
+///
+/// Error: Allocator.Error || Error
+///     Allocator.Error.OutOfMemory - There wasn't enough memory to fulfill the request
+///     Error.NotADirectory - A segment within the path which is not at the end does not correspond to a directory
+///     Error.NoSuchFileOrDir - The file/dir at the end of the path doesn't exist and the flags didn't specify to create it
+///
+fn traversePath(path: []const u8, flags: OpenFlags) (Allocator.Error || Error)!*Node {
+    if (!isAbsolute(path)) {
+        return Error.NotAbsolutePath;
+    }
+
+    const TraversalParent = struct {
+        parent: *Node,
+        child: []const u8,
+
+        const Self = @This();
+        fn func(split: *std.mem.SplitIterator, node: *Node, rec_flags: OpenFlags) (Allocator.Error || Error)!Self {
+            // Get segment string. This will not be unreachable as we've made sure the spliterator has more segments left
+            const seg = split.next() orelse unreachable;
+            if (split.rest().len == 0) {
+                return Self{
+                    .parent = node,
+                    .child = seg,
+                };
+            }
+            return switch (node.*) {
+                .File => Error.NotADirectory,
+                .Dir => |*dir| try func(split, try dir.open(seg, rec_flags), rec_flags),
+            };
+        }
+    };
+
+    // Split path but skip the first separator character
+    var split = std.mem.split(path[1..], &[_]u8{SEPARATOR});
+    // Traverse directories while we're not at the last segment
+    const result = try TraversalParent.func(&split, root, .NO_CREATION);
+
+    // There won't always be a second segment in the path, e.g. in "/"
+    if (std.mem.eql(u8, result.child, "")) {
+        return result.parent;
+    }
+
+    // Open the final segment of the path from whatever the parent is
+    return switch (result.parent.*) {
+        .File => Error.NotADirectory,
+        .Dir => |*dir| try dir.open(result.child, flags),
+    };
+}
+
+///
+/// Mount the root of a filesystem to a directory. Opening files within that directory will then redirect to the target filesystem
+///
+/// Arguments:
+///     IN dir: *DirNode - The directory to mount to. dir.mount is modified.
+///     IN fs: *const FileSystem - The filesystem to mount
+///
+/// Error: MountError
+///     MountError.DirAlreadyMounted - The directory is already mounted to a filesystem
+///
+pub fn mount(dir: *DirNode, fs: *const FileSystem) MountError!void {
+    if (dir.mount) |_| {
+        return MountError.DirAlreadyMounted;
+    }
+    dir.mount = fs.getRootNode(fs);
+}
+
+///
+/// Open a node at a path.
+///
+/// Arguments:
+///     IN path: []const u8 - The path to open. Must be absolute (see isAbsolute)
+///     IN flags: OpenFlags - The flags specifying if this node should be created if it doesn't exist
+///
+/// Return: *const Node
+///     The node that exists at the path starting at the system root
+///
+/// Error: Allocator.Error || Error
+///     Allocator.Error.OutOfMemory - There wasn't enough memory to fulfill the request
+///     Error.NotADirectory - A segment within the path which is not at the end does not correspond to a directory
+///     Error.NoSuchFileOrDir - The file/dir at the end of the path doesn't exist and the flags didn't specify to create it
+///
+pub fn open(path: []const u8, flags: OpenFlags) (Allocator.Error || Error)!*Node {
+    return try traversePath(path, flags);
+}
+
+///
+/// Open a file at a path.
+///
+/// Arguments:
+///     IN path: []const u8 - The path to open. Must be absolute (see isAbsolute)
+///     IN flags: OpenFlags - The flags specifying if this node should be created if it doesn't exist. Cannot be CREATE_DIR
+///
+/// Return: *const FileNode
+///     The node that exists at the path starting at the system root
+///
+/// Error: Allocator.Error || Error
+///     Allocator.Error.OutOfMemory - There wasn't enough memory to fulfill the request
+///     Error.InvalidFlags - The flags were a value invalid when opening files
+///     Error.NotADirectory - A segment within the path which is not at the end does not correspond to a directory
+///     Error.NoSuchFileOrDir - The file/dir at the end of the path doesn't exist and the flags didn't specify to create it
+///     Error.IsADirectory - The path corresponds to a directory rather than a file
+///
+pub fn openFile(path: []const u8, flags: OpenFlags) (Allocator.Error || Error)!*const FileNode {
+    switch (flags) {
+        .CREATE_DIR => return Error.InvalidFlags,
+        .NO_CREATION, .CREATE_FILE => {},
+    }
+    var node = try open(path, flags);
+    return switch (node.*) {
+        .File => &node.File,
+        .Dir => Error.IsADirectory,
+    };
+}
+
+///
+/// Open a directory at a path.
+///
+/// Arguments:
+///     IN path: []const u8 - The path to open. Must be absolute (see isAbsolute)
+///     IN flags: OpenFlags - The flags specifying if this node should be created if it doesn't exist. Cannot be CREATE_FILE
+///
+/// Return: *const DirNode
+///     The node that exists at the path starting at the system root
+///
+/// Error: Allocator.Error || Error
+///     Allocator.Error.OutOfMemory - There wasn't enough memory to fulfill the request
+///     Error.InvalidFlags - The flags were a value invalid when opening files
+///     Error.NotADirectory - A segment within the path which is not at the end does not correspond to a directory
+///     Error.NoSuchFileOrDir - The file/dir at the end of the path doesn't exist and the flags didn't specify to create it
+///     Error.NotADirectory - The path corresponds to a file rather than a directory
+///
+pub fn openDir(path: []const u8, flags: OpenFlags) (Allocator.Error || Error)!*DirNode {
+    switch (flags) {
+        .CREATE_FILE => return Error.InvalidFlags,
+        .NO_CREATION, .CREATE_DIR => {},
+    }
+    var node = try open(path, flags);
+    return switch (node.*) {
+        .File => Error.NotADirectory,
+        .Dir => &node.Dir,
+    };
+}
+
+// TODO: Replace this with the std lib implementation once the OS abstraction layer is up and running
+///
+/// Check if a path is absolute, i.e. its length is greater than 0 and starts with the path separator character
+///
+/// Arguments:
+///     IN path: []const u8 - The path to check
+///
+/// Return: bool
+///     True if the path is absolute else false
+///
+pub fn isAbsolute(path: []const u8) bool {
+    return path.len > 0 and path[0] == SEPARATOR;
+}
+
+const TestFS = struct {
+    const TreeNode = struct {
+        val: *Node,
+        name: []u8,
+        data: ?[]u8,
+        children: *ArrayList(*@This()),
+
+        fn deinit(self: *@This(), allocator: *Allocator) void {
+            allocator.destroy(self.val);
+            allocator.free(self.name);
+            if (self.data) |d| {
+                allocator.free(d);
+            }
+            for (self.children.items) |child| {
+                child.deinit(allocator);
+                allocator.destroy(child);
+            }
+            self.children.deinit();
+            allocator.destroy(self.children);
+        }
+    };
+
+    tree: TreeNode,
+    fs: *FileSystem,
+    allocator: *Allocator,
+    instance: usize,
+
+    const Self = @This();
+
+    fn deinit(self: *@This()) void {
+        self.tree.deinit(self.allocator);
+        self.allocator.destroy(self.fs);
+    }
+
+    fn getTreeNode(test_fs: *Self, node: var) Allocator.Error!?*TreeNode {
+        switch (@TypeOf(node)) {
+            *const Node, *const FileNode, *const DirNode => {},
+            else => @compileError("Node is of type " ++ @typeName(@TypeOf(node)) ++ ". Only *const Node, *const FileNode and *const DirNode are supported"),
+        }
+        // Form a list containing all directory nodes to check via a breadth-first search
+        // This is inefficient but good for testing as it's clear and easy to modify
+        var to_check = TailQueue(*TreeNode).init();
+        var root_node = try to_check.createNode(&test_fs.tree, test_fs.allocator);
+        to_check.append(root_node);
+
+        while (to_check.popFirst()) |queue_node| {
+            var tree_node = queue_node.data;
+            to_check.destroyNode(queue_node, test_fs.allocator);
+            if ((@TypeOf(node) == *const FileNode and tree_node.val.isFile() and &tree_node.val.File == node) or (@TypeOf(node) == *const DirNode and tree_node.val.isDir() and &tree_node.val.Dir == node) or (@TypeOf(node) == *const Node and &tree_node.val == node)) {
+                // Clean up any unused queue nodes
+                while (to_check.popFirst()) |t_node| {
+                    to_check.destroyNode(t_node, test_fs.allocator);
+                }
+                return tree_node;
+            }
+            for (tree_node.children.items) |child| {
+                // It's not the parent so add its children to the list for checking
+                to_check.append(try to_check.createNode(child, test_fs.allocator));
+            }
+        }
+        return null;
+    }
+
+    fn getRootNode(fs: *const FileSystem) *const DirNode {
+        var test_fs = @fieldParentPtr(TestFS, "instance", fs.instance);
+        return &test_fs.tree.val.Dir;
+    }
+
+    fn close(fs: *const FileSystem, node: *const FileNode) void {}
+
+    fn read(fs: *const FileSystem, node: *const FileNode, len: usize) Allocator.Error![]u8 {
+        var test_fs = @fieldParentPtr(TestFS, "instance", fs.instance);
+        // Get the tree that corresponds to the node. Cannot error as the file is already open so it does exist
+        var tree = (getTreeNode(test_fs, node) catch unreachable) orelse unreachable;
+        const count = if (tree.data) |d| std.math.min(len, d.len) else 0;
+        const data = if (tree.data) |d| d[0..count] else "";
+        var bytes = try test_fs.allocator.alloc(u8, count);
+        std.mem.copy(u8, bytes, data);
+        return bytes;
+    }
+
+    fn write(fs: *const FileSystem, node: *const FileNode, bytes: []const u8) Allocator.Error!void {
+        var test_fs = @fieldParentPtr(TestFS, "instance", fs.instance);
+        var tree = (try getTreeNode(test_fs, node)) orelse unreachable;
+        if (tree.data) |_| {
+            test_fs.allocator.free(tree.data.?);
+        }
+        tree.data = try test_fs.allocator.alloc(u8, bytes.len);
+        std.mem.copy(u8, tree.data.?, bytes);
+    }
+
+    fn open(fs: *const FileSystem, dir: *const DirNode, name: []const u8, flags: OpenFlags) (Allocator.Error || Error)!*Node {
+        var test_fs = @fieldParentPtr(TestFS, "instance", fs.instance);
+        const parent = (try getTreeNode(test_fs, dir)) orelse unreachable;
+        // Check if the children match the file wanted
+        for (parent.children.items) |child| {
+            if (std.mem.eql(u8, child.name, name)) {
+                return child.val;
+            }
+        }
+        // The file/dir doesn't exist so create it if necessary
+        if (flags != .NO_CREATION) {
+            var child: *Node = undefined;
+            switch (flags) {
+                .CREATE_DIR => {
+                    // Create the fs node
+                    child = try test_fs.allocator.create(Node);
+                    child.* = .{ .Dir = .{ .fs = test_fs.fs, .mount = null } };
+                },
+                .CREATE_FILE => {
+                    // Create the fs node
+                    child = try test_fs.allocator.create(Node);
+                    child.* = .{ .File = .{ .fs = test_fs.fs } };
+                },
+                .NO_CREATION => unreachable,
+            }
+            // Create the test fs tree node
+            var child_tree = try test_fs.allocator.create(TreeNode);
+            var child_name = try test_fs.allocator.alloc(u8, name.len);
+            std.mem.copy(u8, child_name, name);
+            child_tree.* = .{
+                .val = child,
+                .name = child_name,
+                .children = try test_fs.allocator.create(ArrayList(*TreeNode)),
+                .data = null,
+            };
+            child_tree.children.* = ArrayList(*TreeNode).init(test_fs.allocator);
+            // Add it to the tree
+            try parent.children.append(child_tree);
+            return child;
+        }
+        return Error.NoSuchFileOrDir;
+    }
+};
+
+fn testInitFs(allocator: *Allocator) !*TestFS {
+    const fs = try allocator.create(FileSystem);
+    var testfs = try allocator.create(TestFS);
+    var root_node = try allocator.create(Node);
+    root_node.* = .{ .Dir = .{ .fs = fs, .mount = null } };
+    var name = try allocator.alloc(u8, 4);
+    std.mem.copy(u8, name, "root");
+    testfs.* = TestFS{
+        .tree = .{
+            .val = root_node,
+            .name = name,
+            .children = try allocator.create(ArrayList(*TestFS.TreeNode)),
+            .data = null,
+        },
+        .fs = fs,
+        .instance = 123,
+        .allocator = allocator,
+    };
+    testfs.tree.children.* = ArrayList(*TestFS.TreeNode).init(allocator);
+    fs.* = .{ .open = TestFS.open, .close = TestFS.close, .read = TestFS.read, .write = TestFS.write, .instance = &testfs.instance, .getRootNode = TestFS.getRootNode };
+    return testfs;
+}
+
+test "mount" {
+    var allocator = testing.allocator;
+
+    // The root fs
+    var testfs = try testInitFs(allocator);
+    defer testfs.deinit();
+    defer allocator.destroy(testfs);
+
+    testfs.instance = 1;
+    root = testfs.tree.val;
+
+    // The fs that is to be mounted
+    var testfs2 = try testInitFs(allocator);
+    defer testfs2.deinit();
+    defer allocator.destroy(testfs2);
+
+    testfs2.instance = 2;
+    // Create the dir to mount to
+    var dir = try openDir("/mnt", .CREATE_DIR);
+    try mount(dir, testfs2.fs);
+    testing.expectError(MountError.DirAlreadyMounted, mount(dir, testfs2.fs));
+
+    // Ensure the mount worked
+    testing.expectEqual((dir.mount orelse unreachable), testfs2.fs.getRootNode(testfs2.fs));
+    testing.expectEqual((dir.mount orelse unreachable).fs, testfs2.fs);
+    // Create a file within the mounted directory
+    var test_file = try openFile("/mnt/123.txt", .CREATE_FILE);
+    testing.expectEqual(@ptrCast(*const FileSystem, testfs2.fs), test_file.fs);
+    // This shouldn't be in the root fs
+    testing.expectEqual(@as(usize, 1), testfs.tree.children.items.len);
+    testing.expectEqual(@as(usize, 0), testfs.tree.children.items[0].children.items.len);
+    // It should be in the mounted fs
+    testing.expectEqual(@as(usize, 1), testfs2.tree.children.items.len);
+    testing.expectEqual(test_file, &testfs2.tree.children.items[0].val.File);
+}
+
+test "traversePath" {
+    var allocator = testing.allocator;
+    var testfs = try testInitFs(allocator);
+    defer testfs.deinit();
+    defer allocator.destroy(testfs);
+    root = testfs.tree.val;
+
+    // Get the root
+    var test_root = try traversePath("/", .NO_CREATION);
+    testing.expectEqual(test_root, root);
+    // Create a file in the root and try to traverse to it
+    var child1 = try test_root.Dir.open("child1.txt", .CREATE_FILE);
+    testing.expectEqual(child1, try traversePath("/child1.txt", .NO_CREATION));
+    // Same but with a directory
+    var child2 = try test_root.Dir.open("child2", .CREATE_DIR);
+    testing.expectEqual(child2, try traversePath("/child2", .NO_CREATION));
+    // Again but with a file within that directory
+    var child3 = try child2.Dir.open("child3.txt", .CREATE_FILE);
+    testing.expectEqual(child3, try traversePath("/child2/child3.txt", .NO_CREATION));
+
+    testing.expectError(Error.NotAbsolutePath, traversePath("abc", .NO_CREATION));
+    testing.expectError(Error.NotAbsolutePath, traversePath("", .NO_CREATION));
+    testing.expectError(Error.NotAbsolutePath, traversePath("a/", .NO_CREATION));
+    testing.expectError(Error.NoSuchFileOrDir, traversePath("/notadir/abc.txt", .NO_CREATION));
+    testing.expectError(Error.NoSuchFileOrDir, traversePath("/ ", .NO_CREATION));
+    testing.expectError(Error.NotADirectory, traversePath("/child1.txt/abc.txt", .NO_CREATION));
+}
+
+test "isAbsolute" {
+    testing.expect(isAbsolute("/"));
+    testing.expect(isAbsolute("/abc"));
+    testing.expect(isAbsolute("/abc/def"));
+    testing.expect(isAbsolute("/ a bc/de f"));
+    testing.expect(isAbsolute("//"));
+    testing.expect(!isAbsolute(" /"));
+    testing.expect(!isAbsolute(""));
+    testing.expect(!isAbsolute("abc"));
+    testing.expect(!isAbsolute("abc/def"));
+}
+
+test "isDir" {
+    const fs: FileSystem = undefined;
+    const dir = Node{ .Dir = .{ .fs = &fs, .mount = null } };
+    const file = Node{ .File = .{ .fs = &fs } };
+    testing.expect(dir.isDir());
+    testing.expect(!file.isDir());
+}
+
+test "isFile" {
+    const fs: FileSystem = undefined;
+    const dir = Node{ .Dir = .{ .fs = &fs, .mount = null } };
+    const file = Node{ .File = .{ .fs = &fs } };
+    testing.expect(!dir.isFile());
+    testing.expect(file.isFile());
+}
+
+test "open" {
+    var testfs = try testInitFs(testing.allocator);
+    defer testfs.deinit();
+    defer testing.allocator.destroy(testfs);
+    root = testfs.tree.val;
+
+    // Creating a file
+    var test_node = try openFile("/abc.txt", .CREATE_FILE);
+    testing.expectEqual(testfs.tree.children.items.len, 1);
+    var tree = testfs.tree.children.items[0];
+    testing.expect(tree.val.isFile());
+    testing.expectEqual(test_node, &tree.val.File);
+    testing.expect(std.mem.eql(u8, tree.name, "abc.txt"));
+    testing.expectEqual(tree.data, null);
+    testing.expectEqual(tree.children.items.len, 0);
+
+    // Creating a dir
+    var test_dir = try openDir("/def", .CREATE_DIR);
+    testing.expectEqual(testfs.tree.children.items.len, 2);
+    tree = testfs.tree.children.items[1];
+    testing.expect(tree.val.isDir());
+    testing.expectEqual(test_dir, &tree.val.Dir);
+    testing.expect(std.mem.eql(u8, tree.name, "def"));
+    testing.expectEqual(tree.data, null);
+    testing.expectEqual(tree.children.items.len, 0);
+
+    // Creating a file under a new dir
+    test_node = try openFile("/def/ghi.zig", .CREATE_FILE);
+    testing.expectEqual(testfs.tree.children.items[1].children.items.len, 1);
+    tree = testfs.tree.children.items[1].children.items[0];
+    testing.expect(tree.val.isFile());
+    testing.expectEqual(test_node, &tree.val.File);
+    testing.expect(std.mem.eql(u8, tree.name, "ghi.zig"));
+    testing.expectEqual(tree.data, null);
+    testing.expectEqual(tree.children.items.len, 0);
+
+    testing.expectError(Error.NoSuchFileOrDir, openDir("/jkl", .NO_CREATION));
+    testing.expectError(Error.NoSuchFileOrDir, openFile("/mno.txt", .NO_CREATION));
+    testing.expectError(Error.NoSuchFileOrDir, openFile("/def/pqr.txt", .NO_CREATION));
+    testing.expectError(Error.NoSuchFileOrDir, openDir("/mno/stu", .NO_CREATION));
+    testing.expectError(Error.NoSuchFileOrDir, openFile("/mno/stu.txt", .NO_CREATION));
+    testing.expectError(Error.NotADirectory, openFile("/abc.txt/vxy.md", .NO_CREATION));
+    testing.expectError(Error.IsADirectory, openFile("/def", .NO_CREATION));
+    testing.expectError(Error.InvalidFlags, openFile("/abc.txt", .CREATE_DIR));
+    testing.expectError(Error.InvalidFlags, openDir("/abc.txt", .CREATE_FILE));
+    testing.expectError(Error.NotAbsolutePath, open("", .NO_CREATION));
+    testing.expectError(Error.NotAbsolutePath, open("abc", .NO_CREATION));
+}
+
+test "read" {
+    var testfs = try testInitFs(testing.allocator);
+    defer testfs.deinit();
+    defer testing.allocator.destroy(testfs);
+    root = testfs.tree.val;
+
+    var test_file = try openFile("/foo.txt", .CREATE_FILE);
+    var f_data = &testfs.tree.children.items[0].data;
+    var str = "test123";
+    f_data.* = try std.mem.dupe(testing.allocator, u8, str);
+
+    {
+        var data = try test_file.read(str.len);
+        defer testing.allocator.free(data);
+        testing.expect(std.mem.eql(u8, str, data));
+    }
+
+    {
+        var data = try test_file.read(str.len + 1);
+        defer testing.allocator.free(data);
+        testing.expect(std.mem.eql(u8, str, data));
+    }
+
+    {
+        var data = try test_file.read(str.len + 3);
+        defer testing.allocator.free(data);
+        testing.expect(std.mem.eql(u8, str, data));
+    }
+
+    {
+        var data = try test_file.read(str.len - 1);
+        defer testing.allocator.free(data);
+        testing.expect(std.mem.eql(u8, str[0 .. str.len - 1], data));
+    }
+
+    testing.expect(std.mem.eql(u8, str[0..0], try test_file.read(0)));
+}
+
+test "write" {
+    var testfs = try testInitFs(testing.allocator);
+    defer testfs.deinit();
+    defer testing.allocator.destroy(testfs);
+    root = testfs.tree.val;
+
+    var test_file = try openFile("/foo.txt", .CREATE_FILE);
+    var f_data = &testfs.tree.children.items[0].data;
+    testing.expectEqual(f_data.*, null);
+
+    var str = "test123";
+    try test_file.write(str);
+    testing.expect(std.mem.eql(u8, str, f_data.* orelse unreachable));
+}