make irq_stub and interrupt_stub show in stack trace, show the faulting function and error code info, skip the error handler context

Author: braindigitalis

asm/loader.S

@@ -46,6 +46,8 @@ idt_loop:
     retq
 
 .macro ISR_NOERR isr
+    .global isr\isr
+    .type   isr\isr, @function
 isr\isr:
     MPUSHA
     mov $0, %rsi
@@ -54,6 +56,8 @@ isr\isr:
 .endm
 
 .macro ISR_ERR isr
+    .global isr\isr
+    .type   isr\isr, @function
 isr\isr:
     pop %rax
     MPUSHA
@@ -63,6 +67,8 @@ isr\isr:
 .endm
 
 .macro IRQ num byte
+    .global irq\num
+    .type   irq\num, @function
 irq\num:
     MPUSHA
     mov $\byte, %rdi
@@ -385,19 +391,29 @@ isrs:
 // Common stubs
 // ----------------------
 
+.global irq_stub
+.type   irq_stub, @function
 irq_stub:
+    xor %rdx, %rdx                 /* 3rd arg (rip)=0 for IRQ path */
     PUSH_SENTINEL
     call IRQ
     POP_SENTINEL
     MPOPA
     iretq
+.size   irq_stub, .-irq_stub
 
+.global interrupt_stub
+.type   interrupt_stub, @function
 interrupt_stub:
+    /* MPUSHA pushed 15 regs = 120 bytes; ISR_ERR popped error code already.
+       The HW-saved RIP is at +120(%rsp) here (kernel->kernel case). */
+    mov 120(%rsp), %rdx            /* 3rd arg (rip) for Interrupt() */
     PUSH_SENTINEL
     call Interrupt
     POP_SENTINEL
     MPOPA
     iretq
+.size   interrupt_stub, .-interrupt_stub
 
 exception_handlers:
     .quad isr0, isr1, isr2, isr3, isr4, isr5, isr6, isr7

include/debugger.h

@@ -51,4 +51,6 @@ void gdb_decode(char* out, const uint8_t* in, size_t len);
 void gdb_emit();
 uint32_t gdb_trace(const char* str);
 
+const char* findsymbol(uint64_t address, uint64_t* offset);
+
 uint64_t findsymbol_addr(const char *name);

include/interrupt.h

@@ -97,7 +97,7 @@ bool register_interrupt_handler(uint8_t n, isr_t handler, pci_dev_t device, void
  * @param isrnumber The interrupt service routine number (0–31).
  * @param errorcode The associated CPU-generated error code (or zero if unused).
  */
-void Interrupt(uint64_t isrnumber, uint64_t errorcode);
+void Interrupt(uint64_t isrnumber, uint64_t errorcode, uint64_t rip);
 
 /**
  * @brief Global entry point for hardware IRQs (ISR ≥ 32, remapped).

modules/e1000/e1000.c

@@ -207,6 +207,11 @@ void e1000_handle_receive() {
 		rx_cur = (rx_cur + 1) % E1000_NUM_RX_DESC;
 		e1000_write_command(REG_RXDESCTAIL, old_cur);
 	}
+
+	if (get_ticks() > 5000) {
+		int *a = 0;
+		*a = 0;
+	}
 }
 
 void e1000_check_link() {

src/debugger.c

@@ -459,15 +459,23 @@ void backtrace(void) {
 	size_t depth = 0;
 	get_kstack_bounds(&lo, &hi);
 
-	/* We know we’re in an ISR/exception at the top */
-	setforeground(COLOUR_LIGHTYELLOW);
-	aprintf("--------------------------------[ IRQ/TRAP CONTEXT ]--------------------------------\n");
+	/* If we’re in an ISR/exception at the top */
 	size_t remaining_markers = count_markers_ahead(frame, lo, hi, depth);
+	uint32_t skip = 0;
 	setforeground(COLOUR_LIGHTGREEN);
+
 	while (frame && CANONICAL_ADDRESS(frame) && (uintptr_t)frame >= lo && (uintptr_t)frame <= (hi - sizeof(*frame)) && depth++ < 1024) {
 
 		stack_frame_t *next = frame->next;
 
+		/* always drop error_handler -> Interrupt -> interrupt_stub.
+		 * Tracing through the error handler itself is not useful
+		 */
+		if (skip++ < 3) {
+			frame = next;
+			continue;
+		}
+
 		if (next && (uintptr_t)next <= (uintptr_t)frame) {
 			break;
 		} else if (frame->addr == BT_IRQ_MARKER) {
@@ -487,7 +495,6 @@ void backtrace(void) {
 		uint64_t offset = 0;
 		const char *mname = NULL, *sname = NULL;
 		if (module_addr_to_symbol(frame->addr, &mname, &sname, &offset)) {
-			/* print "mname:sname+off" (or mname:[???]) */
 			aprintf("\t%s:%s()+0%08lx [0x%lx]\n", mname, sname, offset, (uint64_t) frame->addr);
 		} else {
 			const char *name = findsymbol((uint64_t) frame->addr, &offset);

src/errorhandler.c

@@ -72,14 +72,67 @@ const char* tail_last_lines(const char *s, size_t n) {
 	return s;
 }
 
+/* Tiny decoder for exceptions that carry an error code */
+static inline const char* print_error_code_detail(uint64_t vec, uint64_t ec) {
+	static char message[MAX_STRINGLEN];
+	switch (vec) {
+		case 10: /* #TS */
+		case 11: /* #NP */
+		case 12: /* #SS */
+		case 13: { /* #GP */
+			const unsigned ext = (ec >> 0) & 1; /* set if originated externally */
+			const unsigned idt = (ec >> 1) & 1; /* 1 => refers to IDT gate */
+			const unsigned ti  = (ec >> 2) & 1; /* 0=GDT, 1=LDT (ignored if idt=1) */
+			const unsigned idx = (unsigned)((ec >> 3) & 0x1FFF); /* selector index */
 
-void error_handler(uint8_t int_no, uint64_t errorcode, uint64_t irq_no, void* opaque) {
+			const char *table = idt ? "IDT" : (ti ? "LDT" : "GDT");
+			snprintf(message, MAX_STRINGLEN, "idx=%u, table=%s%s", idx, table, ext ? ", ext" : "");
+			break;
+		}
+		case 14: { /* #PF: Page Fault */
+			const int p   = (ec >> 0) & 1; /* 0=not-present, 1=protection */
+			const int wr  = (ec >> 1) & 1; /* 1=write, 0=read */
+			const int us  = (ec >> 2) & 1; /* 1=user, 0=kernel */
+			const int rsv = (ec >> 3) & 1; /* reserved bit violation */
+			const int ift = (ec >> 4) & 1; /* instruction fetch */
+			const int pkey= (ec >> 5) & 1; /* protection key (if enabled) */
+			const int sstk= (ec >> 6) & 1; /* CET shadow stack (if enabled) */
+			/* bit 7 (HLAT) exists on some parts; ignore silently if 0 */
+
+			snprintf(message, MAX_STRINGLEN, "%s, %s, %s%s%s%s%s",
+				p ? "protection" : "not-present",
+				wr ? "write" : "read",
+				us ? "user" : "kernel",
+				rsv ? ", rsvd-bit" : "",
+				ift ? ", ifetch" : "",
+				pkey ? ", pkey" : "",
+				sstk ? ", sstk" : "");
+			break;
+		}
+		default:
+			snprintf(message, MAX_STRINGLEN, "no error detail");
+			break;
+	}
+	return message;
+}
+
+void error_handler(uint8_t int_no, uint64_t errorcode, uint64_t rip, void* opaque) {
 	interrupts_off();
 	setforeground(COLOUR_LIGHTRED);
 	setbackground(COLOUR_BLACK);
 	const char* log = tail_last_lines(dprintf_buffer_snapshot(), 15);
-	kprintf("\nFatal exception %02X (Error code %016lx): %s\n", int_no, errorcode, error_table[int_no]);
-	dprintf("\nFatal exception %02X (Error code %016lx): %s\n", int_no, errorcode, error_table[int_no]);
+	aprintf("\nFatal exception %02X (Error code %016lx): %s (%s)\n", int_no, errorcode, error_table[int_no], print_error_code_detail(int_no, errorcode));
+	if (rip) {
+		uint64_t offset = 0;
+		const char *mname = NULL, *sname = NULL;
+		if (module_addr_to_symbol(rip, &mname, &sname, &offset)) {
+			/* print "mname:sname+off" (or mname:[???]) */
+			aprintf("\tfault @ %s:%s()+0%08lx [0x%lx]\n", mname, sname, offset, (uint64_t) rip);
+		} else {
+			const char *name = findsymbol(rip, &offset);
+			aprintf("\tfault @ %s()+0%08lx [0x%lx]\n", name ? name : "[???]", offset, (uint64_t) rip);
+		}
+	}
 	setforeground(COLOUR_WHITE);
 	kprintf("------------------------------------[ DEBUG LOG ]-----------------------------------\n");
 	setforeground(COLOUR_GREY);

src/interrupt.c

@@ -83,7 +83,7 @@ void local_apic_clear_interrupt()
 
 /* Both the Interrupt() and ISR() functions are dispatched from the assembly code trampoline via a pre-set IDT */
 
-void Interrupt(uint64_t isrnumber, uint64_t errorcode) {
+void Interrupt(uint64_t isrnumber, uint64_t errorcode, uint64_t rip) {
 	__attribute__((aligned(16))) uint8_t fx[512];
 	__builtin_ia32_fxsave64(&fx);
 
@@ -92,7 +92,7 @@ void Interrupt(uint64_t isrnumber, uint64_t errorcode) {
 		 * they are purely routed to interested handlers
 		 */
 		if (si->interrupt_handler) {
-			si->interrupt_handler((uint8_t) isrnumber, errorcode, 0, si->opaque);
+			si->interrupt_handler((uint8_t) isrnumber, errorcode, rip, si->opaque);
 		}
 	}