Subversion Repositories HelenOS

Rev

Rev 3445 | Rev 3623 | 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
{
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) {
3441 svoboda 68
        LOG("join kb_thread..\n");
3438 svoboda 69
        thread_join(TASK->kb_thread);
70
        thread_detach(TASK->kb_thread);
3441 svoboda 71
        LOG("join done\n");
3438 svoboda 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;
3441 svoboda 91
    LOG("kbox_thread_proc()\n");
3438 svoboda 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) {
3441 svoboda 106
                LOG("kbox: handle hangup message\n");
3438 svoboda 107
 
108
                /* Was it our debugger, who hung up? */
109
                if (call->sender == TASK->udebug.debugger) {
110
                    /* Terminate debugging session (if any) */
3441 svoboda 111
                    LOG("kbox: terminate debug session\n");
3438 svoboda 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 {
3441 svoboda 118
                    LOG("kbox: was not debugger\n");
3438 svoboda 119
                }
120
 
3441 svoboda 121
                LOG("kbox: continue with hangup message\n");
3438 svoboda 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;
3441 svoboda 132
                    LOG("phone list is empty\n");
3438 svoboda 133
                }
134
                spinlock_unlock(&TASK->answerbox.lock);
135
                spinlock_unlock(&TASK->lock);
136
                interrupts_restore(ipl);
137
            }
138
        }
139
    }
140
 
3441 svoboda 141
    LOG("kbox: finished\n");
3438 svoboda 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
 */