WebSVN – HelenOS – Diff – /trunk/kernel/generic/src/ipc/ipcrsc.c


/*
 * Copyright (c) 2006 Ondrej Palkovsky
 * 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
 */
 
/* IPC resources management
 *
 * The goal of this source code is to properly manage IPC resources and allow
 * straight and clean clean-up procedure upon task termination.
 *
 * The pattern of usage of the resources is:
 * - allocate empty phone slot, connect | deallocate slot
 * - disconnect connected phone (some messages might be on the fly)
 * - find phone in slot and send a message using phone
 * - answer message to phone
 * - hangup phone (the caller has hung up)
 * - hangup phone (the answerbox is exiting)
 *
 * Locking strategy
 *
 * - To use a phone, disconnect a phone etc., the phone must be first locked and
 *   then checked that it is connected
 * - To connect an allocated phone it need not be locked (assigning pointer is
 *   atomic on all platforms)
 *
 * - To find an empty phone slot, the TASK must be locked
 * - To answer a message, the answerbox must be locked
 * - The locking of phone and answerbox is done at the ipc_ level.
 *   It is perfectly correct to pass unconnected phone to these functions and
 *   proper reply will be generated.
 *
 * Locking order
 *
 * - first phone, then answerbox
 *   + Easy locking on calls
 *   - Very hard traversing list of phones when disconnecting because the phones
 *     may disconnect during traversal of list of connected phones. The only
 *     possibility is try_lock with restart of list traversal.
 *
 * Destroying is less frequent, this approach is taken.
 *
 * Phone call
 *
 * *** Connect_me_to ***
 * The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server receives
 * 'phoneid' of the connecting phone as an ARG3. If it answers with RETVAL=0,
 * the phonecall is accepted, otherwise it is refused.
 *
 * *** Connect_to_me ***
 * The caller sends IPC_M_CONNECT_TO_ME.
 * The server receives an automatically opened phoneid. If it accepts
 * (RETVAL=0), it can use the phoneid immediately.
 * Possible race condition can arise, when the client receives messages from new
 * connection before getting response for connect_to_me message. Userspace
 * should implement handshake protocol that would control it.
 *
 * Phone hangup
 *
 * *** The caller hangs up (sys_ipc_hangup) ***
 * - The phone is disconnected (no more messages can be sent over this phone),
 *   all in-progress messages are correctly handled. The answerbox receives
 *   IPC_M_PHONE_HUNGUP call from the phone that hung up. When all async
 *   calls are answered, the phone is deallocated.
 *
 * *** The answerbox hangs up (ipc_answer(EHANGUP))
 * - The phone is disconnected. EHANGUP response code is sent
 *   to the calling task. All new calls through this phone
 *   get a EHUNGUP error code, the task is expected to
 *   send an sys_ipc_hangup after cleaning up its internal structures.
 *
 * Call forwarding
 *
 * The call can be forwarded, so that the answer to call is passed directly
 * to the original sender. However, this poses special problems regarding
 * routing of hangup messages.
 *
 * sys_ipc_hangup -> IPC_M_PHONE_HUNGUP
 * - this message CANNOT be forwarded
 *
 * EHANGUP during forward
 * - The *forwarding* phone will be closed, EFORWARD is sent to receiver.
 *
 * EHANGUP, ENOENT during forward
 * - EFORWARD is sent to the receiver, ipc_forward returns error code EFORWARD
 *
 * Cleanup strategy
 *
 * 1) Disconnect all our phones ('ipc_phone_hangup').
 *
 * 2) Disconnect all phones connected to answerbox.
 *
 * 3) Answer all messages in 'calls' and 'dispatched_calls' queues with
 *    appropriate error code (EHANGUP, EFORWARD).
 *
 * 4) Wait for all async answers to arrive and dispose of them.
 *
 */
 
#include <synch/spinlock.h>
#include <ipc/ipc.h>
#include <arch.h>
#include <proc/task.h>
#include <ipc/ipcrsc.h>
#include <debug.h>
 
/** Find call_t * in call table according to callid.
 *
 * @todo Some speedup (hash table?)
 *
 * @param callid    Userspace hash of the call. Currently it is the call
 *          structure kernel address.
 *
 * @return      NULL on not found, otherwise pointer to the call
 *          structure.
 */
call_t *get_call(unative_t callid)
{
    link_t *lst;
    call_t *call, *result = NULL;
 
    spinlock_lock(&TASK->answerbox.lock);
    for (lst = TASK->answerbox.dispatched_calls.next;
        lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
        call = list_get_instance(lst, call_t, link);
        if ((unative_t) call == callid) {
            result = call;
            break;
        }
    }
    spinlock_unlock(&TASK->answerbox.lock);
    return result;
}
 
/** Allocate new phone slot in the current TASK structure.
 *
 * @return      New phone handle or -1 if the phone handle limit is
 *          exceeded.
 */
int phone_alloc(void)
{
    int i;
 
    spinlock_lock(&TASK->lock);
   
    for (i = 0; i < IPC_MAX_PHONES; i++) {
        if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
            atomic_get(&TASK->phones[i].active_calls) == 0)
            TASK->phones[i].state = IPC_PHONE_FREE;
 
        if (TASK->phones[i].state == IPC_PHONE_FREE) {
            TASK->phones[i].state = IPC_PHONE_CONNECTING;
            break;
        }
    }
    spinlock_unlock(&TASK->lock);
 
    if (i >= IPC_MAX_PHONES)
        return -1;
    return i;
}
 
/** Mark a phone structure free.
 *
 * @param phone     Phone structure to be marked free.
 */
static void phone_deallocp(phone_t *phone)
{
    ASSERT(phone->state == IPC_PHONE_CONNECTING);
   
    /* atomic operation */
    phone->state = IPC_PHONE_FREE;
}
 
/** Free slot from a disconnected phone.
 *
 * All already sent messages will be correctly processed.
 *
 * @param phoneid   Phone handle of the phone to be freed.
 */
void phone_dealloc(int phoneid)
{
    phone_deallocp(&TASK->phones[phoneid]);
}
 
/** Connect phone to a given answerbox.
 *
 * @param phoneid   Phone handle to be connected.
 * @param box       Answerbox to which to connect the phone handle.
 *
 * The procedure _enforces_ that the user first marks the phone
 * busy (e.g. via phone_alloc) and then connects the phone, otherwise
 * race condition may appear.
 */
void phone_connect(int phoneid, answerbox_t *box)
{
    phone_t *phone = &TASK->phones[phoneid];
   
    ASSERT(phone->state == IPC_PHONE_CONNECTING);
    ipc_phone_connect(phone, box);
}
 
/** @}
 */
 

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/ipc/ipcrsc.c – Rev 2359 → 2471

Rev 2359		Rev 2471
1	/*	1	/*
2	* Copyright (c) 2006 Ondrej Palkovsky	2	* Copyright (c) 2006 Ondrej Palkovsky
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	/* IPC resources management	35	/* IPC resources management
36	*	36	*
37	* The goal of this source code is to properly manage IPC resources and allow	37	* The goal of this source code is to properly manage IPC resources and allow
38	* straight and clean clean-up procedure upon task termination.	38	* straight and clean clean-up procedure upon task termination.
39	*	39	*
40	* The pattern of usage of the resources is:	40	* The pattern of usage of the resources is:
41	* - allocate empty phone slot, connect \| deallocate slot	41	* - allocate empty phone slot, connect \| deallocate slot
42	* - disconnect connected phone (some messages might be on the fly)	42	* - disconnect connected phone (some messages might be on the fly)
43	* - find phone in slot and send a message using phone	43	* - find phone in slot and send a message using phone
44	* - answer message to phone	44	* - answer message to phone
45	* - hangup phone (the caller has hung up)	45	* - hangup phone (the caller has hung up)
46	* - hangup phone (the answerbox is exiting)	46	* - hangup phone (the answerbox is exiting)
47	*	47	*
48	* Locking strategy	48	* Locking strategy
49	*	49	*
50	* - To use a phone, disconnect a phone etc., the phone must be first locked and	50	* - To use a phone, disconnect a phone etc., the phone must be first locked and
51	* then checked that it is connected	51	* then checked that it is connected
52	* - To connect an allocated phone it need not be locked (assigning pointer is	52	* - To connect an allocated phone it need not be locked (assigning pointer is
53	* atomic on all platforms)	53	* atomic on all platforms)
54	*	54	*
55	* - To find an empty phone slot, the TASK must be locked	55	* - To find an empty phone slot, the TASK must be locked
56	* - To answer a message, the answerbox must be locked	56	* - To answer a message, the answerbox must be locked
57	* - The locking of phone and answerbox is done at the ipc_ level.	57	* - The locking of phone and answerbox is done at the ipc_ level.
58	* It is perfectly correct to pass unconnected phone to these functions and	58	* It is perfectly correct to pass unconnected phone to these functions and
59	* proper reply will be generated.	59	* proper reply will be generated.
60	*	60	*
61	* Locking order	61	* Locking order
62	*	62	*
63	* - first phone, then answerbox	63	* - first phone, then answerbox
64	* + Easy locking on calls	64	* + Easy locking on calls
65	* - Very hard traversing list of phones when disconnecting because the phones	65	* - Very hard traversing list of phones when disconnecting because the phones
66	* may disconnect during traversal of list of connected phones. The only	66	* may disconnect during traversal of list of connected phones. The only
67	* possibility is try_lock with restart of list traversal.	67	* possibility is try_lock with restart of list traversal.
68	*	68	*
69	* Destroying is less frequent, this approach is taken.	69	* Destroying is less frequent, this approach is taken.
70	*	70	*
71	* Phone call	71	* Phone call
72	*	72	*
73	* * Connect_me_to *	73	* * Connect_me_to *
74	* The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server receives	74	* The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server receives
75	* 'phoneid' of the connecting phone as an ARG3. If it answers with RETVAL=0,	75	* 'phoneid' of the connecting phone as an ARG3. If it answers with RETVAL=0,
76	* the phonecall is accepted, otherwise it is refused.	76	* the phonecall is accepted, otherwise it is refused.
77	*	77	*
78	* * Connect_to_me *	78	* * Connect_to_me *
79	* The caller sends IPC_M_CONNECT_TO_ME.	79	* The caller sends IPC_M_CONNECT_TO_ME.
80	* The server receives an automatically opened phoneid. If it accepts	80	* The server receives an automatically opened phoneid. If it accepts
81	* (RETVAL=0), it can use the phoneid immediately.	81	* (RETVAL=0), it can use the phoneid immediately.
82	* Possible race condition can arise, when the client receives messages from new	82	* Possible race condition can arise, when the client receives messages from new
83	* connection before getting response for connect_to_me message. Userspace	83	* connection before getting response for connect_to_me message. Userspace
84	* should implement handshake protocol that would control it.	84	* should implement handshake protocol that would control it.
85	*	85	*
86	* Phone hangup	86	* Phone hangup
87	*	87	*
88	* * The caller hangs up (sys_ipc_hangup) *	88	* * The caller hangs up (sys_ipc_hangup) *
89	* - The phone is disconnected (no more messages can be sent over this phone),	89	* - The phone is disconnected (no more messages can be sent over this phone),
90	* all in-progress messages are correctly handled. The answerbox receives	90	* all in-progress messages are correctly handled. The answerbox receives
91	* IPC_M_PHONE_HUNGUP call from the phone that hung up. When all async	91	* IPC_M_PHONE_HUNGUP call from the phone that hung up. When all async
92	* calls are answered, the phone is deallocated.	92	* calls are answered, the phone is deallocated.
93	*	93	*
94	* *** The answerbox hangs up (ipc_answer(EHANGUP))	94	* *** The answerbox hangs up (ipc_answer(EHANGUP))
95	* - The phone is disconnected. EHANGUP response code is sent	95	* - The phone is disconnected. EHANGUP response code is sent
96	* to the calling task. All new calls through this phone	96	* to the calling task. All new calls through this phone
97	* get a EHUNGUP error code, the task is expected to	97	* get a EHUNGUP error code, the task is expected to
98	* send an sys_ipc_hangup after cleaning up its internal structures.	98	* send an sys_ipc_hangup after cleaning up its internal structures.
99	*	99	*
100	* Call forwarding	100	* Call forwarding
101	*	101	*
102	* The call can be forwarded, so that the answer to call is passed directly	102	* The call can be forwarded, so that the answer to call is passed directly
103	* to the original sender. However, this poses special problems regarding	103	* to the original sender. However, this poses special problems regarding
104	* routing of hangup messages.	104	* routing of hangup messages.
105	*	105	*
106	* sys_ipc_hangup -> IPC_M_PHONE_HUNGUP	106	* sys_ipc_hangup -> IPC_M_PHONE_HUNGUP
107	* - this message CANNOT be forwarded	107	* - this message CANNOT be forwarded
108	*	108	*
109	* EHANGUP during forward	109	* EHANGUP during forward
110	* - The forwarding phone will be closed, EFORWARD is sent to receiver.	110	* - The forwarding phone will be closed, EFORWARD is sent to receiver.
111	*	111	*
112	* EHANGUP, ENOENT during forward	112	* EHANGUP, ENOENT during forward
113	* - EFORWARD is sent to the receiver, ipc_forward returns error code EFORWARD	113	* - EFORWARD is sent to the receiver, ipc_forward returns error code EFORWARD
114	*	114	*
115	* Cleanup strategy	115	* Cleanup strategy
116	*	116	*
117	* 1) Disconnect all our phones ('ipc_phone_hangup').	117	* 1) Disconnect all our phones ('ipc_phone_hangup').
118	*	118	*
119	* 2) Disconnect all phones connected to answerbox.	119	* 2) Disconnect all phones connected to answerbox.
120	*	120	*
121	* 3) Answer all messages in 'calls' and 'dispatched_calls' queues with	121	* 3) Answer all messages in 'calls' and 'dispatched_calls' queues with
122	* appropriate error code (EHANGUP, EFORWARD).	122	* appropriate error code (EHANGUP, EFORWARD).
123	*	123	*
124	* 4) Wait for all async answers to arrive and dispose of them.	124	* 4) Wait for all async answers to arrive and dispose of them.
125	*	125	*
126	*/	126	*/
127		127
128	#include <synch/spinlock.h>	128	#include <synch/spinlock.h>
129	#include <ipc/ipc.h>	129	#include <ipc/ipc.h>
130	#include <arch.h>	130	#include <arch.h>
131	#include <proc/task.h>	131	#include <proc/task.h>
132	#include <ipc/ipcrsc.h>	132	#include <ipc/ipcrsc.h>
133	#include <debug.h>	133	#include <debug.h>
134		134
135	/** Find call_t * in call table according to callid	135	/** Find call_t * in call table according to callid.
136	*	136	*
137	* TODO: Some speedup (hash table?)	137	* @todo Some speedup (hash table?)
-		138	*
-		139	* @param callid Userspace hash of the call. Currently it is the call
-		140	* structure kernel address.
-		141	*
138	* @return NULL on not found, otherwise pointer to call structure	142	* @return NULL on not found, otherwise pointer to the call
-		143	* structure.
139	*/	144	*/
140	call_t * get_call(unative_t callid)	145	call_t *get_call(unative_t callid)
141	{	146	{
142	link_t *lst;	147	link_t *lst;
143	call_t call, result = NULL;	148	call_t call, result = NULL;
144		149
145	spinlock_lock(&TASK->answerbox.lock);	150	spinlock_lock(&TASK->answerbox.lock);
146	for (lst = TASK->answerbox.dispatched_calls.next;	151	for (lst = TASK->answerbox.dispatched_calls.next;
147	lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {	152	lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
148	call = list_get_instance(lst, call_t, link);	153	call = list_get_instance(lst, call_t, link);
149	if ((unative_t)call == callid) {	154	if ((unative_t) call == callid) {
150	result = call;	155	result = call;
151	break;	156	break;
152	}	157	}
153	}	158	}
154	spinlock_unlock(&TASK->answerbox.lock);	159	spinlock_unlock(&TASK->answerbox.lock);
155	return result;	160	return result;
156	}	161	}
157		162
158	/** Allocate new phone slot in current TASK structure */	163	/** Allocate new phone slot in the current TASK structure.
-		164	*
-		165	* @return New phone handle or -1 if the phone handle limit is
-		166	* exceeded.
-		167	*/
159	int phone_alloc(void)	168	int phone_alloc(void)
160	{	169	{
161	int i;	170	int i;
162		171
163	spinlock_lock(&TASK->lock);	172	spinlock_lock(&TASK->lock);
164		173
165	for (i=0; i < IPC_MAX_PHONES; i++) {	174	for (i = 0; i < IPC_MAX_PHONES; i++) {
166	if (TASK->phones[i].state == IPC_PHONE_HUNGUP && \	175	if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
167	atomic_get(&TASK->phones[i].active_calls) == 0)	176	atomic_get(&TASK->phones[i].active_calls) == 0)
168	TASK->phones[i].state = IPC_PHONE_FREE;	177	TASK->phones[i].state = IPC_PHONE_FREE;
169		178
170	if (TASK->phones[i].state == IPC_PHONE_FREE) {	179	if (TASK->phones[i].state == IPC_PHONE_FREE) {
171	TASK->phones[i].state = IPC_PHONE_CONNECTING;	180	TASK->phones[i].state = IPC_PHONE_CONNECTING;
172	break;	181	break;
173	}	182	}
174	}	183	}
175	spinlock_unlock(&TASK->lock);	184	spinlock_unlock(&TASK->lock);
176		185
177	if (i >= IPC_MAX_PHONES)	186	if (i >= IPC_MAX_PHONES)
178	return -1;	187	return -1;
179	return i;	188	return i;
180	}	189	}
181		190
-		191	/** Mark a phone structure free.
-		192	*
-		193	* @param phone Phone structure to be marked free.
-		194	*/
182	static void phone_deallocp(phone_t *phone)	195	static void phone_deallocp(phone_t *phone)
183	{	196	{
184	ASSERT(phone->state == IPC_PHONE_CONNECTING);	197	ASSERT(phone->state == IPC_PHONE_CONNECTING);
185		198
186	/* atomic operation */	199	/* atomic operation */
187	phone->state = IPC_PHONE_FREE;	200	phone->state = IPC_PHONE_FREE;
188	}	201	}
189		202
190	/** Free slot from a disconnected phone	203	/** Free slot from a disconnected phone.
-		204	*
-		205	* All already sent messages will be correctly processed.
191	*	206	*
192	* All already sent messages will be correctly processed	207	* @param phoneid Phone handle of the phone to be freed.
193	*/	208	*/
194	void phone_dealloc(int phoneid)	209	void phone_dealloc(int phoneid)
195	{	210	{
196	phone_deallocp(&TASK->phones[phoneid]);	211	phone_deallocp(&TASK->phones[phoneid]);
197	}	212	}
198		213
199	/** Connect phone to a given answerbox	214	/** Connect phone to a given answerbox.
200	*	215	*
201	* @param phoneid The slot that will be connected	216	* @param phoneid Phone handle to be connected.
-		217	* @param box Answerbox to which to connect the phone handle.
202	*	218	*
203	* The procedure _enforces_ that the user first marks the phone	219	* The procedure _enforces_ that the user first marks the phone
204	* busy (e.g. via phone_alloc) and then connects the phone, otherwise	220	* busy (e.g. via phone_alloc) and then connects the phone, otherwise
205	* race condition may appear.	221	* race condition may appear.
206	*/	222	*/
207	void phone_connect(int phoneid, answerbox_t *box)	223	void phone_connect(int phoneid, answerbox_t *box)
208	{	224	{
209	phone_t *phone = &TASK->phones[phoneid];	225	phone_t *phone = &TASK->phones[phoneid];
210		226
211	ASSERT(phone->state == IPC_PHONE_CONNECTING);	227	ASSERT(phone->state == IPC_PHONE_CONNECTING);
212	ipc_phone_connect(phone, box);	228	ipc_phone_connect(phone, box);
213	}	229	}
214		230
215	/** @}	231	/** @}
216	*/	232	*/
217		233