Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/ipc/event.c

    r5d0500c rc0699467  
    4040#include <synch/spinlock.h>
    4141#include <console/console.h>
    42 #include <proc/task.h>
    4342#include <memstr.h>
    4443#include <errno.h>
    … …  
    4847static event_t events[EVENT_END];
    4948
    50 static void event_initialize(event_t *event)
    51 {
    52         spinlock_initialize(&event->lock, "event.lock");
    53         event->answerbox = NULL;
    54         event->counter = 0;
    55         event->imethod = 0;
    56         event->masked = false;
    57         event->unmask_callback = NULL;
    58 }
    59 
    60 static event_t *evno2event(int evno, task_t *t)
    61 {
    62         ASSERT(evno < EVENT_TASK_END);
    63 
    64         event_t *event;
    65 
    66         if (evno < EVENT_END)
    67                 event = &events[(event_type_t) evno];
    68         else
    69                 event = &t->events[(event_task_type_t) evno - EVENT_END];
    70 
    71         return event;
    72 }
    73 
    7449/** Initialize kernel events.
    7550 *
    … …  
    7752void event_init(void)
    7853{
    79         for (unsigned int i = 0; i < EVENT_END; i++)
    80                 event_initialize(evno2event(i, NULL));
    81 }
    82 
    83 void event_task_init(task_t *t)
    84 {
    85         for (unsigned int i = EVENT_END; i < EVENT_TASK_END; i++)
    86                 event_initialize(evno2event(i, t));
    87 }
    88 
     54        for (unsigned int i = 0; i < EVENT_END; i++) {
     55                spinlock_initialize(&events[i].lock, "event.lock");
     56                events[i].answerbox = NULL;
     57                events[i].counter = 0;
     58                events[i].imethod = 0;
     59                events[i].masked = false;
     60                events[i].unmask_callback = NULL;
     61        }
     62}
    8963
    9064/** Unsubscribe kernel events associated with an answerbox
    … …  
    10983}
    11084
    111 static void _event_set_unmask_callback(event_t *event, event_callback_t callback)
    112 {
    113         spinlock_lock(&event->lock);
    114         event->unmask_callback = callback;
    115         spinlock_unlock(&event->lock);
    116 }
    117 
    11885/** Define a callback function for the event unmask event.
    11986 *
    … …  
    12794        ASSERT(evno < EVENT_END);
    12895       
    129         _event_set_unmask_callback(evno2event(evno, NULL), callback);
    130 }
    131 
    132 void event_task_set_unmask_callback(task_t *t, event_task_type_t evno,
    133     event_callback_t callback)
    134 {
    135         ASSERT(evno >= (int) EVENT_END);
    136         ASSERT(evno < EVENT_TASK_END);
    137                
    138         _event_set_unmask_callback(evno2event(evno, t), callback);
    139 }
    140 
    141 static int event_enqueue(event_t *event, bool mask, sysarg_t a1, sysarg_t a2,
    142     sysarg_t a3, sysarg_t a4, sysarg_t a5)
    143 {
    144         int res;
    145 
    146         spinlock_lock(&event->lock);
    147        
    148         if (event->answerbox != NULL) {
    149                 if (!event->masked) {
    150                         call_t *call = ipc_call_alloc(FRAME_ATOMIC);
    151                        
    152                         if (call) {
    153                                 call->flags |= IPC_CALL_NOTIF;
    154                                 call->priv = ++event->counter;
    155                                
    156                                 IPC_SET_IMETHOD(call->data, event->imethod);
    157                                 IPC_SET_ARG1(call->data, a1);
    158                                 IPC_SET_ARG2(call->data, a2);
    159                                 IPC_SET_ARG3(call->data, a3);
    160                                 IPC_SET_ARG4(call->data, a4);
    161                                 IPC_SET_ARG5(call->data, a5);
    162                                
    163                                 irq_spinlock_lock(&event->answerbox->irq_lock, true);
    164                                 list_append(&call->link, &event->answerbox->irq_notifs);
    165                                 irq_spinlock_unlock(&event->answerbox->irq_lock, true);
    166                                
    167                                 waitq_wakeup(&event->answerbox->wq, WAKEUP_FIRST);
    168                                
    169                                 if (mask)
    170                                         event->masked = true;
    171                                
    172                                 res = EOK;
    173                         } else
    174                                 res = ENOMEM;
    175                 } else
    176                         res = EBUSY;
    177         } else
    178                 res = ENOENT;
    179        
    180         spinlock_unlock(&event->lock);
    181         return res;
     96        spinlock_lock(&events[evno].lock);
     97        events[evno].unmask_callback = callback;
     98        spinlock_unlock(&events[evno].lock);
    18299}
    183100
    … …  
    206123        ASSERT(evno < EVENT_END);
    207124       
    208         return event_enqueue(evno2event(evno, NULL), mask, a1, a2, a3, a4, a5);
    209 }
    210 
    211 /** Send per-task kernel notification event
    212  *
    213  * @param t    Destination task.
    214  * @param evno Event type.
    215  * @param mask Mask further notifications after a successful
    216  *             sending.
    217  * @param a1   First argument.
    218  * @param a2   Second argument.
    219  * @param a3   Third argument.
    220  * @param a4   Fourth argument.
    221  * @param a5   Fifth argument.
    222  *
    223  * @return EOK if notification was successfully sent.
    224  * @return ENOMEM if the notification IPC message failed to allocate.
    225  * @return EBUSY if the notifications of the given type are
    226  *         currently masked.
    227  * @return ENOENT if the notifications of the given type are
    228  *         currently not subscribed.
    229  *
    230  */
    231 int event_task_notify(task_t *t, event_task_type_t evno, bool mask, sysarg_t a1,
    232     sysarg_t a2, sysarg_t a3, sysarg_t a4, sysarg_t a5)
    233 {
    234         ASSERT(evno >= (int) EVENT_END);
    235         ASSERT(evno < EVENT_TASK_END);
    236        
    237         return event_enqueue(evno2event(evno, t), mask, a1, a2, a3, a4, a5);
     125        spinlock_lock(&events[evno].lock);
     126       
     127        int ret;
     128       
     129        if (events[evno].answerbox != NULL) {
     130                if (!events[evno].masked) {
     131                        call_t *call = ipc_call_alloc(FRAME_ATOMIC);
     132                       
     133                        if (call) {
     134                                call->flags |= IPC_CALL_NOTIF;
     135                                call->priv = ++events[evno].counter;
     136                               
     137                                IPC_SET_IMETHOD(call->data, events[evno].imethod);
     138                                IPC_SET_ARG1(call->data, a1);
     139                                IPC_SET_ARG2(call->data, a2);
     140                                IPC_SET_ARG3(call->data, a3);
     141                                IPC_SET_ARG4(call->data, a4);
     142                                IPC_SET_ARG5(call->data, a5);
     143                               
     144                                irq_spinlock_lock(&events[evno].answerbox->irq_lock, true);
     145                                list_append(&call->link, &events[evno].answerbox->irq_notifs);
     146                                irq_spinlock_unlock(&events[evno].answerbox->irq_lock, true);
     147                               
     148                                waitq_wakeup(&events[evno].answerbox->wq, WAKEUP_FIRST);
     149                               
     150                                if (mask)
     151                                        events[evno].masked = true;
     152                               
     153                                ret = EOK;
     154                        } else
     155                                ret = ENOMEM;
     156                } else
     157                        ret = EBUSY;
     158        } else
     159                ret = ENOENT;
     160       
     161        spinlock_unlock(&events[evno].lock);
     162       
     163        return ret;
    238164}
    239165
    … …  
    250176 *
    251177 */
    252 static int event_subscribe(event_t *event, sysarg_t imethod,
     178static int event_subscribe(event_type_t evno, sysarg_t imethod,
    253179    answerbox_t *answerbox)
    254180{
     181        ASSERT(evno < EVENT_END);
     182       
     183        spinlock_lock(&events[evno].lock);
     184       
    255185        int res;
    256 
    257         spinlock_lock(&event->lock);
    258        
    259         if (event->answerbox == NULL) {
    260                 event->answerbox = answerbox;
    261                 event->imethod = imethod;
    262                 event->counter = 0;
    263                 event->masked = false;
     186       
     187        if (events[evno].answerbox == NULL) {
     188                events[evno].answerbox = answerbox;
     189                events[evno].imethod = imethod;
     190                events[evno].counter = 0;
     191                events[evno].masked = false;
    264192                res = EOK;
    265193        } else
    266194                res = EEXISTS;
    267195       
    268         spinlock_unlock(&event->lock);
     196        spinlock_unlock(&events[evno].lock);
    269197       
    270198        return res;
    … …  
    276204 *
    277205 */
    278 static void event_unmask(event_t *event)
    279 {
    280         spinlock_lock(&event->lock);
    281         event->masked = false;
    282         event_callback_t callback = event->unmask_callback;
    283         spinlock_unlock(&event->lock);
     206static void event_unmask(event_type_t evno)
     207{
     208        ASSERT(evno < EVENT_END);
     209       
     210        spinlock_lock(&events[evno].lock);
     211        events[evno].masked = false;
     212        event_callback_t callback = events[evno].unmask_callback;
     213        spinlock_unlock(&events[evno].lock);
    284214       
    285215        /*
    … …  
    288218         */
    289219        if (callback != NULL)
    290                 callback(event);
     220                callback();
    291221}
    292222
    … …  
    305235sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t imethod)
    306236{
    307         if (evno >= EVENT_TASK_END)
     237        if (evno >= EVENT_END)
    308238                return ELIMIT;
    309239       
    310         return (sysarg_t) event_subscribe(evno2event(evno, TASK),
    311             (sysarg_t) imethod, &TASK->answerbox);
     240        return (sysarg_t) event_subscribe((event_type_t) evno, (sysarg_t)
     241            imethod, &TASK->answerbox);
    312242}
    313243
    … …  
    327257sysarg_t sys_event_unmask(sysarg_t evno)
    328258{
    329         if (evno >= EVENT_TASK_END)
     259        if (evno >= EVENT_END)
    330260                return ELIMIT;
    331261       
    332         event_unmask(evno2event(evno, TASK));
    333 
     262        event_unmask((event_type_t) evno);
    334263        return EOK;
    335264}
Note: See TracChangeset for help on using the changeset viewer.