Changeset 20d50a1 in mainline for generic

Timestamp:

2006-01-13T13:02:45Z (20 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

f9425006

Parents:

0369911

Message:

Memory management work.

• vm.* → as.* (as like address space is, imho, more fitting)
• Don't do TLB shootdown on vm_install(). Some architectures only need to call tlb_invalidate_asid().
• Don't allocate all frames for as_area in as_area_create(), but let them be allocated on-demand by as_page_fault().
• Add high-level page fault handler as_page_fault().
• Add as_area_load_mapping().

Location:

generic

Files:

• include/arch.h (modified) (2 diffs)
• include/mm/as.h (moved) (moved from generic/include/mm/vm.h ) (2 diffs)
• include/proc/task.h (modified) (2 diffs)
• include/typedefs.h (modified) (1 diff)
• src/main/kinit.c (modified) (4 diffs)
• src/main/main.c (modified) (3 diffs)
• src/mm/as.c (added)
• src/mm/frame.c (modified) (1 diff)
• src/mm/page.c (modified) (2 diffs)
• src/mm/vm.c (deleted)
• src/proc/scheduler.c (modified) (2 diffs)
• src/proc/task.c (modified) (3 diffs)
• src/proc/the.c (modified) (1 diff)

generic/include/arch.h

@@ -40 +40 @@
 #define THREAD                  THE->thread
 #define TASK                    THE->task
-#define VM                      THE->vm
+#define AS                      THE->as
 #define PREEMPTION_DISABLED     THE->preemption_disabled
 
@@ -53 +53 @@
         task_t *task;                   /**< Current task. */
         cpu_t *cpu;                     /**< Executing cpu. */
-        vm_t *vm;                       /**< Current vm. */
+        as_t *as;                       /**< Current address space. */
 };
 

generic/include/mm/as.h

@@ -27 +27 @@
  */
 
-#ifndef __VM_H__
-#define __VM_H__
+#ifndef __AS_H__
+#define __AS_H__
 
 #include <arch/mm/page.h>
-#include <arch/mm/vm.h>
+#include <arch/mm/as.h>
 #include <arch/mm/asid.h>
 #include <arch/types.h>
@@ -49 +49 @@
 #define UDATA_ADDRESS   UDATA_ADDRESS_ARCH
 
-enum vm_type {
-        VMA_TEXT = 1, VMA_DATA, VMA_STACK 
+enum as_area_type {
+        AS_AREA_TEXT = 1, AS_AREA_DATA, AS_AREA_STACK 
 };
 
-/*
- * Each vm_area_t structure describes one continuous area of virtual memory.
- * In the future, it should not be difficult to support shared areas of vm.
+/** Address space area structure.
+ *
+ * Each as_area_t structure describes one contiguous area of virtual memory.
+ * In the future, it should not be difficult to support shared areas.
  */
-struct vm_area {
+struct as_area {
         SPINLOCK_DECLARE(lock);
         link_t link;
-        vm_type_t type;
-        int size;
-        __address address;
-        __address *mapping;
+        as_area_type_t type;
+        size_t size;            /**< Size of this area. */
+        __address base;         /**< Base address of this area. */
+        index_t *mapping;       /**< Map of physical frame numbers mapped to virtual page numbers in this area. */
 };
 
-/*
- * vm_t contains the list of vm_areas of userspace accessible
+/** Address space structure.
+ *
+ * as_t contains the list of as_areas of userspace accessible
  * pages for one or more tasks. Ranges of kernel memory pages are not
  * supposed to figure in the list as they are shared by all tasks and
  * set up during system initialization.
  */
-struct vm {
+struct as {
         SPINLOCK_DECLARE(lock);
-        link_t vm_area_head;
+        link_t as_area_head;
         pte_t *ptl0;
-        asid_t asid;
+        asid_t asid;                    /**< Address space identifier. */
 };
 
-extern vm_t * vm_create(pte_t *ptl0);
-extern void vm_destroy(vm_t *m);
+extern as_t * as_create(pte_t *ptl0);
+extern as_area_t *as_area_create(as_t *as, as_area_type_t type, size_t size, __address base);
+extern void as_area_load_mapping(as_area_t *a, index_t *pfn);
+extern int as_page_fault(__address page);
+extern void as_install(as_t *m);
 
-extern vm_area_t *vm_area_create(vm_t *m, vm_type_t type, size_t size, __address addr);
-extern void vm_area_destroy(vm_area_t *a);
-
-extern void vm_area_map(vm_area_t *a, vm_t *m);
-extern void vm_area_unmap(vm_area_t *a, vm_t *m);
-
-extern void vm_install(vm_t *m);
-extern void vm_uninstall(vm_t *m);
+/*
+ * Each architecture should implement this function.
+ * Its main purpose is to do TLB purges according
+ * to architecture's requirements. Note that
+ * some architectures invalidate their TLB automatically
+ * on hardware address space switch (e.g. ia32 and
+ * amd64).
+ */
+#ifndef as_install_arch
+extern void as_install_arch(as_t *as);
+#endif /* !def as_install_arch */
 
 #endif

generic/include/proc/task.h

@@ -34 +34 @@
 #include <list.h>
 
+/** Task structure. */
 struct task {
         SPINLOCK_DECLARE(lock);
         link_t th_head;         /**< List of threads contained in this task. */
         link_t tasks_link;      /**< Link to other tasks within the system. */
-        vm_t *vm;
+        as_t *as;               /**< Address space. */
 };
 
@@ -45 +46 @@
 
 extern void task_init(void);
-extern task_t *task_create(vm_t *m);
+extern task_t *task_create(as_t *as);
 
 #endif

generic/include/typedefs.h

@@ -71 +71 @@
 typedef struct region region_t;
 
-typedef enum vm_type vm_type_t;
-typedef struct vm_area vm_area_t;
-typedef struct vm vm_t;
+typedef enum as_area_type as_area_type_t;
+typedef struct as_area as_area_t;
+typedef struct as as_t;
 
 typedef struct link link_t;

generic/src/main/kinit.c

@@ -40 +40 @@
 #include <mm/page.h>
 #include <arch/mm/page.h>
-#include <mm/vm.h>
+#include <mm/as.h>
 #include <mm/frame.h>
 #include <print.h>
@@ -71 +71 @@
         thread_t *t;
 #ifdef CONFIG_USERSPACE
-        vm_t *m;
-        vm_area_t *a;
+        as_t *as;
+        as_area_t *a;
+        __address frame;
+        index_t pfn[1];
         task_t *u;
 #endif
@@ -142 +144 @@
          * Create the first user task.
          */
-        m = vm_create(NULL);
-        if (!m)
-                panic("vm_create\n");
-        u = task_create(m);
+        as = as_create(NULL);
+        if (!as)
+                panic("as_create\n");
+        u = task_create(as);
         if (!u)
                 panic("task_create\n");
@@ -153 +155 @@
 
         /*
-         * Create the text vm_area and copy the userspace code there.
+         * Create the text as_area and copy the userspace code there.
          */     
-        a = vm_area_create(m, VMA_TEXT, 1, UTEXT_ADDRESS);
+        a = as_area_create(as, AS_AREA_TEXT, 1, UTEXT_ADDRESS);
         if (!a)
-                panic("vm_area_create: vm_text\n");
-        vm_area_map(a, m);
+                panic("as_area_create: text\n");
+
+        frame = frame_alloc(0, ONE_FRAME, NULL);
+
         if (config.init_size > 0)
-                memcpy((void *) PA2KA(a->mapping[0]), (void *) config.init_addr, config.init_size < PAGE_SIZE ? config.init_size : PAGE_SIZE);
+                memcpy((void *) PA2KA(frame), (void *) config.init_addr, config.init_size < PAGE_SIZE ? config.init_size : PAGE_SIZE);
         else
-                memcpy((void *) PA2KA(a->mapping[0]), (void *) utext, utext_size < PAGE_SIZE ? utext_size : PAGE_SIZE);
+                memcpy((void *) PA2KA(frame), (void *) utext, utext_size < PAGE_SIZE ? utext_size : PAGE_SIZE);
+        
+        pfn[0] = frame / FRAME_SIZE;
+        as_area_load_mapping(a, pfn);
 
         /*
-         * Create the data vm_area.
+         * Create the data as_area.
          */
-        a = vm_area_create(m, VMA_STACK, 1, USTACK_ADDRESS);
+        a = as_area_create(as, AS_AREA_STACK, 1, USTACK_ADDRESS);
         if (!a)
-                panic("vm_area_create: vm_stack\n");
-        vm_area_map(a, m);
+                panic("as_area_create: stack\n");
         
         thread_ready(t);

generic/src/main/main.c

@@ -49 +49 @@
 #include <genarch/mm/page_pt.h>
 #include <mm/tlb.h>
-#include <mm/vm.h>
+#include <mm/as.h>
 #include <synch/waitq.h>
 #include <arch/arch.h>
@@ -136 +136 @@
 void main_bsp_separated_stack(void) 
 {
-        vm_t *m;
+        as_t *as;
         task_t *k;
         thread_t *t;
@@ -184 +184 @@
 
         /*
-         * Create kernel vm mapping.
-         */
-        m = vm_create(GET_PTL0_ADDRESS());
-        if (!m)
-                panic("can't create kernel vm address space\n");
+         * Create kernel address space.
+         */
+        as = as_create(GET_PTL0_ADDRESS());
+        if (!as)
+                panic("can't create kernel address space\n");
 
         /*
          * Create kernel task.
          */
-        k = task_create(m);
+        k = task_create(as);
         if (!k)
                 panic("can't create kernel task\n");

generic/src/mm/frame.c

@@ -32 +32 @@
 #include <mm/heap.h>
 #include <mm/frame.h>
-#include <mm/vm.h>
+#include <mm/as.h>
 #include <panic.h>
 #include <debug.h>

generic/src/mm/page.c

@@ -1 +1 @@
 /*
- * Copyright (C) 2001-2004 Jakub Jermar
+ * Copyright (C) 2001-2006 Jakub Jermar
  * All rights reserved.
  *
@@ -25 +25 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Virtual Address Translation subsystem.
  */
 

generic/src/proc/scheduler.c

@@ -33 +33 @@
 #include <mm/frame.h>
 #include <mm/page.h>
-#include <mm/vm.h>
+#include <mm/as.h>
 #include <arch/asm.h>
 #include <arch/faddr.h>
@@ -353 +353 @@
          */
         if (TASK != THREAD->task) {
-                vm_t *m1 = NULL;
-                vm_t *m2;
+                as_t *as1 = NULL;
+                as_t *as2;
 
                 if (TASK) {
                         spinlock_lock(&TASK->lock);
-                        m1 = TASK->vm;
+                        as1 = TASK->as;
                         spinlock_unlock(&TASK->lock);
                 }
 
                 spinlock_lock(&THREAD->task->lock);
-                m2 = THREAD->task->vm;
+                as2 = THREAD->task->as;
                 spinlock_unlock(&THREAD->task->lock);
                 
                 /*
-                 * Note that it is possible for two tasks to share one vm mapping.
-                 */
-                if (m1 != m2) {
-                        /*
-                         * Both tasks and vm mappings are different.
+                 * Note that it is possible for two tasks to share one address space.
+                 */
+                if (as1 != as2) {
+                        /*
+                         * Both tasks and address spaces are different.
                          * Replace the old one with the new one.
                          */
-                        vm_install(m2);
+                        as_install(as2);
                 }
                 TASK = THREAD->task;    

generic/src/proc/task.c

@@ -29 +29 @@
 #include <proc/thread.h>
 #include <proc/task.h>
-#include <mm/vm.h>
+#include <mm/as.h>
 #include <mm/heap.h>
 
@@ -55 +55 @@
  * Create new task with no threads.
  *
- * @param m Task's virtual memory structure.
+ * @param as Task's address space.
  *
  * @return New task's structure on success, NULL on failure.
  *
  */
-task_t *task_create(vm_t *m)
+task_t *task_create(as_t *as)
 {
         ipl_t ipl;
@@ -70 +70 @@
                 list_initialize(&ta->th_head);
                 list_initialize(&ta->tasks_link);
-                ta->vm = m;
+                ta->as = as;
                 
                 ipl = interrupts_disable();

generic/src/proc/the.c

@@ -43 +43 @@
         the->thread = NULL;
         the->task = NULL;
-        the->vm = NULL;
+        the->as = NULL;
 }