source: mainline/kernel/generic/src/ipc/ipc.c@ 24345a5

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 24345a5 was 119c335, checked in by Jakub Jermar <jakub@…>, 17 years ago

Add comments documenting our treatment of the task's active call counter.

  • Property mode set to 100644
File size: 18.8 KB
Line 
1/*
2 * Copyright (c) 2006 Ondrej Palkovsky
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup genericipc
30 * @{
31 */
32/** @file
33 */
34
35/* Lock ordering
36 *
37 * First the answerbox, then the phone.
38 */
39
40#include <synch/synch.h>
41#include <synch/spinlock.h>
42#include <synch/mutex.h>
43#include <synch/waitq.h>
44#include <synch/synch.h>
45#include <ipc/ipc.h>
46#include <ipc/kbox.h>
47#include <errno.h>
48#include <mm/slab.h>
49#include <arch.h>
50#include <proc/task.h>
51#include <memstr.h>
52#include <debug.h>
53
54#include <print.h>
55#include <console/console.h>
56#include <proc/thread.h>
57#include <arch/interrupt.h>
58#include <ipc/irq.h>
59
60/** Open channel that is assigned automatically to new tasks */
61answerbox_t *ipc_phone_0 = NULL;
62
63static slab_cache_t *ipc_call_slab;
64
65/** Initialize a call structure.
66 *
67 * @param call Call structure to be initialized.
68 */
69static void _ipc_call_init(call_t *call)
70{
71 memsetb(call, sizeof(*call), 0);
72 call->callerbox = &TASK->answerbox;
73 call->sender = TASK;
74 call->buffer = NULL;
75}
76
77/** Allocate and initialize a call structure.
78 *
79 * The call is initialized, so that the reply will be directed to
80 * TASK->answerbox.
81 *
82 * @param flags Parameters for slab_alloc (e.g FRAME_ATOMIC).
83 *
84 * @return If flags permit it, return NULL, or initialized kernel
85 * call structure.
86 */
87call_t *ipc_call_alloc(int flags)
88{
89 call_t *call;
90
91 call = slab_alloc(ipc_call_slab, flags);
92 if (call)
93 _ipc_call_init(call);
94
95 return call;
96}
97
98/** Initialize a statically allocated call structure.
99 *
100 * @param call Statically allocated kernel call structure to be
101 * initialized.
102 */
103void ipc_call_static_init(call_t *call)
104{
105 _ipc_call_init(call);
106 call->flags |= IPC_CALL_STATIC_ALLOC;
107}
108
109/** Deallocate a call structure.
110 *
111 * @param call Call structure to be freed.
112 */
113void ipc_call_free(call_t *call)
114{
115 ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));
116 /* Check to see if we have data in the IPC_M_DATA_SEND buffer. */
117 if (call->buffer)
118 free(call->buffer);
119 slab_free(ipc_call_slab, call);
120}
121
122/** Initialize an answerbox structure.
123 *
124 * @param box Answerbox structure to be initialized.
125 * @param task Task to which the answerbox belongs.
126 */
127void ipc_answerbox_init(answerbox_t *box, task_t *task)
128{
129 spinlock_initialize(&box->lock, "ipc_box_lock");
130 spinlock_initialize(&box->irq_lock, "ipc_box_irqlock");
131 waitq_initialize(&box->wq);
132 list_initialize(&box->connected_phones);
133 list_initialize(&box->calls);
134 list_initialize(&box->dispatched_calls);
135 list_initialize(&box->answers);
136 list_initialize(&box->irq_notifs);
137 list_initialize(&box->irq_head);
138 box->task = task;
139}
140
141/** Connect a phone to an answerbox.
142 *
143 * @param phone Initialized phone structure.
144 * @param box Initialized answerbox structure.
145 */
146void ipc_phone_connect(phone_t *phone, answerbox_t *box)
147{
148 mutex_lock(&phone->lock);
149
150 phone->state = IPC_PHONE_CONNECTED;
151 phone->callee = box;
152
153 spinlock_lock(&box->lock);
154 list_append(&phone->link, &box->connected_phones);
155 spinlock_unlock(&box->lock);
156
157 mutex_unlock(&phone->lock);
158}
159
160/** Initialize a phone structure.
161 *
162 * @param phone Phone structure to be initialized.
163 */
164void ipc_phone_init(phone_t *phone)
165{
166 mutex_initialize(&phone->lock, MUTEX_PASSIVE);
167 phone->callee = NULL;
168 phone->state = IPC_PHONE_FREE;
169 atomic_set(&phone->active_calls, 0);
170}
171
172/** Helper function to facilitate synchronous calls.
173 *
174 * @param phone Destination kernel phone structure.
175 * @param request Call structure with request.
176 *
177 * @return EOK on success or EINTR if the sleep was interrupted.
178 */
179int ipc_call_sync(phone_t *phone, call_t *request)
180{
181 answerbox_t sync_box;
182
183 ipc_answerbox_init(&sync_box, TASK);
184
185 /* We will receive data in a special box. */
186 request->callerbox = &sync_box;
187
188 ipc_call(phone, request);
189 if (!ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT,
190 SYNCH_FLAGS_INTERRUPTIBLE))
191 return EINTR;
192 return EOK;
193}
194
195/** Answer a message which was not dispatched and is not listed in any queue.
196 *
197 * @param call Call structure to be answered.
198 */
199static void _ipc_answer_free_call(call_t *call)
200{
201 answerbox_t *callerbox = call->callerbox;
202
203 call->flags |= IPC_CALL_ANSWERED;
204
205 if (call->flags & IPC_CALL_FORWARDED) {
206 if (call->caller_phone) {
207 /* Demasquerade the caller phone. */
208 call->data.phone = call->caller_phone;
209 }
210 }
211
212 spinlock_lock(&callerbox->lock);
213 list_append(&call->link, &callerbox->answers);
214 spinlock_unlock(&callerbox->lock);
215 waitq_wakeup(&callerbox->wq, WAKEUP_FIRST);
216}
217
218/** Answer a message which is in a callee queue.
219 *
220 * @param box Answerbox that is answering the message.
221 * @param call Modified request that is being sent back.
222 */
223void ipc_answer(answerbox_t *box, call_t *call)
224{
225 /* Remove from active box */
226 spinlock_lock(&box->lock);
227 list_remove(&call->link);
228 spinlock_unlock(&box->lock);
229 /* Send back answer */
230 _ipc_answer_free_call(call);
231}
232
233/** Simulate sending back a message.
234 *
235 * Most errors are better handled by forming a normal backward
236 * message and sending it as a normal answer.
237 *
238 * @param phone Phone structure the call should appear to come from.
239 * @param call Call structure to be answered.
240 * @param err Return value to be used for the answer.
241 */
242void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err)
243{
244 call->data.phone = phone;
245 atomic_inc(&phone->active_calls);
246 IPC_SET_RETVAL(call->data, err);
247 _ipc_answer_free_call(call);
248}
249
250/** Unsafe unchecking version of ipc_call.
251 *
252 * @param phone Phone structure the call comes from.
253 * @param box Destination answerbox structure.
254 * @param call Call structure with request.
255 */
256static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call)
257{
258 if (!(call->flags & IPC_CALL_FORWARDED)) {
259 atomic_inc(&phone->active_calls);
260 call->data.phone = phone;
261 }
262
263 spinlock_lock(&box->lock);
264 list_append(&call->link, &box->calls);
265 spinlock_unlock(&box->lock);
266 waitq_wakeup(&box->wq, WAKEUP_FIRST);
267}
268
269/** Send an asynchronous request using a phone to an answerbox.
270 *
271 * @param phone Phone structure the call comes from and which is
272 * connected to the destination answerbox.
273 * @param call Call structure with request.
274 *
275 * @return Return 0 on success, ENOENT on error.
276 */
277int ipc_call(phone_t *phone, call_t *call)
278{
279 answerbox_t *box;
280
281 mutex_lock(&phone->lock);
282 if (phone->state != IPC_PHONE_CONNECTED) {
283 mutex_unlock(&phone->lock);
284 if (call->flags & IPC_CALL_FORWARDED) {
285 IPC_SET_RETVAL(call->data, EFORWARD);
286 _ipc_answer_free_call(call);
287 } else {
288 if (phone->state == IPC_PHONE_HUNGUP)
289 ipc_backsend_err(phone, call, EHANGUP);
290 else
291 ipc_backsend_err(phone, call, ENOENT);
292 }
293 return ENOENT;
294 }
295 box = phone->callee;
296 _ipc_call(phone, box, call);
297
298 mutex_unlock(&phone->lock);
299 return 0;
300}
301
302/** Disconnect phone from answerbox.
303 *
304 * This call leaves the phone in the HUNGUP state. The change to 'free' is done
305 * lazily later.
306 *
307 * @param phone Phone structure to be hung up.
308 *
309 * @return Return 0 if the phone is disconnected.
310 * Return -1 if the phone was already disconnected.
311 */
312int ipc_phone_hangup(phone_t *phone)
313{
314 answerbox_t *box;
315 call_t *call;
316
317 mutex_lock(&phone->lock);
318 if (phone->state == IPC_PHONE_FREE ||
319 phone->state == IPC_PHONE_HUNGUP ||
320 phone->state == IPC_PHONE_CONNECTING) {
321 mutex_unlock(&phone->lock);
322 return -1;
323 }
324 box = phone->callee;
325 if (phone->state != IPC_PHONE_SLAMMED) {
326 /* Remove myself from answerbox */
327 spinlock_lock(&box->lock);
328 list_remove(&phone->link);
329 spinlock_unlock(&box->lock);
330
331 if (phone->state != IPC_PHONE_SLAMMED) {
332 call = ipc_call_alloc(0);
333 IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
334 call->flags |= IPC_CALL_DISCARD_ANSWER;
335 _ipc_call(phone, box, call);
336 }
337 }
338
339 phone->state = IPC_PHONE_HUNGUP;
340 mutex_unlock(&phone->lock);
341
342 return 0;
343}
344
345/** Forwards call from one answerbox to another one.
346 *
347 * @param call Call structure to be redirected.
348 * @param newphone Phone structure to target answerbox.
349 * @param oldbox Old answerbox structure.
350 * @param mode Flags that specify mode of the forward operation.
351 *
352 * @return Return 0 if forwarding succeeded or an error code if
353 * there was error.
354 *
355 * The return value serves only as an information for the forwarder,
356 * the original caller is notified automatically with EFORWARD.
357 */
358int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox, int mode)
359{
360 spinlock_lock(&oldbox->lock);
361 list_remove(&call->link);
362 spinlock_unlock(&oldbox->lock);
363
364 if (mode & IPC_FF_ROUTE_FROM_ME) {
365 if (!call->caller_phone)
366 call->caller_phone = call->data.phone;
367 call->data.phone = newphone;
368 }
369
370 return ipc_call(newphone, call);
371}
372
373
374/** Wait for a phone call.
375 *
376 * @param box Answerbox expecting the call.
377 * @param usec Timeout in microseconds. See documentation for
378 * waitq_sleep_timeout() for decription of its special
379 * meaning.
380 * @param flags Select mode of sleep operation. See documentation for
381 * waitq_sleep_timeout() for description of its special
382 * meaning.
383 * @return Recived call structure or NULL.
384 *
385 * To distinguish between a call and an answer, have a look at call->flags.
386 */
387call_t *ipc_wait_for_call(answerbox_t *box, uint32_t usec, int flags)
388{
389 call_t *request;
390 ipl_t ipl;
391 int rc;
392
393restart:
394 rc = waitq_sleep_timeout(&box->wq, usec, flags);
395 if (SYNCH_FAILED(rc))
396 return NULL;
397
398 spinlock_lock(&box->lock);
399 if (!list_empty(&box->irq_notifs)) {
400 ipl = interrupts_disable();
401 spinlock_lock(&box->irq_lock);
402
403 request = list_get_instance(box->irq_notifs.next, call_t, link);
404 list_remove(&request->link);
405
406 spinlock_unlock(&box->irq_lock);
407 interrupts_restore(ipl);
408 } else if (!list_empty(&box->answers)) {
409 /* Handle asynchronous answers */
410 request = list_get_instance(box->answers.next, call_t, link);
411 list_remove(&request->link);
412 atomic_dec(&request->data.phone->active_calls);
413 } else if (!list_empty(&box->calls)) {
414 /* Handle requests */
415 request = list_get_instance(box->calls.next, call_t, link);
416 list_remove(&request->link);
417 /* Append request to dispatch queue */
418 list_append(&request->link, &box->dispatched_calls);
419 } else {
420 /* This can happen regularly after ipc_cleanup */
421 spinlock_unlock(&box->lock);
422 goto restart;
423 }
424 spinlock_unlock(&box->lock);
425 return request;
426}
427
428/** Answer all calls from list with EHANGUP answer.
429 *
430 * @param lst Head of the list to be cleaned up.
431 */
432void ipc_cleanup_call_list(link_t *lst)
433{
434 call_t *call;
435
436 while (!list_empty(lst)) {
437 call = list_get_instance(lst->next, call_t, link);
438 if (call->buffer)
439 free(call->buffer);
440 list_remove(&call->link);
441
442 IPC_SET_RETVAL(call->data, EHANGUP);
443 _ipc_answer_free_call(call);
444 }
445}
446
447/** Disconnects all phones connected to an answerbox.
448 *
449 * @param box Answerbox to disconnect phones from.
450 * @param notify_box If true, the answerbox will get a hangup message for
451 * each disconnected phone.
452 */
453void ipc_answerbox_slam_phones(answerbox_t *box, bool notify_box)
454{
455 phone_t *phone;
456 DEADLOCK_PROBE_INIT(p_phonelck);
457 ipl_t ipl;
458 call_t *call;
459
460 call = notify_box ? ipc_call_alloc(0) : NULL;
461
462 /* Disconnect all phones connected to our answerbox */
463restart_phones:
464 ipl = interrupts_disable();
465 spinlock_lock(&box->lock);
466 while (!list_empty(&box->connected_phones)) {
467 phone = list_get_instance(box->connected_phones.next,
468 phone_t, link);
469 if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
470 spinlock_unlock(&box->lock);
471 interrupts_restore(ipl);
472 DEADLOCK_PROBE(p_phonelck, DEADLOCK_THRESHOLD);
473 goto restart_phones;
474 }
475
476 /* Disconnect phone */
477 ASSERT(phone->state == IPC_PHONE_CONNECTED);
478
479 list_remove(&phone->link);
480 phone->state = IPC_PHONE_SLAMMED;
481
482 if (notify_box) {
483 mutex_unlock(&phone->lock);
484 spinlock_unlock(&box->lock);
485 interrupts_restore(ipl);
486
487 /*
488 * Send one message to the answerbox for each
489 * phone. Used to make sure the kbox thread
490 * wakes up after the last phone has been
491 * disconnected.
492 */
493 IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
494 call->flags |= IPC_CALL_DISCARD_ANSWER;
495 _ipc_call(phone, box, call);
496
497 /* Allocate another call in advance */
498 call = ipc_call_alloc(0);
499
500 /* Must start again */
501 goto restart_phones;
502 }
503
504 mutex_unlock(&phone->lock);
505 }
506
507 spinlock_unlock(&box->lock);
508 interrupts_restore(ipl);
509
510 /* Free unused call */
511 if (call)
512 ipc_call_free(call);
513}
514
515/** Cleans up all IPC communication of the current task.
516 *
517 * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
518 * have to change it as well if you want to cleanup other tasks than TASK.
519 */
520void ipc_cleanup(void)
521{
522 int i;
523 call_t *call;
524
525 /* Disconnect all our phones ('ipc_phone_hangup') */
526 for (i = 0; i < IPC_MAX_PHONES; i++)
527 ipc_phone_hangup(&TASK->phones[i]);
528
529 /* Disconnect all connected irqs */
530 ipc_irq_cleanup(&TASK->answerbox);
531
532 /* Disconnect all phones connected to our regular answerbox */
533 ipc_answerbox_slam_phones(&TASK->answerbox, false);
534
535#ifdef CONFIG_UDEBUG
536 /* Clean up kbox thread and communications */
537 ipc_kbox_cleanup();
538#endif
539
540 /* Answer all messages in 'calls' and 'dispatched_calls' queues */
541 spinlock_lock(&TASK->answerbox.lock);
542 ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls);
543 ipc_cleanup_call_list(&TASK->answerbox.calls);
544 spinlock_unlock(&TASK->answerbox.lock);
545
546 /* Wait for all async answers to arrive */
547 while (1) {
548 /* Go through all phones, until all are FREE... */
549 /* Locking not needed, no one else should modify
550 * it, when we are in cleanup */
551 for (i = 0; i < IPC_MAX_PHONES; i++) {
552 if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
553 atomic_get(&TASK->phones[i].active_calls) == 0)
554 TASK->phones[i].state = IPC_PHONE_FREE;
555
556 /* Just for sure, we might have had some
557 * IPC_PHONE_CONNECTING phones */
558 if (TASK->phones[i].state == IPC_PHONE_CONNECTED)
559 ipc_phone_hangup(&TASK->phones[i]);
560 /* If the hangup succeeded, it has sent a HANGUP
561 * message, the IPC is now in HUNGUP state, we
562 * wait for the reply to come */
563
564 if (TASK->phones[i].state != IPC_PHONE_FREE)
565 break;
566 }
567 /* Voila, got into cleanup */
568 if (i == IPC_MAX_PHONES)
569 break;
570
571 call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT,
572 SYNCH_FLAGS_NONE);
573 ASSERT((call->flags & IPC_CALL_ANSWERED) ||
574 (call->flags & IPC_CALL_NOTIF));
575 ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));
576
577 /*
578 * Record the receipt of this call in the current task's counter
579 * of active calls. IPC_M_PHONE_HUNGUP calls do not contribute
580 * to this counter so do not record answers to them either.
581 */
582 if (!(call->flags & IPC_CALL_DISCARD_ANSWER))
583 atomic_dec(&TASK->active_calls);
584 ipc_call_free(call);
585 }
586}
587
588
589/** Initilize IPC subsystem */
590void ipc_init(void)
591{
592 ipc_call_slab = slab_cache_create("ipc_call", sizeof(call_t), 0, NULL,
593 NULL, 0);
594}
595
596
597/** List answerbox contents.
598 *
599 * @param taskid Task ID.
600 */
601void ipc_print_task(task_id_t taskid)
602{
603 task_t *task;
604 int i;
605 call_t *call;
606 link_t *tmp;
607
608 spinlock_lock(&tasks_lock);
609 task = task_find_by_id(taskid);
610 if (task)
611 spinlock_lock(&task->lock);
612 spinlock_unlock(&tasks_lock);
613 if (!task)
614 return;
615
616 /* Print opened phones & details */
617 printf("PHONE:\n");
618 for (i = 0; i < IPC_MAX_PHONES; i++) {
619 if (SYNCH_FAILED(mutex_trylock(&task->phones[i].lock))) {
620 printf("%d: mutex busy\n", i);
621 continue;
622 }
623 if (task->phones[i].state != IPC_PHONE_FREE) {
624 printf("%d: ", i);
625 switch (task->phones[i].state) {
626 case IPC_PHONE_CONNECTING:
627 printf("connecting ");
628 break;
629 case IPC_PHONE_CONNECTED:
630 printf("connected to: %p ",
631 task->phones[i].callee);
632 break;
633 case IPC_PHONE_SLAMMED:
634 printf("slammed by: %p ",
635 task->phones[i].callee);
636 break;
637 case IPC_PHONE_HUNGUP:
638 printf("hung up - was: %p ",
639 task->phones[i].callee);
640 break;
641 default:
642 break;
643 }
644 printf("active: %ld\n",
645 atomic_get(&task->phones[i].active_calls));
646 }
647 mutex_unlock(&task->phones[i].lock);
648 }
649
650
651 /* Print answerbox - calls */
652 spinlock_lock(&task->answerbox.lock);
653 printf("ABOX - CALLS:\n");
654 for (tmp = task->answerbox.calls.next; tmp != &task->answerbox.calls;
655 tmp = tmp->next) {
656 call = list_get_instance(tmp, call_t, link);
657 printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
658 " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
659 " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
660 call->sender->taskid,
661 IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
662 IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
663 IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
664 call->flags);
665 }
666 /* Print answerbox - calls */
667 printf("ABOX - DISPATCHED CALLS:\n");
668 for (tmp = task->answerbox.dispatched_calls.next;
669 tmp != &task->answerbox.dispatched_calls;
670 tmp = tmp->next) {
671 call = list_get_instance(tmp, call_t, link);
672 printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
673 " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
674 " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
675 call->sender->taskid,
676 IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
677 IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
678 IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
679 call->flags);
680 }
681 /* Print answerbox - calls */
682 printf("ABOX - ANSWERS:\n");
683 for (tmp = task->answerbox.answers.next;
684 tmp != &task->answerbox.answers;
685 tmp = tmp->next) {
686 call = list_get_instance(tmp, call_t, link);
687 printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
688 " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
689 call, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
690 IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
691 IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
692 call->flags);
693 }
694
695 spinlock_unlock(&task->answerbox.lock);
696 spinlock_unlock(&task->lock);
697}
698
699/** @}
700 */
Note: See TracBrowser for help on using the repository browser.