Subversion Repositories HelenOS-historic

Rev

Rev 1653 | 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 <psthread.h>
  53.  
  54. /** Structure used for keeping track of sent async msgs
  55.  * and queing unsent msgs
  56.  *
  57.  */
  58. typedef struct {
  59.     link_t list;
  60.  
  61.     ipc_async_callback_t callback;
  62.     void *private;
  63.     union {
  64.         ipc_callid_t callid;
  65.         struct {
  66.             ipc_call_t data;
  67.             int phoneid;
  68.         } msg;
  69.     }u;
  70.     pstid_t ptid;   /**< Thread waiting for sending this msg */
  71. } async_call_t;
  72.  
  73. LIST_INITIALIZE(dispatched_calls);
  74.  
  75. /* queued_calls is protcted by async_futex, because if the
  76.  * call cannot be sent into kernel, async framework is used
  77.  * automatically
  78.  */
  79. LIST_INITIALIZE(queued_calls); /**< List of async calls that were not accepted
  80.                 *   by kernel */
  81.  
  82. static atomic_t ipc_futex = FUTEX_INITIALIZER;
  83.  
  84. int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
  85.           ipcarg_t *result)
  86. {
  87.     ipc_call_t resdata;
  88.     int callres;
  89.    
  90.     callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
  91.                  (sysarg_t)&resdata);
  92.     if (callres)
  93.         return callres;
  94.     if (result)
  95.         *result = IPC_GET_ARG1(resdata);
  96.     return IPC_GET_RETVAL(resdata);
  97. }
  98.  
  99. int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
  100.             ipcarg_t arg2, ipcarg_t arg3,
  101.             ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3)
  102. {
  103.     ipc_call_t data;
  104.     int callres;
  105.  
  106.     IPC_SET_METHOD(data, method);
  107.     IPC_SET_ARG1(data, arg1);
  108.     IPC_SET_ARG2(data, arg2);
  109.     IPC_SET_ARG3(data, arg3);
  110.  
  111.     callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,
  112.                  (sysarg_t)&data);
  113.     if (callres)
  114.         return callres;
  115.  
  116.     if (result1)
  117.         *result1 = IPC_GET_ARG1(data);
  118.     if (result2)
  119.         *result2 = IPC_GET_ARG2(data);
  120.     if (result3)
  121.         *result3 = IPC_GET_ARG3(data);
  122.     return IPC_GET_RETVAL(data);
  123. }
  124.  
  125. /** Syscall to send asynchronous message */
  126. static  ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
  127. {
  128.     return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);
  129. }
  130.  
  131. /** Prolog to ipc_async_send functions */
  132. static inline async_call_t *ipc_prepare_async(void *private, ipc_async_callback_t callback)
  133. {
  134.     async_call_t *call;
  135.  
  136.     call = malloc(sizeof(*call));
  137.     if (!call) {
  138.         if (callback)
  139.             callback(private, ENOMEM, NULL);
  140.         return NULL;
  141.     }
  142.     call->callback = callback;
  143.     call->private = private;
  144.  
  145.     return call;
  146. }
  147.  
  148. /** Epilogue of ipc_async_send functions */
  149. static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
  150.                     async_call_t *call, int can_preempt)
  151. {
  152.     if (callid == IPC_CALLRET_FATAL) {
  153.         futex_up(&ipc_futex);
  154.         /* Call asynchronous handler with error code */
  155.         if (call->callback)
  156.             call->callback(call->private, ENOENT, NULL);
  157.         free(call);
  158.         return;
  159.     }
  160.  
  161.     if (callid == IPC_CALLRET_TEMPORARY) {
  162.         futex_up(&ipc_futex);
  163.  
  164.         call->u.msg.phoneid = phoneid;
  165.        
  166.         futex_down(&async_futex);
  167.         list_append(&call->list, &queued_calls);
  168.  
  169.         if (can_preempt) {
  170.             call->ptid = psthread_get_id();
  171.             psthread_schedule_next_adv(PS_TO_MANAGER);
  172.             /* Async futex unlocked by previous call */
  173.         } else {
  174.             call->ptid = 0;
  175.             futex_up(&async_futex);
  176.         }
  177.         return;
  178.     }
  179.     call->u.callid = callid;
  180.     /* Add call to list of dispatched calls */
  181.     list_append(&call->list, &dispatched_calls);
  182.     futex_up(&ipc_futex);
  183.    
  184. }
  185.  
  186. /** Send asynchronous message
  187.  *
  188.  * - if fatal error, call callback handler with proper error code
  189.  * - if message cannot be temporarily sent, add to queue
  190.  */
  191. void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
  192.               ipcarg_t arg2, void *private,
  193.               ipc_async_callback_t callback, int can_preempt)
  194. {
  195.     async_call_t *call;
  196.     ipc_callid_t callid;
  197.  
  198.     call = ipc_prepare_async(private, callback);
  199.     if (!call)
  200.         return;
  201.  
  202.     /* We need to make sure that we get callid before
  203.      * another thread accesses the queue again */
  204.     futex_down(&ipc_futex);
  205.     callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
  206.  
  207.     if (callid == IPC_CALLRET_TEMPORARY) {
  208.         IPC_SET_METHOD(call->u.msg.data, method);
  209.         IPC_SET_ARG1(call->u.msg.data, arg1);
  210.         IPC_SET_ARG2(call->u.msg.data, arg2);
  211.     }
  212.     ipc_finish_async(callid, phoneid, call, can_preempt);
  213. }
  214.  
  215. /** Send asynchronous message
  216.  *
  217.  * - if fatal error, call callback handler with proper error code
  218.  * - if message cannot be temporarily sent, add to queue
  219.  */
  220. void ipc_call_async_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
  221.               ipcarg_t arg2, ipcarg_t arg3, void *private,
  222.               ipc_async_callback_t callback, int can_preempt)
  223. {
  224.     async_call_t *call;
  225.     ipc_callid_t callid;
  226.  
  227.     call = ipc_prepare_async(private, callback);
  228.     if (!call)
  229.         return;
  230.  
  231.     IPC_SET_METHOD(call->u.msg.data, method);
  232.     IPC_SET_ARG1(call->u.msg.data, arg1);
  233.     IPC_SET_ARG2(call->u.msg.data, arg2);
  234.     IPC_SET_ARG3(call->u.msg.data, arg3);
  235.     /* We need to make sure that we get callid before
  236.      * another thread accesses the queue again */
  237.     futex_down(&ipc_futex);
  238.     callid = _ipc_call_async(phoneid, &call->u.msg.data);
  239.  
  240.     ipc_finish_async(callid, phoneid, call, can_preempt);
  241. }
  242.  
  243.  
  244. /** Send a fast answer to a received call.
  245.  *
  246.  * The fast answer makes use of passing retval and first two arguments in registers.
  247.  * If you need to return more, use the ipc_answer() instead.
  248.  *
  249.  * @param callid ID of the call being answered.
  250.  * @param retval Return value.
  251.  * @param arg1 First return argument.
  252.  * @param arg2 Second return argument.
  253.  *
  254.  * @return Zero on success or a value from @ref errno.h on failure.
  255.  */
  256. ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
  257.         ipcarg_t arg2)
  258. {
  259.     return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
  260. }
  261.  
  262. /** Send a full answer to a received call.
  263.  *
  264.  * @param callid ID of the call being answered.
  265.  * @param call Call data. Must be already initialized by the responder.
  266.  *
  267.  * @return Zero on success or a value from @ref errno.h on failure.
  268.  */
  269. ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
  270. {
  271.     return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
  272. }
  273.  
  274.  
  275. /** Try to dispatch queed calls from async queue */
  276. static void try_dispatch_queued_calls(void)
  277. {
  278.     async_call_t *call;
  279.     ipc_callid_t callid;
  280.  
  281.     /* TODO: integrate intelligently ipc_futex, so that it
  282.      * is locked during ipc_call_async, until it is added
  283.      * to dispatched_calls
  284.      */
  285.     futex_down(&async_futex);
  286.     while (!list_empty(&queued_calls)) {
  287.         call = list_get_instance(queued_calls.next, async_call_t,
  288.                      list);
  289.  
  290.         callid = _ipc_call_async(call->u.msg.phoneid,
  291.                      &call->u.msg.data);
  292.         if (callid == IPC_CALLRET_TEMPORARY) {
  293.             break;
  294.         }
  295.         list_remove(&call->list);
  296.  
  297.         futex_up(&async_futex);
  298.         if (call->ptid)
  299.             psthread_add_ready(call->ptid);
  300.        
  301.         if (callid == IPC_CALLRET_FATAL) {
  302.             if (call->callback)
  303.                 call->callback(call->private, ENOENT, NULL);
  304.             free(call);
  305.         } else {
  306.             call->u.callid = callid;
  307.             futex_down(&ipc_futex);
  308.             list_append(&call->list, &dispatched_calls);
  309.             futex_up(&ipc_futex);
  310.         }
  311.         futex_down(&async_futex);
  312.     }
  313.     futex_up(&async_futex);
  314. }
  315.  
  316. /** Handle received answer
  317.  *
  318.  * TODO: Make it use hash table
  319.  *
  320.  * @param callid Callid (with first bit set) of the answered call
  321.  */
  322. static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
  323. {
  324.     link_t *item;
  325.     async_call_t *call;
  326.  
  327.     callid &= ~IPC_CALLID_ANSWERED;
  328.    
  329.     futex_down(&ipc_futex);
  330.     for (item = dispatched_calls.next; item != &dispatched_calls;
  331.          item = item->next) {
  332.         call = list_get_instance(item, async_call_t, list);
  333.         if (call->u.callid == callid) {
  334.             list_remove(&call->list);
  335.             futex_up(&ipc_futex);
  336.             if (call->callback)
  337.                 call->callback(call->private,
  338.                            IPC_GET_RETVAL(*data),
  339.                            data);
  340.             free(call);
  341.             return;
  342.         }
  343.     }
  344.     futex_up(&ipc_futex);
  345.     printf("Received unidentified answer: %P!!!\n", callid);
  346. }
  347.  
  348.  
  349. /** One cycle of ipc wait for call call
  350.  *
  351.  * - dispatch ASYNC reoutines in the background
  352.  * @param call Space where the message is stored
  353.  * @param usec Timeout in microseconds
  354.  * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking)
  355.  * @return Callid of the answer.
  356.  */
  357. ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
  358. {
  359.     ipc_callid_t callid;
  360.  
  361.     callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
  362.     /* Handle received answers */
  363.     if (callid & IPC_CALLID_ANSWERED) {
  364.         handle_answer(callid, call);
  365.         try_dispatch_queued_calls();
  366.     }
  367.  
  368.     return callid;
  369. }
  370.  
  371. /** Wait some time for an IPC call.
  372.  *
  373.  * - dispatch ASYNC reoutines in the background
  374.  *
  375.  * @param call Space where the message is stored
  376.  * @param usec Timeout in microseconds.
  377.  * @return Callid of the answer.
  378.  */
  379. ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
  380. {
  381.     ipc_callid_t callid;
  382.  
  383.     do {
  384.         callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
  385.     } while (callid & IPC_CALLID_ANSWERED);
  386.  
  387.     return callid;
  388. }
  389.  
  390. /** Check if there is an IPC call waiting to be picked up.
  391.  *
  392.  * - dispatch ASYNC reoutines in the background
  393.  *
  394.  * @param call Space where the message is stored
  395.  * @return Callid of the answer.
  396.  */
  397. ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
  398. {
  399.     ipc_callid_t callid;
  400.  
  401.     do {
  402.         callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
  403.     } while (callid & IPC_CALLID_ANSWERED);
  404.  
  405.     return callid;
  406. }
  407.  
  408. /** Ask destination to do a callback connection
  409.  *
  410.  * @return 0 - OK, error code
  411.  */
  412. int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)
  413. {
  414.     return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,
  415.                    arg2, 0, 0, 0, phone);
  416. }
  417.  
  418. /** Ask through phone for a new connection to some service
  419.  *
  420.  * @return new phoneid - OK, error code
  421.  */
  422. int ipc_connect_me_to(int phoneid, int arg1, int arg2)
  423. {
  424.     ipcarg_t newphid;
  425.     int res;
  426.  
  427.     res =  ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,
  428.                    arg2, 0, 0, 0, &newphid);
  429.     if (res)
  430.         return res;
  431.     return newphid;
  432. }
  433.  
  434. /* Hang up specified phone */
  435. int ipc_hangup(int phoneid)
  436. {
  437.     return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
  438. }
  439.  
  440. int ipc_register_irq(int irq, irq_code_t *ucode)
  441. {
  442.     return __SYSCALL2(SYS_IPC_REGISTER_IRQ, irq, (sysarg_t) ucode);
  443. }
  444.  
  445. int ipc_unregister_irq(int irq)
  446. {
  447.     return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq);
  448. }
  449.  
  450. int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1)
  451. {
  452.     return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1);
  453. }
  454.  
  455.  
  456.  
  457.  /** @}
  458.  */
  459.  
  460.  
  461.