Subversion Repositories HelenOS

Rev

Rev 1089 | Rev 1092 | 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. #include <ipc.h>
  30. #include <libc.h>
  31. #include <malloc.h>
  32. #include <errno.h>
  33. #include <list.h>
  34. #include <stdio.h>
  35. #include <unistd.h>
  36.  
  37. /** Structure used for keeping track of sent async msgs
  38.  * and queing unsent msgs
  39.  *
  40.  */
  41. typedef struct {
  42.     link_t list;
  43.  
  44.     ipc_async_callback_t callback;
  45.     void *private;
  46.     union {
  47.         ipc_callid_t callid;
  48.         struct {
  49.             ipc_call_t data;
  50.             int phoneid;
  51.         } msg;
  52.     }u;
  53. } async_call_t;
  54.  
  55. LIST_INITIALIZE(dispatched_calls);
  56. LIST_INITIALIZE(queued_calls);
  57.  
  58. int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
  59.           ipcarg_t *result)
  60. {
  61.     ipc_call_t resdata;
  62.     int callres;
  63.    
  64.     callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
  65.                  (sysarg_t)&resdata);
  66.     if (callres)
  67.         return callres;
  68.     if (result)
  69.         *result = IPC_GET_ARG1(resdata);
  70.     return IPC_GET_RETVAL(resdata);
  71. }
  72.  
  73. int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
  74.             ipcarg_t arg2, ipcarg_t arg3,
  75.             ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3)
  76. {
  77.     ipc_call_t data;
  78.     int callres;
  79.  
  80.     IPC_SET_METHOD(data, method);
  81.     IPC_SET_ARG1(data, arg1);
  82.     IPC_SET_ARG2(data, arg2);
  83.     IPC_SET_ARG3(data, arg3);
  84.  
  85.     callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,
  86.                  (sysarg_t)&data);
  87.     if (callres)
  88.         return callres;
  89.  
  90.     if (result1)
  91.         *result1 = IPC_GET_ARG1(data);
  92.     if (result2)
  93.         *result2 = IPC_GET_ARG2(data);
  94.     if (result3)
  95.         *result3 = IPC_GET_ARG3(data);
  96.     return IPC_GET_RETVAL(data);
  97. }
  98.  
  99. /** Syscall to send asynchronous message */
  100. static  ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
  101. {
  102.     return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);
  103. }
  104.  
  105. /** Send asynchronous message
  106.  *
  107.  * - if fatal error, call callback handler with proper error code
  108.  * - if message cannot be temporarily sent, add to queue
  109.  */
  110. void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
  111.               ipcarg_t arg2, void *private,
  112.               ipc_async_callback_t callback)
  113. {
  114.     async_call_t *call;
  115.     ipc_callid_t callid;
  116.  
  117.     call = malloc(sizeof(*call));
  118.     if (!call) {
  119.         callback(private, ENOMEM, NULL);
  120.         return;
  121.     }
  122.        
  123.     callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
  124.     if (callid == IPC_CALLRET_FATAL) {
  125.         /* Call asynchronous handler with error code */
  126.         callback(private, ENOENT, NULL);
  127.         free(call);
  128.         return;
  129.     }
  130.  
  131.     call->callback = callback;
  132.     call->private = private;
  133.  
  134.     if (callid == IPC_CALLRET_TEMPORARY) {
  135.         /* Add asynchronous call to queue of non-dispatched async calls */
  136.         call->u.msg.phoneid = phoneid;
  137.         IPC_SET_METHOD(call->u.msg.data, method);
  138.         IPC_SET_ARG1(call->u.msg.data, arg1);
  139.         IPC_SET_ARG2(call->u.msg.data, arg2);
  140.  
  141.         list_append(&call->list, &queued_calls);
  142.         return;
  143.     }
  144.     call->u.callid = callid;
  145.     /* Add call to list of dispatched calls */
  146.     list_append(&call->list, &dispatched_calls);
  147. }
  148.  
  149.  
  150. /** Send answer to a received call */
  151. void ipc_answer(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
  152.         ipcarg_t arg2)
  153. {
  154.     __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
  155. }
  156.  
  157. /** Try to dispatch queed calls from async queue */
  158. static void try_dispatch_queued_calls(void)
  159. {
  160.     async_call_t *call;
  161.     ipc_callid_t callid;
  162.  
  163.     while (!list_empty(&queued_calls)) {
  164.         call = list_get_instance(queued_calls.next, async_call_t,
  165.                      list);
  166.  
  167.         callid = _ipc_call_async(call->u.msg.phoneid,
  168.                      &call->u.msg.data);
  169.         if (callid == IPC_CALLRET_TEMPORARY)
  170.             break;
  171.         list_remove(&call->list);
  172.         if (callid == IPC_CALLRET_FATAL) {
  173.             call->callback(call->private, ENOENT, NULL);
  174.             free(call);
  175.         } else {
  176.             call->u.callid = callid;
  177.             list_append(&call->list, &dispatched_calls);
  178.         }
  179.     }
  180. }
  181.  
  182. /** Handle received answer
  183.  *
  184.  * TODO: Make it use hash table
  185.  *
  186.  * @param callid Callid (with first bit set) of the answered call
  187.  */
  188. static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
  189. {
  190.     link_t *item;
  191.     async_call_t *call;
  192.  
  193.     callid &= ~IPC_CALLID_ANSWERED;
  194.    
  195.     for (item = dispatched_calls.next; item != &dispatched_calls;
  196.          item = item->next) {
  197.         call = list_get_instance(item, async_call_t, list);
  198.         if (call->u.callid == callid) {
  199.             list_remove(&call->list);
  200.             call->callback(call->private,
  201.                        IPC_GET_RETVAL(*data),
  202.                        data);
  203.             return;
  204.         }
  205.     }
  206.     printf("Received unidentified answer: %P!!!\n", callid);
  207. }
  208.  
  209.  
  210. /** Wait for IPC call and return
  211.  *
  212.  * - dispatch ASYNC reoutines in the background
  213.  * @param data Space where the message is stored
  214.  * @return Callid or 0 if nothing available and started with
  215.  *         IPC_WAIT_NONBLOCKING
  216.  */
  217. ipc_callid_t ipc_wait_for_call(ipc_call_t *call, int flags)
  218. {
  219.     ipc_callid_t callid;
  220.  
  221.     do {
  222.         try_dispatch_queued_calls();
  223.  
  224.         callid = __SYSCALL2(SYS_IPC_WAIT, (sysarg_t)call, flags);
  225.         /* Handle received answers */
  226.         if (callid & IPC_CALLID_ANSWERED)
  227.             handle_answer(callid, call);
  228.     } while (callid & IPC_CALLID_ANSWERED);
  229.  
  230.     return callid;
  231. }
  232.  
  233. /** Ask destination to do a callback connection
  234.  *
  235.  * @return 0 - OK, error code
  236.  */
  237. int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)
  238. {
  239.     return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,
  240.                    arg2, 0, 0, 0, phone);
  241. }
  242.  
  243. /** Ask through phone for a new connection to some service
  244.  *
  245.  * @return new phoneid - OK, error code
  246.  */
  247. int ipc_connect_me_to(int phoneid, int arg1, int arg2)
  248. {
  249.     int newphid;
  250.     int res;
  251.  
  252.     res =  ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,
  253.                    arg2, 0, 0, 0, &newphid);
  254.     if (res)
  255.         return res;
  256.     return newphid;
  257. }
  258.  
  259. /* Hang up specified phone */
  260. int ipc_hangup(int phoneid)
  261. {
  262.     return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
  263. }
  264.