Subversion Repositories HelenOS

Rev

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