sylveos

fs.zig (8759B)

---

 const std = @import("std");
 const pi = @import("pi");
 
 const vfs = pi.fs.vfs;
 const sd = pi.devices.sd;
 const uart = pi.devices.mini_uart;
 
 const Explorer = struct {
     alloc: std.mem.Allocator,
     io_w: *std.Io.Writer,
 
     fs: vfs.FileSystem,
     dir: vfs.Directory,
     path: std.ArrayList([]const u8),
 
     const Self = @This();
 
     pub fn init(alloc: std.mem.Allocator, fs: vfs.FileSystem, io_w: *std.Io.Writer) !Self {
         var path: std.ArrayList([]const u8) = try .initCapacity(alloc, 1);
         try path.append(alloc, "/");
 
         return .{
             .alloc = alloc,
             .fs = fs,
             .dir = try fs.open_root(),
             .path = path,
             .io_w = io_w,
         };
     }
 
     pub fn read_line(self: *Self) !void {
         const path = try std.mem.concat(self.alloc, u8, self.path.items);
         defer self.alloc.free(path);
         try self.io_w.print("[{s}] $ ", .{path});
 
         var line: std.ArrayList(u8) = try .initCapacity(self.alloc, 16);
         defer line.deinit(self.alloc);
 
         // Wait until \n
         while (true) {
             const byte = uart.read_byte_sync();
             if (byte == '\n') break;
 
             try line.append(self.alloc, byte);
         }
 
         try self.parse_line(line.items);
     }
 
     // I would like to apologize for this truly bad parser
     fn parse_line(self: *Self, line: []const u8) !void {
         var it = std.mem.splitAny(u8, line, " ");
 
         const cmd = it.next() orelse return;
         const entry = it.next() orelse ".";
 
         if (std.mem.eql(u8, cmd, "ls")) {
             try self.ls(entry);
         } else if (std.mem.eql(u8, cmd, "tree")) {
             try self.tree(entry);
         } else if (std.mem.eql(u8, cmd, "cd")) {
             try self.cd(entry);
         } else if (std.mem.eql(u8, cmd, "stat")) {
             try self.stat(entry);
         } else if (std.mem.eql(u8, cmd, "cat")) {
             try self.cat(entry);
         } else if (std.mem.eql(u8, cmd, "help")) {
             try self.io_w.print("Commands: ls, tree, cd, stat, cat, help, exit\n", .{});
         } else if (std.mem.eql(u8, cmd, "exit")) {
             pi.reboot();
         } else {
             try self.io_w.print("\"{s}\": Command not found\n", .{cmd});
         }
     }
 
     fn open_directory(self: *Self, directory: []const u8) !?vfs.Directory {
         var entry = try self.dir.open_entry(directory) orelse {
             try self.io_w.print("\"{s}\": No such file or directory\n", .{directory});
             return null;
         };
         defer entry.close();
 
         if (!entry.stat().directory) {
             try self.io_w.print("\"{s}\": Not a directory\n", .{directory});
             return null;
         }
 
         return try self.fs.open_directory(&entry);
     }
 
     fn ls(self: *Self, directory: []const u8) !void {
         const dir = if (std.mem.eql(u8, directory, ".")) self.dir else try self.open_directory(directory) orelse return;
 
         try self.io_w.print("Name:\n", .{});
 
         var it = try dir.iterate();
         while (try it.next()) |entry| {
             defer entry.close();
 
             try self.io_w.print("- {s}\n", .{entry.stat().name});
         }
 
         if (!std.mem.eql(u8, directory, ".")) {
             dir.close();
         }
     }
     fn tree(self: *Self, directory: []const u8) !void {
         const dir = if (std.mem.eql(u8, directory, ".")) self.dir else try self.open_directory(directory) orelse return;
 
         try self.io_w.print("{s}\n", .{directory});
 
         var visited: std.ArrayList(Visited) = try .initCapacity(self.alloc, 0);
         defer visited.deinit(self.alloc);
 
         try walk(
             self.alloc,
             &self.fs,
             dir,
             &visited,
             1,
         );
 
         for (visited.items) |entry| {
             const prefix = try make_prefix(self.alloc, entry.level);
             defer self.alloc.free(prefix);
             defer self.alloc.free(entry.name);
 
             try self.io_w.print("{s}{s}\n", .{ prefix, entry.name });
         }
 
         if (!std.mem.eql(u8, directory, ".")) {
             dir.close();
         }
     }
     fn cd(self: *Self, directory: []const u8) !void {
         if (std.mem.eql(u8, directory, ".")) return;
 
         const dir = try self.open_directory(directory) orelse return;
 
         self.dir.close();
         self.dir = dir;
 
         if (std.mem.eql(u8, directory, "..")) {
             self.alloc.free(self.path.pop() orelse unreachable);
             self.alloc.free(self.path.pop() orelse unreachable);
 
             if (self.path.items.len == 1) {
                 self.dir.close();
                 self.dir = try self.fs.open_root();
             }
 
             return;
         }
 
         try self.path.append(self.alloc, try self.alloc.dupe(u8, directory));
         try self.path.append(self.alloc, try self.alloc.dupe(u8, "/"));
     }
     fn stat(self: *Self, file: []const u8) !void {
         const entry = (try self.dir.open_entry(file)) orelse {
             try self.io_w.print("\"{s}\": No such file or directory\n", .{file});
             return;
         };
         defer entry.close();
 
         const info = entry.stat();
 
         try self.io_w.print(
             \\     File: {s}
             \\     Size: {b}
             \\     Kind: {s}
             \\   Hidden: {any}
             \\Read Only: {any}
             \\ Creation: {d}
             \\   Access: {d}
             \\   Modify: {d}
             \\
         , .{
             info.name,
             info.size,
             if (info.directory) "directory" else "file",
             info.read_only,
             info.hidden,
             info.creation_time,
             info.access_time,
             info.modify_time,
         });
     }
     fn cat(self: *Self, file: []const u8) !void {
         var file_entry = (try self.dir.open_entry(file)) orelse {
             try self.io_w.print("\"{s}\": No such file or directory\n", .{file});
             return;
         };
         defer file_entry.close();
 
         const file_handle = try self.fs.open_file(&file_entry);
         defer file_entry.close();
 
         var contents: std.ArrayList(u8) = try .initCapacity(self.alloc, file_entry.stat().size);
         defer contents.deinit(self.alloc);
 
         while (try file_handle.read()) |bytes| {
             defer self.alloc.free(bytes);
             try contents.appendSlice(self.alloc, bytes);
         }
 
         try self.io_w.print("{s}\n", .{contents.items});
     }
 
     // Tree
     const Visited = struct {
         name: []const u8,
         level: usize,
     };
 
     fn make_prefix(alloc: std.mem.Allocator, level: usize) ![]const u8 {
         const prefix = "|  ";
         const base = "|- ";
 
         return switch (level) {
             0 => return try alloc.dupe(u8, ""),
             1 => return try alloc.dupe(u8, base),
             else => {
                 var out = try alloc.alloc(u8, (level - 1) * prefix.len + base.len);
                 for (0..(level - 1)) |i| {
                     @memcpy(out[i * prefix.len .. (i + 1) * prefix.len], prefix);
                 }
                 @memcpy(out[(level - 1) * prefix.len .. level * prefix.len], base);
 
                 return out;
             },
         };
     }
 
     fn walk(alloc: std.mem.Allocator, fs: *vfs.FileSystem, directory: vfs.Directory, visited: *std.ArrayList(Visited), level: usize) !void {
         defer directory.close();
 
         var it = try directory.iterate();
         defer it.close();
 
         while (try it.next()) |entry| {
             defer entry.close();
 
             const info = entry.stat();
             if (std.mem.eql(u8, info.name, ".") or std.mem.eql(u8, info.name, "..")) continue;
 
             const dupe_name = try alloc.dupe(u8, info.name);
             try visited.append(alloc, .{ .level = level, .name = dupe_name });
 
             if (info.directory) {
                 try walk(
                     alloc,
                     fs,
                     try fs.open_directory(@constCast(&entry)),
                     visited,
                     level + 1,
                 );
             }
         }
     }
 };
 
 pub fn main() !void {
     var buffer: [1024 * 1024]u8 = undefined;
     var fba: std.heap.FixedBufferAllocator = .init(&buffer);
     const alloc = fba.allocator();
 
     var sd_card = try sd.init(alloc);
     var fat_vfs: pi.fs.FatVFS = .init();
 
     var vfs_disk = vfs.Disk.impl_by(&sd_card);
     const vfs_fat = vfs.FileSystem.impl_by(&fat_vfs);
 
     const mbr: pi.fs.mbr.MasterBootRecord = @bitCast(try vfs_disk.read_sector(0));
 
     try mbr.debug_print(&uart.writer);
 
     try vfs_fat.open(alloc, &vfs_disk, mbr.pte1.first_lba);
     defer vfs_fat.close();
 
     var explorer = try Explorer.init(alloc, vfs_fat, &uart.writer);
 
     while (true) {
         try explorer.read_line();
     }
 }