Subversion Repositories HelenOS

Rev

Rev 2618 | Rev 2620 | 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.     ipc_finish_async(callid, phoneid, call, can_preempt);
  325. }
  326.  
  327. /** Make an asynchronous call transmitting the entire payload.
  328.  *
  329.  * Note that this function is a void function.
  330.  * During normal opertation, answering this call will trigger the callback.
  331.  * In case of fatal error, call the callback handler with the proper error code.
  332.  * If the call cannot be temporarily made, queue it.
  333.  *
  334.  * @param phoneid   Phone handle for the call.
  335.  * @param method    Requested method.
  336.  * @param arg1      Service-defined payload argument.
  337.  * @param arg2      Service-defined payload argument.
  338.  * @param arg3      Service-defined payload argument.
  339.  * @param arg4      Service-defined payload argument.
  340.  * @param arg5      Service-defined payload argument.
  341.  * @param private   Argument to be passed to the answer/error callback.
  342.  * @param callback  Answer or error callback.
  343.  * @param can_preempt   If non-zero, the current fibril will be preempted in
  344.  *          case the kernel temporarily refuses to accept more
  345.  *          asynchronous calls.
  346.  *
  347.  */
  348. void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
  349.     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private,
  350.     ipc_async_callback_t callback, int can_preempt)
  351. {
  352.     async_call_t *call;
  353.     ipc_callid_t callid;
  354.  
  355.     call = ipc_prepare_async(private, callback);
  356.     if (!call)
  357.         return;
  358.  
  359.     IPC_SET_METHOD(call->u.msg.data, method);
  360.     IPC_SET_ARG1(call->u.msg.data, arg1);
  361.     IPC_SET_ARG2(call->u.msg.data, arg2);
  362.     IPC_SET_ARG3(call->u.msg.data, arg3);
  363.     IPC_SET_ARG4(call->u.msg.data, arg4);
  364.     IPC_SET_ARG5(call->u.msg.data, arg5);
  365.     /*
  366.      * We need to make sure that we get callid before another thread
  367.      * accesses the queue again.
  368.      */
  369.     futex_down(&ipc_futex);
  370.     callid = _ipc_call_async(phoneid, &call->u.msg.data);
  371.  
  372.     ipc_finish_async(callid, phoneid, call, can_preempt);
  373. }
  374.  
  375.  
  376. /** Answer a received call - fast version.
  377.  *
  378.  * The fast answer makes use of passing retval and first four arguments in
  379.  * registers. If you need to return more, use the ipc_answer_slow() instead.
  380.  *
  381.  * @param callid    Hash of the call being answered.
  382.  * @param retval    Return value.
  383.  * @param arg1      First return argument.
  384.  * @param arg2      Second return argument.
  385.  * @param arg3      Third return argument.
  386.  * @param arg4      Fourth return argument.
  387.  *
  388.  * @return      Zero on success or a value from @ref errno.h on failure.
  389.  */
  390. ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
  391.     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4)
  392. {
  393.     return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3,
  394.         arg4);
  395. }
  396.  
  397. /** Answer a received call - slow full version.
  398.  *
  399.  * @param callid    Hash of the call being answered.
  400.  * @param retval    Return value.
  401.  * @param arg1      First return argument.
  402.  * @param arg2      Second return argument.
  403.  * @param arg3      Third return argument.
  404.  * @param arg4      Fourth return argument.
  405.  * @param arg5      Fifth return argument.
  406.  *
  407.  * @return      Zero on success or a value from @ref errno.h on failure.
  408.  */
  409. ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
  410.     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5)
  411. {
  412.     ipc_call_t data;
  413.  
  414.     IPC_SET_RETVAL(data, retval);
  415.     IPC_SET_ARG1(data, arg1);
  416.     IPC_SET_ARG2(data, arg2);
  417.     IPC_SET_ARG3(data, arg3);
  418.     IPC_SET_ARG4(data, arg4);
  419.     IPC_SET_ARG5(data, arg5);
  420.  
  421.     return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data);
  422. }
  423.  
  424.  
  425. /** Try to dispatch queued calls from the async queue. */
  426. static void try_dispatch_queued_calls(void)
  427. {
  428.     async_call_t *call;
  429.     ipc_callid_t callid;
  430.  
  431.     /** @todo
  432.      * Integrate intelligently ipc_futex, so that it is locked during
  433.      * ipc_call_async_*(), until it is added to dispatched_calls.
  434.      */
  435.     futex_down(&async_futex);
  436.     while (!list_empty(&queued_calls)) {
  437.         call = list_get_instance(queued_calls.next, async_call_t, list);
  438.         callid = _ipc_call_async(call->u.msg.phoneid, &call->u.msg.data);
  439.         if (callid == IPC_CALLRET_TEMPORARY) {
  440.             break;
  441.         }
  442.         list_remove(&call->list);
  443.  
  444.         futex_up(&async_futex);
  445.         if (call->fid)
  446.             fibril_add_ready(call->fid);
  447.        
  448.         if (callid == IPC_CALLRET_FATAL) {
  449.             if (call->callback)
  450.                 call->callback(call->private, ENOENT, NULL);
  451.             free(call);
  452.         } else {
  453.             call->u.callid = callid;
  454.             futex_down(&ipc_futex);
  455.             list_append(&call->list, &dispatched_calls);
  456.             futex_up(&ipc_futex);
  457.         }
  458.         futex_down(&async_futex);
  459.     }
  460.     futex_up(&async_futex);
  461. }
  462.  
  463. /** Handle a received answer.
  464.  *
  465.  * Find the hash of the answer and call the answer callback.
  466.  *
  467.  * @todo Make it use hash table.
  468.  *
  469.  * @param callid    Hash of the received answer.
  470.  *          The answer has the same hash as the request OR'ed with
  471.  *          the IPC_CALLID_ANSWERED bit.
  472.  * @param data      Call data of the answer.
  473.  */
  474. static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
  475. {
  476.     link_t *item;
  477.     async_call_t *call;
  478.  
  479.     callid &= ~IPC_CALLID_ANSWERED;
  480.    
  481.     futex_down(&ipc_futex);
  482.     for (item = dispatched_calls.next; item != &dispatched_calls;
  483.         item = item->next) {
  484.         call = list_get_instance(item, async_call_t, list);
  485.         if (call->u.callid == callid) {
  486.             list_remove(&call->list);
  487.             futex_up(&ipc_futex);
  488.             if (call->callback)
  489.                 call->callback(call->private,
  490.                     IPC_GET_RETVAL(*data), data);
  491.             free(call);
  492.             return;
  493.         }
  494.     }
  495.     futex_up(&ipc_futex);
  496. }
  497.  
  498.  
  499. /** Wait for a first call to come.
  500.  *
  501.  * @param call      Storage where the incoming call data will be stored.
  502.  * @param usec      Timeout in microseconds
  503.  * @param flags     Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
  504.  *
  505.  * @return      Hash of the call. Note that certain bits have special
  506.  *          meaning. IPC_CALLID_ANSWERED will be set in an answer
  507.  *          and IPC_CALLID_NOTIFICATION is used for notifications.
  508.  *         
  509.  */
  510. ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
  511. {
  512.     ipc_callid_t callid;
  513.  
  514.     callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
  515.     /* Handle received answers */
  516.     if (callid & IPC_CALLID_ANSWERED) {
  517.         handle_answer(callid, call);
  518.         try_dispatch_queued_calls();
  519.     }
  520.  
  521.     return callid;
  522. }
  523.  
  524. /** Wait some time for an IPC call.
  525.  *
  526.  * The call will return after an answer is received.
  527.  *
  528.  * @param call      Storage where the incoming call data will be stored.
  529.  * @param usec      Timeout in microseconds.
  530.  *
  531.  * @return      Hash of the answer.
  532.  */
  533. ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
  534. {
  535.     ipc_callid_t callid;
  536.  
  537.     do {
  538.         callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
  539.     } while (callid & IPC_CALLID_ANSWERED);
  540.  
  541.     return callid;
  542. }
  543.  
  544. /** Check if there is an IPC call waiting to be picked up.
  545.  *
  546.  * @param call      Storage where the incoming call will be stored.
  547.  * @return      Hash of the answer.
  548.  */
  549. ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
  550. {
  551.     ipc_callid_t callid;
  552.  
  553.     do {
  554.         callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT,
  555.             SYNCH_FLAGS_NON_BLOCKING);
  556.     } while (callid & IPC_CALLID_ANSWERED);
  557.  
  558.     return callid;
  559. }
  560.  
  561. /** Ask destination to do a callback connection.
  562.  *
  563.  * @param phoneid   Phone handle used for contacting the other side.
  564.  * @param arg1      Service-defined argument.
  565.  * @param arg2      Service-defined argument.
  566.  * @param phonehash Storage where the library will store an opaque
  567.  *          identifier of the phone that will be used for incoming
  568.  *          calls. This identifier can be used for connection
  569.  *          tracking.
  570.  *
  571.  * @return      Zero on success or a negative error code.
  572.  */
  573. int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phonehash)
  574. {
  575.     return ipc_call_sync_2_3(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
  576.         NULL, NULL, phonehash);
  577. }
  578.  
  579. /** Ask through phone for a new connection to some service.
  580.  *
  581.  * @param phoneid   Phone handle used for contacting the other side.
  582.  * @param arg1      User defined argument.
  583.  * @param arg2      User defined argument.
  584.  *
  585.  * @return      New phone handle on success or a negative error code.
  586.  */
  587. int ipc_connect_me_to(int phoneid, int arg1, int arg2)
  588. {
  589.     ipcarg_t newphid;
  590.     int res;
  591.  
  592.     res = ipc_call_sync_2_3(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, NULL,
  593.         NULL, &newphid);
  594.     if (res)
  595.         return res;
  596.     return newphid;
  597. }
  598.  
  599. /** Hang up a phone.
  600.  *
  601.  * @param phoneid   Handle of the phone to be hung up.
  602.  *
  603.  * @return      Zero on success or a negative error code.
  604.  */
  605. int ipc_hangup(int phoneid)
  606. {
  607.     return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
  608. }
  609.  
  610. /** Register IRQ notification.
  611.  *
  612.  * @param inr       IRQ number.
  613.  * @param devno     Device number of the device generating inr.
  614.  * @param method    Use this method for notifying me.
  615.  * @param ucode     Top-half pseudocode handler.
  616.  *
  617.  * @return      Value returned by the kernel.
  618.  */
  619. int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode)
  620. {
  621.     return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method,
  622.         (sysarg_t) ucode);
  623. }
  624.  
  625. /** Unregister IRQ notification.
  626.  *
  627.  * @param inr       IRQ number.
  628.  * @param devno     Device number of the device generating inr.
  629.  *
  630.  * @return      Value returned by the kernel.
  631.  */
  632. int ipc_unregister_irq(int inr, int devno)
  633. {
  634.     return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
  635. }
  636.  
  637. /** Forward a received call to another destination.
  638.  *
  639.  * @param callid    Hash of the call to forward.
  640.  * @param phoneid   Phone handle to use for forwarding.
  641.  * @param method    New method for the forwarded call.
  642.  * @param arg1      New value of the first argument for the forwarded call.
  643.  *
  644.  * @return      Zero on success or an error code.
  645.  *
  646.  * For non-system methods, the old method and arg1 are rewritten by the new
  647.  * values. For system methods, the new method and arg1 are written to the old
  648.  * arg1 and arg2, respectivelly.
  649.  */
  650. int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1)
  651. {
  652.     return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1);
  653. }
  654.  
  655. /** Wrapper for making IPC_M_DATA_SEND calls.
  656.  *
  657.  * @param phoneid   Phone that will be used to contact the receiving side.
  658.  * @param src       Address of the beginning of the source buffer.
  659.  * @param size      Size of the source buffer.
  660.  *
  661.  * @return      Zero on success or a negative error code from errno.h.
  662.  */
  663. int ipc_data_send(int phoneid, void *src, size_t size)
  664. {
  665.     return ipc_call_sync_3_0(phoneid, IPC_M_DATA_SEND, 0, (ipcarg_t) src,
  666.         (ipcarg_t) size);
  667. }
  668.  
  669. /** Wrapper for receiving the IPC_M_DATA_SEND calls.
  670.  *
  671.  * This wrapper only makes it more comfortable to receive IPC_M_DATA_SEND calls
  672.  * so that the user doesn't have to remember the meaning of each IPC argument.
  673.  *
  674.  * So far, this wrapper is to be used from within a connection fibril.
  675.  *
  676.  * @param callid    Storage where the hash of the IPC_M_DATA_SEND call will
  677.  *          be stored.
  678.  * @param dst       Storage where the suggested destination address will
  679.  *          be stored. May be NULL.
  680.  * @param size      Storage where the suggested size will be stored. May be
  681.  *          NULL
  682.  *
  683.  * @return      Non-zero on success, zero on failure.
  684.  */
  685. int ipc_data_receive(ipc_callid_t *callid, void **dst, size_t *size)
  686. {
  687.     ipc_call_t data;
  688.    
  689.     assert(callid);
  690.  
  691.     *callid = async_get_call(&data);
  692.     if (IPC_GET_METHOD(data) != IPC_M_DATA_SEND)
  693.         return 0;
  694.     if (dst)
  695.         *dst = (void *) IPC_GET_ARG1(data);
  696.     if (size)
  697.         *size = (size_t) IPC_GET_ARG3(data);
  698.     return 1;
  699. }
  700.  
  701. /** Wrapper for answering the IPC_M_DATA_SEND calls.
  702.  *
  703.  * This wrapper only makes it more comfortable to answer IPC_M_DATA_SEND calls
  704.  * so that the user doesn't have to remember the meaning of each IPC argument.
  705.  *
  706.  * @param callid    Hash of the IPC_M_DATA_SEND call to answer.
  707.  * @param dst       Final destination address for the IPC_M_DATA_SEND call.
  708.  * @param size      Final size for the IPC_M_DATA_SEND call.
  709.  *
  710.  * @return      Zero on success or a value from @ref errno.h on failure.
  711.  */
  712. ipcarg_t ipc_data_deliver(ipc_callid_t callid, void *dst, size_t size)
  713. {
  714.     return ipc_answer_3(callid, EOK, (ipcarg_t) dst, 0, (ipcarg_t) size);
  715. }
  716.  
  717. /** @}
  718.  */
  719.