Changeset ae318d3 in mainline for kernel/generic/src

Timestamp:

2009-02-16T18:50:48Z (16 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

06da55b

Parents:

17f168e

Message:

overhaul pareas: use one single physical area for the physical address space not belonging to physical memory

Location:

kernel/generic/src

Files:

• adt/avl.c (modified) (1 diff)
• console/cmd.c (modified) (1 diff)
• console/console.c (modified) (1 diff)
• ddi/ddi.c (modified) (8 diffs)
• lib/rd.c (modified) (1 diff)
• proc/task.c (modified) (1 diff)
• time/clock.c (modified) (1 diff)

kernel/generic/src/adt/avl.c

@@ -44 +44 @@
  * Every node has a pointer to its parent which allows insertion of multiple
  * identical keys into the tree.
- * 
+ *
  * Be careful when using this tree because of the base atribute which is added
  * to every inserted node key. There is no rule in which order nodes with the

kernel/generic/src/console/cmd.c

@@ -530 +530 @@
         }
         
-        spinlock_unlock(&cmd_lock);     
+        spinlock_unlock(&cmd_lock);
 
         return 1;

kernel/generic/src/console/console.c

@@ -127 +127 @@
         
         klog_parea.pbase = (uintptr_t) faddr;
-        klog_parea.vbase = (uintptr_t) klog;
         klog_parea.frames = SIZE2FRAMES(KLOG_SIZE);
-        klog_parea.cacheable = true;
         ddi_parea_register(&klog_parea);
 

kernel/generic/src/ddi/ddi.c

@@ -48 +48 @@
 #include <synch/spinlock.h>
 #include <syscall/copy.h>
-#include <adt/btree.h>
+#include <adt/list.h>
 #include <arch.h>
 #include <align.h>
@@ -56 +56 @@
 SPINLOCK_INITIALIZE(parea_lock);
 
-/** B+tree with enabled physical memory areas. */
-static btree_t parea_btree;
+/** List with enabled physical memory areas. */
+static LIST_INITIALIZE(parea_head);
+
+/** Physical memory area for devices. */
+static parea_t dev_area;
 
 /** Initialize DDI. */
 void ddi_init(void)
 {
-        btree_create(&parea_btree);
+        hw_area(&dev_area.pbase, &dev_area.frames);
+        ddi_parea_register(&dev_area);
 }
 
@@ -75 +79 @@
 {
         ipl_t ipl;
-
+        
         ipl = interrupts_disable();
         spinlock_lock(&parea_lock);
@@ -81 +85 @@
         /*
          * TODO: we should really check for overlaps here.
-         * However, we should be safe because the kernel is pretty sane and
-         * memory of different devices doesn't overlap. 
-         */
-        btree_insert(&parea_btree, (btree_key_t) parea->pbase, parea, NULL);
-
+         * However, we should be safe because the kernel is pretty sane.
+         */
+        link_initialize(&parea->link);
+        list_append(&parea->link, &parea_head);
+        
         spinlock_unlock(&parea_lock);
-        interrupts_restore(ipl);        
+        interrupts_restore(ipl);
 }
 
@@ -98 +102 @@
  *
  * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *      syscall, ENOENT if there is no task matching the specified ID or the
- *      physical address space is not enabled for mapping and ENOMEM if there
- *      was a problem in creating address space area.
- */
-static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
+ *  syscall, ENOENT if there is no task matching the specified ID or the
+ *  physical address space is not enabled for mapping and ENOMEM if there
+ *  was a problem in creating address space area.
+ */
+static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, pfn_t pages, int flags)
 {
         ipl_t ipl;
         cap_t caps;
         mem_backend_data_t backend_data;
-
+        
         backend_data.base = pf;
         backend_data.frames = pages;
@@ -117 +121 @@
         if (!(caps & CAP_MEM_MANAGER))
                 return EPERM;
-
+        
         ipl = interrupts_disable();
-
+        
         /*
          * Check if the physical memory area is enabled for mapping.
-         * If the architecture supports virtually indexed caches, intercept
-         * attempts to create an illegal address alias.
          */
         spinlock_lock(&parea_lock);
-        parea_t *parea;
-        btree_node_t *nodep;
-        parea = (parea_t *) btree_search(&parea_btree, (btree_key_t) pf, &nodep);
-        if (!parea || parea->frames < pages || ((flags & AS_AREA_CACHEABLE) &&
-            !parea->cacheable) || (!(flags & AS_AREA_CACHEABLE) &&
-            parea->cacheable)) {
+        
+        bool fnd = false;
+        link_t *cur;
+        
+        for (cur = parea_head.next; cur != &parea_head; cur = cur->next) {
+                parea_t *parea = list_get_instance(cur, parea_t, link);
+                if ((parea->pbase <= pf) && (ADDR2PFN(pf - parea->pbase) + pages <= parea->frames)) {
+                        fnd = true;
+                        break;
+                }
+        }
+        
+        spinlock_unlock(&parea_lock);
+        
+        if (!fnd) {
                 /*
-                 * This physical memory area cannot be mapped.
+                 * Physical memory area cannot be mapped.
                  */
-                spinlock_unlock(&parea_lock);
                 interrupts_restore(ipl);
                 return ENOENT;
         }
-        spinlock_unlock(&parea_lock);
-
+        
         spinlock_lock(&TASK->lock);
         
@@ -227 +236 @@
         return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
             FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
-            (count_t) pages, (int) flags);
+            (pfn_t) pages, (int) flags);
 }
 
@@ -259 +268 @@
 unative_t sys_preempt_control(int enable)
 {
-        if (!cap_get(TASK) & CAP_PREEMPT_CONTROL)
-                return EPERM;
-        if (enable)
-                preemption_enable();
-        else
-                preemption_disable();
-        return 0;
+        if (!cap_get(TASK) & CAP_PREEMPT_CONTROL)
+                return EPERM;
+        if (enable)
+                preemption_enable();
+        else
+                preemption_disable();
+        return 0;
 }
 

kernel/generic/src/lib/rd.c

@@ -89 +89 @@
         rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
             FRAME_SIZE);
-        rd_parea.vbase = (uintptr_t) ((void *) header + hsize);
         rd_parea.frames = SIZE2FRAMES(dsize);
-        rd_parea.cacheable = true;
         ddi_parea_register(&rd_parea);
 

kernel/generic/src/proc/task.c

@@ -340 +340 @@
                 
                 thr = list_get_instance(cur, thread_t, th_link);
-                        
+                
                 spinlock_lock(&thr->lock);
                 thr->interrupted = true;

kernel/generic/src/time/clock.c

@@ -89 +89 @@
 
         clock_parea.pbase = (uintptr_t) faddr;
-        clock_parea.vbase = (uintptr_t) uptime;
         clock_parea.frames = 1;
-        clock_parea.cacheable = true;
         ddi_parea_register(&clock_parea);