everything works now for ever

kernel/syscall/handler.cc

@@ -71,7 +71,7 @@ extern "C" size_t syscall_handler(size_t sysnum, size_t p1, size_t p2,
             Syscall::Skeleton::kill(Guard::enter().vault(),p1);
             return 0;
          case Syscall::ID::MAP:
-            return  (size_t) Skeleton::map(Guard::enter().vault(), p1);
+            return  (size_t) Skeleton::map(&(Guard::enter().vault()), p1);
          case Syscall::ID::UNMAP:
             return (int) Skeleton::unmap(Guard::enter().vault(), (void*) (p1), p2);
     }

kernel/syscall/skeleton.cc

@@ -136,52 +136,65 @@ void kill(Vault &vault, size_t pid){
     }
 
 
-void* map(Vault &vault, size_t size) { 
-  int NumberOfPages = (1 + (size/4096));
-  subtable  = (pagetable_t*)  PageFrameAllocator::alloc(false);
 
-  for (int i=0; i < NumberOfPages-1; i++) {
+    void* getFreeVirtSpace(Vault* vault, uint8_t num_pages){
-      PageFrameAllocator::alloc(false);
+      pagetable_t* subbytable = vault->scheduler.active()->subtable;
+      //uint32_t page_counter=0;
+      for (uint32_t v=0x4000; v<0x4200; v++) { 
+        bool space_is_free = true;
+        for(uint32_t i=0; i<num_pages; i++){
+          if(subbytable->entries[v-0x4000+i].present) {
+            space_is_free = false;
           }  
-
-  for(uint8_t i=0; i<NumberOfPages; i++){
-    subtable->entries[i] = {
-      .present = 1,
-      .user = 1,
-      .address = ((uintptr_t)(0x6000+ mapNumber*0x10)) + i
         }
-    memset((void*)((0x6000+(mapNumber*0x10)) >> 12) , 0, 4096);
+        if(space_is_free)
-    mapNumber++;
+          return  (void*) ((uintptr_t) (v <<12));
-  }
-  return subtable; 
-}   
-
-
-int unmap(Vault &vault, void* start, size_t size) {  
-  int NumberOfPages = (1 + (size/4096));
-
-//  for int i=0; i < NumberOfPages-1; i++ {
-//      PageFrameAllocator::alloc(false);
-//  }
-
-  	for(uint8_t i=0; i<NumberOfPages; i++){
-		subtable->entries[i] = {
-			.present = 0,
-			.user = 0,
-			.address =(uintptr_t) start
-		};
-    memset(start, 0, 4096);
-    invlpg(start);
-    mapNumber++;
-
       }
       return 0;
 
-
-
   }
 
+    void* map(Vault *vault, size_t size) {
+      size_t num_pages = (size + 4096 - 1) / 4096;
+      pagetable_t* subbytable = vault->scheduler.active()->subtable;
 
+      void* ptr = getFreeVirtSpace(vault, 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);
+
+        subbytable->entries[(( (uintptr_t) frame-64*1024*1024) /4096)] ={
+          .present = 1,
+          .write =1,
+          .user =1,
+          .address = i+((uintptr_t) ptr >> 12) 
+        };
+
+      }
+      return ptr;
+    }
+
+    int unmap(Vault &vault, void* start, size_t size) {  
+      uint32_t NumberOfPages = (size/4096);
+      pagetable_t* subbytable = vault.scheduler.active()->subtable;
+      uint32_t startIndex = (((uintptr_t)start-64*1024*1024)>>12);  
+      memset(start, 0, size);
+
+      for(uint32_t i=startIndex; i<(startIndex+NumberOfPages); i++){
+        for (uint32_t p =0; p<512 ; p++) {
+          if (subbytable->entries[p].present==1 && subbytable->entries[p].address==i) { 
+            invlpg(i);
+            subbytable->entries[i].present =0;
+          }
+        }
+      }
+      return 0; 
+    }
   }  // namespace Skeleton
 }  // namespace Syscall

kernel/syscall/skeleton.h

@@ -23,9 +23,9 @@ bool sem_signal(Vault &vault, size_t id);
 bool sem_wait(Vault &vault, size_t id);
 void exit(Vault &vault);
 void kill(Vault &vault, size_t pid);
-void* map(Vault &vault, size_t size);
+void* map(Vault *vault, size_t size);
 int unmap(Vault &vault, void* start, size_t size);
-	pagetable_t* subtable;
+void invlpg(uintptr_t virt_addr);
 
 }  // namespace Skeleton
 }  // namespace Syscall

kernel/thread/thread.h

@@ -34,7 +34,6 @@ class Thread {
 	void* start;
 
 
-	pagetable_t* subtable;
 
 	friend class Queue<Thread>;
 	friend class Semaphore;
@@ -75,6 +74,7 @@ class Thread {
 		void* isr;
 	} StackPointer;
 	void* operator new  ( size_t count )noexcept;
+	pagetable_t* subtable;
 
 	/*! \brief Unique thread id */
 	const int id;