Changeset b7068da in mainline for kernel/generic/src/ipc

Timestamp:

2012-02-09T20:35:12Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

591762c6

Parents:

7cede12c (diff), 3d4750f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Location:

kernel/generic/src/ipc

Files:

• irq.c (modified) (4 diffs)
• sysipc.c (modified) (3 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
@@ -365 +365 @@
                 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++) {
+        if (current_as != irq->driver_as)
+                as_switch(AS, irq->driver_as);
+        
+        for (size_t i = 0; i < code->cmdcount; i++) {
                 uint32_t dstval;
+                void *va;
+                uint8_t val8;
+                uint16_t val16;
+                uint32_t val32;
+                
                 uintptr_t srcarg = code->cmds[i].srcarg;
                 uintptr_t dstarg = code->cmds[i].dstarg;
@@ -442 +431 @@
                         }
                         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_READ_8:
+                        va = code->cmds[i].addr;
+                        memcpy_from_uspace(&val8, va, sizeof(val8));
+                        if (dstarg)
+                                scratch[dstarg] = val8;
+                        break;
+                case CMD_MEM_READ_16:
+                        va = code->cmds[i].addr;
+                        memcpy_from_uspace(&val16, va, sizeof(val16));
+                        if (dstarg)
+                                scratch[dstarg] = val16;
+                        break;
+                case CMD_MEM_READ_32:
+                        va = code->cmds[i].addr;
+                        memcpy_from_uspace(&val32, va, sizeof(val32));
+                        if (dstarg)
+                                scratch[dstarg] = val32;
+                        break;
+                case CMD_MEM_WRITE_8:
+                        val8 = code->cmds[i].value;
+                        va = code->cmds[i].addr;
+                        memcpy_to_uspace(va, &val8, sizeof(val8));
+                        break;
+                case CMD_MEM_WRITE_16:
+                        val16 = code->cmds[i].value;
+                        va = code->cmds[i].addr;
+                        memcpy_to_uspace(va, &val16, sizeof(val16));
+                        break;
+                case CMD_MEM_WRITE_32:
+                        val32 = code->cmds[i].value;
+                        va = code->cmds[i].addr;
+                        memcpy_to_uspace(va, &val32, sizeof(val32));
+                        break;
                 case CMD_MEM_WRITE_A_8:
                         if (srcarg) {
-                                uint8_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
+                                val8 = scratch[srcarg];
+                                va = code->cmds[i].addr;
+                                memcpy_to_uspace(va, &val8, sizeof(val8));
                         }
                         break;
                 case CMD_MEM_WRITE_A_16:
                         if (srcarg) {
-                                uint16_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
+                                val16 = scratch[srcarg];
+                                va = code->cmds[i].addr;
+                                memcpy_to_uspace(va, &val16, sizeof(val16));
                         }
                         break;
                 case CMD_MEM_WRITE_A_32:
                         if (srcarg) {
-                                uint32_t val = scratch[srcarg];
-                                CMD_MEM_WRITE(val);
+                                val32 = scratch[srcarg];
+                                va = code->cmds[i].addr;
+                                memcpy_to_uspace(va, &val32, sizeof(val32));
                         }
                         break;
@@ -513 +508 @@
                 }
         }
+        
         if (AS != current_as)
                 as_switch(AS, current_as);

kernel/generic/src/ipc/sysipc.c

@@ -271 +271 @@
                         irq_spinlock_unlock(&answer->sender->lock, true);
                         
+                        uintptr_t dst_base = (uintptr_t) -1;
                         int rc = as_area_share(as, IPC_GET_ARG1(*olddata),
-                            IPC_GET_ARG2(*olddata), AS,
-                            IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
+                            IPC_GET_ARG2(*olddata), AS, IPC_GET_ARG3(*olddata),
+                            &dst_base, IPC_GET_ARG1(answer->data));
+                        
+                        if (rc == EOK)
+                                rc = copy_to_uspace((void *) IPC_GET_ARG2(answer->data),
+                                    &dst_base, sizeof(dst_base));
+                        
                         IPC_SET_RETVAL(answer->data, rc);
                         return rc;
                 }
         } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) {
-                if (!IPC_GET_RETVAL(answer->data)) { 
+                if (!IPC_GET_RETVAL(answer->data)) {
                         irq_spinlock_lock(&answer->sender->lock, true);
                         as_t *as = answer->sender->as;
                         irq_spinlock_unlock(&answer->sender->lock, true);
                         
+                        uintptr_t dst_base = (uintptr_t) -1;
                         int rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
-                            IPC_GET_ARG2(*olddata), as, IPC_GET_ARG1(*olddata),
-                            IPC_GET_ARG2(answer->data));
+                            IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data),
+                            &dst_base, IPC_GET_ARG3(answer->data));
+                        IPC_SET_ARG4(answer->data, dst_base);
                         IPC_SET_RETVAL(answer->data, rc);
                 }
@@ -1185 +1193 @@
  *
  */
-sysarg_t sys_register_irq(inr_t inr, devno_t devno, sysarg_t imethod,
+sysarg_t sys_irq_register(inr_t inr, devno_t devno, sysarg_t imethod,
     irq_code_t *ucode)
 {
@@ -1202 +1210 @@
  *
  */
-sysarg_t sys_unregister_irq(inr_t inr, devno_t devno)
+sysarg_t sys_irq_unregister(inr_t inr, devno_t devno)
 {
         if (!(cap_get(TASK) & CAP_IRQ_REG))