Subversion Repositories HelenOS

Rev

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