Kernel: Support syscall instruction

Author: fido2020

Kernel/CMakeLists.txt

@@ -17,6 +17,7 @@ endif()
 
 include_directories(include)
 include_directories($ENV{LEMON_BUILDROOT}/Thirdparty/frigg/include)
+include_directories($ENV{LEMON_BUILDROOT}/Thirdparty/cxxshim/stage2/include)
 
 if("${LEMON_ARCH}" STREQUAL "x86_64")
     include_directories(include/Arch/x86_64)
@@ -135,6 +136,7 @@ set(KERNEL_SRC_x86_64
     src/Arch/x86_64/Memcpy.asm
     src/Arch/x86_64/SignalTrampoline.asm
     src/Arch/x86_64/SMPTrampoline.asm
+    src/Arch/x86_64/Syscall.asm
     src/Arch/x86_64/TSS.asm
 )
 

Kernel/include/Arch/x86_64/CPU.h

@@ -19,18 +19,34 @@ typedef struct {
 } __attribute__((packed)) idt_ptr_t;
 
 struct CPU {
-    CPU* self;
+    CPU* self; // Pointer to this struct
     uint64_t id; // APIC/CPU id
+    Thread* currentThread = nullptr; // Current executing thread
+    // Scratch register, it is used by the syscall handler
+    // as it cannot touch any registers without saving them
+    uint64_t scratch;
+    tss_t tss __attribute__((aligned(16)));
+
     void* gdt;   // GDT
     gdt_ptr_t gdtPtr;
     idt_ptr_t idtPtr;
-    Thread* currentThread = nullptr;
+
     Thread* idleThread = nullptr;
     Process* idleProcess;
     volatile int runQueueLock = 0;
     FastList<Thread*>* runQueue;
-    tss_t tss __attribute__((aligned(16)));
-};
+} __attribute__((packed));
+
+#define CPU_LOCAL_SELF 0x0
+#define CPU_LOCAL_ID 0x8
+#define CPU_LOCAL_THREAD 0x10
+#define CPU_LOCAL_SCRATCH 0x18
+#define CPU_LOCAL_TSS 0x20
+#define CPU_LOCAL_TSS_RSP0 (CPU_LOCAL_TSS + 0x4)
+
+static_assert(offsetof(CPU, tss) == CPU_LOCAL_TSS);
+static_assert(offsetof(CPU, tss) + offsetof(tss_t, rsp0) == CPU_LOCAL_TSS_RSP0);
+static_assert(offsetof(CPU, currentThread) == CPU_LOCAL_THREAD);
 
 enum {
     CPUID_ECX_SSE3 = 1 << 0,
@@ -185,13 +201,11 @@ static ALWAYS_INLINE Thread* GetCurrentThread() {
     Thread* ret;
     int intEnable = CheckInterrupts();
     asm("cli");
-    asm volatile("swapgs; movq %%gs:48, %0; swapgs;"
+    asm volatile("swapgs; movq %%gs:16, %0; swapgs;"
                  : "=r"(ret)); // CPU info is 16-byte aligned as per liballoc alignment
     if (intEnable)
         asm("sti");
     return ret;
-
-    static_assert(offsetof(CPU, currentThread) == 48);
 }
 
 static ALWAYS_INLINE void DisableInterrupts() {

Kernel/include/Arch/x86_64/Scheduler.h

@@ -18,8 +18,8 @@
 
 #define KERNEL_CS 0x08
 #define KERNEL_SS 0x10
-#define USER_CS 0x1B
-#define USER_SS 0x23
+#define USER_SS 0x1B
+#define USER_CS 0x23
 
 namespace Scheduler {
 class ProcessStateThreadBlocker;

Kernel/include/Arch/x86_64/Thread.h

@@ -67,7 +67,10 @@ struct Thread {
     uint32_t ticksSinceBalance = 0; // Ticks since run queue rebalance
     uint32_t ticksGivenSinceBalance = 0;
     RegisterContext registers;   // Registers
-    RegisterContext lastSyscall; // Last system call
+    struct {
+        RegisterContext regs; // Last system call
+        long result;
+    } lastSyscall;
     void* fxState;               // State of the extended registers
 
     int cpu = -1; // CPU the thread is scheduled on

Kernel/src/Arch/x86_64/SMP.cpp

@@ -32,6 +32,8 @@ volatile bool doneInit = false;
 extern gdt_ptr_t GDT64Pointer64;
 extern idt_ptr_t idtPtr;
 
+void syscall_init();
+
 namespace SMP {
 CPU* cpus[256];
 unsigned processorCount = 1;
@@ -60,6 +62,8 @@ void SMPEntry(uint16_t id) {
 
     doneInit = true;
 
+    syscall_init();
+
     asm("sti");
 
     for (;;)

Kernel/src/Arch/x86_64/SMPTrampoline.asm

@@ -27,6 +27,7 @@ mov cr3, eax
 mov ecx, 0xC0000080 ; EFER Model Specific Register
 rdmsr               ; Read from the MSR 
 or eax, 1 << 8
+or eax, 1 ; syscall enable
 wrmsr
 
 mov eax, cr0

Kernel/src/Arch/x86_64/Syscall.asm

@@ -0,0 +1,73 @@
+global syscall_entry
+
+extern SyscallHandler
+
+section .text
+
+USER_SS equ 0x1B
+USER_CS equ 0x23
+
+CPU_LOCAL_SELF equ 0x0
+CPU_LOCAL_ID equ 0x8
+CPU_LOCAL_THREAD equ 0x10
+CPU_LOCAL_SCRATCH equ 0x18
+CPU_LOCAL_TSS equ 0x20
+CPU_LOCAL_TSS_RSP0 equ (CPU_LOCAL_TSS + 0x4)
+
+syscall_entry:
+    swapgs
+    mov qword [gs:CPU_LOCAL_SCRATCH], rsp
+    mov rsp, qword [gs:CPU_LOCAL_TSS_RSP0]
+    push USER_SS
+    push qword [gs:CPU_LOCAL_SCRATCH]
+    swapgs
+    push r11
+    push USER_CS
+    push rcx
+    push 0
+
+    push rax
+    push rbx
+    push rcx
+    push rdx
+    push rsi
+    push rdi
+    push rbp
+    push r8
+    push r9
+    push r10
+    push r11
+    push r12
+    push r13
+    push r14
+    push r15
+
+    mov rdi, rsp
+    xor rbp, rbp
+    call SyscallHandler
+
+    pop r15
+    pop r14
+    pop r13
+    pop r12
+    pop r11
+    pop r10
+    pop r9
+    pop r8
+    pop rbp
+    pop rdi
+    pop rsi
+    pop rdx
+    pop rcx
+    pop rbx
+    pop rax
+
+    add rsp, 8
+    ; Get user RIP
+    pop rcx
+    add rsp, 8
+    ; User RFLAGS
+    pop r11
+    ; Get user RSP
+    pop rsp
+    o64 sysret

Kernel/src/Arch/x86_64/Syscalls.cpp

@@ -4036,16 +4036,44 @@ syscall_t syscalls[NUM_SYSCALLS]{
 // clang-format on
 
 void DumpLastSyscall(Thread* t) {
-    RegisterContext& lastSyscall = t->lastSyscall;
+    RegisterContext& lastSyscall = t->lastSyscall.regs;
     Log::Info("Last syscall:\nCall: %d, arg0: %i (%x), arg1: %i (%x), arg2: %i (%x), arg3: %i (%x), arg4: %i (%x), "
-              "arg5: %i (%x)",
+              "arg5: %i (%x) result: %i (%x)",
               lastSyscall.rax, SC_ARG0(&lastSyscall), SC_ARG0(&lastSyscall), SC_ARG1(&lastSyscall),
               SC_ARG1(&lastSyscall), SC_ARG2(&lastSyscall), SC_ARG2(&lastSyscall), SC_ARG3(&lastSyscall),
               SC_ARG3(&lastSyscall), SC_ARG4(&lastSyscall), SC_ARG4(&lastSyscall), SC_ARG5(&lastSyscall),
-              SC_ARG5(&lastSyscall));
+              SC_ARG5(&lastSyscall), t->lastSyscall.result, t->lastSyscall.result);
+}
+
+#define MSR_STAR 0xC000'0081
+#define MSR_LSTAR 0xC000'0082
+#define MSR_CSTAR 0xC000'0083
+#define MSR_SFMASK 0xC000'0084
+
+extern "C" void syscall_entry();
+
+void syscall_init() {
+    uint64_t low = ((uint64_t)syscall_entry) & 0xFFFFFFFF;
+    uint64_t high = ((uint64_t)syscall_entry) >> 32;
+    asm volatile("wrmsr" ::"a"(low), "d"(high), "c"(MSR_LSTAR));
+
+    // User CS selector set to this field + 16, SS this field + 8 
+    uint32_t sysretSelectors = USER_SS - 8;
+    // When syscall is called, CS set to field, SS this field + 8
+    uint32_t syscallSelectors = KERNEL_CS;
+    asm volatile("wrmsr" ::"a"(0), "d"((sysretSelectors << 16) | syscallSelectors), "c"(MSR_STAR));
+    // SFMASK masks flag values
+    // mask everything except reserved flags to disable IRQs when syscall is called
+    asm volatile("wrmsr" ::"a"(0x3F7FD5U), "d"(0), "c"(MSR_SFMASK));
+
+    asm volatile("rdmsr" : "=a"(low), "=d"(high) : "c"(0xC0000080));
+    low |= 1; // SCE (syscall enable)
+    asm volatile("wrmsr" :: "a"(low), "d"(high), "c"(0xC0000080));
 }
 
 extern "C" void SyscallHandler(RegisterContext* regs) {
+    assert(!CheckInterrupts());
+
     if (__builtin_expect(regs->rax >= NUM_SYSCALLS || !syscalls[regs->rax],
                          0)) { // If syscall is non-existant then return
         regs->rax = -ENOSYS;
@@ -4069,15 +4097,21 @@ extern "C" void SyscallHandler(RegisterContext* regs) {
 
 #ifdef KERNEL_DEBUG
     if (debugLevelSyscalls >= DebugLevelNormal) {
-        thread->lastSyscall = *regs;
+        thread->lastSyscall.regs = *regs;
     }
 #endif
 
     regs->rax = syscalls[regs->rax](regs); // Call syscall
 
+#ifdef KERNEL_DEBUG
+    if (debugLevelSyscalls >= DebugLevelNormal) {
+        thread->lastSyscall.result = regs->rax;
+    }
+#endif
+
     IF_DEBUG((debugLevelSyscalls >= DebugLevelVerbose), {
         if (regs->rax < 0)
-            Log::Info("Syscall %d exiting with value %d", thread->lastSyscall.rax, regs->rax);
+            Log::Info("Syscall %d exiting with value %d", thread->lastSyscall.regs.rax, regs->rax);
     });
 
     if (__builtin_expect(thread->pendingSignals & (~thread->EffectiveSignalMask()), 0)) {

Kernel/src/Kernel.cpp

@@ -40,6 +40,8 @@ void IdleProcess() {
     }
 }
 
+void syscall_init();
+
 void KernelProcess() {
     NVMe::Initialize();
     USB::XHCIController::Initialize();
@@ -225,6 +227,8 @@ extern "C" [[noreturn]] void kmain() {
 
     Log::Info("OK");
 
+    syscall_init();
+
     Log::Info("Initializing Task Scheduler...");
     Scheduler::Initialize();
     for (;;)

System/CMakeLists.txt

@@ -36,7 +36,7 @@ set(lemonwm_SRC
 
 add_link_options(-llemon)
 
-add_executable(lemond.lef ${lemond_SRC})
+add_executable(init.lef ${lemond_SRC})
 add_executable(netgov.lef ${netgov_SRC})
 add_executable(kmod.lef ${kmod_SRC})
 
@@ -46,5 +46,5 @@ target_link_options(login.lef PUBLIC -llemongui)
 add_executable(lemonwm.lef ${lemonwm_SRC})
 target_link_options(lemonwm.lef PUBLIC -llemongui)
 
-install(TARGETS lemond.lef netgov.lef login.lef kmod.lef lemonwm.lef
+install(TARGETS init.lef netgov.lef login.lef kmod.lef lemonwm.lef
     RUNTIME DESTINATION lemon)