Changes in kernel/generic/src/ipc/irq.c [55b77d9:3cc070d] in mainline

File:

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

kernel/generic/src/ipc/irq.c

@@ -42 +42 @@
  *
  * The structure of a notification message is as follows:
- * - IMETHOD: interface and method as registered by the SYS_REGISTER_IRQ
- *            syscall
+ * - IMETHOD: interface and method as registered by
+ *            the SYS_IRQ_REGISTER syscall
  * - ARG1: payload modified by a 'top-half' handler
  * - ARG2: payload modified by a 'top-half' handler
@@ -74 +74 @@
 #include <arch.h>
 #include <mm/slab.h>
+#include <mm/page.h>
+#include <mm/km.h>
 #include <errno.h>
 #include <ddi/irq.h>
@@ -81 +83 @@
 #include <console/console.h>
 #include <print.h>
+#include <macros.h>
+
+static void ranges_unmap(irq_pio_range_t *ranges, size_t rangecount)
+{
+        size_t i;
+
+        for (i = 0; i < rangecount; i++) {
+#ifdef IO_SPACE_BOUNDARY
+                if ((void *) ranges[i].base >= IO_SPACE_BOUNDARY)
+#endif
+                        km_unmap(ranges[i].base, ranges[i].size);
+        }
+}
+
+static int ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
+    irq_cmd_t *cmds, size_t cmdcount)
+{
+        uintptr_t *pbase;
+        size_t i, j;
+
+        /* Copy the physical base addresses aside. */
+        pbase = malloc(rangecount * sizeof(uintptr_t), 0);
+        for (i = 0; i < rangecount; i++)
+                pbase[i] = ranges[i].base;
+
+        /* Map the PIO ranges into the kernel virtual address space. */
+        for (i = 0; i < rangecount; i++) {
+#ifdef IO_SPACE_BOUNDARY
+                if ((void *) ranges[i].base < IO_SPACE_BOUNDARY)
+                        continue;
+#endif
+                ranges[i].base = km_map(pbase[i], ranges[i].size,
+                    PAGE_READ | PAGE_WRITE | PAGE_KERNEL | PAGE_NOT_CACHEABLE);
+                if (!ranges[i].base) {
+                        ranges_unmap(ranges, i);
+                        free(pbase);
+                        return ENOMEM;
+                }
+        }
+
+        /* Rewrite the pseudocode addresses from physical to kernel virtual. */
+        for (i = 0; i < cmdcount; i++) {
+                uintptr_t addr;
+                size_t size;
+
+                /* Process only commands that use an address. */
+                switch (cmds[i].cmd) {
+                case CMD_PIO_READ_8:
+                case CMD_PIO_WRITE_8:
+                case CMD_PIO_WRITE_A_8:
+                        size = 1;
+                        break;
+                case CMD_PIO_READ_16:
+                case CMD_PIO_WRITE_16:
+                case CMD_PIO_WRITE_A_16:
+                        size = 2;
+                        break;
+                case CMD_PIO_READ_32:
+                case CMD_PIO_WRITE_32:
+                case CMD_PIO_WRITE_A_32:
+                        size = 4;
+                        break;
+                default:
+                        /* Move onto the next command. */
+                        continue;
+                }
+
+                addr = (uintptr_t) cmds[i].addr;
+                
+                for (j = 0; j < rangecount; j++) {
+
+                        /* Find the matching range. */
+                        if (!iswithin(pbase[j], ranges[j].size, addr, size))
+                                continue;
+
+                        /* Switch the command to a kernel virtual address. */
+                        addr -= pbase[j];
+                        addr += ranges[j].base;
+
+                        cmds[i].addr = (void *) addr;
+                        break;
+                }
+
+                if (j == rangecount) {
+                        /*
+                         * The address used in this command is outside of all
+                         * defined ranges.
+                         */
+                        ranges_unmap(ranges, rangecount);
+                        free(pbase);
+                        return EINVAL;
+                }
+        }
+
+        free(pbase);
+        return EOK;
+}
 
 /** Free the top-half pseudocode.
@@ -90 +189 @@
 {
         if (code) {
+                ranges_unmap(code->ranges, code->rangecount);
+                free(code->ranges);
                 free(code->cmds);
                 free(code);
@@ -104 +205 @@
 static irq_code_t *code_from_uspace(irq_code_t *ucode)
 {
+        irq_pio_range_t *ranges = NULL;
+        irq_cmd_t *cmds = NULL;
+
         irq_code_t *code = malloc(sizeof(*code), 0);
         int rc = copy_from_uspace(code, ucode, sizeof(*code));
-        if (rc != 0) {
-                free(code);
-                return NULL;
-        }
-        
-        if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
-                free(code);
-                return NULL;
-        }
-        
-        irq_cmd_t *ucmds = code->cmds;
-        code->cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
-        rc = copy_from_uspace(code->cmds, ucmds,
+        if (rc != EOK)
+                goto error;
+        
+        if ((code->rangecount > IRQ_MAX_RANGE_COUNT) ||
+            (code->cmdcount > IRQ_MAX_PROG_SIZE))
+                goto error;
+        
+        ranges = malloc(sizeof(code->ranges[0]) * code->rangecount, 0);
+        rc = copy_from_uspace(ranges, code->ranges,
+            sizeof(code->ranges[0]) * code->rangecount);
+        if (rc != EOK)
+                goto error;
+
+        cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
+        rc = copy_from_uspace(cmds, code->cmds,
             sizeof(code->cmds[0]) * code->cmdcount);
-        if (rc != 0) {
-                free(code->cmds);
-                free(code);
-                return NULL;
-        }
-        
+        if (rc != EOK)
+                goto error;
+
+        rc = ranges_map_and_apply(ranges, code->rangecount, cmds,
+            code->cmdcount);
+        if (rc != EOK)
+                goto error;
+
+        code->ranges = ranges;
+        code->cmds = cmds;
+
         return code;
+
+error:
+        if (cmds)
+                free(cmds);
+        if (ranges)
+                free(ranges);
+        free(code);
+        return NULL;
 }
 
@@ -174 +293 @@
         irq->notif_cfg.code = code;
         irq->notif_cfg.counter = 0;
-        irq->driver_as = AS;
         
         /*
@@ -239 +357 @@
         
         ASSERT(irq->notif_cfg.answerbox == box);
-        
-        /* Free up the pseudo code and associated structures. */
-        code_free(irq->notif_cfg.code);
         
         /* Remove the IRQ from the answerbox's list. */
@@ -260 +375 @@
         irq_spinlock_unlock(&box->irq_lock, false);
         irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
+        
+        /* Free up the pseudo code and associated structures. */
+        code_free(irq->notif_cfg.code);
         
         /* Free up the IRQ structure. */
@@ -307 +425 @@
                 list_remove(&irq->notif_cfg.link);
                 
-                /* Free up the pseudo code and associated structures. */
-                code_free(irq->notif_cfg.code);
-                
                 /*
                  * We need to drop the IRQ lock now because hash_table_remove()
@@ -321 +436 @@
                 /* Remove from the hash table. */
                 hash_table_remove(&irq_uspace_hash_table, key, 2);
-                
+
+                /*
+                 * Release both locks so that we can free the pseudo code.
+                 */
+                irq_spinlock_unlock(&box->irq_lock, false);
+                irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
+
+                code_free(irq->notif_cfg.code);
                 free(irq);
+                
+                /* Reacquire both locks before taking another round. */
+                irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
+                irq_spinlock_lock(&box->irq_lock, false);
         }
         
@@ -365 +491 @@
                 return IRQ_DECLINE;
         
-#define CMD_MEM_READ(target) \
-do { \
-        void *va = code->cmds[i].addr; \
-        if (AS != irq->driver_as) \
-                as_switch(AS, irq->driver_as); \
-        memcpy_from_uspace(&target, va, (sizeof(target))); \
-        if (dstarg) \
-                scratch[dstarg] = target; \
-} while(0)
-
-#define CMD_MEM_WRITE(val) \
-do { \
-        void *va = code->cmds[i].addr; \
-        if (AS != irq->driver_as) \
-                as_switch(AS, irq->driver_as); \
-        memcpy_to_uspace(va, &val, sizeof(val)); \
-} while (0)
-
-        as_t *current_as = AS;
-        size_t i;
-        for (i = 0; i < code->cmdcount; i++) {
+        for (size_t i = 0; i < code->cmdcount; i++) {
                 uint32_t dstval;
+                
                 uintptr_t srcarg = code->cmds[i].srcarg;
                 uintptr_t dstarg = code->cmds[i].dstarg;
@@ -442 +549 @@
                         }
                         break;
-                case CMD_MEM_READ_8: {
-                        uint8_t val;
-                        CMD_MEM_READ(val);
-                        break;
-                        }
-                case CMD_MEM_READ_16: {
-                        uint16_t val;
-                        CMD_MEM_READ(val);
-                        break;
-                        }
-                case CMD_MEM_READ_32: {
-                        uint32_t val;
-                        CMD_MEM_READ(val);
-                        break;
-                        }
-                case CMD_MEM_WRITE_8: {
-                        uint8_t val = code->cmds[i].value;
-                        CMD_MEM_WRITE(val);
-                        break;
-                        }
-                case CMD_MEM_WRITE_16: {
-                        uint16_t val = code->cmds[i].value;
-                        CMD_MEM_WRITE(val);
-                        break;
-                        }
-                case CMD_MEM_WRITE_32: {
-                        uint32_t val = code->cmds[i].value;
-                        CMD_MEM_WRITE(val);
-                        break;
-                        }
-                case CMD_MEM_WRITE_A_8:
-                        if (srcarg) {
-                                uint8_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
-                        }
-                        break;
-                case CMD_MEM_WRITE_A_16:
-                        if (srcarg) {
-                                uint16_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
-                        }
-                        break;
-                case CMD_MEM_WRITE_A_32:
-                        if (srcarg) {
-                                uint32_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
-                        }
-                        break;
                 case CMD_BTEST:
                         if ((srcarg) && (dstarg)) {
@@ -503 +562 @@
                         break;
                 case CMD_ACCEPT:
-                        if (AS != current_as)
-                                as_switch(AS, current_as);
                         return IRQ_ACCEPT;
                 case CMD_DECLINE:
                 default:
-                        if (AS != current_as)
-                                as_switch(AS, current_as);
                         return IRQ_DECLINE;
                 }
         }
-        if (AS != current_as)
-                as_switch(AS, current_as);
         
         return IRQ_DECLINE;