source: mainline/generic/src/ipc/ipc.c@ 874621f

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 874621f was 874621f, checked in by Ondrej Palkovsky <ondrap@…>, 19 years ago

Added kernel circular buffer klog.
Added automatic killing of tasks raising inappropriate exceptions.
TODO Fix vsnprintf return value(and behaviour according to specs) and remove workaround in klog.
  • Property mode set to 100644
File size: 14.4 KB
Line 
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/* Lock ordering
30 *
31 * First the answerbox, then the phone
32 */
33
34#include <synch/spinlock.h>
35#include <synch/waitq.h>
36#include <synch/synch.h>
37#include <ipc/ipc.h>
38#include <errno.h>
39#include <mm/slab.h>
40#include <arch.h>
41#include <proc/task.h>
42#include <memstr.h>
43#include <debug.h>
44
45#include <print.h>
46#include <proc/thread.h>
47#include <arch/interrupt.h>
48#include <ipc/irq.h>
49
50/* Open channel that is assigned automatically to new tasks */
51answerbox_t *ipc_phone_0 = NULL;
52
53static slab_cache_t *ipc_call_slab;
54
55/* Initialize new call */
56static void _ipc_call_init(call_t *call)
57{
58 memsetb((__address)call, sizeof(*call), 0);
59 call->callerbox = &TASK->answerbox;
60 call->sender = TASK;
61}
62
63/** Allocate & initialize call structure
64 *
65 * The call is initialized, so that the reply will be directed
66 * to TASK->answerbox
67 *
68 * @param flags Parameters for slab_alloc (ATOMIC, etc.)
69 */
70call_t * ipc_call_alloc(int flags)
71{
72 call_t *call;
73
74 call = slab_alloc(ipc_call_slab, flags);
75 _ipc_call_init(call);
76
77 return call;
78}
79
80/** Initialize allocated call */
81void ipc_call_static_init(call_t *call)
82{
83 _ipc_call_init(call);
84 call->flags |= IPC_CALL_STATIC_ALLOC;
85}
86
87/** Deallocate call stracuture */
88void ipc_call_free(call_t *call)
89{
90 slab_free(ipc_call_slab, call);
91}
92
93/** Initialize answerbox structure
94 */
95void ipc_answerbox_init(answerbox_t *box)
96{
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);
105 box->task = TASK;
106}
107
108/** Connect phone to answerbox */
109void ipc_phone_connect(phone_t *phone, answerbox_t *box)
110{
111 spinlock_lock(&phone->lock);
112
113 phone->state = IPC_PHONE_CONNECTED;
114 phone->callee = box;
115
116 spinlock_lock(&box->lock);
117 list_append(&phone->link, &box->connected_phones);
118 spinlock_unlock(&box->lock);
119
120 spinlock_unlock(&phone->lock);
121}
122
123/** Initialize phone structure and connect phone to answerbox
124 */
125void ipc_phone_init(phone_t *phone)
126{
127 spinlock_initialize(&phone->lock, "phone_lock");
128 phone->callee = NULL;
129 phone->state = IPC_PHONE_FREE;
130 atomic_set(&phone->active_calls, 0);
131}
132
133/** Helper function to facilitate synchronous calls */
134void ipc_call_sync(phone_t *phone, call_t *request)
135{
136 answerbox_t sync_box;
137
138 ipc_answerbox_init(&sync_box);
139
140 /* We will receive data on special box */
141 request->callerbox = &sync_box;
142
143 ipc_call(phone, request);
144 ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
145}
146
147/** Answer message that was not dispatched and is not entered in
148 * any queue
149 */
150static void _ipc_answer_free_call(call_t *call)
151{
152 answerbox_t *callerbox = call->callerbox;
153
154 call->flags |= IPC_CALL_ANSWERED;
155
156 spinlock_lock(&callerbox->lock);
157 list_append(&call->link, &callerbox->answers);
158 spinlock_unlock(&callerbox->lock);
159 waitq_wakeup(&callerbox->wq, 0);
160}
161
162/** Answer message, that is in callee queue
163 *
164 * @param box Answerbox that is answering the message
165 * @param call Modified request that is being sent back
166 */
167void ipc_answer(answerbox_t *box, call_t *call)
168{
169 /* Remove from active box */
170 spinlock_lock(&box->lock);
171 list_remove(&call->link);
172 spinlock_unlock(&box->lock);
173 /* Send back answer */
174 _ipc_answer_free_call(call);
175}
176
177/** Simulate sending back a message
178 *
179 * Most errors are better handled by forming a normal backward
180 * message and sending it as a normal answer.
181 */
182void ipc_backsend_err(phone_t *phone, call_t *call, __native err)
183{
184 call->data.phone = phone;
185 atomic_inc(&phone->active_calls);
186 IPC_SET_RETVAL(call->data, err);
187 _ipc_answer_free_call(call);
188}
189
190/* Unsafe unchecking ipc_call */
191static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call)
192{
193 if (! (call->flags & IPC_CALL_FORWARDED)) {
194 atomic_inc(&phone->active_calls);
195 call->data.phone = phone;
196 }
197
198 spinlock_lock(&box->lock);
199 list_append(&call->link, &box->calls);
200 spinlock_unlock(&box->lock);
201 waitq_wakeup(&box->wq, 0);
202}
203
204/** Send a asynchronous request using phone to answerbox
205 *
206 * @param phone Phone connected to answerbox
207 * @param request Request to be sent
208 */
209int ipc_call(phone_t *phone, call_t *call)
210{
211 answerbox_t *box;
212
213 spinlock_lock(&phone->lock);
214 if (phone->state != IPC_PHONE_CONNECTED) {
215 spinlock_unlock(&phone->lock);
216 if (call->flags & IPC_CALL_FORWARDED) {
217 IPC_SET_RETVAL(call->data, EFORWARD);
218 _ipc_answer_free_call(call);
219 } else {
220 if (phone->state == IPC_PHONE_HUNGUP)
221 ipc_backsend_err(phone, call, EHANGUP);
222 else
223 ipc_backsend_err(phone, call, ENOENT);
224 }
225 return ENOENT;
226 }
227 box = phone->callee;
228 _ipc_call(phone, box, call);
229
230 spinlock_unlock(&phone->lock);
231 return 0;
232}
233
234/** Disconnect phone from answerbox
235 *
236 * This call leaves the phone in HUNGUP state. The change to 'free' is done
237 * lazily later.
238 *
239 * @param phone Phone to be hung up
240 *
241 * @return 0 - phone disconnected, -1 - the phone was already disconnected
242 */
243int ipc_phone_hangup(phone_t *phone)
244{
245 answerbox_t *box;
246 call_t *call;
247
248 spinlock_lock(&phone->lock);
249 if (phone->state == IPC_PHONE_FREE || phone->state ==IPC_PHONE_HUNGUP \
250 || phone->state == IPC_PHONE_CONNECTING) {
251 spinlock_unlock(&phone->lock);
252 return -1;
253 }
254 box = phone->callee;
255 if (phone->state != IPC_PHONE_SLAMMED) {
256 /* Remove myself from answerbox */
257 spinlock_lock(&box->lock);
258 list_remove(&phone->link);
259 spinlock_unlock(&box->lock);
260
261 if (phone->state != IPC_PHONE_SLAMMED) {
262 call = ipc_call_alloc(0);
263 IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
264 call->flags |= IPC_CALL_DISCARD_ANSWER;
265 _ipc_call(phone, box, call);
266 }
267 }
268
269 phone->state = IPC_PHONE_HUNGUP;
270 spinlock_unlock(&phone->lock);
271
272 return 0;
273}
274
275/** Forwards call from one answerbox to a new one
276 *
277 * @param call Call to be redirected.
278 * @param newphone Phone to target answerbox.
279 * @param oldbox Old answerbox
280 * @return 0 on forward ok, error code, if there was error
281 *
282 * - the return value serves only as an information for the forwarder,
283 * the original caller is notified automatically with EFORWARD
284 */
285int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox)
286{
287 spinlock_lock(&oldbox->lock);
288 list_remove(&call->link);
289 spinlock_unlock(&oldbox->lock);
290
291 return ipc_call(newphone, call);
292}
293
294
295/** Wait for phone call
296 *
297 * @param box Answerbox expecting the call.
298 * @param usec Timeout in microseconds. See documentation for waitq_sleep_timeout() for
299 * decription of its special meaning.
300 * @param flags Select mode of sleep operation. See documentation for waitq_sleep_timeout()i
301 * for description of its special meaning.
302 * @return Recived message address
303 * - to distinguish between call and answer, look at call->flags
304 */
305call_t * ipc_wait_for_call(answerbox_t *box, __u32 usec, int flags)
306{
307 call_t *request;
308 ipl_t ipl;
309 int rc;
310
311restart:
312 rc = waitq_sleep_timeout(&box->wq, usec, flags);
313 if (SYNCH_FAILED(rc))
314 return NULL;
315
316 spinlock_lock(&box->lock);
317 if (!list_empty(&box->irq_notifs)) {
318 ipl = interrupts_disable();
319 spinlock_lock(&box->irq_lock);
320
321 request = list_get_instance(box->irq_notifs.next, call_t, link);
322 list_remove(&request->link);
323
324 spinlock_unlock(&box->irq_lock);
325 interrupts_restore(ipl);
326 } else if (!list_empty(&box->answers)) {
327 /* Handle asynchronous answers */
328 request = list_get_instance(box->answers.next, call_t, link);
329 list_remove(&request->link);
330 atomic_dec(&request->data.phone->active_calls);
331 } else if (!list_empty(&box->calls)) {
332 /* Handle requests */
333 request = list_get_instance(box->calls.next, call_t, link);
334 list_remove(&request->link);
335 /* Append request to dispatch queue */
336 list_append(&request->link, &box->dispatched_calls);
337 } else {
338 /* This can happen regularly after ipc_cleanup */
339 spinlock_unlock(&box->lock);
340 goto restart;
341 }
342 spinlock_unlock(&box->lock);
343 return request;
344}
345
346/** Answer all calls from list with EHANGUP msg */
347static void ipc_cleanup_call_list(link_t *lst)
348{
349 call_t *call;
350
351 while (!list_empty(lst)) {
352 call = list_get_instance(lst->next, call_t, link);
353 list_remove(&call->link);
354
355 IPC_SET_RETVAL(call->data, EHANGUP);
356 _ipc_answer_free_call(call);
357 }
358}
359
360/** Cleans up all IPC communication of the current task
361 *
362 * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
363 * have to change it as well if you want to cleanup other current then current.
364 */
365void ipc_cleanup(void)
366{
367 int i;
368 call_t *call;
369 phone_t *phone;
370
371 /* Disconnect all our phones ('ipc_phone_hangup') */
372 for (i=0;i < IPC_MAX_PHONES; i++)
373 ipc_phone_hangup(&TASK->phones[i]);
374
375 /* Disconnect all connected irqs */
376 ipc_irq_cleanup(&TASK->answerbox);
377
378 /* Disconnect all phones connected to our answerbox */
379restart_phones:
380 spinlock_lock(&TASK->answerbox.lock);
381 while (!list_empty(&TASK->answerbox.connected_phones)) {
382 phone = list_get_instance(TASK->answerbox.connected_phones.next,
383 phone_t, link);
384 if (! spinlock_trylock(&phone->lock)) {
385 spinlock_unlock(&TASK->answerbox.lock);
386 goto restart_phones;
387 }
388
389 /* Disconnect phone */
390 ASSERT(phone->state == IPC_PHONE_CONNECTED);
391 phone->state = IPC_PHONE_SLAMMED;
392 list_remove(&phone->link);
393
394 spinlock_unlock(&phone->lock);
395 }
396
397 /* Answer all messages in 'calls' and 'dispatched_calls' queues */
398 ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls);
399 ipc_cleanup_call_list(&TASK->answerbox.calls);
400 spinlock_unlock(&TASK->answerbox.lock);
401
402 /* Wait for all async answers to arrive */
403 while (1) {
404 /* Go through all phones, until all are FREE... */
405 /* Locking not needed, no one else should modify
406 * it, when we are in cleanup */
407 for (i=0;i < IPC_MAX_PHONES; i++) {
408 if (TASK->phones[i].state == IPC_PHONE_HUNGUP && \
409 atomic_get(&TASK->phones[i].active_calls) == 0)
410 TASK->phones[i].state = IPC_PHONE_FREE;
411
412 /* Just for sure, we might have had some
413 * IPC_PHONE_CONNECTING phones */
414 if (TASK->phones[i].state == IPC_PHONE_CONNECTED)
415 ipc_phone_hangup(&TASK->phones[i]);
416 /* If the hangup succeeded, it has sent a HANGUP
417 * message, the IPC is now in HUNGUP state, we
418 * wait for the reply to come */
419
420 if (TASK->phones[i].state != IPC_PHONE_FREE)
421 break;
422 }
423 /* Voila, got into cleanup */
424 if (i == IPC_MAX_PHONES)
425 break;
426
427 call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
428 ASSERT((call->flags & IPC_CALL_ANSWERED) || (call->flags & IPC_CALL_NOTIF));
429 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
430
431 atomic_dec(&TASK->active_calls);
432 ipc_call_free(call);
433 }
434}
435
436
437/** Initilize ipc subsystem */
438void ipc_init(void)
439{
440 ipc_call_slab = slab_cache_create("ipc_call",
441 sizeof(call_t),
442 0,
443 NULL, NULL, 0);
444 ipc_irq_make_table(IRQ_COUNT);
445}
446
447
448/** Kconsole - list answerbox contents */
449void ipc_print_task(task_id_t taskid)
450{
451 task_t *task;
452 int i;
453 call_t *call;
454 link_t *tmp;
455
456 spinlock_lock(&tasks_lock);
457 task = task_find_by_id(taskid);
458 if (task)
459 spinlock_lock(&task->lock);
460 spinlock_unlock(&tasks_lock);
461 if (!task)
462 return;
463
464 /* Print opened phones & details */
465 printf("PHONE:\n");
466 for (i=0; i < IPC_MAX_PHONES;i++) {
467 spinlock_lock(&task->phones[i].lock);
468 if (task->phones[i].state != IPC_PHONE_FREE) {
469 printf("%d: ",i);
470 switch (task->phones[i].state) {
471 case IPC_PHONE_CONNECTING:
472 printf("connecting ");
473 break;
474 case IPC_PHONE_CONNECTED:
475 printf("connected to: %P ",
476 task->phones[i].callee);
477 break;
478 case IPC_PHONE_SLAMMED:
479 printf("slammed by: %P ",
480 task->phones[i].callee);
481 break;
482 case IPC_PHONE_HUNGUP:
483 printf("hung up - was: %P ",
484 task->phones[i].callee);
485 break;
486 default:
487 break;
488 }
489 printf("active: %d\n", atomic_get(&task->phones[i].active_calls));
490 }
491 spinlock_unlock(&task->phones[i].lock);
492 }
493
494
495 /* Print answerbox - calls */
496 spinlock_lock(&task->answerbox.lock);
497 printf("ABOX - CALLS:\n");
498 for (tmp=task->answerbox.calls.next; tmp != &task->answerbox.calls;tmp = tmp->next) {
499 call = list_get_instance(tmp, call_t, link);
500 printf("Callid: %P Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
501 call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
502 IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
503 }
504 /* Print answerbox - calls */
505 printf("ABOX - DISPATCHED CALLS:\n");
506 for (tmp=task->answerbox.dispatched_calls.next;
507 tmp != &task->answerbox.dispatched_calls;
508 tmp = tmp->next) {
509 call = list_get_instance(tmp, call_t, link);
510 printf("Callid: %P Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
511 call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
512 IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
513 }
514 /* Print answerbox - calls */
515 printf("ABOX - ANSWERS:\n");
516 for (tmp=task->answerbox.answers.next; tmp != &task->answerbox.answers; tmp = tmp->next) {
517 call = list_get_instance(tmp, call_t, link);
518 printf("Callid:%P M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
519 IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
520 IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
521 }
522
523 spinlock_unlock(&task->answerbox.lock);
524 spinlock_unlock(&task->lock);
525}
Note: See TracBrowser for help on using the repository browser.