rewrite code for map/unmap

kernel/syscall/skeleton.cc

@@ -14,6 +14,8 @@ void *operator new(size_t, void *);
 
 uint8_t mapNumber = 0;
 
+uint32_t next_start_v = 0x4000;
+
 namespace Syscall {
   namespace Skeleton {
 
@@ -138,64 +140,142 @@ namespace Syscall {
     }
 
 
+    uintptr_t isMapped(uintptr_t vaddr, four_lvl_paging_t* flpt){
+        uint16_t l4Index = (vaddr>>39) & 0x1FF;
+        uint16_t l3Index = (vaddr>>30) & 0x1FF;
+        uint16_t l2Index = (vaddr>>21) & 0x1FF;
+        uint16_t l1Index = (vaddr>>12) & 0x1FF;
 
-    void* getFreeVirtSpace(Vault* vault, uint8_t num_pages){
+        if(flpt->l4->entries[l4Index].present){
-      pagetable_t* subbytable = vault->scheduler.active()->subtable;
+            pagetable_t* lvl3 = (pagetable_t*)(flpt->l4->entries[l4Index].address<<12);
-      //uint32_t page_counter=0;
+            if(lvl3->entries[l3Index].present){
-      for (uint32_t v=0x4000; v<0x4200; v++) { 
+                pagetable_t* lvl2 = (pagetable_t*)(lvl3->entries[l3Index].address<<12);
-        bool space_is_free = true;
+                if(lvl2->entries[l2Index].present){
-        for(uint32_t i=0; i<num_pages; i++){
+                    pagetable_t* lvl1 = (pagetable_t*)(lvl2->entries[l2Index].address<<12);
-          if(subbytable->entries[v-0x4000+i].present) {
+                    if(lvl1->entries[l1Index].present)
-            space_is_free = false;
+                        return lvl1->entries[l1Index].address<<12;
-          }  
+                }
+            }
         }
-        if(space_is_free)
+        return 0;
-          return  (void*) ((uintptr_t) (v <<12));
+    }
+
+    void* getFreeVirtSpace(four_lvl_paging_t* search_table, uint8_t num_pages){
+      uint32_t start_v = 0x4000;
+      uint32_t stop_v = 0x6000;
+      //static uint32_t next_start_v = start_v;
+
+      //start from last found address
+      for (uint32_t v=next_start_v; v<stop_v; v++) {
+          bool space_is_free = true;
+          for(uint32_t i=0; i<num_pages; i++){
+              if(isMapped((uintptr_t)(v+i)<<12, search_table)) {
+                  space_is_free = false;
+              }
+          }
+          if(space_is_free){
+              next_start_v = v+num_pages;
+              return  (void*) ((uintptr_t) (v <<12));
+          }
+      }
+      //start again from the real start address
+      for (uint32_t v=start_v; v<next_start_v; v++) {
+          bool space_is_free = true;
+          for(uint32_t i=0; i<num_pages; i++){
+              if(isMapped((uintptr_t)(v+i)<<12, search_table)) {
+                  space_is_free = false;
+              }
+          }
+          if(space_is_free){
+              next_start_v = v+num_pages;
+              return  (void*) ((uintptr_t) (v <<12));
+          }
       }
       return 0;
+    }
 
-  }
+    void setMapping(uintptr_t vaddr, void* frame, four_lvl_paging_t* flpt){
+        uint16_t l4Index = (vaddr>>39) & 0x1FF;
+        uint16_t l3Index = (vaddr>>30) & 0x1FF;
+        uint16_t l2Index = (vaddr>>21) & 0x1FF;
+        uint16_t l1Index = (vaddr>>12) & 0x1FF;
+
+        if(!(flpt->l4->entries[l4Index].present)){
+            pagetable_t* newl3 = (pagetable_t*)PageFrameAllocator::alloc(true);
+            flpt->l4->entries[l4Index] = {
+                .present = 1,
+                .write = 1,
+                .user = 1,
+                .address = (uintptr_t)newl3 >> 12
+            };
+        }
+
+        pagetable_t* lvl3 = (pagetable_t*)(flpt->l4->entries[l4Index].address<<12);
+        if(!(lvl3->entries[l3Index].present)){
+            pagetable_t* newl2 = (pagetable_t*)PageFrameAllocator::alloc(true);
+            lvl3->entries[l3Index] = {
+                .present = 1,
+                .write = 1,
+                .user = 1,
+                .address = (uintptr_t)newl2 >> 12
+            };
+        }
+
+        pagetable_t* lvl2 = (pagetable_t*)(lvl3->entries[l3Index].address<<12);
+        if(!(lvl2->entries[l2Index].present)){
+            pagetable_t* newl1 = (pagetable_t*)PageFrameAllocator::alloc(true);
+            lvl2->entries[l2Index] = {
+                .present = 1,
+                .write = 1,
+                .user = 1,
+                .address = (uintptr_t)newl1 >> 12
+            };
+        }
+
+        pagetable_t* lvl1 = (pagetable_t*)(lvl2->entries[l2Index].address<<12);
+        assert(!(lvl1->entries[l1Index].present)); // should not be present, bc its a new mapping
+
+        if(frame)
+            lvl1->entries[l1Index] = {
+                .present = 1,
+                .write = 1,
+                .user = 1,
+                .address = (uintptr_t)frame >> 12
+            };
+        else //unmap if nullptr
+            lvl1->entries[l1Index].present = 0;
+    }
 
     void* map(Vault *vault, size_t size) {
       size_t num_pages = (size + 4096 - 1) / 4096;
-      pagetable_t* subbytable = vault->scheduler.active()->subtable;
+      //pagetable_t* subbytable = vault->scheduler.active()->subtable;
+      four_lvl_paging_t* search_table = vault->scheduler.active()->paging_tree;
 
-      void* ptr = getFreeVirtSpace(vault, num_pages);
+      void* ptr = getFreeVirtSpace(search_table, num_pages);
       if (ptr == nullptr) {
         return nullptr;
       }
-      uintptr_t gap_start = reinterpret_cast<uintptr_t>(ptr);
 
       // map all used pages
       for (size_t i = 0; i < num_pages; ++i) {
         // allocate each page with allocator	
         void* frame = PageFrameAllocator::alloc(false);
-
+        setMapping((uintptr_t)ptr, frame, search_table);
-        subbytable->entries[(( (uintptr_t) ptr-64*1024*1024) /4096)+i] ={
-          .present = 1,
-          .write =1,
-          .user =1,
-          .address = ((uintptr_t) frame >> 12) 
-        };
-
       }
       return ptr;
     }
 
     int unmap(Vault &vault, void* start, size_t size) {  
       uint32_t NumberOfPages = (size/4096);
-      pagetable_t* subbytable = vault.scheduler.active()->subtable;
+      four_lvl_paging_t* search_table = vault.scheduler.active()->paging_tree;
-      uint32_t startIndex = (((uintptr_t)start-64*1024*1024)>>12);  
+      uint32_t startIndex = ((uintptr_t)start)>>12;
       memset(start, 0, size);
 
       for(uint32_t i=startIndex; i<(startIndex+NumberOfPages); i++){
-        for (uint32_t p =0; p<512 ; p++) {
+          uintptr_t frame = isMapped(i<<12, search_table);
-          if (subbytable->entries[p].present==1 && subbytable->entries[p].address==i) { 
+          setMapping(i<<12, 0, search_table);
-            invlpg(i);
+          PageFrameAllocator::free(frame);
-            PageFrameAllocator::free(subbytable->entries[p].address);
+          invlpg(i);
-            subbytable->entries[i].present =0;
-          }
-        }
       }
       return 0; 
     }