WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/syscall/syscall.c


/*
 * Copyright (C) 2005 Martin Decky
 * 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.
 */
 
#include <syscall/syscall.h>
#include <proc/thread.h>
#include <mm/as.h>
#include <print.h>
#include <putchar.h>
#include <ipc/ipc.h>
#include <errno.h>
#include <proc/task.h>
#include <arch.h>
#include <debug.h>
 
static __native sys_ctl(void) {
    printf("Thread finished\n");
    thread_exit();
    /* Unreachable */
    return 0;
}
 
static __native sys_io(int fd, const void * buf, size_t count) {
   
    // TODO: buf sanity checks and a lot of other stuff ...
 
    size_t i;
   
    for (i = 0; i < count; i++)
        putchar(((char *) buf)[i]);
   
    return count;
}
 
static phone_t * get_phone(__native phoneid)
{
    phone_t *phone;
 
    if (phoneid >= IPC_MAX_PHONES)
        return NULL;
 
    phone = &TASK->phones[phoneid];
    if (!phone->callee)
        return NULL;
    return phone;
}
 
/** Send a call over IPC, wait for reply, return to user
 *
 * @return Call identification, returns -1 on fatal error,
           -2 on 'Too many async request, handle answers first
 */
static __native sys_ipc_call_sync_fast(__native phoneid, __native method,
                       __native arg1, __native *data)
{
    call_t call;
    phone_t *phone;
    /* Special answerbox for synchronous messages */
 
    phone = get_phone(phoneid);
    if (!phone)
        return IPC_CALLRET_FATAL;
 
    ipc_call_init(&call);
    IPC_SET_METHOD(call.data, method);
    IPC_SET_ARG1(call.data, arg1);
   
    ipc_call_sync(phone, &call);
 
    copy_to_uspace(data, &call.data, sizeof(call.data));
 
    return 0;
}
 
/** Synchronous IPC call allowing to send whole message */
static __native sys_ipc_call_sync(__native phoneid, __native *question,
                  __native *reply)
{
    call_t call;
    phone_t *phone;
    /* Special answerbox for synchronous messages */
 
    phone = get_phone(phoneid);
    if (!phone)
        return IPC_CALLRET_FATAL;
 
    ipc_call_init(&call);
    copy_from_uspace(&call.data, question, sizeof(call.data));
   
    ipc_call_sync(phone, &call);
 
    copy_to_uspace(reply, &call.data, sizeof(call.data));
 
    return 0;
}
 
/** Check that the task did not exceed allowed limit
 *
 * @return 0 - Limit OK,   -1 - limit exceeded
 */
static int check_call_limit(void)
{
    if (atomic_inc_post(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
        atomic_dec(&TASK->active_calls);
        return -1;
    }
    return 0;
}
 
/** Send an asynchronous call over ipc
 *
 * @return Call identification, returns -1 on fatal error,
           -2 on 'Too many async request, handle answers first
 */
static __native sys_ipc_call_async_fast(__native phoneid, __native method,
                    __native arg1, __native arg2)
{
    call_t *call;
    phone_t *phone;
 
    phone = get_phone(phoneid);
    if (!phone)
        return IPC_CALLRET_FATAL;
 
    if (check_call_limit())
        return IPC_CALLRET_TEMPORARY;
 
    call = ipc_call_alloc();
    IPC_SET_METHOD(call->data, method);
    IPC_SET_ARG1(call->data, arg1);
    IPC_SET_ARG2(call->data, arg2);
 
    ipc_call(phone, call);
 
    return (__native) call;
}
 
/** Synchronous IPC call allowing to send whole message
 *
 * @return The same as sys_ipc_call_async
 */
static __native sys_ipc_call_async(__native phoneid, __native *data)
{
    call_t *call;
    phone_t *phone;
 
    phone = get_phone(phoneid);
    if (!phone)
        return IPC_CALLRET_FATAL;
 
    if (check_call_limit())
        return IPC_CALLRET_TEMPORARY;
 
    call = ipc_call_alloc();
    copy_from_uspace(&call->data, data, sizeof(call->data));
   
    ipc_call(phone, call);
 
    return (__native) call;
}
 
 
/** Send IPC answer */
static __native sys_ipc_answer_fast(__native callid, __native retval,
                    __native arg1, __native arg2)
{
    call_t *call;
 
    /* Check that the user is not sending us answer callid */
    ASSERT(! (callid & 1));
    /* TODO: Check that the callid is in the dispatch table */
    call = (call_t *) callid;
 
    IPC_SET_RETVAL(call->data, retval);
    IPC_SET_ARG1(call->data, arg1);
    IPC_SET_ARG2(call->data, arg2);
 
    ipc_answer(&TASK->answerbox, call);
    return 0;
}
 
/** Send IPC answer */
static __native sys_ipc_answer(__native callid, __native *data)
{
    call_t *call;
 
    /* Check that the user is not sending us answer callid */
    ASSERT(! (callid & 1));
    /* TODO: Check that the callid is in the dispatch table */
    call = (call_t *) callid;
    copy_from_uspace(&call->data, data, sizeof(call->data));
    ipc_answer(&TASK->answerbox, call);
 
    return 0;
}
 
/** Wait for incoming ipc call or answer
 *
 * @param result
 * @param flags
 * @return Callid, if callid & 1, then the call is answer
 */
static __native sys_ipc_wait_for_call(__native *calldata, task_id_t *taskid,
                      __native flags)
{
    call_t *call;
   
    call = ipc_wait_for_call(&TASK->answerbox, flags);
 
    copy_to_uspace(calldata, &call->data, sizeof(call->data));
 
    if (call->flags & IPC_CALL_ANSWERED) {
        ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
        ipc_call_free(call);
        atomic_dec(&TASK->active_calls);
        return ((__native)call) | IPC_CALLID_ANSWERED;
    }
    copy_to_uspace(taskid, (void *)&TASK->taskid, sizeof(TASK->taskid));
    return (__native)call;
}
 
static __native sys_mremap(void *address, size_t size, unsigned long flags)
{
    return as_remap(AS, (__address) address, size, 0);
}
 
syshandler_t syscall_table[SYSCALL_END] = {
    sys_ctl,
    sys_io,
    sys_mremap,
    sys_ipc_call_sync_fast,
    sys_ipc_call_sync,
    sys_ipc_call_async_fast,
    sys_ipc_call_async,
    sys_ipc_answer_fast,
    sys_ipc_answer,
    sys_ipc_wait_for_call
};
 

Rev 998	Rev 1005
1	/*	1	/*
2	* Copyright (C) 2005 Martin Decky	2	* Copyright (C) 2005 Martin Decky
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	#include <syscall/syscall.h>	29	#include <syscall/syscall.h>
30	#include <proc/thread.h>	30	#include <proc/thread.h>
31	#include <mm/as.h>	31	#include <mm/as.h>
32	#include <print.h>	32	#include <print.h>
33	#include <putchar.h>	33	#include <putchar.h>
34	#include <ipc/ipc.h>	34	#include <ipc/ipc.h>
35	#include <errno.h>	35	#include <errno.h>
36	#include <proc/task.h>	36	#include <proc/task.h>
37	#include <arch.h>	37	#include <arch.h>
38	#include <debug.h>	38	#include <debug.h>
39		39
40	static __native sys_ctl(void) {	40	static __native sys_ctl(void) {
41	printf("Thread finished\n");	41	printf("Thread finished\n");
42	thread_exit();	42	thread_exit();
43	/* Unreachable */	43	/* Unreachable */
44	return 0;	44	return 0;
45	}	45	}
46		46
47	static __native sys_io(int fd, const void * buf, size_t count) {	47	static __native sys_io(int fd, const void * buf, size_t count) {
48		48
49	// TODO: buf sanity checks and a lot of other stuff ...	49	// TODO: buf sanity checks and a lot of other stuff ...
50		50
51	size_t i;	51	size_t i;
52		52
53	for (i = 0; i < count; i++)	53	for (i = 0; i < count; i++)
54	putchar(((char *) buf)[i]);	54	putchar(((char *) buf)[i]);
55		55
56	return count;	56	return count;
57	}	57	}
58		58
59	static phone_t * get_phone(__native phoneid)	59	static phone_t * get_phone(__native phoneid)
60	{	60	{
61	phone_t *phone;	61	phone_t *phone;
62		62
63	if (phoneid >= IPC_MAX_PHONES)	63	if (phoneid >= IPC_MAX_PHONES)
64	return NULL;	64	return NULL;
65		65
66	phone = &TASK->phones[phoneid];	66	phone = &TASK->phones[phoneid];
67	if (!phone->callee)	67	if (!phone->callee)
68	return NULL;	68	return NULL;
69	return phone;	69	return phone;
70	}	70	}
71		71
72	/** Send a call over IPC, wait for reply, return to user	72	/** Send a call over IPC, wait for reply, return to user
73	*	73	*
74	* @return Call identification, returns -1 on fatal error,	74	* @return Call identification, returns -1 on fatal error,
75	-2 on 'Too many async request, handle answers first	75	-2 on 'Too many async request, handle answers first
76	*/	76	*/
77	static __native sys_ipc_call_sync_fast(__native phoneid, __native method,	77	static __native sys_ipc_call_sync_fast(__native phoneid, __native method,
78	__native arg1, __native *data)	78	__native arg1, __native *data)
79	{	79	{
80	call_t call;	80	call_t call;
81	phone_t *phone;	81	phone_t *phone;
82	/* Special answerbox for synchronous messages */	82	/* Special answerbox for synchronous messages */
83		83
84	phone = get_phone(phoneid);	84	phone = get_phone(phoneid);
85	if (!phone)	85	if (!phone)
86	return IPC_CALLRET_FATAL;	86	return IPC_CALLRET_FATAL;
87		87
88	ipc_call_init(&call);	88	ipc_call_init(&call);
89	IPC_SET_METHOD(call.data, method);	89	IPC_SET_METHOD(call.data, method);
90	IPC_SET_ARG1(call.data, arg1);	90	IPC_SET_ARG1(call.data, arg1);
91		91
92	ipc_call_sync(phone, &call);	92	ipc_call_sync(phone, &call);
93		93
94	copy_to_uspace(data, &call.data, sizeof(call.data));	94	copy_to_uspace(data, &call.data, sizeof(call.data));
95		95
96	return 0;	96	return 0;
97	}	97	}
98		98
99	/** Synchronous IPC call allowing to send whole message */	99	/** Synchronous IPC call allowing to send whole message */
100	static __native sys_ipc_call_sync(__native phoneid, __native *data)	100	static __native sys_ipc_call_sync(__native phoneid, __native *question,
-		101	__native *reply)
101	{	102	{
102	call_t call;	103	call_t call;
103	phone_t *phone;	104	phone_t *phone;
104	/* Special answerbox for synchronous messages */	105	/* Special answerbox for synchronous messages */
105		106
106	phone = get_phone(phoneid);	107	phone = get_phone(phoneid);
107	if (!phone)	108	if (!phone)
108	return IPC_CALLRET_FATAL;	109	return IPC_CALLRET_FATAL;
109		110
110	ipc_call_init(&call);	111	ipc_call_init(&call);
111	copy_from_uspace(&call.data, data, sizeof(call.data));	112	copy_from_uspace(&call.data, question, sizeof(call.data));
112		113
113	ipc_call_sync(phone, &call);	114	ipc_call_sync(phone, &call);
114		115
115	copy_to_uspace(data, &call.data, sizeof(call.data));	116	copy_to_uspace(reply, &call.data, sizeof(call.data));
116		117
117	return 0;	118	return 0;
118	}	119	}
119		120
120	/** Check that the task did not exceed allowed limit	121	/** Check that the task did not exceed allowed limit
121	*	122	*
122	* @return 0 - Limit OK, -1 - limit exceeded	123	* @return 0 - Limit OK, -1 - limit exceeded
123	*/	124	*/
124	static int check_call_limit(void)	125	static int check_call_limit(void)
125	{	126	{
126	if (atomic_inc_post(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {	127	if (atomic_inc_post(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
127	atomic_dec(&TASK->active_calls);	128	atomic_dec(&TASK->active_calls);
128	return -1;	129	return -1;
129	}	130	}
130	return 0;	131	return 0;
131	}	132	}
132		133
133	/** Send an asynchronous call over ipc	134	/** Send an asynchronous call over ipc
134	*	135	*
135	* @return Call identification, returns -1 on fatal error,	136	* @return Call identification, returns -1 on fatal error,
136	-2 on 'Too many async request, handle answers first	137	-2 on 'Too many async request, handle answers first
137	*/	138	*/
138	static __native sys_ipc_call_async_fast(__native phoneid, __native method,	139	static __native sys_ipc_call_async_fast(__native phoneid, __native method,
139	__native arg1, __native arg2)	140	__native arg1, __native arg2)
140	{	141	{
141	call_t *call;	142	call_t *call;
142	phone_t *phone;	143	phone_t *phone;
143		144
144	phone = get_phone(phoneid);	145	phone = get_phone(phoneid);
145	if (!phone)	146	if (!phone)
146	return IPC_CALLRET_FATAL;	147	return IPC_CALLRET_FATAL;
147		148
148	if (check_call_limit())	149	if (check_call_limit())
149	return IPC_CALLRET_TEMPORARY;	150	return IPC_CALLRET_TEMPORARY;
150		151
151	call = ipc_call_alloc();	152	call = ipc_call_alloc();
152	IPC_SET_METHOD(call->data, method);	153	IPC_SET_METHOD(call->data, method);
153	IPC_SET_ARG1(call->data, arg1);	154	IPC_SET_ARG1(call->data, arg1);
154	IPC_SET_ARG2(call->data, arg2);	155	IPC_SET_ARG2(call->data, arg2);
155		156
156	ipc_call(phone, call);	157	ipc_call(phone, call);
157		158
158	return (__native) call;	159	return (__native) call;
159	}	160	}
160		161
161	/** Synchronous IPC call allowing to send whole message	162	/** Synchronous IPC call allowing to send whole message
162	*	163	*
163	* @return The same as sys_ipc_call_async	164	* @return The same as sys_ipc_call_async
164	*/	165	*/
165	static __native sys_ipc_call_async(__native phoneid, __native *data)	166	static __native sys_ipc_call_async(__native phoneid, __native *data)
166	{	167	{
167	call_t *call;	168	call_t *call;
168	phone_t *phone;	169	phone_t *phone;
169		170
170	phone = get_phone(phoneid);	171	phone = get_phone(phoneid);
171	if (!phone)	172	if (!phone)
172	return IPC_CALLRET_FATAL;	173	return IPC_CALLRET_FATAL;
173		174
174	if (check_call_limit())	175	if (check_call_limit())
175	return IPC_CALLRET_TEMPORARY;	176	return IPC_CALLRET_TEMPORARY;
176		177
177	call = ipc_call_alloc();	178	call = ipc_call_alloc();
178	copy_from_uspace(&call->data, data, sizeof(call->data));	179	copy_from_uspace(&call->data, data, sizeof(call->data));
179		180
180	ipc_call(phone, call);	181	ipc_call(phone, call);
181		182
182	return (__native) call;	183	return (__native) call;
183	}	184	}
184		185
185		186
186	/** Send IPC answer */	187	/** Send IPC answer */
187	static __native sys_ipc_answer(__native callid, __native retval, __native arg1,	188	static __native sys_ipc_answer_fast(__native callid, __native retval,
188	__native arg2)	189	__native arg1, __native arg2)
189	{	190	{
190	call_t *call;	191	call_t *call;
191		192
192	/* Check that the user is not sending us answer callid */	193	/* Check that the user is not sending us answer callid */
193	ASSERT(! (callid & 1));	194	ASSERT(! (callid & 1));
194	/* TODO: Check that the callid is in the dispatch table */	195	/* TODO: Check that the callid is in the dispatch table */
195	call = (call_t *) callid;	196	call = (call_t *) callid;
196		197
197	IPC_SET_RETVAL(call->data, retval);	198	IPC_SET_RETVAL(call->data, retval);
198	IPC_SET_ARG1(call->data, arg1);	199	IPC_SET_ARG1(call->data, arg1);
199	IPC_SET_ARG2(call->data, arg2);	200	IPC_SET_ARG2(call->data, arg2);
200		201
201	ipc_answer(&TASK->answerbox, call);	202	ipc_answer(&TASK->answerbox, call);
202	return 0;	203	return 0;
203	}	204	}
204		205
-		206	/** Send IPC answer */
-		207	static __native sys_ipc_answer(__native callid, __native *data)
-		208	{
-		209	call_t *call;
-		210
-		211	/* Check that the user is not sending us answer callid */
-		212	ASSERT(! (callid & 1));
-		213	/* TODO: Check that the callid is in the dispatch table */
-		214	call = (call_t *) callid;
-		215	copy_from_uspace(&call->data, data, sizeof(call->data));
-		216	ipc_answer(&TASK->answerbox, call);
-		217
-		218	return 0;
-		219	}
-		220
205	/** Wait for incoming ipc call or answer	221	/** Wait for incoming ipc call or answer
206	*	222	*
207	* @param result	223	* @param result
208	* @param flags	224	* @param flags
209	* @return Callid, if callid & 1, then the call is answer	225	* @return Callid, if callid & 1, then the call is answer
210	*/	226	*/
211	static __native sys_ipc_wait_for_call(__native *calldata, __native flags)	227	static __native sys_ipc_wait_for_call(__native calldata, task_id_t taskid,
-		228	__native flags)
212	{	229	{
213	call_t *call;	230	call_t *call;
214		231
215	call = ipc_wait_for_call(&TASK->answerbox, flags);	232	call = ipc_wait_for_call(&TASK->answerbox, flags);
216		233
217	copy_to_uspace(calldata, &call->data, sizeof(call->data));	234	copy_to_uspace(calldata, &call->data, sizeof(call->data));
218		235
219	if (call->flags & IPC_CALL_ANSWERED) {	236	if (call->flags & IPC_CALL_ANSWERED) {
220	ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));	237	ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
221	ipc_call_free(call);	238	ipc_call_free(call);
222	atomic_dec(&TASK->active_calls);	239	atomic_dec(&TASK->active_calls);
223	return ((__native)call) \| IPC_CALLID_ANSWERED;	240	return ((__native)call) \| IPC_CALLID_ANSWERED;
224	}	241	}
-		242	copy_to_uspace(taskid, (void *)&TASK->taskid, sizeof(TASK->taskid));
225	return (__native)call;	243	return (__native)call;
226	}	244	}
227		245
228	static __native sys_mremap(void *address, size_t size, unsigned long flags)	246	static __native sys_mremap(void *address, size_t size, unsigned long flags)
229	{	247	{
230	return as_remap(AS, (__address) address, size, 0);	248	return as_remap(AS, (__address) address, size, 0);
231	}	249	}
232		250
233	syshandler_t syscall_table[SYSCALL_END] = {	251	syshandler_t syscall_table[SYSCALL_END] = {
234	sys_ctl,	252	sys_ctl,
235	sys_io,	253	sys_io,
236	sys_mremap,	254	sys_mremap,
237	sys_ipc_call_sync_fast,	255	sys_ipc_call_sync_fast,
238	sys_ipc_call_sync,	256	sys_ipc_call_sync,
239	sys_ipc_call_async_fast,	257	sys_ipc_call_async_fast,
240	sys_ipc_call_async,	258	sys_ipc_call_async,
-		259	sys_ipc_answer_fast,
241	sys_ipc_answer,	260	sys_ipc_answer,
242	sys_ipc_wait_for_call	261	sys_ipc_wait_for_call
243	};	262	};
244		263

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/syscall/syscall.c – Rev 998 → 1005