flaming pile of shit

kernel/syscall/handler.cc

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

kernel/syscall/skeleton.cc

@@ -6,14 +6,22 @@
 #include "../interrupt/guard.h"
 #include "../sync/semaphore.h"
 #include "../thread/scheduler.h"
-
+#include "../memory/pageframealloc.h"
 void *operator new(size_t, void *);
 
 //#include "../user/app1/appl.h"
 //extern Application apps[];
 
+uint8_t mapNumber = 0;
+
 namespace Syscall {
 namespace Skeleton {
+
+
+void invlpg(uintptr_t virt_addr) {                                                                                                                                                           
+  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 p5) {
 	(void)vault;
@@ -126,5 +134,54 @@ void exit(Vault &vault) {
 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++;
+  }
+  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; 
+
+
+
+}
+
+
+
 }  // namespace Skeleton
 }  // namespace Syscall

kernel/syscall/skeleton.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "types.h"
-
+#include "../memory/pagetable.h"
 struct Vault;
 
 namespace Syscall {
@@ -23,6 +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);
+int unmap(Vault &vault, void* start, size_t size);
+	pagetable_t* subtable;
 
 }  // namespace Skeleton
 }  // namespace Syscall

kernel/syscall/stub.h

@@ -16,7 +16,9 @@ enum class ID : size_t {
     SEM_SIGNAL=7,
     SYS_GETPID = 8,
     SYS_EXIT = 9,
-    SYS_KILL = 10
+    SYS_KILL = 10,
+    MAP = 11,                                                                                                                                                                                       
+    UNMAP = 12
 };
 }  // namespace Syscall
 
@@ -64,10 +66,18 @@ extern "C" ssize_t sys_safe_call(Syscall::ID id, size_t p1, size_t p2,
 }
 
 [[gnu::always_inline]] static inline void sys_exit(){
-    sys_call(Syscall::ID::SYS_EXIT, 0, 0, 0, 0, 0);
+  sys_call(Syscall::ID::SYS_EXIT, 0, 0, 0, 0, 0);
 }
 
 [[gnu::always_inline]] static inline void sys_kill(size_t pid){
-    sys_call(Syscall::ID::SYS_KILL, pid, 0, 0, 0, 0);
+  sys_call(Syscall::ID::SYS_KILL, pid, 0, 0, 0, 0);
 }
 
+
+[[gnu::always_inline]] static inline void* map(size_t size) {                                                                                                                           
+  return  (void*) sys_call(Syscall::ID::MAP, size,0,0,0,0);                                                                                                                                                        
+}                                                                                                                                                                                                         
+
+  [[gnu::always_inline]] static inline int unmap(void*  start, size_t size) {                                                                                                                               
+  return sys_call(Syscall::ID::UNMAP,  (size_t)  start, size,0,0,0);                                                                                                                                              
+}