Rephrase panic messages

Fixes #62.

3 files changed, 18 insertions, 23 deletions

diff --git a/src/lib/interrupts.zig b/src/lib/interrupts.zig
index 1f45ce3..7010295 100644
--- a/src/lib/interrupts.zig
+++ b/src/lib/interrupts.zig
@@ -88,7 +88,7 @@ pub const SyncCause = enum(u63) {
     _,
 };
 
-export fn handleTrap(epc: usize, tval: usize, cause_bits: usize, frame: *trap.Frame) usize {
+export fn handleTrap(epc: usize, cause_bits: usize, frame: *trap.Frame) usize {
     const console = Console.autoChoose().?;
     const w = console.writer();
 
@@ -100,10 +100,6 @@ export fn handleTrap(epc: usize, tval: usize, cause_bits: usize, frame: *trap.Fr
         switch (@as(AsyncCause, @enumFromInt(cause.num))) {
             .supervisor_software => w.print("Hart {d}: Software interrupt\r\n", .{frame.hart_id}) catch unreachable,
             .supervisor_timer => {
-                defer time.interruptInMillis(process.schedule_interval_millis) catch |err| {
-                    std.debug.panic("Hart {d}: Unable to reset interrupt timer: {any}", .{ frame.hart_id, err });
-                };
-
                 if (status.previous_privilege == .user) {
                     // Trapped from U-mode, update pc for next time slice.
                     //
@@ -115,7 +111,7 @@ export fn handleTrap(epc: usize, tval: usize, cause_bits: usize, frame: *trap.Fr
                     process.list.last.?.data.state = .waiting;
 
                     process.schedule() catch |err| {
-                        std.debug.panic("Hart {d}: Unable to schedule next process: {any}", .{ frame.hart_id, err });
+                        std.debug.panic("schedule error: {}", .{err});
                     };
                 }
 
@@ -125,18 +121,18 @@ export fn handleTrap(epc: usize, tval: usize, cause_bits: usize, frame: *trap.Fr
                 const context: u14 = @intCast(2 * frame.hart_id + 1);
 
                 const external_cause = plic.default.claim(context) catch |err| {
-                    std.debug.panic("Hart {d}: Unable to claim external interrupt: {any}", .{ frame.hart_id, err });
+                    std.debug.panic("plic claim error: {}", .{err});
                 };
                 if (external_cause) |source| {
                     w.print("Hart {d}: External interrupt: 0x{x}\r\n", .{ frame.hart_id, source }) catch unreachable;
                     handleExternal(source);
                     plic.default.complete(context, source) catch |err| {
-                        std.debug.panic("Hart {d}: Unable to complete external interrupt: {any}", .{ frame.hart_id, err });
+                        std.debug.panic("plic complete error: {}", .{err});
                     };
                 }
             },
             else => {
-                std.debug.panic("Hart {d}: Unhandled asynchronous interrupt: {d}", .{ frame.hart_id, cause.num });
+                std.debug.panic("unhandled interrupt {}", .{cause.num});
             },
         }
     } else {
@@ -149,16 +145,16 @@ export fn handleTrap(epc: usize, tval: usize, cause_bits: usize, frame: *trap.Fr
 
         switch (@as(SyncCause, @enumFromInt(cause.num))) {
             .illegal_instruction => {
-                std.debug.panic("Hart {d}, PID = {d}: Illegal instruction, EPC = 0x{x:0>16}", .{ frame.hart_id, pid, epc });
+                std.debug.panic("illegal instruction", .{});
             },
             .instruction_access_fault => {
-                std.debug.panic("Hart {d}, PID = {d}: Instruction access fault: EPC = 0x{x:0>16}, TVAL = 0x{x:0>16}", .{ frame.hart_id, pid, epc, tval });
+                std.debug.panic("instruction access fault", .{});
             },
             .load_access_fault => {
-                std.debug.panic("Hart {d}, PID = {d}: Load access fault: EPC = 0x{x:0>16}, TVAL = 0x{x:0>16}", .{ frame.hart_id, pid, epc, tval });
+                std.debug.panic("load access fault", .{});
             },
             .store_or_amo_access_fault => {
-                std.debug.panic("Hart {d}, PID = {d}: Store/AMO access fault: EPC = 0x{x:0>16}, TVAL = 0x{x:0>16}", .{ frame.hart_id, pid, epc, tval });
+                std.debug.panic("store/amo access fault", .{});
             },
             .ecall => {
                 const proc = &process.list.last.?.data;
@@ -172,16 +168,16 @@ export fn handleTrap(epc: usize, tval: usize, cause_bits: usize, frame: *trap.Fr
                 return epc + 4;
             },
             .instruction_page_fault => {
-                std.debug.panic("Hart {d}, PID = {d}: Instruction page fault: EPC = 0x{x:0>16}, TVAL = 0x{x:0>16}", .{ frame.hart_id, pid, epc, tval });
+                std.debug.panic("instruction page fault", .{});
             },
             .load_page_fault => {
-                std.debug.panic("Hart {d}, PID = {d}: Load page fault: EPC = 0x{x:0>16}, TVAL = 0x{x:0>16}", .{ frame.hart_id, pid, epc, tval });
+                std.debug.panic("load page fault", .{});
             },
             .store_or_amo_page_fault => {
-                std.debug.panic("Hart {d}, PID = {d}: Store/AMO page fault: EPC = 0x{x:0>16}, TVAL = 0x{x:0>16}", .{ frame.hart_id, pid, epc, tval });
+                std.debug.panic("store/amo page fault", .{});
             },
             else => {
-                std.debug.panic("Hart {d}, PID = {d}: Unhandled synchronous interrupt: {d}, EPC = 0x{x:0>16}", .{ frame.hart_id, pid, cause.num, epc });
+                std.debug.panic("unhandled exception {d}", .{cause.num});
             },
         }
     }
@@ -241,9 +237,8 @@ export fn supervisorTrapVector() align(4) callconv(.Naked) noreturn {
         \\ .option pop
         \\
         \\ csrr a0, sepc
-        \\ csrr a1, stval
-        \\ csrr a2, scause
-        \\ mv a3, t5
+        \\ csrr a1, scause
+        \\ mv a2, t5
         \\
         \\ la sp, _stvec_stack_end
         \\ call handleTrap
diff --git a/src/lib/process.zig b/src/lib/process.zig
index 4b7c095..c7eddf6 100644
--- a/src/lib/process.zig
+++ b/src/lib/process.zig
@@ -157,7 +157,7 @@ pub const Info = struct {
 
         self.state = .waiting;
         schedule() catch |err| {
-            std.debug.panic("Unable to schedule thread: {any}", .{err});
+            std.debug.panic("schedule error: {}", .{err});
         };
     }
 
diff --git a/src/lib/syscall.zig b/src/lib/syscall.zig
index 0f1a44a..e4d5254 100644
--- a/src/lib/syscall.zig
+++ b/src/lib/syscall.zig
@@ -311,7 +311,7 @@ fn list(proc: *process.Info, trap_frame: *trap.Frame) void {
 fn end(proc: *process.Info) void {
     proc.terminate();
     process.schedule() catch |err| {
-        std.debug.panic("Unable to schedule because all processes are terminated: {}", .{err});
+        std.debug.panic("schedule error: {}", .{err});
     };
 }
 
@@ -360,7 +360,7 @@ fn terminate(proc: *const process.Info, trap_frame: *const trap.Frame) !void {
 
     if (target.shouldTerminate(proc)) {
         process.schedule() catch |err| {
-            std.debug.panic("Unable to schedule because all processes are terminated: {}", .{err});
+            std.debug.panic("schedule error: {}", .{err});
         };
     }
 }