syscall_entry.asm

; syscall_entry.asm - SYSCALL instruction handler + userspace entry/exit for Pactor64

;

; When the CPU executes SYSCALL:

;   RCX = return address (user RIP)

;   R11 = saved RFLAGS

;   RIP = MSR_LSTAR

;   CS = MSR_STAR[63:48]  (= 0x08)

;   SS = MSR_STAR[63:48] + 8  (= 0x10)

;

; SYSRET (with REX.W):

;   RIP = RCX

;   RFLAGS = R11

;   CS = MSR_STAR[47:32] | 3  (= 0x1B)

;   SS = (MSR_STAR[47:32] + 8) | 3  (= 0x23)

;

; IMPORTANT: SYSCALL only clobbers RCX and R11. All other GPRs must be

; preserved across the syscall handler for the user program to work correctly.

bits 64

section .text

extern syscall_dispatch

global syscall_entry

global enter_userspace

global return_to_kernel

; ============================================================================

; syscall_entry — SYSCALL handler entry point

; ============================================================================

syscall_entry:

    ; Save user RSP, RFLAGS (from R11), RIP (from RCX)

    mov [rel user_rsp], rsp

    mov [rel user_rflags], r11

    mov [rel user_rcx], rcx          ; User RIP (return address)

    ; Switch to kernel stack

    mov rsp, syscall_stack_top

    ; === Save ALL user registers ===

    ; SYSCALL clobbers RCX and R11, but all other GPRs must be preserved.

    ; We save everything so we can restore after dispatch.

    push rax                         ; syscall number / return value

    push rbx

    push rcx                         ; user RIP (already saved, but save for callee-saved)

    push rdx                         ; arg3

    push rsi                         ; arg2

    push rdi                         ; arg1

    push rbp

    push r8                          ; arg5

    push r9                          ; arg6

    push r10                         ; arg4

    push r12

    push r13

    push r14

    push r15

    ; === Map Linux syscall ABI → C calling convention ===

    ; Linux SYSCALL receives:

    ;   rax = syscall number

    ;   rdi = arg1, rsi = arg2, rdx = arg3

    ;   r10 = arg4, r8  = arg5, r9  = arg6

    ;

    ; C calling convention (for syscall_dispatch):

    ;   rdi = num, rsi = arg1, rdx = arg2, rcx = arg3

    ;   r8  = arg4, r9  = arg5

    ;

    ; Move in reverse order to avoid clobbering values we still need:

    mov r9, r8                       ; arg5 → C arg6 (r9)

    mov r8, r10                      ; arg4 → C arg5 (r8)

    mov rcx, rdx                     ; arg3 → C arg4 (rcx)

    mov rdx, rsi                     ; arg2 → C arg3 (rdx)

    mov rsi, rdi                     ; arg1 → C arg2 (rsi)

    mov rdi, rax                     ; num  → C arg1 (rdi)

    ; Check if this is exit(60) BEFORE calling dispatch — handle in asm

    cmp rdi, 60             ; SYS_EXIT?

    jne .not_exit

    ; Exit: print message and return to kernel

    ; rsi = exit status

    jmp .return_to_kernel

.not_exit:

    call syscall_dispatch

    ; Return value is in rax — save it

    mov [rel syscall_retval], rax

    ; === Restore ALL user registers ===

    ; Restore in reverse order (except rax — we'll set it to the return value)

    pop r15

    pop r14

    pop r13

    pop r12

    pop r10

    pop r9

    pop r8

    pop rbp

    pop rdi

    pop rsi

    pop rdx

    pop rcx                          ; original user RCX (will be overwritten by SYSRET)

    pop rbx

    ; Don't pop rax yet — we need the return value

    ; Set return value

    mov rax, [rel syscall_retval]

    ; Restore user RSP and RFLAGS for SYSRET

    mov rsp, [rel user_rsp]

    mov r11, [rel user_rflags]

    mov rcx, [rel user_rcx]

    ; Enable interrupts on return

    or r11, (1 << 9)                 ; Set IF bit

    ; SYSRET returns to RCX:RIP with R11:RFLAGS

    o64 sysret

; ============================================================================

; .return_to_kernel — exit syscall path

;   Clean up syscall stack and return to shell.

;   Called when syscall_dispatch returns -999 (exit).

; ============================================================================

.return_to_kernel:

    ; Clean up the 14 saved registers from the syscall stack

    add rsp, 14 * 8

    ; Jump to return_to_kernel which restores kernel RSP and rets

    jmp return_to_kernel

; ============================================================================

; enter_userspace(uint64_t user_rip, uint64_t user_rsp)

;   Jump from ring 0 to ring 3 using IRETQ.

;   rdi = user RIP

;   rsi = user RSP

; ============================================================================

enter_userspace:

    ; Save kernel state for return_to_kernel

    mov [rel saved_kernel_rsp], rsp

    mov [rel saved_kernel_rbp], rbp

    ; Disable interrupts during IRETQ frame setup

    cli

    ; Use SYSRET to enter ring 3 — set RSP manually before SYSRET

    mov rsp, rsi                     ; User RSP

    mov rcx, rdi                     ; User RIP (SYSRET sets RIP=RCX)

    mov r11, 0x202                   ; User RFLAGS (IF=1, bit1=1)

    o64 sysret

return_to_kernel:

    cli

    ; Restore kernel segments

    push rax

    mov ax, 0x10

    mov ds, ax

    mov es, ax

    mov fs, ax

    mov gs, ax

    pop rax

    ; Get return address and target RSP

    mov r8, [rel saved_kernel_rsp]

    mov r9, [r8]        ; return address

    add r8, 8           ; RSP past the return addr

    mov rbp, [rel saved_kernel_rbp]

    ; Build IRETQ on syscall stack (clean CS/SS transition)

    mov rsp, syscall_stack_top

    push qword 0x10     ; SS = kernel data

    push r8              ; RSP = shell stack

    pushfq

    or qword [rsp], 0x200 ; IF

    push qword 0x08     ; CS = kernel code

    push r9              ; RIP = return address

    iretq

    ; Restore kernel segment registers (user code set them to ring 3 values)

    push rax

    mov ax, 0x10

    mov ds, ax

    mov es, ax

    mov fs, ax

    mov gs, ax

    pop rax

    pop rax

    sti

    ret

; ============================================================================

; Data section — saved state

; ============================================================================

section .data

align 8

user_rsp:           dq 0

user_rflags:        dq 0

user_rcx:           dq 0

saved_kernel_rsp:   dq 0

saved_kernel_rbp:   dq 0

syscall_retval:     dq 0

; ============================================================================

; BSS — dedicated syscall stack (8KB)

; ============================================================================

section .bss

align 16

    resb 8192                        ; 8KB syscall stack

syscall_stack_top: