Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/ipc/kbox.c

    r5a6cc679 ra35b458  
    6363        TASK->kb.finished = true;
    6464        mutex_unlock(&TASK->kb.cleanup_lock);
    65        
     65
    6666        bool have_kb_thread = (TASK->kb.thread != NULL);
    67        
     67
    6868        /*
    6969         * From now on nobody will try to connect phones or attach
    7070         * kbox threads
    7171         */
    72        
     72
    7373        /*
    7474         * Disconnect all phones connected to our kbox. Passing true for
     
    7878         */
    7979        ipc_answerbox_slam_phones(&TASK->kb.box, have_kb_thread);
    80        
     80
    8181        /*
    8282         * If the task was being debugged, clean up debugging session.
     
    8787        udebug_task_cleanup(TASK);
    8888        mutex_unlock(&TASK->udebug.lock);
    89        
     89
    9090        if (have_kb_thread) {
    9191                LOG("Join kb.thread.");
     
    9595                TASK->kb.thread = NULL;
    9696        }
    97        
     97
    9898        /* Answer all messages in 'calls' and 'dispatched_calls' queues. */
    9999        ipc_cleanup_call_list(&TASK->kb.box, &TASK->kb.box.calls);
     
    120120                LOG("Was not debugger.");
    121121        }
    122        
     122
    123123        LOG("Continue with hangup message.");
    124124        IPC_SET_RETVAL(call->data, 0);
    125125        ipc_answer(&TASK->kb.box, call);
    126        
     126
    127127        mutex_lock(&TASK->kb.cleanup_lock);
    128        
     128
    129129        irq_spinlock_lock(&TASK->lock, true);
    130130        irq_spinlock_lock(&TASK->kb.box.lock, false);
     
    134134                 * gets freed and signal to the caller.
    135135                 */
    136                
     136
    137137                /* Only detach kbox thread unless already terminating. */
    138138                if (TASK->kb.finished == false) {
     
    141141                        TASK->kb.thread = NULL;
    142142                }
    143                
     143
    144144                LOG("Phone list is empty.");
    145145                *last = true;
    146146        } else
    147147                *last = false;
    148        
     148
    149149        irq_spinlock_unlock(&TASK->kb.box.lock, false);
    150150        irq_spinlock_unlock(&TASK->lock, true);
    151        
     151
    152152        mutex_unlock(&TASK->kb.cleanup_lock);
    153153}
     
    166166        LOG("Starting.");
    167167        bool done = false;
    168        
     168
    169169        while (!done) {
    170170                call_t *call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT,
    171171                    SYNCH_FLAGS_NONE);
    172                
     172
    173173                if (call == NULL)
    174174                        continue;  /* Try again. */
    175                
     175
    176176                switch (IPC_GET_IMETHOD(call->data)) {
    177                
     177
    178178                case IPC_M_DEBUG:
    179179                        /* Handle debug call. */
    180180                        udebug_call_receive(call);
    181181                        break;
    182                
     182
    183183                case IPC_M_PHONE_HUNGUP:
    184184                        /*
     
    189189                        kbox_proc_phone_hungup(call, &done);
    190190                        break;
    191                
     191
    192192                default:
    193193                        /* Ignore */
     
    195195                }
    196196        }
    197        
     197
    198198        LOG("Exiting.");
    199199}
     
    213213{
    214214        irq_spinlock_lock(&tasks_lock, true);
    215        
     215
    216216        task_t *task = task_find_by_id(taskid);
    217217        if (task == NULL) {
     
    219219                return ENOENT;
    220220        }
    221        
     221
    222222        atomic_inc(&task->refcount);
    223        
     223
    224224        irq_spinlock_unlock(&tasks_lock, true);
    225        
     225
    226226        mutex_lock(&task->kb.cleanup_lock);
    227        
     227
    228228        if (atomic_predec(&task->refcount) == 0) {
    229229                mutex_unlock(&task->kb.cleanup_lock);
     
    231231                return ENOENT;
    232232        }
    233        
     233
    234234        if (task->kb.finished) {
    235235                mutex_unlock(&task->kb.cleanup_lock);
    236236                return EINVAL;
    237237        }
    238        
     238
    239239        /* Create a kbox thread if necessary. */
    240240        if (task->kb.thread == NULL) {
    241241                thread_t *kb_thread = thread_create(kbox_thread_proc, NULL, task,
    242242                    THREAD_FLAG_NONE, "kbox");
    243                
     243
    244244                if (!kb_thread) {
    245245                        mutex_unlock(&task->kb.cleanup_lock);
    246246                        return ENOMEM;
    247247                }
    248                
     248
    249249                task->kb.thread = kb_thread;
    250250                thread_ready(kb_thread);
    251251        }
    252        
     252
    253253        /* Allocate a new phone. */
    254254        cap_handle_t phone_handle;
     
    258258                return rc;
    259259        }
    260        
     260
    261261        kobject_t *phone_obj = kobject_get(TASK, phone_handle,
    262262            KOBJECT_TYPE_PHONE);
     
    264264        /* Hand over phone_obj's reference to ipc_phone_connect() */
    265265        (void) ipc_phone_connect(phone_obj->phone, &task->kb.box);
    266        
     266
    267267        mutex_unlock(&task->kb.cleanup_lock);
    268268        *out_phone = phone_handle;
Note: See TracChangeset for help on using the changeset viewer.