foo

core/mem/pmm.c

@@ -25,7 +25,7 @@ static struct phys_mem* bump_region = nullptr;
 
 static errno_t bump_alloc(size_t num_pages, enum alloc_flags flags, phys_t* out) {
     const size_t bytes = num_pages * arch_mem_page_size();
-    if (((intptr_t)bump_mem.length - bytes) <= 0)
+    if (bytes > bump_mem.length)
         return ENOMEM;
 
     *out = bump_mem.address;
@@ -76,7 +76,7 @@ static errno_t freelist_alloc(size_t num_pages, enum alloc_flags flags, phys_t*
     while (it) {
         const phys_t page_addr = (((uintptr_t)it - (uintptr_t)vm_pfndb) / sizeof(struct page)) * arch_mem_page_size();
         // If the region is too high up or doesn't have enough pages left, continue searching.
-        if (page_addr + bytes >= limit || __unlikely(it->freelist.count < num_pages)) {
+        if (__unlikely(it->freelist.count < num_pages) || page_addr + bytes > limit) {
             prev_it = it;
             it = it->freelist.next;
             continue;
@@ -96,11 +96,26 @@ static errno_t freelist_alloc(size_t num_pages, enum alloc_flags flags, phys_t*
                 *out = page_addr;
         }
         // If not, we can just shrink the block.
-        else {
+        else if (page_addr + it->freelist.count * arch_mem_page_size() <= limit) {
             it->freelist.count -= num_pages;
 
             if (__likely(out))
                 *out = page_addr + (it->freelist.count * arch_mem_page_size());
+        } else {
+            struct page* rest = it + num_pages;
+            rest->freelist.count = it->freelist.count - num_pages;
+            rest->freelist.next = it->freelist.next;
+
+            if (prev_it)
+                prev_it->freelist.next = rest;
+            else
+                pmm_head = rest;
+
+            it->freelist.next = nullptr;
+            it->freelist.count = 0;
+
+            if (__likely(out))
+                *out = page_addr;
         }
         goto success;
     }
@@ -118,13 +133,41 @@ success:
     return 0;
 }
 
+static void freelist_insert(struct page* page, size_t num_pages) {
+    struct page* prev = nullptr;
+    struct page* next = pmm_head;
+    while (next && next < page) {
+        prev = next;
+        next = next->freelist.next;
+    }
+
+    page->freelist.count = num_pages;
+    page->freelist.next = next;
+
+    if (next && page + page->freelist.count == next) {
+        page->freelist.count += next->freelist.count;
+        page->freelist.next = next->freelist.next;
+        next->freelist.next = nullptr;
+        next->freelist.count = 0;
+    }
+
+    if (prev && prev + prev->freelist.count == page) {
+        prev->freelist.count += page->freelist.count;
+        prev->freelist.next = page->freelist.next;
+        page->freelist.next = nullptr;
+        page->freelist.count = 0;
+    } else if (prev) {
+        prev->freelist.next = page;
+    } else {
+        pmm_head = page;
+    }
+}
+
 static errno_t freelist_free(phys_t addr, size_t num_pages) {
     spin_lock(&pmm_lock);
 
-    struct page* page = &vm_pfndb[addr / arch_mem_page_size()];
-    page->freelist.count = num_pages;
-    page->freelist.next = pmm_head;
-    pmm_head = page;
+    freelist_insert(&vm_pfndb[addr / arch_mem_page_size()], num_pages);
+    pmm_total_free += num_pages;
 
     spin_unlock(&pmm_lock);
     return 0;
@@ -141,11 +184,9 @@ void mem_phys_init(struct phys_mem* map, size_t length) {
         if (map[i].length < arch_mem_page_size() || map[i].usage != PHYS_USABLE)
             continue;
 
-        struct page* page = &vm_pfndb[map[i].address / arch_mem_page_size()];
-        page->freelist.count = map[i].length / arch_mem_page_size();
-        page->freelist.next = pmm_head;
-        pmm_head = page;
-        pmm_total_free += page->freelist.count;
+        const size_t num_pages = map[i].length / arch_mem_page_size();
+        freelist_insert(&vm_pfndb[map[i].address / arch_mem_page_size()], num_pages);
+        pmm_total_free += num_pages;
     }
 
     const size_t free_bytes = (pmm_total_free * arch_mem_page_size());