2 * Copyright (c) 2006 Ondrej Palkovsky
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
29 /** @addtogroup genericipc
37 * First the answerbox, then the phone.
41 #include <synch/spinlock.h>
42 #include <synch/mutex.h>
43 #include <synch/waitq.h>
45 #include <ipc/ipcrsc.h>
46 #include <abi/ipc/methods.h>
48 #include <ipc/event.h>
49 #include <ipc/sysipc_ops.h>
50 #include <ipc/sysipc_priv.h>
54 #include <proc/task.h>
57 #include <console/console.h>
58 #include <proc/thread.h>
59 #include <arch/interrupt.h>
63 static void ipc_forget_call(call_t
*);
65 /** Answerbox that new tasks are automatically connected to */
66 answerbox_t
*ipc_box_0
= NULL
;
68 static slab_cache_t
*call_cache
;
69 static slab_cache_t
*answerbox_cache
;
71 slab_cache_t
*phone_cache
= NULL
;
73 /** Initialize a call structure.
75 * @param call Call structure to be initialized.
78 static void _ipc_call_init(call_t
*call
)
80 memsetb(call
, sizeof(*call
), 0);
81 spinlock_initialize(&call
->forget_lock
, "forget_lock");
85 call
->callerbox
= NULL
;
89 static void call_destroy(void *arg
)
91 call_t
*call
= (call_t
*) arg
;
95 if (call
->caller_phone
)
96 kobject_put(call
->caller_phone
->kobject
);
97 slab_free(call_cache
, call
);
100 static kobject_ops_t call_kobject_ops
= {
101 .destroy
= call_destroy
104 /** Allocate and initialize a call structure.
106 * The call is initialized, so that the reply will be directed to
109 * @param flags Parameters for slab_alloc (e.g FRAME_ATOMIC).
111 * @return If flags permit it, return NULL, or initialized kernel
112 * call structure with one reference.
115 call_t
*ipc_call_alloc(unsigned int flags
)
117 call_t
*call
= slab_alloc(call_cache
, flags
);
120 kobject_t
*kobj
= (kobject_t
*) malloc(sizeof(kobject_t
), flags
);
122 slab_free(call_cache
, call
);
126 _ipc_call_init(call
);
127 kobject_initialize(kobj
, KOBJECT_TYPE_CALL
, call
, &call_kobject_ops
);
128 call
->kobject
= kobj
;
133 /** Initialize an answerbox structure.
135 * @param box Answerbox structure to be initialized.
136 * @param task Task to which the answerbox belongs.
139 void ipc_answerbox_init(answerbox_t
*box
, task_t
*task
)
141 irq_spinlock_initialize(&box
->lock
, "ipc.box.lock");
142 irq_spinlock_initialize(&box
->irq_lock
, "ipc.box.irqlock");
143 waitq_initialize(&box
->wq
);
144 list_initialize(&box
->connected_phones
);
145 list_initialize(&box
->calls
);
146 list_initialize(&box
->dispatched_calls
);
147 list_initialize(&box
->answers
);
148 list_initialize(&box
->irq_notifs
);
149 atomic_set(&box
->active_calls
, 0);
153 /** Connect a phone to an answerbox.
155 * This function must be passed a reference to phone->kobject.
157 * @param phone Initialized phone structure.
158 * @param box Initialized answerbox structure.
159 * @return True if the phone was connected, false otherwise.
161 bool ipc_phone_connect(phone_t
*phone
, answerbox_t
*box
)
165 mutex_lock(&phone
->lock
);
166 irq_spinlock_lock(&box
->lock
, true);
168 connected
= box
->active
&& (phone
->state
== IPC_PHONE_CONNECTING
);
170 phone
->state
= IPC_PHONE_CONNECTED
;
172 /* Pass phone->kobject reference to box->connected_phones */
173 list_append(&phone
->link
, &box
->connected_phones
);
176 irq_spinlock_unlock(&box
->lock
, true);
177 mutex_unlock(&phone
->lock
);
180 /* We still have phone->kobject's reference; drop it */
181 kobject_put(phone
->kobject
);
187 /** Initialize a phone structure.
189 * @param phone Phone structure to be initialized.
190 * @param caller Owning task.
193 void ipc_phone_init(phone_t
*phone
, task_t
*caller
)
195 mutex_initialize(&phone
->lock
, MUTEX_PASSIVE
);
196 phone
->caller
= caller
;
197 phone
->callee
= NULL
;
198 phone
->state
= IPC_PHONE_FREE
;
199 atomic_set(&phone
->active_calls
, 0);
200 phone
->kobject
= NULL
;
203 /** Helper function to facilitate synchronous calls.
205 * @param phone Destination kernel phone structure.
206 * @param request Call structure with request.
208 * @return EOK on success or an error code.
211 errno_t
ipc_call_sync(phone_t
*phone
, call_t
*request
)
213 answerbox_t
*mybox
= slab_alloc(answerbox_cache
, 0);
214 ipc_answerbox_init(mybox
, TASK
);
216 /* We will receive data in a special box. */
217 request
->callerbox
= mybox
;
219 errno_t rc
= ipc_call(phone
, request
);
221 slab_free(answerbox_cache
, mybox
);
225 call_t
*answer
= ipc_wait_for_call(mybox
, SYNCH_NO_TIMEOUT
,
226 SYNCH_FLAGS_INTERRUPTIBLE
);
230 * The sleep was interrupted.
232 * There are two possibilities now:
233 * 1) the call gets answered before we manage to forget it
234 * 2) we manage to forget the call before it gets answered
237 spinlock_lock(&request
->forget_lock
);
238 spinlock_lock(&TASK
->active_calls_lock
);
240 assert(!request
->forget
);
242 bool answered
= !request
->active
;
245 * The call is not yet answered and we won the race to
248 ipc_forget_call(request
); /* releases locks */
252 spinlock_unlock(&TASK
->active_calls_lock
);
253 spinlock_unlock(&request
->forget_lock
);
258 * The other side won the race to answer the call.
259 * It is safe to wait for the answer uninterruptibly
262 answer
= ipc_wait_for_call(mybox
, SYNCH_NO_TIMEOUT
,
266 assert(!answer
|| request
== answer
);
268 slab_free(answerbox_cache
, mybox
);
272 /** Answer a message which was not dispatched and is not listed in any queue.
274 * @param call Call structure to be answered.
275 * @param selflocked If true, then TASK->answebox is locked.
278 void _ipc_answer_free_call(call_t
*call
, bool selflocked
)
280 /* Count sent answer */
281 irq_spinlock_lock(&TASK
->lock
, true);
282 TASK
->ipc_info
.answer_sent
++;
283 irq_spinlock_unlock(&TASK
->lock
, true);
285 spinlock_lock(&call
->forget_lock
);
287 /* This is a forgotten call and call->sender is not valid. */
288 spinlock_unlock(&call
->forget_lock
);
289 kobject_put(call
->kobject
);
293 * If the call is still active, i.e. it was answered
294 * in a non-standard way, remove the call from the
295 * sender's active call list.
298 spinlock_lock(&call
->sender
->active_calls_lock
);
299 list_remove(&call
->ta_link
);
300 spinlock_unlock(&call
->sender
->active_calls_lock
);
303 spinlock_unlock(&call
->forget_lock
);
305 answerbox_t
*callerbox
= call
->callerbox
? call
->callerbox
:
306 &call
->sender
->answerbox
;
307 bool do_lock
= ((!selflocked
) || (callerbox
!= &TASK
->answerbox
));
309 call
->flags
|= IPC_CALL_ANSWERED
;
311 call
->data
.task_id
= TASK
->taskid
;
314 irq_spinlock_lock(&callerbox
->lock
, true);
316 list_append(&call
->ab_link
, &callerbox
->answers
);
319 irq_spinlock_unlock(&callerbox
->lock
, true);
321 waitq_wakeup(&callerbox
->wq
, WAKEUP_FIRST
);
324 /** Answer a message which is in a callee queue.
326 * @param box Answerbox that is answering the message.
327 * @param call Modified request that is being sent back.
330 void ipc_answer(answerbox_t
*box
, call_t
*call
)
332 /* Remove from active box */
333 irq_spinlock_lock(&box
->lock
, true);
334 list_remove(&call
->ab_link
);
335 irq_spinlock_unlock(&box
->lock
, true);
337 /* Send back answer */
338 _ipc_answer_free_call(call
, false);
341 static void _ipc_call_actions_internal(phone_t
*phone
, call_t
*call
,
344 task_t
*caller
= phone
->caller
;
346 call
->caller_phone
= phone
;
347 kobject_add_ref(phone
->kobject
);
352 atomic_inc(&phone
->active_calls
);
353 atomic_inc(&caller
->answerbox
.active_calls
);
354 kobject_add_ref(phone
->kobject
);
355 call
->sender
= caller
;
357 spinlock_lock(&caller
->active_calls_lock
);
358 list_append(&call
->ta_link
, &caller
->active_calls
);
359 spinlock_unlock(&caller
->active_calls_lock
);
362 call
->data
.phone
= phone
;
363 call
->data
.task_id
= caller
->taskid
;
366 /** Simulate sending back a message.
368 * Most errors are better handled by forming a normal backward
369 * message and sending it as a normal answer.
371 * @param phone Phone structure the call should appear to come from.
372 * @param call Call structure to be answered.
373 * @param err Return value to be used for the answer.
376 void ipc_backsend_err(phone_t
*phone
, call_t
*call
, errno_t err
)
378 _ipc_call_actions_internal(phone
, call
, false);
379 IPC_SET_RETVAL(call
->data
, err
);
380 _ipc_answer_free_call(call
, false);
383 /** Unsafe unchecking version of ipc_call.
385 * @param phone Phone structure the call comes from.
386 * @param box Destination answerbox structure.
387 * @param call Call structure with request.
388 * @param preforget If true, the call will be delivered already forgotten.
391 static void _ipc_call(phone_t
*phone
, answerbox_t
*box
, call_t
*call
,
394 task_t
*caller
= phone
->caller
;
396 /* Count sent ipc call */
397 irq_spinlock_lock(&caller
->lock
, true);
398 caller
->ipc_info
.call_sent
++;
399 irq_spinlock_unlock(&caller
->lock
, true);
401 if (!(call
->flags
& IPC_CALL_FORWARDED
))
402 _ipc_call_actions_internal(phone
, call
, preforget
);
404 irq_spinlock_lock(&box
->lock
, true);
405 list_append(&call
->ab_link
, &box
->calls
);
406 irq_spinlock_unlock(&box
->lock
, true);
408 waitq_wakeup(&box
->wq
, WAKEUP_FIRST
);
411 /** Send an asynchronous request using a phone to an answerbox.
413 * @param phone Phone structure the call comes from and which is
414 * connected to the destination answerbox.
415 * @param call Call structure with request.
417 * @return Return 0 on success, ENOENT on error.
420 errno_t
ipc_call(phone_t
*phone
, call_t
*call
)
422 mutex_lock(&phone
->lock
);
423 if (phone
->state
!= IPC_PHONE_CONNECTED
) {
424 mutex_unlock(&phone
->lock
);
425 if (!(call
->flags
& IPC_CALL_FORWARDED
)) {
426 if (phone
->state
== IPC_PHONE_HUNGUP
)
427 ipc_backsend_err(phone
, call
, EHANGUP
);
429 ipc_backsend_err(phone
, call
, ENOENT
);
435 answerbox_t
*box
= phone
->callee
;
436 _ipc_call(phone
, box
, call
, false);
438 mutex_unlock(&phone
->lock
);
442 /** Disconnect phone from answerbox.
444 * This call leaves the phone in the hung-up state. The phone is destroyed when
445 * its last active call is answered and there are no references to it.
447 * @param phone Phone structure to be hung up.
449 * @return EOK if the phone is disconnected.
450 * @return EINVAL if the phone was already disconnected.
453 errno_t
ipc_phone_hangup(phone_t
*phone
)
455 mutex_lock(&phone
->lock
);
456 if (phone
->state
== IPC_PHONE_FREE
||
457 phone
->state
== IPC_PHONE_HUNGUP
||
458 phone
->state
== IPC_PHONE_CONNECTING
) {
459 mutex_unlock(&phone
->lock
);
463 answerbox_t
*box
= phone
->callee
;
464 if (phone
->state
!= IPC_PHONE_SLAMMED
) {
465 /* Remove myself from answerbox */
466 irq_spinlock_lock(&box
->lock
, true);
467 list_remove(&phone
->link
);
468 irq_spinlock_unlock(&box
->lock
, true);
470 /* Drop the answerbox reference */
471 kobject_put(phone
->kobject
);
473 call_t
*call
= ipc_call_alloc(0);
474 IPC_SET_IMETHOD(call
->data
, IPC_M_PHONE_HUNGUP
);
475 call
->request_method
= IPC_M_PHONE_HUNGUP
;
476 call
->flags
|= IPC_CALL_DISCARD_ANSWER
;
477 _ipc_call(phone
, box
, call
, false);
480 phone
->state
= IPC_PHONE_HUNGUP
;
481 mutex_unlock(&phone
->lock
);
486 /** Forwards call from one answerbox to another one.
488 * @param call Call structure to be redirected.
489 * @param newphone Phone structure to target answerbox.
490 * @param oldbox Old answerbox structure.
491 * @param mode Flags that specify mode of the forward operation.
493 * @return 0 if forwarding succeeded or an error code if
494 * there was an error.
496 * The return value serves only as an information for the forwarder,
497 * the original caller is notified automatically with EFORWARD.
500 errno_t
ipc_forward(call_t
*call
, phone_t
*newphone
, answerbox_t
*oldbox
,
503 /* Count forwarded calls */
504 irq_spinlock_lock(&TASK
->lock
, true);
505 TASK
->ipc_info
.forwarded
++;
506 irq_spinlock_pass(&TASK
->lock
, &oldbox
->lock
);
507 list_remove(&call
->ab_link
);
508 irq_spinlock_unlock(&oldbox
->lock
, true);
510 if (mode
& IPC_FF_ROUTE_FROM_ME
) {
511 call
->data
.phone
= newphone
;
512 call
->data
.task_id
= TASK
->taskid
;
515 return ipc_call(newphone
, call
);
519 /** Wait for a phone call.
521 * @param box Answerbox expecting the call.
522 * @param usec Timeout in microseconds. See documentation for
523 * waitq_sleep_timeout() for decription of its special
525 * @param flags Select mode of sleep operation. See documentation for
526 * waitq_sleep_timeout() for description of its special
529 * @return Recived call structure or NULL.
531 * To distinguish between a call and an answer, have a look at call->flags.
534 call_t
*ipc_wait_for_call(answerbox_t
*box
, uint32_t usec
, unsigned int flags
)
537 uint64_t irq_cnt
= 0;
538 uint64_t answer_cnt
= 0;
539 uint64_t call_cnt
= 0;
543 rc
= waitq_sleep_timeout(&box
->wq
, usec
, flags
, NULL
);
547 irq_spinlock_lock(&box
->lock
, true);
548 if (!list_empty(&box
->irq_notifs
)) {
549 /* Count received IRQ notification */
552 irq_spinlock_lock(&box
->irq_lock
, false);
554 request
= list_get_instance(list_first(&box
->irq_notifs
),
556 list_remove(&request
->ab_link
);
558 irq_spinlock_unlock(&box
->irq_lock
, false);
559 } else if (!list_empty(&box
->answers
)) {
560 /* Count received answer */
563 /* Handle asynchronous answers */
564 request
= list_get_instance(list_first(&box
->answers
),
566 list_remove(&request
->ab_link
);
567 atomic_dec(&request
->caller_phone
->active_calls
);
568 atomic_dec(&box
->active_calls
);
569 kobject_put(request
->caller_phone
->kobject
);
570 } else if (!list_empty(&box
->calls
)) {
571 /* Count received call */
574 /* Handle requests */
575 request
= list_get_instance(list_first(&box
->calls
),
577 list_remove(&request
->ab_link
);
579 /* Append request to dispatch queue */
580 list_append(&request
->ab_link
, &box
->dispatched_calls
);
582 /* This can happen regularly after ipc_cleanup */
583 irq_spinlock_unlock(&box
->lock
, true);
587 irq_spinlock_pass(&box
->lock
, &TASK
->lock
);
589 TASK
->ipc_info
.irq_notif_received
+= irq_cnt
;
590 TASK
->ipc_info
.answer_received
+= answer_cnt
;
591 TASK
->ipc_info
.call_received
+= call_cnt
;
593 irq_spinlock_unlock(&TASK
->lock
, true);
598 /** Answer all calls from list with EHANGUP answer.
600 * @param box Answerbox with the list.
601 * @param lst Head of the list to be cleaned up.
603 void ipc_cleanup_call_list(answerbox_t
*box
, list_t
*lst
)
605 irq_spinlock_lock(&box
->lock
, true);
606 while (!list_empty(lst
)) {
607 call_t
*call
= list_get_instance(list_first(lst
), call_t
,
610 list_remove(&call
->ab_link
);
612 irq_spinlock_unlock(&box
->lock
, true);
614 if (lst
== &box
->calls
)
615 SYSIPC_OP(request_process
, call
, box
);
617 ipc_data_t old
= call
->data
;
618 IPC_SET_RETVAL(call
->data
, EHANGUP
);
619 answer_preprocess(call
, &old
);
620 _ipc_answer_free_call(call
, true);
622 irq_spinlock_lock(&box
->lock
, true);
624 irq_spinlock_unlock(&box
->lock
, true);
627 /** Disconnects all phones connected to an answerbox.
629 * @param box Answerbox to disconnect phones from.
630 * @param notify_box If true, the answerbox will get a hangup message for
631 * each disconnected phone.
634 void ipc_answerbox_slam_phones(answerbox_t
*box
, bool notify_box
)
637 DEADLOCK_PROBE_INIT(p_phonelck
);
639 /* Disconnect all phones connected to our answerbox */
641 irq_spinlock_lock(&box
->lock
, true);
642 while (!list_empty(&box
->connected_phones
)) {
643 phone
= list_get_instance(list_first(&box
->connected_phones
),
645 if (mutex_trylock(&phone
->lock
) != EOK
) {
646 irq_spinlock_unlock(&box
->lock
, true);
647 DEADLOCK_PROBE(p_phonelck
, DEADLOCK_THRESHOLD
);
651 /* Disconnect phone */
652 assert(phone
->state
== IPC_PHONE_CONNECTED
);
654 list_remove(&phone
->link
);
655 phone
->state
= IPC_PHONE_SLAMMED
;
658 task_hold(phone
->caller
);
659 mutex_unlock(&phone
->lock
);
660 irq_spinlock_unlock(&box
->lock
, true);
663 * Send one call to the answerbox for each phone.
664 * Used to make sure the kbox thread wakes up after
665 * the last phone has been disconnected. The call is
666 * forgotten upon sending, so the "caller" may cease
667 * to exist as soon as we release it.
669 call_t
*call
= ipc_call_alloc(0);
670 IPC_SET_IMETHOD(call
->data
, IPC_M_PHONE_HUNGUP
);
671 call
->request_method
= IPC_M_PHONE_HUNGUP
;
672 call
->flags
|= IPC_CALL_DISCARD_ANSWER
;
673 _ipc_call(phone
, box
, call
, true);
675 task_release(phone
->caller
);
677 kobject_put(phone
->kobject
);
679 /* Must start again */
683 mutex_unlock(&phone
->lock
);
684 kobject_put(phone
->kobject
);
687 irq_spinlock_unlock(&box
->lock
, true);
690 static void ipc_forget_call(call_t
*call
)
692 assert(spinlock_locked(&TASK
->active_calls_lock
));
693 assert(spinlock_locked(&call
->forget_lock
));
696 * Forget the call and donate it to the task which holds up the answer.
701 list_remove(&call
->ta_link
);
704 * The call may be freed by _ipc_answer_free_call() before we are done
705 * with it; to avoid working with a destroyed call_t structure, we
706 * must hold a reference to it.
708 kobject_add_ref(call
->kobject
);
710 spinlock_unlock(&call
->forget_lock
);
711 spinlock_unlock(&TASK
->active_calls_lock
);
713 atomic_dec(&call
->caller_phone
->active_calls
);
714 atomic_dec(&TASK
->answerbox
.active_calls
);
715 kobject_put(call
->caller_phone
->kobject
);
717 SYSIPC_OP(request_forget
, call
);
719 kobject_put(call
->kobject
);
722 static void ipc_forget_all_active_calls(void)
727 spinlock_lock(&TASK
->active_calls_lock
);
728 if (list_empty(&TASK
->active_calls
)) {
730 * We are done, there are no more active calls.
731 * Nota bene: there may still be answers waiting for pick up.
733 spinlock_unlock(&TASK
->active_calls_lock
);
737 call
= list_get_instance(list_first(&TASK
->active_calls
), call_t
,
740 if (!spinlock_trylock(&call
->forget_lock
)) {
742 * Avoid deadlock and let async_answer() or
743 * _ipc_answer_free_call() win the race to dequeue the first
746 spinlock_unlock(&TASK
->active_calls_lock
);
750 ipc_forget_call(call
);
755 static bool phone_cap_cleanup_cb(cap_t
*cap
, void *arg
)
757 ipc_phone_hangup(cap
->kobject
->phone
);
758 kobject_t
*kobj
= cap_unpublish(cap
->task
, cap
->handle
,
761 cap_free(cap
->task
, cap
->handle
);
765 /** Wait for all answers to asynchronous calls to arrive. */
766 static void ipc_wait_for_all_answered_calls(void)
768 while (atomic_get(&TASK
->answerbox
.active_calls
) != 0) {
769 call_t
*call
= ipc_wait_for_call(&TASK
->answerbox
,
770 SYNCH_NO_TIMEOUT
, SYNCH_FLAGS_NONE
);
771 assert(call
->flags
& (IPC_CALL_ANSWERED
| IPC_CALL_NOTIF
));
773 SYSIPC_OP(answer_process
, call
);
775 kobject_put(call
->kobject
);
778 * Now there may be some new phones and new hangup calls to
779 * immediately forget.
781 caps_apply_to_kobject_type(TASK
, KOBJECT_TYPE_PHONE
,
782 phone_cap_cleanup_cb
, NULL
);
783 ipc_forget_all_active_calls();
787 static bool irq_cap_cleanup_cb(cap_t
*cap
, void *arg
)
789 ipc_irq_unsubscribe(&TASK
->answerbox
, cap
->handle
);
793 static bool call_cap_cleanup_cb(cap_t
*cap
, void *arg
)
796 * Here we just free the capability and release the kobject.
797 * The kernel answers the remaining calls elsewhere in ipc_cleanup().
799 kobject_t
*kobj
= cap_unpublish(cap
->task
, cap
->handle
,
802 cap_free(cap
->task
, cap
->handle
);
806 /** Clean up all IPC communication of the current task.
808 * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
809 * have to change it as well if you want to cleanup other tasks than TASK.
812 void ipc_cleanup(void)
815 * Mark the answerbox as inactive.
817 * The main purpose for doing this is to prevent any pending callback
818 * connections from getting established beyond this point.
820 irq_spinlock_lock(&TASK
->answerbox
.lock
, true);
821 TASK
->answerbox
.active
= false;
822 irq_spinlock_unlock(&TASK
->answerbox
.lock
, true);
824 /* Hangup all phones and destroy all phone capabilities */
825 caps_apply_to_kobject_type(TASK
, KOBJECT_TYPE_PHONE
,
826 phone_cap_cleanup_cb
, NULL
);
828 /* Unsubscribe from any event notifications */
829 event_cleanup_answerbox(&TASK
->answerbox
);
831 /* Disconnect all connected IRQs */
832 caps_apply_to_kobject_type(TASK
, KOBJECT_TYPE_IRQ
, irq_cap_cleanup_cb
,
835 /* Disconnect all phones connected to our regular answerbox */
836 ipc_answerbox_slam_phones(&TASK
->answerbox
, false);
839 /* Clean up kbox thread and communications */
843 /* Destroy all call capabilities */
844 caps_apply_to_kobject_type(TASK
, KOBJECT_TYPE_CALL
, call_cap_cleanup_cb
,
847 /* Answer all messages in 'calls' and 'dispatched_calls' queues */
848 ipc_cleanup_call_list(&TASK
->answerbox
, &TASK
->answerbox
.calls
);
849 ipc_cleanup_call_list(&TASK
->answerbox
,
850 &TASK
->answerbox
.dispatched_calls
);
852 ipc_forget_all_active_calls();
853 ipc_wait_for_all_answered_calls();
855 assert(atomic_get(&TASK
->answerbox
.active_calls
) == 0);
858 /** Initilize IPC subsystem
863 call_cache
= slab_cache_create("call_t", sizeof(call_t
), 0, NULL
,
865 phone_cache
= slab_cache_create("phone_t", sizeof(phone_t
), 0, NULL
,
867 answerbox_cache
= slab_cache_create("answerbox_t", sizeof(answerbox_t
),
872 static void ipc_print_call_list(list_t
*list
)
874 list_foreach(*list
, ab_link
, call_t
, call
) {
876 printf("%10p ", call
);
880 printf("%18p ", call
);
883 spinlock_lock(&call
->forget_lock
);
885 printf("%-8" PRIun
" %-6" PRIun
" %-6" PRIun
" %-6" PRIun
886 " %-6" PRIun
" %-6" PRIun
" %-7x",
887 IPC_GET_IMETHOD(call
->data
), IPC_GET_ARG1(call
->data
),
888 IPC_GET_ARG2(call
->data
), IPC_GET_ARG3(call
->data
),
889 IPC_GET_ARG4(call
->data
), IPC_GET_ARG5(call
->data
),
893 printf(" ? (call forgotten)\n");
895 printf(" %" PRIu64
" (%s)\n",
896 call
->sender
->taskid
, call
->sender
->name
);
899 spinlock_unlock(&call
->forget_lock
);
903 static bool print_task_phone_cb(cap_t
*cap
, void *arg
)
905 phone_t
*phone
= cap
->kobject
->phone
;
907 mutex_lock(&phone
->lock
);
908 if (phone
->state
!= IPC_PHONE_FREE
) {
909 printf("%-11d %7" PRIun
" ", cap
->handle
,
910 atomic_get(&phone
->active_calls
));
912 switch (phone
->state
) {
913 case IPC_PHONE_CONNECTING
:
914 printf("connecting");
916 case IPC_PHONE_CONNECTED
:
917 printf("connected to %" PRIu64
" (%s)",
918 phone
->callee
->task
->taskid
,
919 phone
->callee
->task
->name
);
921 case IPC_PHONE_SLAMMED
:
922 printf("slammed by %p", phone
->callee
);
924 case IPC_PHONE_HUNGUP
:
925 printf("hung up to %p", phone
->callee
);
933 mutex_unlock(&phone
->lock
);
938 /** List answerbox contents.
940 * @param taskid Task ID.
943 void ipc_print_task(task_id_t taskid
)
945 irq_spinlock_lock(&tasks_lock
, true);
946 task_t
*task
= task_find_by_id(taskid
);
948 irq_spinlock_unlock(&tasks_lock
, true);
952 irq_spinlock_unlock(&tasks_lock
, true);
954 printf("[phone cap] [calls] [state\n");
956 caps_apply_to_kobject_type(task
, KOBJECT_TYPE_PHONE
,
957 print_task_phone_cb
, NULL
);
959 irq_spinlock_lock(&task
->lock
, true);
960 irq_spinlock_lock(&task
->answerbox
.lock
, false);
963 printf("[call id ] [method] [arg1] [arg2] [arg3] [arg4] [arg5]"
964 " [flags] [sender\n");
968 printf("[call id ] [method] [arg1] [arg2] [arg3] [arg4]"
969 " [arg5] [flags] [sender\n");
972 printf(" --- incomming calls ---\n");
973 ipc_print_call_list(&task
->answerbox
.calls
);
974 printf(" --- dispatched calls ---\n");
975 ipc_print_call_list(&task
->answerbox
.dispatched_calls
);
976 printf(" --- incoming answers ---\n");
977 ipc_print_call_list(&task
->answerbox
.answers
);
979 irq_spinlock_unlock(&task
->answerbox
.lock
, false);
980 irq_spinlock_unlock(&task
->lock
, true);