[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Lost] [Patch] kernel: RPC-Parameter prüfen



Antoine Kaufmann schrieb:
Index: src/kernel/src/mm/paging.c
===================================================================
--- src/kernel/src/mm/paging.c  (Revision 699)
+++ src/kernel/src/mm/paging.c  (Arbeitskopie)
-        return (paddr_t) (
-            (page_directory[vpage / PAGE_TABLE_LENGTH] & ~0x3FFFFF)
-          | ((dword) vaddr & 0x3FFFFF));
+        return (page_directory[vpage / PAGE_TABLE_LENGTH] & ~0x3FF000)
+            | ((dword) vaddr & 0x3FF000);

Was ist die Überlegung hinter diesem Rückgabewert? Ich sehe da nicht, warum das so Kompliziert sein muss. Sind die Bits im PD-Eintrag nicht an der gewünschten Stelle, oder wo ist das Problem?

Die Überlegung war, daß resolve_vaddr() bisher mit 4M-Pages umgehen kann und ich das nicht kaputtmachen wollte, auch wenn wir es im Moment nicht nutzen. Die einfachere Lösung wäre es aber vermutlich wirklich, in resolve_vaddr() den Rückgabewert einfach auf PTE_PS zu prüfen und entsprechend viel von der virtuellen Adresse dazuzuoren - Wald vor lauter Bäumen nicht gesehen und so...

Neuer Versuch:
Index: src/kernel/include/paging.h
===================================================================
--- src/kernel/include/paging.h	(Revision 699)
+++ src/kernel/include/paging.h	(Arbeitskopie)
@@ -11,6 +11,8 @@
 bool map_page(page_directory_t page_directory, vaddr_t vaddr, paddr_t paddr, int flags);
 bool unmap_page(page_directory_t page_directory, vaddr_t vaddr);
 paddr_t resolve_vaddr(page_directory_t page_directory, vaddr_t vaddr);
+bool is_userspace(vaddr_t start, dword len);
+
 vaddr_t find_contiguous_pages(page_directory_t page_directory, int num, dword lower_limit, dword upper_limit);
 void increase_user_stack_size(struct task * task_ptr, int pages);
 
Index: src/kernel/src/syscall.c
===================================================================
--- src/kernel/src/syscall.c	(Revision 699)
+++ src/kernel/src/syscall.c	(Arbeitskopie)
@@ -67,22 +67,6 @@
 dword debug_last_syscall_data[DEBUG_LAST_SYSCALL_DATA_SIZE] = { 0 };
 #endif 
 
-/**
- * Prueft, ob ein Speicherbereich komplett gemappt ist und PTE_U gesetzt
- * hat.
- *
- * FIXME Tut sie in dieser Form natuerlich nicht
- */
-bool is_userspace(vaddr_t start, dword len)
-{
-    if (start + len < start) {
-        return FALSE;
-    }
-
-    return ((uintptr_t) start >= USER_MEM_START) 
-        && ((uintptr_t) start + len <= USER_MEM_END);
-}
-
 void syscall(struct int_stack_frame ** esp) 
 {
     struct int_stack_frame * isf = *esp;
@@ -677,13 +661,26 @@
         {
             struct task* callee = get_task(*((dword*) isf->esp));
 
+            dword metadata_size = *((dword*) (isf->esp + 4));
+            void* metadata = *((void**) (isf->esp + 8));
+            dword data_size = *((dword*) (isf->esp + 12));
+            void* data = *((void**) (isf->esp + 16));
+
+            if (!is_userspace(metadata, metadata_size)) {
+                abort_task("SYSCALL_FASTRPC: Ungueltige Metadaten (%08x)",
+                    (dword) metadata);
+            }
+            
+            if (!is_userspace(data, data_size)) {
+                abort_task("SYSCALL_FASTRPC: Ungueltige Daten (%08x)",
+                    (dword) data);
+            }
+
             isf->eax = 0;
             if (fastrpc(
                 callee,
-                *((dword*) (isf->esp + 4)),
-                *((void**) (isf->esp + 8)),
-                *((dword*) (isf->esp + 12)),
-                *((void**) (isf->esp + 16))
+                metadata_size, metadata,
+                data_size, data    
             )) {
                 schedule_to_task(callee, (dword*) esp);
             } else {
Index: src/kernel/src/mm/paging.c
===================================================================
--- src/kernel/src/mm/paging.c	(Revision 699)
+++ src/kernel/src/mm/paging.c	(Arbeitskopie)
@@ -285,18 +285,23 @@
     return map_page(page_directory, vaddr, NULL, 0);
 }
 
-
 /**
- * Loest eine virtuelle Adresse bezueglich eines Page Directory
- * in eine physische Adresse auf.
+ * Gibt den Pagetable-Eintrag zu einer gegebenen virtuellen Speicheradresse
+ * zurueck.
  *
- * @return Physische Adresse oder NULL, wenn die Page nicht vorhanden ist
+ * @param page_directory Page Directory, auf das sich die Adresse bezieht
+ * @param vaddr Aufzuloesende virtuelle Adresse
+ *
+ * @return Pagetable-Eintrag der 4K-Seite, zu der die gegebene virtuelle
+ * Adresse gehoert. 0, wenn die Adresse nicht in einer Seite liegt, die
+ * present ist.
  */
-paddr_t resolve_vaddr(page_directory_t page_directory, vaddr_t vaddr)
+static dword get_pagetable_entry
+    (page_directory_t page_directory, vaddr_t vaddr)
 {
     page_table_t page_table;
     paddr_t phys_page_table;
-    paddr_t result;
+    dword result;
     
     dword vpage = (dword) vaddr / PAGE_SIZE;
     //kprintf("[Resolv: %x in PD %x]", vaddr, page_directory);
@@ -304,30 +309,23 @@
     // Passende Page Table suchen
     // Bei einer 4M-Page sind wir eigentlich schon am Ziel
     if ((page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_P) == 0) {
-        return NULL;
+        return 0;
     } else if (page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_PS) {
-      
-        return (paddr_t) (
-            (page_directory[vpage / PAGE_TABLE_LENGTH] & ~0x3FFFFF)
-          | ((dword) vaddr & 0x3FFFFF));
-        
+        return page_directory[vpage / PAGE_TABLE_LENGTH];
     } else {
-        phys_page_table = (page_table_t) (page_directory[vpage / PAGE_TABLE_LENGTH] & ~0xFFF);
+        phys_page_table = (page_table_t) 
+            (page_directory[vpage / PAGE_TABLE_LENGTH] & ~0xFFF);
     }
         
-    // Die Page-Table-Adresse ist eine physische Adresse. Am sichersten ist es, die
-    // Adresse einfach noch einmal zu mappen.
+    // Die Page-Table-Adresse ist eine physische Adresse. Am sichersten ist es,
+    // die Adresse einfach noch einmal zu mappen.
     page_table = map_phys_addr(phys_page_table, PAGE_SIZE);
     
     // Adresse zusammenbasteln und fertig
     if (page_table[vpage % PAGE_TABLE_LENGTH] & PTE_P) {
-        
-        result = (paddr_t) (
-            (page_table[vpage % PAGE_TABLE_LENGTH] & ~0xFFF) 
-          | ((dword) vaddr & 0xFFF));
-        
+        result = page_table[vpage % PAGE_TABLE_LENGTH]; 
     } else {
-        result = NULL;
+        result = 0;
     }
         
     // Falls wir die Page Table extra in den Kerneladressraum gemappt haben,
@@ -337,8 +335,50 @@
     return result;
 }
 
+/**
+ * Loest eine virtuelle Adresse bezueglich eines Page Directory
+ * in eine physische Adresse auf.
+ *
+ * @return Physische Adresse oder NULL, wenn die Page nicht vorhanden ist
+ */
+paddr_t resolve_vaddr(page_directory_t page_directory, vaddr_t vaddr)
+{
+    dword pte = get_pagetable_entry(page_directory, vaddr);
+    
+    if ((pte & PTE_PS) == 0) {
+        return (paddr_t) ((pte & ~0xFFF) | ((dword) vaddr & 0xFFF));
+    } else {
+        return (paddr_t) ((pte & ~0x3FFFFF) | ((dword) vaddr & 0x3FFFFF));
+    }
+}
 
 /**
+ * Prueft, ob ein Speicherbereich im Page Directory des aktuellen Tasks
+ * komplett gemappt ist und PTE_U (Zugriffsrecht fuer Usermode) gesetzt hat.
+ */
+bool is_userspace(vaddr_t start, dword len)
+{
+    vaddr_t cur;
+
+    if (start + len < start) {
+        return FALSE;
+    }    
+    
+    for (cur = start; 
+        (cur < start + len) && (cur > (vaddr_t) 0xFFF); 
+        cur += PAGE_SIZE) 
+    {
+        dword pte = get_pagetable_entry(current_task->cr3, cur);
+        if ((pte == 0) || (!pte & PTE_U)) {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+
+/**
  * Findet einen freien Bereich mit num freien Seiten
  *
  * @return Die Anfangsadresse der ersten Seite dieses Bereiches