changed pmm to be a freelist allocator instead of bitmap

3 files changed, 35 insertions, 108 deletions

diff --git a/kernel/include/mm/pmm.h b/kernel/include/mm/pmm.h
index 772bc44..a2af030 100644
--- a/kernel/include/mm/pmm.h
+++ b/kernel/include/mm/pmm.h
@@ -5,15 +5,8 @@
 #include <stddef.h>
 #include <limine.h>
 
-struct Bitmap {
-    Bitmap* next;
-    uint64_t length;
-    uint64_t limit;
-    uint64_t* address;
-};
-
 void pmm_init(limine_memmap_response* memmap);
-uint64_t palloc();
-void pfree(uint64_t page);
+uint64_t page_alloc();
+void page_free(uint64_t page);
 
 #endif
\ No newline at end of file
diff --git a/kernel/kernel.cpp b/kernel/kernel.cpp
index 9fbab22..3801082 100644
--- a/kernel/kernel.cpp
+++ b/kernel/kernel.cpp
@@ -9,7 +9,7 @@
 

 namespace {

 __attribute__((used, section(".requests")))

-volatile LIMINE_BASE_REVISION(2);

+volatile LIMINE_BASE_REVISION(3);

 }

 

 namespace {

@@ -98,12 +98,6 @@ extern "C" void _start() {
     draw_pixel(727, 727, 0x9528fd);

     draw_pixel(0, 0, 0xff0000);

     draw_pixel(framebuffer->width - 1, framebuffer->height - 1, 0x00ff00);

-    // for (size_t i = 0; i < framebuffer->mode_count; i++) {

-    //     printf("Mode %d\n", i);

-    //     printf("Pitch %d\nWidth %d\nHeight %d\nbpp %d\nmem_model %d\n",

-    //     framebuffer->modes[i]->pitch, framebuffer->modes[i]->width, framebuffer->modes[i]->height,

-    //     framebuffer->modes[i]->bpp, framebuffer->modes[i]->memory_model);

-    // }

 

     printf("Actual framebuffer:\n");

     printf("Pitch %d\nWidth %d\nHeight %d\nbpp %d\nmem_model %d\n",

@@ -118,6 +112,14 @@ extern "C" void _start() {
 

     printf("hhdm offset: %lx\n", _hhdm_offset);

     pmm_init(memmap_request.response);

+

+    uint64_t tester = page_alloc();

+    printf("tester: %lx\n", tester);

+    page_free(tester);

+    tester = page_alloc();

+    printf("tester: %lx\n", tester);

+    uint64_t tester2 = page_alloc();

+    printf("tester 2: %lx\n", tester2);

     

     // We're done, just hang...

     hcf();

diff --git a/kernel/mm/pmm.cpp b/kernel/mm/pmm.cpp
index fb92767..685f038 100644
--- a/kernel/mm/pmm.cpp
+++ b/kernel/mm/pmm.cpp
@@ -2,111 +2,43 @@
 #include <kernel.h>
 #include <stdio.h>
 
-#define BIT_WIDTH 64
+struct freelist {
+    freelist* next = nullptr;
+};
 
-Bitmap* head;
+freelist* head = nullptr;
 
 void pmm_init(limine_memmap_response* memmap) {
-    Bitmap* current = nullptr;
-    Bitmap* tail = nullptr;
-    bool first = true;
 
-    for (size_t i = 0; i < memmap->entry_count; i++) {
+    for (int i = 0; i < memmap->entry_count; i++) {
+        // only maps usable entries
         if (memmap->entries[i]->type == LIMINE_MEMMAP_USABLE) {
-            // sets bitmap struct pointer address
-            current = (Bitmap*)(memmap->entries[i]->base + _hhdm_offset);
-
-            // sets up bitmap
-            current->address = (uint64_t*)(memmap->entries[i]->base + sizeof(Bitmap) + _hhdm_offset);
-
-            current->limit = memmap->entries[i]->length;
-
-            // almost always will be less pages than the full space
-            // since it doesn't account for remainders (yet)
-            // length / page size / bit width
-            current->length = memmap->entries[i]->length / 0x1000uL / BIT_WIDTH;
-            if (current->length < 1) {
-                continue;
-            }
-            // printf("len %lx\n", current->length);
-
-            // allocate memory for the bitmaps themselves
-            // printf("test %lx\n", current->limit / 0x40000uL / BIT_WIDTH);
-            for (size_t i = 0; i < (current->limit / 0x1000uL / BIT_WIDTH / BIT_WIDTH) + 1; i++) {
-                for (size_t j = 0; j < BIT_WIDTH; j++) {
-                    // shifts bits off the right and masks the rest out to check for a 0
-                    if (!((current->address[i] >> j) & 0x1uL)) {
-                        current->address[i] |= 0x1uL << j;
-                        // printf("init alloc: %lx\n", ((i * BIT_WIDTH) + j) * 0x1000uL + (uint64_t)current - _hhdm_offset);
-                        break;
-                    }
+            printf("%d\n", i);
+            // iterates through all addresses
+            for (uint64_t addr = memmap->entries[i]->base; addr < (memmap->entries[i]->length + memmap->entries[i]->base); addr += 0x1000ul) {
+                freelist* temp = (freelist*)(addr + _hhdm_offset);
+                if (head) {
+                    temp->next = head;
+                    head = temp;
+                } else {
+                    temp->next = nullptr;
+                    head = temp;
                 }
             }
-
-            if (first) {
-                current->next = nullptr;
-                tail = current;
-                head = current;
-                first = false;
-            } 
-            else {
-                tail->next = current;
-                tail = current;
-            }
         }
     }
 
-    tail->next = nullptr;
-
     printf("Initialized PMM\n");
 }
 
-uint64_t palloc() {
-    Bitmap* current = head;
-
-    while (true) {
-        for (size_t i = 0; i < current->length; i++) {
-            //if ((current->address[i] & UINT64_MAX) != UINT64_MAX) {
-                for (size_t j = 0; j < BIT_WIDTH; j++) {
-                    // shifts bits off the right and masks the rest out to check for a 0
-                    if (!((current->address[i] >> j) & 0x1uL)) {
-                        current->address[i] |= 0x1uL << j;
-                        // printf("addr: %lx\n", current + j);
-                        return ((i * BIT_WIDTH) + j) * 0x1000uL + (uint64_t)current - _hhdm_offset;
-                    }
-                }
-            //}
-        }
-
-        if (current->next == nullptr) {
-            return NULL;
-        }
-        current = current->next;
-    }
+uint64_t page_alloc() {
+    freelist* alloced = head;
+    head = head->next;
+    return (uint64_t)alloced;
 }
 
-void pfree(uint64_t page) {
-    Bitmap* current = head;
-    int offset;
-
-    while (true) {
-        if (page + _hhdm_offset >= (uint64_t)current) {
-            if (page + _hhdm_offset <= current->limit + (uint64_t)current) {
-                break;
-            }
-        }
-        current = current->next;
-    }
-    
-    // Gets the starting number of the mem region page to get the correct bit number
-    // start 4D000, freeing 4E000, offset D - E = 1 = bit in bitmap
-    offset = ((uint64_t)current / 0x1000uL) & 0xFuL; 
-    // divided by the amount of address space each index can hold
-    // should probably put that in its own variable/define later
-    uint64_t index = (page - ((uint64_t)current - _hhdm_offset)) / 0x40000uL;
-    int bit = page / 0x1000uL % BIT_WIDTH - offset;
-
-    // printf("before: %lx, ", current->address[index]);
-    current->address[index] &= ~(0x1uL << bit);
-    // printf("after: %lx\n", current->address[index]);
+void page_free(uint64_t page) {
+    freelist* freed = (freelist*)page;
+    freed->next = head;
+    head = freed;
 }
\ No newline at end of file