From 852a5b237116e8b53ae18ea8ea00505e44b40dfe Mon Sep 17 00:00:00 2001 From: hachem Date: Thu, 8 Oct 2026 22:23:55 +0200 Subject: feat: file descriptor and proper stdio --- boot/elf.zig | 1 + boot/sched.zig | 59 ++++++++++++++++++- boot/user.zig | 172 +++++++++++++++++++++++++++++++++++++++++------------- bridge/bridge.zig | 12 ++++ build.zig | 5 +- kernel/fs.rv | 18 ++++++ kernel/io.rv | 37 ++++++++++++ kernel/main.rv | 4 +- kernel/proc.rv | 4 +- kernel/seed.rv | 7 ++- kernel/shell.rv | 32 +++++----- user/chat.c | 33 +++++++++++ user/hexview.c | 16 ++--- user/save.c | 34 +++++------ user/user.h | 58 ++++++++++++++---- 15 files changed, 389 insertions(+), 103 deletions(-) create mode 100644 kernel/io.rv create mode 100644 user/chat.c 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 )\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 \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 \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); } -- cgit v1.3