| 0,0 → 1,232 |
|---|
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** @addtogroup genericipc |
| * @{ |
| */ |
| /** @file |
| */ |
| |
| /* IPC resources management |
| * |
| * The goal of this source code is to properly manage IPC resources and allow |
| * straight and clean clean-up procedure upon task termination. |
| * |
| * The pattern of usage of the resources is: |
| * - allocate empty phone slot, connect | deallocate slot |
| * - disconnect connected phone (some messages might be on the fly) |
| * - find phone in slot and send a message using phone |
| * - answer message to phone |
| * - hangup phone (the caller has hung up) |
| * - hangup phone (the answerbox is exiting) |
| * |
| * Locking strategy |
| * |
| * - To use a phone, disconnect a phone etc., the phone must be first locked and |
| * then checked that it is connected |
| * - To connect an allocated phone it need not be locked (assigning pointer is |
| * atomic on all platforms) |
| * |
| * - To find an empty phone slot, the TASK must be locked |
| * - To answer a message, the answerbox must be locked |
| * - The locking of phone and answerbox is done at the ipc_ level. |
| * It is perfectly correct to pass unconnected phone to these functions and |
| * proper reply will be generated. |
| * |
| * Locking order |
| * |
| * - first phone, then answerbox |
| * + Easy locking on calls |
| * - Very hard traversing list of phones when disconnecting because the phones |
| * may disconnect during traversal of list of connected phones. The only |
| * possibility is try_lock with restart of list traversal. |
| * |
| * Destroying is less frequent, this approach is taken. |
| * |
| * Phone call |
| * |
| * *** Connect_me_to *** |
| * The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server receives |
| * 'phoneid' of the connecting phone as an ARG5. If it answers with RETVAL=0, |
| * the phonecall is accepted, otherwise it is refused. |
| * |
| * *** Connect_to_me *** |
| * The caller sends IPC_M_CONNECT_TO_ME. |
| * The server receives an automatically opened phoneid. If it accepts |
| * (RETVAL=0), it can use the phoneid immediately. |
| * Possible race condition can arise, when the client receives messages from new |
| * connection before getting response for connect_to_me message. Userspace |
| * should implement handshake protocol that would control it. |
| * |
| * Phone hangup |
| * |
| * *** The caller hangs up (sys_ipc_hangup) *** |
| * - The phone is disconnected (no more messages can be sent over this phone), |
| * all in-progress messages are correctly handled. The answerbox receives |
| * IPC_M_PHONE_HUNGUP call from the phone that hung up. When all async |
| * calls are answered, the phone is deallocated. |
| * |
| * *** The answerbox hangs up (ipc_answer(EHANGUP)) |
| * - The phone is disconnected. EHANGUP response code is sent |
| * to the calling task. All new calls through this phone |
| * get a EHUNGUP error code, the task is expected to |
| * send an sys_ipc_hangup after cleaning up its internal structures. |
| * |
| * Call forwarding |
| * |
| * The call can be forwarded, so that the answer to call is passed directly |
| * to the original sender. However, this poses special problems regarding |
| * routing of hangup messages. |
| * |
| * sys_ipc_hangup -> IPC_M_PHONE_HUNGUP |
| * - this message CANNOT be forwarded |
| * |
| * EHANGUP during forward |
| * - The *forwarding* phone will be closed, EFORWARD is sent to receiver. |
| * |
| * EHANGUP, ENOENT during forward |
| * - EFORWARD is sent to the receiver, ipc_forward returns error code EFORWARD |
| * |
| * Cleanup strategy |
| * |
| * 1) Disconnect all our phones ('ipc_phone_hangup'). |
| * |
| * 2) Disconnect all phones connected to answerbox. |
| * |
| * 3) Answer all messages in 'calls' and 'dispatched_calls' queues with |
| * appropriate error code (EHANGUP, EFORWARD). |
| * |
| * 4) Wait for all async answers to arrive and dispose of them. |
| * |
| */ |
| |
| #include <synch/spinlock.h> |
| #include <ipc/ipc.h> |
| #include <arch.h> |
| #include <proc/task.h> |
| #include <ipc/ipcrsc.h> |
| #include <debug.h> |
| |
| /** Find call_t * in call table according to callid. |
| * |
| * @todo Some speedup (hash table?) |
| * |
| * @param callid Userspace hash of the call. Currently it is the call |
| * structure kernel address. |
| * |
| * @return NULL on not found, otherwise pointer to the call |
| * structure. |
| */ |
| call_t *get_call(unative_t callid) |
| { |
| link_t *lst; |
| call_t *call, *result = NULL; |
| |
| spinlock_lock(&TASK->answerbox.lock); |
| for (lst = TASK->answerbox.dispatched_calls.next; |
| lst != &TASK->answerbox.dispatched_calls; lst = lst->next) { |
| call = list_get_instance(lst, call_t, link); |
| if ((unative_t) call == callid) { |
| result = call; |
| break; |
| } |
| } |
| spinlock_unlock(&TASK->answerbox.lock); |
| return result; |
| } |
| |
| /** Allocate new phone slot in the current TASK structure. |
| * |
| * @return New phone handle or -1 if the phone handle limit is |
| * exceeded. |
| */ |
| int phone_alloc(void) |
| { |
| int i; |
| |
| spinlock_lock(&TASK->lock); |
| |
| for (i = 0; i < IPC_MAX_PHONES; i++) { |
| if (TASK->phones[i].state == IPC_PHONE_HUNGUP && |
| atomic_get(&TASK->phones[i].active_calls) == 0) |
| TASK->phones[i].state = IPC_PHONE_FREE; |
| |
| if (TASK->phones[i].state == IPC_PHONE_FREE) { |
| TASK->phones[i].state = IPC_PHONE_CONNECTING; |
| break; |
| } |
| } |
| spinlock_unlock(&TASK->lock); |
| |
| if (i >= IPC_MAX_PHONES) |
| return -1; |
| return i; |
| } |
| |
| /** Mark a phone structure free. |
| * |
| * @param phone Phone structure to be marked free. |
| */ |
| static void phone_deallocp(phone_t *phone) |
| { |
| ASSERT(phone->state == IPC_PHONE_CONNECTING); |
| |
| /* atomic operation */ |
| phone->state = IPC_PHONE_FREE; |
| } |
| |
| /** Free slot from a disconnected phone. |
| * |
| * All already sent messages will be correctly processed. |
| * |
| * @param phoneid Phone handle of the phone to be freed. |
| */ |
| void phone_dealloc(int phoneid) |
| { |
| phone_deallocp(&TASK->phones[phoneid]); |
| } |
| |
| /** Connect phone to a given answerbox. |
| * |
| * @param phoneid Phone handle to be connected. |
| * @param box Answerbox to which to connect the phone handle. |
| * |
| * The procedure _enforces_ that the user first marks the phone |
| * busy (e.g. via phone_alloc) and then connects the phone, otherwise |
| * race condition may appear. |
| */ |
| void phone_connect(int phoneid, answerbox_t *box) |
| { |
| phone_t *phone = &TASK->phones[phoneid]; |
| |
| ASSERT(phone->state == IPC_PHONE_CONNECTING); |
| ipc_phone_connect(phone, box); |
| } |
| |
| /** @} |
| */ |