everything works now for ever

kernel/main.cc

@@ -119,7 +119,7 @@ extern "C" int main() {
 
 	DBG_VERBOSE << "Schedule..." << endl;
 	// Schedule first app
-	g.vault().scheduler.schedule();
+  g.vault().scheduler.schedule();
 
 	return 0;
 }

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

@@ -15,173 +15,186 @@ void *operator new(size_t, void *);
 uint8_t mapNumber = 0;
 
 namespace Syscall {
-namespace Skeleton {
+  namespace Skeleton {
 
 
-void invlpg(uintptr_t virt_addr) {                                                                                                                                                           
+    void invlpg(uintptr_t virt_addr) {                                                                                                                                                           
-  asm volatile("invlpg (%0)" : : "r" (virt_addr) : "memory");                                                                                                                                           
+      asm volatile("invlpg (%0)" : : "r" (virt_addr) : "memory");                                                                                                                                           
-}   
+    }   
 
-size_t test(Vault &vault, size_t p1, size_t p2, size_t p3, size_t p4,
+    size_t test(Vault &vault, size_t p1, size_t p2, size_t p3, size_t p4,
-			size_t p5) {
+        size_t p5) {
-	(void)vault;
+      (void)vault;
-	vault.kout << "test(" << p1 << ", " << p2 << ", " << p3 << ", " << p4
+      vault.kout << "test(" << p1 << ", " << p2 << ", " << p3 << ", " << p4
-			   << ", " << p5 << ");" << endl;
+        << ", " << p5 << ");" << endl;
-	return 0xdeadbeef;
+      return 0xdeadbeef;
-}
-
-int getpid(Vault &vault) {
-	Thread *me = vault.scheduler.active();
-	//unsigned id = 0;
-	//while (&apps[id++] != me); // TODO find better pid source
-    //return id;
-    return me->id;
-}
-
-size_t write(Vault &vault, uint32_t id, const void *buffer, size_t size, int x, int y) {
-    (void)id;
-
-    TextStream* out;
-
-    switch (id) {
-        case 1:
-            out = &vault.kout;
-            break;
-        case 2:
-            out = &dout;
-            break;
-        default:
-            out = &vault.kout;
     }
 
-    int dummy;
+    int getpid(Vault &vault) {
-    if(x == -1 && y != -1)
+      Thread *me = vault.scheduler.active();
+      //unsigned id = 0;
+      //while (&apps[id++] != me); // TODO find better pid source
+      //return id;
+      return me->id;
+    }
+
+    size_t write(Vault &vault, uint32_t id, const void *buffer, size_t size, int x, int y) {
+      (void)id;
+
+      TextStream* out;
+
+      switch (id) {
+        case 1:
+          out = &vault.kout;
+          break;
+        case 2:
+          out = &dout;
+          break;
+        default:
+          out = &vault.kout;
+      }
+
+      int dummy;
+      if(x == -1 && y != -1)
         out->getPos(x, dummy);
-    if(x != -1 && y == -1)
+      if(x != -1 && y == -1)
         out->getPos(dummy, y);
-    if(x == -1 && y == -1)
+      if(x == -1 && y == -1)
         out->getPos(x, y);
 
-    out->setPos(x, y);
+      out->setPos(x, y);
 
-    for(size_t i = 0; i<size; i++)
+      for(size_t i = 0; i<size; i++)
         *out << ((char*)buffer)[i];
-    out->flush();
+      out->flush();
 
-    return 0;
+      return 0;
-}
+    }
 
-size_t read(Vault &vault, uint32_t id, void *buf, size_t len) {
+    size_t read(Vault &vault, uint32_t id, void *buf, size_t len) {
-    (void)id;
+      (void)id;
 
-    size_t read_cnt = 0;
+      size_t read_cnt = 0;
-    while(read_cnt < len){
+      while(read_cnt < len){
         Key key;
         vault.keys_sem.p(vault);
         vault.keys.consume(key);
         if(key.valid())
-            ((char*)buf)[read_cnt++] = key.ascii();
+          ((char*)buf)[read_cnt++] = key.ascii();
         else
-            break;
+          break;
+      }
+      return read_cnt;
     }
-    return read_cnt;
-}
 
-void sleep(Vault &vault, size_t ms) {
+    void sleep(Vault &vault, size_t ms) {
-	vault.bellringer.sleep(vault, ms);
+      vault.bellringer.sleep(vault, ms);
-}
-
-bool sem_init(Vault &vault, size_t id, uint32_t value) {
-  if (id >= vault.MAX_SEMS) {
-    return false;             // out‐of‐range id
-  }
-  if (vault.sems[id].used==1){
-    return false;  //already in use
-  }
-
-  vault.sems[id].counter=value;
-	return true;
-}
-
-bool sem_destroy(Vault &vault, size_t id) {
-  if (id >= vault.MAX_SEMS) {
-    return false;             // out‐of‐range id
-  }
-  if (vault.sems[id].used==0){
-    return false;  //already in free
-  }
-
-  vault.sems[id].used=0;
-  vault.sems[id].counter=0;
-	return true;
-}
-
-bool sem_signal(Vault &vault, size_t id) {
-  vault.sems[id].v(vault);
-
-  return true;
-}
-
-bool sem_wait(Vault &vault, size_t id) {
-  vault.sems[id].p(vault);
-  return true;
-}
-
-void exit(Vault &vault) {
-    vault.scheduler.exit();
-}
-
-void kill(Vault &vault, size_t pid){
-    //vault.scheduler.kill(&apps[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++) {
-      PageFrameAllocator::alloc(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);
+
-    mapNumber++;
+    bool sem_init(Vault &vault, size_t id, uint32_t value) {
+      if (id >= vault.MAX_SEMS) {
+        return false;             // out‐of‐range id
+      }
+      if (vault.sems[id].used==1){
+        return false;  //already in use
+      }
+
+      vault.sems[id].counter=value;
+      return true;
+    }
+
+    bool sem_destroy(Vault &vault, size_t id) {
+      if (id >= vault.MAX_SEMS) {
+        return false;             // out‐of‐range id
+      }
+      if (vault.sems[id].used==0){
+        return false;  //already in free
+      }
+
+      vault.sems[id].used=0;
+      vault.sems[id].counter=0;
+      return true;
+    }
+
+    bool sem_signal(Vault &vault, size_t id) {
+      vault.sems[id].v(vault);
+
+      return true;
+    }
+
+    bool sem_wait(Vault &vault, size_t id) {
+      vault.sems[id].p(vault);
+      return true;
+    }
+
+    void exit(Vault &vault) {
+      vault.scheduler.exit();
+    }
+
+    void kill(Vault &vault, size_t pid){
+      //vault.scheduler.kill(&apps[pid]);
+    }
+
+
+
+    void* getFreeVirtSpace(Vault* vault, uint8_t num_pages){
+      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;
+          }  
+        }
+        if(space_is_free)
+          return  (void*) ((uintptr_t) (v <<12));
+      }
+      return 0;
+
   }
-  return subtable; 
-}   
 
+    void* map(Vault *vault, size_t size) {
+      size_t num_pages = (size + 4096 - 1) / 4096;
+      pagetable_t* subbytable = vault->scheduler.active()->subtable;
 
-int unmap(Vault &vault, void* start, size_t size) {  
+      void* ptr = getFreeVirtSpace(vault, num_pages);
-  int NumberOfPages = (1 + (size/4096));
+      if (ptr == nullptr) {
+        return nullptr;
+      }
+      uintptr_t gap_start = reinterpret_cast<uintptr_t>(ptr);
 
-//  for int i=0; i < NumberOfPages-1; i++ {
+      // map all used pages
-//      PageFrameAllocator::alloc(false);
+      for (size_t i = 0; i < num_pages; ++i) {
-//  }
+        // allocate each page with allocator	
+        void* frame = PageFrameAllocator::alloc(false);
 
-  	for(uint8_t i=0; i<NumberOfPages; i++){
+        subbytable->entries[(( (uintptr_t) frame-64*1024*1024) /4096)] ={
-		subtable->entries[i] = {
+          .present = 1,
-			.present = 0,
+          .write =1,
-			.user = 0,
+          .user =1,
-			.address =(uintptr_t) start
+          .address = i+((uintptr_t) ptr >> 12) 
-		};
+        };
-    memset(start, 0, 4096);
-    invlpg(start);
-    mapNumber++;
 
-	}
+      }
-  return 0; 
+      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;
-}  // namespace Skeleton
+          }
+        }
+      }
+      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;