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