user program (still many #PF)

include/arch/x86.h

@@ -10,7 +10,6 @@ void wrmsr(uint32_t msr, uint64_t value);
 bool x86_has_msr();
 void x86_arch_init();
 
-
 void x86_cpu_identification();
 int cpuid_get_vendor_string(char* str);
 

include/config.h

@@ -43,6 +43,7 @@
 /* user */
 #define USER_STACK_TOP 0x80000000
 #define USER_STACK_PAGES 16 // 16*4096 = 64kb
+#define USER_CODE_START 0x400000 // like linux
 
 /* paging */
 #define PAGING_MAX_PHYS 0x200000000

include/mem/vmm.h

@@ -22,6 +22,8 @@ void vmm_unmap(uint64_t* pml4, uint64_t virt);
 void* vmm_map(uint64_t* pml4, uint64_t virt, uint64_t flags);
 uint64_t* vmm_create_address_space();
 uint64_t vmm_virt_to_phys(uint64_t* pml4, uint64_t virt);
+uintptr_t vmm_alloc_user_stack(uint64_t* pml4);
+uintptr_t vmm_alloc_user_code(uint64_t* pml4, void* code_addr, uint64_t code_size);
 
 #define VMM_USER_SPACE_START 0x0000000000001000 
 #define VMM_USER_SPACE_END   0x00007FFFFFFFF000

include/sched/process.h

@@ -10,6 +10,7 @@
 #include <stddef.h>
 #include <config.h>
 #include <stdint.h>
+#include <limine.h>
 
 typedef enum {
     READY,
@@ -37,4 +38,6 @@ void process_exit(void);
 
 void process_display_list(struct process* processes_list);
 
+void process_create_user(struct limine_file* file);
+
 #endif

src/arch/x86/idt.c

@@ -77,7 +77,7 @@ void idt_init()
         idt_set_entry(i, vector_0_handler + (i*16), 0);
     }
 
-    idt_set_entry(0x80, vector_128_handler, 0);
+    idt_set_entry(0x80, vector_128_handler, 3);
 
     idt_load(&idt);
     DEBUG("IDT initialized");
@@ -264,9 +264,10 @@ struct cpu_status* interrupt_dispatch(struct cpu_status* context)
             // Send an EOI so that we can continue having interrupts
             outb(0x20, 0x20);
 
-            if (ticks % SCHEDULER_QUANTUM == 0) {
+            // Scheduler is temporarily disabled to test user trampoline
+            /* if (ticks % SCHEDULER_QUANTUM == 0) {
                 return scheduler_schedule(context);
-            }
+            } */
 
             break;
 

src/arch/x86/init.c

@@ -45,7 +45,7 @@ static void x86_enable_fpu()
 	__asm__ volatile("mov %%cr4, %0" : "=r"(cr4));
 	cr4 |= 0x200;
 	__asm__ volatile("mov %0, %%cr4" :: "r"(cr4));
-    uint16_t cw = 0x37F;
+    uint16_t cw = 0x37F; // control word
     asm volatile("fldcw %0" :: "m"(cw));
 }
 

src/kmain.c

@@ -124,15 +124,16 @@ void kmain()
 
 	if (!boot_ctx.module) {
 		panic(NULL, "could not load 'hello' executable :(");
-	}
+	} 
-
-	if (boot_ctx.module->module_count == 1) {
-		file = boot_ctx.module->modules[0];
-		DEBUG("file: addr=%p size=%u", file->address, file->size);
-	}
 
 	printf(PEPPEROS_SPLASH);
 	init.all = true;
 
+	if (boot_ctx.module->module_count == 1) {
+		file = boot_ctx.module->modules[0];
+		DEBUG("file: addr=%p size=%u", file->address, file->size);
+		process_create_user(file);
+	}
+
 	idle();
 }

src/mem/paging.c

@@ -99,30 +99,46 @@ void paging_map_page(uint64_t* root_table, uint64_t virt, uint64_t phys, uint64_
 
     uint64_t *pdpt, *pd, *pt;
 
+    // Any parent entry on a userspace mapping must also carry PTE_USER,
+    // otherwise CPL3 accesses fault even if the final PTE is user.
+    uint64_t parent_flags = PTE_PRESENT | PTE_WRITABLE;
+    if (flags & PTE_USER) {
+        parent_flags |= PTE_USER;
+    }
+
     // PML4
     // If the entry at index is not present, allocate enough space for it
     // then populate the entry with correct addr + flags
     if (!(root_table[pml4_i] & PTE_PRESENT)) {
         pdpt = alloc_page_table();
-        root_table[pml4_i] = VIRT_TO_PHYS(pdpt) | PTE_PRESENT | PTE_WRITABLE;
+        root_table[pml4_i] = VIRT_TO_PHYS(pdpt) | parent_flags;
     } else {
         pdpt = (uint64_t *)PHYS_TO_VIRT(root_table[pml4_i] & PTE_ADDR_MASK);
+        if (flags & PTE_USER) {
+            root_table[pml4_i] |= PTE_USER;
+        }
     }
 
     // PDPT: same here
     if (!(pdpt[pdpt_i] & PTE_PRESENT)) {
         pd = alloc_page_table();
-        pdpt[pdpt_i] = VIRT_TO_PHYS(pd) | PTE_PRESENT | PTE_WRITABLE;
+        pdpt[pdpt_i] = VIRT_TO_PHYS(pd) | parent_flags;
     } else {
         pd = (uint64_t *)PHYS_TO_VIRT(pdpt[pdpt_i] & PTE_ADDR_MASK);
+        if (flags & PTE_USER) {
+            pdpt[pdpt_i] |= PTE_USER;
+        }
     }
 
     // PD: and here
     if (!(pd[pd_i] & PTE_PRESENT)) {
         pt = alloc_page_table();
-        pd[pd_i] = VIRT_TO_PHYS(pt) | PTE_PRESENT | PTE_WRITABLE;
+        pd[pd_i] = VIRT_TO_PHYS(pt) | parent_flags;
     } else {
         pt = (uint64_t *)PHYS_TO_VIRT(pd[pd_i] & PTE_ADDR_MASK);
+        if (flags & PTE_USER) {
+            pd[pd_i] |= PTE_USER;
+        }
     }
 
     // PT: finally, populate the page table entry

src/mem/vmm.c

@@ -250,6 +250,17 @@ uintptr_t vmm_alloc_user_stack(uint64_t* pml4)
     return stack_top;
 }
 
+uintptr_t vmm_alloc_user_code(uint64_t* pml4, void* code_addr, uint64_t code_size)
+{
+    uintptr_t code_start = USER_CODE_START;
+
+    for (size_t i=code_start; i<code_start+code_size; i+=PAGE_SIZE) {
+        vmm_map(pml4, i, PTE_PRESENT | PTE_WRITABLE | PTE_USER);
+    }
+    
+    return code_start;
+}
+
 void vmm_init()
 {
     // NO U

src/sched/process.c

@@ -4,6 +4,8 @@
  * @license GPL-3.0-only
  */
 
+#include "mem/paging.h"
+#include "mem/vmm.h"
 #include <stddef.h>
 #include <sched/process.h>
 #include <mem/kheap.h>
@@ -13,6 +15,7 @@
 #include <config.h>
 #include <io/serial/serial.h>
 #include <io/term/flanterm.h>
+#include <mem/utils.h>
 
 extern struct flanterm_context* ft_ctx;
 
@@ -196,4 +199,59 @@ void process_exit()
     for (;;) {
         asm("hlt");
     }
+}
+
+/*
+ * process_jump_to_user - Jump to userland
+ * @stack_top: Address of the top of the user stack
+ * @user_code: Address of the first instruction of user code
+ */
+void process_jump_to_user(uintptr_t stack_top, uintptr_t user_code)
+{
+    // 0x20 | 3 = 0x23 (user data segment | 3)
+    // 0x18 | 3 = 0x1B (user code segment | 3)
+    asm volatile(" \
+        push $0x23 \n\
+        push %0 \n\
+        push $0x202 \n\
+        push $0x1B \n\
+        push %1 \n\
+        iretq \n\
+        " :: "r"(stack_top), "r"(user_code));
+}
+
+// Kernel stack used for interrupts from userland process.
+// Should be set in TSS.RSP0 when switching to userland process.
+uint8_t interrupt_stack[0x8000];
+
+extern struct tss tss;
+
+/*
+ * process_create_user - Create a new user process
+ * @file: pointer to Limine file structure
+ *
+ * This function takes a loaded Limine executable
+ * module, and maps its code, a user stack, sets the
+ * TSS RSP0 for interrupts, and finally jumps to the
+ * user code.
+ */
+void process_create_user(struct limine_file* file)
+{
+    void* exec_addr = file->address;
+    uint64_t exec_size = file->size;
+
+    uint64_t* user_pml4 = vmm_create_address_space();
+    uintptr_t stack_top = vmm_alloc_user_stack(user_pml4);
+    uint64_t code = vmm_alloc_user_code(user_pml4, exec_addr, exec_size);
+    
+    // Could be kalloc_stack()ed PER PROCESS when we grow that
+    tss.rsp0 = (uint64_t)(interrupt_stack + sizeof(interrupt_stack));
+
+    // Load user_pml4 into cr3 along here??
+    load_cr3(VIRT_TO_PHYS((uint64_t)user_pml4));
+
+    // Copy code into user pages
+    memcpy((uint64_t*)code, exec_addr, exec_size);
+
+    process_jump_to_user(stack_top, code);
 }

user/hello.S

@@ -1,5 +1,4 @@
 bits 64
 
 hello:
-    mov qword rax, 0xcafebabe
+    mov rax, 0xcafebabe
-    jmp hello