Changes in kernel/generic/src/ipc/event.c [0fe52ef:97d42d5] in mainline
- File:
-
- 1 edited
-
kernel/generic/src/ipc/event.c (modified) (11 diffs)
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/ipc/event.c
r0fe52ef r97d42d5 36 36 37 37 #include <ipc/event.h> 38 #include <ipc/event_types.h> 38 39 #include <mm/slab.h> 39 40 #include <typedefs.h> 40 41 #include <synch/spinlock.h> 41 42 #include <console/console.h> 42 #include <proc/task.h>43 43 #include <memstr.h> 44 44 #include <errno.h> … … 48 48 static event_t events[EVENT_END]; 49 49 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 else69 event = &t->events[(event_task_type_t) evno - EVENT_END];70 71 return event;72 }73 74 50 /** Initialize kernel events. 75 51 * … … 77 53 void event_init(void) 78 54 { 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 55 for (unsigned int i = 0; i < EVENT_END; i++) { 56 spinlock_initialize(&events[i].lock, "event.lock"); 57 events[i].answerbox = NULL; 58 events[i].counter = 0; 59 events[i].imethod = 0; 60 events[i].masked = false; 61 events[i].unmask_callback = NULL; 62 } 63 } 89 64 90 65 /** Unsubscribe kernel events associated with an answerbox … … 109 84 } 110 85 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 118 86 /** Define a callback function for the event unmask event. 119 87 * … … 127 95 ASSERT(evno < EVENT_END); 128 96 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; 97 spinlock_lock(&events[evno].lock); 98 events[evno].unmask_callback = callback; 99 spinlock_unlock(&events[evno].lock); 184 100 } 185 101 … … 208 124 ASSERT(evno < EVENT_END); 209 125 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); 126 spinlock_lock(&events[evno].lock); 127 128 int ret; 129 130 if (events[evno].answerbox != NULL) { 131 if (!events[evno].masked) { 132 call_t *call = ipc_call_alloc(FRAME_ATOMIC); 133 134 if (call) { 135 call->flags |= IPC_CALL_NOTIF; 136 call->priv = ++events[evno].counter; 137 138 IPC_SET_IMETHOD(call->data, events[evno].imethod); 139 IPC_SET_ARG1(call->data, a1); 140 IPC_SET_ARG2(call->data, a2); 141 IPC_SET_ARG3(call->data, a3); 142 IPC_SET_ARG4(call->data, a4); 143 IPC_SET_ARG5(call->data, a5); 144 145 irq_spinlock_lock(&events[evno].answerbox->irq_lock, true); 146 list_append(&call->link, &events[evno].answerbox->irq_notifs); 147 irq_spinlock_unlock(&events[evno].answerbox->irq_lock, true); 148 149 waitq_wakeup(&events[evno].answerbox->wq, WAKEUP_FIRST); 150 151 if (mask) 152 events[evno].masked = true; 153 154 ret = EOK; 155 } else 156 ret = ENOMEM; 157 } else 158 ret = EBUSY; 159 } else 160 ret = ENOENT; 161 162 spinlock_unlock(&events[evno].lock); 163 164 return ret; 240 165 } 241 166 … … 252 177 * 253 178 */ 254 static int event_subscribe(event_t *event, sysarg_t imethod,179 static int event_subscribe(event_type_t evno, sysarg_t imethod, 255 180 answerbox_t *answerbox) 256 181 { 182 ASSERT(evno < EVENT_END); 183 184 spinlock_lock(&events[evno].lock); 185 257 186 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; 187 188 if (events[evno].answerbox == NULL) { 189 events[evno].answerbox = answerbox; 190 events[evno].imethod = imethod; 191 events[evno].counter = 0; 192 events[evno].masked = false; 266 193 res = EOK; 267 194 } else 268 195 res = EEXISTS; 269 196 270 spinlock_unlock(&event ->lock);197 spinlock_unlock(&events[evno].lock); 271 198 272 199 return res; … … 278 205 * 279 206 */ 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); 207 static void event_unmask(event_type_t evno) 208 { 209 ASSERT(evno < EVENT_END); 210 211 spinlock_lock(&events[evno].lock); 212 events[evno].masked = false; 213 event_callback_t callback = events[evno].unmask_callback; 214 spinlock_unlock(&events[evno].lock); 286 215 287 216 /* … … 290 219 */ 291 220 if (callback != NULL) 292 callback( event);221 callback(); 293 222 } 294 223 … … 307 236 sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t imethod) 308 237 { 309 if (evno >= EVENT_ TASK_END)238 if (evno >= EVENT_END) 310 239 return ELIMIT; 311 240 312 return (sysarg_t) event_subscribe( evno2event(evno, TASK),313 (sysarg_t)imethod, &TASK->answerbox);241 return (sysarg_t) event_subscribe((event_type_t) evno, (sysarg_t) 242 imethod, &TASK->answerbox); 314 243 } 315 244 … … 329 258 sysarg_t sys_event_unmask(sysarg_t evno) 330 259 { 331 if (evno >= EVENT_ TASK_END)260 if (evno >= EVENT_END) 332 261 return ELIMIT; 333 262 334 event_unmask(evno2event(evno, TASK)); 335 263 event_unmask((event_type_t) evno); 336 264 return EOK; 337 265 }
Note:
See TracChangeset
for help on using the changeset viewer.
