patch of meow · round #0 · pull #1 · pci.express/frostium

+1 -1

components/ukernel/arch/amd64/interrupts/idt.zig

···

       172
       172
        
           const Self = @This();

     

       173
       173
        
           pub fn parse(self: Self) Target {

     

       174
       174
        
               return switch (self.interrupt) {

     

       175
       175
       -
                   true => .{ .interrupt = @enumFromInt(self.idx) },

     

       175
       175
       +
                   true => .{ .interrupt = .{ .interrupt = @truncate(self.idx) } },

     

       176
       176
        
                   false => switch (self.type) {

     

       177
       177
        
                       .gdt => .{ .gdt_sel = self.idx },

     

       178
       178
        
                       .ldt => .{ .ldt_sel = self.idx },

+31 -3

components/ukernel/arch/amd64/interrupts/root.zig

···

       12
       12
        
           asm volatile ("cli");

     

       13
       13
        
       }

     

       14
       14
        
       

     

       15
       15
       -
       pub fn unhandled_interrupt(stack_frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       16
       16
       -
           std.log.err("Unhandled interrupt (0x{x})!!! rip = 0x{x}", .{ stack_frame.int_num.interrupt, stack_frame.rip });

     

       15
       15
       +
       pub fn unhandled_interrupt(frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       16
       16
       +
           if (std.enums.tagName(idt.Exception, frame.int_num.exception)) |exception_name| {

     

       17
       17
       +
               std.log.err("Unhandled interrupt (0x{x} : {s})!!!", .{ frame.int_num.interrupt, exception_name });

     

       18
       18
       +
           } else {

     

       19
       19
       +
               std.log.err("Unhandled interrupt (0x{x})!!!", .{frame.int_num.interrupt});

     

       20
       20
       +
           }

     

       21
       21
       +
           std.log.err("CR3: 0x{x:0>16}", .{frame.cr3});

     

       22
       22
       +
           std.log.err("RAX: 0x{x:0>16}, RBX: 0x{x:0>16}, RCX: 0x{x:0>16}, RDX: 0x{x:0>16}", .{ frame.regs.rax, frame.regs.rbx, frame.regs.rcx, frame.regs.rdx });

     

       23
       23
       +
           std.log.err("RSI: 0x{x:0>16}, RDI: 0x{x:0>16}, RBP: 0x{x:0>16}, RSP: 0x{x:0>16}", .{ frame.regs.rsi, frame.regs.rdi, frame.regs.rbp, frame.rsp });

     

       24
       24
       +
           std.log.err("R8:  0x{x:0>16}, R9:  0x{x:0>16}, R10: 0x{x:0>16}, R11: 0x{x:0>16}", .{ frame.regs.r8, frame.regs.r9, frame.regs.r10, frame.regs.r11 });

     

       25
       25
       +
           std.log.err("R12: 0x{x:0>16}, R13: 0x{x:0>16}, R14: 0x{x:0>16}, R15: 0x{x:0>16}", .{ frame.regs.r12, frame.regs.r13, frame.regs.r14, frame.regs.r15 });

     

       26
       26
       +
           std.log.err("RFL: 0x{x:0>16}, RIP: 0x{x:0>16}, CS:  0x{x:0>16}, SS:  0x{x:0>16}", .{ frame.eflags, frame.rip, frame.cs, frame.ss });

     

       27
       27
       +
           arch.interrupts.disable();

     

       17
       28
        
           arch.instructions.die();

     

       18
       29
        
       }

     

       19
       30
        
       

     
···

       27
       38
        
       }

     

       28
       39
        
       

     

       29
       40
        
       pub fn general_protection_fault(stack_frame: *idt.InterruptFrame(idt.SelectorErrorCode)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       30
       30
       -
           std.log.warn("General Protection Fault @ 0x{x} (Error Code {}), returning execution...", .{ stack_frame.rip, stack_frame.error_code });

     

       41
       41
       +
           std.log.warn("General Protection Fault @ 0x{x}", .{stack_frame.rip});

     

       42
       42
       +
       

     

       43
       43
       +
           const target = stack_frame.error_code.parse();

     

       44
       44
       +
           switch (target) {

     

       45
       45
       +
               .interrupt => |int| {

     

       46
       46
       +
                   if (std.enums.tagName(idt.Exception, int.exception)) |exc_name| {

     

       47
       47
       +
                       std.log.warn("Caused by interrupt 0x{x} ({s})", .{ int.interrupt, exc_name });

     

       48
       48
       +
                   } else {

     

       49
       49
       +
                       std.log.warn("Caused by interrupt 0x{x}", .{int.interrupt});

     

       50
       50
       +
                   }

     

       51
       51
       +
               },

     

       52
       52
       +
               .gdt_sel => |gdt_sel| {

     

       53
       53
       +
                   std.log.warn("GDT selector: 0x{x}", .{gdt_sel});

     

       54
       54
       +
               },

     

       55
       55
       +
               .ldt_sel => |ldt_sel| {

     

       56
       56
       +
                   std.log.warn("LDT selector: 0x{x}", .{ldt_sel});

     

       57
       57
       +
               },

     

       58
       58
       +
           }

     

       31
       59
        
           arch.instructions.die();

     

       32
       60
        
       }