Broken attempt at freelist pmm.

5 files changed, 71 insertions, 62 deletions

diff --git a/kernel/arch/x86_64/limine.cpp b/kernel/arch/x86_64/limine.cpp
index b592592..5e9905f 100644
--- a/kernel/arch/x86_64/limine.cpp
+++ b/kernel/arch/x86_64/limine.cpp
@@ -62,12 +62,17 @@ extern void (*__init_array_end[])();
 

 void kernel_main();

 

+// this will cause problems later

+uint64_t _hhdm_offset;

+

 extern "C" void _start() {

     asm("cli");

     if (!LIMINE_BASE_REVISION_SUPPORTED) {

         hcf();

     }

 

+    _hhdm_offset = hhdm_request.response->offset;

+

     // setup gdt

     SegDesc segs[5];

     GDTR gdtr{sizeof(struct SegDesc) * 5 - 1, (uint64_t)&segs};

@@ -129,10 +134,15 @@ extern "C" void _start() {
         memmap->entries[i]->base, memmap->entries[i]->length, memmap->entries[i]->type);

     }

 

-    // broken printf mirroring 64 bit values for some reason

-    //uint64_t tester = 0xFFFE0000000000AE + 1;

-    //printf("aaaa: %lx\n", tester);

-    pmm_init(memmap_request.response, hhdm_request.response->offset);

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

+    // pmm_init(memmap_request.response);

+    

+    // asm("xchgw %bx, %bx");

+    // uint64_t pmm_test[5];

+    // for (size_t i = 0; i < 5; i++) {

+    //     pmm_test[i] = (uint64_t)palloc();

+    //     printf("Alloc %d: %lx\n", i, pmm_test[i]);

+    // }

 

     kernel_main();

 

diff --git a/kernel/include/kernel.h b/kernel/include/kernel.h
new file mode 100644
index 0000000..9f641ae
--- /dev/null
+++ b/kernel/include/kernel.h
@@ -0,0 +1,8 @@
+#ifndef KERNEL_H
+#define KERNEL_H
+
+#include <stdint.h>
+
+extern const uint64_t _hhdm_offset;
+
+#endif
\ No newline at end of file
diff --git a/kernel/include/mm/pmm.h b/kernel/include/mm/pmm.h
index bfe21c5..c81438f 100644
--- a/kernel/include/mm/pmm.h
+++ b/kernel/include/mm/pmm.h
@@ -5,23 +5,12 @@
 #include <stddef.h>
 #include <limine.h>
 
-enum mm_type {
-    MEM_USABLE,
-    MEM_RESERVED
+struct pmm_list_node {
+    pmm_list_node* next;
 };
 
-struct MMEntry {
-    uint64_t base;
-    uint64_t length;
-    mm_type type;
-};
-
-struct PBitmap {
-    uint64_t* addr;
-    size_t size;
-    MMEntry entry;
-};
-
-void pmm_init(limine_memmap_response* memmap, uint64_t hhdm_offset);
+void pmm_init(limine_memmap_response* memmap);
+void* palloc();
+void pfree(void* page);
 
 #endif
\ No newline at end of file
diff --git a/kernel/makefile b/kernel/makefile
index 030caaa..99b2dd8 100644
--- a/kernel/makefile
+++ b/kernel/makefile
@@ -1,11 +1,11 @@
 # Kernel makefile

 

 CFLAGS := -ffreestanding -Wall -Wextra -g -std=gnu99 -O2 -Iinclude --sysroot=$(SYSROOT) \

-	-isystem="/usr/include"

+	-isystem $(SYSROOT)/usr/include

 CXXFLAGS := -ffreestanding -Wall -Wextra -fno-exceptions -fno-rtti -g -O2 -Iinclude --sysroot=$(SYSROOT) \

-	-isystem="/usr/include" -std=gnu++20

+	-isystem $(SYSROOT)/usr/include -std=gnu++20

 LDFLAGS := -T arch/$(ARCH)/linker.ld -ffreestanding -g -O2 -Iinclude --sysroot=$(SYSROOT) \

-	-isystem="/usr/include"

+	-isystem $(SYSROOT)/usr/include

 ASMFLAGS :=

 

 ifeq ($(ARCH),x86_64)

diff --git a/kernel/mm/pmm.cpp b/kernel/mm/pmm.cpp
index bd8f12c..632bc1d 100644
--- a/kernel/mm/pmm.cpp
+++ b/kernel/mm/pmm.cpp
@@ -1,55 +1,57 @@
 #include <mm/pmm.h>
+#include <kernel.h>
 #include <stdio.h>
 
-PBitmap bitmap;
+pmm_list_node* head;
+pmm_list_node* tail;
 
-// Finds the biggest chunk of memory
-static MMEntry find_mem_chunk(limine_memmap_response* memmap) {
-    uint64_t highestmem = 0;
-    size_t highestindex = 0;
-    limine_memmap_entry* entries = memmap->entries[0];
+void pmm_init(limine_memmap_response* memmap) {
     for (size_t i = 0; i < memmap->entry_count; i++) {
-        if (entries[i].type == LIMINE_MEMMAP_USABLE && entries[i].length > highestmem) {
-            highestmem = entries[i].length;
-            highestindex = i;
+        if (memmap->entries[i]->type != LIMINE_MEMMAP_USABLE) {
+            continue;
         }
-    }
-
-    return MMEntry{
-        entries[highestindex].base,
-        entries[highestindex].length,
-        MEM_USABLE
-    };
-}
 
-void pmm_init(limine_memmap_response* memmap, uint64_t hhdm_offset) {
-    MMEntry mem_entry = find_mem_chunk(memmap);
-
-    // Round any numbers needed to 4K boudaries
-    //mem_entry.base += 4096 - (mem_entry.base % 4096);
-    mem_entry.length -= mem_entry.length % 4096;
-
-    // setup bitmap at the beginning of the chunk
-    bitmap.entry = mem_entry;
-    bitmap.addr = (uint64_t*)(bitmap.entry.base + hhdm_offset);
-    // divided by byte size since size is for iterating over the bitmap
-    bitmap.size = mem_entry.length / 4096 / sizeof(uint64_t);
+        // Puts a node into each page of usable physical memory
+        
+        if (head != nullptr) {
+            head->next = (pmm_list_node*)(memmap->entries[i]->base + _hhdm_offset);
+        }
 
-    printf("addr: %lx\nsize: %lx\n", (uint64_t)bitmap.addr, bitmap.size);
-    printf("hhdm offset: %lx\n", hhdm_offset);
+        if (tail != nullptr) {
+            tail = (pmm_list_node*)(memmap->entries[i]->base + _hhdm_offset);
+        }
 
-    // write test
-    for (size_t i = 0; i < 100; i++) {
-        bitmap.addr[i] = i;
-        //printf("value %d: %lx\n", i, bitmap.addr[i]);
+        for (size_t j = 0; j < memmap->entries[i]->length; j += 0x1000) {
+            pmm_list_node* page = (pmm_list_node*)(memmap->entries[i]->base + j + _hhdm_offset);
+            //head->next = page;
+            page->next = page + 0x1000;
+            head = page;
+            //tail = page;
+        }
     }
 
-    // read test
-    for (size_t i = 0; i < bitmap.size; i++) {
-        //printf("value %d: %lx\n");
+    // sets head->next to first set page
+    for (size_t i = 0; i < memmap->entry_count; i++) {
+        if (memmap->entries[i] == LIMINE_MEMMAP_USABLE) {
+            head->next = tail;
+            // head = (pmm_list_node*)(memmap->entries[i]->base + _hhdm_offset);
+            //tail->next = head;
+            break;
+        }
     }
+
+    printf("Initialized PMM\n");
 }
 
-uint64_t get_phys_page() {
+void* palloc() {
+    pmm_list_node* node = head;
+    printf("Head: %lx\nNext: %lx\n", head, head->next);
+    head = head->next;
+    return node;
+}
 
+void pfree(void* page) {
+    pmm_list_node* node = (pmm_list_node*)page + _hhdm_offset;
+    node->next = head;
+    head = node;
 }
\ No newline at end of file