Subversion Repositories HelenOS

Rev

Rev 3441 | Go to most recent revision | Details | 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>
42 
#include <print.h>
43 
#include <udebug/udebug_ipc.h>
44 
#include <ipc/ipc_kbox.h>
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) {
68 
        printf("join kb_thread..\n");
69 
        thread_join(TASK->kb_thread);
70 
        thread_detach(TASK->kb_thread);
71 
        printf("join done\n");
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;
91 
    printf("kbox_thread_proc()\n");
92 
    done = false;
93 
 
94 
    while (!done) {
95 
        //printf("kbox: wait for call\n");
96 
        call = ipc_wait_for_call(&TASK->kernel_box, SYNCH_NO_TIMEOUT,
97 
            SYNCH_FLAGS_NONE);
98 
 
99 
        if (call != NULL) {
100 
            method = IPC_GET_METHOD(call->data);
101 
 
102 
            if (method == IPC_M_DEBUG_ALL) {
103 
                udebug_call_receive(call);
104 
            }
105 
 
106 
            if (method == IPC_M_PHONE_HUNGUP) {
107 
                printf("kbox: handle hangup message\n");
108 
 
109 
                /* Was it our debugger, who hung up? */
110 
                if (call->sender == TASK->udebug.debugger) {
111 
                    /* Terminate debugging session (if any) */
112 
                    printf("kbox: terminate debug session\n");
113 
                    ipl = interrupts_disable();
114 
                    spinlock_lock(&TASK->lock);
115 
                    udebug_task_cleanup(TASK);
116 
                    spinlock_unlock(&TASK->lock);
117 
                    interrupts_restore(ipl);
118 
                } else {
119 
                    printf("kbox: was not debugger\n");
120 
                }
121 
 
122 
                printf("kbox: continue with hangup message\n");
123 
                IPC_SET_RETVAL(call->data, 0);
124 
                ipc_answer(&TASK->kernel_box, call);
125 
 
126 
                ipl = interrupts_disable();
127 
                spinlock_lock(&TASK->lock);
128 
                spinlock_lock(&TASK->answerbox.lock);
129 
                if (list_empty(&TASK->answerbox.connected_phones)) {
130 
                    /* Last phone has been disconnected */
131 
                    TASK->kb_thread = NULL;
132 
                    done = true;
133 
                    printf("phone list is empty\n");
134 
                }
135 
                spinlock_unlock(&TASK->answerbox.lock);
136 
                spinlock_unlock(&TASK->lock);
137 
                interrupts_restore(ipl);
138 
            }
139 
        }
140 
    }
141 
 
142 
    printf("kbox: finished\n");
143 
}
144 
 
145 
 
146 
/**
147 
 * Connect phone to a task kernel-box specified by id.
148 
 *
149 
 * Note that this is not completely atomic. For optimisation reasons,
150 
 * The task might start cleaning up kbox after the phone has been connected
151 
 * and before a kbox thread has been created. This must be taken into account
152 
 * in the cleanup code.
153 
 *
154 
 * @return      Phone id on success, or negative error code.
155 
 */
156 
int ipc_connect_kbox(task_id_t taskid)
157 
{
158 
    int newphid;
159 
    task_t *ta;
160 
    thread_t *kb_thread;
161 
    ipl_t ipl;
162 
 
163 
    ipl = interrupts_disable();
164 
    spinlock_lock(&tasks_lock);
165 
 
166 
    ta = task_find_by_id(taskid);
167 
    if (ta == NULL) {
168 
        spinlock_unlock(&tasks_lock);
169 
        interrupts_restore(ipl);
170 
        return ENOENT;
171 
    }
172 
 
173 
    atomic_inc(&ta->refcount);
174 
 
175 
    spinlock_unlock(&tasks_lock);
176 
    interrupts_restore(ipl);
177 
 
178 
    mutex_lock(&ta->kb_cleanup_lock);
179 
 
180 
    if (atomic_predec(&ta->refcount) == 0) {
181 
        mutex_unlock(&ta->kb_cleanup_lock);
182 
        task_destroy(ta);
183 
        return ENOENT;
184 
    }
185 
 
186 
    if (ta->kb_finished != false) {
187 
        mutex_unlock(&ta->kb_cleanup_lock);
188 
        return EINVAL;
189 
    }
190 
 
191 
    newphid = phone_alloc();
192 
    if (newphid < 0) {
193 
        mutex_unlock(&ta->kb_cleanup_lock);
194 
        return ELIMIT;
195 
    }
196 
 
197 
    /* Connect the newly allocated phone to the kbox */
198 
    ipc_phone_connect(&TASK->phones[newphid], &ta->kernel_box);
199 
 
200 
    if (ta->kb_thread != NULL) {
201 
        mutex_unlock(&ta->kb_cleanup_lock);
202 
        return newphid;
203 
    }
204 
 
205 
    /* Create a kbox thread */
206 
    kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0, "kbox", false);
207 
    if (!kb_thread) {
208 
        mutex_unlock(&ta->kb_cleanup_lock);
209 
        return ENOMEM;
210 
    }
211 
 
212 
    ta->kb_thread = kb_thread;
213 
    thread_ready(kb_thread);
214 
 
215 
    mutex_unlock(&ta->kb_cleanup_lock);
216 
 
217 
    return newphid;
218 
}
219 
 
220 
/** @}
221 
 */