Subversion Repositories HelenOS-historic

Rev

Rev 1086 | Rev 1090 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1072 palkovsky 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
1086 palkovsky 39 
 * - hangup phone (the caller has hung up)
40 
 * - hangup phone (the answerbox is exiting)
1072 palkovsky 41 
 *
1084 palkovsky 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 
 *
1086 palkovsky 63 
 * Destroying is less frequent, this approach is taken.
1084 palkovsky 64 
 *
1086 palkovsky 65 
 * Phone hangup
66 
 *
67 
 * *** The caller hangs up (sys_ipc_hangup) ***
68 
 * - The phone is disconnected (no more messages can be sent over this phone),
69 
 *   all in-progress messages are correctly handled. The anwerbox receives
70 
 *   IPC_M_PHONE_HUNGUP call from the phone that hung up. When all async
71 
 *   calls are answered, the phone is deallocated.
1084 palkovsky 72 
 *
1088 palkovsky 73 
 * *** The answerbox hangs up (ipc_answer(EHANGUP))
74 
 * - The phone is disconnected. EHANGUP response code is sent
75 
 *   to the calling process. All new calls through this phone
76 
 *   get a EHUNGUP error code, the task is expected to
1086 palkovsky 77 
 *   send an sys_ipc_hangup after cleaning up it's internal structures.
78 
 *
1088 palkovsky 79 
 * Call forwarding
80 
 *
81 
 * The call can be forwarded, so that the answer to call is passed directly
82 
 * to the original sender. However, this poses special problems regarding
83 
 * routing of hangup messages.
84 
 *
85 
 * sys_ipc_hangup -> IPC_M_PHONE_HUNGUP
86 
 * - this message CANNOT be forwarded
87 
 *
88 
 * EHANGUP during forward
89 
 * - The *forwarding* phone will be closed, EFORWARD is sent to receiver.
90 
 *
91 
 * EHANGUP, ENOENT during forward
92 
 * - EFORWARD is sent to the receiver, ipc_forward returns error code EFORWARD
93 
 *
1084 palkovsky 94 
 * Cleanup strategy
1072 palkovsky 95 
 *
1088 palkovsky 96 
 * 1) Disconnect all our phones ('ipc_phone_hangup').
1086 palkovsky 97 
 *
98 
 * 2) Disconnect all phones connected to answerbox.
1084 palkovsky 99 
 *
1086 palkovsky 100 
 * 3) Answer all messages in 'calls' and 'dispatched_calls' queues with
1088 palkovsky 101 
 *    appropriate error code (EHANGUP, EFORWARD).
1084 palkovsky 102 
 *
1088 palkovsky 103 
 * 4) Wait for all async answers to arrive.
1084 palkovsky 104 
 *
1072 palkovsky 105 
 */
106 
 
107 
#include <synch/spinlock.h>
108 
#include <ipc/ipc.h>
109 
#include <arch.h>
110 
#include <proc/task.h>
111 
#include <ipc/ipcrsc.h>
112 
#include <debug.h>
113 
 
114 
/** Find call_t * in call table according to callid
115 
 *
116 
 * @return NULL on not found, otherwise pointer to call structure
117 
 */
118 
call_t * get_call(__native callid)
119 
{
120 
    /* TODO: Traverse list of dispatched calls and find one */
121 
    /* TODO: locking of call, ripping it from dispatched calls etc.  */
122 
    return (call_t *) callid;
123 
}
124 
 
125 
/** Allocate new phone slot in current TASK structure */
126 
int phone_alloc(void)
127 
{
128 
    int i;
129 
 
130 
    spinlock_lock(&TASK->lock);
131 
 
132 
    for (i=0; i < IPC_MAX_PHONES; i++) {
1088 palkovsky 133 
        if (TASK->phones[i].busy==IPC_BUSY_FREE && !atomic_get(&TASK->phones[i].active_calls)) {
134 
            TASK->phones[i].busy = IPC_BUSY_CONNECTING;
1072 palkovsky 135 
            break;
136 
        }
137 
    }
138 
    spinlock_unlock(&TASK->lock);
139 
 
140 
    if (i >= IPC_MAX_PHONES)
141 
        return -1;
142 
    return i;
143 
}
144 
 
1086 palkovsky 145 
/** Disconnect phone a free the slot
146 
 *
147 
 * All already sent messages will be correctly processed
148 
 */
1072 palkovsky 149 
void phone_dealloc(int phoneid)
150 
{
151 
    spinlock_lock(&TASK->lock);
152 
 
1088 palkovsky 153 
    ASSERT(TASK->phones[phoneid].busy == IPC_BUSY_CONNECTING);
1086 palkovsky 154 
    ASSERT(! TASK->phones[phoneid].callee);
1072 palkovsky 155 
 
1088 palkovsky 156 
    TASK->phones[phoneid].busy = IPC_BUSY_FREE;
1072 palkovsky 157 
    spinlock_unlock(&TASK->lock);
158 
}
159 
 
1084 palkovsky 160 
/** Connect phone to a given answerbox
161 
 *
162 
 * @param phoneid The slot that will be connected
163 
 *
164 
 * The procedure _enforces_ that the user first marks the phone
165 
 * busy (e.g. via phone_alloc) and then connects the phone, otherwise
166 
 * race condition may appear.
167 
 */
1072 palkovsky 168 
void phone_connect(int phoneid, answerbox_t *box)
169 
{
170 
    phone_t *phone = &TASK->phones[phoneid];
171 
 
1088 palkovsky 172 
    ASSERT(phone->busy == IPC_BUSY_CONNECTING);
1072 palkovsky 173 
    ipc_phone_connect(phone, box);
174 
}