Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
955 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
/* Lock ordering
30
 *
31
 * First the answerbox, then the phone
32
 */
33
 
1040 palkovsky 34
#include <synch/spinlock.h>
35
#include <synch/waitq.h>
955 palkovsky 36
#include <ipc/ipc.h>
37
#include <errno.h>
38
#include <mm/slab.h>
39
#include <arch.h>
40
#include <proc/task.h>
41
#include <memstr.h>
42
#include <debug.h>
43
 
44
#include <print.h>
45
#include <proc/thread.h>
1258 palkovsky 46
#include <arch/interrupt.h>
1281 palkovsky 47
#include <ipc/irq.h>
955 palkovsky 48
 
965 palkovsky 49
/* Open channel that is assigned automatically to new tasks */
50
answerbox_t *ipc_phone_0 = NULL;
955 palkovsky 51
 
52
static slab_cache_t *ipc_call_slab;
53
 
1084 palkovsky 54
/* Initialize new call */
55
static void _ipc_call_init(call_t *call)
56
{
57
    memsetb((__address)call, sizeof(*call), 0);
58
    call->callerbox = &TASK->answerbox;
59
    call->sender = TASK;
60
}
61
 
955 palkovsky 62
/** Allocate & initialize call structure
63
 *
64
 * The call is initialized, so that the reply will be directed
65
 * to TASK->answerbox
1258 palkovsky 66
 *
67
 * @param flags Parameters for slab_alloc (ATOMIC, etc.)
955 palkovsky 68
 */
1258 palkovsky 69
call_t * ipc_call_alloc(int flags)
955 palkovsky 70
{
71
    call_t *call;
72
 
1258 palkovsky 73
    call = slab_alloc(ipc_call_slab, flags);
1084 palkovsky 74
    _ipc_call_init(call);
955 palkovsky 75
 
76
    return call;
77
}
78
 
965 palkovsky 79
/** Initialize allocated call */
1084 palkovsky 80
void ipc_call_static_init(call_t *call)
965 palkovsky 81
{
1084 palkovsky 82
    _ipc_call_init(call);
83
    call->flags |= IPC_CALL_STATIC_ALLOC;
965 palkovsky 84
}
85
 
955 palkovsky 86
/** Deallocate call stracuture */
87
void ipc_call_free(call_t *call)
88
{
89
    slab_free(ipc_call_slab, call);
90
}
91
 
92
/** Initialize answerbox structure
93
 */
94
void ipc_answerbox_init(answerbox_t *box)
95
{
1040 palkovsky 96
    spinlock_initialize(&box->lock, "ipc_box_lock");
1258 palkovsky 97
    spinlock_initialize(&box->irq_lock, "ipc_box_irqlock");
1040 palkovsky 98
    waitq_initialize(&box->wq);
955 palkovsky 99
    list_initialize(&box->connected_phones);
100
    list_initialize(&box->calls);
101
    list_initialize(&box->dispatched_calls);
102
    list_initialize(&box->answers);
1258 palkovsky 103
    list_initialize(&box->irq_notifs);
1027 palkovsky 104
    box->task = TASK;
955 palkovsky 105
}
106
 
1040 palkovsky 107
/** Connect phone to answerbox */
108
void ipc_phone_connect(phone_t *phone, answerbox_t *box)
955 palkovsky 109
{
1084 palkovsky 110
    spinlock_lock(&phone->lock);
111
 
1040 palkovsky 112
    ASSERT(!phone->callee);
1088 palkovsky 113
    phone->busy = IPC_BUSY_CONNECTED;
955 palkovsky 114
    phone->callee = box;
965 palkovsky 115
 
1040 palkovsky 116
    spinlock_lock(&box->lock);
955 palkovsky 117
    list_append(&phone->list, &box->connected_phones);
1040 palkovsky 118
    spinlock_unlock(&box->lock);
1084 palkovsky 119
 
120
    spinlock_unlock(&phone->lock);
955 palkovsky 121
}
122
 
1223 jermar 123
/** Initialize phone structure and connect phone to answerbox
1040 palkovsky 124
 */
125
void ipc_phone_init(phone_t *phone)
126
{
127
    spinlock_initialize(&phone->lock, "phone_lock");
128
    phone->callee = NULL;
1088 palkovsky 129
    phone->busy = IPC_BUSY_FREE;
130
    atomic_set(&phone->active_calls, 0);
1040 palkovsky 131
}
132
 
959 palkovsky 133
/** Helper function to facilitate synchronous calls */
134
void ipc_call_sync(phone_t *phone, call_t *request)
135
{
136
    answerbox_t sync_box;
955 palkovsky 137
 
959 palkovsky 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, 0);
145
}
146
 
1084 palkovsky 147
/** Answer message that was not dispatched and is not entered in
148
 * any queue
149
 */
150
static 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->list, &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
 */
167
void ipc_answer(answerbox_t *box, call_t *call)
168
{
169
    /* Remove from active box */
170
    spinlock_lock(&box->lock);
171
    list_remove(&call->list);
172
    spinlock_unlock(&box->lock);
173
    /* Send back answer */
174
    _ipc_answer_free_call(call);
175
}
176
 
1090 palkovsky 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
 */
182
void ipc_backsend_err(phone_t *phone, call_t *call, __native err)
183
{
184
    call->data.phone = phone;
185
    atomic_inc(&phone->active_calls);
186
    if (phone->busy == IPC_BUSY_CONNECTED)
187
        IPC_SET_RETVAL(call->data, EHANGUP);
188
    else
189
        IPC_SET_RETVAL(call->data, ENOENT);
190
 
191
    _ipc_answer_free_call(call);
192
}
193
 
1086 palkovsky 194
/* Unsafe unchecking ipc_call */
195
static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call)
196
{
1088 palkovsky 197
    if (! (call->flags & IPC_CALL_FORWARDED)) {
198
        atomic_inc(&phone->active_calls);
199
        call->data.phone = phone;
200
    }
1086 palkovsky 201
 
202
    spinlock_lock(&box->lock);
203
    list_append(&call->list, &box->calls);
204
    spinlock_unlock(&box->lock);
205
    waitq_wakeup(&box->wq, 0);
206
}
207
 
959 palkovsky 208
/** Send a asynchronous request using phone to answerbox
955 palkovsky 209
 *
210
 * @param phone Phone connected to answerbox
211
 * @param request Request to be sent
212
 */
1088 palkovsky 213
int ipc_call(phone_t *phone, call_t *call)
955 palkovsky 214
{
1084 palkovsky 215
    answerbox_t *box;
955 palkovsky 216
 
1084 palkovsky 217
    spinlock_lock(&phone->lock);
1086 palkovsky 218
 
1084 palkovsky 219
    box = phone->callee;
220
    if (!box) {
221
        /* Trying to send over disconnected phone */
1086 palkovsky 222
        spinlock_unlock(&phone->lock);
1088 palkovsky 223
        if (call->flags & IPC_CALL_FORWARDED) {
224
            IPC_SET_RETVAL(call->data, EFORWARD);
1090 palkovsky 225
            _ipc_answer_free_call(call);
226
        } else { /* Simulate sending back a message */
1088 palkovsky 227
            if (phone->busy == IPC_BUSY_CONNECTED)
1090 palkovsky 228
                ipc_backsend_err(phone, call, EHANGUP);
1088 palkovsky 229
            else
1090 palkovsky 230
                ipc_backsend_err(phone, call, ENOENT);
1088 palkovsky 231
        }
1086 palkovsky 232
 
1088 palkovsky 233
        return ENOENT;
1084 palkovsky 234
    }
1086 palkovsky 235
    _ipc_call(phone, box, call);
236
 
237
    spinlock_unlock(&phone->lock);
1088 palkovsky 238
    return 0;
1086 palkovsky 239
}
955 palkovsky 240
 
1086 palkovsky 241
/** Disconnect phone from answerbox
242
 *
243
 * It is allowed to call disconnect on already disconnected phone
244
 *
245
 * @return 0 - phone disconnected, -1 - the phone was already disconnected
246
 */
247
int ipc_phone_hangup(phone_t *phone)
248
{
249
    answerbox_t *box;
250
    call_t *call;
251
 
252
    spinlock_lock(&phone->lock);
253
    box = phone->callee;
254
    if (!box) {
1088 palkovsky 255
        if (phone->busy == IPC_BUSY_CONNECTING) {
256
            spinlock_unlock(&phone->lock);
257
            return -1;
258
        }
259
        /* Already disconnected phone */
260
        phone->busy = IPC_BUSY_FREE;
1086 palkovsky 261
        spinlock_unlock(&phone->lock);
1088 palkovsky 262
        return 0;
1086 palkovsky 263
    }
264
 
1040 palkovsky 265
    spinlock_lock(&box->lock);
1086 palkovsky 266
    list_remove(&phone->list);
267
    phone->callee = NULL;
1040 palkovsky 268
    spinlock_unlock(&box->lock);
1086 palkovsky 269
 
1258 palkovsky 270
    call = ipc_call_alloc(0);
1086 palkovsky 271
    IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
272
    call->flags |= IPC_CALL_DISCARD_ANSWER;
273
    _ipc_call(phone, box, call);
274
 
1088 palkovsky 275
    phone->busy = IPC_BUSY_FREE;
1086 palkovsky 276
 
1084 palkovsky 277
    spinlock_unlock(&phone->lock);
1086 palkovsky 278
 
279
    return 0;
955 palkovsky 280
}
281
 
1040 palkovsky 282
/** Forwards call from one answerbox to a new one
283
 *
1342 jermar 284
 * @param call Call to be redirected.
285
 * @param newphone Phone to target answerbox.
1040 palkovsky 286
 * @param oldbox Old answerbox
1088 palkovsky 287
 * @return 0 on forward ok, error code, if there was error
288
 *
289
 * - the return value serves only as an information for the forwarder,
290
 *   the original caller is notified automatically with EFORWARD
1040 palkovsky 291
 */
1088 palkovsky 292
int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox)
1040 palkovsky 293
{
294
    spinlock_lock(&oldbox->lock);
295
    list_remove(&call->list);
296
    spinlock_unlock(&oldbox->lock);
297
 
1088 palkovsky 298
    return ipc_call(newphone, call);
1040 palkovsky 299
}
300
 
955 palkovsky 301
 
302
/** Wait for phone call
303
 *
304
 * @return Recived message address
305
 * - to distinguish between call and answer, look at call->flags
306
 */
307
call_t * ipc_wait_for_call(answerbox_t *box, int flags)
308
{
309
    call_t *request;
1258 palkovsky 310
    ipl_t ipl;
955 palkovsky 311
 
1086 palkovsky 312
restart:      
313
    if (flags & IPC_WAIT_NONBLOCKING) {
314
        if (waitq_sleep_timeout(&box->wq,0,1) == ESYNCH_WOULD_BLOCK)
315
            return NULL;
316
    } else
317
        waitq_sleep(&box->wq);
318
 
1040 palkovsky 319
    spinlock_lock(&box->lock);
1258 palkovsky 320
    if (!list_empty(&box->irq_notifs)) {
321
        ipl = interrupts_disable();
322
        spinlock_lock(&box->irq_lock);
323
 
1281 palkovsky 324
        request = list_get_instance(box->irq_notifs.next, call_t, list);
1258 palkovsky 325
        list_remove(&request->list);
326
 
327
        spinlock_unlock(&box->irq_lock);
328
        interrupts_restore(ipl);
329
    } else if (!list_empty(&box->answers)) {
1086 palkovsky 330
        /* Handle asynchronous answers */
331
        request = list_get_instance(box->answers.next, call_t, list);
332
        list_remove(&request->list);
333
        atomic_dec(&request->data.phone->active_calls);
334
    } else if (!list_empty(&box->calls)) {
335
        /* Handle requests */
336
        request = list_get_instance(box->calls.next, call_t, list);
337
        list_remove(&request->list);
338
        /* Append request to dispatch queue */
339
        list_append(&request->list, &box->dispatched_calls);
340
    } else {
1141 palkovsky 341
        /* This can happen regularly after ipc_cleanup, remove
342
         * the warning in the future when the IPC is
343
         * more debugged */
1086 palkovsky 344
        printf("WARNING: Spurious IPC wakeup.\n");
345
        spinlock_unlock(&box->lock);
346
        goto restart;
955 palkovsky 347
    }
1040 palkovsky 348
    spinlock_unlock(&box->lock);
955 palkovsky 349
    return request;
350
}
351
 
1141 palkovsky 352
/** Answer all calls from list with EHANGUP msg */
353
static void ipc_cleanup_call_list(link_t *lst)
354
{
355
    call_t *call;
356
 
357
    while (!list_empty(lst)) {
358
        call = list_get_instance(lst->next, call_t, list);
359
        list_remove(&call->list);
360
 
361
        IPC_SET_RETVAL(call->data, EHANGUP);
362
        _ipc_answer_free_call(call);
363
    }
364
}
365
 
1072 palkovsky 366
/** Cleans up all IPC communication of the given task
367
 *
368
 *
369
 */
370
void ipc_cleanup(task_t *task)
371
{
1088 palkovsky 372
    int i;
1141 palkovsky 373
    call_t *call;
374
    phone_t *phone;
375
 
1088 palkovsky 376
    /* Disconnect all our phones ('ipc_phone_hangup') */
377
    for (i=0;i < IPC_MAX_PHONES; i++)
378
        ipc_phone_hangup(&task->phones[i]);
379
 
1258 palkovsky 380
    /* Disconnect all connected irqs */
381
    ipc_irq_cleanup(&task->answerbox);
382
 
1141 palkovsky 383
    /* Disconnect all phones connected to our answerbox */
384
restart_phones:
385
    spinlock_lock(&task->answerbox.lock);
386
    while (!list_empty(&task->answerbox.connected_phones)) {
387
        phone = list_get_instance(task->answerbox.connected_phones.next,
388
                      phone_t,
389
                      list);
390
        if (! spinlock_trylock(&phone->lock)) {
391
            spinlock_unlock(&task->answerbox.lock);
392
            goto restart_phones;
393
        }
394
 
395
        /* Disconnect phone */
396
        phone->callee = NULL;
397
        list_remove(&phone->list);
1088 palkovsky 398
 
1141 palkovsky 399
        spinlock_unlock(&phone->lock);
400
    }
401
 
1088 palkovsky 402
    /* Answer all messages in 'calls' and 'dispatched_calls' queues */
1141 palkovsky 403
    spinlock_lock(&task->answerbox.lock);
404
    ipc_cleanup_call_list(&task->answerbox.dispatched_calls);
405
    ipc_cleanup_call_list(&task->answerbox.calls);
406
    spinlock_unlock(&task->answerbox.lock);
1072 palkovsky 407
 
1088 palkovsky 408
    /* Wait for all async answers to arrive */
1141 palkovsky 409
    while (atomic_get(&task->active_calls)) {
410
        call = ipc_wait_for_call(&task->answerbox, 0);
1260 palkovsky 411
        ASSERT((call->flags & IPC_CALL_ANSWERED) || (call->flags & IPC_CALL_NOTIF));
1141 palkovsky 412
        ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
413
 
414
        atomic_dec(&task->active_calls);
415
        ipc_call_free(call);
416
    }
1072 palkovsky 417
}
1258 palkovsky 418
 
419
 
420
/** Initilize ipc subsystem */
421
void ipc_init(void)
422
{
423
    ipc_call_slab = slab_cache_create("ipc_call",
424
                      sizeof(call_t),
425
                      0,
426
                      NULL, NULL, 0);
427
    ipc_irq_make_table(IRQ_COUNT);
428
}
429