[misc]removed brk heap in favor of full anon, cleaned up structs

Author: CodeAnarchist

kernel/bin/monitor_processes.c

@@ -8,6 +8,7 @@
 #include "ui/draw/draw.h"
 #include "std/string.h"
 #include "theme/theme.h"
+#include "memory/addr.h"
 #include "math/math.h"
 #include "syscalls/syscalls.h"
 #include "memory/memory_types.h"
@@ -17,12 +18,12 @@ char* parse_proc_state(int state){
     {
     case STOPPED:
         return "Stopped";
-
     case READY:
+        return "Ready";
     case RUNNING:
-    case BLOCKED:
         return "Running";
-    
+    case BLOCKED:
+        return "Blocked";
     default:
         return "Invalid";
     }
@@ -46,7 +47,7 @@ void print_process_info(){
         if (proc->id != 0 && proc->state != STOPPED && (!procname || strcmp_case(procname,proc->name,true) == 0)){
             print("Process [%i]: %s [pid = %i | status = %s]",i,(uintptr_t)proc->name,proc->id,(uintptr_t)parse_proc_state(proc->state));
             print("Stack: %x (%x). SP: %x",proc->stack, proc->stack_size, proc->sp);
-            print("Heap: %x (%x)",proc->mm.brk, calc_heap(proc->heap_phys));
+            print("Heap: %x (%x)",proc->mm.mmap_bottom, calc_heap(proc->heap_phys));
             print("Flags: %x", proc->spsr);
             print("PC: %x",proc->pc);
         }
@@ -132,10 +133,10 @@ void draw_process_view(){
         fb_draw_string(&ctx,pc.data, xo, pc_y, scale, system_theme.bg_color);
         string_free(pc);
 
-        draw_memory("Stack", xo, stack_y, stack_width, stack_height, proc->stack - proc->sp, proc->stack_size);
-        uint64_t heap = proc->mm.ttbr0 ? (proc->mm.rss_heap_pages * PAGE_SIZE) : calc_heap(proc->heap_phys);
-        uint64_t heap_limit = proc->mm.ttbr0 ? (proc->mm.brk > proc->mm.heap_start ? (uint64_t)(proc->mm.brk - proc->mm.heap_start) : (uint64_t)PAGE_SIZE) : ((heap + 0xFFF) & ~0xFFF);
-        draw_memory("Heap", xo + stack_width + 50, stack_y, stack_width, stack_height, heap, heap_limit);
+        draw_memory("Stack", xo, stack_y, stack_width, stack_height, proc->stack - proc->sp, proc->stack_size ? proc->stack_size : 1);
+        uint64_t heap = proc->mm.ttbr0 ? (proc->mm.rss_anon_pages * PAGE_SIZE) : calc_heap(proc->heap_phys);
+        uint64_t heap_limit = proc->mm.ttbr0 ? (uint64_t)(proc->mm.mmap_top - proc->mm.mmap_bottom) : ((heap + 0xFFF) & ~0xFFF);
+        draw_memory("Heap", xo + stack_width + 50, stack_y, stack_width, stack_height, heap, heap_limit ? heap_limit : PAGE_SIZE);
 
         string flags = string_format("Flags: %x", proc->spsr);
         fb_draw_string(&ctx, flags.data, xo, flags_y, scale, system_theme.bg_color);

kernel/bin/tracert.c

@@ -38,7 +38,7 @@ static bool parse_args(int argc, char *argv[], tr_opts_t *o) {
     o->src_set = false;
     o->host = NULL;
 
-    for (int i = 1; i < argc; ++i) {
+    for (int i = 1; i < argc; i++) {
         const char *a = argv[i];
         if (a && a[0] == '-') {
             if (strcmp_case(a, "-4",true) == 0) {

kernel/kernel_processes/kprocess_loader.c

@@ -50,8 +50,6 @@ process_t *create_kernel_process(const char *name, int (*func)(int argc, char* a
     proc->stack_size = stack_size;
 
     proc->heap_phys = heap;
-    proc->mm.heap_start = (uaddr_t)dmap_pa_to_kva(heap);
-    proc->mm.brk = proc->mm.heap_start;
 
     proc->sp = proc->stack;
 
@@ -114,7 +112,8 @@ process_t *create_kernel_process(const char *name, int (*func)(int argc, char* a
         }
     }
 
-    kprintf("Kernel process %s (%i) allocated with address at %llx, stack at %llx-%llx, heap at %llx. %i argument(s)", (uintptr_t)name, proc->id, proc->pc, proc->sp - proc->stack_size, proc->sp, proc->mm.brk, argc);
+    ready_process(proc);
+    kprintf("Kernel process %s (%i) allocated with address at %llx, stack at %llx-%llx, heap at %llx. %i argument(s)", (uintptr_t)name, proc->id, proc->pc, proc->sp - proc->stack_size, proc->sp, (uaddr_t)dmap_pa_to_kva(proc->heap_phys), argc);
     irq_restore(irq);
 
     return proc;

kernel/kernel_processes/windows/launcher.c

@@ -47,9 +47,11 @@ void add_entry(string_slice name, string_slice ext, string path, package_info in
 }
 
 uint16_t find_extension(char *path){
-    uint16_t count = 0;
-    while (*path && *path != '.'){ path++; count++; }
-    return path ? count : 0;
+    if (!path) return 0;
+    int32_t dot = -1;
+    for (uint16_t i = 0; path[i]; i++) if (path[i] == '.') dot = i;
+    if (dot <= 0) return 0;
+    return (uint16_t)dot;
 }
 
 package_info get_pkg_info(char* info_path){
@@ -65,9 +67,12 @@ package_info get_pkg_info(char* info_path){
 void handle_entry(const char *directory, const char *file) {
     string fullpath = string_format("%s/%s",directory, (uintptr_t)file);
     uint16_t ext_loc = find_extension((char*)file);
+    if (!ext_loc) {
+        string_free(fullpath);
+        return;
+    }
     string_slice name = make_string_slice(fullpath.data, fullpath.length - strlen(file), ext_loc);
-    uint16_t extra = ext_loc ? 1 : 0;
-    string_slice ext = make_string_slice(name.data + ext_loc + 1, 0, strlen(file)-ext_loc-extra);
+    string_slice ext = make_string_slice(file, ext_loc + 1, strlen(file)-ext_loc-1);
     if (slice_lit_match(ext,"red",true)){
         string pkg_info = string_concat(fullpath, string_from_literal("/package.info"));
         add_entry(name, ext, fullpath, get_pkg_info(pkg_info.data));
@@ -192,7 +197,7 @@ void activate_current(){
         active_proc->priority = PROC_PRIORITY_FULL;
         process_active = true;
         sys_set_focus(active_proc->id);
-        active_proc->state = READY;
+        ready_process(active_proc);
         kprintf("[LAUNCHER] process launched");
         enable_interrupt();
     }

kernel/memory/mm_process.c

@@ -66,7 +66,7 @@ bool mm_remove_vma(mm_struct *mm, uaddr_t start, uaddr_t end) {
         if (end <= m->start) return false;
         if (start >= m->end) continue;
 
-        bool track_free = m->kind != VMA_KIND_HEAP && m->kind != VMA_KIND_STACK;
+        bool track_free = m->kind != VMA_KIND_STACK;
         uaddr_t free_start = 0;
         uaddr_t free_end = 0;
 
@@ -150,7 +150,7 @@ uaddr_t mm_alloc_mmap(mm_struct *mm, size_t size, uint8_t prot, uint8_t kind, ui
         return base;
     }
 
-    uaddr_t heap_guard = mm->brk + (MM_GAP_PAGES * PAGE_SIZE);
+    uaddr_t heap_guard = mm->mmap_bottom + (MM_GAP_PAGES * PAGE_SIZE);
     if (!mm->mmap_cursor) return 0;
     uaddr_t base = (mm->mmap_cursor - size) & ~(PAGE_SIZE - 1);
     if (base < heap_guard) return 0;
@@ -216,7 +216,7 @@ bool mm_try_handle_page_fault(process_t *proc, uintptr_t far, uint64_t esr) {
         return true;
     }
 
-    if ((m->kind == VMA_KIND_HEAP && proc->mm.rss_heap_pages >= proc->mm.cap_heap_pages) || (m->kind == VMA_KIND_ANON && proc->mm.rss_anon_pages >= proc->mm.cap_anon_pages)) return false;
+    if (m->kind == VMA_KIND_ANON && proc->mm.rss_anon_pages >= proc->mm.cap_anon_pages) return false;
 
     paddr_t phys = palloc_inner(PAGE_SIZE, MEM_PRIV_USER, MEM_RW, true, false);
     if (!phys) return false;
@@ -225,8 +225,7 @@ bool mm_try_handle_page_fault(process_t *proc, uintptr_t far, uint64_t esr) {
     mmu_map_4kb((uint64_t*)proc->mm.ttbr0, va_page, phys, MAIR_IDX_NORMAL, m->prot | MEM_NORM, MEM_PRIV_USER);
     mmu_flush_asid(proc->mm.asid);
 
-    if (m->kind == VMA_KIND_HEAP) proc->mm.rss_heap_pages++;
-    else if (m->kind == VMA_KIND_ANON) proc->mm.rss_anon_pages++;
+    if (m->kind == VMA_KIND_ANON) proc->mm.rss_anon_pages++;
 
     return true;
 }

kernel/memory/mm_process.h

@@ -10,10 +10,9 @@ typedef struct process process_t;
 #define VMA_FLAG_ZERO 4
 #define VMA_FLAG_NOFREE 8
 #define VMA_KIND_ELF 1
-#define VMA_KIND_HEAP 2
-#define VMA_KIND_STACK 3
-#define VMA_KIND_ANON 4
-#define VMA_KIND_SPECIAL 5
+#define VMA_KIND_STACK 2
+#define VMA_KIND_ANON 3
+#define VMA_KIND_SPECIAL 4
 
 #define MAX_VMAS 128
 #define MM_GAP_PAGES 16
@@ -40,18 +39,14 @@ typedef struct mm_struct {
     uint16_t vma_count;
     mm_free_range mmap_free[MAX_VMAS];
     uint16_t mmap_free_count;
-    uaddr_t heap_start;
-    uaddr_t brk;
-    uaddr_t brk_max;
+    uaddr_t mmap_bottom;
     uaddr_t mmap_top;
     uaddr_t mmap_cursor;
     uaddr_t stack_top;
     uaddr_t stack_limit;
     uaddr_t stack_commit;
-    uint64_t rss_heap_pages;
     uint64_t rss_stack_pages;
     uint64_t rss_anon_pages;
-    uint64_t cap_heap_pages;
     uint64_t cap_stack_pages;
     uint64_t cap_anon_pages;
 } mm_struct;

kernel/memory/page_allocator.c

@@ -18,26 +18,14 @@
 #define LOW_ADDR_WARN 0x100000ULL
 
 #define ALLOC_TAG_MAGIC 0xCCDEC00ED00DAA0EULL
-#define ALLOC_TAG_MAGIC_INV (~ALLOC_TAG_MAGIC)
-#define ALLOC_TAG_SIZE 64
-#define ALLOC_KIND_SMALL 1
+#define ALLOC_TAG_SIZE sizeof(alloc_tag)
 
 typedef struct {
     uint64_t magic;
-    uint64_t magic_inv;
     uint64_t base_phys;
     uint64_t user_phys;
-    uint64_t owner_phys;
     uint32_t alloc_size;
-    uint32_t user_size;
-    uint16_t alignment;
-    uint8_t kind;
-    uint8_t level;
-    uint8_t attributes;
-    uint8_t reserved0;
-    uint16_t reserved1;
     uint32_t checksum;
-    uint32_t checksum_inv;
 } alloc_tag;
 
 typedef struct {
@@ -451,25 +439,11 @@ void* kalloc_inner(void *page, size_t size, uint16_t alignment, uint8_t level, u
 
                 alloc_tag* tag = (alloc_tag*)PHYS_TO_VIRT(tag_phys);
                 tag->magic = ALLOC_TAG_MAGIC;
-                tag->magic_inv = ALLOC_TAG_MAGIC_INV;
                 tag->base_phys = base_phys;
                 tag->user_phys = user_phys;
-                tag->owner_phys = owner_phys;
                 tag->alloc_size = (uint32_t)bsz;
-                tag->user_size = (uint32_t)req_size;
-                tag->alignment = alignment;
-                tag->kind = ALLOC_KIND_SMALL;
-                tag->level = level;
-                tag->attributes = info->attributes;
-                tag->reserved0 = 0;
-                tag->reserved1 = 0;
-
-                uint64_t mix = tag->base_phys ^ tag->user_phys ^ tag->owner_phys ^ ((uint64_t)tag->alloc_size << 32) ^ tag->user_size;
-                mix ^= ((uint64_t)tag->alignment << 48) ^ ((uint64_t)tag->kind << 40) ^ ((uint64_t)tag->level << 32) ^ ((uint64_t)tag->attributes << 24);
-                mix ^= ALLOC_TAG_MAGIC; //token
-                uint32_t c = (uint32_t)(mix ^ (mix >> 32));
-                tag->checksum = c;
-                tag->checksum_inv = ~c;
+                uint64_t mix = tag->base_phys ^ tag->user_phys ^ ((uint64_t)tag->alloc_size << 32) ^ ALLOC_TAG_MAGIC;
+                tag->checksum = (uint32_t)(mix ^ (mix >> 32));
 
                 memset((void*)PHYS_TO_VIRT(user_phys), 0, size);
                 info->size += bsz;
@@ -517,25 +491,11 @@ void* kalloc_inner(void *page, size_t size, uint16_t alignment, uint8_t level, u
 
     alloc_tag* tag = (alloc_tag*)PHYS_TO_VIRT(tag_phys);
     tag->magic = ALLOC_TAG_MAGIC;
-    tag->magic_inv = ALLOC_TAG_MAGIC_INV;
     tag->base_phys = base_phys;
     tag->user_phys = user_phys;
-    tag->owner_phys = owner_phys;
     tag->alloc_size = (uint32_t)small_need;
-    tag->user_size = (uint32_t)req_size;
-    tag->alignment = alignment;
-    tag->kind = ALLOC_KIND_SMALL;
-    tag->level = level;
-    tag->attributes = info->attributes;
-    tag->reserved0 = 0;
-    tag->reserved1 = 0;
-
-    uint64_t mix = tag->base_phys ^ tag->user_phys ^ tag->owner_phys ^ ((uint64_t)tag->alloc_size << 32) ^ tag->user_size;
-    mix ^= ((uint64_t)tag->alignment << 48) ^ ((uint64_t)tag->kind << 40) ^ ((uint64_t)tag->level << 32) ^ ((uint64_t)tag->attributes << 24);
-    mix ^= ALLOC_TAG_MAGIC;
-    uint32_t c = (uint32_t)(mix ^ (mix >> 32));
-    tag->checksum = c;
-    tag->checksum_inv = ~c;
+    uint64_t mix = tag->base_phys ^ tag->user_phys ^ ((uint64_t)tag->alloc_size << 32) ^ ALLOC_TAG_MAGIC;
+    tag->checksum = (uint32_t)(mix ^ (mix >> 32));
 
     memset((void*)PHYS_TO_VIRT(user_phys), 0, size);
     info->size += small_need;
@@ -648,22 +608,15 @@ void kfree(void* ptr, size_t size) {
 
         if(phys_tag) {
             tag = (alloc_tag*)PHYS_TO_VIRT(phys_tag);
-            if(tag->magic == ALLOC_TAG_MAGIC && tag->magic_inv == ALLOC_TAG_MAGIC_INV && tag->user_phys == phys){
-                uint64_t mix = tag->base_phys ^ tag->user_phys ^ tag->owner_phys ^ ((uint64_t)tag->alloc_size << 32) ^ tag->user_size;
-                mix ^= ((uint64_t)tag->alignment << 48) ^ ((uint64_t)tag->kind << 40) ^ ((uint64_t)tag->level << 32) ^ ((uint64_t)tag->attributes << 24);
-                mix ^= ALLOC_TAG_MAGIC; //token
+            if(tag->magic == ALLOC_TAG_MAGIC && tag->user_phys == phys){
+                uint64_t mix = tag->base_phys ^ tag->user_phys ^ ((uint64_t)tag->alloc_size << 32) ^ ALLOC_TAG_MAGIC;
                 uint32_t c = (uint32_t)(mix ^ (mix >> 32));
-                if(tag->checksum == c && tag->checksum_inv == ~c) tag_ok = true;
+                if(tag->checksum == c) tag_ok = true;
             }
         }
     }
 
     if(tag_ok) {
-        if(tag->kind != ALLOC_KIND_SMALL) {
-            kprintf("[kfree] bad tag kind ptr=%llx phys=%llx kind=%u size=%llx", (uint64_t)va, (uint64_t)phys, (unsigned)tag->kind, (uint64_t)size);
-            panic("kfree bad tag kind", va);
-        }
-
         uintptr_t base_phys = (uintptr_t)tag->base_phys;
         uint64_t alloc_size = tag->alloc_size;
 

kernel/process/debug.c

@@ -23,8 +23,8 @@ void debug_load(){
 
     kprintf("[DEBUG] Reading debug info from %x",file);
 
-    get_elf_debug_info(get_proc_by_pid(0), file, fd.size);
+    get_elf_debug_info(get_kernel_proc(), file, fd.size);
 
-    kprintf("[DEBUG] .debug_line %x .debug_line_str %x", get_proc_by_pid(0)->debug_lines.ptr, get_proc_by_pid(0)->debug_line_str.ptr);
+    kprintf("[DEBUG] .debug_line %x .debug_line_str %x", get_kernel_proc()->debug_lines.ptr, get_kernel_proc()->debug_line_str.ptr);
 
 }

kernel/process/kernel_syscall_impl.c

@@ -17,14 +17,12 @@
 extern page_index *p_index;
 
 void* malloc(size_t size){
-    process_t* k = get_proc_by_pid(1);
+    process_t* k = get_kernel_proc();
     if (!k) return 0;
 
-    int tr = 0;
-    paddr_t heap_pa = mmu_translate(0, k->mm.brk, &tr);
-    if (tr) return 0;
+    if (!k->heap_phys) return 0;
 
-    void* ptr = kalloc((void*)dmap_pa_to_kva(heap_pa), size, ALIGN_16B, MEM_PRIV_KERNEL);
+    void* ptr = kalloc((void*)dmap_pa_to_kva(k->heap_phys), size, ALIGN_16B, MEM_PRIV_KERNEL);
     if (ptr && size >= PAGE_SIZE && k->alloc_map)
         register_allocation(k->alloc_map, ptr, size);
     return ptr;
@@ -36,7 +34,7 @@ void free_sized(void*ptr, size_t size){
 
 void* page_alloc(size_t size){
     if (!size) return 0;
-    process_t* k = get_proc_by_pid(1);//TODO: can we make this more fragmented? This inside a syscall, current proc outside
+    process_t* k = get_kernel_proc();//TODO: can we make this more fragmented? This inside a syscall, current proc outside
     void *ptr = palloc(size, MEM_PRIV_KERNEL, MEM_RW | MEM_NORM, true);
     if (k && k->alloc_map && ptr) register_allocation(k->alloc_map, ptr, size);
     return ptr;
@@ -45,7 +43,7 @@ void* page_alloc(size_t size){
 void page_free(void *ptr){
     if (!ptr) return;
     if (((uintptr_t)ptr & (PAGE_SIZE - 1)) != 0) return;
-    process_t* k = get_proc_by_pid(1);//TODO: can we make this more fragmented? This inside a syscall, current proc outside
+    process_t* k = get_kernel_proc();//TODO: can we make this more fragmented? This inside a syscall, current proc outside
     if (k && k->alloc_map) {
         free_registered(k->alloc_map, ptr);
         return;

kernel/process/loading/elf_file.c

@@ -228,7 +228,7 @@ process_t* load_elf_process_path(const char *name, const char *bundle, const cha
         return 0;
     }
 
-    proc->state = READY;
+    ready_process(proc);
     return proc;
 }