Subversion Repositories HelenOS-historic

Rev

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

Rev Author Line No. Line
954 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.
1653 cejka 27
 */
28
 
29
/** @addtogroup libc
30
 * @{
31
 * @}
32
 */
33
 
34
 /** @addtogroup libcipc IPC
35
 * @brief HelenOS uspace IPC
36
 * @{
37
 * @ingroup libc
38
 */
39
/** @file
954 palkovsky 40
 */
41
 
1352 palkovsky 42
#include <ipc/ipc.h>
954 palkovsky 43
#include <libc.h>
999 palkovsky 44
#include <malloc.h>
45
#include <errno.h>
1352 palkovsky 46
#include <libadt/list.h>
999 palkovsky 47
#include <stdio.h>
48
#include <unistd.h>
1350 palkovsky 49
#include <futex.h>
1365 jermar 50
#include <kernel/synch/synch.h>
1463 palkovsky 51
#include <async.h>
52
#include <psthread.h>
954 palkovsky 53
 
999 palkovsky 54
/** Structure used for keeping track of sent async msgs
55
 * and queing unsent msgs
56
 *
57
 */
58
typedef struct {
59
    link_t list;
60
 
61
    ipc_async_callback_t callback;
62
    void *private;
63
    union {
64
        ipc_callid_t callid;
65
        struct {
1091 palkovsky 66
            ipc_call_t data;
999 palkovsky 67
            int phoneid;
68
        } msg;
69
    }u;
1463 palkovsky 70
    pstid_t ptid;   /**< Thread waiting for sending this msg */
999 palkovsky 71
} async_call_t;
72
 
73
LIST_INITIALIZE(dispatched_calls);
74
 
1463 palkovsky 75
/* queued_calls is protcted by async_futex, because if the
76
 * call cannot be sent into kernel, async framework is used
77
 * automatically
78
 */
79
LIST_INITIALIZE(queued_calls); /**< List of async calls that were not accepted
80
                *   by kernel */
81
 
1392 palkovsky 82
static atomic_t ipc_futex = FUTEX_INITIALIZER;
1350 palkovsky 83
 
999 palkovsky 84
int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
85
          ipcarg_t *result)
954 palkovsky 86
{
1091 palkovsky 87
    ipc_call_t resdata;
966 palkovsky 88
    int callres;
89
 
999 palkovsky 90
    callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
966 palkovsky 91
                 (sysarg_t)&resdata);
92
    if (callres)
93
        return callres;
94
    if (result)
95
        *result = IPC_GET_ARG1(resdata);
96
    return IPC_GET_RETVAL(resdata);
954 palkovsky 97
}
98
 
999 palkovsky 99
int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
100
            ipcarg_t arg2, ipcarg_t arg3,
101
            ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3)
954 palkovsky 102
{
1091 palkovsky 103
    ipc_call_t data;
966 palkovsky 104
    int callres;
105
 
106
    IPC_SET_METHOD(data, method);
107
    IPC_SET_ARG1(data, arg1);
108
    IPC_SET_ARG2(data, arg2);
109
    IPC_SET_ARG3(data, arg3);
110
 
1006 palkovsky 111
    callres = __SYSCALL3(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data,
112
                 (sysarg_t)&data);
966 palkovsky 113
    if (callres)
114
        return callres;
115
 
116
    if (result1)
117
        *result1 = IPC_GET_ARG1(data);
118
    if (result2)
119
        *result2 = IPC_GET_ARG2(data);
120
    if (result3)
121
        *result3 = IPC_GET_ARG3(data);
122
    return IPC_GET_RETVAL(data);
123
}
124
 
999 palkovsky 125
/** Syscall to send asynchronous message */
1091 palkovsky 126
static  ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
999 palkovsky 127
{
128
    return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);
129
}
130
 
1489 palkovsky 131
/** Prolog to ipc_async_send functions */
132
static inline async_call_t *ipc_prepare_async(void *private, ipc_async_callback_t callback)
966 palkovsky 133
{
999 palkovsky 134
    async_call_t *call;
966 palkovsky 135
 
999 palkovsky 136
    call = malloc(sizeof(*call));
137
    if (!call) {
1443 palkovsky 138
        if (callback)
139
            callback(private, ENOMEM, NULL);
1489 palkovsky 140
        return NULL;
999 palkovsky 141
    }
1463 palkovsky 142
    call->callback = callback;
143
    call->private = private;
144
 
1489 palkovsky 145
    return call;
146
}
147
 
148
/** Epilogue of ipc_async_send functions */
1518 palkovsky 149
static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
150
                    async_call_t *call, int can_preempt)
1489 palkovsky 151
{
966 palkovsky 152
    if (callid == IPC_CALLRET_FATAL) {
1463 palkovsky 153
        futex_up(&ipc_futex);
966 palkovsky 154
        /* Call asynchronous handler with error code */
1489 palkovsky 155
        if (call->callback)
156
            call->callback(call->private, ENOENT, NULL);
999 palkovsky 157
        free(call);
966 palkovsky 158
        return;
159
    }
999 palkovsky 160
 
1463 palkovsky 161
    if (callid == IPC_CALLRET_TEMPORARY) {
162
        futex_up(&ipc_futex);
999 palkovsky 163
 
164
        call->u.msg.phoneid = phoneid;
1518 palkovsky 165
 
1463 palkovsky 166
        futex_down(&async_futex);
999 palkovsky 167
        list_append(&call->list, &queued_calls);
1463 palkovsky 168
 
1518 palkovsky 169
        if (can_preempt) {
170
            call->ptid = psthread_get_id();
171
            psthread_schedule_next_adv(PS_TO_MANAGER);
172
            /* Async futex unlocked by previous call */
173
        } else {
174
            call->ptid = 0;
175
            futex_up(&async_futex);
176
        }
966 palkovsky 177
        return;
178
    }
999 palkovsky 179
    call->u.callid = callid;
180
    /* Add call to list of dispatched calls */
181
    list_append(&call->list, &dispatched_calls);
1350 palkovsky 182
    futex_up(&ipc_futex);
1489 palkovsky 183
 
954 palkovsky 184
}
185
 
1489 palkovsky 186
/** Send asynchronous message
187
 *
188
 * - if fatal error, call callback handler with proper error code
189
 * - if message cannot be temporarily sent, add to queue
190
 */
191
void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
192
              ipcarg_t arg2, void *private,
1518 palkovsky 193
              ipc_async_callback_t callback, int can_preempt)
1489 palkovsky 194
{
195
    async_call_t *call;
196
    ipc_callid_t callid;
966 palkovsky 197
 
1489 palkovsky 198
    call = ipc_prepare_async(private, callback);
199
    if (!call)
200
        return;
201
 
202
    /* We need to make sure that we get callid before
203
     * another thread accesses the queue again */
204
    futex_down(&ipc_futex);
205
    callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
206
 
207
    if (callid == IPC_CALLRET_TEMPORARY) {
208
        IPC_SET_METHOD(call->u.msg.data, method);
209
        IPC_SET_ARG1(call->u.msg.data, arg1);
210
        IPC_SET_ARG2(call->u.msg.data, arg2);
211
    }
1518 palkovsky 212
    ipc_finish_async(callid, phoneid, call, can_preempt);
1489 palkovsky 213
}
214
 
215
/** Send asynchronous message
216
 *
217
 * - if fatal error, call callback handler with proper error code
218
 * - if message cannot be temporarily sent, add to queue
219
 */
220
void ipc_call_async_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
221
              ipcarg_t arg2, ipcarg_t arg3, void *private,
1518 palkovsky 222
              ipc_async_callback_t callback, int can_preempt)
1489 palkovsky 223
{
224
    async_call_t *call;
225
    ipc_callid_t callid;
226
 
227
    call = ipc_prepare_async(private, callback);
228
    if (!call)
229
        return;
230
 
231
    IPC_SET_METHOD(call->u.msg.data, method);
232
    IPC_SET_ARG1(call->u.msg.data, arg1);
233
    IPC_SET_ARG2(call->u.msg.data, arg2);
234
    IPC_SET_ARG3(call->u.msg.data, arg3);
235
    /* We need to make sure that we get callid before
236
     * another thread accesses the queue again */
237
    futex_down(&ipc_futex);
238
    callid = _ipc_call_async(phoneid, &call->u.msg.data);
239
 
1518 palkovsky 240
    ipc_finish_async(callid, phoneid, call, can_preempt);
1489 palkovsky 241
}
242
 
243
 
1343 jermar 244
/** Send a fast answer to a received call.
245
 *
246
 * The fast answer makes use of passing retval and first two arguments in registers.
247
 * If you need to return more, use the ipc_answer() instead.
248
 *
249
 * @param callid ID of the call being answered.
250
 * @param retval Return value.
251
 * @param arg1 First return argument.
252
 * @param arg2 Second return argument.
253
 *
254
 * @return Zero on success or a value from @ref errno.h on failure.
255
 */
256
ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
999 palkovsky 257
        ipcarg_t arg2)
954 palkovsky 258
{
1330 palkovsky 259
    return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
954 palkovsky 260
}
261
 
1343 jermar 262
/** Send a full answer to a received call.
263
 *
264
 * @param callid ID of the call being answered.
265
 * @param call Call data. Must be already initialized by the responder.
266
 *
267
 * @return Zero on success or a value from @ref errno.h on failure.
268
 */
269
ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
270
{
271
    return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
272
}
273
 
274
 
999 palkovsky 275
/** Try to dispatch queed calls from async queue */
276
static void try_dispatch_queued_calls(void)
277
{
278
    async_call_t *call;
279
    ipc_callid_t callid;
280
 
1463 palkovsky 281
    /* TODO: integrate intelligently ipc_futex, so that it
282
     * is locked during ipc_call_async, until it is added
283
     * to dispatched_calls
284
     */
285
    futex_down(&async_futex);
999 palkovsky 286
    while (!list_empty(&queued_calls)) {
287
        call = list_get_instance(queued_calls.next, async_call_t,
288
                     list);
289
 
290
        callid = _ipc_call_async(call->u.msg.phoneid,
291
                     &call->u.msg.data);
1463 palkovsky 292
        if (callid == IPC_CALLRET_TEMPORARY) {
999 palkovsky 293
            break;
1463 palkovsky 294
        }
999 palkovsky 295
        list_remove(&call->list);
1350 palkovsky 296
 
1463 palkovsky 297
        futex_up(&async_futex);
1518 palkovsky 298
        if (call->ptid)
299
            psthread_add_ready(call->ptid);
1463 palkovsky 300
 
999 palkovsky 301
        if (callid == IPC_CALLRET_FATAL) {
1443 palkovsky 302
            if (call->callback)
303
                call->callback(call->private, ENOENT, NULL);
999 palkovsky 304
            free(call);
305
        } else {
306
            call->u.callid = callid;
1463 palkovsky 307
            futex_down(&ipc_futex);
999 palkovsky 308
            list_append(&call->list, &dispatched_calls);
1463 palkovsky 309
            futex_up(&ipc_futex);
999 palkovsky 310
        }
1463 palkovsky 311
        futex_down(&async_futex);
999 palkovsky 312
    }
1463 palkovsky 313
    futex_up(&async_futex);
999 palkovsky 314
}
315
 
316
/** Handle received answer
317
 *
318
 * TODO: Make it use hash table
319
 *
320
 * @param callid Callid (with first bit set) of the answered call
321
 */
1091 palkovsky 322
static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
999 palkovsky 323
{
324
    link_t *item;
325
    async_call_t *call;
326
 
327
    callid &= ~IPC_CALLID_ANSWERED;
328
 
1350 palkovsky 329
    futex_down(&ipc_futex);
999 palkovsky 330
    for (item = dispatched_calls.next; item != &dispatched_calls;
331
         item = item->next) {
332
        call = list_get_instance(item, async_call_t, list);
333
        if (call->u.callid == callid) {
334
            list_remove(&call->list);
1350 palkovsky 335
            futex_up(&ipc_futex);
1443 palkovsky 336
            if (call->callback)
337
                call->callback(call->private,
338
                           IPC_GET_RETVAL(*data),
339
                           data);
340
            free(call);
999 palkovsky 341
            return;
342
        }
343
    }
1350 palkovsky 344
    futex_up(&ipc_futex);
999 palkovsky 345
    printf("Received unidentified answer: %P!!!\n", callid);
346
}
347
 
348
 
1392 palkovsky 349
/** One cycle of ipc wait for call call
954 palkovsky 350
 *
351
 * - dispatch ASYNC reoutines in the background
1365 jermar 352
 * @param call Space where the message is stored
1392 palkovsky 353
 * @param usec Timeout in microseconds
354
 * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking)
1365 jermar 355
 * @return Callid of the answer.
954 palkovsky 356
 */
1392 palkovsky 357
ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
954 palkovsky 358
{
359
    ipc_callid_t callid;
360
 
1392 palkovsky 361
    callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
362
    /* Handle received answers */
1463 palkovsky 363
    if (callid & IPC_CALLID_ANSWERED) {
1392 palkovsky 364
        handle_answer(callid, call);
1463 palkovsky 365
        try_dispatch_queued_calls();
366
    }
999 palkovsky 367
 
954 palkovsky 368
    return callid;
369
}
1028 palkovsky 370
 
1365 jermar 371
/** Wait some time for an IPC call.
372
 *
373
 * - dispatch ASYNC reoutines in the background
1709 jermar 374
 *
1365 jermar 375
 * @param call Space where the message is stored
376
 * @param usec Timeout in microseconds.
377
 * @return Callid of the answer.
378
 */
379
ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
380
{
381
    ipc_callid_t callid;
382
 
383
    do {
1503 jermar 384
        callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
1365 jermar 385
    } while (callid & IPC_CALLID_ANSWERED);
386
 
387
    return callid;
388
}
389
 
390
/** Check if there is an IPC call waiting to be picked up.
391
 *
392
 * - dispatch ASYNC reoutines in the background
1709 jermar 393
 *
1365 jermar 394
 * @param call Space where the message is stored
395
 * @return Callid of the answer.
396
 */
397
ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
398
{
399
    ipc_callid_t callid;
400
 
401
    do {
1503 jermar 402
        callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
1365 jermar 403
    } while (callid & IPC_CALLID_ANSWERED);
404
 
405
    return callid;
406
}
407
 
1091 palkovsky 408
/** Ask destination to do a callback connection
409
 *
410
 * @return 0 - OK, error code
411
 */
412
int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)
1028 palkovsky 413
{
1091 palkovsky 414
    return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,
415
                   arg2, 0, 0, 0, phone);
1028 palkovsky 416
}
1061 palkovsky 417
 
1091 palkovsky 418
/** Ask through phone for a new connection to some service
419
 *
420
 * @return new phoneid - OK, error code
421
 */
1061 palkovsky 422
int ipc_connect_me_to(int phoneid, int arg1, int arg2)
423
{
1092 palkovsky 424
    ipcarg_t newphid;
1091 palkovsky 425
    int res;
426
 
427
    res =  ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,
428
                   arg2, 0, 0, 0, &newphid);
429
    if (res)
430
        return res;
431
    return newphid;
1061 palkovsky 432
}
433
 
1089 palkovsky 434
/* Hang up specified phone */
435
int ipc_hangup(int phoneid)
436
{
437
    return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
438
}
1259 palkovsky 439
 
1282 palkovsky 440
int ipc_register_irq(int irq, irq_code_t *ucode)
1259 palkovsky 441
{
1282 palkovsky 442
    return __SYSCALL2(SYS_IPC_REGISTER_IRQ, irq, (sysarg_t) ucode);
1259 palkovsky 443
}
444
 
445
int ipc_unregister_irq(int irq)
446
{
447
    return __SYSCALL1(SYS_IPC_UNREGISTER_IRQ, irq);
448
}
1330 palkovsky 449
 
1336 jermar 450
int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1)
451
{
452
    return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1);
453
}
454
 
1653 cejka 455
 
456
 
457
 /** @}
458
 */
459
 
460