WebSVN – HelenOS – Diff – /branches/tracing/kernel/generic/src/ipc/kbox.c


/*
 * Copyright (c) 2008 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup genericipc
 * @{
 */
/** @file
 */
 
#include <synch/synch.h>
#include <synch/spinlock.h>
#include <synch/mutex.h>
#include <ipc/ipc.h>
#include <ipc/ipcrsc.h>
#include <arch.h>
#include <errno.h>
#include <debug.h>
#include <udebug/udebug_ipc.h>
#include <ipc/kbox.h>
#include <print.h>
 
void ipc_kbox_cleanup(void)
{
    ipl_t ipl;
    bool have_kb_thread;
 
    /*
     * Only hold kb.cleanup_lock while setting kb.finished -
     * this is enough.
     */
    mutex_lock(&TASK->kb.cleanup_lock);
    TASK->kb.finished = true;
    mutex_unlock(&TASK->kb.cleanup_lock);
 
    have_kb_thread = (TASK->kb.thread != NULL);
 
    /*
     * From now on nobody will try to connect phones or attach
     * kbox threads
     */
 
    /*
     * Disconnect all phones connected to our kbox. Passing true for
     * notify_box causes a HANGUP message to be inserted for each
     * disconnected phone. This ensures the kbox thread is going to
     * wake up and terminate.
     */
    ipc_answerbox_slam_phones(&TASK->kb.box, have_kb_thread);
 
    /*
     * If the task was being debugged, clean up debugging session.
     * This is necessarry as slamming the phones won't force
     * kbox thread to clean it up since sender != debugger.
     */
    ipl = interrupts_disable();
    spinlock_lock(&TASK->lock);
    udebug_task_cleanup(TASK);
    spinlock_unlock(&TASK->lock);
    interrupts_restore(ipl);
   
    if (have_kb_thread) {
        LOG("Join kb.thread.");
        thread_join(TASK->kb.thread);
        thread_detach(TASK->kb.thread);
        LOG("...join done.");
        TASK->kb.thread = NULL;
    }
 
    /* Answer all messages in 'calls' and 'dispatched_calls' queues. */
    spinlock_lock(&TASK->kb.box.lock);
    ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls);
    ipc_cleanup_call_list(&TASK->kb.box.calls);
    spinlock_unlock(&TASK->kb.box.lock);
}
 
/** Handle hangup message in kbox.
 *
 * @param call  The IPC_M_PHONE_HUNGUP call structure.
 * @param last  Output, the function stores @c true here if
 *      this was the last phone, @c false otherwise.
 **/
static void kbox_proc_phone_hungup(call_t *call, bool *last)
{
    ipl_t ipl;
 
 
 
    /* Was it our debugger, who hung up? */
    if (call->sender == TASK->udebug.debugger) {
        /* Terminate debugging session (if any). */
        LOG("Terminate debugging session.");
        ipl = interrupts_disable();
        spinlock_lock(&TASK->lock);
        udebug_task_cleanup(TASK);
        spinlock_unlock(&TASK->lock);
        interrupts_restore(ipl);
    } else {
        LOG("Was not debugger.");
    }
 
    LOG("Continue with hangup message.");
    IPC_SET_RETVAL(call->data, 0);
    ipc_answer(&TASK->kb.box, call);
 
    ipl = interrupts_disable();
    spinlock_lock(&TASK->lock);
    spinlock_lock(&TASK->kb.box.lock);
    if (list_empty(&TASK->kb.box.connected_phones)) {
        /*
         * Last phone has been disconnected. Detach this thread so it
         * gets freed and signal to the caller.
         */
 
        /* Only detach kbox thread unless already terminating. */
        mutex_lock(&TASK->kb.cleanup_lock);
        if (&TASK->kb.finished == false) {
            /* Detach kbox thread so it gets freed from memory. */
            thread_detach(TASK->kb.thread);
            TASK->kb.thread = NULL;
        }
        mutex_unlock(&TASK->kb.cleanup_lock);
 
        LOG("Phone list is empty.");
        *last = true;
    } else {
        *last = false;
    }
 
    spinlock_unlock(&TASK->kb.box.lock);
    spinlock_unlock(&TASK->lock);
    interrupts_restore(ipl);
}
 
/** Implementing function for the kbox thread.
 *
 * This function listens for debug requests. It terminates
 * when all phones are disconnected from the kbox.
 *
 * @param arg   Ignored.
 */
static void kbox_thread_proc(void *arg)
{
    call_t *call;
    bool done;
 
    (void)arg;
    LOG("Starting.");
    done = false;
 
    while (!done) {
        call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT,
            SYNCH_FLAGS_NONE);
 
        if (call == NULL)
            continue;   /* Try again. */
 
        switch (IPC_GET_METHOD(call->data)) {
 
        case IPC_M_DEBUG_ALL:
            /* Handle debug call. */
            udebug_call_receive(call);
            break;
 
        case IPC_M_PHONE_HUNGUP:
            /*
             * Process the hangup call. If this was the last
             * phone, done will be set to true and the
             * while loop will terminate.
             */
            kbox_proc_phone_hungup(call, &done);
            break;
 
        default:
            /* Ignore */
            break;
        }
    }
 
    LOG("Exiting.");
}
 
 
/**
 * Connect phone to a task kernel-box specified by id.
 *
 * Note that this is not completely atomic. For optimisation reasons, the task
 * might start cleaning up kbox after the phone has been connected and before
 * a kbox thread has been created. This must be taken into account in the
 * cleanup code.
 *
 * @return      Phone id on success, or negative error code.
 */
int ipc_connect_kbox(task_id_t taskid)
{
    int newphid;
    task_t *ta;
    thread_t *kb_thread;
    ipl_t ipl;
 
    ipl = interrupts_disable();
    spinlock_lock(&tasks_lock);
 
    ta = task_find_by_id(taskid);
    if (ta == NULL) {
        spinlock_unlock(&tasks_lock);
        interrupts_restore(ipl);
        return ENOENT;
    }
 
    atomic_inc(&ta->refcount);
 
    spinlock_unlock(&tasks_lock);
    interrupts_restore(ipl);
 
    mutex_lock(&ta->kb.cleanup_lock);
 
    if (atomic_predec(&ta->refcount) == 0) {
        mutex_unlock(&ta->kb.cleanup_lock);
        task_destroy(ta);
        return ENOENT;
    }
 
    if (ta->kb.finished != false) {
        mutex_unlock(&ta->kb.cleanup_lock);
        return EINVAL;
    }
 
    newphid = phone_alloc(TASK);
    if (newphid < 0) {
        mutex_unlock(&ta->kb.cleanup_lock);
        return ELIMIT;
    }
 
    /* Connect the newly allocated phone to the kbox */
    ipc_phone_connect(&TASK->phones[newphid], &ta->kb.box);
 
    if (ta->kb.thread != NULL) {
        mutex_unlock(&ta->kb.cleanup_lock);
        return newphid;
    }
 
    /* Create a kbox thread */
    kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0,
        "kbox", false);
    if (!kb_thread) {
        mutex_unlock(&ta->kb.cleanup_lock);
        return ENOMEM;
    }
 
    ta->kb.thread = kb_thread;
    thread_ready(kb_thread);
 
    mutex_unlock(&ta->kb.cleanup_lock);
 
    return newphid;
}
 
/** @}
 */
 

Rev 4377	Rev 4692
1	/*	1	/*
2	* Copyright (c) 2008 Jiri Svoboda	2	* Copyright (c) 2008 Jiri Svoboda
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup genericipc	29	/** @addtogroup genericipc
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <synch/synch.h>	35	#include <synch/synch.h>
36	#include <synch/spinlock.h>	36	#include <synch/spinlock.h>
37	#include <synch/mutex.h>	37	#include <synch/mutex.h>
38	#include <ipc/ipc.h>	38	#include <ipc/ipc.h>
39	#include <ipc/ipcrsc.h>	39	#include <ipc/ipcrsc.h>
40	#include <arch.h>	40	#include <arch.h>
41	#include <errno.h>	41	#include <errno.h>
42	#include <debug.h>	42	#include <debug.h>
43	#include <udebug/udebug_ipc.h>	43	#include <udebug/udebug_ipc.h>
44	#include <ipc/kbox.h>	44	#include <ipc/kbox.h>
45	#include <print.h>	45	#include <print.h>
46		46
47	void ipc_kbox_cleanup(void)	47	void ipc_kbox_cleanup(void)
48	{	48	{
49	ipl_t ipl;	49	ipl_t ipl;
50	bool have_kb_thread;	50	bool have_kb_thread;
51		51
52	/*	52	/*
53	* Only hold kb.cleanup_lock while setting kb.finished -	53	* Only hold kb.cleanup_lock while setting kb.finished -
54	* this is enough.	54	* this is enough.
55	*/	55	*/
56	mutex_lock(&TASK->kb.cleanup_lock);	56	mutex_lock(&TASK->kb.cleanup_lock);
57	TASK->kb.finished = true;	57	TASK->kb.finished = true;
58	mutex_unlock(&TASK->kb.cleanup_lock);	58	mutex_unlock(&TASK->kb.cleanup_lock);
59		59
60	have_kb_thread = (TASK->kb.thread != NULL);	60	have_kb_thread = (TASK->kb.thread != NULL);
61		61
62	/*	62	/*
63	* From now on nobody will try to connect phones or attach	63	* From now on nobody will try to connect phones or attach
64	* kbox threads	64	* kbox threads
65	*/	65	*/
66		66
67	/*	67	/*
68	* Disconnect all phones connected to our kbox. Passing true for	68	* Disconnect all phones connected to our kbox. Passing true for
69	* notify_box causes a HANGUP message to be inserted for each	69	* notify_box causes a HANGUP message to be inserted for each
70	* disconnected phone. This ensures the kbox thread is going to	70	* disconnected phone. This ensures the kbox thread is going to
71	* wake up and terminate.	71	* wake up and terminate.
72	*/	72	*/
73	ipc_answerbox_slam_phones(&TASK->kb.box, have_kb_thread);	73	ipc_answerbox_slam_phones(&TASK->kb.box, have_kb_thread);
74		74
75	/*	75	/*
76	* If the task was being debugged, clean up debugging session.	76	* If the task was being debugged, clean up debugging session.
77	* This is necessarry as slamming the phones won't force	77	* This is necessarry as slamming the phones won't force
78	* kbox thread to clean it up since sender != debugger.	78	* kbox thread to clean it up since sender != debugger.
79	*/	79	*/
80	ipl = interrupts_disable();	80	ipl = interrupts_disable();
81	spinlock_lock(&TASK->lock);	81	spinlock_lock(&TASK->lock);
82	udebug_task_cleanup(TASK);	82	udebug_task_cleanup(TASK);
83	spinlock_unlock(&TASK->lock);	83	spinlock_unlock(&TASK->lock);
84	interrupts_restore(ipl);	84	interrupts_restore(ipl);
85		85
86	if (have_kb_thread) {	86	if (have_kb_thread) {
87	LOG("join kb.thread..\n");	87	LOG("Join kb.thread.");
88	thread_join(TASK->kb.thread);	88	thread_join(TASK->kb.thread);
89	thread_detach(TASK->kb.thread);	89	thread_detach(TASK->kb.thread);
90	LOG("join done\n");	90	LOG("...join done.");
91	TASK->kb.thread = NULL;	91	TASK->kb.thread = NULL;
92	}	92	}
93		93
94	/* Answer all messages in 'calls' and 'dispatched_calls' queues. */	94	/* Answer all messages in 'calls' and 'dispatched_calls' queues. */
95	spinlock_lock(&TASK->kb.box.lock);	95	spinlock_lock(&TASK->kb.box.lock);
96	ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls);	96	ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls);
97	ipc_cleanup_call_list(&TASK->kb.box.calls);	97	ipc_cleanup_call_list(&TASK->kb.box.calls);
98	spinlock_unlock(&TASK->kb.box.lock);	98	spinlock_unlock(&TASK->kb.box.lock);
99	}	99	}
100		100
101	/** Handle hangup message in kbox.	101	/** Handle hangup message in kbox.
102	*	102	*
103	* @param call The IPC_M_PHONE_HUNGUP call structure.	103	* @param call The IPC_M_PHONE_HUNGUP call structure.
104	* @param last Output, the function stores @c true here if	104	* @param last Output, the function stores @c true here if
105	* this was the last phone, @c false otherwise.	105	* this was the last phone, @c false otherwise.
106	**/	106	**/
107	static void kbox_proc_phone_hungup(call_t call, bool last)	107	static void kbox_proc_phone_hungup(call_t call, bool last)
108	{	108	{
109	ipl_t ipl;	109	ipl_t ipl;
110		110
111	LOG("kbox_proc_phone_hungup()\n");	-
112		-
113	/* Was it our debugger, who hung up? */	111	/* Was it our debugger, who hung up? */
114	if (call->sender == TASK->udebug.debugger) {	112	if (call->sender == TASK->udebug.debugger) {
115	/* Terminate debugging session (if any). */	113	/* Terminate debugging session (if any). */
116	LOG("kbox: terminate debug session\n");	114	LOG("Terminate debugging session.");
117	ipl = interrupts_disable();	115	ipl = interrupts_disable();
118	spinlock_lock(&TASK->lock);	116	spinlock_lock(&TASK->lock);
119	udebug_task_cleanup(TASK);	117	udebug_task_cleanup(TASK);
120	spinlock_unlock(&TASK->lock);	118	spinlock_unlock(&TASK->lock);
121	interrupts_restore(ipl);	119	interrupts_restore(ipl);
122	} else {	120	} else {
123	LOG("kbox: was not debugger\n");	121	LOG("Was not debugger.");
124	}	122	}
125		123
126	LOG("kbox: continue with hangup message\n");	124	LOG("Continue with hangup message.");
127	IPC_SET_RETVAL(call->data, 0);	125	IPC_SET_RETVAL(call->data, 0);
128	ipc_answer(&TASK->kb.box, call);	126	ipc_answer(&TASK->kb.box, call);
129		127
130	ipl = interrupts_disable();	128	ipl = interrupts_disable();
131	spinlock_lock(&TASK->lock);	129	spinlock_lock(&TASK->lock);
132	spinlock_lock(&TASK->kb.box.lock);	130	spinlock_lock(&TASK->kb.box.lock);
133	if (list_empty(&TASK->kb.box.connected_phones)) {	131	if (list_empty(&TASK->kb.box.connected_phones)) {
134	/*	132	/*
135	* Last phone has been disconnected. Detach this thread so it	133	* Last phone has been disconnected. Detach this thread so it
136	* gets freed and signal to the caller.	134	* gets freed and signal to the caller.
137	*/	135	*/
138		136
139	/* Only detach kbox thread unless already terminating. */	137	/* Only detach kbox thread unless already terminating. */
140	mutex_lock(&TASK->kb.cleanup_lock);	138	mutex_lock(&TASK->kb.cleanup_lock);
141	if (&TASK->kb.finished == false) {	139	if (&TASK->kb.finished == false) {
142	/* Detach kbox thread so it gets freed from memory. */	140	/* Detach kbox thread so it gets freed from memory. */
143	thread_detach(TASK->kb.thread);	141	thread_detach(TASK->kb.thread);
144	TASK->kb.thread = NULL;	142	TASK->kb.thread = NULL;
145	}	143	}
146	mutex_unlock(&TASK->kb.cleanup_lock);	144	mutex_unlock(&TASK->kb.cleanup_lock);
147		145
148	LOG("phone list is empty\n");	146	LOG("Phone list is empty.");
149	*last = true;	147	*last = true;
150	} else {	148	} else {
151	*last = false;	149	*last = false;
152	}	150	}
153		151
154	spinlock_unlock(&TASK->kb.box.lock);	152	spinlock_unlock(&TASK->kb.box.lock);
155	spinlock_unlock(&TASK->lock);	153	spinlock_unlock(&TASK->lock);
156	interrupts_restore(ipl);	154	interrupts_restore(ipl);
157	}	155	}
158		156
159	/** Implementing function for the kbox thread.	157	/** Implementing function for the kbox thread.
160	*	158	*
161	* This function listens for debug requests. It terminates	159	* This function listens for debug requests. It terminates
162	* when all phones are disconnected from the kbox.	160	* when all phones are disconnected from the kbox.
163	*	161	*
164	* @param arg Ignored.	162	* @param arg Ignored.
165	*/	163	*/
166	static void kbox_thread_proc(void *arg)	164	static void kbox_thread_proc(void *arg)
167	{	165	{
168	call_t *call;	166	call_t *call;
169	bool done;	167	bool done;
170		168
171	(void)arg;	169	(void)arg;
172	LOG("kbox_thread_proc()\n");	170	LOG("Starting.");
173	done = false;	171	done = false;
174		172
175	while (!done) {	173	while (!done) {
176	call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT,	174	call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT,
177	SYNCH_FLAGS_NONE);	175	SYNCH_FLAGS_NONE);
178		176
179	if (call == NULL)	177	if (call == NULL)
180	continue; /* Try again. */	178	continue; /* Try again. */
181		179
182	switch (IPC_GET_METHOD(call->data)) {	180	switch (IPC_GET_METHOD(call->data)) {
183		181
184	case IPC_M_DEBUG_ALL:	182	case IPC_M_DEBUG_ALL:
185	/* Handle debug call. */	183	/* Handle debug call. */
186	udebug_call_receive(call);	184	udebug_call_receive(call);
187	break;	185	break;
188		186
189	case IPC_M_PHONE_HUNGUP:	187	case IPC_M_PHONE_HUNGUP:
190	/*	188	/*
191	* Process the hangup call. If this was the last	189	* Process the hangup call. If this was the last
192	* phone, done will be set to true and the	190	* phone, done will be set to true and the
193	* while loop will terminate.	191	* while loop will terminate.
194	*/	192	*/
195	kbox_proc_phone_hungup(call, &done);	193	kbox_proc_phone_hungup(call, &done);
196	break;	194	break;
197		195
198	default:	196	default:
199	/* Ignore */	197	/* Ignore */
200	break;	198	break;
201	}	199	}
202	}	200	}
203		201
204	LOG("kbox: finished\n");	202	LOG("Exiting.");
205	}	203	}
206		204
207		205
208	/**	206	/**
209	* Connect phone to a task kernel-box specified by id.	207	* Connect phone to a task kernel-box specified by id.
210	*	208	*
211	* Note that this is not completely atomic. For optimisation reasons, the task	209	* Note that this is not completely atomic. For optimisation reasons, the task
212	* might start cleaning up kbox after the phone has been connected and before	210	* might start cleaning up kbox after the phone has been connected and before
213	* a kbox thread has been created. This must be taken into account in the	211	* a kbox thread has been created. This must be taken into account in the
214	* cleanup code.	212	* cleanup code.
215	*	213	*
216	* @return Phone id on success, or negative error code.	214	* @return Phone id on success, or negative error code.
217	*/	215	*/
218	int ipc_connect_kbox(task_id_t taskid)	216	int ipc_connect_kbox(task_id_t taskid)
219	{	217	{
220	int newphid;	218	int newphid;
221	task_t *ta;	219	task_t *ta;
222	thread_t *kb_thread;	220	thread_t *kb_thread;
223	ipl_t ipl;	221	ipl_t ipl;
224		222
225	ipl = interrupts_disable();	223	ipl = interrupts_disable();
226	spinlock_lock(&tasks_lock);	224	spinlock_lock(&tasks_lock);
227		225
228	ta = task_find_by_id(taskid);	226	ta = task_find_by_id(taskid);
229	if (ta == NULL) {	227	if (ta == NULL) {
230	spinlock_unlock(&tasks_lock);	228	spinlock_unlock(&tasks_lock);
231	interrupts_restore(ipl);	229	interrupts_restore(ipl);
232	return ENOENT;	230	return ENOENT;
233	}	231	}
234		232
235	atomic_inc(&ta->refcount);	233	atomic_inc(&ta->refcount);
236		234
237	spinlock_unlock(&tasks_lock);	235	spinlock_unlock(&tasks_lock);
238	interrupts_restore(ipl);	236	interrupts_restore(ipl);
239		237
240	mutex_lock(&ta->kb.cleanup_lock);	238	mutex_lock(&ta->kb.cleanup_lock);
241		239
242	if (atomic_predec(&ta->refcount) == 0) {	240	if (atomic_predec(&ta->refcount) == 0) {
243	mutex_unlock(&ta->kb.cleanup_lock);	241	mutex_unlock(&ta->kb.cleanup_lock);
244	task_destroy(ta);	242	task_destroy(ta);
245	return ENOENT;	243	return ENOENT;
246	}	244	}
247		245
248	if (ta->kb.finished != false) {	246	if (ta->kb.finished != false) {
249	mutex_unlock(&ta->kb.cleanup_lock);	247	mutex_unlock(&ta->kb.cleanup_lock);
250	return EINVAL;	248	return EINVAL;
251	}	249	}
252		250
253	newphid = phone_alloc();	251	newphid = phone_alloc(TASK);
254	if (newphid < 0) {	252	if (newphid < 0) {
255	mutex_unlock(&ta->kb.cleanup_lock);	253	mutex_unlock(&ta->kb.cleanup_lock);
256	return ELIMIT;	254	return ELIMIT;
257	}	255	}
258		256
259	/* Connect the newly allocated phone to the kbox */	257	/* Connect the newly allocated phone to the kbox */
260	ipc_phone_connect(&TASK->phones[newphid], &ta->kb.box);	258	ipc_phone_connect(&TASK->phones[newphid], &ta->kb.box);
261		259
262	if (ta->kb.thread != NULL) {	260	if (ta->kb.thread != NULL) {
263	mutex_unlock(&ta->kb.cleanup_lock);	261	mutex_unlock(&ta->kb.cleanup_lock);
264	return newphid;	262	return newphid;
265	}	263	}
266		264
267	/* Create a kbox thread */	265	/* Create a kbox thread */
268	kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0,	266	kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0,
269	"kbox", false);	267	"kbox", false);
270	if (!kb_thread) {	268	if (!kb_thread) {
271	mutex_unlock(&ta->kb.cleanup_lock);	269	mutex_unlock(&ta->kb.cleanup_lock);
272	return ENOMEM;	270	return ENOMEM;
273	}	271	}
274		272
275	ta->kb.thread = kb_thread;	273	ta->kb.thread = kb_thread;
276	thread_ready(kb_thread);	274	thread_ready(kb_thread);
277		275
278	mutex_unlock(&ta->kb.cleanup_lock);	276	mutex_unlock(&ta->kb.cleanup_lock);
279		277
280	return newphid;	278	return newphid;
281	}	279	}
282		280
283	/** @}	281	/** @}
284	*/	282	*/
285		283

Subversion Repositories HelenOS

(root)/branches/tracing/kernel/generic/src/ipc/kbox.c – Rev 4377 → 4692