Changes in kernel/generic/src/ddi/ddi.c [d7533c7:98000fb] in mainline

File:

• kernel/generic/src/ddi/ddi.c (modified) (13 diffs)

kernel/generic/src/ddi/ddi.c

@@ -46 +46 @@
 #include <mm/frame.h>
 #include <mm/as.h>
-#include <synch/mutex.h>
+#include <synch/spinlock.h>
 #include <syscall/copy.h>
 #include <adt/btree.h>
@@ -52 +52 @@
 #include <align.h>
 #include <errno.h>
-#include <trace.h>
 
 /** This lock protects the parea_btree. */
-static mutex_t parea_lock;
+SPINLOCK_INITIALIZE(parea_lock);
 
 /** B+tree with enabled physical memory areas. */
 static btree_t parea_btree;
 
-/** Initialize DDI.
- *
- */
+/** Initialize DDI. */
 void ddi_init(void)
 {
         btree_create(&parea_btree);
-        mutex_initialize(&parea_lock, MUTEX_PASSIVE);
 }
 
@@ -76 +72 @@
 void ddi_parea_register(parea_t *parea)
 {
-        mutex_lock(&parea_lock);
+        ipl_t ipl = interrupts_disable();
+        spinlock_lock(&parea_lock);
         
         /*
@@ -83 +80 @@
         btree_insert(&parea_btree, (btree_key_t) parea->pbase, parea, NULL);
         
-        mutex_unlock(&parea_lock);
+        spinlock_unlock(&parea_lock);
+        interrupts_restore(ipl);
 }
 
@@ -100 +98 @@
  *
  */
-NO_TRACE static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages,
-    unsigned int flags)
+static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages, int flags)
 {
         ASSERT(TASK);
-        
-        if ((pf % FRAME_SIZE) != 0)
-                return EBADMEM;
-        
-        if ((vp % PAGE_SIZE) != 0)
-                return EBADMEM;
-        
-        /*
-         * Unprivileged tasks are only allowed to map pareas
-         * which are explicitly marked as such.
-         */
-        bool priv =
-            ((cap_get(TASK) & CAP_MEM_MANAGER) == CAP_MEM_MANAGER);
+        ASSERT((pf % FRAME_SIZE) == 0);
+        ASSERT((vp % PAGE_SIZE) == 0);
+        
+        /*
+         * Make sure the caller is authorised to make this syscall.
+         */
+        cap_t caps = cap_get(TASK);
+        if (!(caps & CAP_MEM_MANAGER))
+                return EPERM;
         
         mem_backend_data_t backend_data;
@@ -122 +115 @@
         backend_data.frames = pages;
         
+        ipl_t ipl = interrupts_disable();
+        
         /* Find the zone of the physical memory */
-        irq_spinlock_lock(&zones.lock, true);
+        spinlock_lock(&zones.lock);
         size_t znum = find_zone(ADDR2PFN(pf), pages, 0);
         
         if (znum == (size_t) -1) {
-                /*
-                 * Frames not found in any zone
-                 * -> assume it is a hardware device and allow mapping
-                 *    for privileged tasks.
-                 */
-                irq_spinlock_unlock(&zones.lock, true);
+                /* Frames not found in any zones
+                 * -> assume it is hardware device and allow mapping
+                 */
+                spinlock_unlock(&zones.lock);
+                goto map;
+        }
+        
+        if (zones.info[znum].flags & ZONE_FIRMWARE) {
+                /* Frames are part of firmware */
+                spinlock_unlock(&zones.lock);
+                goto map;
+        }
+        
+        if (zone_flags_available(zones.info[znum].flags)) {
+                /* Frames are part of physical memory, check if the memory
+                 * region is enabled for mapping.
+                 */
+                spinlock_unlock(&zones.lock);
                 
-                if (!priv)
-                        return EPERM;
-                
-                goto map;
-        }
-        
-        if (zones.info[znum].flags & ZONE_FIRMWARE) {
-                /*
-                 * Frames are part of firmware
-                 * -> allow mapping for privileged tasks.
-                 */
-                irq_spinlock_unlock(&zones.lock, true);
-                
-                if (!priv)
-                        return EPERM;
-                
-                goto map;
-        }
-        
-        if (zone_flags_available(zones.info[znum].flags)) {
-                /*
-                 * Frames are part of physical memory, check
-                 * if the memory region is enabled for mapping.
-                 */
-                irq_spinlock_unlock(&zones.lock, true);
-                
-                mutex_lock(&parea_lock);
+                spinlock_lock(&parea_lock);
                 btree_node_t *nodep;
                 parea_t *parea = (parea_t *) btree_search(&parea_btree,
                     (btree_key_t) pf, &nodep);
                 
-                if ((!parea) || (parea->frames < pages)) {
-                        mutex_unlock(&parea_lock);
-                        return ENOENT;
-                }
+                if ((!parea) || (parea->frames < pages))
+                        goto err;
                 
-                if (!priv) {
-                        if (!parea->unpriv) {
-                                mutex_unlock(&parea_lock);
-                                return EPERM;
-                        }
-                }
-                
-                mutex_unlock(&parea_lock);
+                spinlock_unlock(&parea_lock);
                 goto map;
         }
         
-        irq_spinlock_unlock(&zones.lock, true);
+err:
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
         return ENOENT;
         
 map:
+        spinlock_lock(&TASK->lock);
+        
         if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp,
             AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
@@ -191 +167 @@
                  * We report it using ENOMEM.
                  */
+                spinlock_unlock(&TASK->lock);
+                interrupts_restore(ipl);
                 return ENOMEM;
         }
@@ -197 +175 @@
          * Mapping is created on-demand during page fault.
          */
+        
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
         return 0;
 }
@@ -210 +191 @@
  *
  */
-NO_TRACE static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr,
-    size_t size)
+static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
 {
         /*
@@ -220 +200 @@
                 return EPERM;
         
-        irq_spinlock_lock(&tasks_lock, true);
+        ipl_t ipl = interrupts_disable();
+        spinlock_lock(&tasks_lock);
         
         task_t *task = task_find_by_id(id);
@@ -230 +211 @@
                  * context.
                  */
-                irq_spinlock_unlock(&tasks_lock, true);
+                spinlock_unlock(&tasks_lock);
+                interrupts_restore(ipl);
                 return ENOENT;
         }
         
         /* Lock the task and release the lock protecting tasks_btree. */
-        irq_spinlock_exchange(&tasks_lock, &task->lock);
+        spinlock_lock(&task->lock);
+        spinlock_unlock(&tasks_lock);
         
         int rc = ddi_iospace_enable_arch(task, ioaddr, size);
         
-        irq_spinlock_unlock(&task->lock, true);
+        spinlock_unlock(&task->lock);
+        interrupts_restore(ipl);
         
         return rc;
@@ -254 +238 @@
  *
  */
-sysarg_t sys_physmem_map(sysarg_t phys_base, sysarg_t virt_base,
-    sysarg_t pages, sysarg_t flags)
-{
-        return (sysarg_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
+unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base,
+    unative_t pages, unative_t flags)
+{
+        return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
             FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
             (size_t) pages, (int) flags);
@@ -269 +253 @@
  *
  */
-sysarg_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
+unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
 {
         ddi_ioarg_t arg;
         int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
         if (rc != 0)
-                return (sysarg_t) rc;
-        
-        return (sysarg_t) ddi_iospace_enable((task_id_t) arg.task_id,
+                return (unative_t) rc;
+        
+        return (unative_t) ddi_iospace_enable((task_id_t) arg.task_id,
             (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 
+/** Disable or enable preemption.
+ *
+ * @param enable If non-zero, the preemption counter will be decremented,
+ *               leading to potential enabling of preemption. Otherwise
+ *               the preemption counter will be incremented, preventing
+ *               preemption from occurring.
+ *
+ * @return Zero on success or EPERM if callers capabilities are not sufficient.
+ *
+ */
+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;
+}
+
 /** @}
  */