2 * Copyright (c) 2006 Ondrej Palkovsky
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
29 /** @addtogroup genericipc
40 #include <abi/ipc/methods.h>
41 #include <ipc/sysipc.h>
42 #include <ipc/sysipc_ops.h>
43 #include <ipc/sysipc_priv.h>
45 #include <ipc/ipcrsc.h>
46 #include <ipc/event.h>
48 #include <synch/waitq.h>
49 #include <arch/interrupt.h>
50 #include <syscall/copy.h>
51 #include <security/perm.h>
52 #include <console/console.h>
56 #define STRUCT_TO_USPACE(dst, src) copy_to_uspace((dst), (src), sizeof(*(src)))
58 /** Decide if the interface and method is a system method.
60 * @param imethod Interface and method to be decided.
62 * @return True if the interface and method is a system
63 * interface and method.
66 static inline bool method_is_system(sysarg_t imethod
)
68 if (imethod
<= IPC_M_LAST_SYSTEM
)
74 /** Decide if the message with this interface and method is forwardable.
76 * Some system messages may be forwarded, for some of them
79 * @param imethod Interface and method to be decided.
81 * @return True if the interface and method is forwardable.
84 static inline bool method_is_forwardable(sysarg_t imethod
)
87 case IPC_M_PHONE_HUNGUP
:
88 /* This message is meant only for the original recipient. */
95 /** Decide if the message with this interface and method is immutable on forward.
97 * Some system messages may be forwarded but their content cannot be altered.
99 * @param imethod Interface and method to be decided.
101 * @return True if the interface and method is immutable on forward.
104 static inline bool method_is_immutable(sysarg_t imethod
)
108 case IPC_M_SHARE_OUT
:
110 case IPC_M_DATA_WRITE
:
111 case IPC_M_DATA_READ
:
112 case IPC_M_STATE_CHANGE_AUTHORIZE
:
120 /***********************************************************************
121 * Functions that preprocess answer before sending it to the recepient.
122 ***********************************************************************/
124 /** Decide if the caller (e.g. ipc_answer()) should save the old call contents
125 * for answer_preprocess().
127 * @param call Call structure to be decided.
129 * @return true if the old call contents should be saved.
132 static inline bool answer_need_old(call_t
*call
)
134 switch (IPC_GET_IMETHOD(call
->data
)) {
135 case IPC_M_CONNECT_TO_ME
:
136 case IPC_M_CONNECT_ME_TO
:
138 case IPC_M_SHARE_OUT
:
140 case IPC_M_DATA_WRITE
:
141 case IPC_M_DATA_READ
:
142 case IPC_M_STATE_CHANGE_AUTHORIZE
:
149 /** Interpret process answer as control information.
151 * This function is called directly after sys_ipc_answer().
153 * @param answer Call structure with the answer.
154 * @param olddata Saved data of the request.
156 * @return Return EOK on success or a negative error code.
159 int answer_preprocess(call_t
*answer
, ipc_data_t
*olddata
)
163 spinlock_lock(&answer
->forget_lock
);
164 if (answer
->forget
) {
166 * This is a forgotten call and answer->sender is not valid.
168 spinlock_unlock(&answer
->forget_lock
);
170 SYSIPC_OP(answer_cleanup
, answer
, olddata
);
173 assert(answer
->active
);
176 * Mark the call as inactive to prevent _ipc_answer_free_call()
177 * from attempting to remove the call from the active list
180 answer
->active
= false;
183 * Remove the call from the sender's active call list.
184 * We enforce this locking order so that any potential
185 * concurrently executing forget operation is forced to
186 * release its active_calls_lock and lose the race to
187 * forget this soon to be answered call.
189 spinlock_lock(&answer
->sender
->active_calls_lock
);
190 list_remove(&answer
->ta_link
);
191 spinlock_unlock(&answer
->sender
->active_calls_lock
);
193 spinlock_unlock(&answer
->forget_lock
);
195 if ((native_t
) IPC_GET_RETVAL(answer
->data
) == EHANGUP
) {
196 phone_t
*phone
= answer
->caller_phone
;
197 mutex_lock(&phone
->lock
);
198 if (phone
->state
== IPC_PHONE_CONNECTED
) {
199 irq_spinlock_lock(&phone
->callee
->lock
, true);
200 list_remove(&phone
->link
);
201 phone
->state
= IPC_PHONE_SLAMMED
;
202 irq_spinlock_unlock(&phone
->callee
->lock
, true);
204 mutex_unlock(&phone
->lock
);
210 return SYSIPC_OP(answer_preprocess
, answer
, olddata
);
213 /** Called before the request is sent.
215 * @param call Call structure with the request.
216 * @param phone Phone that the call will be sent through.
218 * @return Return 0 on success, ELIMIT or EPERM on error.
221 static int request_preprocess(call_t
*call
, phone_t
*phone
)
223 call
->request_method
= IPC_GET_IMETHOD(call
->data
);
224 return SYSIPC_OP(request_preprocess
, call
, phone
);
227 /*******************************************************************************
228 * Functions called to process received call/answer before passing it to uspace.
229 *******************************************************************************/
231 /** Do basic kernel processing of received call answer.
233 * @param call Call structure with the answer.
236 static void process_answer(call_t
*call
)
238 if (((native_t
) IPC_GET_RETVAL(call
->data
) == EHANGUP
) &&
239 (call
->flags
& IPC_CALL_FORWARDED
))
240 IPC_SET_RETVAL(call
->data
, EFORWARD
);
242 SYSIPC_OP(answer_process
, call
);
246 /** Do basic kernel processing of received call request.
248 * @param box Destination answerbox structure.
249 * @param call Call structure with the request.
251 * @return 0 if the call should be passed to userspace.
252 * @return -1 if the call should be ignored.
255 static int process_request(answerbox_t
*box
, call_t
*call
)
257 return SYSIPC_OP(request_process
, call
, box
);
260 /** Make a call over IPC and wait for reply.
262 * @param handle Phone capability handle for the call.
263 * @param data[inout] Structure with request/reply data.
264 * @param priv Value to be stored in call->priv.
266 * @return EOK on success.
267 * @return ENOENT if there is no such phone handle.
270 int ipc_req_internal(cap_handle_t handle
, ipc_data_t
*data
, sysarg_t priv
)
272 kobject_t
*kobj
= kobject_get(TASK
, handle
, KOBJECT_TYPE_PHONE
);
276 call_t
*call
= ipc_call_alloc(0);
278 memcpy(call
->data
.args
, data
->args
, sizeof(data
->args
));
280 int rc
= request_preprocess(call
, kobj
->phone
);
283 udebug_stoppable_begin();
287 rc
= ipc_call_sync(kobj
->phone
, call
);
288 spinlock_lock(&call
->forget_lock
);
289 bool forgotten
= call
->forget
;
290 spinlock_unlock(&call
->forget_lock
);
291 ipc_call_release(call
);
294 udebug_stoppable_end();
300 * There was an error, but it did not result
301 * in the call being forgotten. In fact, the
302 * call was not even sent. We are still
303 * its owners and are responsible for its
309 * The call was forgotten and it changed hands.
310 * We are no longer expected to free it.
318 process_answer(call
);
320 IPC_SET_RETVAL(call
->data
, rc
);
322 memcpy(data
->args
, call
->data
.args
, sizeof(data
->args
));
329 /** Check that the task did not exceed the allowed limit of asynchronous calls
332 * @param phone Phone to check the limit against.
334 * @return 0 if limit not reached or -1 if limit exceeded.
337 static int check_call_limit(phone_t
*phone
)
339 if (atomic_get(&phone
->active_calls
) >= IPC_MAX_ASYNC_CALLS
)
345 /** Make a fast asynchronous call over IPC.
347 * This function can only handle four arguments of payload, but is faster than
348 * the generic function sys_ipc_call_async_slow().
350 * @param handle Phone capability handle for the call.
351 * @param imethod Interface and method of the call.
352 * @param arg1 Service-defined payload argument.
353 * @param arg2 Service-defined payload argument.
354 * @param arg3 Service-defined payload argument.
355 * @param arg4 Service-defined payload argument.
357 * @return Call hash on success.
358 * @return IPC_CALLRET_FATAL in case of a fatal error.
359 * @return IPC_CALLRET_TEMPORARY if there are too many pending
360 * asynchronous requests; answers should be handled first.
363 sysarg_t
sys_ipc_call_async_fast(sysarg_t handle
, sysarg_t imethod
,
364 sysarg_t arg1
, sysarg_t arg2
, sysarg_t arg3
, sysarg_t arg4
)
366 kobject_t
*kobj
= kobject_get(TASK
, handle
, KOBJECT_TYPE_PHONE
);
368 return IPC_CALLRET_FATAL
;
370 if (check_call_limit(kobj
->phone
)) {
372 return IPC_CALLRET_TEMPORARY
;
375 call_t
*call
= ipc_call_alloc(0);
376 IPC_SET_IMETHOD(call
->data
, imethod
);
377 IPC_SET_ARG1(call
->data
, arg1
);
378 IPC_SET_ARG2(call
->data
, arg2
);
379 IPC_SET_ARG3(call
->data
, arg3
);
380 IPC_SET_ARG4(call
->data
, arg4
);
383 * To achieve deterministic behavior, zero out arguments that are beyond
384 * the limits of the fast version.
386 IPC_SET_ARG5(call
->data
, 0);
388 int res
= request_preprocess(call
, kobj
->phone
);
391 ipc_call(kobj
->phone
, call
);
393 ipc_backsend_err(kobj
->phone
, call
, res
);
396 return (sysarg_t
) call
;
399 /** Make an asynchronous IPC call allowing to transmit the entire payload.
401 * @param handle Phone capability for the call.
402 * @param data Userspace address of call data with the request.
404 * @return See sys_ipc_call_async_fast().
407 sysarg_t
sys_ipc_call_async_slow(sysarg_t handle
, ipc_data_t
*data
)
409 kobject_t
*kobj
= kobject_get(TASK
, handle
, KOBJECT_TYPE_PHONE
);
411 return IPC_CALLRET_FATAL
;
413 if (check_call_limit(kobj
->phone
)) {
415 return IPC_CALLRET_TEMPORARY
;
418 call_t
*call
= ipc_call_alloc(0);
419 int rc
= copy_from_uspace(&call
->data
.args
, &data
->args
,
420 sizeof(call
->data
.args
));
424 return (sysarg_t
) rc
;
427 int res
= request_preprocess(call
, kobj
->phone
);
430 ipc_call(kobj
->phone
, call
);
432 ipc_backsend_err(kobj
->phone
, call
, res
);
435 return (sysarg_t
) call
;
438 /** Forward a received call to another destination
440 * Common code for both the fast and the slow version.
442 * @param callid Hash of the call to forward.
443 * @param handle Phone capability to use for forwarding.
444 * @param imethod New interface and method to use for the forwarded call.
445 * @param arg1 New value of the first argument for the forwarded call.
446 * @param arg2 New value of the second argument for the forwarded call.
447 * @param arg3 New value of the third argument for the forwarded call.
448 * @param arg4 New value of the fourth argument for the forwarded call.
449 * @param arg5 New value of the fifth argument for the forwarded call.
450 * @param mode Flags that specify mode of the forward operation.
451 * @param slow If true, arg3, arg4 and arg5 are considered. Otherwise
452 * the function considers only the fast version arguments:
453 * i.e. arg1 and arg2.
455 * @return 0 on succes, otherwise an error code.
457 * Warning: Make sure that ARG5 is not rewritten for certain system IPC
460 static sysarg_t
sys_ipc_forward_common(sysarg_t callid
, sysarg_t handle
,
461 sysarg_t imethod
, sysarg_t arg1
, sysarg_t arg2
, sysarg_t arg3
,
462 sysarg_t arg4
, sysarg_t arg5
, unsigned int mode
, bool slow
)
464 call_t
*call
= get_call(callid
);
469 bool need_old
= answer_need_old(call
);
473 bool after_forward
= false;
476 kobject_t
*kobj
= kobject_get(TASK
, handle
, KOBJECT_TYPE_PHONE
);
482 if (!method_is_forwardable(IPC_GET_IMETHOD(call
->data
))) {
487 call
->flags
|= IPC_CALL_FORWARDED
;
490 * User space is not allowed to change interface and method of system
491 * methods on forward, allow changing ARG1, ARG2, ARG3 and ARG4 by
492 * means of imethod, arg1, arg2 and arg3.
493 * If the interface and method is immutable, don't change anything.
495 if (!method_is_immutable(IPC_GET_IMETHOD(call
->data
))) {
496 if (method_is_system(IPC_GET_IMETHOD(call
->data
))) {
497 if (IPC_GET_IMETHOD(call
->data
) == IPC_M_CONNECT_TO_ME
)
498 phone_dealloc(IPC_GET_ARG5(call
->data
));
500 IPC_SET_ARG1(call
->data
, imethod
);
501 IPC_SET_ARG2(call
->data
, arg1
);
502 IPC_SET_ARG3(call
->data
, arg2
);
505 IPC_SET_ARG4(call
->data
, arg3
);
508 * For system methods we deliberately don't
512 IPC_SET_IMETHOD(call
->data
, imethod
);
513 IPC_SET_ARG1(call
->data
, arg1
);
514 IPC_SET_ARG2(call
->data
, arg2
);
516 IPC_SET_ARG3(call
->data
, arg3
);
517 IPC_SET_ARG4(call
->data
, arg4
);
518 IPC_SET_ARG5(call
->data
, arg5
);
523 rc
= ipc_forward(call
, kobj
->phone
, &TASK
->answerbox
, mode
);
525 after_forward
= true;
533 IPC_SET_RETVAL(call
->data
, EFORWARD
);
534 (void) answer_preprocess(call
, need_old
? &old
: NULL
);
536 _ipc_answer_free_call(call
, false);
538 ipc_answer(&TASK
->answerbox
, call
);
545 /** Forward a received call to another destination - fast version.
547 * In case the original interface and method is a system method, ARG1, ARG2
548 * and ARG3 are overwritten in the forwarded message with the new method and
549 * the new arg1 and arg2, respectively. Otherwise the IMETHOD, ARG1 and ARG2
550 * are rewritten with the new interface and method, arg1 and arg2, respectively.
551 * Also note there is a set of immutable methods, for which the new method and
552 * arguments are not set and these values are ignored.
554 * @param callid Hash of the call to forward.
555 * @param handle Phone handle to use for forwarding.
556 * @param imethod New interface and method to use for the forwarded call.
557 * @param arg1 New value of the first argument for the forwarded call.
558 * @param arg2 New value of the second argument for the forwarded call.
559 * @param mode Flags that specify mode of the forward operation.
561 * @return 0 on succes, otherwise an error code.
564 sysarg_t
sys_ipc_forward_fast(sysarg_t callid
, sysarg_t handle
,
565 sysarg_t imethod
, sysarg_t arg1
, sysarg_t arg2
, unsigned int mode
)
567 return sys_ipc_forward_common(callid
, handle
, imethod
, arg1
, arg2
, 0, 0,
571 /** Forward a received call to another destination - slow version.
573 * This function is the slow verision of the sys_ipc_forward_fast interface.
574 * It can copy all five new arguments and the new interface and method from
575 * the userspace. It naturally extends the functionality of the fast version.
576 * For system methods, it additionally stores the new value of arg3 to ARG4.
577 * For non-system methods, it additionally stores the new value of arg3, arg4
578 * and arg5, respectively, to ARG3, ARG4 and ARG5, respectively.
580 * @param callid Hash of the call to forward.
581 * @param handle Phone handle to use for forwarding.
582 * @param data Userspace address of the new IPC data.
583 * @param mode Flags that specify mode of the forward operation.
585 * @return 0 on succes, otherwise an error code.
588 sysarg_t
sys_ipc_forward_slow(sysarg_t callid
, sysarg_t handle
,
589 ipc_data_t
*data
, unsigned int mode
)
592 int rc
= copy_from_uspace(&newdata
.args
, &data
->args
,
593 sizeof(newdata
.args
));
595 return (sysarg_t
) rc
;
597 return sys_ipc_forward_common(callid
, handle
,
598 IPC_GET_IMETHOD(newdata
), IPC_GET_ARG1(newdata
),
599 IPC_GET_ARG2(newdata
), IPC_GET_ARG3(newdata
),
600 IPC_GET_ARG4(newdata
), IPC_GET_ARG5(newdata
), mode
, true);
603 /** Answer an IPC call - fast version.
605 * This function can handle only two return arguments of payload, but is faster
606 * than the generic sys_ipc_answer().
608 * @param callid Hash of the call to be answered.
609 * @param retval Return value of the answer.
610 * @param arg1 Service-defined return value.
611 * @param arg2 Service-defined return value.
612 * @param arg3 Service-defined return value.
613 * @param arg4 Service-defined return value.
615 * @return 0 on success, otherwise an error code.
618 sysarg_t
sys_ipc_answer_fast(sysarg_t callid
, sysarg_t retval
,
619 sysarg_t arg1
, sysarg_t arg2
, sysarg_t arg3
, sysarg_t arg4
)
621 /* Do not answer notification callids */
622 if (callid
& IPC_CALLID_NOTIFICATION
)
625 call_t
*call
= get_call(callid
);
629 ipc_data_t saved_data
;
632 if (answer_need_old(call
)) {
633 memcpy(&saved_data
, &call
->data
, sizeof(call
->data
));
638 IPC_SET_RETVAL(call
->data
, retval
);
639 IPC_SET_ARG1(call
->data
, arg1
);
640 IPC_SET_ARG2(call
->data
, arg2
);
641 IPC_SET_ARG3(call
->data
, arg3
);
642 IPC_SET_ARG4(call
->data
, arg4
);
645 * To achieve deterministic behavior, zero out arguments that are beyond
646 * the limits of the fast version.
648 IPC_SET_ARG5(call
->data
, 0);
649 int rc
= answer_preprocess(call
, saved
? &saved_data
: NULL
);
651 ipc_answer(&TASK
->answerbox
, call
);
655 /** Answer an IPC call.
657 * @param callid Hash of the call to be answered.
658 * @param data Userspace address of call data with the answer.
660 * @return 0 on success, otherwise an error code.
663 sysarg_t
sys_ipc_answer_slow(sysarg_t callid
, ipc_data_t
*data
)
665 /* Do not answer notification callids */
666 if (callid
& IPC_CALLID_NOTIFICATION
)
669 call_t
*call
= get_call(callid
);
673 ipc_data_t saved_data
;
676 if (answer_need_old(call
)) {
677 memcpy(&saved_data
, &call
->data
, sizeof(call
->data
));
682 int rc
= copy_from_uspace(&call
->data
.args
, &data
->args
,
683 sizeof(call
->data
.args
));
687 rc
= answer_preprocess(call
, saved
? &saved_data
: NULL
);
689 ipc_answer(&TASK
->answerbox
, call
);
695 * @param handle Phone capability handle of the phone to be hung up.
697 * @return 0 on success or an error code.
700 sysarg_t
sys_ipc_hangup(sysarg_t handle
)
702 kobject_t
*kobj
= kobject_get(TASK
, handle
, KOBJECT_TYPE_PHONE
);
706 if (ipc_phone_hangup(kobj
->phone
)) {
715 /** Wait for an incoming IPC call or an answer.
717 * @param calldata Pointer to buffer where the call/answer data is stored.
718 * @param usec Timeout. See waitq_sleep_timeout() for explanation.
719 * @param flags Select mode of sleep operation. See waitq_sleep_timeout()
722 * @return Hash of the call.
723 * If IPC_CALLID_NOTIFICATION bit is set in the hash, the
724 * call is a notification. IPC_CALLID_ANSWERED denotes an
728 sysarg_t
sys_ipc_wait_for_call(ipc_data_t
*calldata
, uint32_t usec
,
736 udebug_stoppable_begin();
739 call
= ipc_wait_for_call(&TASK
->answerbox
, usec
,
740 flags
| SYNCH_FLAGS_INTERRUPTIBLE
);
743 udebug_stoppable_end();
749 if (call
->flags
& IPC_CALL_NOTIF
) {
750 /* Set in_phone_hash to the interrupt counter */
751 call
->data
.phone
= (void *) call
->priv
;
753 STRUCT_TO_USPACE(calldata
, &call
->data
);
757 return ((sysarg_t
) call
) | IPC_CALLID_NOTIFICATION
;
760 if (call
->flags
& IPC_CALL_ANSWERED
) {
761 process_answer(call
);
763 if (call
->flags
& IPC_CALL_DISCARD_ANSWER
) {
768 STRUCT_TO_USPACE(&calldata
->args
, &call
->data
.args
);
771 return ((sysarg_t
) call
) | IPC_CALLID_ANSWERED
;
774 if (process_request(&TASK
->answerbox
, call
))
777 /* Include phone address('id') of the caller in the request,
778 * copy whole call->data, not only call->data.args */
779 if (STRUCT_TO_USPACE(calldata
, &call
->data
)) {
781 * The callee will not receive this call and no one else has
782 * a chance to answer it. Reply with the EPARTY error code.
784 ipc_data_t saved_data
;
787 if (answer_need_old(call
)) {
788 memcpy(&saved_data
, &call
->data
, sizeof(call
->data
));
793 IPC_SET_RETVAL(call
->data
, EPARTY
);
794 (void) answer_preprocess(call
, saved
? &saved_data
: NULL
);
795 ipc_answer(&TASK
->answerbox
, call
);
799 return (sysarg_t
) call
;
802 /** Interrupt one thread from sys_ipc_wait_for_call().
805 sysarg_t
sys_ipc_poke(void)
807 waitq_unsleep(&TASK
->answerbox
.wq
);
811 /** Connect an IRQ handler to a task.
813 * @param inr IRQ number.
814 * @param imethod Interface and method to be associated with the notification.
815 * @param ucode Uspace pointer to the top-half pseudocode.
817 * @return IRQ kernel object capability
819 * @return Error code returned by ipc_irq_subscribe().
822 sysarg_t
sys_ipc_irq_subscribe(inr_t inr
, sysarg_t imethod
, irq_code_t
*ucode
)
824 if (!(perm_get(TASK
) & PERM_IRQ_REG
))
827 return ipc_irq_subscribe(&TASK
->answerbox
, inr
, imethod
, ucode
);
830 /** Disconnect an IRQ handler from a task.
832 * @param inr IRQ number.
833 * @param devno Device number.
835 * @return Zero on success or EPERM on error.
838 sysarg_t
sys_ipc_irq_unsubscribe(sysarg_t cap
)
840 if (!(perm_get(TASK
) & PERM_IRQ_REG
))
843 ipc_irq_unsubscribe(&TASK
->answerbox
, cap
);
850 /** Syscall connect to a task by ID (32 bits)
852 * @return Phone id on success, or negative error code.
855 sysarg_t
sys_ipc_connect_kbox(sysarg64_t
*uspace_taskid
)
859 int rc
= copy_from_uspace(&taskid
, uspace_taskid
, sizeof(sysarg64_t
));
861 return (sysarg_t
) rc
;
863 return ipc_connect_kbox((task_id_t
) taskid
);
865 return (sysarg_t
) ENOTSUP
;
869 #endif /* __32_BITS__ */
873 /** Syscall connect to a task by ID (64 bits)
875 * @return Phone id on success, or negative error code.
878 sysarg_t
sys_ipc_connect_kbox(sysarg_t taskid
)
881 return ipc_connect_kbox((task_id_t
) taskid
);
883 return (sysarg_t
) ENOTSUP
;
887 #endif /* __64_BITS__ */