feat: file descriptor and proper stdio

15 files changed, 389 insertions, 103 deletions

diff --git a/boot/elf.zig b/boot/elf.zig
index 2070db6..a6e621c 100644
--- a/boot/elf.zig
+++ b/boot/elf.zig
@@ -4,4 +4,5 @@ pub const programs = [_]Program{
     .{ .name = "calc", .bytes = @embedFile("user_calc") },
     .{ .name = "primes", .bytes = @embedFile("user_primes") },
     .{ .name = "save", .bytes = @embedFile("user_save") },
+    .{ .name = "chat", .bytes = @embedFile("user_chat") },
 };
diff --git a/boot/sched.zig b/boot/sched.zig
index 383b40d..30d5698 100644
--- a/boot/sched.zig
+++ b/boot/sched.zig
@@ -8,9 +8,20 @@ const bridge = @import("bridge");
 
 const MAX_TASKS = 8;
 const KSTACK_SIZE = 16 * 1024;
+const MAX_FDS = 8;
+const MAX_PATH = 128;
 
 const State = enum { free, ready, dead, blocked };
 
+// file descriptor not "foid decimator"
+pub const FdKind = enum { closed, keyboard, console, file };
+pub const Fd = struct {
+    kind: FdKind = .closed,
+    offset: u64 = 0,
+    path_len: usize = 0,
+    path: [MAX_PATH]u8 = @splat(0),
+};
+
 const Task = struct {
     frame: Frame = std.mem.zeroes(Frame),
     cr3: u64 = 0,
@@ -20,6 +31,7 @@ const Task = struct {
 
 var tasks: [MAX_TASKS]Task = @splat(.{});
 var kstacks: [MAX_TASKS][KSTACK_SIZE]u8 align(16) = undefined;
+var fdtabs: [MAX_TASKS][MAX_FDS]Fd = @splat(@splat(.{}));
 var current: usize = 0;
 var blocked_reader: ?usize = null;
 
@@ -53,10 +65,10 @@ pub fn spawn(cr3: u64, entry: u64, ustack: u64, arg: u64, arglen: u64) void {
         var f = std.mem.zeroes(Frame);
         f.rip = entry;
         f.cs = 0x1b; // user code (0x18) | rpl 3
-        f.rflags = 0x202; // reserved bit + if=1, so its preemptible
+        f.rflags = 0x202; // reserved bit + if=1 so its preemptible
         f.rsp = ustack;
         f.ss = 0x23; // user data (0x20) | rpl 3
-        f.rdi = arg; // _start(arg_ptr, arg_len), the sysv first two args
+        f.rdi = arg; // _start(arg_ptr, arg_len) the sysv first two args
         f.rsi = arglen;
         tasks[i] = .{
             .frame = f,
@@ -64,10 +76,51 @@ pub fn spawn(cr3: u64, entry: u64, ustack: u64, arg: u64, arglen: u64) void {
             .kstack_top = @intFromPtr(&kstacks[i]) + KSTACK_SIZE,
             .state = .ready,
         };
+        initFds(i);
         return;
     }
 }
 
+// stdin at keyboard
+fn initFds(i: usize) void {
+    for (&fdtabs[i]) |*f| f.* = .{};
+    fdtabs[i][0].kind = .keyboard;
+    fdtabs[i][1].kind = .console;
+    fdtabs[i][2].kind = .console;
+}
+
+// foid decimator open
+pub fn fdOpen(path: []const u8) i64 {
+    var i: usize = 3;
+    while (i < MAX_FDS) : (i += 1) {
+        const f = &fdtabs[current][i];
+        if (f.kind == .closed) {
+            f.kind = .file;
+            f.offset = 0;
+            const n = @min(path.len, MAX_PATH);
+            @memcpy(f.path[0..n], path[0..n]);
+            f.path_len = n;
+            return @intCast(i);
+        }
+    }
+    return -1;
+}
+
+// foid decimator get
+pub fn fdGet(fd: i64) ?*Fd {
+    if (fd < 0 or fd >= MAX_FDS) return null;
+    const f = &fdtabs[current][@intCast(fd)];
+    if (f.kind == .closed) return null;
+    return f;
+}
+
+// foid decimator close
+pub fn fdClose(fd: i64) i64 {
+    const f = fdGet(fd) orelse return -1;
+    f.kind = .closed;
+    return 0;
+}
+
 pub fn procCount() u64 {
     var count: u64 = 0;
     var i: usize = 1;
@@ -122,7 +175,7 @@ pub fn blockCurrentOnRead(resume_frame: Frame) void {
 
 pub fn deliverInput(byte: u8) bool {
     if (blocked_reader) |task| {
-        tasks[task].frame.rax = byte;
+        stdinPush(byte);
         tasks[task].state = .ready;
         blocked_reader = null;
         return true;
diff --git a/boot/user.zig b/boot/user.zig
index 9bce9e9..78d20ff 100644
--- a/boot/user.zig
+++ b/boot/user.zig
@@ -8,8 +8,17 @@ const regs = @import("regs.zig");
 const bridge = @import("bridge");
 const Frame = regs.Frame;
 
-// scratch for a filename copied out of the caller legit one static buffer is fine
-var name_buf: [64]u8 = undefined;
+// what a syscall returns in rax on failure
+const SYS_ERR: u64 = @bitCast(@as(i64, -1));
+
+// open() flags (linux values lmao)
+const O_CREAT: u64 = 0x40;
+const O_TRUNC: u64 = 0x200;
+const O_APPEND: u64 = 0x400;
+
+// scratch for a filename copied out of the caller
+// legit one static buffer is fine
+var name_buf: [128]u8 = undefined;
 fn userName(ptr: u64) []const u8 {
     const p: [*]const u8 = @ptrFromInt(ptr);
     var i: usize = 0;
@@ -62,63 +71,144 @@ export fn syscallStub() callconv(.naked) void {
 }
 
 export fn syscallHandler(frame: *SyscallFrame) callconv(.c) void {
+    // i js reorganized half of these so if anyone wrote code in asm
+    // for this (me), your syscalled are fucked
     switch (frame.rax) {
         0 => { // exit(code): code in rdi
             sched.exitCurrent();
             asm volatile ("sti");
             while (true) asm volatile ("hlt");
         },
-        1 => { // write(ptr, len): rdi = user pointer, rsi = length
-            const len = frame.rsi;
-            if (len > 0 and len <= 4096) {
-                const bytes: [*]const u8 = @ptrFromInt(frame.rdi);
-                serial.write(bytes[0..len]);
+        1 => { // write(fd, ptr, len)
+            const len = frame.rdx;
+            if (sched.fdGet(@bitCast(frame.rdi))) |f| {
+                if (f.kind == .console) {
+                    if (len > 0 and len <= 4096) {
+                        const bytes: [*]const u8 = @ptrFromInt(frame.rsi);
+                        serial.write(bytes[0..len]);
+                    }
+                    frame.rax = len;
+                } else if (f.kind == .file) {
+                    const n = @min(len, 4096);
+                    const src: [*]const u8 = @ptrFromInt(frame.rsi);
+                    if (bridge.fsWriteAt(f.path[0..f.path_len], f.offset, src[0..n])) {
+                        f.offset += n;
+                        frame.rax = n;
+                    } else frame.rax = SYS_ERR;
+                } else {
+                    frame.rax = SYS_ERR; // keyboard isnt writable
+                }
+            } else frame.rax = SYS_ERR;
+        },
+        2 => { // read(fd, buf, count)
+            const count = frame.rdx;
+            const f = sched.fdGet(@bitCast(frame.rdi)) orelse {
+                frame.rax = SYS_ERR;
+                return;
+            };
+            switch (f.kind) {
+                .keyboard => {
+                    if (count == 0) {
+                        frame.rax = 0;
+                        return;
+                    }
+                    if (sched.readReady()) |byte| {
+                        const dst: [*]u8 = @ptrFromInt(frame.rsi);
+                        dst[0] = byte;
+                        frame.rax = 1;
+                        return;
+                    }
+                    // nothn buffered
+                    const resume_frame: Frame = .{
+                        .r15 = frame.r15,
+                        .r14 = frame.r14,
+                        .r13 = frame.r13,
+                        .r12 = frame.r12,
+                        .r11 = frame.r11,
+                        .r10 = frame.r10,
+                        .r9 = frame.r9,
+                        .r8 = frame.r8,
+                        .rbp = frame.rbp,
+                        .rdi = frame.rdi,
+                        .rsi = frame.rsi,
+                        .rdx = frame.rdx,
+                        .rcx = frame.rcx,
+                        .rbx = frame.rbx,
+                        .rax = frame.rax,
+                        .vector = 0,
+                        .error_code = 0,
+                        .rip = frame.rip - 2,
+                        .cs = frame.cs,
+                        .rflags = frame.rflags,
+                        .rsp = frame.rsp,
+                        .ss = frame.ss,
+                    };
+                    sched.blockCurrentOnRead(resume_frame);
+                    asm volatile ("sti");
+                    while (true) asm volatile ("hlt");
+                },
+                .file => {
+                    const n = @min(count, 4096);
+                    const dst: [*]u8 = @ptrFromInt(frame.rsi);
+                    const got = bridge.fsReadInto(f.path[0..f.path_len], f.offset, dst[0..n]);
+                    f.offset += got;
+                    frame.rax = got;
+                },
+                else => frame.rax = SYS_ERR,
             }
-            frame.rax = len; // syscall return value
         },
-        2 => { // read(): return a buffered byte, else block for one
-            if (sched.readReady()) |byte| {
-                frame.rax = byte;
+        7 => { // open(path_ptr, flags)
+            const name = userName(frame.rdi);
+            const flags = frame.rsi;
+            var size = bridge.fsSize(name);
+            if (size < 0) {
+                if (flags & O_CREAT != 0 and bridge.fsStore(name, "")) {
+                    size = 0;
+                } else {
+                    frame.rax = SYS_ERR;
+                    return;
+                }
+            } else if (flags & O_TRUNC != 0) {
+                _ = bridge.fsStore(name, "");
+                size = 0;
+            }
+            const fd = sched.fdOpen(name);
+            if (fd < 0) {
+                frame.rax = SYS_ERR;
                 return;
             }
-            const resume_frame: Frame = .{
-                .r15 = frame.r15,
-                .r14 = frame.r14,
-                .r13 = frame.r13,
-                .r12 = frame.r12,
-                .r11 = frame.r11,
-                .r10 = frame.r10,
-                .r9 = frame.r9,
-                .r8 = frame.r8,
-                .rbp = frame.rbp,
-                .rdi = frame.rdi,
-                .rsi = frame.rsi,
-                .rdx = frame.rdx,
-                .rcx = frame.rcx,
-                .rbx = frame.rbx,
-                .rax = frame.rax,
-                .vector = 0,
-                .error_code = 0,
-                .rip = frame.rip,
-                .cs = frame.cs,
-                .rflags = frame.rflags,
-                .rsp = frame.rsp,
-                .ss = frame.ss,
-            };
-            sched.blockCurrentOnRead(resume_frame);
-            asm volatile ("sti");
-            while (true) asm volatile ("hlt");
+            if (flags & O_APPEND != 0) {
+                if (sched.fdGet(fd)) |f| f.offset = @intCast(size);
+            }
+            frame.rax = @bitCast(fd);
+        },
+        8 => { // close(fd)
+            frame.rax = @bitCast(sched.fdClose(@bitCast(frame.rdi)));
+        },
+        9 => { // lseek(fd, offset, whence)
+            if (sched.fdGet(@bitCast(frame.rdi))) |f| {
+                switch (frame.rdx) {
+                    0 => f.offset = frame.rsi, // SEEK_SET
+                    1 => f.offset += frame.rsi, // SEEK_CUR
+                    2 => { // SEEK_END
+                        const sz = bridge.fsSize(f.path[0..f.path_len]);
+                        if (sz >= 0) f.offset = @as(u64, @intCast(sz)) +% frame.rsi;
+                    },
+                    else => {},
+                }
+                frame.rax = f.offset;
+            } else frame.rax = SYS_ERR;
         },
-        4 => { // fs_size(name_ptr): returns size (like obv), or -1
+        4 => { // fs_size(name_ptr)
             frame.rax = @bitCast(bridge.fsSize(userName(frame.rdi)));
         },
-        5 => { // fs_read(name_ptr, offset, buf_ptr, len): returns bytes read
+        5 => { // fs_read(name_ptr, offset, buf_ptr, len)
             const len = @min(frame.rcx, 4096);
             const name = userName(frame.rdi);
             const dst: [*]u8 = @ptrFromInt(frame.rdx);
             frame.rax = bridge.fsReadInto(name, frame.rsi, dst[0..len]);
         },
-        6 => { // fs_write(name_ptr, buf_ptr, len): returns 1 ok / 0 fail
+        6 => { // fs_write(name_ptr, buf_ptr, len)
             const len = @min(frame.rdx, 64 * 1024);
             const name = userName(frame.rdi);
             const src: [*]const u8 = @ptrFromInt(frame.rsi);
diff --git a/bridge/bridge.zig b/bridge/bridge.zig
index 56cfc7f..4570e3d 100644
--- a/bridge/bridge.zig
+++ b/bridge/bridge.zig
@@ -21,6 +21,7 @@ const init_program = blk: {
         @embedFile("k_console") ++ "\n" ++
         @embedFile("k_vmm") ++ "\n" ++
         @embedFile("k_fs") ++ "\n" ++
+        @embedFile("k_io") ++ "\n" ++
         @embedFile("k_vfs") ++ "\n" ++
         @embedFile("k_seed") ++ "\n";
 
@@ -179,3 +180,14 @@ pub fn fsStore(name: []const u8, data: []const u8) bool {
     const r = vm.callFunctionParts(func, null, &[_]revo.Value{ name_val, data_val }, null) catch return false;
     return (r.asNumOpt() orelse 0) == 1;
 }
+
+pub fn fsWriteAt(name: []const u8, offset: u64, data: []const u8) bool {
+    const vm = g_vm orelse return false;
+    const func = vm.getGlobal("fs_write_at") orelse return false;
+    const name_val = vm.ownValueString(name) catch return false;
+    const data_val = vm.ownValueString(data) catch return false;
+    g_vm_running = true;
+    defer g_vm_running = false;
+    const r = vm.callFunctionParts(func, null, &[_]revo.Value{ name_val, revo.Value.new.num(@as(f64, @floatFromInt(offset))), data_val }, null) catch return false;
+    return (r.asNumOpt() orelse 0) == 1;
+}
diff --git a/build.zig b/build.zig
index 469d513..c8797d6 100644
--- a/build.zig
+++ b/build.zig
@@ -67,6 +67,7 @@ pub fn build(b: *std.Build) void {
         .{ "k_console", "kernel/console.rv" },
         .{ "k_vmm", "kernel/vmm.rv" },
         .{ "k_fs", "kernel/fs.rv" },
+        .{ "k_io", "kernel/io.rv" },
         .{ "k_vfs", "kernel/vfs.rv" },
         .{ "k_seed", "kernel/seed.rv" },
         .{ "k_proc", "kernel/proc.rv" },
@@ -98,7 +99,7 @@ pub fn build(b: *std.Build) void {
         kernel.root_module.addAnonymousImport(e[0], .{ .root_source_file = b.path(e[1]) });
     }
 
-    inline for (.{ "hexview", "calc", "primes", "save" }) |prog| {
+    inline for (.{ "hexview", "calc", "primes", "save", "chat" }) |prog| {
         const cc = b.addSystemCommand(&.{
             "zig",                  "cc",
             "-target",              "x86_64-freestanding",
@@ -110,6 +111,8 @@ pub fn build(b: *std.Build) void {
         });
         const prog_elf = cc.addOutputFileArg(prog ++ ".elf");
         cc.addFileArg(b.path("user/" ++ prog ++ ".c"));
+        cc.addFileInput(b.path("user/user.h"));
+        cc.addFileInput(b.path("user/link.ld"));
         kernel.root_module.addAnonymousImport("user_" ++ prog, .{ .root_source_file = prog_elf });
     }
 
diff --git a/kernel/fs.rv b/kernel/fs.rv
index 23ccd78..1e72dc4 100644
--- a/kernel/fs.rv
+++ b/kernel/fs.rv
@@ -346,6 +346,23 @@ global fs = {
     return entry.size
   end,
 
+  # TODO: ts needs a rewrite its not cheap and rewrites every file from scratch
+  write_at = fn(self, path, offset, bytes) do
+    const size = self:size(path)
+    let base = ""
+    if size > 0 do base = self:read_bytes(path, 0, size) end
+    let prefix = ""
+    if offset <= base:len() do prefix = base[0..offset] end
+    else do
+      prefix = base
+      while prefix:len() < offset do prefix = prefix ~ string.of_ascii(0) end
+    end
+    const after = offset + bytes:len()
+    let tail = ""
+    if after < base:len() do tail = base[after..] end
+    return self:store(path, prefix ~ bytes ~ tail)
+  end,
+
   cat = fn(self, path) do
     if self:ensure() == :false return :nil
     const entry = self:resolve(path)
@@ -444,3 +461,4 @@ global fs = {
 global fs_store = fn(name, text) fs:store(name, text)
 global fs_size = fn(name) fs:size(name)
 global fs_read_bytes = fn(name, offset, length) fs:read_bytes(name, offset, length)
+global fs_write_at = fn(name, offset, bytes) fs:write_at(name, offset, bytes)
diff --git a/kernel/io.rv b/kernel/io.rv
new file mode 100644
index 0000000..68b7039
--- /dev/null
+++ b/kernel/io.rv
@@ -0,0 +1,37 @@
+# stdio stuff
+
+global io = {
+  open = fn(self, path, mode) do
+    if mode == "w" do fs:store(path, "") end
+    let offset = 0
+    if mode == "a" do
+      const size = fs:size(path)
+      if size > 0 do offset = size end
+    end
+    return { path = path, offset = offset }
+  end,
+
+  read = fn(self, handle, count) do
+    const data = fs:read_bytes(handle.path, handle.offset, count)
+    handle.offset += data:len()
+    return data
+  end,
+
+  read_all = fn(self, handle) do
+    const size = fs:size(handle.path)
+    if size <= handle.offset return ""
+    const data = fs:read_bytes(handle.path, handle.offset, size - handle.offset)
+    handle.offset += data:len()
+    return data
+  end,
+
+  write = fn(self, handle, data) do
+    fs:write_at(handle.path, handle.offset, data)
+    handle.offset += data:len()
+    return data:len()
+  end,
+
+  seek = fn(self, handle, offset) do handle.offset = offset end,
+  tell = fn(self, handle) handle.offset,
+  close = fn(self, handle) :nil,
+}
diff --git a/kernel/main.rv b/kernel/main.rv
index 3363bde..93de758 100644
--- a/kernel/main.rv
+++ b/kernel/main.rv
@@ -16,9 +16,9 @@ if (disk_sectors() != 0 and fs.ready == :false) do
 end
 
 # lung will be happy
-const default_face = load_ttf("/fonts/terminess.ttf", 32)
+const default_face = load_ttf("/usr/share/terminess.ttf", 32)
 if default_face != :nil do
-  add_font("terminess", default_face.glyphs, default_face.width, default_face.height, :ttf, "/fonts/terminess.ttf", 32)
+  add_font("terminess", default_face.glyphs, default_face.width, default_face.height, :ttf, "/usr/share/terminess.ttf", 32)
   console:set_font(find_font("terminess"))
 end
 
diff --git a/kernel/proc.rv b/kernel/proc.rv
index 5019fa8..92d48f1 100644
--- a/kernel/proc.rv
+++ b/kernel/proc.rv
@@ -67,8 +67,8 @@ end
 
 fn run_prog(name, arg) do
   let bare_name = name
-  if bare_name:starts_with?("/bin/") bare_name = bare_name[5..]
-  const path = "/bin/#{bare_name}"
+  if bare_name:starts_with?("/usr/bin/") bare_name = bare_name[9..]
+  const path = "/usr/bin/#{bare_name}"
   if fs:size(path) < 0 return :false
   return load_file_elf(path, arg)
 end
diff --git a/kernel/seed.rv b/kernel/seed.rv
index 058b57a..f673f68 100644
--- a/kernel/seed.rv
+++ b/kernel/seed.rv
@@ -2,8 +2,9 @@
 
 fn seed_bin() do
   fs:mkdir("/bin")
+  fs:mkdir("/usr/bin")
   for index in 0..prog_count() do
-    fs:store("/bin/#{prog_name(index)}", phys_to_str(prog_phys(index), prog_size(index)))
+    fs:store("/usr/bin/#{prog_name(index)}", phys_to_str(prog_phys(index), prog_size(index)))
   end
   for index in 0..script_count() do
     fs:store("/bin/#{script_name(index)}.rv", script_src(index))
@@ -11,9 +12,9 @@ fn seed_bin() do
 end
 
 fn seed_fonts() do
-  fs:mkdir("/fonts")
+  fs:mkdir("/usr/share")
   for index in 0..font_count() do
-    fs:store("/fonts/#{font_name(index)}", phys_to_str(font_phys(index), font_size(index)))
+    fs:store("/usr/share/#{font_name(index)}", phys_to_str(font_phys(index), font_size(index)))
   end
 end
 
diff --git a/kernel/shell.rv b/kernel/shell.rv
index 31cc70e..2811e5a 100644
--- a/kernel/shell.rv
+++ b/kernel/shell.rv
@@ -22,26 +22,26 @@ end
 fn cmd_help(context) do
   help_group("shell", "shell")
   help_group("gils (builtin)", "gils")
-  # the rest of gils, and the programs, are real files in /bin now
-  const items = fs:entries("/bin")
-  if items != :nil do
+  # gils scripts are real files in /bin, native programs in /usr/bin
+  const scripts = fs:entries("/bin")
+  if scripts != :nil do
     puts("\n  gils (/bin scripts)\n")
-    for index in 0..items:len() do
-      const name = items[index].name
+    for index in 0..scripts:len() do
+      const name = scripts[index].name
       if (name:len() > 3 and name[(name:len() - 3)..] == ".rv") do help_row(name[0..(name:len() - 3)], "") end
     end
-    puts("\n  programs (/bin)\n")
-    for index in 0..items:len() do
-      const name = items[index].name
-      if (name:len() <= 3 or name[(name:len() - 3)..] != ".rv") do help_row(name, "") end
-    end
+  end
+  const progs = fs:entries("/usr/bin")
+  if progs != :nil do
+    puts("\n  programs (/usr/bin)\n")
+    for index in 0..progs:len() do help_row(progs[index].name, "") end
   end
 
   puts("\n  fonts (font <name>)\n")
   for index in 0..fonts:len() do help_row(fonts[index].name, "8x#{fonts[index].height}") end
-  const font_files = fs:entries("/fonts")
+  const font_files = fs:entries("/usr/share")
   if font_files != :nil do
-    puts("\n  fonts on disk (font load /fonts/x.psf)\n")
+    puts("\n  fonts on disk (font load /usr/share/x.psf)\n")
     for index in 0..font_files:len() do help_row(font_files[index].name, "") end
   end
   puts("\n")
@@ -186,8 +186,8 @@ fn font_file(name) do
     if fs:size(p ~ ".psf") >= 0 return { path = p ~ ".psf", kind = :psf }
     return { path = p, kind = :none }
   end
-  if fs:size("/fonts/#{name}.psf") >= 0 return { path = "/fonts/#{name}.psf", kind = :psf }
-  if fs:size("/fonts/#{name}.ttf") >= 0 return { path = "/fonts/#{name}.ttf", kind = :ttf }
+  if fs:size("/usr/share/#{name}.psf") >= 0 return { path = "/usr/share/#{name}.psf", kind = :psf }
+  if fs:size("/usr/share/#{name}.ttf") >= 0 return { path = "/usr/share/#{name}.ttf", kind = :ttf }
   return { path = name, kind = :none }
 end
 
@@ -196,7 +196,7 @@ fn cmd_font(context) do
     puts("fonts:")
     for index in 0..fonts:len() do puts(" #{fonts[index].name}(#{fonts[index].width}x#{fonts[index].height})") end
     puts("\n")
-    const font_files = fs:entries("/fonts")
+    const font_files = fs:entries("/usr/share")
     if font_files != :nil do
       puts("on disk:")
       for index in 0..font_files:len() do puts(" #{font_files[index].name}") end
@@ -291,7 +291,7 @@ fn exec_file(target) do
   else do
     candidates:push(expand_path(target))
     candidates:push(expand_path(target) ~ ".rv")
-    candidates:push("/bin/#{target}")
+    candidates:push("/usr/bin/#{target}")
     candidates:push("/bin/#{target}.rv")
   end
   for index in 0..candidates:len() do
diff --git a/user/chat.c b/user/chat.c
new file mode 100644
index 0000000..67bc727
--- /dev/null
+++ b/user/chat.c
@@ -0,0 +1,33 @@
+#include "user.h"
+
+void _start(const char* arg, unsigned long arglen)
+{
+    if (arglen == 0)
+    {
+        put("usage: run chat <path>\n");
+        sys_exit(1);
+    }
+
+    char path[128];
+    unsigned long i = 0;
+    for (; i < arglen && i < sizeof(path) - 1; i++)
+        path[i] = arg[i];
+    path[i] = 0;
+
+    long fd = sys_open(path, 0);
+    if (fd < 0)
+    {
+        put("chat: ");
+        put(path);
+        put(": cannot open\n");
+        sys_exit(1);
+    }
+
+    char buffer[256];
+    long n;
+    while ((n = sys_read(fd, buffer, sizeof(buffer))) > 0)
+        sys_write(1, buffer, (unsigned long)n);
+
+    sys_close(fd);
+    sys_exit(0);
+}
diff --git a/user/hexview.c b/user/hexview.c
index c211b44..5eac27c 100644
--- a/user/hexview.c
+++ b/user/hexview.c
@@ -5,7 +5,7 @@ static const char HEX[] = "0123456789abcdef";
 static void put_hex8(unsigned char byte)
 {
     char digits[2] = { HEX[byte >> 4], HEX[byte & 15] };
-    sys_write(digits, 2);
+    sys_write(1, digits, 2);
 }
 
 static void put_hex32(unsigned long value)
@@ -13,7 +13,7 @@ static void put_hex32(unsigned long value)
     char digits[8];
     for (int nibble = 0; nibble < 8; nibble++)
         digits[nibble] = HEX[(value >> ((7 - nibble) * 4)) & 15];
-    sys_write(digits, 8);
+    sys_write(1, digits, 8);
 }
 
 #define PAGE 256
@@ -67,7 +67,7 @@ void _start(const char* arg, unsigned long arglen)
                 if (row + column < count)
                 {
                     put_hex8((unsigned char)buffer[row + column]);
-                    sys_write(" ", 1);
+                    sys_write(1, " ", 1);
                 }
                 else
                     put("   ");
@@ -78,19 +78,19 @@ void _start(const char* arg, unsigned long arglen)
             {
                 char character = buffer[row + column];
                 if (character >= 32 && character < 127)
-                    sys_write(&character, 1);
+                    sys_write(1, &character, 1);
                 else
-                    sys_write(".", 1);
+                    sys_write(1, ".", 1);
             }
             put("\n");
         }
 
         put("[n]ext [p]rev [q]uit (or up/down arrows) > ");
-        char key = (char)sys_read();
+        char key = (char)get_char();
         if (key == 27) // ESC
         {
-            sys_read();
-            char final = (char)sys_read();
+            get_char();
+            char final = (char)get_char();
             if (final == 'A')
                 key = 'p';
             else if (final == 'B')
diff --git a/user/save.c b/user/save.c
index b3664f4..48e1930 100644
--- a/user/save.c
+++ b/user/save.c
@@ -2,23 +2,30 @@
 
 void _start(const char* arg, unsigned long arglen)
 {
-    if (arglen == 0 || arglen >= 64)
+    if (arglen == 0 || arglen >= 120)
     {
         put("usage: run save <path>\n");
         sys_exit(1);
     }
 
-    char name[64];
+    char name[128];
     for (unsigned long i = 0; i < arglen; i++)
         name[i] = arg[i];
     name[arglen] = 0;
 
+    long fd = sys_open(name, O_CREAT | O_TRUNC | O_WRONLY);
+    if (fd < 0)
+    {
+        put("save: ");
+        put(name);
+        put(": cannot open\n");
+        sys_exit(1);
+    }
+
     put("saving to ");
     put(name);
     put(" -- type lines, a single . saves\n");
 
-    char buffer[4096];
-    int length = 0;
     for (;;)
     {
         char line[256];
@@ -26,20 +33,13 @@ void _start(const char* arg, unsigned long arglen)
         put("\n");
         if (n == 1 && line[0] == '.')
             break;
-        for (int i = 0; i < n && length < 4000; i++)
-            buffer[length++] = line[i];
-        if (length < 4000)
-            buffer[length++] = '\n';
+        sys_write(fd, line, (unsigned long)n);
+        sys_write(fd, "\n", 1);
     }
 
-    if (sys_fs_write(name, buffer, (unsigned long)length))
-    {
-        put("saved ");
-        put(name);
-        put("\n");
-    }
-    else
-        put("write failed\n");
-
+    sys_close(fd);
+    put("saved ");
+    put(name);
+    put("\n");
     sys_exit(0);
 }
diff --git a/user/user.h b/user/user.h
index 635dc86..34710ac 100644
--- a/user/user.h
+++ b/user/user.h
@@ -1,16 +1,44 @@
-// shared syscall stubs
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
 
-static long sys_write(const char* buffer, unsigned long length)
+#define O_WRONLY 1
+#define O_CREAT  0x40
+#define O_TRUNC  0x200
+#define O_APPEND 0x400
+
+static long sys_write(long fd, const char* buffer, unsigned long length)
+{
+    long result;
+    __asm__ volatile("int $0x80" : "=a"(result) : "a"(1L), "D"(fd), "S"(buffer), "d"(length) : "memory");
+    return result;
+}
+
+static long sys_read(long fd, char* buffer, unsigned long length)
+{
+    long result;
+    __asm__ volatile("int $0x80" : "=a"(result) : "a"(2L), "D"(fd), "S"(buffer), "d"(length) : "memory");
+    return result;
+}
+
+static long sys_open(const char* path, long flags)
+{
+    long result;
+    __asm__ volatile("int $0x80" : "=a"(result) : "a"(7L), "D"(path), "S"(flags) : "memory");
+    return result;
+}
+
+static long sys_close(long fd)
 {
     long result;
-    __asm__ volatile("int $0x80" : "=a"(result) : "a"(1L), "D"(buffer), "S"(length) : "memory");
+    __asm__ volatile("int $0x80" : "=a"(result) : "a"(8L), "D"(fd) : "memory");
     return result;
 }
 
-static long sys_read(void)
+static long sys_lseek(long fd, long offset, long whence)
 {
     long result;
-    __asm__ volatile("int $0x80" : "=a"(result) : "a"(2L) : "memory");
+    __asm__ volatile("int $0x80" : "=a"(result) : "a"(9L), "D"(fd), "S"(offset), "d"(whence) : "memory");
     return result;
 }
 
@@ -52,7 +80,15 @@ static void put(const char* string)
     unsigned long length = 0;
     while (string[length])
         length++;
-    sys_write(string, length);
+    sys_write(1, string, length);
+}
+
+static int get_char(void)
+{
+    char c;
+    if (sys_read(0, &c, 1) <= 0)
+        return -1;
+    return (unsigned char)c;
 }
 
 static int read_line(char* buffer, int max_length)
@@ -60,7 +96,9 @@ static int read_line(char* buffer, int max_length)
     int length = 0;
     for (;;)
     {
-        char character = (char)sys_read();
+        char character;
+        if (sys_read(0, &character, 1) <= 0)
+            break;
         if (character == '\n')
             break;
         if (character == '\b')
@@ -68,14 +106,14 @@ static int read_line(char* buffer, int max_length)
             if (length > 0)
             {
                 length--;
-                sys_write("\b \b", 3);
+                sys_write(1, "\b \b", 3);
             }
             continue;
         }
         if (length < max_length - 1)
         {
             buffer[length++] = character;
-            sys_write(&character, 1);
+            sys_write(1, &character, 1);
         }
     }
     buffer[length] = 0;
@@ -108,5 +146,5 @@ static void put_int(long value)
         buffer[right] = swap;
     }
 
-    sys_write(buffer, length);
+    sys_write(1, buffer, length);
 }