Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r0fe52ef 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 *task)
    84 {
    85         for (unsigned int i = EVENT_END; i < EVENT_TASK_END; i++)
    86                 event_initialize(evno2event(i, task));
    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 *task, 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, task), 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                                 call->data.task_id = TASK ? TASK->taskid : 0;
    164                                
    165                                 irq_spinlock_lock(&event->answerbox->irq_lock, true);
    166                                 list_append(&call->link, &event->answerbox->irq_notifs);
    167                                 irq_spinlock_unlock(&event->answerbox->irq_lock, true);
    168                                
    169                                 waitq_wakeup(&event->answerbox->wq, WAKEUP_FIRST);
    170                                
    171                                 if (mask)
    172                                         event->masked = true;
    173                                
    174                                 res = EOK;
    175                         } else
    176                                 res = ENOMEM;
    177                 } else
    178                         res = EBUSY;
    179         } else
    180                 res = ENOENT;
    181        
    182         spinlock_unlock(&event->lock);
    183         return res;
     96        spinlock_lock(&events[evno].lock);
     97        events[evno].unmask_callback = callback;
     98        spinlock_unlock(&events[evno].lock);
    18499}
    185100
    … …  
    208123        ASSERT(evno < EVENT_END);
    209124       
    210         return event_enqueue(evno2event(evno, NULL), mask, a1, a2, a3, a4, a5);
    211 }
    212 
    213 /** Send per-task kernel notification event
    214  *
    215  * @param task Destination task.
    216  * @param evno Event type.
    217  * @param mask Mask further notifications after a successful
    218  *             sending.
    219  * @param a1   First argument.
    220  * @param a2   Second argument.
    221  * @param a3   Third argument.
    222  * @param a4   Fourth argument.
    223  * @param a5   Fifth argument.
    224  *
    225  * @return EOK if notification was successfully sent.
    226  * @return ENOMEM if the notification IPC message failed to allocate.
    227  * @return EBUSY if the notifications of the given type are
    228  *         currently masked.
    229  * @return ENOENT if the notifications of the given type are
    230  *         currently not subscribed.
    231  *
    232  */
    233 int event_task_notify(task_t *task, event_task_type_t evno, bool mask,
    234     sysarg_t a1, sysarg_t a2, sysarg_t a3, sysarg_t a4, sysarg_t a5)
    235 {
    236         ASSERT(evno >= (int) EVENT_END);
    237         ASSERT(evno < EVENT_TASK_END);
    238        
    239         return event_enqueue(evno2event(evno, task), 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;
    240164}
    241165
    … …  
    252176 *
    253177 */
    254 static int event_subscribe(event_t *event, sysarg_t imethod,
     178static int event_subscribe(event_type_t evno, sysarg_t imethod,
    255179    answerbox_t *answerbox)
    256180{
     181        ASSERT(evno < EVENT_END);
     182       
     183        spinlock_lock(&events[evno].lock);
     184       
    257185        int res;
    258 
    259         spinlock_lock(&event->lock);
    260        
    261         if (event->answerbox == NULL) {
    262                 event->answerbox = answerbox;
    263                 event->imethod = imethod;
    264                 event->counter = 0;
    265                 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;
    266192                res = EOK;
    267193        } else
    268194                res = EEXISTS;
    269195       
    270         spinlock_unlock(&event->lock);
     196        spinlock_unlock(&events[evno].lock);
    271197       
    272198        return res;
    … …  
    278204 *
    279205 */
    280 static void event_unmask(event_t *event)
    281 {
    282         spinlock_lock(&event->lock);
    283         event->masked = false;
    284         event_callback_t callback = event->unmask_callback;
    285         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);
    286214       
    287215        /*
    … …  
    290218         */
    291219        if (callback != NULL)
    292                 callback(event);
     220                callback();
    293221}
    294222
    … …  
    307235sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t imethod)
    308236{
    309         if (evno >= EVENT_TASK_END)
     237        if (evno >= EVENT_END)
    310238                return ELIMIT;
    311239       
    312         return (sysarg_t) event_subscribe(evno2event(evno, TASK),
    313             (sysarg_t) imethod, &TASK->answerbox);
     240        return (sysarg_t) event_subscribe((event_type_t) evno, (sysarg_t)
     241            imethod, &TASK->answerbox);
    314242}
    315243
    … …  
    329257sysarg_t sys_event_unmask(sysarg_t evno)
    330258{
    331         if (evno >= EVENT_TASK_END)
     259        if (evno >= EVENT_END)
    332260                return ELIMIT;
    333261       
    334         event_unmask(evno2event(evno, TASK));
    335 
     262        event_unmask((event_type_t) evno);
    336263        return EOK;
    337264}
Note: See TracChangeset for help on using the changeset viewer.