Subversion Repositories HelenOS

Rev

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