Subversion Repositories HelenOS

Rev

Rev 3438 | Rev 3819 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2006 Ondrej Palkovsky
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  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.
  16.  *
  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.
  27.  */
  28.  
  29. /** @addtogroup libc
  30.  * @{
  31.  * @}
  32.  */
  33.  
  34. /** @addtogroup libcipc IPC
  35.  * @brief HelenOS uspace IPC
  36.  * @{
  37.  * @ingroup libc
  38.  */
  39. /** @file
  40.  */
  41.  
  42. #include <ipc/ipc.h>
  43. #include <libc.h>
  44. #include <malloc.h>
  45. #include <errno.h>
  46. #include <libadt/list.h>
  47. #include <stdio.h>
  48. #include <unistd.h>
  49. #include <futex.h>
  50. #include <kernel/synch/synch.h>
  51. #include <async.h>
  52. #include <fibril.h>
  53. #include <assert.h>
  54.  
  55. /**
  56.  * Structures of this type are used for keeping track of sent asynchronous calls
  57.  * and queing unsent calls.
  58.  */
  59. typedef struct {
  60.     link_t list;
  61.  
  62.     ipc_async_callback_t callback;
  63.     void *private;
  64.     union {
  65.         ipc_callid_t callid;
  66.         struct {
  67.             ipc_call_t data;
  68.             int phoneid;
  69.         } msg;
  70.     } u;
  71.     fid_t fid;  /**< Fibril waiting for sending this call. */
  72. } async_call_t;
  73.  
  74. LIST_INITIALIZE(dispatched_calls);
  75.  
  76. /** List of asynchronous calls that were not accepted by kernel.
  77.  *
  78.  * It is protected by async_futex, because if the call cannot be sent into the
  79.  * kernel, the async framework is used automatically.
  80.  */
  81. LIST_INITIALIZE(queued_calls);
  82.  
  83. static atomic_t ipc_futex = FUTEX_INITIALIZER;
  84.  
  85. /** Make a fast synchronous call.
  86.  *
  87.  * Only three payload arguments can be passed using this function. However, this
  88.  * function is faster than the generic ipc_call_sync_slow() because the payload
  89.  * is passed directly in registers.
  90.  *
  91.  * @param phoneid   Phone handle for the call.
  92.  * @param method    Requested method.
  93.  * @param arg1      Service-defined payload argument.
  94.  * @param arg2      Service-defined payload argument.
  95.  * @param arg3      Service-defined payload argument.
  96.  * @param result1   If non-NULL, the return ARG1 will be stored there.
  97.  * @param result2   If non-NULL, the return ARG2 will be stored there.
  98.  * @param result3   If non-NULL, the return ARG3 will be stored there.
  99.  * @param result4   If non-NULL, the return ARG4 will be stored there.
  100.  * @param result5   If non-NULL, the return ARG5 will be stored there.
  101.  *
  102.  * @return      Negative values represent errors returned by IPC.
  103.  *          Otherwise the RETVAL of the answer is returned.
  104.  */
  105. int
  106. ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
  107.     ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3,
  108.     ipcarg_t *result4, ipcarg_t *result5)
  109. {
  110.     ipc_call_t resdata;
  111.     int callres;
  112.    
  113.     callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
  114.         arg2, arg3, (sysarg_t) &resdata);
  115.     if (callres)
  116.         return callres;
  117.     if (result1)
  118.         *result1 = IPC_GET_ARG1(resdata);
  119.     if (result2)
  120.         *result2 = IPC_GET_ARG2(resdata);
  121.     if (result3)
  122.         *result3 = IPC_GET_ARG3(resdata);
  123.     if (result4)
  124.         *result4 = IPC_GET_ARG4(resdata);
  125.     if (result5)
  126.         *result5 = IPC_GET_ARG5(resdata);
  127.  
  128.     return IPC_GET_RETVAL(resdata);
  129. }
  130.  
  131. /** Make a synchronous call transmitting 5 arguments of payload.
  132.  *
  133.  * @param phoneid   Phone handle for the call.
  134.  * @param method    Requested method.
  135.  * @param arg1      Service-defined payload argument.
  136.  * @param arg2      Service-defined payload argument.
  137.  * @param arg3      Service-defined payload argument.
  138.  * @param arg4      Service-defined payload argument.
  139.  * @param arg5      Service-defined payload argument.
  140.  * @param result1   If non-NULL, storage for the first return argument.
  141.  * @param result2   If non-NULL, storage for the second return argument.
  142.  * @param result3   If non-NULL, storage for the third return argument.
  143.  * @param result4   If non-NULL, storage for the fourth return argument.
  144.  * @param result5   If non-NULL, storage for the fifth return argument.
  145.  *
  146.  * @return      Negative value means IPC error.
  147.  *          Otherwise the RETVAL of the answer.
  148.  */
  149. int
  150. ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
  151.     ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *result1,
  152.     ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5)
  153. {
  154.     ipc_call_t data;
  155.     int callres;
  156.  
  157.     IPC_SET_METHOD(data, method);
  158.     IPC_SET_ARG1(data, arg1);
  159.     IPC_SET_ARG2(data, arg2);
  160.     IPC_SET_ARG3(data, arg3);
  161.     IPC_SET_ARG4(data, arg4);
  162.     IPC_SET_ARG5(data, arg5);
  163.  
  164.     callres = __SYSCALL3(SYS_IPC_CALL_SYNC_SLOW, phoneid, (sysarg_t) &data,
  165.         (sysarg_t) &data);
  166.     if (callres)
  167.         return callres;
  168.  
  169.     if (result1)
  170.         *result1 = IPC_GET_ARG1(data);
  171.     if (result2)
  172.         *result2 = IPC_GET_ARG2(data);
  173.     if (result3)
  174.         *result3 = IPC_GET_ARG3(data);
  175.     if (result4)
  176.         *result4 = IPC_GET_ARG4(data);
  177.     if (result5)
  178.         *result5 = IPC_GET_ARG5(data);
  179.  
  180.     return IPC_GET_RETVAL(data);
  181. }
  182.  
  183. /** Syscall to send asynchronous message.
  184.  *
  185.  * @param phoneid   Phone handle for the call.
  186.  * @param data      Call data with the request.
  187.  *
  188.  * @return      Hash of the call or an error code.
  189.  */
  190. static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
  191. {
  192.     return __SYSCALL2(SYS_IPC_CALL_ASYNC_SLOW, phoneid, (sysarg_t) data);
  193. }
  194.  
  195. /** Prolog to ipc_call_async_*() functions.
  196.  *
  197.  * @param private   Argument for the answer/error callback.
  198.  * @param callback  Answer/error callback.
  199.  *
  200.  * @return      New, partially initialized async_call structure or NULL.
  201.  */
  202. static inline async_call_t *ipc_prepare_async(void *private,
  203.     ipc_async_callback_t callback)
  204. {
  205.     async_call_t *call;
  206.  
  207.     call = malloc(sizeof(*call));
  208.     if (!call) {
  209.         if (callback)
  210.             callback(private, ENOMEM, NULL);
  211.         return NULL;
  212.     }
  213.     call->callback = callback;
  214.     call->private = private;
  215.  
  216.     return call;
  217. }
  218.  
  219. /** Epilogue of ipc_call_async_*() functions.
  220.  *
  221.  * @param callid    Value returned by the SYS_IPC_CALL_ASYNC_* syscall.
  222.  * @param phoneid   Phone handle through which the call was made.
  223.  * @param call      async_call structure returned by ipc_prepare_async().
  224.  * @param can_preempt   If non-zero, the current fibril can be preempted in this
  225.  *          call.
  226.  */
  227. static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
  228.     async_call_t *call, int can_preempt)
  229. {
  230.     if (!call) { /* Nothing to do regardless if failed or not */
  231.         futex_up(&ipc_futex);
  232.         return;
  233.     }
  234.  
  235.     if (callid == IPC_CALLRET_FATAL) {
  236.         futex_up(&ipc_futex);
  237.         /* Call asynchronous handler with error code */
  238.         if (call->callback)
  239.             call->callback(call->private, ENOENT, NULL);
  240.         free(call);
  241.         return;
  242.     }
  243.  
  244.     if (callid == IPC_CALLRET_TEMPORARY) {
  245.         futex_up(&ipc_futex);
  246.  
  247.         call->u.msg.phoneid = phoneid;
  248.        
  249.         futex_down(&async_futex);
  250.         list_append(&call->list, &queued_calls);
  251.  
  252.         if (can_preempt) {
  253.             call->fid = fibril_get_id();
  254.             fibril_switch(FIBRIL_TO_MANAGER);
  255.             /* Async futex unlocked by previous call */
  256.         } else {
  257.             call->fid = 0;
  258.             futex_up(&async_futex);
  259.         }
  260.         return;
  261.     }
  262.     call->u.callid = callid;
  263.     /* Add call to the list of dispatched calls */
  264.     list_append(&call->list, &dispatched_calls);
  265.     futex_up(&ipc_futex);
  266.    
  267. }
  268.  
  269. /** Make a fast asynchronous call.
  270.  *
  271.  * This function can only handle four arguments of payload. It is, however,
  272.  * faster than the more generic ipc_call_async_slow().
  273.  *
  274.  * Note that this function is a void function.
  275.  * During normal opertation, answering this call will trigger the callback.
  276.  * In case of fatal error, call the callback handler with the proper error code.
  277.  * If the call cannot be temporarily made, queue it.
  278.  *
  279.  * @param phoneid   Phone handle for the call.
  280.  * @param method    Requested method.
  281.  * @param arg1      Service-defined payload argument.
  282.  * @param arg2      Service-defined payload argument.
  283.  * @param arg3      Service-defined payload argument.
  284.  * @param arg4      Service-defined payload argument.
  285.  * @param private   Argument to be passed to the answer/error callback.
  286.  * @param callback  Answer or error callback.
  287.  * @param can_preempt   If non-zero, the current fibril will be preempted in
  288.  *          case the kernel temporarily refuses to accept more
  289.  *          asynchronous calls.
  290.  */
  291. void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
  292.     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, void *private,
  293.     ipc_async_callback_t callback, int can_preempt)
  294. {
  295.     async_call_t *call = NULL;
  296.     ipc_callid_t callid;
  297.  
  298.     if (callback) {
  299.         call = ipc_prepare_async(private, callback);
  300.         if (!call)
  301.             return;
  302.     }
  303.  
  304.     /*
  305.      * We need to make sure that we get callid before another thread
  306.      * accesses the queue again.
  307.      */
  308.     futex_down(&ipc_futex);
  309.     callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1,
  310.         arg2, arg3, arg4);
  311.  
  312.     if (callid == IPC_CALLRET_TEMPORARY) {
  313.         if (!call) {
  314.             call = ipc_prepare_async(private, callback);
  315.             if (!call)
  316.                 return;
  317.         }
  318.         IPC_SET_METHOD(call->u.msg.data, method);
  319.         IPC_SET_ARG1(call->u.msg.data, arg1);
  320.         IPC_SET_ARG2(call->u.msg.data, arg2);
  321.         IPC_SET_ARG3(call->u.msg.data, arg3);
  322.         IPC_SET_ARG4(call->u.msg.data, arg4);
  323.         /*
  324.          * To achieve deterministic behavior, we always zero out the
  325.          * arguments that are beyond the limits of the fast version.
  326.          */
  327.         IPC_SET_ARG5(call->u.msg.data, 0);
  328.     }
  329.     ipc_finish_async(callid, phoneid, call, can_preempt);
  330. }
  331.  
  332. /** Make an asynchronous call transmitting the entire payload.
  333.  *
  334.  * Note that this function is a void function.
  335.  * During normal opertation, answering this call will trigger the callback.
  336.  * In case of fatal error, call the callback handler with the proper error code.
  337.  * If the call cannot be temporarily made, queue it.
  338.  *
  339.  * @param phoneid   Phone handle for the call.
  340.  * @param method    Requested method.
  341.  * @param arg1      Service-defined payload argument.
  342.  * @param arg2      Service-defined payload argument.
  343.  * @param arg3      Service-defined payload argument.
  344.  * @param arg4      Service-defined payload argument.
  345.  * @param arg5      Service-defined payload argument.
  346.  * @param private   Argument to be passed to the answer/error callback.
  347.  * @param callback  Answer or error callback.
  348.  * @param can_preempt   If non-zero, the current fibril will be preempted in
  349.  *          case the kernel temporarily refuses to accept more
  350.  *          asynchronous calls.
  351.  *
  352.  */
  353. void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
  354.     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private,
  355.     ipc_async_callback_t callback, int can_preempt)
  356. {
  357.     async_call_t *call;
  358.     ipc_callid_t callid;
  359.  
  360.     call = ipc_prepare_async(private, callback);
  361.     if (!call)
  362.         return;
  363.  
  364.     IPC_SET_METHOD(call->u.msg.data, method);
  365.     IPC_SET_ARG1(call->u.msg.data, arg1);
  366.     IPC_SET_ARG2(call->u.msg.data, arg2);
  367.     IPC_SET_ARG3(call->u.msg.data, arg3);
  368.     IPC_SET_ARG4(call->u.msg.data, arg4);
  369.     IPC_SET_ARG5(call->u.msg.data, arg5);
  370.     /*
  371.      * We need to make sure that we get callid before another thread
  372.      * accesses the queue again.
  373.      */
  374.     futex_down(&ipc_futex);
  375.     callid = _ipc_call_async(phoneid, &call->u.msg.data);
  376.  
  377.     ipc_finish_async(callid, phoneid, call, can_preempt);
  378. }
  379.  
  380.  
  381. /** Answer a received call - fast version.
  382.  *
  383.  * The fast answer makes use of passing retval and first four arguments in
  384.  * registers. If you need to return more, use the ipc_answer_slow() instead.
  385.  *
  386.  * @param callid    Hash of the call being answered.
  387.  * @param retval    Return value.
  388.  * @param arg1      First return argument.
  389.  * @param arg2      Second return argument.
  390.  * @param arg3      Third return argument.
  391.  * @param arg4      Fourth return argument.
  392.  *
  393.  * @return      Zero on success or a value from @ref errno.h on failure.
  394.  */
  395. ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
  396.     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4)
  397. {
  398.     return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3,
  399.         arg4);
  400. }
  401.  
  402. /** Answer a received call - slow full version.
  403.  *
  404.  * @param callid    Hash of the call being answered.
  405.  * @param retval    Return value.
  406.  * @param arg1      First return argument.
  407.  * @param arg2      Second return argument.
  408.  * @param arg3      Third return argument.
  409.  * @param arg4      Fourth return argument.
  410.  * @param arg5      Fifth return argument.
  411.  *
  412.  * @return      Zero on success or a value from @ref errno.h on failure.
  413.  */
  414. ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
  415.     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5)
  416. {
  417.     ipc_call_t data;
  418.  
  419.     IPC_SET_RETVAL(data, retval);
  420.     IPC_SET_ARG1(data, arg1);
  421.     IPC_SET_ARG2(data, arg2);
  422.     IPC_SET_ARG3(data, arg3);
  423.     IPC_SET_ARG4(data, arg4);
  424.     IPC_SET_ARG5(data, arg5);
  425.  
  426.     return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data);
  427. }
  428.  
  429.  
  430. /** Try to dispatch queued calls from the async queue. */
  431. static void try_dispatch_queued_calls(void)
  432. {
  433.     async_call_t *call;
  434.     ipc_callid_t callid;
  435.  
  436.     /** @todo
  437.      * Integrate intelligently ipc_futex, so that it is locked during
  438.      * ipc_call_async_*(), until it is added to dispatched_calls.
  439.      */
  440.     futex_down(&async_futex);
  441.     while (!list_empty(&queued_calls)) {
  442.         call = list_get_instance(queued_calls.next, async_call_t, list);
  443.         callid = _ipc_call_async(call->u.msg.phoneid,
  444.             &call->u.msg.data);
  445.         if (callid == IPC_CALLRET_TEMPORARY) {
  446.             break;
  447.         }
  448.         list_remove(&call->list);
  449.  
  450.         futex_up(&async_futex);
  451.         if (call->fid)
  452.             fibril_add_ready(call->fid);
  453.        
  454.         if (callid == IPC_CALLRET_FATAL) {
  455.             if (call->callback)
  456.                 call->callback(call->private, ENOENT, NULL);
  457.             free(call);
  458.         } else {
  459.             call->u.callid = callid;
  460.             futex_down(&ipc_futex);
  461.             list_append(&call->list, &dispatched_calls);
  462.             futex_up(&ipc_futex);
  463.         }
  464.         futex_down(&async_futex);
  465.     }
  466.     futex_up(&async_futex);
  467. }
  468.  
  469. /** Handle a received answer.
  470.  *
  471.  * Find the hash of the answer and call the answer callback.
  472.  *
  473.  * @todo Make it use hash table.
  474.  *
  475.  * @param callid    Hash of the received answer.
  476.  *          The answer has the same hash as the request OR'ed with
  477.  *          the IPC_CALLID_ANSWERED bit.
  478.  * @param data      Call data of the answer.
  479.  */
  480. static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
  481. {
  482.     link_t *item;
  483.     async_call_t *call;
  484.  
  485.     callid &= ~IPC_CALLID_ANSWERED;
  486.    
  487.     futex_down(&ipc_futex);
  488.     for (item = dispatched_calls.next; item != &dispatched_calls;
  489.         item = item->next) {
  490.         call = list_get_instance(item, async_call_t, list);
  491.         if (call->u.callid == callid) {
  492.             list_remove(&call->list);
  493.             futex_up(&ipc_futex);
  494.             if (call->callback)
  495.                 call->callback(call->private,
  496.                     IPC_GET_RETVAL(*data), data);
  497.             free(call);
  498.             return;
  499.         }
  500.     }
  501.     futex_up(&ipc_futex);
  502. }
  503.  
  504.  
  505. /** Wait for a first call to come.
  506.  *
  507.  * @param call      Storage where the incoming call data will be stored.
  508.  * @param usec      Timeout in microseconds
  509.  * @param flags     Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
  510.  *
  511.  * @return      Hash of the call. Note that certain bits have special
  512.  *          meaning. IPC_CALLID_ANSWERED will be set in an answer
  513.  *          and IPC_CALLID_NOTIFICATION is used for notifications.
  514.  *         
  515.  */
  516. ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
  517. {
  518.     ipc_callid_t callid;
  519.  
  520.     callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
  521.     /* Handle received answers */
  522.     if (callid & IPC_CALLID_ANSWERED) {
  523.         handle_answer(callid, call);
  524.         try_dispatch_queued_calls();
  525.     }
  526.  
  527.     return callid;
  528. }
  529.  
  530. /** Wait some time for an IPC call.
  531.  *
  532.  * The call will return after an answer is received.
  533.  *
  534.  * @param call      Storage where the incoming call data will be stored.
  535.  * @param usec      Timeout in microseconds.
  536.  *
  537.  * @return      Hash of the answer.
  538.  */
  539. ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
  540. {
  541.     ipc_callid_t callid;
  542.  
  543.     do {
  544.         callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
  545.     } while (callid & IPC_CALLID_ANSWERED);
  546.  
  547.     return callid;
  548. }
  549.  
  550. /** Check if there is an IPC call waiting to be picked up.
  551.  *
  552.  * @param call      Storage where the incoming call will be stored.
  553.  * @return      Hash of the answer.
  554.  */
  555. ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
  556. {
  557.     ipc_callid_t callid;
  558.  
  559.     do {
  560.         callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT,
  561.             SYNCH_FLAGS_NON_BLOCKING);
  562.     } while (callid & IPC_CALLID_ANSWERED);
  563.  
  564.     return callid;
  565. }
  566.  
  567. /** Ask destination to do a callback connection.
  568.  *
  569.  * @param phoneid   Phone handle used for contacting the other side.
  570.  * @param arg1      Service-defined argument.
  571.  * @param arg2      Service-defined argument.
  572.  * @param arg3      Service-defined argument.
  573.  * @param phonehash Storage where the library will store an opaque
  574.  *          identifier of the phone that will be used for incoming
  575.  *          calls. This identifier can be used for connection
  576.  *          tracking.
  577.  *
  578.  * @return      Zero on success or a negative error code.
  579.  */
  580. int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
  581.     ipcarg_t *phonehash)
  582. {
  583.     return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
  584.         arg3, NULL, NULL, NULL, NULL, phonehash);
  585. }
  586.  
  587. /** Ask through phone for a new connection to some service.
  588.  *
  589.  * @param phoneid   Phone handle used for contacting the other side.
  590.  * @param arg1      User defined argument.
  591.  * @param arg2      User defined argument.
  592.  * @param arg3      User defined argument.
  593.  *
  594.  * @return      New phone handle on success or a negative error code.
  595.  */
  596. int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3)
  597. {
  598.     ipcarg_t newphid;
  599.     int res;
  600.  
  601.     res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
  602.         NULL, NULL, NULL, NULL, &newphid);
  603.     if (res)
  604.         return res;
  605.     return newphid;
  606. }
  607.  
  608. /** Hang up a phone.
  609.  *
  610.  * @param phoneid   Handle of the phone to be hung up.
  611.  *
  612.  * @return      Zero on success or a negative error code.
  613.  */
  614. int ipc_hangup(int phoneid)
  615. {
  616.     return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
  617. }
  618.  
  619. /** Register IRQ notification.
  620.  *
  621.  * @param inr       IRQ number.
  622.  * @param devno     Device number of the device generating inr.
  623.  * @param method    Use this method for notifying me.
  624.  * @param ucode     Top-half pseudocode handler.
  625.  *
  626.  * @return      Value returned by the kernel.
  627.  */
  628. int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode)
  629. {
  630.     return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method,
  631.         (sysarg_t) ucode);
  632. }
  633.  
  634. /** Unregister IRQ notification.
  635.  *
  636.  * @param inr       IRQ number.
  637.  * @param devno     Device number of the device generating inr.
  638.  *
  639.  * @return      Value returned by the kernel.
  640.  */
  641. int ipc_unregister_irq(int inr, int devno)
  642. {
  643.     return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
  644. }
  645.  
  646. /** Forward a received call to another destination.
  647.  *
  648.  * @param callid    Hash of the call to forward.
  649.  * @param phoneid   Phone handle to use for forwarding.
  650.  * @param method    New method for the forwarded call.
  651.  * @param arg1      New value of the first argument for the forwarded call.
  652.  * @param arg2      New value of the second argument for the forwarded call.
  653.  * @param mode      Flags specifying mode of the forward operation.
  654.  *
  655.  * @return      Zero on success or an error code.
  656.  *
  657.  * For non-system methods, the old method, arg1 and arg2 are rewritten by the
  658.  * new values. For system methods, the new method, arg1 and arg2 are written
  659.  * to the old arg1, arg2 and arg3, respectivelly. Calls with immutable
  660.  * methods are forwarded verbatim.
  661.  */
  662. int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method,
  663.     ipcarg_t arg1, ipcarg_t arg2, int mode)
  664. {
  665.     return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1,
  666.         arg2, mode);
  667. }
  668.  
  669. /** Wrapper for making IPC_M_SHARE_IN calls.
  670.  *
  671.  * @param phoneid   Phone that will be used to contact the receiving side.
  672.  * @param dst       Destination address space area base.
  673.  * @param size      Size of the destination address space area.
  674.  * @param arg       User defined argument.
  675.  * @param flags     Storage where the received flags will be stored. Can be
  676.  *          NULL.
  677.  *
  678.  * @return      Zero on success or a negative error code from errno.h.
  679.  */
  680. int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
  681.     int *flags)
  682. {
  683.     int res;
  684.     sysarg_t tmp_flags;
  685.     res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
  686.         (ipcarg_t) size, arg, NULL, &tmp_flags);
  687.     if (flags)
  688.         *flags = tmp_flags;
  689.     return res;
  690. }
  691.  
  692. /** Wrapper for receiving the IPC_M_SHARE_IN calls.
  693.  *
  694.  * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN calls
  695.  * so that the user doesn't have to remember the meaning of each IPC argument.
  696.  *
  697.  * So far, this wrapper is to be used from within a connection fibril.
  698.  *
  699.  * @param callid    Storage where the hash of the IPC_M_SHARE_IN call will
  700.  *          be stored.
  701.  * @param size      Destination address space area size.   
  702.  *
  703.  * @return      Non-zero on success, zero on failure.
  704.  */
  705. int ipc_share_in_receive(ipc_callid_t *callid, size_t *size)
  706. {
  707.     ipc_call_t data;
  708.    
  709.     assert(callid);
  710.     assert(size);
  711.  
  712.     *callid = async_get_call(&data);
  713.     if (IPC_GET_METHOD(data) != IPC_M_SHARE_IN)
  714.         return 0;
  715.     *size = (size_t) IPC_GET_ARG2(data);
  716.     return 1;
  717. }
  718.  
  719. /** Wrapper for answering the IPC_M_SHARE_IN calls.
  720.  *
  721.  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
  722.  * so that the user doesn't have to remember the meaning of each IPC argument.
  723.  *
  724.  * @param callid    Hash of the IPC_M_DATA_READ call to answer.
  725.  * @param src       Source address space base.
  726.  * @param flags     Flags to be used for sharing. Bits can be only cleared.
  727.  *
  728.  * @return      Zero on success or a value from @ref errno.h on failure.
  729.  */
  730. int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags)
  731. {
  732.     return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) flags);
  733. }
  734.  
  735. /** Wrapper for making IPC_M_SHARE_OUT calls.
  736.  *
  737.  * @param phoneid   Phone that will be used to contact the receiving side.
  738.  * @param src       Source address space area base address.
  739.  * @param flags     Flags to be used for sharing. Bits can be only cleared.
  740.  *
  741.  * @return      Zero on success or a negative error code from errno.h.
  742.  */
  743. int ipc_share_out_start(int phoneid, void *src, int flags)
  744. {
  745.     return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
  746.         (ipcarg_t) flags);
  747. }
  748.  
  749. /** Wrapper for receiving the IPC_M_SHARE_OUT calls.
  750.  *
  751.  * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT calls
  752.  * so that the user doesn't have to remember the meaning of each IPC argument.
  753.  *
  754.  * So far, this wrapper is to be used from within a connection fibril.
  755.  *
  756.  * @param callid    Storage where the hash of the IPC_M_SHARE_OUT call will
  757.  *          be stored.
  758.  * @param size      Storage where the source address space area size will be
  759.  *          stored.
  760.  * @param flags     Storage where the sharing flags will be stored.
  761.  *
  762.  * @return      Non-zero on success, zero on failure.
  763.  */
  764. int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags)
  765. {
  766.     ipc_call_t data;
  767.    
  768.     assert(callid);
  769.     assert(size);
  770.     assert(flags);
  771.  
  772.     *callid = async_get_call(&data);
  773.     if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT)
  774.         return 0;
  775.     *size = (size_t) IPC_GET_ARG2(data);
  776.     *flags = (int) IPC_GET_ARG3(data);
  777.     return 1;
  778. }
  779.  
  780. /** Wrapper for answering the IPC_M_SHARE_OUT calls.
  781.  *
  782.  * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls
  783.  * so that the user doesn't have to remember the meaning of each IPC argument.
  784.  *
  785.  * @param callid    Hash of the IPC_M_DATA_WRITE call to answer.
  786.  * @param dst       Destination address space area base address.   
  787.  *
  788.  * @return      Zero on success or a value from @ref errno.h on failure.
  789.  */
  790. int ipc_share_out_finalize(ipc_callid_t callid, void *dst)
  791. {
  792.     return ipc_answer_1(callid, EOK, (ipcarg_t) dst);
  793. }
  794.  
  795.  
  796. /** Wrapper for making IPC_M_DATA_READ calls.
  797.  *
  798.  * @param phoneid   Phone that will be used to contact the receiving side.
  799.  * @param dst       Address of the beginning of the destination buffer.
  800.  * @param size      Size of the destination buffer.
  801.  *
  802.  * @return      Zero on success or a negative error code from errno.h.
  803.  */
  804. int ipc_data_read_start(int phoneid, void *dst, size_t size)
  805. {
  806.     return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
  807.         (ipcarg_t) size);
  808. }
  809.  
  810. /** Wrapper for receiving the IPC_M_DATA_READ calls.
  811.  *
  812.  * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ calls
  813.  * so that the user doesn't have to remember the meaning of each IPC argument.
  814.  *
  815.  * So far, this wrapper is to be used from within a connection fibril.
  816.  *
  817.  * @param callid    Storage where the hash of the IPC_M_DATA_READ call will
  818.  *          be stored.
  819.  * @param size      Storage where the maximum size will be stored. Can be
  820.  *          NULL.
  821.  *
  822.  * @return      Non-zero on success, zero on failure.
  823.  */
  824. int ipc_data_read_receive(ipc_callid_t *callid, size_t *size)
  825. {
  826.     ipc_call_t data;
  827.    
  828.     assert(callid);
  829.  
  830.     *callid = async_get_call(&data);
  831.     if (IPC_GET_METHOD(data) != IPC_M_DATA_READ)
  832.         return 0;
  833.     if (size)
  834.         *size = (size_t) IPC_GET_ARG2(data);
  835.     return 1;
  836. }
  837.  
  838. /** Wrapper for answering the IPC_M_DATA_READ calls.
  839.  *
  840.  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
  841.  * so that the user doesn't have to remember the meaning of each IPC argument.
  842.  *
  843.  * @param callid    Hash of the IPC_M_DATA_READ call to answer.
  844.  * @param src       Source address for the IPC_M_DATA_READ call.
  845.  * @param size      Size for the IPC_M_DATA_READ call. Can be smaller than
  846.  *          the maximum size announced by the sender.
  847.  *
  848.  * @return      Zero on success or a value from @ref errno.h on failure.
  849.  */
  850. int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
  851. {
  852.     return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size);
  853. }
  854.  
  855. /** Wrapper for making IPC_M_DATA_WRITE calls.
  856.  *
  857.  * @param phoneid   Phone that will be used to contact the receiving side.
  858.  * @param src       Address of the beginning of the source buffer.
  859.  * @param size      Size of the source buffer.
  860.  *
  861.  * @return      Zero on success or a negative error code from errno.h.
  862.  */
  863. int ipc_data_write_start(int phoneid, const void *src, size_t size)
  864. {
  865.     return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
  866.         (ipcarg_t) size);
  867. }
  868.  
  869. /** Wrapper for receiving the IPC_M_DATA_WRITE calls.
  870.  *
  871.  * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE calls
  872.  * so that the user doesn't have to remember the meaning of each IPC argument.
  873.  *
  874.  * So far, this wrapper is to be used from within a connection fibril.
  875.  *
  876.  * @param callid    Storage where the hash of the IPC_M_DATA_WRITE call will
  877.  *          be stored.
  878.  * @param size      Storage where the suggested size will be stored. May be
  879.  *          NULL
  880.  *
  881.  * @return      Non-zero on success, zero on failure.
  882.  */
  883. int ipc_data_write_receive(ipc_callid_t *callid, size_t *size)
  884. {
  885.     ipc_call_t data;
  886.    
  887.     assert(callid);
  888.  
  889.     *callid = async_get_call(&data);
  890.     if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
  891.         return 0;
  892.     if (size)
  893.         *size = (size_t) IPC_GET_ARG2(data);
  894.     return 1;
  895. }
  896.  
  897. /** Wrapper for answering the IPC_M_DATA_WRITE calls.
  898.  *
  899.  * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls
  900.  * so that the user doesn't have to remember the meaning of each IPC argument.
  901.  *
  902.  * @param callid    Hash of the IPC_M_DATA_WRITE call to answer.
  903.  * @param dst       Final destination address for the IPC_M_DATA_WRITE call.
  904.  * @param size      Final size for the IPC_M_DATA_WRITE call.
  905.  *
  906.  * @return      Zero on success or a value from @ref errno.h on failure.
  907.  */
  908. int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
  909. {
  910.     return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size);
  911. }
  912.  
  913. #include <kernel/syscall/sysarg64.h>
  914. /** Connect to a task specified by id.
  915.  */
  916. int ipc_connect_kbox(task_id_t id)
  917. {
  918.     sysarg64_t arg;
  919.  
  920.     arg.value = (unsigned long long) id;
  921.  
  922.     return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg);
  923. }
  924.  
  925. /** @}
  926.  */
  927.