Attempting to fix userland.

Author: pradosh-arduino

source/includes/paging.h

@@ -13,6 +13,7 @@
 
 #include <basics.h>
 #include <userland.h>
+#include <limine.h>
 
 #define PAGE_SIZE      4096ULL
 
@@ -24,27 +25,7 @@
 #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
- * 
- */
-void initialize_page_bitmap(int64 kernel_start, int64 kernel_end);
-
-/**
- * @brief Function to allocate a page.
- * 
- * @return Pointer to the allocated page's memory address
- */
-void* allocate_page();
-
-/**
- * @brief Function to free a page
- * 
- * @param addr Address of the allocated page.
- */
-void free_page(void* addr);
+extern struct limine_memmap_response *memmap;
 
 /**
  * @brief Function to map userland pages
@@ -55,12 +36,6 @@ void free_page(void* addr);
  */
 void map_user_page(uint64_t virt, uint64_t phys, uint64_t flags);
 
-/**
- * @brief Set the up physical memory for userland
- * 
- */
-void setup_userland_memory();
-
 /**
  * @brief Maps user code in paging.
  * 

source/kernel/C/kernel.c

@@ -159,15 +159,31 @@ void main(void) {
 
     mm_print_out();
 
-    initialize_page_bitmap((int64)(kstart), (int64)(kend));
-
     setup_gdt();
     initIdt();
 
     RTL8139 = (struct rtl8139*) kmalloc(sizeof(struct rtl8139));
 
     analyze_memory_map(memory, memory_map_request);
-    
+    memmap = memory_map_request.response;
+
+    uintptr_t page1 = allocate_page();
+    uintptr_t page2 = allocate_page();
+
+    printf("Page1 phys: 0x%x", page1);
+    printf("Page2 phys: 0x%x", page2);
+
+    uint64_t *test1 = (uint64_t *)page1;
+    uint64_t *test2 = (uint64_t *)page2;
+
+    // Write some values
+    *test1 = 0xDEADBEEFCAFEBABE;
+    *test2 = 0x123456789ABCDEF0;
+
+    // Read back
+    printf("Read back page1: 0x%x", *test1);
+    printf("Read back page2: 0x%x", *test2);
+
     probe_pci();
 
     print(public_key);
@@ -223,7 +239,7 @@ void main(void) {
 
     info("Welcome to FrostWing Operating System!", "(https://github.com/Frost-Wing)");
 
-    // enter_userland(module_request.response->modules[0]->address, module_request.response->modules[0]->size);
+    enter_userland();
     sh_exec();
 }
 

source/kernel/C/paging.c

@@ -18,75 +18,27 @@ int8*    page_bitmap;
 extern uint8_t user_code_start[];
 extern uint8_t user_code_end[];
 
-inline void* phys_to_virt(uint64_t phys) {
-    return (void*)(phys + KERNEL_PHYS_OFFSET);
-}
-
-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));
-}
+struct limine_memmap_response *memmap;
+static uintptr_t bump_ptr = 0;
 
-
-void initialize_page_bitmap(int64 kernel_start, int64 kernel_end) {
-    info("Initializing paging", __FILE__);
-
-    size_t physical_memory_size = 32 MiB;
-    void* memory_block = kmalloc(physical_memory_size);
-    if (!memory_block) {
-        error("Failed to allocate physical memory block!", __FILE__);
-        return;
+uintptr_t allocate_page() {
+    if(!memmap){
+        error("Limine failed to give the memory map", __FILE__);
+        hcf2();
     }
 
-    memory_start = (uint64_t)memory_block;
-    memory_end   = memory_start + physical_memory_size;
-    amount_of_pages = physical_memory_size / PAGE_SIZE;
-
-    size_t bitmap_size = amount_of_pages / 8;
-    page_bitmap = (int8*)kmalloc(bitmap_size);
-    if (!page_bitmap) {
-        error("Failed to allocate page bitmap!", __FILE__);
-        return;
-    }
-
-    memset(page_bitmap, 0, bitmap_size);
-
-    // Reserve kernel memory
-    for (uint64_t addr = (uint64_t)kernel_start; addr < (uint64_t)kernel_end; addr += PAGE_SIZE)
-        mark_page_used(addr);
-
-    // Reserve user code memory
-    for (uint64_t addr = (uint64_t)user_code_start; addr < (uint64_t)user_code_end; addr += PAGE_SIZE)
-        mark_page_used(addr);
-
-    mm_print_out();
-
-    done("Successfully initialized page bitmap", __FILE__);
-}
-
-void* allocate_page() {
-    for (size_t i = 0; i < amount_of_pages; ++i) {
-        size_t byte = i / 8;
-        size_t bit  = i % 8;
-        if (!(page_bitmap[byte] & (1 << bit))) {
-            page_bitmap[byte] |= (1 << bit);
-            return (void*)(memory_start + i * PAGE_SIZE);
+    if (!bump_ptr) {
+        for (uint64_t i = 0; i < memmap->entry_count; i++) {
+            struct limine_memmap_entry *e = memmap->entries[i];
+            if (e->type != LIMINE_MEMMAP_USABLE) continue;
+            bump_ptr = (e->base + PAGE_SIZE - 1) & ~0xFFFULL;
+            break;
         }
     }
-    error("Out of physical pages!", __FILE__);
-    return NULL;
-}
 
-void free_page(void* addr) {
-    uint64_t aligned_addr = ((uint64_t)addr / PAGE_SIZE) * PAGE_SIZE;
-    mark_page_free(aligned_addr);
+    uintptr_t page = bump_ptr;
+    bump_ptr += PAGE_SIZE;
+    return page;
 }
 
 static inline uint64_t get_kernel_pml4() {

source/kernel/C/userland.c

@@ -6,63 +6,67 @@
 extern uint8_t user_code_start[];
 extern uint8_t user_code_end[];
 
-// Simple userland code
-__attribute__((section(".user")))
-__attribute__((naked))
-void user_entry() {
-    asm volatile (
-        "1: pause\n"
-        "jmp 1b\n"
-    );
-}
-
-// 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
-//     }
-//     done("Userland heap mapped", __FILE__);
-// }
-
+/**
+ * @brief Map the user code into virtual memory.
+ *
+ * @param code_phys Physical address of the user code
+ * @param code_size Size in bytes
+ */
 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 phys_page = code_phys & ~0xFFFULL;
+    uint64_t page_offset = code_phys & 0xFFFULL;
     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);
+        if (mapped == 0 && page_offset != 0)
+            mapped += PAGE_SIZE - page_offset;
+        else
+            mapped += PAGE_SIZE;
+
         phys_page += PAGE_SIZE;
     }
 }
 
+/**
+ * @brief Enter userland (ring 3) safely
+ */
+void enter_userland() {
+    printf("Setting up kernel to move to userland...");
 
-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;
+    // Compute physical addresses of user code
+    uint64_t code_phys = virtual_to_physical((uint64_t)user_code_start);
+    uint64_t code_size = (uint64_t)user_code_end - (uint64_t)user_code_start;
     uint64_t stack_top  = USER_STACK_TOP;
+    uint64_t code_entry = USER_CODE_VADDR; // virtual address where user code will run
 
-    // Map the user code pages from the passed physical address
+    // Map user code
     map_user_code_physical(code_phys, code_size);
 
-    // Map the user stack pages
+    // Map the user stack
     for (uint64_t off = 0; off < USER_STACK_SIZE; off += PAGE_SIZE) {
-        uint64_t phys = (uint64_t)allocate_page();
+        uint64_t phys = allocate_page();
         uint64_t vaddr = stack_top - off - PAGE_SIZE;
         map_user_page(vaddr, phys, USER_DATA_FLAGS);
     }
 
-    // Switch to userland
+    // Optional: Map user heap (commented for now)
+    /*
+    for (uint64_t off = 0; off < USER_HEAP_SIZE; off += PAGE_SIZE) {
+        uint64_t phys = allocate_page();
+        map_user_page(USER_HEAP_VADDR + off, phys, USER_DATA_FLAGS);
+    }
+    */
+
+    printf("Switching to userland at 0x%x with stack 0x%x", code_entry, stack_top);
+
+    // Jump to userland (ring 3) using iretq
     asm volatile (
         "cli\n"
         "pushq $0x23\n"        // User SS
         "pushq %0\n"           // User RSP
-        "pushq $0x202\n"       // RFLAGS
+        "pushq $0x202\n"       // RFLAGS (IF = 1)
         "pushq $0x1B\n"        // User CS
         "pushq %1\n"           // User RIP
         "iretq\n"
@@ -71,3 +75,15 @@ void enter_userland(uint64_t code_phys, uint64_t code_size) {
         : "memory"
     );
 }
+
+/**
+ * @brief Simple user code (halt in a loop)
+ */
+__attribute__((section(".user")))
+__attribute__((naked))
+void user_entry() {
+    asm volatile (
+        "1: hlt\n"   // halt CPU in an infinite loop
+        "jmp 1b\n"
+    );
+}

source/linker/linker.ld

@@ -52,7 +52,7 @@ SECTIONS
         *(COMMON)
     } :data
 
-    .user : ALIGN(4096) {
+    .user : ALIGN(0x1000) {
         user_code_start = .;
         *(.user)
         user_code_end = .;