Subversion Repositories HelenOS

Rev

Rev 4055 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3438 svoboda 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>
3441 svoboda 42
#include <debug.h>
3438 svoboda 43
#include <udebug/udebug_ipc.h>
3445 jermar 44
#include <ipc/kbox.h>
3870 decky 45
#include <print.h>
3438 svoboda 46
 
47
void ipc_kbox_cleanup(void)
48
{
3494 svoboda 49
    ipl_t ipl;
3438 svoboda 50
    bool have_kb_thread;
51
 
3620 svoboda 52
    /*
53
     * Only hold kb.cleanup_lock while setting kb.finished -
54
     * this is enough.
55
     */
56
    mutex_lock(&TASK->kb.cleanup_lock);
57
    TASK->kb.finished = true;
58
    mutex_unlock(&TASK->kb.cleanup_lock);
3438 svoboda 59
 
3620 svoboda 60
    have_kb_thread = (TASK->kb.thread != NULL);
3438 svoboda 61
 
3620 svoboda 62
    /*
63
     * From now on nobody will try to connect phones or attach
64
     * kbox threads
65
     */
3438 svoboda 66
 
67
    /*
68
     * Disconnect all phones connected to our kbox. Passing true for
69
     * notify_box causes a HANGUP message to be inserted for each
70
     * disconnected phone. This ensures the kbox thread is going to
71
     * wake up and terminate.
72
     */
3620 svoboda 73
    ipc_answerbox_slam_phones(&TASK->kb.box, have_kb_thread);
3494 svoboda 74
 
75
    /*
76
     * If the task was being debugged, clean up debugging session.
77
     * This is necessarry as slamming the phones won't force
78
     * kbox thread to clean it up since sender != debugger.
79
     */
80
    ipl = interrupts_disable();
81
    spinlock_lock(&TASK->lock);
82
    udebug_task_cleanup(TASK);
83
    spinlock_unlock(&TASK->lock);
84
    interrupts_restore(ipl);
3438 svoboda 85
 
86
    if (have_kb_thread) {
4420 trochtova 87
        LOG("Join kb.thread.");
3620 svoboda 88
        thread_join(TASK->kb.thread);
89
        thread_detach(TASK->kb.thread);
4420 trochtova 90
        LOG("...join done.");
3620 svoboda 91
        TASK->kb.thread = NULL;
3438 svoboda 92
    }
93
 
3620 svoboda 94
    /* Answer all messages in 'calls' and 'dispatched_calls' queues. */
95
    spinlock_lock(&TASK->kb.box.lock);
96
    ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls);
97
    ipc_cleanup_call_list(&TASK->kb.box.calls);
98
    spinlock_unlock(&TASK->kb.box.lock);
3438 svoboda 99
}
100
 
3496 svoboda 101
/** Handle hangup message in kbox.
102
 *
103
 * @param call  The IPC_M_PHONE_HUNGUP call structure.
104
 * @param last  Output, the function stores @c true here if
105
 *      this was the last phone, @c false otherwise.
106
 **/
107
static void kbox_proc_phone_hungup(call_t *call, bool *last)
108
{
109
    ipl_t ipl;
3438 svoboda 110
 
3496 svoboda 111
    /* Was it our debugger, who hung up? */
112
    if (call->sender == TASK->udebug.debugger) {
3620 svoboda 113
        /* Terminate debugging session (if any). */
4420 trochtova 114
        LOG("Terminate debugging session.");
3496 svoboda 115
        ipl = interrupts_disable();
116
        spinlock_lock(&TASK->lock);
117
        udebug_task_cleanup(TASK);
118
        spinlock_unlock(&TASK->lock);
119
        interrupts_restore(ipl);
120
    } else {
4420 trochtova 121
        LOG("Was not debugger.");
3496 svoboda 122
    }
123
 
4420 trochtova 124
    LOG("Continue with hangup message.");
3496 svoboda 125
    IPC_SET_RETVAL(call->data, 0);
3620 svoboda 126
    ipc_answer(&TASK->kb.box, call);
3496 svoboda 127
 
128
    ipl = interrupts_disable();
129
    spinlock_lock(&TASK->lock);
3867 svoboda 130
    spinlock_lock(&TASK->kb.box.lock);
131
    if (list_empty(&TASK->kb.box.connected_phones)) {
3496 svoboda 132
        /*
133
         * Last phone has been disconnected. Detach this thread so it
134
         * gets freed and signal to the caller.
135
         */
136
 
137
        /* Only detach kbox thread unless already terminating. */
3620 svoboda 138
        mutex_lock(&TASK->kb.cleanup_lock);
139
        if (&TASK->kb.finished == false) {
3496 svoboda 140
            /* Detach kbox thread so it gets freed from memory. */
3620 svoboda 141
            thread_detach(TASK->kb.thread);
142
            TASK->kb.thread = NULL;
3496 svoboda 143
        }
3620 svoboda 144
        mutex_unlock(&TASK->kb.cleanup_lock);
3496 svoboda 145
 
4420 trochtova 146
        LOG("Phone list is empty.");
3496 svoboda 147
        *last = true;
148
    } else {
149
        *last = false;
150
    }
151
 
3867 svoboda 152
    spinlock_unlock(&TASK->kb.box.lock);
3496 svoboda 153
    spinlock_unlock(&TASK->lock);
154
    interrupts_restore(ipl);
155
}
156
 
157
/** Implementing function for the kbox thread.
158
 *
159
 * This function listens for debug requests. It terminates
160
 * when all phones are disconnected from the kbox.
161
 *
162
 * @param arg   Ignored.
163
 */
3438 svoboda 164
static void kbox_thread_proc(void *arg)
165
{
166
    call_t *call;
167
    bool done;
168
 
169
    (void)arg;
4420 trochtova 170
    LOG("Starting.");
3438 svoboda 171
    done = false;
172
 
173
    while (!done) {
3620 svoboda 174
        call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT,
3438 svoboda 175
            SYNCH_FLAGS_NONE);
176
 
3496 svoboda 177
        if (call == NULL)
178
            continue;   /* Try again. */
3438 svoboda 179
 
3496 svoboda 180
        switch (IPC_GET_METHOD(call->data)) {
3438 svoboda 181
 
3496 svoboda 182
        case IPC_M_DEBUG_ALL:
183
            /* Handle debug call. */
184
            udebug_call_receive(call);
185
            break;
3438 svoboda 186
 
3496 svoboda 187
        case IPC_M_PHONE_HUNGUP:
188
            /*
189
             * Process the hangup call. If this was the last
190
             * phone, done will be set to true and the
191
             * while loop will terminate.
192
             */
193
            kbox_proc_phone_hungup(call, &done);
194
            break;
3438 svoboda 195
 
3496 svoboda 196
        default:
197
            /* Ignore */
198
            break;
3438 svoboda 199
        }
200
    }
201
 
4420 trochtova 202
    LOG("Exiting.");
3438 svoboda 203
}
204
 
205
 
206
/**
207
 * Connect phone to a task kernel-box specified by id.
208
 *
3620 svoboda 209
 * Note that this is not completely atomic. For optimisation reasons, the task
210
 * might start cleaning up kbox after the phone has been connected and before
211
 * a kbox thread has been created. This must be taken into account in the
212
 * cleanup code.
3438 svoboda 213
 *
214
 * @return      Phone id on success, or negative error code.
215
 */
216
int ipc_connect_kbox(task_id_t taskid)
217
{
218
    int newphid;
219
    task_t *ta;
220
    thread_t *kb_thread;
221
    ipl_t ipl;
222
 
223
    ipl = interrupts_disable();
224
    spinlock_lock(&tasks_lock);
225
 
226
    ta = task_find_by_id(taskid);
227
    if (ta == NULL) {
228
        spinlock_unlock(&tasks_lock);
229
        interrupts_restore(ipl);
230
        return ENOENT;
231
    }
232
 
233
    atomic_inc(&ta->refcount);
234
 
235
    spinlock_unlock(&tasks_lock);
236
    interrupts_restore(ipl);
237
 
3620 svoboda 238
    mutex_lock(&ta->kb.cleanup_lock);
3438 svoboda 239
 
240
    if (atomic_predec(&ta->refcount) == 0) {
3620 svoboda 241
        mutex_unlock(&ta->kb.cleanup_lock);
3438 svoboda 242
        task_destroy(ta);
243
        return ENOENT;
244
    }
245
 
3620 svoboda 246
    if (ta->kb.finished != false) {
247
        mutex_unlock(&ta->kb.cleanup_lock);
3438 svoboda 248
        return EINVAL;
249
    }
250
 
4420 trochtova 251
    newphid = phone_alloc(TASK);
3438 svoboda 252
    if (newphid < 0) {
3620 svoboda 253
        mutex_unlock(&ta->kb.cleanup_lock);
3438 svoboda 254
        return ELIMIT;
255
    }
256
 
257
    /* Connect the newly allocated phone to the kbox */
3620 svoboda 258
    ipc_phone_connect(&TASK->phones[newphid], &ta->kb.box);
3438 svoboda 259
 
3620 svoboda 260
    if (ta->kb.thread != NULL) {
261
        mutex_unlock(&ta->kb.cleanup_lock);
3438 svoboda 262
        return newphid;
263
    }
264
 
265
    /* Create a kbox thread */
3620 svoboda 266
    kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0,
267
        "kbox", false);
3438 svoboda 268
    if (!kb_thread) {
3620 svoboda 269
        mutex_unlock(&ta->kb.cleanup_lock);
3438 svoboda 270
        return ENOMEM;
271
    }
272
 
3620 svoboda 273
    ta->kb.thread = kb_thread;
3438 svoboda 274
    thread_ready(kb_thread);
275
 
3620 svoboda 276
    mutex_unlock(&ta->kb.cleanup_lock);
3438 svoboda 277
 
278
    return newphid;
279
}
280
 
281
/** @}
282
 */