Changes in kernel/generic/src/ipc/sysipc.c [fa3b8e4:8add9ca5] in mainline

File:

• kernel/generic/src/ipc/sysipc.c (modified) (54 diffs)

kernel/generic/src/ipc/sysipc.c

@@ -49 +49 @@
 #include <syscall/copy.h>
 #include <security/cap.h>
+#include <console/console.h>
 #include <mm/as.h>
 #include <print.h>
@@ -68 +69 @@
  *
  */
-static int phone_get(unative_t phoneid, phone_t **phone)
+static int phone_get(sysarg_t phoneid, phone_t **phone)
 {
         if (phoneid >= IPC_MAX_PHONES)
@@ -77 +78 @@
 }
 
-/** Decide if the method is a system method.
- *
- * @param method Method to be decided.
- *
- * @return true if the method is a system method.
- *
- */
-static inline bool method_is_system(unative_t method)
-{
-        if (method <= IPC_M_LAST_SYSTEM)
+/** Decide if the interface and method is a system method.
+ *
+ * @param imethod Interface and method to be decided.
+ *
+ * @return True if the interface and method is a system
+ *         interface and method.
+ *
+ */
+static inline bool method_is_system(sysarg_t imethod)
+{
+        if (imethod <= IPC_M_LAST_SYSTEM)
                 return true;
         
@@ -92 +94 @@
 }
 
-/** Decide if the message with this method is forwardable.
- *
- * - some system messages may be forwarded, for some of them
- *   it is useless
- *
- * @param method Method to be decided.
- *
- * @return true if the method is forwardable.
- *
- */
-static inline bool method_is_forwardable(unative_t method)
-{
-        switch (method) {
+/** Decide if the message with this interface and method is forwardable.
+ *
+ * Some system messages may be forwarded, for some of them
+ * it is useless.
+ *
+ * @param imethod Interface and method to be decided.
+ *
+ * @return True if the interface and method is forwardable.
+ *
+ */
+static inline bool method_is_forwardable(sysarg_t imethod)
+{
+        switch (imethod) {
         case IPC_M_CONNECTION_CLONE:
         case IPC_M_CONNECT_ME:
@@ -115 +117 @@
 }
 
-/** Decide if the message with this method is immutable on forward.
- *
- * - some system messages may be forwarded but their content cannot be altered
- *
- * @param method Method to be decided.
- *
- * @return true if the method is immutable on forward.
- *
- */
-static inline bool method_is_immutable(unative_t method)
-{
-        switch (method) {
+/** Decide if the message with this interface and method is immutable on forward.
+ *
+ * Some system messages may be forwarded but their content cannot be altered.
+ *
+ * @param imethod Interface and method to be decided.
+ *
+ * @return True if the interface and method is immutable on forward.
+ *
+ */
+static inline bool method_is_immutable(sysarg_t imethod)
+{
+        switch (imethod) {
         case IPC_M_SHARE_OUT:
         case IPC_M_SHARE_IN:
@@ -152 +154 @@
 static inline bool answer_need_old(call_t *call)
 {
-        switch (IPC_GET_METHOD(call->data)) {
+        switch (IPC_GET_IMETHOD(call->data)) {
         case IPC_M_CONNECTION_CLONE:
         case IPC_M_CONNECT_ME:
@@ -196 +198 @@
                 return 0;
         
-        if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
+        if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
                 int phoneid = IPC_GET_ARG1(*olddata);
                 phone_t *phone = &TASK->phones[phoneid];
@@ -218 +220 @@
                         mutex_unlock(&phone->lock);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_ME) {
                 phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata);
                 
@@ -237 +239 @@
                         mutex_unlock(&phone->lock);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
                 int phoneid = IPC_GET_ARG5(*olddata);
                 
@@ -246 +248 @@
                         /* The connection was accepted */
                         phone_connect(phoneid, &answer->sender->answerbox);
+                        /* Set 'task hash' as arg4 of response */
+                        IPC_SET_ARG4(answer->data, (sysarg_t) TASK);
                         /* Set 'phone hash' as arg5 of response */
                         IPC_SET_ARG5(answer->data,
-                            (unative_t) &TASK->phones[phoneid]);
-                }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
+                            (sysarg_t) &TASK->phones[phoneid]);
+                }
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
                 /* If the users accepted call, connect */
                 if (IPC_GET_RETVAL(answer->data) == EOK) {
@@ -256 +260 @@
                             &TASK->answerbox);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_OUT) {
                 if (!IPC_GET_RETVAL(answer->data)) {
                         /* Accepted, handle as_area receipt */
@@ -270 +274 @@
                         return rc;
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) {
                 if (!IPC_GET_RETVAL(answer->data)) { 
                         irq_spinlock_lock(&answer->sender->lock, true);
@@ -281 +285 @@
                         IPC_SET_RETVAL(answer->data, rc);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_READ) {
                 ASSERT(!answer->buffer);
                 if (!IPC_GET_RETVAL(answer->data)) {
@@ -310 +314 @@
                         }
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_WRITE) {
                 ASSERT(answer->buffer);
                 if (!IPC_GET_RETVAL(answer->data)) {
@@ -363 +367 @@
 static int request_preprocess(call_t *call, phone_t *phone)
 {
-        switch (IPC_GET_METHOD(call->data)) {
+        switch (IPC_GET_IMETHOD(call->data)) {
         case IPC_M_CONNECTION_CLONE: {
                 phone_t *cloned_phone;
@@ -399 +403 @@
         }
         case IPC_M_CONNECT_ME:
-                IPC_SET_ARG5(call->data, (unative_t) phone);
+                IPC_SET_ARG5(call->data, (sysarg_t) phone);
                 break;
         case IPC_M_CONNECT_ME_TO: {
@@ -407 +411 @@
                 
                 /* Set arg5 for server */
-                IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
+                IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]);
                 call->flags |= IPC_CALL_CONN_ME_TO;
                 call->priv = newphid;
@@ -503 +507 @@
 static int process_request(answerbox_t *box, call_t *call)
 {
-        if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
+        if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME) {
                 int phoneid = phone_alloc(TASK);
                 if (phoneid < 0) { /* Failed to allocate phone */
@@ -514 +518 @@
         }
         
-        switch (IPC_GET_METHOD(call->data)) {
+        switch (IPC_GET_IMETHOD(call->data)) {
         case IPC_M_DEBUG_ALL:
                 return -1;
@@ -530 +534 @@
  *
  * @param phoneid Phone handle for the call.
- * @param method  Method of the call.
+ * @param imethod Interface and method of the call.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
  * @param arg3    Service-defined payload argument.
- * @param data    Address of userspace structure where the reply call will
+ * @param data    Address of user-space structure where the reply call will
  *                be stored.
  *
@@ -541 +545 @@
  *
  */
-unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
-    unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
+sysarg_t sys_ipc_call_sync_fast(sysarg_t phoneid, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, ipc_data_t *data)
 {
         phone_t *phone;
         if (phone_get(phoneid, &phone) != EOK)
                 return ENOENT;
-
+        
         call_t *call = ipc_call_alloc(0);
-        IPC_SET_METHOD(call->data, method);
+        IPC_SET_IMETHOD(call->data, imethod);
         IPC_SET_ARG1(call->data, arg1);
         IPC_SET_ARG2(call->data, arg2);
@@ -579 +583 @@
                 
                 process_answer(call);
-                
         } else
                 IPC_SET_RETVAL(call->data, res);
@@ -593 +596 @@
 /** Make a synchronous IPC call allowing to transmit the entire payload.
  *
- * @param phoneid  Phone handle for the call.
- * @param question Userspace address of call data with the request.
- * @param reply    Userspace address of call data where to store the
- *                 answer.
+ * @param phoneid Phone handle for the call.
+ * @param request User-space address of call data with the request.
+ * @param reply   User-space address of call data where to store the
+ *                answer.
  *
  * @return Zero on success or an error code.
  *
  */
-unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
+sysarg_t sys_ipc_call_sync_slow(sysarg_t phoneid, ipc_data_t *request,
     ipc_data_t *reply)
 {
@@ -607 +610 @@
         if (phone_get(phoneid, &phone) != EOK)
                 return ENOENT;
-
+        
         call_t *call = ipc_call_alloc(0);
-        int rc = copy_from_uspace(&call->data.args, &question->args,
+        int rc = copy_from_uspace(&call->data.args, &request->args,
             sizeof(call->data.args));
         if (rc != 0) {
                 ipc_call_free(call);
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         }
         
@@ -644 +647 @@
 }
 
-/** Check that the task did not exceed the allowed limit of asynchronous calls.
+/** Check that the task did not exceed the allowed limit of asynchronous calls
+ * made over a phone.
+ *
+ * @param phone Phone to check the limit against.
  *
  * @return 0 if limit not reached or -1 if limit exceeded.
  *
  */
-static int check_call_limit(void)
-{
-        if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
-                atomic_dec(&TASK->active_calls);
+static int check_call_limit(phone_t *phone)
+{
+        if (atomic_get(&phone->active_calls) >= IPC_MAX_ASYNC_CALLS)
                 return -1;
-        }
         
         return 0;
@@ -665 +669 @@
  *
  * @param phoneid Phone handle for the call.
- * @param method  Method of the call.
+ * @param imethod Interface and method of the call.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
@@ -677 +681 @@
  *
  */
-unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
-    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
-{
-        if (check_call_limit())
-                return IPC_CALLRET_TEMPORARY;
-        
+sysarg_t sys_ipc_call_async_fast(sysarg_t phoneid, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+{
         phone_t *phone;
         if (phone_get(phoneid, &phone) != EOK)
                 return IPC_CALLRET_FATAL;
         
+        if (check_call_limit(phone))
+                return IPC_CALLRET_TEMPORARY;
+        
         call_t *call = ipc_call_alloc(0);
-        IPC_SET_METHOD(call->data, method);
+        IPC_SET_IMETHOD(call->data, imethod);
         IPC_SET_ARG1(call->data, arg1);
         IPC_SET_ARG2(call->data, arg2);
@@ -707 +711 @@
                 ipc_backsend_err(phone, call, res);
         
-        return (unative_t) call;
+        return (sysarg_t) call;
 }
 
@@ -718 +722 @@
  *
  */
-unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
-{
-        if (check_call_limit())
-                return IPC_CALLRET_TEMPORARY;
-        
+sysarg_t sys_ipc_call_async_slow(sysarg_t phoneid, ipc_data_t *data)
+{
         phone_t *phone;
         if (phone_get(phoneid, &phone) != EOK)
                 return IPC_CALLRET_FATAL;
+
+        if (check_call_limit(phone))
+                return IPC_CALLRET_TEMPORARY;
 
         call_t *call = ipc_call_alloc(0);
@@ -732 +736 @@
         if (rc != 0) {
                 ipc_call_free(call);
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         }
         
@@ -742 +746 @@
                 ipc_backsend_err(phone, call, res);
         
-        return (unative_t) call;
+        return (sysarg_t) call;
 }
 
@@ -751 +755 @@
  * @param callid  Hash of the call to forward.
  * @param phoneid Phone handle to use for forwarding.
- * @param method  New method to use for the forwarded call.
+ * @param imethod New interface and method to use for the forwarded call.
  * @param arg1    New value of the first argument for the forwarded call.
  * @param arg2    New value of the second argument for the forwarded call.
@@ -767 +771 @@
  *
  */
-static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
-    unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
-    unative_t arg4, unative_t arg5, unsigned int mode, bool slow)
+static sysarg_t sys_ipc_forward_common(sysarg_t callid, sysarg_t phoneid,
+    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
+    sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
 {
         call_t *call = get_call(callid);
@@ -784 +788 @@
         }
         
-        if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
+        if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) {
                 IPC_SET_RETVAL(call->data, EFORWARD);
                 ipc_answer(&TASK->answerbox, call);
@@ -791 +795 @@
         
         /*
-         * Userspace is not allowed to change method of system methods on
-         * forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
-         * arg1, arg2 and arg3.
-         * If the method is immutable, don't change anything.
+         * Userspace is not allowed to change interface and method of system
+         * methods on forward, allow changing ARG1, ARG2, ARG3 and ARG4 by
+         * means of method, arg1, arg2 and arg3.
+         * If the interface and method is immutable, don't change anything.
          */
-        if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
-                if (method_is_system(IPC_GET_METHOD(call->data))) {
-                        if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
+        if (!method_is_immutable(IPC_GET_IMETHOD(call->data))) {
+                if (method_is_system(IPC_GET_IMETHOD(call->data))) {
+                        if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME)
                                 phone_dealloc(IPC_GET_ARG5(call->data));
                         
-                        IPC_SET_ARG1(call->data, method);
+                        IPC_SET_ARG1(call->data, imethod);
                         IPC_SET_ARG2(call->data, arg1);
                         IPC_SET_ARG3(call->data, arg2);
@@ -813 +817 @@
                         }
                 } else {
-                        IPC_SET_METHOD(call->data, method);
+                        IPC_SET_IMETHOD(call->data, imethod);
                         IPC_SET_ARG1(call->data, arg1);
                         IPC_SET_ARG2(call->data, arg2);
@@ -829 +833 @@
 /** Forward a received call to another destination - fast version.
  *
- * In case the original method is a system method, ARG1, ARG2 and ARG3 are
- * overwritten in the forwarded message with the new method and the new
- * arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
- * rewritten with the new method, arg1 and arg2, respectively. Also note there
- * is a set of immutable methods, for which the new method and arguments are not
- * set and these values are ignored.
+ * In case the original interface and method is a system method, ARG1, ARG2
+ * and ARG3 are overwritten in the forwarded message with the new method and
+ * the new arg1 and arg2, respectively. Otherwise the IMETHOD, ARG1 and ARG2
+ * are rewritten with the new interface and method, arg1 and arg2, respectively.
+ * Also note there is a set of immutable methods, for which the new method and
+ * arguments are not set and these values are ignored.
  *
  * @param callid  Hash of the call to forward.
  * @param phoneid Phone handle to use for forwarding.
- * @param method  New method to use for the forwarded call.
+ * @param imethod New interface and method to use for the forwarded call.
  * @param arg1    New value of the first argument for the forwarded call.
  * @param arg2    New value of the second argument for the forwarded call.
@@ -846 +850 @@
  *
  */
-unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
-    unative_t method, unative_t arg1, unative_t arg2, unsigned int mode)
-{
-        return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
+sysarg_t sys_ipc_forward_fast(sysarg_t callid, sysarg_t phoneid,
+    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
+{
+        return sys_ipc_forward_common(callid, phoneid, imethod, arg1, arg2, 0, 0,
             0, mode, false); 
 }
@@ -856 +860 @@
  *
  * This function is the slow verision of the sys_ipc_forward_fast interface.
- * It can copy all five new arguments and the new method from the userspace.
- * It naturally extends the functionality of the fast version. For system
- * methods, it additionally stores the new value of arg3 to ARG4. For non-system
- * methods, it additionally stores the new value of arg3, arg4 and arg5,
- * respectively, to ARG3, ARG4 and ARG5, respectively.
+ * It can copy all five new arguments and the new interface and method from
+ * the userspace. It naturally extends the functionality of the fast version.
+ * For system methods, it additionally stores the new value of arg3 to ARG4.
+ * For non-system methods, it additionally stores the new value of arg3, arg4
+ * and arg5, respectively, to ARG3, ARG4 and ARG5, respectively.
  *
  * @param callid  Hash of the call to forward.
@@ -870 +874 @@
  *
  */
-unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
+sysarg_t sys_ipc_forward_slow(sysarg_t callid, sysarg_t phoneid,
     ipc_data_t *data, unsigned int mode)
 {
@@ -877 +881 @@
             sizeof(newdata.args));
         if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         
         return sys_ipc_forward_common(callid, phoneid,
-            IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
+            IPC_GET_IMETHOD(newdata), IPC_GET_ARG1(newdata),
             IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
             IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true); 
@@ -900 +904 @@
  *
  */
-unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
-    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
+sysarg_t sys_ipc_answer_fast(sysarg_t callid, sysarg_t retval,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
 {
         /* Do not answer notification callids */
@@ -945 +949 @@
  *
  */
-unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
+sysarg_t sys_ipc_answer_slow(sysarg_t callid, ipc_data_t *data)
 {
         /* Do not answer notification callids */
@@ -982 +986 @@
  *
  */
-unative_t sys_ipc_hangup(unative_t phoneid)
+sysarg_t sys_ipc_hangup(sysarg_t phoneid)
 {
         phone_t *phone;
@@ -1008 +1012 @@
  *
  */
-unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
+sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     unsigned int flags)
 {
@@ -1037 +1041 @@
                 ipc_call_free(call);
                 
-                return ((unative_t) call) | IPC_CALLID_NOTIFICATION;
+                return ((sysarg_t) call) | IPC_CALLID_NOTIFICATION;
         }
         
@@ -1046 +1050 @@
                         ipc_call_free(call);
                         goto restart;
-                } else {
-                        /*
-                         * Decrement the counter of active calls only if the
-                         * call is not an answer to IPC_M_PHONE_HUNGUP,
-                         * which doesn't contribute to the counter.
-                         */
-                        atomic_dec(&TASK->active_calls);
                 }
                 
@@ -1058 +1055 @@
                 ipc_call_free(call);
                 
-                return ((unative_t) call) | IPC_CALLID_ANSWERED;
+                return ((sysarg_t) call) | IPC_CALLID_ANSWERED;
         }
         
@@ -1086 +1083 @@
         }
         
-        return (unative_t) call;
+        return (sysarg_t) call;
 }
 
@@ -1092 +1089 @@
  *
  */
-unative_t sys_ipc_poke(void)
+sysarg_t sys_ipc_poke(void)
 {
         waitq_unsleep(&TASK->answerbox.wq);
@@ -1100 +1097 @@
 /** Connect an IRQ handler to a task.
  *
- * @param inr    IRQ number.
- * @param devno  Device number.
- * @param method Method to be associated with the notification.
- * @param ucode  Uspace pointer to the top-half pseudocode.
+ * @param inr     IRQ number.
+ * @param devno   Device number.
+ * @param imethod Interface and method to be associated with the notification.
+ * @param ucode   Uspace pointer to the top-half pseudocode.
  *
  * @return EPERM or a return code returned by ipc_irq_register().
  *
  */
-unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
+sysarg_t sys_register_irq(inr_t inr, devno_t devno, sysarg_t imethod,
     irq_code_t *ucode)
 {
@@ -1114 +1111 @@
                 return EPERM;
         
-        return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
+        return ipc_irq_register(&TASK->answerbox, inr, devno, imethod, ucode);
 }
 
@@ -1125 +1122 @@
  *
  */
-unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
+sysarg_t sys_unregister_irq(inr_t inr, devno_t devno)
 {
         if (!(cap_get(TASK) & CAP_IRQ_REG))
@@ -1135 +1132 @@
 }
 
-#include <console/console.h>
-
-/** Syscall connect to a task by id.
+#ifdef __32_BITS__
+
+/** Syscall connect to a task by ID (32 bits)
  *
  * @return Phone id on success, or negative error code.
  *
  */
-unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
+sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid)
 {
 #ifdef CONFIG_UDEBUG
-        sysarg64_t taskid_arg;
-        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
+        sysarg64_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
         if (rc != 0)
-                return (unative_t) rc;
-        
-        LOG("sys_ipc_connect_kbox(%" PRIu64 ")", taskid_arg.value);
-        
-        return ipc_connect_kbox(taskid_arg.value);
+                return (sysarg_t) rc;
+        
+        return ipc_connect_kbox((task_id_t) taskid);
 #else
-        return (unative_t) ENOTSUP;
+        return (sysarg_t) ENOTSUP;
 #endif
 }
 
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+/** Syscall connect to a task by ID (64 bits)
+ *
+ * @return Phone id on success, or negative error code.
+ *
+ */
+sysarg_t sys_ipc_connect_kbox(sysarg_t taskid)
+{
+#ifdef CONFIG_UDEBUG
+        return ipc_connect_kbox((task_id_t) taskid);
+#else
+        return (sysarg_t) ENOTSUP;
+#endif
+}
+
+#endif  /* __64_BITS__ */
+
 /** @}
  */