Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
1351 palkovsky 1
/*
2071 jermar 2
 * Copyright (c) 2006 Ondrej Palkovsky
1351 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
 
1719 decky 29
/** @addtogroup libc
1653 cejka 30
 * @{
31
 */
32
/** @file
1351 palkovsky 33
 */
34
 
1392 palkovsky 35
/**
36
 * Asynchronous library
37
 *
2484 jermar 38
 * The aim of this library is facilitating writing programs utilizing the
39
 * asynchronous nature of HelenOS IPC, yet using a normal way of programming.
1392 palkovsky 40
 *
2484 jermar 41
 * You should be able to write very simple multithreaded programs, the async
42
 * framework will automatically take care of most synchronization problems.
1392 palkovsky 43
 *
44
 * Default semantics:
2484 jermar 45
 * - async_send_*():    send asynchronously. If the kernel refuses to send
46
 *          more messages, [ try to get responses from kernel, if
47
 *          nothing found, might try synchronous ]
1392 palkovsky 48
 *
2484 jermar 49
 * Example of use (pseudo C):
1392 palkovsky 50
 *
51
 * 1) Multithreaded client application
2484 jermar 52
 *
53
 * fibril_create(fibril1, ...);
54
 * fibril_create(fibril2, ...);
55
 * ...
1392 palkovsky 56
 *  
2484 jermar 57
 * int fibril1(void *arg)
58
 * {
59
 *  conn = ipc_connect_me_to();
60
 *  c1 = async_send(conn);
61
 *  c2 = async_send(conn);
62
 *  async_wait_for(c1);
63
 *  async_wait_for(c2);
64
 *  ...
65
 * }
1392 palkovsky 66
 *
67
 *
68
 * 2) Multithreaded server application
2484 jermar 69
 * main()
70
 * {
71
 *  async_manager();
1392 palkovsky 72
 * }
73
 *
74
 *
2484 jermar 75
 * client_connection(icallid, *icall)
76
 * {
77
 *  if (want_refuse) {
78
 *      ipc_answer_fast(icallid, ELIMIT, 0, 0);
79
 *      return;
80
 *  }
81
 *  ipc_answer_fast(icallid, EOK, 0, 0);
1392 palkovsky 82
 *
2484 jermar 83
 *  callid = async_get_call(&call);
84
 *  handle_call(callid, call);
85
 *  ipc_answer_fast(callid, 1, 2, 3);
1407 palkovsky 86
 *
2484 jermar 87
 *  callid = async_get_call(&call);
88
 *  ....
1392 palkovsky 89
 * }
1404 palkovsky 90
 *
1392 palkovsky 91
 */
2484 jermar 92
 
1392 palkovsky 93
#include <futex.h>
94
#include <async.h>
2482 jermar 95
#include <fibril.h>
1392 palkovsky 96
#include <stdio.h>
97
#include <libadt/hash_table.h>
98
#include <libadt/list.h>
99
#include <ipc/ipc.h>
100
#include <assert.h>
101
#include <errno.h>
1441 palkovsky 102
#include <time.h>
103
#include <arch/barrier.h>
1392 palkovsky 104
 
1463 palkovsky 105
atomic_t async_futex = FUTEX_INITIALIZER;
1392 palkovsky 106
static hash_table_t conn_hash_table;
1441 palkovsky 107
static LIST_INITIALIZE(timeout_list);
1392 palkovsky 108
 
109
typedef struct {
2482 jermar 110
    /** Expiration time for waiting fibril. */
111
    struct timeval expires;    
112
    /** If true, this struct is in the timeout list. */
113
    int inlist;
1500 palkovsky 114
    link_t link;
115
 
2482 jermar 116
    /** Fibril waiting for this message. */
117
    fid_t fid;
118
    /** If this fibril is currently active. */
119
    int active;
120
    /** If true, we timed out. */
121
    int timedout;
1500 palkovsky 122
} awaiter_t;
123
 
124
typedef struct {
125
    awaiter_t wdata;
126
 
1971 jermar 127
    int done;                   /**< If reply was received */
128
    ipc_call_t *dataptr;        /**< Pointer where the answer data
2482 jermar 129
                     *   is stored */
1427 palkovsky 130
    ipcarg_t retval;
131
} amsg_t;
132
 
133
typedef struct {
1392 palkovsky 134
    link_t link;
135
    ipc_callid_t callid;
136
    ipc_call_t call;
137
} msg_t;
138
 
139
typedef struct {
1500 palkovsky 140
    awaiter_t wdata;
141
 
2482 jermar 142
    link_t link;            /**< Hash table link. */
1971 jermar 143
    ipcarg_t in_phone_hash;     /**< Incoming phone hash. */
2482 jermar 144
    link_t msg_queue;       /**< Messages that should be delivered
145
                     *   to this fibril. */
1392 palkovsky 146
    /* Structures for connection opening packet */
147
    ipc_callid_t callid;
148
    ipc_call_t call;
2482 jermar 149
    ipc_callid_t close_callid;  /* Identification of closing packet. */
150
    void (*cfibril)(ipc_callid_t, ipc_call_t *);
1392 palkovsky 151
} connection_t;
152
 
2482 jermar 153
/** Identifier of the incoming connection handled by the current fibril. */
154
__thread connection_t *FIBRIL_connection;
1610 palkovsky 155
/** If true, it is forbidden to use async_req functions and
156
 *  all preemption is disabled */
157
__thread int in_interrupt_handler;
1392 palkovsky 158
 
1490 palkovsky 159
static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
1596 palkovsky 160
static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call);
1490 palkovsky 161
static async_client_conn_t client_connection = default_client_connection;
1596 palkovsky 162
static async_client_conn_t interrupt_received = default_interrupt_received;
1490 palkovsky 163
 
1441 palkovsky 164
/** Add microseconds to give timeval */
165
static void tv_add(struct timeval *tv, suseconds_t usecs)
166
{
167
    tv->tv_sec += usecs / 1000000;
168
    tv->tv_usec += usecs % 1000000;
169
    if (tv->tv_usec > 1000000) {
170
        tv->tv_sec++;
171
        tv->tv_usec -= 1000000;
172
    }
173
}
174
 
175
/** Subtract 2 timevals, return microseconds difference */
176
static suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2)
177
{
178
    suseconds_t result;
179
 
180
    result = tv1->tv_usec - tv2->tv_usec;
181
    result += (tv1->tv_sec - tv2->tv_sec) * 1000000;
182
 
183
    return result;
184
}
185
 
186
/** Compare timeval
187
 *
188
 * @return 1 if tv1 > tv2, otherwise 0
189
 */
190
static int tv_gt(struct timeval *tv1, struct timeval *tv2)
191
{
192
    if (tv1->tv_sec > tv2->tv_sec)
193
        return 1;
194
    if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec > tv2->tv_usec)
195
        return 1;
196
    return 0;
197
}
1466 palkovsky 198
static int tv_gteq(struct timeval *tv1, struct timeval *tv2)
199
{
200
    if (tv1->tv_sec > tv2->tv_sec)
201
        return 1;
202
    if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec >= tv2->tv_usec)
203
        return 1;
204
    return 0;
205
}
1441 palkovsky 206
 
1392 palkovsky 207
/* Hash table functions */
1404 palkovsky 208
#define CONN_HASH_TABLE_CHAINS  32
1392 palkovsky 209
 
210
static hash_index_t conn_hash(unsigned long *key)
1351 palkovsky 211
{
1392 palkovsky 212
    assert(key);
1404 palkovsky 213
    return ((*key) >> 4) % CONN_HASH_TABLE_CHAINS;
1351 palkovsky 214
}
215
 
1392 palkovsky 216
static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
1351 palkovsky 217
{
1392 palkovsky 218
    connection_t *hs;
219
 
220
    hs = hash_table_get_instance(item, connection_t, link);
221
 
222
    return key[0] == hs->in_phone_hash;
1351 palkovsky 223
}
224
 
1392 palkovsky 225
static void conn_remove(link_t *item)
1351 palkovsky 226
{
1392 palkovsky 227
    free(hash_table_get_instance(item, connection_t, link));
1351 palkovsky 228
}
229
 
1392 palkovsky 230
 
231
/** Operations for NS hash table. */
232
static hash_table_operations_t conn_hash_table_ops = {
233
    .hash = conn_hash,
234
    .compare = conn_compare,
235
    .remove_callback = conn_remove
236
};
237
 
1500 palkovsky 238
/** Insert sort timeout msg into timeouts list
239
 *
240
 */
241
static void insert_timeout(awaiter_t *wd)
242
{
243
    link_t *tmp;
244
    awaiter_t *cur;
245
 
246
    wd->timedout = 0;
1610 palkovsky 247
    wd->inlist = 1;
1500 palkovsky 248
 
249
    tmp = timeout_list.next;
250
    while (tmp != &timeout_list) {
251
        cur = list_get_instance(tmp, awaiter_t, link);
252
        if (tv_gteq(&cur->expires, &wd->expires))
253
            break;
254
        tmp = tmp->next;
255
    }
256
    list_append(&wd->link, tmp);
257
}
258
 
2485 jermar 259
/** Try to route a call to an appropriate connection fibril
1392 palkovsky 260
 *
261
 */
262
static int route_call(ipc_callid_t callid, ipc_call_t *call)
1351 palkovsky 263
{
1392 palkovsky 264
    connection_t *conn;
265
    msg_t *msg;
266
    link_t *hlp;
267
    unsigned long key;
268
 
1427 palkovsky 269
    futex_down(&async_futex);
1392 palkovsky 270
 
271
    key = call->in_phone_hash;
272
    hlp = hash_table_find(&conn_hash_table, &key);
273
    if (!hlp) {
1427 palkovsky 274
        futex_up(&async_futex);
1392 palkovsky 275
        return 0;
1351 palkovsky 276
    }
1392 palkovsky 277
    conn = hash_table_get_instance(hlp, connection_t, link);
1351 palkovsky 278
 
1392 palkovsky 279
    msg = malloc(sizeof(*msg));
280
    msg->callid = callid;
281
    msg->call = *call;
282
    list_append(&msg->link, &conn->msg_queue);
1648 palkovsky 283
 
284
    if (IPC_GET_METHOD(*call) == IPC_M_PHONE_HUNGUP)
285
        conn->close_callid = callid;
1392 palkovsky 286
 
1500 palkovsky 287
    /* If the call is waiting for event, run it */
288
    if (!conn->wdata.active) {
289
        /* If in timeout list, remove it */
290
        if (conn->wdata.inlist) {
291
            conn->wdata.inlist = 0;
292
            list_remove(&conn->wdata.link);
293
        }
294
        conn->wdata.active = 1;
2482 jermar 295
        fibril_add_ready(conn->wdata.fid);
1392 palkovsky 296
    }
1351 palkovsky 297
 
1427 palkovsky 298
    futex_up(&async_futex);
1392 palkovsky 299
 
300
    return 1;
301
}
302
 
2485 jermar 303
/** Return new incoming message for the current (fibril-local) connection */
1500 palkovsky 304
ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
1392 palkovsky 305
{
306
    msg_t *msg;
307
    ipc_callid_t callid;
1536 palkovsky 308
    connection_t *conn;
1392 palkovsky 309
 
2482 jermar 310
    assert(FIBRIL_connection);
311
    /* GCC 4.1.0 coughs on FIBRIL_connection-> dereference,
1536 palkovsky 312
     * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot.
313
     *           I would never expect to find so many errors in
314
     *           compiler *($&$(*&$
315
     */
2482 jermar 316
    conn = FIBRIL_connection;
1466 palkovsky 317
 
1427 palkovsky 318
    futex_down(&async_futex);
1392 palkovsky 319
 
1500 palkovsky 320
    if (usecs) {
1536 palkovsky 321
        gettimeofday(&conn->wdata.expires, NULL);
322
        tv_add(&conn->wdata.expires, usecs);
1500 palkovsky 323
    } else {
1536 palkovsky 324
        conn->wdata.inlist = 0;
1500 palkovsky 325
    }
1392 palkovsky 326
    /* If nothing in queue, wait until something appears */
1536 palkovsky 327
    while (list_empty(&conn->msg_queue)) {
1610 palkovsky 328
        if (usecs)
1536 palkovsky 329
            insert_timeout(&conn->wdata);
1610 palkovsky 330
 
1536 palkovsky 331
        conn->wdata.active = 0;
2482 jermar 332
        fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
1500 palkovsky 333
        /* Futex is up after getting back from async_manager
334
         * get it again */
335
        futex_down(&async_futex);
2482 jermar 336
        if (usecs && conn->wdata.timedout &&
1536 palkovsky 337
            list_empty(&conn->msg_queue)) {
1500 palkovsky 338
            /* If we timed out-> exit */
339
            futex_up(&async_futex);
340
            return 0;
341
        }
1351 palkovsky 342
    }
343
 
1536 palkovsky 344
    msg = list_get_instance(conn->msg_queue.next, msg_t, link);
1392 palkovsky 345
    list_remove(&msg->link);
346
    callid = msg->callid;
347
    *call = msg->call;
348
    free(msg);
349
 
1427 palkovsky 350
    futex_up(&async_futex);
1392 palkovsky 351
    return callid;
1351 palkovsky 352
}
353
 
2485 jermar 354
/** Fibril function that gets created on new connection
1404 palkovsky 355
 *
356
 * This function is defined as a weak symbol - to be redefined in
357
 * user code.
358
 */
1490 palkovsky 359
static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
1392 palkovsky 360
{
1404 palkovsky 361
    ipc_answer_fast(callid, ENOENT, 0, 0);
1392 palkovsky 362
}
1596 palkovsky 363
static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
1452 palkovsky 364
{
365
}
366
 
2485 jermar 367
/** Wrapper for client connection fibril.
1404 palkovsky 368
 *
2485 jermar 369
 * When new connection arrives, a fibril with this implementing function is
370
 * created. It calls client_connection() and does the final cleanup.
1404 palkovsky 371
 *
2485 jermar 372
 * @param arg       Connection structure pointer
373
 *
374
 * @return      Always zero.
1404 palkovsky 375
 */
2482 jermar 376
static int connection_fibril(void  *arg)
1351 palkovsky 377
{
1404 palkovsky 378
    unsigned long key;
379
    msg_t *msg;
1648 palkovsky 380
    int close_answered = 0;
1404 palkovsky 381
 
2485 jermar 382
    /* Setup fibril-local connection pointer */
2482 jermar 383
    FIBRIL_connection = (connection_t *) arg;
384
    FIBRIL_connection->cfibril(FIBRIL_connection->callid,
385
        &FIBRIL_connection->call);
1719 decky 386
 
1404 palkovsky 387
    /* Remove myself from connection hash table */
1427 palkovsky 388
    futex_down(&async_futex);
2482 jermar 389
    key = FIBRIL_connection->in_phone_hash;
1404 palkovsky 390
    hash_table_remove(&conn_hash_table, &key, 1);
1427 palkovsky 391
    futex_up(&async_futex);
1719 decky 392
 
1404 palkovsky 393
    /* Answer all remaining messages with ehangup */
2482 jermar 394
    while (!list_empty(&FIBRIL_connection->msg_queue)) {
395
        msg = list_get_instance(FIBRIL_connection->msg_queue.next,
396
            msg_t, link);
1404 palkovsky 397
        list_remove(&msg->link);
2482 jermar 398
        if (msg->callid == FIBRIL_connection->close_callid)
1648 palkovsky 399
            close_answered = 1;
1404 palkovsky 400
        ipc_answer_fast(msg->callid, EHANGUP, 0, 0);
401
        free(msg);
402
    }
2482 jermar 403
    if (FIBRIL_connection->close_callid)
404
        ipc_answer_fast(FIBRIL_connection->close_callid, 0, 0, 0);
1719 decky 405
 
406
    return 0;
1351 palkovsky 407
}
1392 palkovsky 408
 
2485 jermar 409
/** Create a new fibril for a new connection.
1392 palkovsky 410
 *
2485 jermar 411
 * Creates new fibril for connection, fills in connection structures and inserts
412
 * it into the hash table, so that later we can easily do routing of messages to
413
 * particular fibrils.
1407 palkovsky 414
 *
2485 jermar 415
 * @param in_phone_hash Identification of the incoming connection
416
 * @param callid    Callid of the IPC_M_CONNECT_ME_TO packet
417
 * @param call      Call data of the opening packet
418
 * @param cfibril   Fibril function that should be called upon
419
 *                  opening the connection
420
 * @return      New fibril id.
1392 palkovsky 421
 */
2482 jermar 422
fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
423
    ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *))
1392 palkovsky 424
{
425
    connection_t *conn;
426
    unsigned long key;
427
 
428
    conn = malloc(sizeof(*conn));
429
    if (!conn) {
430
        ipc_answer_fast(callid, ENOMEM, 0, 0);
1407 palkovsky 431
        return NULL;
1392 palkovsky 432
    }
1452 palkovsky 433
    conn->in_phone_hash = in_phone_hash;
1392 palkovsky 434
    list_initialize(&conn->msg_queue);
435
    conn->callid = callid;
1648 palkovsky 436
    conn->close_callid = 0;
1453 palkovsky 437
    if (call)
438
        conn->call = *call;
1500 palkovsky 439
    conn->wdata.active = 1; /* We will activate it asap */
2482 jermar 440
    conn->cfibril = cfibril;
1500 palkovsky 441
 
2482 jermar 442
    conn->wdata.fid = fibril_create(connection_fibril, conn);
443
    if (!conn->wdata.fid) {
1392 palkovsky 444
        free(conn);
445
        ipc_answer_fast(callid, ENOMEM, 0, 0);
1407 palkovsky 446
        return NULL;
1392 palkovsky 447
    }
1500 palkovsky 448
    /* Add connection to hash table */
1392 palkovsky 449
    key = conn->in_phone_hash;
1427 palkovsky 450
    futex_down(&async_futex);
1392 palkovsky 451
    hash_table_insert(&conn_hash_table, &key, &conn->link);
1427 palkovsky 452
    futex_up(&async_futex);
1392 palkovsky 453
 
2482 jermar 454
    fibril_add_ready(conn->wdata.fid);
1407 palkovsky 455
 
2482 jermar 456
    return conn->wdata.fid;
1392 palkovsky 457
}
458
 
2485 jermar 459
/** Handle a call that was received. */
1392 palkovsky 460
static void handle_call(ipc_callid_t callid, ipc_call_t *call)
461
{
1452 palkovsky 462
    /* Unrouted call - do some default behaviour */
1694 palkovsky 463
    if ((callid & IPC_CALLID_NOTIFICATION)) {
1610 palkovsky 464
        in_interrupt_handler = 1;
1596 palkovsky 465
        (*interrupt_received)(callid,call);
1610 palkovsky 466
        in_interrupt_handler = 0;
1452 palkovsky 467
        return;
1694 palkovsky 468
    }      
469
 
470
    switch (IPC_GET_METHOD(*call)) {
1392 palkovsky 471
    case IPC_M_CONNECT_ME_TO:
2485 jermar 472
        /* Open new connection with fibril etc. */
2482 jermar 473
        async_new_connection(IPC_GET_ARG3(*call), callid, call,
474
            client_connection);
1452 palkovsky 475
        return;
1392 palkovsky 476
    }
1452 palkovsky 477
 
478
    /* Try to route call through connection tables */
479
    if (route_call(callid, call))
480
        return;
481
 
482
    /* Unknown call from unknown phone - hang it up */
483
    ipc_answer_fast(callid, EHANGUP, 0, 0);
1392 palkovsky 484
}
485
 
2485 jermar 486
/** Fire all timeouts that expired. */
1441 palkovsky 487
static void handle_expired_timeouts(void)
488
{
489
    struct timeval tv;
1500 palkovsky 490
    awaiter_t *waiter;
1441 palkovsky 491
    link_t *cur;
492
 
493
    gettimeofday(&tv,NULL);
494
    futex_down(&async_futex);
495
 
496
    cur = timeout_list.next;
497
    while (cur != &timeout_list) {
2482 jermar 498
        waiter = list_get_instance(cur, awaiter_t, link);
1500 palkovsky 499
        if (tv_gt(&waiter->expires, &tv))
1441 palkovsky 500
            break;
501
        cur = cur->next;
1500 palkovsky 502
        list_remove(&waiter->link);
503
        waiter->inlist = 0;
504
        waiter->timedout = 1;
2485 jermar 505
        /* Redundant condition? The fibril should not
1441 palkovsky 506
         * be active when it gets here.
507
         */
1500 palkovsky 508
        if (!waiter->active) {
509
            waiter->active = 1;
2482 jermar 510
            fibril_add_ready(waiter->fid);
1441 palkovsky 511
        }
512
    }
513
 
514
    futex_up(&async_futex);
515
}
516
 
1392 palkovsky 517
/** Endless loop dispatching incoming calls and answers */
1610 palkovsky 518
static int async_manager_worker(void)
1392 palkovsky 519
{
520
    ipc_call_t call;
521
    ipc_callid_t callid;
1435 palkovsky 522
    int timeout;
1500 palkovsky 523
    awaiter_t *waiter;
1441 palkovsky 524
    struct timeval tv;
1392 palkovsky 525
 
526
    while (1) {
2482 jermar 527
        if (fibril_schedule_next_adv(FIBRIL_FROM_MANAGER)) {
1719 decky 528
            futex_up(&async_futex);
529
            /* async_futex is always held
2485 jermar 530
             * when entering manager fibril
1719 decky 531
             */
1392 palkovsky 532
            continue;
533
        }
1441 palkovsky 534
        futex_down(&async_futex);
535
        if (!list_empty(&timeout_list)) {
2482 jermar 536
            waiter = list_get_instance(timeout_list.next, awaiter_t,
537
                link);
538
            gettimeofday(&tv, NULL);
1500 palkovsky 539
            if (tv_gteq(&tv, &waiter->expires)) {
1536 palkovsky 540
                futex_up(&async_futex);
1441 palkovsky 541
                handle_expired_timeouts();
542
                continue;
543
            } else
1500 palkovsky 544
                timeout = tv_sub(&waiter->expires, &tv);
1441 palkovsky 545
        } else
1435 palkovsky 546
            timeout = SYNCH_NO_TIMEOUT;
1441 palkovsky 547
        futex_up(&async_futex);
548
 
1503 jermar 549
        callid = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE);
1392 palkovsky 550
 
1435 palkovsky 551
        if (!callid) {
1441 palkovsky 552
            handle_expired_timeouts();
1435 palkovsky 553
            continue;
554
        }
555
 
1610 palkovsky 556
        if (callid & IPC_CALLID_ANSWERED) {
1392 palkovsky 557
            continue;
1610 palkovsky 558
        }
1427 palkovsky 559
 
1392 palkovsky 560
        handle_call(callid, &call);
561
    }
1719 decky 562
 
563
    return 0;
1392 palkovsky 564
}
565
 
2485 jermar 566
/** Function to start async_manager as a standalone fibril.
1404 palkovsky 567
 *
568
 * When more kernel threads are used, one async manager should
2485 jermar 569
 * exist per thread.
1404 palkovsky 570
 */
2484 jermar 571
static int async_manager_fibril(void *arg)
1392 palkovsky 572
{
1719 decky 573
    futex_up(&async_futex);
574
    /* async_futex is always locked when entering
575
     * manager */
1610 palkovsky 576
    async_manager_worker();
1719 decky 577
 
578
    return 0;
1392 palkovsky 579
}
580
 
581
/** Add one manager to manager list */
582
void async_create_manager(void)
583
{
2482 jermar 584
    fid_t fid;
1392 palkovsky 585
 
2484 jermar 586
    fid = fibril_create(async_manager_fibril, NULL);
2482 jermar 587
    fibril_add_manager(fid);
1392 palkovsky 588
}
589
 
590
/** Remove one manager from manager list */
591
void async_destroy_manager(void)
592
{
2482 jermar 593
    fibril_remove_manager();
1392 palkovsky 594
}
595
 
596
/** Initialize internal structures needed for async manager */
597
int _async_init(void)
598
{
2482 jermar 599
    if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1,
600
        &conn_hash_table_ops)) {
1392 palkovsky 601
        printf("%s: cannot create hash table\n", "async");
602
        return ENOMEM;
603
    }
604
 
1719 decky 605
    return 0;
1392 palkovsky 606
}
1427 palkovsky 607
 
608
/** IPC handler for messages in async framework
609
 *
2482 jermar 610
 * Notify the fibril which is waiting for this message, that it arrived
1427 palkovsky 611
 */
2485 jermar 612
static void reply_received(void *private, int retval, ipc_call_t *data)
1427 palkovsky 613
{
614
    amsg_t *msg = (amsg_t *) private;
615
 
616
    msg->retval = retval;
617
 
618
    futex_down(&async_futex);
619
    /* Copy data after futex_down, just in case the
620
     * call was detached
621
     */
622
    if (msg->dataptr)
623
        *msg->dataptr = *data;
1435 palkovsky 624
 
1441 palkovsky 625
    write_barrier();
626
    /* Remove message from timeout list */
1500 palkovsky 627
    if (msg->wdata.inlist)
628
        list_remove(&msg->wdata.link);
1427 palkovsky 629
    msg->done = 1;
1500 palkovsky 630
    if (! msg->wdata.active) {
631
        msg->wdata.active = 1;
2482 jermar 632
        fibril_add_ready(msg->wdata.fid);
1427 palkovsky 633
    }
634
    futex_up(&async_futex);
635
}
636
 
637
/** Send message and return id of the sent message
638
 *
639
 * The return value can be used as input for async_wait() to wait
640
 * for completion.
641
 */
642
aid_t async_send_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
2485 jermar 643
    ipc_call_t *dataptr)
1427 palkovsky 644
{
645
    amsg_t *msg;
646
 
1610 palkovsky 647
    if (in_interrupt_handler) {
2482 jermar 648
        printf("Cannot send asynchronous request in interrupt "
649
            "handler.\n");
1610 palkovsky 650
        _exit(1);
651
    }
652
 
1427 palkovsky 653
    msg = malloc(sizeof(*msg));
654
    msg->done = 0;
655
    msg->dataptr = dataptr;
1500 palkovsky 656
 
657
    msg->wdata.active = 1; /* We may sleep in next method, but it
658
                * will use it's own mechanism */
2482 jermar 659
    ipc_call_async_2(phoneid, method, arg1, arg2, msg, reply_received, 1);
1427 palkovsky 660
 
661
    return (aid_t) msg;
662
}
663
 
1547 palkovsky 664
/** Send message and return id of the sent message
665
 *
666
 * The return value can be used as input for async_wait() to wait
667
 * for completion.
668
 */
669
aid_t async_send_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
2485 jermar 670
    ipcarg_t arg3, ipc_call_t *dataptr)
1547 palkovsky 671
{
672
    amsg_t *msg;
673
 
1610 palkovsky 674
    if (in_interrupt_handler) {
1923 jermar 675
        printf("Cannot send asynchronous request in interrupt handler.\n");
1610 palkovsky 676
        _exit(1);
677
    }
678
 
1547 palkovsky 679
    msg = malloc(sizeof(*msg));
680
    msg->done = 0;
681
    msg->dataptr = dataptr;
682
 
683
    msg->wdata.active = 1; /* We may sleep in next method, but it
684
                * will use it's own mechanism */
2482 jermar 685
    ipc_call_async_3(phoneid, method, arg1, arg2, arg3, msg, reply_received,
686
        1);
1547 palkovsky 687
 
688
    return (aid_t) msg;
689
}
690
 
1427 palkovsky 691
/** Wait for a message sent by async framework
692
 *
2485 jermar 693
 * @param amsgid    Message ID to wait for
694
 * @param retval    Pointer to variable where will be stored retval of the
695
 *          answered message. If NULL, it is ignored.
1427 palkovsky 696
 */
697
void async_wait_for(aid_t amsgid, ipcarg_t *retval)
698
{
699
    amsg_t *msg = (amsg_t *) amsgid;
700
 
701
    futex_down(&async_futex);
702
    if (msg->done) {
703
        futex_up(&async_futex);
704
        goto done;
705
    }
706
 
2482 jermar 707
    msg->wdata.fid = fibril_get_id();
1500 palkovsky 708
    msg->wdata.active = 0;
709
    msg->wdata.inlist = 0;
1427 palkovsky 710
    /* Leave locked async_futex when entering this function */
2482 jermar 711
    fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
712
    /* futex is up automatically after fibril_schedule_next...*/
1427 palkovsky 713
done:
714
    if (retval)
715
        *retval = msg->retval;
716
    free(msg);
717
}
1435 palkovsky 718
 
1441 palkovsky 719
/** Wait for a message sent by async framework with timeout
720
 *
721
 * @param amsgid Message ID to wait for
722
 * @param retval Pointer to variable where will be stored retval
723
 *               of the answered message. If NULL, it is ignored.
724
 * @param timeout Timeout in usecs
725
 * @return 0 on success, ETIMEOUT if timeout expired
726
 *
727
 */
728
int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, suseconds_t timeout)
729
{
730
    amsg_t *msg = (amsg_t *) amsgid;
1435 palkovsky 731
 
1532 palkovsky 732
    /* TODO: Let it go through the event read at least once */
733
    if (timeout < 0)
734
        return ETIMEOUT;
735
 
1441 palkovsky 736
    futex_down(&async_futex);
737
    if (msg->done) {
738
        futex_up(&async_futex);
739
        goto done;
740
    }
1435 palkovsky 741
 
1500 palkovsky 742
    gettimeofday(&msg->wdata.expires, NULL);
743
    tv_add(&msg->wdata.expires, timeout);
1435 palkovsky 744
 
2482 jermar 745
    msg->wdata.fid = fibril_get_id();
1500 palkovsky 746
    msg->wdata.active = 0;
747
    insert_timeout(&msg->wdata);
748
 
1441 palkovsky 749
    /* Leave locked async_futex when entering this function */
2482 jermar 750
    fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
751
    /* futex is up automatically after fibril_schedule_next...*/
1435 palkovsky 752
 
1441 palkovsky 753
    if (!msg->done)
754
        return ETIMEOUT;
755
 
756
done:
757
    if (retval)
758
        *retval = msg->retval;
759
    free(msg);
760
 
761
    return 0;
762
}
763
 
1452 palkovsky 764
/** Wait specified time, but in the meantime handle incoming events
765
 *
766
 * @param timeout Time in microseconds to wait
767
 */
768
void async_usleep(suseconds_t timeout)
769
{
770
    amsg_t *msg;
771
 
1610 palkovsky 772
    if (in_interrupt_handler) {
773
        printf("Cannot call async_usleep in interrupt handler.\n");
774
        _exit(1);
775
    }
776
 
1452 palkovsky 777
    msg = malloc(sizeof(*msg));
778
    if (!msg)
779
        return;
780
 
2482 jermar 781
    msg->wdata.fid = fibril_get_id();
1500 palkovsky 782
    msg->wdata.active = 0;
1452 palkovsky 783
 
1500 palkovsky 784
    gettimeofday(&msg->wdata.expires, NULL);
785
    tv_add(&msg->wdata.expires, timeout);
1452 palkovsky 786
 
787
    futex_down(&async_futex);
1500 palkovsky 788
    insert_timeout(&msg->wdata);
2485 jermar 789
    /* Leave locked the async_futex when entering this function */
2482 jermar 790
    fibril_schedule_next_adv(FIBRIL_TO_MANAGER);
2485 jermar 791
    /* futex is up automatically after fibril_schedule_next_adv()...*/
1452 palkovsky 792
    free(msg);
793
}
1490 palkovsky 794
 
2485 jermar 795
/** Set function that is called when IPC_M_CONNECT_ME_TO is received.
1490 palkovsky 796
 *
2485 jermar 797
 * @param conn Function that will form a new fibril.
1490 palkovsky 798
 */
799
void async_set_client_connection(async_client_conn_t conn)
800
{
801
    client_connection = conn;
802
}
1596 palkovsky 803
void async_set_interrupt_received(async_client_conn_t conn)
804
{
805
    interrupt_received = conn;
806
}
1610 palkovsky 807
 
808
/* Primitive functions for simple communication */
809
void async_msg_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
810
         ipcarg_t arg2, ipcarg_t arg3)
811
{
2482 jermar 812
    ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL,
813
        !in_interrupt_handler);
1610 palkovsky 814
}
815
 
816
void async_msg_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
817
{
2482 jermar 818
    ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL,
819
        !in_interrupt_handler);
1610 palkovsky 820
}
1653 cejka 821
 
1719 decky 822
/** @}
1653 cejka 823
 */