Subversion Repositories HelenOS

Rev

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