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

Timestamp:

2014-08-16T00:02:04Z (11 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

35b8bfe, 8cd680c

Parents:

83f29e0

Message:

support for kernel notification multiplexing in the async framework

• rename SYS_EVENT_* and SYS_IRQ_* syscalls to unify the terminology
• add SYS_IPC_EVENT_UNSUBSCRIBE
• remove IRQ handler multiplexing from DDF, the generic mechanism replaces it (unfortunatelly the order of arguments used by interrupt_handler_t needs to be permutated to align with the async framework conventions)

Location:

kernel/generic/src/ipc

Files:

• event.c (modified) (8 diffs)
• irq.c (modified) (8 diffs)
• sysipc.c (modified) (3 diffs)

kernel/generic/src/ipc/event.c

@@ -58 +58 @@
 }
 
-static event_t *evno2event(int evno, task_t *t)
+static event_t *evno2event(int evno, task_t *task)
 {
         ASSERT(evno < EVENT_TASK_END);
-
+        
         event_t *event;
-
+        
         if (evno < EVENT_END)
                 event = &events[(event_type_t) evno];
         else
-                event = &t->events[(event_task_type_t) evno - EVENT_END];
-
+                event = &task->events[(event_task_type_t) evno - EVENT_END];
+        
         return event;
 }
@@ -86 +86 @@
                 event_initialize(evno2event(i, task));
 }
-
 
 /** Unsubscribe kernel events associated with an answerbox
@@ -260 +259 @@
 {
         int res;
-
+        
         spinlock_lock(&event->lock);
         
@@ -277 +276 @@
 }
 
+/** Unsubscribe event notifications
+ *
+ * @param evno      Event type.
+ * @param answerbox Answerbox used to send the notifications to.
+ *
+ * @return EOK if the subscription was successful.
+ * @return EEXISTS if the notifications of the given type are
+ *         already subscribed.
+ *
+ */
+static int event_unsubscribe(event_t *event, answerbox_t *answerbox)
+{
+        int res;
+        
+        spinlock_lock(&event->lock);
+        
+        if (event->answerbox == answerbox) {
+                event->answerbox = NULL;
+                event->counter = 0;
+                event->imethod = 0;
+                event->masked = false;
+                res = EOK;
+        } else
+                res = ENOENT;
+        
+        spinlock_unlock(&event->lock);
+        
+        return res;
+}
+
 /** Unmask event notifications
  *
@@ -297 +326 @@
 }
 
-/** Event notification syscall wrapper
+/** Event notification subscription syscall wrapper
  *
  * @param evno    Event type to subscribe.
@@ -309 +338 @@
  *
  */
-sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t imethod)
+sysarg_t sys_ipc_event_subscribe(sysarg_t evno, sysarg_t imethod)
 {
         if (evno >= EVENT_TASK_END)
@@ -316 +345 @@
         return (sysarg_t) event_subscribe(evno2event(evno, TASK),
             (sysarg_t) imethod, &TASK->answerbox);
+}
+
+/** Event notification unsubscription syscall wrapper
+ *
+ * @param evno    Event type to unsubscribe.
+ *
+ * @return EOK on success.
+ * @return ELIMIT on unknown event type.
+ * @return ENOENT if the notification of the given type is not
+           subscribed.
+ *
+ */
+sysarg_t sys_ipc_event_unsubscribe(sysarg_t evno)
+{
+        if (evno >= EVENT_TASK_END)
+                return ELIMIT;
+        
+        return (sysarg_t) event_unsubscribe(evno2event(evno, TASK),
+            &TASK->answerbox);
 }
 
@@ -331 +379 @@
  *
  */
-sysarg_t sys_event_unmask(sysarg_t evno)
+sysarg_t sys_ipc_event_unmask(sysarg_t evno)
 {
         if (evno >= EVENT_TASK_END)

kernel/generic/src/ipc/irq.c

@@ -36 +36 @@
  * @brief IRQ notification framework.
  *
- * This framework allows applications to register to receive a notification
+ * This framework allows applications to subscribe to receive a notification
  * when interrupt is detected. The application may provide a simple 'top-half'
  * handler as part of its registration, which can perform simple operations
@@ -42 +42 @@
  *
  * The structure of a notification message is as follows:
- * - IMETHOD: interface and method as registered by
- *            the SYS_IRQ_REGISTER syscall
+ * - IMETHOD: interface and method as set by the SYS_IPC_IRQ_SUBSCRIBE syscall
  * - ARG1: payload modified by a 'top-half' handler (scratch[1])
  * - ARG2: payload modified by a 'top-half' handler (scratch[2])
@@ -52 +51 @@
  *                  in multithreaded drivers)
  *
- * Note on synchronization for ipc_irq_register(), ipc_irq_unregister(),
+ * Note on synchronization for ipc_irq_subscribe(), ipc_irq_unsubscribe(),
  * ipc_irq_cleanup() and IRQ handlers:
  *
@@ -289 +288 @@
 }
 
-/** Register an answerbox as a receiving end for IRQ notifications.
+/** Subscribe an answerbox as a receiving end for IRQ notifications.
  *
  * @param box     Receiving answerbox.
@@ -301 +300 @@
  *
  */
-int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
+int ipc_irq_subscribe(answerbox_t *box, inr_t inr, devno_t devno,
     sysarg_t imethod, irq_code_t *ucode)
 {
@@ -369 +368 @@
 }
 
-/** Unregister task from IRQ notification.
+/** Unsubscribe task from IRQ notification.
  *
  * @param box   Answerbox associated with the notification.
@@ -378 +377 @@
  *
  */
-int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
+int ipc_irq_unsubscribe(answerbox_t *box, inr_t inr, devno_t devno)
 {
         sysarg_t key[] = {
@@ -432 +431 @@
  *
  * This function is effective because the answerbox contains
- * list of all irq_t structures that are registered to
+ * list of all irq_t structures that are subscribed to
  * send notifications to it.
  *

kernel/generic/src/ipc/sysipc.c

@@ -736 +736 @@
  * @param ucode   Uspace pointer to the top-half pseudocode.
  *
- * @return EPERM or a return code returned by ipc_irq_register().
- *
- */
-sysarg_t sys_irq_register(inr_t inr, devno_t devno, sysarg_t imethod,
+ * @return EPERM or a return code returned by ipc_irq_subscribe().
+ *
+ */
+sysarg_t sys_ipc_irq_subscribe(inr_t inr, devno_t devno, sysarg_t imethod,
     irq_code_t *ucode)
 {
@@ -745 +745 @@
                 return EPERM;
         
-        return ipc_irq_register(&TASK->answerbox, inr, devno, imethod, ucode);
+        return ipc_irq_subscribe(&TASK->answerbox, inr, devno, imethod, ucode);
 }
 
@@ -756 +756 @@
  *
  */
-sysarg_t sys_irq_unregister(inr_t inr, devno_t devno)
+sysarg_t sys_ipc_irq_unsubscribe(inr_t inr, devno_t devno)
 {
         if (!(cap_get(TASK) & CAP_IRQ_REG))
                 return EPERM;
         
-        ipc_irq_unregister(&TASK->answerbox, inr, devno);
+        ipc_irq_unsubscribe(&TASK->answerbox, inr, devno);
         
         return 0;