2 * Copyright (C) 2006 Ondrej Palkovsky
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
31 * First the answerbox, then the phone
34 #include <synch/spinlock.h>
35 #include <synch/waitq.h>
36 #include <synch/synch.h>
41 #include <proc/task.h>
46 #include <proc/thread.h>
47 #include <arch/interrupt.h>
50 /* Open channel that is assigned automatically to new tasks */
51 answerbox_t
*ipc_phone_0
= NULL
;
53 static slab_cache_t
*ipc_call_slab
;
55 /* Initialize new call */
56 static void _ipc_call_init(call_t
*call
)
58 memsetb((__address
)call
, sizeof(*call
), 0);
59 call
->callerbox
= &TASK
->answerbox
;
63 /** Allocate & initialize call structure
65 * The call is initialized, so that the reply will be directed
68 * @param flags Parameters for slab_alloc (ATOMIC, etc.)
70 call_t
* ipc_call_alloc(int flags
)
74 call
= slab_alloc(ipc_call_slab
, flags
);
80 /** Initialize allocated call */
81 void ipc_call_static_init(call_t
*call
)
84 call
->flags
|= IPC_CALL_STATIC_ALLOC
;
87 /** Deallocate call stracuture */
88 void ipc_call_free(call_t
*call
)
90 slab_free(ipc_call_slab
, call
);
93 /** Initialize answerbox structure
95 void ipc_answerbox_init(answerbox_t
*box
)
97 spinlock_initialize(&box
->lock
, "ipc_box_lock");
98 spinlock_initialize(&box
->irq_lock
, "ipc_box_irqlock");
99 waitq_initialize(&box
->wq
);
100 list_initialize(&box
->connected_phones
);
101 list_initialize(&box
->calls
);
102 list_initialize(&box
->dispatched_calls
);
103 list_initialize(&box
->answers
);
104 list_initialize(&box
->irq_notifs
);
108 /** Connect phone to answerbox */
109 void ipc_phone_connect(phone_t
*phone
, answerbox_t
*box
)
111 spinlock_lock(&phone
->lock
);
113 ASSERT(!phone
->callee
);
114 phone
->busy
= IPC_BUSY_CONNECTED
;
117 spinlock_lock(&box
->lock
);
118 list_append(&phone
->list
, &box
->connected_phones
);
119 spinlock_unlock(&box
->lock
);
121 spinlock_unlock(&phone
->lock
);
124 /** Initialize phone structure and connect phone to answerbox
126 void ipc_phone_init(phone_t
*phone
)
128 spinlock_initialize(&phone
->lock
, "phone_lock");
129 phone
->callee
= NULL
;
130 phone
->busy
= IPC_BUSY_FREE
;
131 atomic_set(&phone
->active_calls
, 0);
134 /** Helper function to facilitate synchronous calls */
135 void ipc_call_sync(phone_t
*phone
, call_t
*request
)
137 answerbox_t sync_box
;
139 ipc_answerbox_init(&sync_box
);
141 /* We will receive data on special box */
142 request
->callerbox
= &sync_box
;
144 ipc_call(phone
, request
);
145 ipc_wait_for_call(&sync_box
, SYNCH_NO_TIMEOUT
, SYNCH_BLOCKING
);
148 /** Answer message that was not dispatched and is not entered in
151 static void _ipc_answer_free_call(call_t
*call
)
153 answerbox_t
*callerbox
= call
->callerbox
;
155 call
->flags
|= IPC_CALL_ANSWERED
;
157 spinlock_lock(&callerbox
->lock
);
158 list_append(&call
->list
, &callerbox
->answers
);
159 spinlock_unlock(&callerbox
->lock
);
160 waitq_wakeup(&callerbox
->wq
, 0);
163 /** Answer message, that is in callee queue
165 * @param box Answerbox that is answering the message
166 * @param call Modified request that is being sent back
168 void ipc_answer(answerbox_t
*box
, call_t
*call
)
170 /* Remove from active box */
171 spinlock_lock(&box
->lock
);
172 list_remove(&call
->list
);
173 spinlock_unlock(&box
->lock
);
174 /* Send back answer */
175 _ipc_answer_free_call(call
);
178 /** Simulate sending back a message
180 * Most errors are better handled by forming a normal backward
181 * message and sending it as a normal answer.
183 void ipc_backsend_err(phone_t
*phone
, call_t
*call
, __native err
)
185 call
->data
.phone
= phone
;
186 atomic_inc(&phone
->active_calls
);
187 if (phone
->busy
== IPC_BUSY_CONNECTED
)
188 IPC_SET_RETVAL(call
->data
, EHANGUP
);
190 IPC_SET_RETVAL(call
->data
, ENOENT
);
192 _ipc_answer_free_call(call
);
195 /* Unsafe unchecking ipc_call */
196 static void _ipc_call(phone_t
*phone
, answerbox_t
*box
, call_t
*call
)
198 if (! (call
->flags
& IPC_CALL_FORWARDED
)) {
199 atomic_inc(&phone
->active_calls
);
200 call
->data
.phone
= phone
;
203 spinlock_lock(&box
->lock
);
204 list_append(&call
->list
, &box
->calls
);
205 spinlock_unlock(&box
->lock
);
206 waitq_wakeup(&box
->wq
, 0);
209 /** Send a asynchronous request using phone to answerbox
211 * @param phone Phone connected to answerbox
212 * @param request Request to be sent
214 int ipc_call(phone_t
*phone
, call_t
*call
)
218 spinlock_lock(&phone
->lock
);
222 /* Trying to send over disconnected phone */
223 spinlock_unlock(&phone
->lock
);
224 if (call
->flags
& IPC_CALL_FORWARDED
) {
225 IPC_SET_RETVAL(call
->data
, EFORWARD
);
226 _ipc_answer_free_call(call
);
227 } else { /* Simulate sending back a message */
228 if (phone
->busy
== IPC_BUSY_CONNECTED
)
229 ipc_backsend_err(phone
, call
, EHANGUP
);
231 ipc_backsend_err(phone
, call
, ENOENT
);
236 _ipc_call(phone
, box
, call
);
238 spinlock_unlock(&phone
->lock
);
242 /** Disconnect phone from answerbox
244 * It is allowed to call disconnect on already disconnected phone
246 * @return 0 - phone disconnected, -1 - the phone was already disconnected
248 int ipc_phone_hangup(phone_t
*phone
)
253 spinlock_lock(&phone
->lock
);
256 if (phone
->busy
== IPC_BUSY_CONNECTING
) {
257 spinlock_unlock(&phone
->lock
);
260 /* Already disconnected phone */
261 phone
->busy
= IPC_BUSY_FREE
;
262 spinlock_unlock(&phone
->lock
);
266 spinlock_lock(&box
->lock
);
267 list_remove(&phone
->list
);
268 phone
->callee
= NULL
;
269 spinlock_unlock(&box
->lock
);
271 call
= ipc_call_alloc(0);
272 IPC_SET_METHOD(call
->data
, IPC_M_PHONE_HUNGUP
);
273 call
->flags
|= IPC_CALL_DISCARD_ANSWER
;
274 _ipc_call(phone
, box
, call
);
276 phone
->busy
= IPC_BUSY_FREE
;
278 spinlock_unlock(&phone
->lock
);
283 /** Forwards call from one answerbox to a new one
285 * @param call Call to be redirected.
286 * @param newphone Phone to target answerbox.
287 * @param oldbox Old answerbox
288 * @return 0 on forward ok, error code, if there was error
290 * - the return value serves only as an information for the forwarder,
291 * the original caller is notified automatically with EFORWARD
293 int ipc_forward(call_t
*call
, phone_t
*newphone
, answerbox_t
*oldbox
)
295 spinlock_lock(&oldbox
->lock
);
296 list_remove(&call
->list
);
297 spinlock_unlock(&oldbox
->lock
);
299 return ipc_call(newphone
, call
);
303 /** Wait for phone call
305 * @param box Answerbox expecting the call.
306 * @param usec Timeout in microseconds. See documentation for waitq_sleep_timeout() for
307 * decription of its special meaning.
308 * @param nonblocking Blocking vs. non-blocking operation mode switch. See documentation
309 * for waitq_sleep_timeout() for description of its special meaning.
310 * @return Recived message address
311 * - to distinguish between call and answer, look at call->flags
313 call_t
* ipc_wait_for_call(answerbox_t
*box
, __u32 usec
, int nonblocking
)
320 rc
= waitq_sleep_timeout(&box
->wq
, usec
, nonblocking
);
321 if (SYNCH_FAILED(rc
))
324 spinlock_lock(&box
->lock
);
325 if (!list_empty(&box
->irq_notifs
)) {
326 ipl
= interrupts_disable();
327 spinlock_lock(&box
->irq_lock
);
329 request
= list_get_instance(box
->irq_notifs
.next
, call_t
, list
);
330 list_remove(&request
->list
);
332 spinlock_unlock(&box
->irq_lock
);
333 interrupts_restore(ipl
);
334 } else if (!list_empty(&box
->answers
)) {
335 /* Handle asynchronous answers */
336 request
= list_get_instance(box
->answers
.next
, call_t
, list
);
337 list_remove(&request
->list
);
338 atomic_dec(&request
->data
.phone
->active_calls
);
339 } else if (!list_empty(&box
->calls
)) {
340 /* Handle requests */
341 request
= list_get_instance(box
->calls
.next
, call_t
, list
);
342 list_remove(&request
->list
);
343 /* Append request to dispatch queue */
344 list_append(&request
->list
, &box
->dispatched_calls
);
346 /* This can happen regularly after ipc_cleanup, remove
347 * the warning in the future when the IPC is
349 printf("WARNING: Spurious IPC wakeup.\n");
350 spinlock_unlock(&box
->lock
);
353 spinlock_unlock(&box
->lock
);
357 /** Answer all calls from list with EHANGUP msg */
358 static void ipc_cleanup_call_list(link_t
*lst
)
362 while (!list_empty(lst
)) {
363 call
= list_get_instance(lst
->next
, call_t
, list
);
364 list_remove(&call
->list
);
366 IPC_SET_RETVAL(call
->data
, EHANGUP
);
367 _ipc_answer_free_call(call
);
371 /** Cleans up all IPC communication of the given task
375 void ipc_cleanup(task_t
*task
)
381 /* Disconnect all our phones ('ipc_phone_hangup') */
382 for (i
=0;i
< IPC_MAX_PHONES
; i
++)
383 ipc_phone_hangup(&task
->phones
[i
]);
385 /* Disconnect all connected irqs */
386 ipc_irq_cleanup(&task
->answerbox
);
388 /* Disconnect all phones connected to our answerbox */
390 spinlock_lock(&task
->answerbox
.lock
);
391 while (!list_empty(&task
->answerbox
.connected_phones
)) {
392 phone
= list_get_instance(task
->answerbox
.connected_phones
.next
,
395 if (! spinlock_trylock(&phone
->lock
)) {
396 spinlock_unlock(&task
->answerbox
.lock
);
400 /* Disconnect phone */
401 phone
->callee
= NULL
;
402 list_remove(&phone
->list
);
404 spinlock_unlock(&phone
->lock
);
407 /* Answer all messages in 'calls' and 'dispatched_calls' queues */
408 spinlock_lock(&task
->answerbox
.lock
);
409 ipc_cleanup_call_list(&task
->answerbox
.dispatched_calls
);
410 ipc_cleanup_call_list(&task
->answerbox
.calls
);
411 spinlock_unlock(&task
->answerbox
.lock
);
413 /* Wait for all async answers to arrive */
414 while (atomic_get(&task
->active_calls
)) {
415 call
= ipc_wait_for_call(&task
->answerbox
, SYNCH_NO_TIMEOUT
, SYNCH_BLOCKING
);
416 ASSERT((call
->flags
& IPC_CALL_ANSWERED
) || (call
->flags
& IPC_CALL_NOTIF
));
417 ASSERT(! (call
->flags
& IPC_CALL_STATIC_ALLOC
));
419 atomic_dec(&task
->active_calls
);
425 /** Initilize ipc subsystem */
428 ipc_call_slab
= slab_cache_create("ipc_call",
432 ipc_irq_make_table(IRQ_COUNT
);