Subversion Repositories HelenOS-historic

Rev

Rev 1088 | Rev 1568 | 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. /* IPC resources management
  30.  *
  31.  * The goal of this source code is to properly manage IPC resources
  32.  * and allow straight and clean clean-up procedure upon task termination.
  33.  *
  34.  * The pattern of usage of the resources is:
  35.  * - allocate empty phone slot, connect | deallocate slot
  36.  * - disconnect connected phone (some messages might be on the fly)
  37.  * - find phone in slot and send a message using phone
  38.  * - answer message to phone
  39.  * - hangup phone (the caller has hung up)
  40.  * - hangup phone (the answerbox is exiting)
  41.  *
  42.  * Locking strategy
  43.  *
  44.  * - To use a phone, disconnect a phone etc., the phone must be
  45.  *   first locked and then checked that it is connected
  46.  * - To connect an allocated phone it need not be locked (assigning
  47.  *   pointer is atomic on all platforms)
  48.  *
  49.  * - To find an empty phone slot, the TASK must be locked
  50.  * - To answer a message, the answerbox must be locked
  51.  * - The locking of phone and answerbox is done at the ipc_ level.
  52.  *   It is perfectly correct to pass unconnected phone to these functions
  53.  *   and proper reply will be generated.
  54.  *
  55.  * Locking order
  56.  *
  57.  * - first phone, then answerbox
  58.  *   + Easy locking on calls
  59.  *   - Very hard traversing list of phones when disconnecting because
  60.  *     the phones may disconnect during traversal of list of connected phones.
  61.  *     The only possibility is try_lock with restart of list traversal.
  62.  *
  63.  * Destroying is less frequent, this approach is taken.
  64.  *
  65.  * Phone call
  66.  *
  67.  * *** Connect_me_to ***
  68.  * The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server
  69.  * receives 'phoneid' of the connecting phone as an ARG3. If it answers
  70.  * with RETVAL=0, the phonecall is accepted, otherwise it is refused.
  71.  *
  72.  * *** Connect_to_me ***
  73.  * The caller sends IPC_M_CONNECT_TO_ME, with special
  74.  * The server receives an automatically
  75.  * opened phoneid. If it accepts (RETVAL=0), it can use the phoneid
  76.  * immediately.
  77.  * Possible race condition can arise, when the client receives messages
  78.  * from new connection before getting response for connect_to_me message.
  79.  * Userspace should implement handshake protocol that would control it.
  80.  *
  81.  * Phone hangup
  82.  *
  83.  * *** The caller hangs up (sys_ipc_hangup) ***
  84.  * - The phone is disconnected (no more messages can be sent over this phone),
  85.  *   all in-progress messages are correctly handled. The anwerbox receives
  86.  *   IPC_M_PHONE_HUNGUP call from the phone that hung up. When all async
  87.  *   calls are answered, the phone is deallocated.
  88.  *
  89.  * *** The answerbox hangs up (ipc_answer(EHANGUP))
  90.  * - The phone is disconnected. EHANGUP response code is sent
  91.  *   to the calling process. All new calls through this phone
  92.  *   get a EHUNGUP error code, the task is expected to
  93.  *   send an sys_ipc_hangup after cleaning up it's internal structures.
  94.  *
  95.  * Call forwarding
  96.  *
  97.  * The call can be forwarded, so that the answer to call is passed directly
  98.  * to the original sender. However, this poses special problems regarding
  99.  * routing of hangup messages.
  100.  *
  101.  * sys_ipc_hangup -> IPC_M_PHONE_HUNGUP
  102.  * - this message CANNOT be forwarded
  103.  *
  104.  * EHANGUP during forward
  105.  * - The *forwarding* phone will be closed, EFORWARD is sent to receiver.
  106.  *
  107.  * EHANGUP, ENOENT during forward
  108.  * - EFORWARD is sent to the receiver, ipc_forward returns error code EFORWARD
  109.  *
  110.  * Cleanup strategy
  111.  *
  112.  * 1) Disconnect all our phones ('ipc_phone_hangup').
  113.  *
  114.  * 2) Disconnect all phones connected to answerbox.
  115.  *
  116.  * 3) Answer all messages in 'calls' and 'dispatched_calls' queues with
  117.  *    appropriate error code (EHANGUP, EFORWARD).
  118.  *
  119.  * 4) Wait for all async answers to arrive and dispose of them.
  120.  *
  121.  */
  122.  
  123. #include <synch/spinlock.h>
  124. #include <ipc/ipc.h>
  125. #include <arch.h>
  126. #include <proc/task.h>
  127. #include <ipc/ipcrsc.h>
  128. #include <debug.h>
  129.  
  130. /** Find call_t * in call table according to callid
  131.  *
  132.  * @return NULL on not found, otherwise pointer to call structure
  133.  */
  134. call_t * get_call(__native callid)
  135. {
  136.     /* TODO: Traverse list of dispatched calls and find one */
  137.     /* TODO: locking of call, ripping it from dispatched calls etc.  */
  138.     return (call_t *) callid;
  139. }
  140.  
  141. /** Allocate new phone slot in current TASK structure */
  142. int phone_alloc(void)
  143. {
  144.     int i;
  145.  
  146.     spinlock_lock(&TASK->lock);
  147.    
  148.     for (i=0; i < IPC_MAX_PHONES; i++) {
  149.         if (TASK->phones[i].busy==IPC_BUSY_FREE && !atomic_get(&TASK->phones[i].active_calls)) {
  150.             TASK->phones[i].busy = IPC_BUSY_CONNECTING;
  151.             break;
  152.         }
  153.     }
  154.     spinlock_unlock(&TASK->lock);
  155.  
  156.     if (i >= IPC_MAX_PHONES)
  157.         return -1;
  158.     return i;
  159. }
  160.  
  161. static void phone_deallocp(phone_t *phone)
  162. {
  163.     ASSERT(phone->busy == IPC_BUSY_CONNECTING);
  164.     ASSERT(! phone->callee);
  165.    
  166.     /* atomic operation */
  167.     phone->busy = IPC_BUSY_FREE;
  168. }
  169.  
  170. /** Free slot from a disconnected phone
  171.  *
  172.  * All already sent messages will be correctly processed
  173.  */
  174. void phone_dealloc(int phoneid)
  175. {
  176.     phone_deallocp(&TASK->phones[phoneid]);
  177. }
  178.  
  179. /** Connect phone to a given answerbox
  180.  *
  181.  * @param phoneid The slot that will be connected
  182.  *
  183.  * The procedure _enforces_ that the user first marks the phone
  184.  * busy (e.g. via phone_alloc) and then connects the phone, otherwise
  185.  * race condition may appear.
  186.  */
  187. void phone_connect(int phoneid, answerbox_t *box)
  188. {
  189.     phone_t *phone = &TASK->phones[phoneid];
  190.    
  191.     ASSERT(phone->busy == IPC_BUSY_CONNECTING);
  192.     ipc_phone_connect(phone, box);
  193. }
  194.