wip on allocator

kernel/memory/pageframe.h

@@ -1,8 +1,16 @@
 #ifndef _PAGEFRAME_H_
 #define _PAGEFRAME_H_
+
+#include "../types.h"
+
 class PageFrame {
     private:
+        uintptr_t address;
+        uintptr_t mapped_address;
     public:
-        PageFrame();
+        PageFrame* queue_link;
+        PageFrame(uintptr_t a):address(a){};
+        uintptr_t getAddr(){return address;};
+        uintptr_t getVirtualAddr(){return address;};
 };
 #endif

kernel/memory/pageframealloc.cc

@@ -1,5 +1,6 @@
 #include "../memory/pageframealloc.h"
 #include "../boot/multiboot/data.h"
+#include "page.h"
 #include "pageframe.h"
 #include "../debug/output.h"
 
@@ -9,48 +10,64 @@
 
 uint8_t PageFrameAllocator::bitmap[4294967296 / 4096 / 8];
 
-void mark_unavailable(uintptr_t start, uintptr_t end){
+//PageFrame PageFrameList[4294967296 / 4096];
-    DBG << "start: " << hex << start << " end: " << end << endl;
+
+void mark_pageframes(uintptr_t start, uintptr_t end, bool available){
+    DBG << "start: " << hex << start << " end: " << end;
+    start = Page::floor(start);
+    end = Page::ceil(end);
+    DBG << " page start: " << hex << start << " end: " << end << endl;
 
     for(uint64_t i = start; i < end; i += 4096){
         uint64_t pg = i/4096;
-        PageFrameAllocator::bitmap[pg/8] &= ~(1 << pg%8);
+        if(available)
+            PageFrameAllocator::bitmap[pg/8] |= (1 << pg%8);
+        else
+            PageFrameAllocator::bitmap[pg/8] &= ~(1 << pg%8);
     }
 }
 
 void PageFrameAllocator::init(){
-    Multiboot::Memory* memory_map_entry = Multiboot::getMemoryMap();
+    Multiboot::Memory* memory_map_start = Multiboot::getMemoryMap();
+    Multiboot::Memory* memory_map_entry = memory_map_start;
 
-    dout << "kernel start: " << ___KERNEL_START___;
+    //mark as available
-    dout << " kernel end: " << ___KERNEL_END___ << endl;
     while(memory_map_entry != 0){
-        void* start =  memory_map_entry->getStartAddress();
+        uintptr_t start =  (uintptr_t)memory_map_entry->getStartAddress();
-        void* end =  memory_map_entry->getEndAddress();
+        uintptr_t end =  (uintptr_t)memory_map_entry->getEndAddress();
         bool available = memory_map_entry->isAvailable();
 
-        //TODO priotity for conflicting regions
+        if(available)
-        for(uint64_t i = (uint64_t)start; i < (uint64_t)end; i += 4096){
+            mark_pageframes(start, end, true);
-            uint64_t pg = i/4096;
-            if(available)
-                bitmap[pg/8] |= 1 << pg%8;
-            else
-                bitmap[pg/8] &= ~(1 << pg%8);
-        }
 
         memory_map_entry = memory_map_entry->getNext();
     }
 
+    //mark as unavailable
+    memory_map_entry = memory_map_start;
+    while(memory_map_entry != 0){
+        uintptr_t start =  (uintptr_t)memory_map_entry->getStartAddress();
+        uintptr_t end =  (uintptr_t)memory_map_entry->getEndAddress();
+        bool available = memory_map_entry->isAvailable();
+
+        if(!available)
+            mark_pageframes(start, end, false);
+
+        memory_map_entry = memory_map_entry->getNext();
+    }
+
+    //mark other known regions as unavailable
     DBG << "kernel image ";
-    mark_unavailable((uintptr_t)&___KERNEL_START___, (uintptr_t)&___KERNEL_END___);
+    mark_pageframes((uintptr_t)&___KERNEL_START___, (uintptr_t)&___KERNEL_END___, false);
 
     DBG << "ISA adresses ";
-    mark_unavailable(0x00F00000, 0x00FFFFFF);
+    mark_pageframes(0x00F00000, 0x00FFFFFF, false);
 
     DBG << "LAPIC ";
-    mark_unavailable(0xfee00000, 0xfee003f0);
+    mark_pageframes(0xfee00000, 0xfee003f0, false);
 
     DBG << "IO APIC ";
-    mark_unavailable(APIC::getIOAPICAddress(), APIC::getIOAPICAddress()+0x10);
+    mark_pageframes(APIC::getIOAPICAddress(), APIC::getIOAPICAddress()+0x10, false);
 
     stats();
 }
@@ -66,8 +83,7 @@ void PageFrameAllocator::stats(){
     }
 
     uint64_t pages_available = 0;
-    for(uint64_t i=0; i<sizeof(bitmap)*8;i++)
+    for(uint64_t i=0; i<sizeof(bitmap)*8;i++){
-    {
         if(bitmap[i/8] & (1<<i%8))
             pages_available++;
     }
@@ -89,11 +105,33 @@ void PageFrameAllocator::stats(){
             DBG << '/';
     }
     DBG << "\npages available: " << dec << pages_available << endl;
-
 }
 
 PageFrame* PageFrameAllocator::alloc(bool kernel){
-    (void) kernel;
+    uintptr_t search_start;
+    uintptr_t search_end;
+    if(kernel){
+        search_start = Page::ceil((uintptr_t)&___KERNEL_END___);
+        search_end = 0x4000000;
+    }
+    else{
+        search_start = 0x4000000;
+        search_end = 0x8000000;
+    }
+
+    uint64_t free_pageframe=0;
+    //TODO make this more efficent
+    for(uint64_t i=search_start/4096; i < search_end/4096; i++){
+        if(bitmap[i/8]&(1<<i%8)){
+            free_pageframe = i;
+            break;
+        }
+    }
+
+    if(!free_pageframe)
+        return 0;
+
+    mark_pageframes(free_pageframe*4096, free_pageframe*4096, false);
     return 0;
 }
 

kernel/memory/pageframealloc.h

@@ -3,9 +3,11 @@
 
 #include <types.h>
 #include "../memory/pageframe.h"
+#include "../object/queue.h"
 
 namespace PageFrameAllocator {
     extern uint8_t bitmap[4294967296 / 4096 / 8];
+	//Queue<PageFrame> PageFrameList;
 
     void init ();
     void stats ();