Attempt userland

Author: pradosh-arduino

source/boot/libFrostedWM.so

@@ -15,20 +15,17 @@
 #include <userland.h>
 
 #define PAGE_SIZE      4096ULL
-#define MEMORY_START   0x10000000ULL
-#define MEMORY_END     0x2000000000ULL
-#define AMOUNT_OF_PAGES ((MEMORY_END - MEMORY_START) / PAGE_SIZE)
 
-#define KERNEL_OFFSET 0xFFFFFFFE80000000ULL
 #define PAGE_PRESENT  0x1
 #define PAGE_RW       0x2
 #define PAGE_USER     0x4
 #define PAGE_NX       (1ULL << 63)
-#define PAGE_SIZE        0x1000      // 4 KB
 
 #define USER_CODE_FLAGS (PAGE_PRESENT | PAGE_USER)          // executable
 #define USER_DATA_FLAGS (PAGE_PRESENT | PAGE_USER | PAGE_RW | PAGE_NX)
 
+#define KERNEL_PHYS_OFFSET 0xFFFF800000000000ULL
+
 /**
  * @brief Function to initialize the page bitmap
  * 
@@ -68,6 +65,6 @@ void setup_userland_memory();
  * @brief Maps user code in paging.
  * 
  */
-void map_user_code();
+void map_user_code(uint64_t code_entry);
 
 #endif

source/includes/paging.h

@@ -13,16 +13,12 @@
 
 #include <basics.h>
 #include <syscalls.h>
- 
-#define USER_STACK_SIZE 0x4000      // 16 KB
-#define USER_HEAP_VADDR 0x50000000
-#define USER_HEAP_SIZE  0x100000   // 1 MB
-#define USER_CODE_VADDR  0x1000000ULL
-#define USER_STACK_VADDR 0x4000000ULL
-#define USER_STACK_TOP   0x7FFFFFF000ULL
 
+#define USER_STACK_SIZE  (16 * 1024)
+#define USER_HEAP_SIZE   (1 * 1024 * 1024)
 
-extern void userland_main();
-extern void enter_userland();
+#define USER_CODE_VADDR  0x40000000ULL   // 1 GB
+#define USER_HEAP_VADDR  0x50000000ULL   // 1.25 GB
+#define USER_STACK_TOP   0x7FFFFFF000ULL // top of canonical user space
 
-#endif
+#endif

source/includes/userland.h

@@ -159,7 +159,7 @@ void main(void) {
 
     mm_print_out();
 
-    initialize_page_bitmap((int64)virtual_to_physical(kstart), (int64)virtual_to_physical(kend));
+    initialize_page_bitmap((int64)(kstart), (int64)(kend));
 
     setup_gdt();
     initIdt();
@@ -223,7 +223,7 @@ void main(void) {
 
     info("Welcome to FrostWing Operating System!", "(https://github.com/Frost-Wing)");
 
-    // enter_userland();
+    // enter_userland(module_request.response->modules[0]->address, module_request.response->modules[0]->size);
     sh_exec();
 }
 

source/kernel/C/kernel.c

@@ -18,22 +18,23 @@ int8*    page_bitmap;
 extern uint8_t user_code_start[];
 extern uint8_t user_code_end[];
 
-static void mark_page_used(uint64_t addr) {
-    if (addr < MEMORY_START || addr >= MEMORY_END) return;
-    size_t page_index = (addr - MEMORY_START) / PAGE_SIZE;
-    size_t byte = page_index / 8;
-    size_t bit  = page_index % 8;
-    page_bitmap[byte] |= (1 << bit);
+inline void* phys_to_virt(uint64_t phys) {
+    return (void*)(phys + KERNEL_PHYS_OFFSET);
 }
 
-static void mark_page_free(uint64_t addr) {
-    if (addr < MEMORY_START || addr >= MEMORY_END) return;
-    size_t page_index = (addr - MEMORY_START) / PAGE_SIZE;
-    size_t byte = page_index / 8;
-    size_t bit  = page_index % 8;
-    page_bitmap[byte] &= ~(1 << bit);
+void mark_page_used(uint64_t addr) {
+    if (addr < memory_start || addr >= memory_end) return;
+    size_t page_index = (addr - memory_start) / PAGE_SIZE;
+    page_bitmap[page_index / 8] |= (1 << (page_index % 8));
 }
 
+void mark_page_free(uint64_t addr) {
+    if (addr < memory_start || addr >= memory_end) return;
+    size_t page_index = (addr - memory_start) / PAGE_SIZE;
+    page_bitmap[page_index / 8] &= ~(1 << (page_index % 8));
+}
+
+
 void initialize_page_bitmap(int64 kernel_start, int64 kernel_end) {
     info("Initializing paging", __FILE__);
 
@@ -159,44 +160,3 @@ void map_user_page(uint64_t virt, uint64_t phys, uint64_t flags) {
     // Flush TLB
     asm volatile("invlpg (%0)" ::"r"(virt) : "memory");
 }
-
-void map_user_code() {
-    uint64_t size = (uint64_t)user_code_end - (uint64_t)user_code_start;
-
-    debug_printf("size of user code -> %z\n", size);
-    debug_printf("user code start   -> %z\n", user_code_start);
-    debug_printf("user code end     -> %z\n", user_code_end);
-
-    for (uint64_t off = 0; off < size; off += PAGE_SIZE) {
-        void* kernel_va = allocate_page();
-        uint64_t phys = (int64)virtual_to_physical((int64)kernel_va);
-
-        if (!phys)
-            error("page allocation failed", __FILE__);
-        else
-            info("page allocation is fine", __FILE__);
-        
-        uint64_t vaddr = USER_CODE_VADDR + off;
-        map_user_page(vaddr, phys, USER_CODE_FLAGS);
-        info("map_user_code: mapped executable user page", __FILE__);
-
-        // Verify mapping
-        uint64_t resolved = virtual_to_physical(vaddr) & ~0xFFF;
-        if (resolved != (phys & ~0xFFF)) {
-            error("map_user_code: VA->PA mismatch", __FILE__);
-        } else {
-            info("map_user_code: VA->PA matches", __FILE__);
-        }
-
-        // The code bytes to copy.
-        uint64_t copy = (size - off >= PAGE_SIZE) ? PAGE_SIZE : (size - off);
-        memcpy(kernel_va, user_code_start + off, copy);
-
-        // Verify the copy of userland.
-        if (memcmp(kernel_va, user_code_start + off, copy) != 0) {
-            error("map_user_code: memcpy verification failed", __FILE__);
-        } else {
-            info("map_user_code: memcpy verification succeeded", __FILE__);
-        }
-    }
-}

source/kernel/C/paging.c

@@ -17,36 +17,47 @@ void user_entry() {
 }
 
 // Map user code and stack
-void setup_userland_heap() {
-    for (uint64_t offset = 0; offset < USER_HEAP_SIZE; offset += 0x1000) {
-        void *phys = allocate_page();  // get real physical page
-        map_user_page(USER_HEAP_VADDR + offset, (uint64_t)phys, 0); // non-executable
+// void setup_userland_heap() {
+//     for (uint64_t offset = 0; offset < USER_HEAP_SIZE; offset += 0x1000) {
+//         void *phys = allocate_page();  // get real physical page
+//         map_user_page(USER_HEAP_VADDR + offset, (uint64_t)phys, 0); // non-executable
+//     }
+//     done("Userland heap mapped", __FILE__);
+// }
+
+void map_user_code_physical(uint64_t code_phys, uint64_t code_size) {
+    uint64_t phys_page = code_phys & ~0xFFFULL;      // round down
+    uint64_t offset = code_phys & 0xFFFULL;         // offset into first page
+    uint64_t mapped = 0;
+
+    while (mapped < code_size) {
+        uint64_t to_map = PAGE_SIZE;
+        map_user_page(USER_CODE_VADDR + mapped, phys_page, USER_CODE_FLAGS);
+
+        mark_page_used(phys_page); // prevent reuse
+        mapped += to_map - (mapped == 0 ? offset : 0);
+        phys_page += PAGE_SIZE;
     }
-    done("Userland heap mapped", __FILE__);
 }
 
-void enter_userland() {
-    printf("Setting up kernel to move to userland...\n");
 
-    map_user_code();
-    // setup_userland_heap();
+void enter_userland(uint64_t code_phys, uint64_t code_size) {
+    printf("Setting up kernel to move to userland...\n");
 
+    uint64_t code_entry = code_phys;
     uint64_t stack_top  = USER_STACK_TOP;
-    uint64_t code_entry = USER_CODE_VADDR;
-
-    // Map user stack
-    for (uint64_t off = 0; off < USER_STACK_SIZE; off += 0x1000) {
-        void *phys = allocate_page();
-        map_user_page(USER_STACK_TOP - off - 0x1000,
-                      (uint64_t)phys,
-                      USER_DATA_FLAGS);
-    }
 
-    done("Switching to userland...", __FILE__);
-    debug_printf("User RIP target = %z\n", code_entry);
-    debug_printf("User RSP target = %z\n", stack_top);
+    // Map the user code pages from the passed physical address
+    map_user_code_physical(code_phys, code_size);
+
+    // Map the user stack pages
+    for (uint64_t off = 0; off < USER_STACK_SIZE; off += PAGE_SIZE) {
+        uint64_t phys = (uint64_t)allocate_page();
+        uint64_t vaddr = stack_top - off - PAGE_SIZE;
+        map_user_page(vaddr, phys, USER_DATA_FLAGS);
+    }
 
-    // 🔥 Actually enter userland
+    // Switch to userland
     asm volatile (
         "cli\n"
         "pushq $0x23\n"        // User SS
@@ -59,4 +70,4 @@ void enter_userland() {
         : "r"(stack_top), "r"(code_entry)
         : "memory"
     );
-}
+}