Merge branch 'master' of gitlab.ibr.cs.tu-bs.de:vss/teaching/ws25/v_bsb2/Gruppe_003

kernel/syscall/handler.cc

@@ -74,6 +74,17 @@ extern "C" size_t syscall_handler(size_t sysnum, size_t p1, size_t p2,
             return  (size_t) Skeleton::map(&(Guard::enter().vault()), p1);
          case Syscall::ID::UNMAP:
             return (int) Skeleton::unmap(Guard::enter().vault(), (void*) (p1), p2);
+         case Syscall::ID::SEND:
+            return Skeleton::send(Guard::enter().vault(), static_cast<int>(p1), reinterpret_cast<const void*>(p2), p3, reinterpret_cast<void*>(p4), p5);
+         case Syscall::ID::RECEIVE:
+            return Skeleton::receive(Guard::enter().vault(), (void*)(p1), p2);
+         case Syscall::ID::REPLY:
+            return Skeleton::reply(Guard::enter().vault(), (void*)(p1), p2);
+      //   case Syscall::ID::FORK:
+      //      return Skeleton::fork(v, user);
+            break;
+
+
     }
 
 	return static_cast<size_t>(-1);

kernel/syscall/skeleton.cc

@@ -4,6 +4,7 @@
 #include "../debug/output.h"
 #include "../device/textstream.h"
 #include "../interrupt/guard.h"
+#include "../memory/page.h"
 #include "../sync/semaphore.h"
 #include "../thread/scheduler.h"
 #include "../memory/pageframealloc.h"
@@ -283,5 +284,107 @@ namespace Syscall {
       }
       return 0; 
     }
+
+
+bool copy_from_phys(Vault& vault, uintptr_t phys_ptr, void* virt_ptr, size_t size) {
+	Thread* current_thread = vault.scheduler.active();
+	
+	size_t offset = Page::offset(phys_ptr); 
+	size_t total_size = size + offset;
+  four_lvl_paging_t* search_table = vault.scheduler.active()->paging_tree;
+
+	void* page_ptr = getFreeVirtSpace(search_table, total_size); // page aligned pointer 
+	if (page_ptr == nullptr) {
+		return false;
+	}
+	
+	uintptr_t virt_addr = (uintptr_t)(page_ptr) + offset;
+  for(uint8_t i =0; i<size/4096; i++){
+    setMapping(virt_addr, (void*)phys_ptr, vault.scheduler.active()->paging_tree);
+  }
+
+	memcpy(virt_ptr, (void*)(virt_addr), size);
+	PageFrameAllocator::free((uintptr_t)(page_ptr));
+	
+	return true;
+}
+
+
+
+bool send(Vault& v, int pid, const void* sbuffer, size_t ssize, void* rbuffer, size_t rsize) {
+	Thread* current_thread = v.scheduler.active();
+	Thread* target_thread = v.thread_list[pid];
+
+	uintptr_t sbuffer_ptr = (uintptr_t) target_thread->paging_tree;
+
+    // Erstelle Nachichtenobjekt
+	IpcStruct msg = {sbuffer_ptr, ssize, current_thread->id, false, nullptr};
+	
+	target_thread->ipc_queue.enqueue(msg);
+	target_thread->ipc_sem.v(v);
+
+	while (true) {
+		current_thread->ipc_sem.p(v);
+		if (msg.is_answer) {
+			break;
+		}
+		DBG_VERBOSE << "" << endl;
+	}
+
+	// Kopiere Antwort
+	if (!copy_from_phys(v, msg.ptr, rbuffer, rsize)) {
+		return false;
+	}
+
+	return true;
+}
+
+int receive(Vault& v, void* buffer, size_t size) {
+
+	// DBG_VERBOSE << "Receive syscall for thread " << dec << v.scheduler.active()->id << endl;
+	Thread* thread = v.scheduler.active();
+
+	// Warte auf Nachricht
+	if (thread->ipc_queue.is_empty()) {
+		thread->ipc_sem.p(v);
+	}
+	
+	IpcStruct* ipc = thread->ipc_queue.first();
+	if (ipc == nullptr) return -1;
+	
+	// Buffer holen
+	if (!copy_from_phys(v, ipc->ptr, buffer, size)) {
+		return -3;
+	}
+	
+	return ipc->pid;
+}
+
+bool reply(Vault& v, const void* buffer, size_t size) {
+
+  Thread* current_thread = v.scheduler.active();
+  IpcStruct* ipc = current_thread->ipc_queue.dequeue();
+
+  // if (!ipc || ipc->pid < 0 || static_cast<size_t>(ipc->pid) >= v.thread_count) return false;
+
+  Thread* other_thread = v.thread_list[ipc->pid];
+  if (other_thread == nullptr) return false;
+
+  uintptr_t phys_ptr =  (uintptr_t) current_thread->paging_tree;
+
+  ipc->ptr = phys_ptr;
+  ipc->size = size;
+  ipc->pid = current_thread->id;
+  ipc->is_answer = true;
+
+  // Sender aufwecken
+  other_thread->ipc_sem.v(v);
+
+  return true;
+}
+
+
+
+
   }  // namespace Skeleton
 }  // namespace Syscall

kernel/syscall/skeleton.h

@@ -26,6 +26,11 @@ void kill(Vault &vault, size_t pid);
 void* map(Vault *vault, size_t size);
 int unmap(Vault &vault, void* start, size_t size);
 void invlpg(uintptr_t virt_addr);
+bool send(Vault &vault, int pid, const void* sbuffer, size_t ssize, void* rbuffer, size_t rsize);
+int receive(Vault &vault, void* buffer, size_t size);
+bool reply(Vault &vaul, const void* buffer, size_t size);
+//int fork(Vault &vault, InterruptContext *user);
+
 
 }  // namespace Skeleton
 }  // namespace Syscall

kernel/syscall/stub.h

@@ -5,7 +5,7 @@ namespace Syscall {
 /*! \brief Syscall IDs
  *  \note the syscall number must correspond to the values in the syscall stub!
  */
-enum class ID : size_t {
+  enum class ID : size_t {
     TEST = 0,
     WRITE = 1,
     READ = 2,
@@ -18,7 +18,11 @@ enum class ID : size_t {
     SYS_EXIT = 9,
     SYS_KILL = 10,
     MAP = 11,                                                                                                                                                                                       
-    UNMAP = 12
+    UNMAP = 12,
+    SEND = 13,
+    RECEIVE = 14,
+    REPLY = 15,
+    //	FORK = 16
 };
 }  // namespace Syscall
 
@@ -81,3 +85,15 @@ extern "C" ssize_t sys_safe_call(Syscall::ID id, size_t p1, size_t p2,
   [[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);                                                                                                                                              
 }
+
+[[gnu::always_inline]] static inline bool send(int pid, const void* sbuffer, size_t ssize, void* rbuffer, size_t rsize) {
+	return sys_call(Syscall::ID::SEND, pid, (size_t)sbuffer, ssize, (size_t)rbuffer, rsize);
+}
+
+[[gnu::always_inline]] static inline int receive(void* buffer, size_t size) {
+	return sys_call(Syscall::ID::RECEIVE, (size_t)buffer, size,0,0,0);
+}
+
+[[gnu::always_inline]] static inline bool reply(const void* buffer, size_t size) {
+	return sys_call(Syscall::ID::REPLY, (size_t)buffer, size,0,0,0);
+}