Changeset e3c762cd in mainline for generic/src/mm

Timestamp:

2006-05-05T11:59:19Z (20 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

de07bcf

Parents:

22cf454d

Message:

Complete implementation of copy_from_uspace() and copy_to_uspace()
for amd64 and ia32. Other architectures still compile and run,
but need to implement their own assembly-only memcpy(), memcpy_from_uspace(),
memcpy_to_uspace() and their failover parts. For these architectures
only dummy implementations are provided.

Location:

generic/src/mm

Files:

• as.c (modified) (8 diffs)
• slab.c (modified) (4 diffs)

generic/src/mm/as.c

@@ -58 +58 @@
 #include <adt/btree.h>
 #include <proc/task.h>
+#include <proc/thread.h>
 #include <arch/asm.h>
 #include <panic.h>
@@ -69 +70 @@
 #include <arch/types.h>
 #include <typedefs.h>
+#include <syscall/copy.h>
+#include <arch/interrupt.h>
 
 as_operations_t *as_operations = NULL;
@@ -478 +481 @@
  *
  * @param page Faulting page.
- *
- * @return 0 on page fault, 1 on success.
- */
-int as_page_fault(__address page)
+ * @param istate Pointer to interrupted state.
+ *
+ * @return 0 on page fault, 1 on success or 2 if the fault was caused by copy_to_uspace() or copy_from_uspace().
+ */
+int as_page_fault(__address page, istate_t *istate)
 {
         pte_t *pte;
@@ -497 +501 @@
                  */
                 spinlock_unlock(&AS->lock);
-                return 0;
+                goto page_fault;
         }
 
@@ -507 +511 @@
                 spinlock_unlock(&area->lock);
                 spinlock_unlock(&AS->lock);
-                return 0;               
+                goto page_fault;                
         }
 
@@ -555 +559 @@
         spinlock_unlock(&area->lock);
         spinlock_unlock(&AS->lock);
-        return 1;
+        return AS_PF_OK;
+
+page_fault:
+        if (!THREAD)
+                return AS_PF_FAULT;
+        
+        if (THREAD->in_copy_from_uspace) {
+                THREAD->in_copy_from_uspace = false;
+                istate_set_retaddr(istate, (__address) &memcpy_from_uspace_failover_address);
+        } else if (THREAD->in_copy_to_uspace) {
+                THREAD->in_copy_to_uspace = false;
+                istate_set_retaddr(istate, (__address) &memcpy_to_uspace_failover_address);
+        } else {
+                return AS_PF_FAULT;
+        }
+
+        return AS_PF_DEFER;
 }
 
@@ -885 +905 @@
 {
         as_area_acptsnd_arg_t arg;
-        
-        copy_from_uspace(&arg, uspace_accept_arg, sizeof(as_area_acptsnd_arg_t));
+        int rc;
+        
+        rc = copy_from_uspace(&arg, uspace_accept_arg, sizeof(as_area_acptsnd_arg_t));
+        if (rc != 0)
+                return rc;
         
         if (!arg.size)
@@ -907 +930 @@
 {
         as_area_acptsnd_arg_t arg;
-        
-        copy_from_uspace(&arg, uspace_send_arg, sizeof(as_area_acptsnd_arg_t));
+        int rc;
+        
+        rc = copy_from_uspace(&arg, uspace_send_arg, sizeof(as_area_acptsnd_arg_t));
+        if (rc != 0)
+                return rc;
 
         if (!arg.size)

generic/src/mm/slab.c

@@ -176 +176 @@
                 slab = data + fsize - sizeof(*slab);
         }
-                
+        
         /* Fill in slab structures */
         for (i=0; i < (1 << cache->order); i++)
@@ -278 +278 @@
                 /* Allow recursion and reclaiming
                  * - this should work, as the slab control structures
-                 *   are small and do not need to allocte with anything
-                 *   other ten frame_alloc when they are allocating,
+                 *   are small and do not need to allocate with anything
+                 *   other than frame_alloc when they are allocating,
                  *   that's why we should get recursion at most 1-level deep
                  */
@@ -880 +880 @@
 
         ASSERT(_slab_initialized);
-        ASSERT( size && size <= (1 << SLAB_MAX_MALLOC_W));
+        ASSERT(size && size <= (1 << SLAB_MAX_MALLOC_W));
         
         if (size < (1 << SLAB_MIN_MALLOC_W))
@@ -890 +890 @@
 }
 
-
 void free(void *obj)
 {