attempt for userland

Author: pradosh-arduino

source/includes/heap.h

@@ -13,9 +13,6 @@
 #include <stddef.h>
 #include <basics.h>
 
-#define HEAP_SAFE_BEGIN 0x200000 // 2 MB mark, just after kernel & stack
-#define HEAP_SAFE_SIZE  0x100000 // 1 MB heap for testing
-
 /**
  * @brief Function to initlialize heap.
  * 

source/includes/paging.h

@@ -13,8 +13,8 @@
 
 #define page_size 4096
 
-#define memory_start 0x100000
-#define memory_end   0x200000
+#define memory_start 0x10000000
+#define memory_end   0x20000000
 
 #define amount_of_pages    ((memory_end - memory_start) / page_size)
 
@@ -59,8 +59,9 @@ void free_page(void* addr);
  * 
  * @param virt Virtual memory address
  * @param phys Physical memory address
+ * @param executable 
  */
-void map_user_page(uint64_t virt, uint64_t phys);
+void map_user_page(uint64_t virt, uint64_t phys, int executable);
 
 /**
  * @brief Set the up physical memory for userland

source/kernel/C/heap.c

@@ -21,10 +21,10 @@ void mm_init(uintptr_t kernel_end)
     info("Initializing heap.", __FILE__);
 
     heap_begin = ALIGN_UP(kernel_end + 8 KiB, 8);
-    heap_end   = heap_begin + HEAP_SAFE_SIZE;
+    heap_end   = heap_begin + 64 MiB;
     last_alloc = heap_begin;
 
-    memset((void*)heap_begin, 0, HEAP_SAFE_SIZE);
+    memset((void*)heap_begin, 0, 64 MiB);
 
     printf("heap begin -> 0x%X\nheap end -> 0x%X", heap_begin, heap_end);
 
@@ -122,7 +122,7 @@ void* krealloc(void* ptr, size_t size)
 
 void mm_print_out()
 {
-    printf("%sMemory used :%s %u bytes", yellow_color, reset_color, (unsigned long long)memory_used);
-    printf("%sMemory free :%s %u bytes", yellow_color, reset_color, (unsigned long long)(heap_end - last_alloc));
-    printf("%sHeap size   :%s %u bytes", yellow_color, reset_color, (unsigned long long)(heap_end - heap_begin));
+    printf("%sMemory used :%s %u KiB", yellow_color, reset_color, memory_used/(1 KiB));
+    printf("%sMemory free :%s %u KiB", yellow_color, reset_color, (heap_end - last_alloc)/(1 KiB));
+    printf("%sHeap size   :%s %u KiB", yellow_color, reset_color, (heap_end - heap_begin)/(1 KiB));
 }

source/kernel/C/kernel.c

@@ -320,8 +320,6 @@ void main(void) {
 
     enable_fpu();
 
-    // enter_userland();
-
     info("Welcome to FrostWing Operating System!", "(https://github.com/Frost-Wing)");
 
     // glCreateContext();
@@ -372,32 +370,13 @@ void main(void) {
     // print("\x1b[2J"); // Clears screen
     // print("\x1b[H");  // Resets Cursor to 0, 0
 
-    // int* test1 = kmalloc(sizeof(int));
-    // int* test2 = kmalloc(sizeof(int));
-    // int* test3 = kmalloc(sizeof(int));
-    // int* test4 = kmalloc(sizeof(int));
-
     wm_addr = module_request.response->modules[0]->address;
 
     int failed_attempts = 0;
 
-    // void* binaddress = module_request.response->modules[1]->address;
-    // printf("binary addr: 0x%x", binaddress);
-    // int (*execute_binary)(void) = binaddress;
-    // int status_code = execute_binary();
-    // printf("return code: 0x%x", status_code);
-
-
     extern char* login_request();
 
     while(1){
-        // decode_targa_image(module_request.response->modules[2]->address, (uvec2){0, 0}, framebuffer->width, framebuffer->height);
-
-
-        // // ivec2 lastMousePos = GetLastMousePosition();
-        // ivec2 mousePos = GetMousePosition();
-        // decode_targa_image(module_request.response->modules[3]->address, (uvec2){mousePos.x, mousePos.y}, framebuffer->width, framebuffer->height);
-
         if (failed_attempts >= 5){
             error("You tried 5 diffrent wrong attempts. You've been locked out.", __FILE__);
             hcf();

source/kernel/C/paging.c

@@ -51,12 +51,34 @@ static inline uint64_t get_kernel_pml4() {
     return cr3;
 }
 
-void map_user_page(uint64_t virt, uint64_t phys) {
+uint64_t virtual_to_physical(uint64_t virt) {
+    uint64_t *pml4 = (uint64_t*)get_kernel_pml4();
+    uint64_t pml4_idx = (virt >> 39) & 0x1FF;
+    uint64_t pdpt_idx = (virt >> 30) & 0x1FF;
+    uint64_t pd_idx   = (virt >> 21) & 0x1FF;
+    uint64_t pt_idx   = (virt >> 12) & 0x1FF;
+    uint64_t offset   = virt & 0xFFF;
+
+    if (!(pml4[pml4_idx] & PAGE_PRESENT)) return 0;
+    uint64_t *pdpt = (uint64_t*)(pml4[pml4_idx] & ~0xFFF);
+
+    if (!(pdpt[pdpt_idx] & PAGE_PRESENT)) return 0;
+    uint64_t *pd = (uint64_t*)(pdpt[pdpt_idx] & ~0xFFF);
+
+    if (!(pd[pd_idx] & PAGE_PRESENT)) return 0;
+    uint64_t *pt = (uint64_t*)(pd[pd_idx] & ~0xFFF);
+
+    if (!(pt[pt_idx] & PAGE_PRESENT)) return 0;
+
+    uint64_t phys = (pt[pt_idx] & ~0xFFF) | offset;
+    return phys;
+}
+
+void map_user_page(uint64_t virt, uint64_t phys, int executable) {
     // Traverse or create PML4 -> PDPT -> PD -> PT
-    uint64_t *pml4 = (uint64_t*)get_kernel_pml4(); // existing kernel PML4
+    uint64_t *pml4 = (uint64_t*)get_kernel_pml4(); // kernel PML4
     uint64_t *pdpt, *pd, *pt;
 
-    // Indexes
     uint64_t pml4_idx = (virt >> 39) & 0x1FF;
     uint64_t pdpt_idx = (virt >> 30) & 0x1FF;
     uint64_t pd_idx   = (virt >> 21) & 0x1FF;
@@ -90,22 +112,14 @@ void map_user_page(uint64_t virt, uint64_t phys) {
     }
 
     // Map the physical page
-    pt[pt_idx] = phys | PAGE_PRESENT | PAGE_RW | PAGE_USER;
-
-    // Flush TLB for this page
-    asm volatile("invlpg (%0)" ::"r"(virt) : "memory");
-}
+    uint64_t flags = PAGE_PRESENT | PAGE_USER;
+    if (!executable) flags |= PAGE_RW; // writable if data/stack
+    else flags &= ~PAGE_RW;            // code = read-only
 
-void setup_userland_memory() {
-    // Map multiple pages for stack (16 KB total)
-    for(int i = 0; i < 4; i++) {
-        map_user_page(USER_STACK_VADDR + i*PAGE_SIZE, (uint64_t)allocate_page());
-    }
+    if (!executable) flags |= PAGE_RW;
 
-    // Map 4 KB for code
-    map_user_page(USER_CODE_VADDR, (uint64_t)allocate_page());
-    memcpy((void*)USER_CODE_VADDR, (void*)userland_main, 0x1000);
+    pt[pt_idx] = phys | flags;
 
-    // Map 4 KB for rodata / strings (for printf)
-    map_user_page(USER_CODE_VADDR + 0x1000, (uint64_t)allocate_page());
-}
+    // Flush TLB
+    asm volatile("invlpg (%0)" ::"r"(virt) : "memory");
+}

source/kernel/C/shell/sh.c

@@ -312,6 +312,8 @@ void execute(const char* buffer, int argc, char** argv)
         list_contents(fs);
     } else if (strncmp(buffer, "frostedwm", 9) == 0 || strcmp(buffer, "frostedwm") == 0) { 
         start_window_manager();
+    } else if (strncmp(buffer, "userland", 8) == 0 || strcmp(buffer, "userland") == 0) { 
+        enter_userland();
     } else if (strncmp(buffer, "meminfo", 7) == 0 || strcmp(buffer, "meminfo") == 0) { 
         display_memory_formatted(memory);
     } else if (strncmp(buffer, "heapinfo", 7) == 0 || strcmp(buffer, "heapinfo") == 0) { 

source/kernel/C/userland.c

@@ -1,45 +1,72 @@
-/**
- * @file userland.c
- * @author Pradosh ([email protected])
- * @brief Main steps to enter Userland.
- * @version 0.1
- * @date 2025-10-03
- * 
- * @copyright Copyright (c) Pradosh 2025
- * 
- */
-#include <userland.h>
-
-uint8_t user_stack[USER_STACK_SIZE] __attribute__((aligned(16)));
+#include <stdint.h>
+#include <memory.h>
+#include <basics.h>
+#include <paging.h>
 
+#define USER_STACK_SIZE 0x4000      // 16 KB
+#define USER_STACK_VADDR 0x70000000
+#define USER_CODE_VADDR  0x40000000
+#define USER_HEAP_VADDR 0x50000000
+#define USER_HEAP_SIZE  0x100000   // 1 MB
+
+
+__attribute__((aligned(16)))
+uint8_t user_stack[USER_STACK_SIZE];
+
+// Simple userland code
 void userland_main() {
-    info("HELLO FROM USERLAND", __FILE__);
+    info("HELLO FROM USERLAND!", __FILE__);
+    for (;;) asm volatile("hlt");
+}
 
-    for(;;) asm volatile("hlt");
+// 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__);
 }
 
+
+
 void enter_userland() {
-    setup_userland_memory();
-    done("Setuped memory for userland", __FILE__);
-    
-    uint64_t user_stack_top = 0x70000000 + USER_STACK_SIZE; // mapped stack top
-    uint64_t user_code = 0x40000000; // mapped code entry
+    setup_userland_heap();
+
+    uint64_t stack_top = USER_STACK_VADDR + USER_STACK_SIZE;
+    uint64_t code_entry = USER_CODE_VADDR;
+
+    done("Switching to userland...", __FILE__);
+
+    info("userland_main @ virtual:", __FILE__);
+    printf("  &userland_main = 0x%x", (uint64_t)&userland_main);
+
+    info("user_code entry @ virtual:", __FILE__);
+    printf("  user_code = 0x%x", code_entry);
+
+    info("user stack top @ virtual:", __FILE__);
+    printf("  user_stack_top = 0x%x", stack_top);
+
+    info("Mapped pages:", __FILE__);
+    printf("  USER_CODE_VADDR = 0x%x -> phys = 0x%x", USER_CODE_VADDR, (uint64_t)&userland_main);
+    for (uint64_t offset = 0; offset < USER_STACK_SIZE; offset += 0x1000) {
+        printf("  USER_STACK_VADDR+0x%x -> phys = 0x%x", offset, (uint64_t)&user_stack[offset]);
+    }
 
-    done("Expect to jump to userland_main()", __FILE__);
 
     asm volatile(
-        "cli\n\t"
-        "movq %0, %%rsp\n\t"
-        "pushq $0x23\n\t"        // user data segment
-        "pushq %0\n\t"           // user RSP
-        "pushq $0x202\n\t"       // RFLAGS, IF=1
-        "pushq $0x1B\n\t"        // user code segment
-        "pushq %1\n\t"           // user RIP
-        "iretq\n\t"
+        "cli\n\t"                  // disable interrupts
+        "movq %0, %%rsp\n\t"       // load user stack
+        "pushq $0x23\n\t"          // user data segment (DS)
+        "pushq %0\n\t"             // RSP for user
+        "pushq $0x202\n\t"         // RFLAGS with IF=1
+        "pushq $0x1B\n\t"          // user code segment (CS)
+        "pushq %1\n\t"             // RIP for userland
+        "iretq\n\t"                // ring 3 jump
         :
-        : "r"(user_stack_top), "r"(user_code)
+        : "r"(stack_top), "r"(code_entry)
         : "memory"
     );
 
-    warn("This should not execute something went wrong", __FILE__);
+    warn("Should never reach here!", __FILE__);
 }