Subversion Repositories HelenOS

Rev

Rev 3445 | Rev 3674 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2008 Jiri Svoboda
  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. #include <synch/synch.h>
  36. #include <synch/spinlock.h>
  37. #include <synch/mutex.h>
  38. #include <ipc/ipc.h>
  39. #include <ipc/ipcrsc.h>
  40. #include <arch.h>
  41. #include <errno.h>
  42. #include <debug.h>
  43. #include <udebug/udebug_ipc.h>
  44. #include <ipc/kbox.h>
  45.  
  46. void ipc_kbox_cleanup(void)
  47. {
  48.     bool have_kb_thread;
  49.  
  50.     /* Only hold kb_cleanup_lock while setting kb_finished - this is enough */
  51.     mutex_lock(&TASK->kb_cleanup_lock);
  52.     TASK->kb_finished = true;
  53.     mutex_unlock(&TASK->kb_cleanup_lock);
  54.  
  55.     have_kb_thread = (TASK->kb_thread != NULL);
  56.  
  57.     /* From now on nobody will try to connect phones or attach kbox threads */
  58.  
  59.     /*
  60.      * Disconnect all phones connected to our kbox. Passing true for
  61.      * notify_box causes a HANGUP message to be inserted for each
  62.      * disconnected phone. This ensures the kbox thread is going to
  63.      * wake up and terminate.
  64.      */
  65.     ipc_answerbox_slam_phones(&TASK->kernel_box, have_kb_thread);
  66.    
  67.     if (have_kb_thread) {
  68.         LOG("join kb_thread..\n");
  69.         thread_join(TASK->kb_thread);
  70.         thread_detach(TASK->kb_thread);
  71.         LOG("join done\n");
  72.         TASK->kb_thread = NULL;
  73.     }
  74.  
  75.     /* Answer all messages in 'calls' and 'dispatched_calls' queues */
  76.     spinlock_lock(&TASK->kernel_box.lock);
  77.     ipc_cleanup_call_list(&TASK->kernel_box.dispatched_calls);
  78.     ipc_cleanup_call_list(&TASK->kernel_box.calls);
  79.     spinlock_unlock(&TASK->kernel_box.lock);
  80. }
  81.  
  82.  
  83. static void kbox_thread_proc(void *arg)
  84. {
  85.     call_t *call;
  86.     int method;
  87.     bool done;
  88.     ipl_t ipl;
  89.  
  90.     (void)arg;
  91.     LOG("kbox_thread_proc()\n");
  92.     done = false;
  93.  
  94.     while (!done) {
  95.         call = ipc_wait_for_call(&TASK->kernel_box, SYNCH_NO_TIMEOUT,
  96.             SYNCH_FLAGS_NONE);
  97.  
  98.         if (call != NULL) {
  99.             method = IPC_GET_METHOD(call->data);
  100.  
  101.             if (method == IPC_M_DEBUG_ALL) {
  102.                 udebug_call_receive(call);
  103.             }
  104.  
  105.             if (method == IPC_M_PHONE_HUNGUP) {
  106.                 LOG("kbox: handle hangup message\n");
  107.  
  108.                 /* Was it our debugger, who hung up? */
  109.                 if (call->sender == TASK->udebug.debugger) {
  110.                     /* Terminate debugging session (if any) */
  111.                     LOG("kbox: terminate debug session\n");
  112.                     ipl = interrupts_disable();
  113.                     spinlock_lock(&TASK->lock);
  114.                     udebug_task_cleanup(TASK);
  115.                     spinlock_unlock(&TASK->lock);
  116.                     interrupts_restore(ipl);
  117.                 } else {
  118.                     LOG("kbox: was not debugger\n");
  119.                 }
  120.  
  121.                 LOG("kbox: continue with hangup message\n");
  122.                 IPC_SET_RETVAL(call->data, 0);
  123.                 ipc_answer(&TASK->kernel_box, call);
  124.  
  125.                 ipl = interrupts_disable();
  126.                 spinlock_lock(&TASK->lock);
  127.                 spinlock_lock(&TASK->answerbox.lock);
  128.                 if (list_empty(&TASK->answerbox.connected_phones)) {
  129.                     /* Last phone has been disconnected */
  130.                     TASK->kb_thread = NULL;
  131.                     done = true;
  132.                     LOG("phone list is empty\n");
  133.                 }
  134.                 spinlock_unlock(&TASK->answerbox.lock);
  135.                 spinlock_unlock(&TASK->lock);
  136.                 interrupts_restore(ipl);
  137.             }
  138.         }
  139.     }
  140.  
  141.     LOG("kbox: finished\n");
  142. }
  143.  
  144.  
  145. /**
  146.  * Connect phone to a task kernel-box specified by id.
  147.  *
  148.  * Note that this is not completely atomic. For optimisation reasons,
  149.  * The task might start cleaning up kbox after the phone has been connected
  150.  * and before a kbox thread has been created. This must be taken into account
  151.  * in the cleanup code.
  152.  *
  153.  * @return      Phone id on success, or negative error code.
  154.  */
  155. int ipc_connect_kbox(task_id_t taskid)
  156. {
  157.     int newphid;
  158.     task_t *ta;
  159.     thread_t *kb_thread;
  160.     ipl_t ipl;
  161.  
  162.     ipl = interrupts_disable();
  163.     spinlock_lock(&tasks_lock);
  164.  
  165.     ta = task_find_by_id(taskid);
  166.     if (ta == NULL) {
  167.         spinlock_unlock(&tasks_lock);
  168.         interrupts_restore(ipl);
  169.         return ENOENT;
  170.     }
  171.  
  172.     atomic_inc(&ta->refcount);
  173.  
  174.     spinlock_unlock(&tasks_lock);
  175.     interrupts_restore(ipl);
  176.  
  177.     mutex_lock(&ta->kb_cleanup_lock);
  178.  
  179.     if (atomic_predec(&ta->refcount) == 0) {
  180.         mutex_unlock(&ta->kb_cleanup_lock);
  181.         task_destroy(ta);
  182.         return ENOENT;
  183.     }
  184.  
  185.     if (ta->kb_finished != false) {
  186.         mutex_unlock(&ta->kb_cleanup_lock);
  187.         return EINVAL;
  188.     }
  189.  
  190.     newphid = phone_alloc();
  191.     if (newphid < 0) {
  192.         mutex_unlock(&ta->kb_cleanup_lock);
  193.         return ELIMIT;
  194.     }
  195.  
  196.     /* Connect the newly allocated phone to the kbox */
  197.     ipc_phone_connect(&TASK->phones[newphid], &ta->kernel_box);
  198.  
  199.     if (ta->kb_thread != NULL) {
  200.         mutex_unlock(&ta->kb_cleanup_lock);
  201.         return newphid;
  202.     }
  203.  
  204.     /* Create a kbox thread */
  205.     kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0, "kbox", false);
  206.     if (!kb_thread) {
  207.         mutex_unlock(&ta->kb_cleanup_lock);
  208.         return ENOMEM;
  209.     }
  210.  
  211.     ta->kb_thread = kb_thread;
  212.     thread_ready(kb_thread);
  213.  
  214.     mutex_unlock(&ta->kb_cleanup_lock);
  215.  
  216.     return newphid;
  217. }
  218.  
  219. /** @}
  220.  */
  221.