Changes in kernel/generic/src/ipc/ipc.c [da1bafb:170332d] in mainline

File:

• kernel/generic/src/ipc/ipc.c (modified) (37 diffs)

kernel/generic/src/ipc/ipc.c

@@ -66 +66 @@
 /** Initialize a call structure.
  *
- * @param call Call structure to be initialized.
- *
+ * @param call          Call structure to be initialized.
  */
 static void _ipc_call_init(call_t *call)
@@ -78 +77 @@
 
 /** Allocate and initialize a call structure.
- *
+ * 
  * The call is initialized, so that the reply will be directed to
  * TASK->answerbox.
  *
- * @param flags Parameters for slab_alloc (e.g FRAME_ATOMIC).
- *
- * @return If flags permit it, return NULL, or initialized kernel
- *         call structure.
- *
- */
-call_t *ipc_call_alloc(unsigned int flags)
-{
-        call_t *call = slab_alloc(ipc_call_slab, flags);
+ * @param flags         Parameters for slab_alloc (e.g FRAME_ATOMIC).
+ *
+ * @return              If flags permit it, return NULL, or initialized kernel
+ *                      call structure.
+ */
+call_t *ipc_call_alloc(int flags)
+{
+        call_t *call;
+
+        call = slab_alloc(ipc_call_slab, flags);
         if (call)
                 _ipc_call_init(call);
-        
+
         return call;
 }
@@ -99 +99 @@
 /** Deallocate a call structure.
  *
- * @param call Call structure to be freed.
- *
+ * @param call          Call structure to be freed.
  */
 void ipc_call_free(call_t *call)
@@ -112 +111 @@
 /** Initialize an answerbox structure.
  *
- * @param box  Answerbox structure to be initialized.
- * @param task Task to which the answerbox belongs.
- *
+ * @param box           Answerbox structure to be initialized.
+ * @param task          Task to which the answerbox belongs.
  */
 void ipc_answerbox_init(answerbox_t *box, task_t *task)
 {
-        irq_spinlock_initialize(&box->lock, "ipc.box.lock");
-        irq_spinlock_initialize(&box->irq_lock, "ipc.box.irqlock");
+        spinlock_initialize(&box->lock, "ipc_box_lock");
+        spinlock_initialize(&box->irq_lock, "ipc_box_irqlock");
         waitq_initialize(&box->wq);
         link_initialize(&box->sync_box_link);
@@ -133 +131 @@
 /** Connect a phone to an answerbox.
  *
- * @param phone Initialized phone structure.
- * @param box   Initialized answerbox structure.
- *
+ * @param phone         Initialized phone structure.
+ * @param box           Initialized answerbox structure.
  */
 void ipc_phone_connect(phone_t *phone, answerbox_t *box)
 {
         mutex_lock(&phone->lock);
-        
+
         phone->state = IPC_PHONE_CONNECTED;
         phone->callee = box;
-        
-        irq_spinlock_lock(&box->lock, true);
+
+        spinlock_lock(&box->lock);
         list_append(&phone->link, &box->connected_phones);
-        irq_spinlock_unlock(&box->lock, true);
-        
+        spinlock_unlock(&box->lock);
+
         mutex_unlock(&phone->lock);
 }
@@ -153 +150 @@
 /** Initialize a phone structure.
  *
- * @param phone Phone structure to be initialized.
- *
+ * @param phone         Phone structure to be initialized.
  */
 void ipc_phone_init(phone_t *phone)
@@ -166 +162 @@
 /** Helper function to facilitate synchronous calls.
  *
- * @param phone   Destination kernel phone structure.
- * @param request Call structure with request.
- *
- * @return EOK on success or EINTR if the sleep was interrupted.
- *
+ * @param phone         Destination kernel phone structure.
+ * @param request       Call structure with request.
+ *
+ * @return              EOK on success or EINTR if the sleep was interrupted.
  */
 int ipc_call_sync(phone_t *phone, call_t *request)
 {
-        answerbox_t *sync_box = slab_alloc(ipc_answerbox_slab, 0);
+        answerbox_t *sync_box; 
+        ipl_t ipl;
+
+        sync_box = slab_alloc(ipc_answerbox_slab, 0);
         ipc_answerbox_init(sync_box, TASK);
-        
+
         /*
          * Put the answerbox on the TASK's list of synchronous answerboxes so
          * that it can be cleaned up if the call is interrupted.
          */
-        irq_spinlock_lock(&TASK->lock, true);
+        ipl = interrupts_disable();
+        spinlock_lock(&TASK->lock);
         list_append(&sync_box->sync_box_link, &TASK->sync_box_head);
-        irq_spinlock_unlock(&TASK->lock, true);
-        
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+
         /* We will receive data in a special box. */
         request->callerbox = sync_box;
-        
+
         ipc_call(phone, request);
         if (!ipc_wait_for_call(sync_box, SYNCH_NO_TIMEOUT,
             SYNCH_FLAGS_INTERRUPTIBLE)) {
-                /* The answerbox and the call will be freed by ipc_cleanup(). */
+                /* The answerbox and the call will be freed by ipc_cleanup(). */
                 return EINTR;
         }
-        
+
         /*
          * The answer arrived without interruption so we can remove the
          * answerbox from the TASK's list of synchronous answerboxes.
          */
-        irq_spinlock_lock(&TASK->lock, true);
+        (void) interrupts_disable();
+        spinlock_lock(&TASK->lock);
         list_remove(&sync_box->sync_box_link);
-        irq_spinlock_unlock(&TASK->lock, true);
-        
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+
         slab_free(ipc_answerbox_slab, sync_box);
         return EOK;
@@ -209 +211 @@
 /** Answer a message which was not dispatched and is not listed in any queue.
  *
- * @param call       Call structure to be answered.
- * @param selflocked If true, then TASK->answebox is locked.
- *
+ * @param call          Call structure to be answered.
+ * @param selflocked    If true, then TASK->answebox is locked.
  */
 static void _ipc_answer_free_call(call_t *call, bool selflocked)
@@ -217 +218 @@
         answerbox_t *callerbox = call->callerbox;
         bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox));
-        
+        ipl_t ipl;
+
         /* Count sent answer */
-        irq_spinlock_lock(&TASK->lock, true);
+        ipl = interrupts_disable();
+        spinlock_lock(&TASK->lock);
         TASK->ipc_info.answer_sent++;
-        irq_spinlock_unlock(&TASK->lock, true);
-        
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+
         call->flags |= IPC_CALL_ANSWERED;
-        
+
         if (call->flags & IPC_CALL_FORWARDED) {
                 if (call->caller_phone) {
@@ -231 +235 @@
                 }
         }
-        
+
         if (do_lock)
-                irq_spinlock_lock(&callerbox->lock, true);
-        
+                spinlock_lock(&callerbox->lock);
         list_append(&call->link, &callerbox->answers);
-        
         if (do_lock)
-                irq_spinlock_unlock(&callerbox->lock, true);
-        
+                spinlock_unlock(&callerbox->lock);
         waitq_wakeup(&callerbox->wq, WAKEUP_FIRST);
 }
@@ -245 +246 @@
 /** Answer a message which is in a callee queue.
  *
- * @param box  Answerbox that is answering the message.
- * @param call Modified request that is being sent back.
- *
+ * @param box           Answerbox that is answering the message.
+ * @param call          Modified request that is being sent back.
  */
 void ipc_answer(answerbox_t *box, call_t *call)
 {
         /* Remove from active box */
-        irq_spinlock_lock(&box->lock, true);
+        spinlock_lock(&box->lock);
         list_remove(&call->link);
-        irq_spinlock_unlock(&box->lock, true);
-        
+        spinlock_unlock(&box->lock);
         /* Send back answer */
         _ipc_answer_free_call(call, false);
@@ -265 +264 @@
  * message and sending it as a normal answer.
  *
- * @param phone Phone structure the call should appear to come from.
- * @param call  Call structure to be answered.
- * @param err   Return value to be used for the answer.
- *
+ * @param phone         Phone structure the call should appear to come from.
+ * @param call          Call structure to be answered.
+ * @param err           Return value to be used for the answer.
  */
 void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err)
@@ -280 +278 @@
 /** Unsafe unchecking version of ipc_call.
  *
- * @param phone Phone structure the call comes from.
- * @param box   Destination answerbox structure.
- * @param call  Call structure with request.
- *
+ * @param phone         Phone structure the call comes from.
+ * @param box           Destination answerbox structure.
+ * @param call          Call structure with request.
  */
 static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call)
 {
+        ipl_t ipl;
+
         /* Count sent ipc call */
-        irq_spinlock_lock(&TASK->lock, true);
+        ipl = interrupts_disable();
+        spinlock_lock(&TASK->lock);
         TASK->ipc_info.call_sent++;
-        irq_spinlock_unlock(&TASK->lock, true);
-        
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+
         if (!(call->flags & IPC_CALL_FORWARDED)) {
                 atomic_inc(&phone->active_calls);
                 call->data.phone = phone;
         }
-        
-        irq_spinlock_lock(&box->lock, true);
+
+        spinlock_lock(&box->lock);
         list_append(&call->link, &box->calls);
-        irq_spinlock_unlock(&box->lock, true);
-        
+        spinlock_unlock(&box->lock);
         waitq_wakeup(&box->wq, WAKEUP_FIRST);
 }
@@ -306 +306 @@
 /** Send an asynchronous request using a phone to an answerbox.
  *
- * @param phone Phone structure the call comes from and which is
- *              connected to the destination answerbox.
- * @param call  Call structure with request.
- *
- * @return Return 0 on success, ENOENT on error.
- *
+ * @param phone         Phone structure the call comes from and which is
+ *                      connected to the destination answerbox.
+ * @param call          Call structure with request.
+ *
+ * @return              Return 0 on success, ENOENT on error.
  */
 int ipc_call(phone_t *phone, call_t *call)
 {
+        answerbox_t *box;
+
         mutex_lock(&phone->lock);
         if (phone->state != IPC_PHONE_CONNECTED) {
@@ -327 +328 @@
                                 ipc_backsend_err(phone, call, ENOENT);
                 }
-                
                 return ENOENT;
         }
-        
-        answerbox_t *box = phone->callee;
+        box = phone->callee;
         _ipc_call(phone, box, call);
         
@@ -343 +342 @@
  * lazily later.
  *
- * @param phone Phone structure to be hung up.
- *
- * @return 0 if the phone is disconnected.
- * @return -1 if the phone was already disconnected.
- *
+ * @param phone         Phone structure to be hung up.
+ *              
+ * @return              Return 0 if the phone is disconnected.
+ *                      Return -1 if the phone was already disconnected.
  */
 int ipc_phone_hangup(phone_t *phone)
 {
+        answerbox_t *box;
+        call_t *call;
+        
         mutex_lock(&phone->lock);
         if (phone->state == IPC_PHONE_FREE ||
@@ -358 +359 @@
                 return -1;
         }
-        
-        answerbox_t *box = phone->callee;
+        box = phone->callee;
         if (phone->state != IPC_PHONE_SLAMMED) {
                 /* Remove myself from answerbox */
-                irq_spinlock_lock(&box->lock, true);
+                spinlock_lock(&box->lock);
                 list_remove(&phone->link);
-                irq_spinlock_unlock(&box->lock, true);
-                
-                call_t *call = ipc_call_alloc(0);
+                spinlock_unlock(&box->lock);
+
+                call = ipc_call_alloc(0);
                 IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
                 call->flags |= IPC_CALL_DISCARD_ANSWER;
                 _ipc_call(phone, box, call);
         }
-        
+
         phone->state = IPC_PHONE_HUNGUP;
         mutex_unlock(&phone->lock);
-        
+
         return 0;
 }
@@ -380 +380 @@
 /** Forwards call from one answerbox to another one.
  *
- * @param call     Call structure to be redirected.
- * @param newphone Phone structure to target answerbox.
- * @param oldbox   Old answerbox structure.
- * @param mode     Flags that specify mode of the forward operation.
- *
- * @return 0 if forwarding succeeded or an error code if
- *         there was an error.
- *
+ * @param call          Call structure to be redirected.
+ * @param newphone      Phone structure to target answerbox.
+ * @param oldbox        Old answerbox structure.
+ * @param mode          Flags that specify mode of the forward operation.
+ *
+ * @return              Return 0 if forwarding succeeded or an error code if
+ *                      there was error.
+ * 
  * The return value serves only as an information for the forwarder,
  * the original caller is notified automatically with EFORWARD.
- *
- */
-int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox,
-    unsigned int mode)
-{
+ */
+int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox, int mode)
+{
+        ipl_t ipl;
+
         /* Count forwarded calls */
-        irq_spinlock_lock(&TASK->lock, true);
+        ipl = interrupts_disable();
+        spinlock_lock(&TASK->lock);
         TASK->ipc_info.forwarded++;
-        irq_spinlock_pass(&TASK->lock, &oldbox->lock);
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+
+        spinlock_lock(&oldbox->lock);
         list_remove(&call->link);
-        irq_spinlock_unlock(&oldbox->lock, true);
-        
+        spinlock_unlock(&oldbox->lock);
+
         if (mode & IPC_FF_ROUTE_FROM_ME) {
                 if (!call->caller_phone)
@@ -407 +411 @@
                 call->data.phone = newphone;
         }
-        
+
         return ipc_call(newphone, call);
 }
@@ -414 +418 @@
 /** Wait for a phone call.
  *
- * @param box   Answerbox expecting the call.
- * @param usec  Timeout in microseconds. See documentation for
- *              waitq_sleep_timeout() for decription of its special
- *              meaning.
- * @param flags Select mode of sleep operation. See documentation for
- *              waitq_sleep_timeout() for description of its special
- *              meaning.
- *
- * @return Recived call structure or NULL.
- *
+ * @param box           Answerbox expecting the call.
+ * @param usec          Timeout in microseconds. See documentation for
+ *                      waitq_sleep_timeout() for decription of its special
+ *                      meaning.
+ * @param flags         Select mode of sleep operation. See documentation for
+ *                      waitq_sleep_timeout() for description of its special
+ *                      meaning.
+ * @return              Recived call structure or NULL.
+ * 
  * To distinguish between a call and an answer, have a look at call->flags.
- *
- */
-call_t *ipc_wait_for_call(answerbox_t *box, uint32_t usec, unsigned int flags)
+ */
+call_t *ipc_wait_for_call(answerbox_t *box, uint32_t usec, int flags)
 {
         call_t *request;
+        ipl_t ipl;
         uint64_t irq_cnt = 0;
         uint64_t answer_cnt = 0;
         uint64_t call_cnt = 0;
         int rc;
-        
+
 restart:
         rc = waitq_sleep_timeout(&box->wq, usec, flags);
@@ -440 +443 @@
                 return NULL;
         
-        irq_spinlock_lock(&box->lock, true);
+        spinlock_lock(&box->lock);
         if (!list_empty(&box->irq_notifs)) {
                 /* Count recieved IRQ notification */
-                irq_cnt++;
-                
-                irq_spinlock_lock(&box->irq_lock, false);
-                
+                irq_cnt++;      
+
+                ipl = interrupts_disable();
+                spinlock_lock(&box->irq_lock);
+
                 request = list_get_instance(box->irq_notifs.next, call_t, link);
                 list_remove(&request->link);
-                
-                irq_spinlock_unlock(&box->irq_lock, false);
+
+                spinlock_unlock(&box->irq_lock);
+                interrupts_restore(ipl);
         } else if (!list_empty(&box->answers)) {
                 /* Count recieved answer */
                 answer_cnt++;
-                
+
                 /* Handle asynchronous answers */
                 request = list_get_instance(box->answers.next, call_t, link);
@@ -462 +467 @@
                 /* Count recieved call */
                 call_cnt++;
-                
+
                 /* Handle requests */
                 request = list_get_instance(box->calls.next, call_t, link);
                 list_remove(&request->link);
-                
                 /* Append request to dispatch queue */
                 list_append(&request->link, &box->dispatched_calls);
         } else {
                 /* This can happen regularly after ipc_cleanup */
-                irq_spinlock_unlock(&box->lock, true);
+                spinlock_unlock(&box->lock);
                 goto restart;
         }
+        spinlock_unlock(&box->lock);
         
-        irq_spinlock_pass(&box->lock, &TASK->lock);
-        
+        ipl = interrupts_disable();
+        spinlock_lock(&TASK->lock);
         TASK->ipc_info.irq_notif_recieved += irq_cnt;
         TASK->ipc_info.answer_recieved += answer_cnt;
         TASK->ipc_info.call_recieved += call_cnt;
-        
-        irq_spinlock_unlock(&TASK->lock, true);
-        
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+
         return request;
 }
@@ -488 +493 @@
 /** Answer all calls from list with EHANGUP answer.
  *
- * @param lst Head of the list to be cleaned up.
- *
+ * @param lst           Head of the list to be cleaned up.
  */
 void ipc_cleanup_call_list(link_t *lst)
 {
+        call_t *call;
+
         while (!list_empty(lst)) {
-                call_t *call = list_get_instance(lst->next, call_t, link);
+                call = list_get_instance(lst->next, call_t, link);
                 if (call->buffer)
                         free(call->buffer);
-                
                 list_remove(&call->link);
-                
+
                 IPC_SET_RETVAL(call->data, EHANGUP);
                 _ipc_answer_free_call(call, true);
@@ -507 +512 @@
 /** Disconnects all phones connected to an answerbox.
  *
- * @param box        Answerbox to disconnect phones from.
- * @param notify_box If true, the answerbox will get a hangup message for
- *                   each disconnected phone.
- *
+ * @param box           Answerbox to disconnect phones from.
+ * @param notify_box    If true, the answerbox will get a hangup message for
+ *                      each disconnected phone.
  */
 void ipc_answerbox_slam_phones(answerbox_t *box, bool notify_box)
@@ -516 +520 @@
         phone_t *phone;
         DEADLOCK_PROBE_INIT(p_phonelck);
-        
-        call_t *call = notify_box ? ipc_call_alloc(0) : NULL;
-        
+        ipl_t ipl;
+        call_t *call;
+
+        call = notify_box ? ipc_call_alloc(0) : NULL;
+
         /* Disconnect all phones connected to our answerbox */
 restart_phones:
-        irq_spinlock_lock(&box->lock, true);
+        ipl = interrupts_disable();
+        spinlock_lock(&box->lock);
         while (!list_empty(&box->connected_phones)) {
                 phone = list_get_instance(box->connected_phones.next,
                     phone_t, link);
                 if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
-                        irq_spinlock_unlock(&box->lock, true);
+                        spinlock_unlock(&box->lock);
+                        interrupts_restore(ipl);
                         DEADLOCK_PROBE(p_phonelck, DEADLOCK_THRESHOLD);
                         goto restart_phones;
@@ -533 +541 @@
                 /* Disconnect phone */
                 ASSERT(phone->state == IPC_PHONE_CONNECTED);
-                
+
                 list_remove(&phone->link);
                 phone->state = IPC_PHONE_SLAMMED;
-                
+
                 if (notify_box) {
                         mutex_unlock(&phone->lock);
-                        irq_spinlock_unlock(&box->lock, true);
-                        
+                        spinlock_unlock(&box->lock);
+                        interrupts_restore(ipl);
+
                         /*
                          * Send one message to the answerbox for each
@@ -550 +559 @@
                         call->flags |= IPC_CALL_DISCARD_ANSWER;
                         _ipc_call(phone, box, call);
-                        
+
                         /* Allocate another call in advance */
                         call = ipc_call_alloc(0);
-                        
+
                         /* Must start again */
                         goto restart_phones;
                 }
-                
+
                 mutex_unlock(&phone->lock);
         }
-        
-        irq_spinlock_unlock(&box->lock, true);
-        
+
+        spinlock_unlock(&box->lock);
+        interrupts_restore(ipl);
+
         /* Free unused call */
         if (call)
@@ -568 +578 @@
 }
 
-/** Clean up all IPC communication of the current task.
+/** Cleans up all IPC communication of the current task.
  *
  * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
  * have to change it as well if you want to cleanup other tasks than TASK.
- *
  */
 void ipc_cleanup(void)
 {
+        int i;
+        call_t *call;
+        ipl_t ipl;
+
         /* Disconnect all our phones ('ipc_phone_hangup') */
-        size_t i;
         for (i = 0; i < IPC_MAX_PHONES; i++)
                 ipc_phone_hangup(&TASK->phones[i]);
-        
+
         /* Unsubscribe from any event notifications. */
         event_cleanup_answerbox(&TASK->answerbox);
-        
+
         /* Disconnect all connected irqs */
         ipc_irq_cleanup(&TASK->answerbox);
-        
+
         /* Disconnect all phones connected to our regular answerbox */
         ipc_answerbox_slam_phones(&TASK->answerbox, false);
-        
+
 #ifdef CONFIG_UDEBUG
         /* Clean up kbox thread and communications */
         ipc_kbox_cleanup();
 #endif
-        
+
         /* Answer all messages in 'calls' and 'dispatched_calls' queues */
-        irq_spinlock_lock(&TASK->answerbox.lock, true);
+        spinlock_lock(&TASK->answerbox.lock);
         ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls);
         ipc_cleanup_call_list(&TASK->answerbox.calls);
-        irq_spinlock_unlock(&TASK->answerbox.lock, true);
+        spinlock_unlock(&TASK->answerbox.lock);
         
         /* Wait for all answers to interrupted synchronous calls to arrive */
-        ipl_t ipl = interrupts_disable();
+        ipl = interrupts_disable();
         while (!list_empty(&TASK->sync_box_head)) {
                 answerbox_t *box = list_get_instance(TASK->sync_box_head.next,
                     answerbox_t, sync_box_link);
-                
+
                 list_remove(&box->sync_box_link);
-                call_t *call = ipc_wait_for_call(box, SYNCH_NO_TIMEOUT,
+                call = ipc_wait_for_call(box, SYNCH_NO_TIMEOUT,
                     SYNCH_FLAGS_NONE);
                 ipc_call_free(call);
@@ -614 +626 @@
         }
         interrupts_restore(ipl);
-        
+
         /* Wait for all answers to asynchronous calls to arrive */
-        while (true) {
-                /*
-                 * Go through all phones, until they are all FREE
-                 * Locking is not needed, no one else should modify
-                 * it when we are in cleanup
-                 */
+        while (1) {
+                /* Go through all phones, until all are FREE... */
+                /* Locking not needed, no one else should modify
+                 * it, when we are in cleanup */
                 for (i = 0; i < IPC_MAX_PHONES; i++) {
                         if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
@@ -629 +639 @@
                         }
                         
-                        /*
-                         * Just for sure, we might have had some
-                         * IPC_PHONE_CONNECTING phones
-                         */
+                        /* Just for sure, we might have had some 
+                         * IPC_PHONE_CONNECTING phones */
                         if (TASK->phones[i].state == IPC_PHONE_CONNECTED)
                                 ipc_phone_hangup(&TASK->phones[i]);
-                        
-                        /*
-                         * If the hangup succeeded, it has sent a HANGUP
+                        /* If the hangup succeeded, it has sent a HANGUP 
                          * message, the IPC is now in HUNGUP state, we
-                         * wait for the reply to come
-                         */
+                         * wait for the reply to come */
                         
                         if (TASK->phones[i].state != IPC_PHONE_FREE)
                                 break;
                 }
-                
-                /* Got into cleanup */
+                /* Voila, got into cleanup */
                 if (i == IPC_MAX_PHONES)
                         break;
                 
-                call_t *call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT,
+                call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT,
                     SYNCH_FLAGS_NONE);
                 ASSERT((call->flags & IPC_CALL_ANSWERED) ||
@@ -662 +666 @@
                 if (!(call->flags & IPC_CALL_DISCARD_ANSWER))
                         atomic_dec(&TASK->active_calls);
-                
                 ipc_call_free(call);
         }
 }
 
-/** Initilize IPC subsystem
- *
- */
+
+/** Initilize IPC subsystem */
 void ipc_init(void)
 {
@@ -678 +680 @@
 }
 
+
 /** List answerbox contents.
  *
- * @param taskid Task ID.
- *
+ * @param taskid        Task ID.
  */
 void ipc_print_task(task_id_t taskid)
 {
-        irq_spinlock_lock(&tasks_lock, true);
-        task_t *task = task_find_by_id(taskid);
+        task_t *task;
+        int i;
+        call_t *call;
+        link_t *tmp;
+        ipl_t ipl;
         
+        ipl = interrupts_disable();
+        spinlock_lock(&tasks_lock);
+        task = task_find_by_id(taskid);
+        if (task) 
+                spinlock_lock(&task->lock);
+        spinlock_unlock(&tasks_lock);
         if (!task) {
-                irq_spinlock_unlock(&tasks_lock, true);
+                interrupts_restore(ipl);
                 return;
         }
-        
-        /* Hand-over-hand locking */
-        irq_spinlock_exchange(&tasks_lock, &task->lock);
-        
+
         /* Print opened phones & details */
         printf("PHONE:\n");
-        
-        size_t i;
         for (i = 0; i < IPC_MAX_PHONES; i++) {
                 if (SYNCH_FAILED(mutex_trylock(&task->phones[i].lock))) {
@@ -705 +711 @@
                         continue;
                 }
-                
                 if (task->phones[i].state != IPC_PHONE_FREE) {
-                        printf("%" PRIs ": ", i);
-                        
+                        printf("%d: ", i);
                         switch (task->phones[i].state) {
                         case IPC_PHONE_CONNECTING:
@@ -714 +718 @@
                                 break;
                         case IPC_PHONE_CONNECTED:
-                                printf("connected to: %p ",
-                                    task->phones[i].callee);
+                                printf("connected to: %p ", 
+                                       task->phones[i].callee);
                                 break;
                         case IPC_PHONE_SLAMMED:
                                 printf("slammed by: %p ", 
-                                    task->phones[i].callee);
+                                       task->phones[i].callee);
                                 break;
                         case IPC_PHONE_HUNGUP:
                                 printf("hung up - was: %p ", 
-                                    task->phones[i].callee);
+                                       task->phones[i].callee);
                                 break;
                         default:
                                 break;
                         }
-                        
-                        printf("active: %" PRIun "\n",
+                        printf("active: %ld\n",
                             atomic_get(&task->phones[i].active_calls));
                 }
-                
                 mutex_unlock(&task->phones[i].lock);
         }
-        
-        irq_spinlock_lock(&task->answerbox.lock, false);
-        
-        link_t *cur;
-        
+
+
         /* Print answerbox - calls */
+        spinlock_lock(&task->answerbox.lock);
         printf("ABOX - CALLS:\n");
-        for (cur = task->answerbox.calls.next; cur != &task->answerbox.calls;
-            cur = cur->next) {
-                call_t *call = list_get_instance(cur, call_t, link);
+        for (tmp = task->answerbox.calls.next; tmp != &task->answerbox.calls;
+            tmp = tmp->next) {
+                call = list_get_instance(tmp, call_t, link);
                 printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun 
                     " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
@@ -754 +754 @@
                     call->flags);
         }
-        
-        /* Print answerbox - dispatched calls */
+        /* Print answerbox - calls */
         printf("ABOX - DISPATCHED CALLS:\n");
-        for (cur = task->answerbox.dispatched_calls.next;
-            cur != &task->answerbox.dispatched_calls;
-            cur = cur->next) {
-                call_t *call = list_get_instance(cur, call_t, link);
+        for (tmp = task->answerbox.dispatched_calls.next;
+            tmp != &task->answerbox.dispatched_calls; 
+            tmp = tmp->next) {
+                call = list_get_instance(tmp, call_t, link);
                 printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
                     " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
@@ -770 +769 @@
                     call->flags);
         }
-        
-        /* Print answerbox - answers */
+        /* Print answerbox - calls */
         printf("ABOX - ANSWERS:\n");
-        for (cur = task->answerbox.answers.next;
-            cur != &task->answerbox.answers;
-            cur = cur->next) {
-                call_t *call = list_get_instance(cur, call_t, link);
+        for (tmp = task->answerbox.answers.next;
+            tmp != &task->answerbox.answers;
+            tmp = tmp->next) {
+                call = list_get_instance(tmp, call_t, link);
                 printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
                     " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
@@ -784 +782 @@
                     call->flags);
         }
-        
-        irq_spinlock_unlock(&task->answerbox.lock, false);
-        irq_spinlock_unlock(&task->lock, true);
+
+        spinlock_unlock(&task->answerbox.lock);
+        spinlock_unlock(&task->lock);
+        interrupts_restore(ipl);
 }