Subversion Repositories HelenOS

Rev

Rev 2071 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
954 palkovsky 1
/*
2071 jermar 2
 * Copyright (c) 2006 Ondrej Palkovsky
954 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
 
1866 jermar 34
/** @addtogroup libcipc IPC
1653 cejka 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
{
1751 palkovsky 152
    if (!call) { /* Nothing to do regardless if failed or not */
153
        futex_up(&ipc_futex);
154
        return;
155
    }
156
 
966 palkovsky 157
    if (callid == IPC_CALLRET_FATAL) {
1463 palkovsky 158
        futex_up(&ipc_futex);
966 palkovsky 159
        /* Call asynchronous handler with error code */
1489 palkovsky 160
        if (call->callback)
161
            call->callback(call->private, ENOENT, NULL);
999 palkovsky 162
        free(call);
966 palkovsky 163
        return;
164
    }
999 palkovsky 165
 
1463 palkovsky 166
    if (callid == IPC_CALLRET_TEMPORARY) {
167
        futex_up(&ipc_futex);
999 palkovsky 168
 
169
        call->u.msg.phoneid = phoneid;
1518 palkovsky 170
 
1463 palkovsky 171
        futex_down(&async_futex);
999 palkovsky 172
        list_append(&call->list, &queued_calls);
1463 palkovsky 173
 
1518 palkovsky 174
        if (can_preempt) {
175
            call->ptid = psthread_get_id();
176
            psthread_schedule_next_adv(PS_TO_MANAGER);
177
            /* Async futex unlocked by previous call */
178
        } else {
179
            call->ptid = 0;
180
            futex_up(&async_futex);
181
        }
966 palkovsky 182
        return;
183
    }
999 palkovsky 184
    call->u.callid = callid;
185
    /* Add call to list of dispatched calls */
186
    list_append(&call->list, &dispatched_calls);
1350 palkovsky 187
    futex_up(&ipc_futex);
1489 palkovsky 188
 
954 palkovsky 189
}
190
 
1489 palkovsky 191
/** Send asynchronous message
192
 *
193
 * - if fatal error, call callback handler with proper error code
194
 * - if message cannot be temporarily sent, add to queue
195
 */
196
void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
197
              ipcarg_t arg2, void *private,
1518 palkovsky 198
              ipc_async_callback_t callback, int can_preempt)
1489 palkovsky 199
{
1751 palkovsky 200
    async_call_t *call = NULL;
1489 palkovsky 201
    ipc_callid_t callid;
966 palkovsky 202
 
1751 palkovsky 203
    if (callback) {
204
        call = ipc_prepare_async(private, callback);
205
        if (!call)
206
            return;
207
    }
1489 palkovsky 208
 
209
    /* We need to make sure that we get callid before
210
     * another thread accesses the queue again */
211
    futex_down(&ipc_futex);
212
    callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
213
 
214
    if (callid == IPC_CALLRET_TEMPORARY) {
1751 palkovsky 215
        if (!call) {
216
            call = ipc_prepare_async(private, callback);
217
            if (!call)
218
                return;
219
        }
1489 palkovsky 220
        IPC_SET_METHOD(call->u.msg.data, method);
221
        IPC_SET_ARG1(call->u.msg.data, arg1);
222
        IPC_SET_ARG2(call->u.msg.data, arg2);
223
    }
1518 palkovsky 224
    ipc_finish_async(callid, phoneid, call, can_preempt);
1489 palkovsky 225
}
226
 
227
/** Send asynchronous message
228
 *
229
 * - if fatal error, call callback handler with proper error code
230
 * - if message cannot be temporarily sent, add to queue
231
 */
232
void ipc_call_async_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
233
              ipcarg_t arg2, ipcarg_t arg3, void *private,
1518 palkovsky 234
              ipc_async_callback_t callback, int can_preempt)
1489 palkovsky 235
{
236
    async_call_t *call;
237
    ipc_callid_t callid;
238
 
239
    call = ipc_prepare_async(private, callback);
240
    if (!call)
241
        return;
242
 
243
    IPC_SET_METHOD(call->u.msg.data, method);
244
    IPC_SET_ARG1(call->u.msg.data, arg1);
245
    IPC_SET_ARG2(call->u.msg.data, arg2);
246
    IPC_SET_ARG3(call->u.msg.data, arg3);
247
    /* We need to make sure that we get callid before
248
     * another thread accesses the queue again */
249
    futex_down(&ipc_futex);
250
    callid = _ipc_call_async(phoneid, &call->u.msg.data);
251
 
1518 palkovsky 252
    ipc_finish_async(callid, phoneid, call, can_preempt);
1489 palkovsky 253
}
254
 
255
 
1343 jermar 256
/** Send a fast answer to a received call.
257
 *
258
 * The fast answer makes use of passing retval and first two arguments in registers.
259
 * If you need to return more, use the ipc_answer() instead.
260
 *
261
 * @param callid ID of the call being answered.
262
 * @param retval Return value.
263
 * @param arg1 First return argument.
264
 * @param arg2 Second return argument.
265
 *
266
 * @return Zero on success or a value from @ref errno.h on failure.
267
 */
268
ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
999 palkovsky 269
        ipcarg_t arg2)
954 palkovsky 270
{
1330 palkovsky 271
    return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
954 palkovsky 272
}
273
 
1343 jermar 274
/** Send a full answer to a received call.
275
 *
276
 * @param callid ID of the call being answered.
277
 * @param call Call data. Must be already initialized by the responder.
278
 *
279
 * @return Zero on success or a value from @ref errno.h on failure.
280
 */
281
ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
282
{
283
    return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
284
}
285
 
286
 
999 palkovsky 287
/** Try to dispatch queed calls from async queue */
288
static void try_dispatch_queued_calls(void)
289
{
290
    async_call_t *call;
291
    ipc_callid_t callid;
292
 
1463 palkovsky 293
    /* TODO: integrate intelligently ipc_futex, so that it
294
     * is locked during ipc_call_async, until it is added
295
     * to dispatched_calls
296
     */
297
    futex_down(&async_futex);
999 palkovsky 298
    while (!list_empty(&queued_calls)) {
299
        call = list_get_instance(queued_calls.next, async_call_t,
300
                     list);
301
 
302
        callid = _ipc_call_async(call->u.msg.phoneid,
303
                     &call->u.msg.data);
1463 palkovsky 304
        if (callid == IPC_CALLRET_TEMPORARY) {
999 palkovsky 305
            break;
1463 palkovsky 306
        }
999 palkovsky 307
        list_remove(&call->list);
1350 palkovsky 308
 
1463 palkovsky 309
        futex_up(&async_futex);
1518 palkovsky 310
        if (call->ptid)
311
            psthread_add_ready(call->ptid);
1463 palkovsky 312
 
999 palkovsky 313
        if (callid == IPC_CALLRET_FATAL) {
1443 palkovsky 314
            if (call->callback)
315
                call->callback(call->private, ENOENT, NULL);
999 palkovsky 316
            free(call);
317
        } else {
318
            call->u.callid = callid;
1463 palkovsky 319
            futex_down(&ipc_futex);
999 palkovsky 320
            list_append(&call->list, &dispatched_calls);
1463 palkovsky 321
            futex_up(&ipc_futex);
999 palkovsky 322
        }
1463 palkovsky 323
        futex_down(&async_futex);
999 palkovsky 324
    }
1463 palkovsky 325
    futex_up(&async_futex);
999 palkovsky 326
}
327
 
328
/** Handle received answer
329
 *
330
 * TODO: Make it use hash table
331
 *
332
 * @param callid Callid (with first bit set) of the answered call
333
 */
1091 palkovsky 334
static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
999 palkovsky 335
{
336
    link_t *item;
337
    async_call_t *call;
338
 
339
    callid &= ~IPC_CALLID_ANSWERED;
340
 
1350 palkovsky 341
    futex_down(&ipc_futex);
999 palkovsky 342
    for (item = dispatched_calls.next; item != &dispatched_calls;
343
         item = item->next) {
344
        call = list_get_instance(item, async_call_t, list);
345
        if (call->u.callid == callid) {
346
            list_remove(&call->list);
1350 palkovsky 347
            futex_up(&ipc_futex);
1443 palkovsky 348
            if (call->callback)
349
                call->callback(call->private,
350
                           IPC_GET_RETVAL(*data),
351
                           data);
352
            free(call);
999 palkovsky 353
            return;
354
        }
355
    }
1350 palkovsky 356
    futex_up(&ipc_futex);
1751 palkovsky 357
    /* We may get here after async_msg, which doesn't register any callback */
999 palkovsky 358
}
359
 
360
 
1392 palkovsky 361
/** One cycle of ipc wait for call call
954 palkovsky 362
 *
363
 * - dispatch ASYNC reoutines in the background
1365 jermar 364
 * @param call Space where the message is stored
1392 palkovsky 365
 * @param usec Timeout in microseconds
366
 * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking)
1365 jermar 367
 * @return Callid of the answer.
954 palkovsky 368
 */
1392 palkovsky 369
ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
954 palkovsky 370
{
371
    ipc_callid_t callid;
372
 
1392 palkovsky 373
    callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
374
    /* Handle received answers */
1463 palkovsky 375
    if (callid & IPC_CALLID_ANSWERED) {
1392 palkovsky 376
        handle_answer(callid, call);
1463 palkovsky 377
        try_dispatch_queued_calls();
378
    }
999 palkovsky 379
 
954 palkovsky 380
    return callid;
381
}
1028 palkovsky 382
 
1365 jermar 383
/** Wait some time for an IPC call.
384
 *
385
 * - dispatch ASYNC reoutines in the background
1709 jermar 386
 *
1365 jermar 387
 * @param call Space where the message is stored
388
 * @param usec Timeout in microseconds.
389
 * @return Callid of the answer.
390
 */
391
ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
392
{
393
    ipc_callid_t callid;
394
 
395
    do {
1503 jermar 396
        callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
1365 jermar 397
    } while (callid & IPC_CALLID_ANSWERED);
398
 
399
    return callid;
400
}
401
 
402
/** Check if there is an IPC call waiting to be picked up.
403
 *
404
 * - dispatch ASYNC reoutines in the background
1709 jermar 405
 *
1365 jermar 406
 * @param call Space where the message is stored
407
 * @return Callid of the answer.
408
 */
409
ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
410
{
411
    ipc_callid_t callid;
412
 
413
    do {
1503 jermar 414
        callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
1365 jermar 415
    } while (callid & IPC_CALLID_ANSWERED);
416
 
417
    return callid;
418
}
419
 
1091 palkovsky 420
/** Ask destination to do a callback connection
421
 *
422
 * @return 0 - OK, error code
423
 */
424
int ipc_connect_to_me(int phoneid, int arg1, int arg2, ipcarg_t *phone)
1028 palkovsky 425
{
1091 palkovsky 426
    return ipc_call_sync_3(phoneid, IPC_M_CONNECT_TO_ME, arg1,
427
                   arg2, 0, 0, 0, phone);
1028 palkovsky 428
}
1061 palkovsky 429
 
1091 palkovsky 430
/** Ask through phone for a new connection to some service
431
 *
432
 * @return new phoneid - OK, error code
433
 */
1061 palkovsky 434
int ipc_connect_me_to(int phoneid, int arg1, int arg2)
435
{
1092 palkovsky 436
    ipcarg_t newphid;
1091 palkovsky 437
    int res;
438
 
439
    res =  ipc_call_sync_3(phoneid, IPC_M_CONNECT_ME_TO, arg1,
440
                   arg2, 0, 0, 0, &newphid);
441
    if (res)
442
        return res;
443
    return newphid;
1061 palkovsky 444
}
445
 
1089 palkovsky 446
/* Hang up specified phone */
447
int ipc_hangup(int phoneid)
448
{
449
    return __SYSCALL1(SYS_IPC_HANGUP, phoneid);
450
}
1259 palkovsky 451
 
1923 jermar 452
/** Register IRQ notification.
453
 *
454
 * @param inr IRQ number.
455
 * @param devno Device number of the device generating inr.
456
 * @param method Use this method for notifying me.
457
 * @param ucode Top-half pseudocode handler.
458
 *
459
 * @return Value returned by the kernel.
460
 */
461
int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode)
1259 palkovsky 462
{
1923 jermar 463
    return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method, (sysarg_t) ucode);
1259 palkovsky 464
}
465
 
1923 jermar 466
/** Unregister IRQ notification.
467
 *
468
 * @param inr IRQ number.
469
 * @param devno Device number of the device generating inr.
470
 *
471
 * @return Value returned by the kernel.
472
 */
473
int ipc_unregister_irq(int inr, int devno)
1259 palkovsky 474
{
1923 jermar 475
    return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
1259 palkovsky 476
}
1330 palkovsky 477
 
1336 jermar 478
int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1)
479
{
480
    return __SYSCALL4(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1);
481
}
482
 
1866 jermar 483
/** @}
1653 cejka 484
 */