Subversion Repositories HelenOS

Rev

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