restructure app output

kernel/memory/pagetable.cc

@@ -188,7 +188,7 @@ void* getFreeVirtSpace(pagetable_t* l4, uint8_t num_pages){
             }
         }
         if(space_is_free){
-            //next_start_v = v+num_pages;
+            next_start_v = v+num_pages;
             return  (void*) ((uintptr_t) (v <<12));
         }
     }

kernel/syscall/skeleton.cc

@@ -132,9 +132,8 @@ namespace Syscall {
     }
 
     void exit(Vault &vault) {
-
-      unmap(vault, (void*) 0x4000, 512 );
       vault.scheduler.exit();
+      unmap(vault, (void*) 0x4000000, 512 );
     }
 
     void kill(Vault &vault, size_t pid){
@@ -175,23 +174,26 @@ namespace Syscall {
     }
 
 
-bool copy_from_phys(Vault& vault, uintptr_t phys_ptr, void* virt_ptr, size_t size) {
-	size_t offset = Page::offset(phys_ptr); 
+bool copy_from_phys(Vault& vault, uintptr_t src_paddr, void* dest_vaddr, size_t size) {
+	size_t offset = Page::offset(src_paddr);
 	size_t total_size = size + offset;
     four_lvl_paging_t* search_table = vault.scheduler.active()->paging_tree;
 
-	void* virt_addr =  getFreeVirtSpace(search_table->l4, (total_size/4096)+1); // page aligned pointer 
-	if (virt_addr == nullptr) {
+	uintptr_t src_vaddr = (uintptr_t)getFreeVirtSpace(search_table->l4, (total_size/4096)+1); // page aligned pointer
+	if (src_vaddr == 0) {
 		return false;
 	}
+    src_vaddr += offset;
 
     for(uint8_t i =0; i<size/4096  +1; i++){
-        //TODO actually use loop
-        setMapping((uintptr_t)virt_addr, (void*)phys_ptr, vault.scheduler.active()->paging_tree->l4);
+        setMapping(src_vaddr+(uintptr_t)(i*4096), (void*)(src_paddr+(uintptr_t)(i*4096)), search_table->l4);
     }
 
-	memcpy(virt_ptr, (void*)((uintptr_t)(virt_addr)+ (uintptr_t)offset), size);
-    setMapping((uintptr_t)(virt_addr), 0, search_table->l4);
+	memcpy(dest_vaddr, (void*)src_vaddr, size);
+
+    for(uint8_t i =0; i<size/4096  +1; i++){
+        setMapping((uintptr_t)(src_vaddr), 0, search_table->l4);
+    }
 
 	return true;
 }
@@ -202,16 +204,15 @@ bool send(Vault& v, int pid, const void* sbuffer, size_t ssize, void* rbuffer, s
 	Thread* current_thread = v.scheduler.active();
 	Thread* target_thread = v.thread_list[pid];
 
-	uintptr_t sbuffer_ptr = isMapped((uintptr_t)sbuffer,v.scheduler.active()->paging_tree->l4) + ((uintptr_t)sbuffer&0xFFF);
-IpcStruct msg {
-  .ptr        = sbuffer_ptr,
+	//uintptr_t sbuffer_ptr = isMapped((uintptr_t)sbuffer,v.scheduler.active()->paging_tree->l4) + ((uintptr_t)sbuffer&0xFFF);
+
+    IpcStruct msg = {
+        .ptr        = (uintptr_t)sbuffer,
         .size       = ssize,
         .pid        = current_thread->id,
         .is_answer  = false,
         .queue_link = nullptr
-};
-
-
+    };
 
 	target_thread->ipc_queue.enqueue(msg);
 	target_thread->ipc_sem.v(v);
@@ -223,12 +224,21 @@ IpcStruct msg {
 		}
 		DBG_VERBOSE << "" << endl;
 	}
+    uint8_t num_pages = (rsize/4096)+1;
 
-	// Kopiere Antwort
-	if (!copy_from_phys(v, msg.ptr, rbuffer, rsize)) {
+  // Kopiere Antwort                                  size  kann mehr sein 
+  for(uint8_t i=0;i<num_pages;i++){
+    uintptr_t paddr = isMapped(msg.ptr, target_thread->paging_tree->l4); //always page aligned
+    if(rsize-i*4096>4096){                                                               // ganze pages
+      if (!copy_from_phys(v,paddr,(void*)((uintptr_t) rbuffer+ (4096*i)),4096)) {
         return false;
       }
-
+    } else {                                                          //teil von pages
+      if (!copy_from_phys(v,paddr,(void*)((uintptr_t)rbuffer+ 4096*i), rsize-i*4096)) {
+        return false;
+      }
+    }
+  }
   return true;
 }
 
@@ -246,9 +256,16 @@ int receive(Vault& v, void* buffer, size_t size) {
 	if (ipc == nullptr) return -1;
 	
     size_t copy_len = (size < ipc->size) ? size:ipc->size;
-	// Buffer holen
-	if (!copy_from_phys(v, ipc->ptr, buffer, copy_len)) {
-		return -3;
+    size_t total_len = (Page::offset(ipc->ptr)+copy_len);
+    uint8_t num_pages = (total_len/4096)+1;
+    
+    for(uint32_t i=0; i<num_pages; i++){
+        uintptr_t offset = i==0?Page::offset(ipc->ptr):0; //apply offset only on first page
+        uintptr_t paddr = isMapped((ipc->ptr)+(i*4096), v.thread_list[ipc->pid]->paging_tree->l4);
+        if(total_len - (i*4096) > 4096)
+            copy_from_phys(v, paddr+offset,(void*)((uintptr_t)buffer+i*4096), 4096-offset);
+        else
+            copy_from_phys(v, paddr, (void*)((uintptr_t)buffer+i*4096), total_len - (i*4096)); //last page
     }
 	
 	return ipc->pid;
@@ -268,8 +285,7 @@ bool reply(Vault& v, const void* buffer, size_t size) {
   Thread* other_thread = v.thread_list[ipc->pid];
   if (other_thread == nullptr) return false;
 
-  uintptr_t phys_ptr = isMapped((uintptr_t)buffer, current_thread->paging_tree->l4 );
-  ipc->ptr = phys_ptr + ((uintptr_t)buffer & 0xFFF);
+  ipc->ptr = (uintptr_t)buffer;
   ipc->size = size;
   ipc->pid = current_thread->id;
   ipc->is_answer = true;

notes

@@ -33,4 +33,21 @@
                       schedule(2)   kickoff
 
 
+
+
+
+
 p/x ((pagetable_t*)(((pagetable_t*)(((pagetable_t*)(child.paging_tree.l4.entries[0].address<<12)).entries[0].address<<12)).entries[0].address<<12)).entries[0]
+
+
+
+
+bei fork nur den richtigen speicher kopieren, nicht alle  globale daten wie bei initrd ? 
+
+beim iterieren über pagetables bei copy simple und recursive halten, einfach alles kopieren was nicht supervisormode
+
+
+cow    instruction pointer zurückgehen
+
+pagetable bits nutzen für copy on write markierung
+

user/app2/appl.cc

@@ -7,8 +7,10 @@ void main() {
     fork();
     fork();
     int ppid = sys_getpid();
-    write(1, "app", 3, 0, ppid);
     int other = fork();
+
+    int pid = sys_getpid();
+    write(1, "app", 3, 0, pid);
     if (ppid == other) { // child
         sbuf[0] = 3;
         sbuf[8192] = sys_getpid();
@@ -18,12 +20,14 @@ void main() {
         char msg[] = "REPLY: AA\n";
         msg[7] += rbuf[0] + sbuf[8193];
         msg[8] += 4 + ppid;
-        write(0, msg, 10);
+        write(0, msg, 10, 20, pid);
     } else { // parent
+      //  int X = recv(rbuf, 8193);
         receive(rbuf, 8193);
         rbuf[0] = rbuf[0] + rbuf[8192];
         rbuf[8193] = 7;
-        reply(rbuf, 8193);
+     //   reply(X,rbuf, 8193);
+      reply(rbuf,8193);
     }
  
     sys_exit();