chore(debug): add dwarf data for ISR

include/kernel/interrupt.hpp

@@ -22,22 +22,9 @@ struct saved_regs {
     unsigned long rbp;
 };
 
-struct PACKED interrupt_stack_head {
-    saved_regs s_regs;
+struct interrupt_stack {
+    saved_regs regs;
     unsigned long int_no;
-};
-
-struct PACKED interrupt_stack_normal {
-    interrupt_stack_head head;
-    uintptr_t v_rip;
-    unsigned long cs;
-    unsigned long flags;
-    uintptr_t rsp;
-    unsigned long ss;
-};
-
-struct PACKED interrupt_stack_with_code {
-    interrupt_stack_head head;
     unsigned long error_code;
     uintptr_t v_rip;
     unsigned long cs;
@@ -50,24 +37,6 @@ struct mmx_registers {
     uint8_t data[512]; // TODO: list of content
 };
 
-// present: When set, the page fault was caused by a page-protection violation.
-//          When not set, it was caused by a non-present page.
-// write:   When set, the page fault was caused by a write access.
-//          When not set, it was caused by a read access.
-// user:    When set, the page fault was caused while CPL = 3.
-//          This does not necessarily mean that the page fault was a privilege violation.
-// from https://wiki.osdev.org/Exceptions#Page_Fault
-struct page_fault_error_code {
-    unsigned long present : 1;
-    unsigned long write : 1;
-    unsigned long user : 1;
-    unsigned long reserved_write : 1;
-    unsigned long instruction_fetch : 1;
-    unsigned long protection_key : 1;
-    unsigned long shadow_stack : 1;
-    unsigned long software_guard_extensions : 1;
-};
-
 namespace kernel::kinit {
 void init_interrupt();
 

include/kernel/signal.hpp

@@ -64,7 +64,7 @@ public:
 
     // return value: whether the thread should wake up
     bool raise(signo_type signal);
-    void handle(interrupt_stack_normal* context, mmx_registers* mmxregs);
+    void handle(interrupt_stack* context, mmx_registers* mmxregs);
     void after_signal(signo_type signal);
 };
 

include/kernel/syscall.hpp

@@ -27,8 +27,8 @@
 namespace kernel {
 void init_syscall_table();
 
-void handle_syscall32(int no, interrupt_stack_normal* data, mmx_registers* mmxregs);
-void handle_syscall64(int no, interrupt_stack_normal* data, mmx_registers* mmxregs);
+void handle_syscall32(int no, interrupt_stack* data, mmx_registers* mmxregs);
+void handle_syscall64(int no, interrupt_stack* data, mmx_registers* mmxregs);
 
 namespace syscall {
 // in fileops.cc

src/asm/interrupt.s

@@ -1,34 +1,73 @@
 .text
 
+#define RAX     0x00
+#define RBX     0x08
+#define RCX     0x10
+#define RDX     0x18
+#define RDI     0x20
+#define RSI     0x28
+#define R8      0x30
+#define R9      0x38
+#define R10     0x40
+#define R11     0x48
+#define R12     0x50
+#define R13     0x58
+#define R14     0x60
+#define R15     0x68
+#define RBP     0x70
+#define INT_NO  0x78
+#define ERRCODE 0x80
+#define RIP     0x88
+#define CS      0x90
+#define FLAGS   0x98
+#define RSP     0xa0
+#define SS      0xa8
+
+.macro movcfi reg, offset
+	mov \reg, \offset(%rsp)
+	.cfi_rel_offset \reg, \offset
+.endm
+
+.macro movrst reg, offset
+	mov \offset(%rsp), \reg
+	.cfi_restore \reg
+.endm
+
 .extern after_ctx_switch
 .globl ISR_stub_restore
 
 ISR_stub:
+	.cfi_startproc
+	.cfi_def_cfa %rsp, 0x18
+
 	sub $0x78, %rsp
-	mov %rax,  0x00(%rsp)
-	mov %rbx,  0x08(%rsp)
-	mov %rcx,  0x10(%rsp)
-	mov %rdx,  0x18(%rsp)
-	mov %rdi,  0x20(%rsp)
-	mov %rsi,  0x28(%rsp)
-	mov %r8,   0x30(%rsp)
-	mov %r9,   0x38(%rsp)
-	mov %r10,  0x40(%rsp)
-	mov %r11,  0x48(%rsp)
-	mov %r12,  0x50(%rsp)
-	mov %r13,  0x58(%rsp)
-	mov %r14,  0x60(%rsp)
-	mov %r15,  0x68(%rsp)
-	mov %rbp,  0x70(%rsp)
-
-	mov 0x78(%rsp), %rax
+	.cfi_def_cfa_offset 0x90
+
+	movcfi %rax, RAX
+	movcfi %rbx, RBX
+	movcfi %rcx, RCX
+	movcfi %rdx, RDX
+	movcfi %rdi, RDI
+	movcfi %rsi, RSI
+	movcfi %r8,  R8
+	movcfi %r9,  R9
+	movcfi %r10, R10
+	movcfi %r11, R11
+	movcfi %r12, R12
+	movcfi %r13, R13
+	movcfi %r14, R14
+	movcfi %r15, R15
+	movcfi %rbp, RBP
+
+	mov INT_NO(%rsp), %rax
 	sub $ISR0, %rax
 	shr $3, %rax
-	mov %rax, 0x78(%rsp)
+	mov %rax, INT_NO(%rsp)
 
 	mov %rsp, %rbx
-	and $~0xf, %rsp
+	.cfi_def_cfa_register %rbx
 
+	and $~0xf, %rsp
 	sub $512, %rsp
 	fxsave (%rsp)
 
@@ -39,25 +78,29 @@ ISR_stub:
 ISR_stub_restore:
 	fxrstor (%rsp)
 	mov %rbx, %rsp
+	.cfi_def_cfa_register %rsp
+
+	movrst %rax, RAX
+	movrst %rbx, RBX
+	movrst %rcx, RCX
+	movrst %rdx, RDX
+	movrst %rdi, RDI
+	movrst %rsi, RSI
+	movrst %r8,  R8
+	movrst %r9,  R9
+	movrst %r10, R10
+	movrst %r11, R11
+	movrst %r12, R12
+	movrst %r13, R13
+	movrst %r14, R14
+	movrst %r15, R15
+	movrst %rbp, RBP
+
+	add $0x88, %rsp
+	.cfi_def_cfa_offset 0x08
 
-	mov 0x00(%rsp), %rax
-	mov 0x08(%rsp), %rbx
-	mov 0x10(%rsp), %rcx
-	mov 0x18(%rsp), %rdx
-	mov 0x20(%rsp), %rdi
-	mov 0x28(%rsp), %rsi
-	mov 0x30(%rsp), %r8
-	mov 0x38(%rsp), %r9
-	mov 0x40(%rsp), %r10
-	mov 0x48(%rsp), %r11
-	mov 0x50(%rsp), %r12
-	mov 0x58(%rsp), %r13
-	mov 0x60(%rsp), %r14
-	mov 0x68(%rsp), %r15
-	mov 0x70(%rsp), %rbp
-
-	mov 0x78(%rsp), %rsp
 	iretq
+	.cfi_endproc
 
 # parameters
 # #1: sp* current_task_sp
@@ -65,26 +108,33 @@ ISR_stub_restore:
 .globl asm_ctx_switch
 .type  asm_ctx_switch @function
 asm_ctx_switch:
+	.cfi_startproc
     pushf
+	.cfi_def_cfa_offset 0x10
+
 	sub $0x38, %rsp  # extra 8 bytes to align to 16 bytes
+	.cfi_def_cfa_offset 0x48
 
-    mov %rbx, 0x08(%rsp)
-	mov %rbp, 0x10(%rsp)
-	mov %r12, 0x18(%rsp)
-	mov %r13, 0x20(%rsp)
-	mov %r14, 0x28(%rsp)
-	mov %r15, 0x30(%rsp)
+	movcfi %rbx, 0x08
+	movcfi %rbp, 0x10
+	movcfi %r12, 0x18
+	movcfi %r13, 0x20
+	movcfi %r14, 0x28
+	movcfi %r15, 0x30
 
     push (%rdi) 	 # save sp of previous stack frame of current
 	                 # acts as saving bp
+	.cfi_def_cfa_offset 0x50
 
     mov %rsp, (%rdi) # save sp of current stack
     mov (%rsi), %rsp # load sp of target stack
 
     pop (%rsi)       # load sp of previous stack frame of target
 	                 # acts as restoring previous bp
+	.cfi_def_cfa_offset 0x48
 
 	pop %rax         # align to 16 bytes
+	.cfi_def_cfa_offset 0x40
 
 	call after_ctx_switch
 
@@ -96,20 +146,111 @@ asm_ctx_switch:
     mov 0x00(%rsp), %rbx
 
 	add $0x30, %rsp
+	.cfi_def_cfa_offset 0x10
+
     popf
+	.cfi_def_cfa_offset 0x08
 
     ret
+	.cfi_endproc
 
 .altmacro
-.macro build_isr name
+.macro build_isr_no_err name
 	.align 8
+	.globl ISR\name
+	.type  ISR\name @function
 	ISR\name:
+		.cfi_startproc
+		.cfi_def_cfa_offset 0x08
+
+		.cfi_same_value %rax
+		.cfi_same_value %rbx
+		.cfi_same_value %rcx
+		.cfi_same_value %rdx
+		.cfi_same_value %rdi
+		.cfi_same_value %rsi
+		.cfi_same_value %r8
+		.cfi_same_value %r9
+		.cfi_same_value %r10
+		.cfi_same_value %r11
+		.cfi_same_value %r12
+		.cfi_same_value %r13
+		.cfi_same_value %r14
+		.cfi_same_value %r15
+		.cfi_same_value %rbp
+
+		push %rbp # push placeholder for error code
+		.cfi_def_cfa_offset 0x10
+
 		call ISR_stub
+		.cfi_endproc
 .endm
 
-.set i, 0
+.altmacro
+.macro build_isr_err name
+	.align 8
+	.globl ISR\name
+	.type  ISR\name @function
+	ISR\name:
+		.cfi_startproc
+		.cfi_def_cfa_offset 0x10
+
+		.cfi_same_value %rax
+		.cfi_same_value %rbx
+		.cfi_same_value %rcx
+		.cfi_same_value %rdx
+		.cfi_same_value %rdi
+		.cfi_same_value %rsi
+		.cfi_same_value %r8
+		.cfi_same_value %r9
+		.cfi_same_value %r10
+		.cfi_same_value %r11
+		.cfi_same_value %r12
+		.cfi_same_value %r13
+		.cfi_same_value %r14
+		.cfi_same_value %r15
+		.cfi_same_value %rbp
+
+		call ISR_stub
+		.cfi_endproc
+.endm
+
+build_isr_no_err 0
+build_isr_no_err 1
+build_isr_no_err 2
+build_isr_no_err 3
+build_isr_no_err 4
+build_isr_no_err 5
+build_isr_no_err 6
+build_isr_no_err 7
+build_isr_err    8
+build_isr_no_err 9
+build_isr_err    10
+build_isr_err    11
+build_isr_err    12
+build_isr_err    13
+build_isr_err    14
+build_isr_no_err 15
+build_isr_no_err 16
+build_isr_err    17
+build_isr_no_err 18
+build_isr_no_err 19
+build_isr_no_err 20
+build_isr_err    21
+build_isr_no_err 22
+build_isr_no_err 23
+build_isr_no_err 24
+build_isr_no_err 25
+build_isr_no_err 26
+build_isr_no_err 27
+build_isr_no_err 28
+build_isr_err    29
+build_isr_err    30
+build_isr_no_err 31
+
+.set i, 32
 .rept 0x80+1
-	build_isr %i
+	build_isr_no_err %i
 	.set i, i+1
 .endr
 

src/kernel/interrupt.cpp

@@ -98,11 +98,9 @@ void kernel::irq::register_handler(int irqno, irq_handler_t handler)
     s_irq_handlers[irqno].emplace_back(std::move(handler));
 }
 
-static inline void fault_handler(
-        interrupt_stack_with_code* context,
-        mmx_registers*)
+static inline void fault_handler(interrupt_stack* context, mmx_registers*)
 {
-    switch (context->head.int_no) {
+    switch (context->int_no) {
     case 6:
     case 8: {
         if (!current_process->attr.system)
@@ -114,7 +112,6 @@ static inline void fault_handler(
     } break;
     case 14: {
         kernel::mem::paging::handle_page_fault(context->error_code);
-        context->head.int_no = (unsigned long)context + 0x88;
         return;
     } break;
     }
@@ -123,11 +120,9 @@ static inline void fault_handler(
     freeze();
 }
 
-static inline void irq_handler(
-        interrupt_stack_normal* context,
-        mmx_registers*)
+static inline void irq_handler(interrupt_stack* context, mmx_registers*)
 {
-    int irqno = context->head.int_no - 0x20;
+    int irqno = context->int_no - 0x20;
 
     constexpr uint8_t PIC_EOI = 0x20;
 
@@ -139,23 +134,12 @@ static inline void irq_handler(
         handler();
 }
 
-extern "C" void interrupt_handler(
-        interrupt_stack_head* context,
-        mmx_registers* mmxregs)
+extern "C" void interrupt_handler(interrupt_stack* context, mmx_registers* mmxregs)
 {
-    // interrupt is a fault
-    if (context->int_no < 0x20) {
-        auto* with_code = (interrupt_stack_with_code*)context;
-        fault_handler(with_code, mmxregs);
-    }
-    else if (context->int_no == 0x80) { // syscall by int 0x80
-        auto* normal = (interrupt_stack_normal*)context;
-        kernel::handle_syscall32(context->s_regs.rax, normal, mmxregs);
-        context->int_no = (unsigned long)context + 0x80;
-    }
-    else {
-        auto* normal = (interrupt_stack_normal*)context;
-        irq_handler(normal, mmxregs);
-        context->int_no = (unsigned long)context + 0x80;
-    }
+    if (context->int_no < 0x20) // interrupt is a fault
+        fault_handler(context, mmxregs);
+    else if (context->int_no == 0x80) // syscall by int 0x80
+        kernel::handle_syscall32(context->regs.rax, context, mmxregs);
+    else
+        irq_handler(context, mmxregs);
 }

src/kernel/process.cpp

@@ -24,6 +24,7 @@
 #include <kernel/task/thread.hpp>
 #include <kernel/user/thread_local.hpp>
 #include <kernel/vfs.hpp>
+#include <kernel/vfs/dentry.hpp>
 
 process::process(const process& parent, pid_t pid)
     : mms { parent.mms }, attr { parent.attr } , files { parent.files.copy() }
@@ -250,6 +251,8 @@ void NORETURN _kernel_init(kernel::mem::paging::pfn_t kernel_stack_pfn)
         int ret = rootfs->mount(mnt, "/dev/sda", "/mnt",
                 "fat32", MS_RDONLY | MS_NOATIME | MS_NODEV | MS_NOSUID, "ro,nodev");
         assert(ret == 0);
+
+        fs::d_put(mnt);
     }
 
     current_process->attr.system = 0;

src/kernel/signal.cpp

@@ -148,7 +148,7 @@ signo_type signal_list::pending_signal()
     return 0;
 }
 
-void signal_list::handle(interrupt_stack_normal* context, mmx_registers* mmxregs)
+void signal_list::handle(interrupt_stack* context, mmx_registers* mmxregs)
 {
     unsigned int signal;
     if (1) {
@@ -186,7 +186,7 @@ void signal_list::handle(interrupt_stack_normal* context, mmx_registers* mmxregs
 
     // save current interrupt context to 128 bytes above current user stack
     uintptr_t sp = (uintptr_t)context->rsp;
-    sp -= (128 + sizeof(mmx_registers) + sizeof(interrupt_stack_normal) + 16);
+    sp -= (128 + sizeof(mmx_registers) + sizeof(interrupt_stack) + 16);
     sp &= ~0xf;
 
     auto tmpsp = sp;
@@ -197,8 +197,8 @@ void signal_list::handle(interrupt_stack_normal* context, mmx_registers* mmxregs
 
     memcpy((void*)tmpsp, mmxregs, sizeof(mmx_registers));
     tmpsp += sizeof(mmx_registers); // mmx registers
-    memcpy((void*)tmpsp, context, sizeof(interrupt_stack_normal));
-    tmpsp += sizeof(interrupt_stack_normal); // context
+    memcpy((void*)tmpsp, context, sizeof(interrupt_stack));
+    tmpsp += sizeof(interrupt_stack); // context
 
     sp -= sizeof(void*);
     // signal handler return address: restorer

src/kernel/syscall.cpp

@@ -42,12 +42,12 @@
 
 #define NOT_IMPLEMENTED not_implemented(__FILE__, __LINE__)
 
-#define SYSCALL32_ARG1(type, name) type name = (type)((data)->head.s_regs.rbx)
-#define SYSCALL32_ARG2(type, name) type name = (type)((data)->head.s_regs.rcx)
-#define SYSCALL32_ARG3(type, name) type name = (type)((data)->head.s_regs.rdx)
-#define SYSCALL32_ARG4(type, name) type name = (type)((data)->head.s_regs.rsi)
-#define SYSCALL32_ARG5(type, name) type name = (type)((data)->head.s_regs.rdi)
-#define SYSCALL32_ARG6(type, name) type name = (type)((data)->head.s_regs.rbp)
+#define SYSCALL32_ARG1(type, name) type name = (type)((data)->regs.rbx)
+#define SYSCALL32_ARG2(type, name) type name = (type)((data)->regs.rcx)
+#define SYSCALL32_ARG3(type, name) type name = (type)((data)->regs.rdx)
+#define SYSCALL32_ARG4(type, name) type name = (type)((data)->regs.rsi)
+#define SYSCALL32_ARG5(type, name) type name = (type)((data)->regs.rdi)
+#define SYSCALL32_ARG6(type, name) type name = (type)((data)->regs.rbp)
 
 #define _DEFINE_SYSCALL32_ARGS1(type, name, ...) \
 SYSCALL32_ARG1(type, name); \
@@ -83,7 +83,7 @@ SYSCALL32_ARG6(type, name);
     kernel::syscall::do_ ## name ( __VA_OPT__(_DEFINE_SYSCALL32_END_PARAMS1(__VA_ARGS__)) )
 
 #define DEFINE_SYSCALL32_TO(name, to, ...) \
-static uint32_t _syscall32_##name(interrupt_stack_normal* data, mmx_registers* mmxregs) \
+static uint32_t _syscall32_##name(interrupt_stack* data, mmx_registers* mmxregs) \
 { \
     (void)data, (void)mmxregs; \
     __VA_OPT__(_DEFINE_SYSCALL32_ARGS1(__VA_ARGS__);) \
@@ -93,7 +93,7 @@ static uint32_t _syscall32_##name(interrupt_stack_normal* data, mmx_registers* m
 #define DEFINE_SYSCALL32(name, ...) DEFINE_SYSCALL32_TO(name, name __VA_OPT__(,) __VA_ARGS__)
 
 #define DEFINE_SYSCALL32_NORETURN(name, ...) \
-[[noreturn]] static uint32_t _syscall32_##name(interrupt_stack_normal* data, mmx_registers* mmxregs) \
+[[noreturn]] static uint32_t _syscall32_##name(interrupt_stack* data, mmx_registers* mmxregs) \
 { \
     (void)data, (void)mmxregs; \
     __VA_OPT__(_DEFINE_SYSCALL32_ARGS1(__VA_ARGS__);) \
@@ -101,7 +101,7 @@ static uint32_t _syscall32_##name(interrupt_stack_normal* data, mmx_registers* m
 }
 
 struct syscall_handler_t {
-    uint32_t (*handler)(interrupt_stack_normal*, mmx_registers*);
+    uint32_t (*handler)(interrupt_stack*, mmx_registers*);
     const char* name;
 };
 
@@ -190,7 +190,7 @@ DEFINE_SYSCALL32_TO(clock_gettime64, clock_gettime,
         clockid_t, clk_id, timespec __user*, tp)
 
 extern "C" void NORETURN ISR_stub_restore();
-static uint32_t _syscall32_fork(interrupt_stack_normal* data, mmx_registers* mmxregs)
+static uint32_t _syscall32_fork(interrupt_stack* data, mmx_registers* mmxregs)
 {
     auto& newproc = procs->copy_from(*current_process);
     auto [ iter_newthd, inserted ] = newproc.thds.emplace(*current_thread, newproc.pid);
@@ -201,34 +201,13 @@ static uint32_t _syscall32_fork(interrupt_stack_normal* data, mmx_registers* mmx
     kernel::task::dispatcher::enqueue(newthd);
 
     auto newthd_prev_sp = newthd->kstack.sp;
+    assert(!(newthd_prev_sp & 0xf));
 
-    // create fake interrupt stack
-    newthd->kstack.pushq(data->ss);
-    newthd->kstack.pushq(data->rsp);
-    newthd->kstack.pushq(data->flags);
-    newthd->kstack.pushq(data->cs);
-    newthd->kstack.pushq(data->v_rip);
-    auto cur_sp = newthd->kstack.sp;
-
-    newthd->kstack.pushq(0); // 0 for 16 bytes alignment
-    newthd->kstack.pushq(cur_sp);
-    newthd->kstack.pushq(data->head.s_regs.rbp);
-    newthd->kstack.pushq(data->head.s_regs.r15);
-    newthd->kstack.pushq(data->head.s_regs.r14);
-    newthd->kstack.pushq(data->head.s_regs.r13);
-    newthd->kstack.pushq(data->head.s_regs.r12);
-    newthd->kstack.pushq(data->head.s_regs.r11);
-    newthd->kstack.pushq(data->head.s_regs.r10);
-    newthd->kstack.pushq(data->head.s_regs.r9);
-    newthd->kstack.pushq(data->head.s_regs.r8);
-    newthd->kstack.pushq(data->head.s_regs.rsi);
-    newthd->kstack.pushq(data->head.s_regs.rdi);
-    newthd->kstack.pushq(data->head.s_regs.rdx);
-    newthd->kstack.pushq(data->head.s_regs.rcx);
-    newthd->kstack.pushq(data->head.s_regs.rbx);
-    newthd->kstack.pushq(0); // rax: return value
-
-    cur_sp = newthd->kstack.sp;
+    newthd->kstack.sp -= sizeof(interrupt_stack);
+    memcpy((void*)(newthd->kstack.sp), data, sizeof(interrupt_stack));
+
+    ((interrupt_stack*)(newthd->kstack.sp))->regs.rax = 0; // return value
+    auto isr_restore_sp = newthd->kstack.sp;
 
     newthd->kstack.sp -= sizeof(mmx_registers);
     memcpy((void*)(newthd->kstack.sp), mmxregs, sizeof(mmx_registers));
@@ -242,7 +221,7 @@ static uint32_t _syscall32_fork(interrupt_stack_normal* data, mmx_registers* mmx
     newthd->kstack.pushq(0);              // r13
     newthd->kstack.pushq(0);              // r12
     newthd->kstack.pushq(0);              // rbp
-    newthd->kstack.pushq(cur_sp);         // rbx
+    newthd->kstack.pushq(isr_restore_sp); // rbx
     newthd->kstack.pushq(0);              // 0 for alignment
     newthd->kstack.pushq(newthd_prev_sp); // previous sp
 
@@ -250,7 +229,7 @@ static uint32_t _syscall32_fork(interrupt_stack_normal* data, mmx_registers* mmx
     return newproc.pid;
 }
 
-static uint32_t _syscall32_llseek(interrupt_stack_normal* data, mmx_registers*)
+static uint32_t _syscall32_llseek(interrupt_stack* data, mmx_registers*)
 {
     SYSCALL32_ARG1(unsigned int, fd);
     SYSCALL32_ARG2(unsigned long, offset_high);
@@ -273,7 +252,7 @@ static uint32_t _syscall32_llseek(interrupt_stack_normal* data, mmx_registers*)
     return 0;
 }
 
-static uint32_t _syscall32_readv(interrupt_stack_normal* data, mmx_registers*)
+static uint32_t _syscall32_readv(interrupt_stack* data, mmx_registers*)
 {
     SYSCALL32_ARG1(int, fd);
     SYSCALL32_ARG2(const types::iovec32 __user*, _iov);
@@ -294,7 +273,7 @@ static uint32_t _syscall32_readv(interrupt_stack_normal* data, mmx_registers*)
     return kernel::syscall::do_readv(fd, iov.data(), iovcnt);
 }
 
-static uint32_t _syscall32_writev(interrupt_stack_normal* data, mmx_registers*)
+static uint32_t _syscall32_writev(interrupt_stack* data, mmx_registers*)
 {
     SYSCALL32_ARG1(int, fd);
     SYSCALL32_ARG2(const types::iovec32 __user*, _iov);
@@ -316,13 +295,13 @@ static uint32_t _syscall32_writev(interrupt_stack_normal* data, mmx_registers*)
 }
 
 [[noreturn]] static uint32_t _syscall32_exit_group(
-        interrupt_stack_normal* data, mmx_registers* mmxregs)
+        interrupt_stack* data, mmx_registers* mmxregs)
 {
     // we implement exit_group as exit for now
     _syscall32_exit(data, mmxregs);
 }
 
-static uint32_t _syscall32_execve(interrupt_stack_normal* data, mmx_registers*)
+static uint32_t _syscall32_execve(interrupt_stack* data, mmx_registers*)
 {
     SYSCALL32_ARG1(const char __user*, exec);
     SYSCALL32_ARG2(const uint32_t __user*, argv);
@@ -355,7 +334,7 @@ static uint32_t _syscall32_execve(interrupt_stack_normal* data, mmx_registers*)
     return retval.status;
 }
 
-static uint32_t _syscall32_wait4(interrupt_stack_normal* data, mmx_registers* mmxregs)
+static uint32_t _syscall32_wait4(interrupt_stack* data, mmx_registers* mmxregs)
 {
     SYSCALL32_ARG4(void __user*, rusage);
 
@@ -366,7 +345,7 @@ static uint32_t _syscall32_wait4(interrupt_stack_normal* data, mmx_registers* mm
     return _syscall32_waitpid(data, mmxregs);
 }
 
-void kernel::handle_syscall32(int no, interrupt_stack_normal* data, mmx_registers* mmxregs)
+void kernel::handle_syscall32(int no, interrupt_stack* data, mmx_registers* mmxregs)
 {
     if (no >= SYSCALL_HANDLERS_SIZE || !syscall_handlers[no].handler) {
         kmsgf("[kernel] syscall %d(%x) isn't implemented", no, no);
@@ -380,15 +359,15 @@ void kernel::handle_syscall32(int no, interrupt_stack_normal* data, mmx_register
     // kmsgf_debug("[kernel:debug] (pid\t%d) %s()", current_process->pid, syscall_handlers[no].name);
 
     asm volatile("sti");
-    data->head.s_regs.rax = syscall_handlers[no].handler(data, mmxregs);
-    data->head.s_regs.r8 = 0;
-    data->head.s_regs.r9 = 0;
-    data->head.s_regs.r10 = 0;
-    data->head.s_regs.r11 = 0;
-    data->head.s_regs.r12 = 0;
-    data->head.s_regs.r13 = 0;
-    data->head.s_regs.r14 = 0;
-    data->head.s_regs.r15 = 0;
+    data->regs.rax = syscall_handlers[no].handler(data, mmxregs);
+    data->regs.r8 = 0;
+    data->regs.r9 = 0;
+    data->regs.r10 = 0;
+    data->regs.r11 = 0;
+    data->regs.r12 = 0;
+    data->regs.r13 = 0;
+    data->regs.r14 = 0;
+    data->regs.r15 = 0;
 
     if (current_thread->signals.pending_signal())
         current_thread->signals.handle(data, mmxregs);