Subversion Repositories HelenOS

Rev

Rev 2569 | Rev 2621 | 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
 *
2490 jermar 75
 * my_client_connection(icallid, *icall)
2484 jermar 76
 * {
77
 *  if (want_refuse) {
2619 jermar 78
 *      ipc_answer_0(icallid, ELIMIT);
2484 jermar 79
 *      return;
80
 *  }
2619 jermar 81
 *  ipc_answer_0(icallid, EOK);
1392 palkovsky 82
 *
2484 jermar 83
 *  callid = async_get_call(&call);
84
 *  handle_call(callid, call);
2619 jermar 85
 *  ipc_answer_2(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>
2486 jermar 102
#include <sys/time.h>
1441 palkovsky 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
 
2488 jermar 109
/** Structures of this type represent a waiting fibril. */
1392 palkovsky 110
typedef struct {
2488 jermar 111
    /** Expiration time. */
2482 jermar 112
    struct timeval expires;    
113
    /** If true, this struct is in the timeout list. */
114
    int inlist;
2488 jermar 115
    /** Timeout list link. */
1500 palkovsky 116
    link_t link;
117
 
2490 jermar 118
    /** Identification of and link to the waiting fibril. */
2482 jermar 119
    fid_t fid;
2488 jermar 120
    /** If true, this fibril is currently active. */
2482 jermar 121
    int active;
2488 jermar 122
    /** If true, we have timed out. */
2482 jermar 123
    int timedout;
1500 palkovsky 124
} awaiter_t;
125
 
126
typedef struct {
127
    awaiter_t wdata;
2488 jermar 128
 
129
    /** If reply was received. */
130
    int done;
131
    /** Pointer to where the answer data is stored. */
132
    ipc_call_t *dataptr;
1500 palkovsky 133
 
1427 palkovsky 134
    ipcarg_t retval;
135
} amsg_t;
136
 
2490 jermar 137
/**
138
 * Structures of this type are used to group information about a call and a
139
 * message queue link.
140
 */
1427 palkovsky 141
typedef struct {
1392 palkovsky 142
    link_t link;
143
    ipc_callid_t callid;
144
    ipc_call_t call;
145
} msg_t;
146
 
147
typedef struct {
1500 palkovsky 148
    awaiter_t wdata;
149
 
2488 jermar 150
    /** Hash table link. */
151
    link_t link;
152
 
153
    /** Incoming phone hash. */
154
    ipcarg_t in_phone_hash;    
155
 
156
    /** Messages that should be delivered to this fibril. */
157
    link_t msg_queue;      
158
 
159
    /** Identification of the opening call. */
1392 palkovsky 160
    ipc_callid_t callid;
2488 jermar 161
    /** Call data of the opening call. */
1392 palkovsky 162
    ipc_call_t call;
2488 jermar 163
 
164
    /** Identification of the closing call. */
165
    ipc_callid_t close_callid;
166
 
167
    /** Fibril function that will be used to handle the connection. */
2482 jermar 168
    void (*cfibril)(ipc_callid_t, ipc_call_t *);
1392 palkovsky 169
} connection_t;
170
 
2482 jermar 171
/** Identifier of the incoming connection handled by the current fibril. */
172
__thread connection_t *FIBRIL_connection;
2488 jermar 173
 
2490 jermar 174
/**
175
 * If true, it is forbidden to use async_req functions and all preemption is
176
 * disabled.
177
 */
1610 palkovsky 178
__thread int in_interrupt_handler;
1392 palkovsky 179
 
1490 palkovsky 180
static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
1596 palkovsky 181
static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call);
2490 jermar 182
 
183
/**
184
 * Pointer to a fibril function that will be used to handle connections.
185
 */
1490 palkovsky 186
static async_client_conn_t client_connection = default_client_connection;
2490 jermar 187
/**
188
 * Pointer to a fibril function that will be used to handle interrupt
189
 * notifications.
190
 */
1596 palkovsky 191
static async_client_conn_t interrupt_received = default_interrupt_received;
1490 palkovsky 192
 
1404 palkovsky 193
#define CONN_HASH_TABLE_CHAINS  32
1392 palkovsky 194
 
2488 jermar 195
/** Compute hash into the connection hash table based on the source phone hash.
196
 *
197
 * @param key       Pointer to source phone hash.
198
 *
199
 * @return      Index into the connection hash table.
200
 */
1392 palkovsky 201
static hash_index_t conn_hash(unsigned long *key)
1351 palkovsky 202
{
1392 palkovsky 203
    assert(key);
1404 palkovsky 204
    return ((*key) >> 4) % CONN_HASH_TABLE_CHAINS;
1351 palkovsky 205
}
206
 
2488 jermar 207
/** Compare hash table item with a key.
208
 *
209
 * @param key       Array containing the source phone hash as the only item.
210
 * @param keys      Expected 1 but ignored.
211
 * @param item      Connection hash table item.
212
 *
213
 * @return      True on match, false otherwise.
214
 */
1392 palkovsky 215
static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
1351 palkovsky 216
{
1392 palkovsky 217
    connection_t *hs;
218
 
219
    hs = hash_table_get_instance(item, connection_t, link);
220
 
221
    return key[0] == hs->in_phone_hash;
1351 palkovsky 222
}
223
 
2488 jermar 224
/** Connection hash table removal callback function.
225
 *
226
 * This function is called whenever a connection is removed from the connection
227
 * hash table.
228
 *
229
 * @param item      Connection hash table item being removed.
230
 */
1392 palkovsky 231
static void conn_remove(link_t *item)
1351 palkovsky 232
{
1392 palkovsky 233
    free(hash_table_get_instance(item, connection_t, link));
1351 palkovsky 234
}
235
 
1392 palkovsky 236
 
2488 jermar 237
/** Operations for the connection hash table. */
1392 palkovsky 238
static hash_table_operations_t conn_hash_table_ops = {
239
    .hash = conn_hash,
240
    .compare = conn_compare,
241
    .remove_callback = conn_remove
242
};
243
 
2488 jermar 244
/** Sort in current fibril's timeout request.
1500 palkovsky 245
 *
2488 jermar 246
 * @param wd        Wait data of the current fibril.
1500 palkovsky 247
 */
248
static void insert_timeout(awaiter_t *wd)
249
{
250
    link_t *tmp;
251
    awaiter_t *cur;
252
 
253
    wd->timedout = 0;
1610 palkovsky 254
    wd->inlist = 1;
1500 palkovsky 255
 
256
    tmp = timeout_list.next;
257
    while (tmp != &timeout_list) {
258
        cur = list_get_instance(tmp, awaiter_t, link);
259
        if (tv_gteq(&cur->expires, &wd->expires))
260
            break;
261
        tmp = tmp->next;
262
    }
263
    list_append(&wd->link, tmp);
264
}
265
 
2488 jermar 266
/** Try to route a call to an appropriate connection fibril.
1392 palkovsky 267
 *
2490 jermar 268
 * If the proper connection fibril is found, a message with the call is added to
269
 * its message queue. If the fibril was not active, it is activated and all
270
 * timeouts are unregistered.
271
 *
272
 * @param callid    Hash of the incoming call.
273
 * @param call      Data of the incoming call.
274
 *
275
 * @return      Zero if the call doesn't match any connection.
276
 *          One if the call was passed to the respective connection
277
 *          fibril.
1392 palkovsky 278
 */
279
static int route_call(ipc_callid_t callid, ipc_call_t *call)
1351 palkovsky 280
{
1392 palkovsky 281
    connection_t *conn;
282
    msg_t *msg;
283
    link_t *hlp;
284
    unsigned long key;
285
 
1427 palkovsky 286
    futex_down(&async_futex);
1392 palkovsky 287
 
288
    key = call->in_phone_hash;
289
    hlp = hash_table_find(&conn_hash_table, &key);
290
    if (!hlp) {
1427 palkovsky 291
        futex_up(&async_futex);
1392 palkovsky 292
        return 0;
1351 palkovsky 293
    }
1392 palkovsky 294
    conn = hash_table_get_instance(hlp, connection_t, link);
1351 palkovsky 295
 
1392 palkovsky 296
    msg = malloc(sizeof(*msg));
297
    msg->callid = callid;
298
    msg->call = *call;
299
    list_append(&msg->link, &conn->msg_queue);
1648 palkovsky 300
 
301
    if (IPC_GET_METHOD(*call) == IPC_M_PHONE_HUNGUP)
302
        conn->close_callid = callid;
1392 palkovsky 303
 
2490 jermar 304
    /* If the connection fibril is waiting for an event, activate it */
1500 palkovsky 305
    if (!conn->wdata.active) {
306
        /* If in timeout list, remove it */
307
        if (conn->wdata.inlist) {
308
            conn->wdata.inlist = 0;
309
            list_remove(&conn->wdata.link);
310
        }
311
        conn->wdata.active = 1;
2482 jermar 312
        fibril_add_ready(conn->wdata.fid);
1392 palkovsky 313
    }
1351 palkovsky 314
 
1427 palkovsky 315
    futex_up(&async_futex);
1392 palkovsky 316
 
317
    return 1;
318
}
319
 
2488 jermar 320
/** Return new incoming message for the current (fibril-local) connection.
321
 *
322
 * @param call      Storage where the incoming call data will be stored.
323
 * @param usecs     Timeout in microseconds. Zero denotes no timeout.
324
 *
325
 * @return      If no timeout was specified, then a hash of the
326
 *          incoming call is returned. If a timeout is specified,
327
 *          then a hash of the incoming call is returned unless
328
 *          the timeout expires prior to receiving a message. In
329
 *          that case zero is returned.
330
 */
1500 palkovsky 331
ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
1392 palkovsky 332
{
333
    msg_t *msg;
334
    ipc_callid_t callid;
1536 palkovsky 335
    connection_t *conn;
1392 palkovsky 336
 
2482 jermar 337
    assert(FIBRIL_connection);
338
    /* GCC 4.1.0 coughs on FIBRIL_connection-> dereference,
1536 palkovsky 339
     * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot.
340
     *           I would never expect to find so many errors in
2490 jermar 341
     *           a compiler *($&$(*&$
1536 palkovsky 342
     */
2482 jermar 343
    conn = FIBRIL_connection;
1466 palkovsky 344
 
1427 palkovsky 345
    futex_down(&async_futex);
1392 palkovsky 346
 
1500 palkovsky 347
    if (usecs) {
1536 palkovsky 348
        gettimeofday(&conn->wdata.expires, NULL);
349
        tv_add(&conn->wdata.expires, usecs);
1500 palkovsky 350
    } else {
1536 palkovsky 351
        conn->wdata.inlist = 0;
1500 palkovsky 352
    }
2488 jermar 353
    /* If nothing in queue, wait until something arrives */
1536 palkovsky 354
    while (list_empty(&conn->msg_queue)) {
1610 palkovsky 355
        if (usecs)
1536 palkovsky 356
            insert_timeout(&conn->wdata);
1610 palkovsky 357
 
1536 palkovsky 358
        conn->wdata.active = 0;
2492 jermar 359
        /*
360
         * Note: the current fibril will be rescheduled either due to a
361
         * timeout or due to an arriving message destined to it. In the
362
         * former case, handle_expired_timeouts() and, in the latter
363
         * case, route_call() will perform the wakeup.
364
         */
2568 jermar 365
        fibril_switch(FIBRIL_TO_MANAGER);
2488 jermar 366
        /*
367
         * Futex is up after getting back from async_manager get it
368
         * again.
2492 jermar 369
         */
1500 palkovsky 370
        futex_down(&async_futex);
2482 jermar 371
        if (usecs && conn->wdata.timedout &&
1536 palkovsky 372
            list_empty(&conn->msg_queue)) {
2488 jermar 373
            /* If we timed out -> exit */
1500 palkovsky 374
            futex_up(&async_futex);
375
            return 0;
376
        }
1351 palkovsky 377
    }
378
 
1536 palkovsky 379
    msg = list_get_instance(conn->msg_queue.next, msg_t, link);
1392 palkovsky 380
    list_remove(&msg->link);
381
    callid = msg->callid;
382
    *call = msg->call;
383
    free(msg);
384
 
1427 palkovsky 385
    futex_up(&async_futex);
1392 palkovsky 386
    return callid;
1351 palkovsky 387
}
388
 
2490 jermar 389
/** Default fibril function that gets called to handle new connection.
1404 palkovsky 390
 *
2488 jermar 391
 * This function is defined as a weak symbol - to be redefined in user code.
2490 jermar 392
 *
393
 * @param callid    Hash of the incoming call.
394
 * @param call      Data of the incoming call.
1404 palkovsky 395
 */
1490 palkovsky 396
static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
1392 palkovsky 397
{
2619 jermar 398
    ipc_answer_0(callid, ENOENT);
1392 palkovsky 399
}
2490 jermar 400
 
401
/** Default fibril function that gets called to handle interrupt notifications.
402
 *
403
 * @param callid    Hash of the incoming call.
404
 * @param call      Data of the incoming call.
405
 */
1596 palkovsky 406
static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
1452 palkovsky 407
{
408
}
409
 
2485 jermar 410
/** Wrapper for client connection fibril.
1404 palkovsky 411
 *
2490 jermar 412
 * When a new connection arrives, a fibril with this implementing function is
2485 jermar 413
 * created. It calls client_connection() and does the final cleanup.
1404 palkovsky 414
 *
2490 jermar 415
 * @param arg       Connection structure pointer.
2485 jermar 416
 *
417
 * @return      Always zero.
1404 palkovsky 418
 */
2482 jermar 419
static int connection_fibril(void  *arg)
1351 palkovsky 420
{
1404 palkovsky 421
    unsigned long key;
422
    msg_t *msg;
1648 palkovsky 423
    int close_answered = 0;
1404 palkovsky 424
 
2485 jermar 425
    /* Setup fibril-local connection pointer */
2482 jermar 426
    FIBRIL_connection = (connection_t *) arg;
427
    FIBRIL_connection->cfibril(FIBRIL_connection->callid,
428
        &FIBRIL_connection->call);
1719 decky 429
 
2490 jermar 430
    /* Remove myself from the connection hash table */
1427 palkovsky 431
    futex_down(&async_futex);
2482 jermar 432
    key = FIBRIL_connection->in_phone_hash;
1404 palkovsky 433
    hash_table_remove(&conn_hash_table, &key, 1);
1427 palkovsky 434
    futex_up(&async_futex);
1719 decky 435
 
2490 jermar 436
    /* Answer all remaining messages with EHANGUP */
2482 jermar 437
    while (!list_empty(&FIBRIL_connection->msg_queue)) {
438
        msg = list_get_instance(FIBRIL_connection->msg_queue.next,
439
            msg_t, link);
1404 palkovsky 440
        list_remove(&msg->link);
2482 jermar 441
        if (msg->callid == FIBRIL_connection->close_callid)
1648 palkovsky 442
            close_answered = 1;
2619 jermar 443
        ipc_answer_0(msg->callid, EHANGUP);
1404 palkovsky 444
        free(msg);
445
    }
2482 jermar 446
    if (FIBRIL_connection->close_callid)
2619 jermar 447
        ipc_answer_0(FIBRIL_connection->close_callid, EOK);
1719 decky 448
 
449
    return 0;
1351 palkovsky 450
}
1392 palkovsky 451
 
2485 jermar 452
/** Create a new fibril for a new connection.
1392 palkovsky 453
 *
2485 jermar 454
 * Creates new fibril for connection, fills in connection structures and inserts
455
 * it into the hash table, so that later we can easily do routing of messages to
456
 * particular fibrils.
1407 palkovsky 457
 *
2490 jermar 458
 * @param in_phone_hash Identification of the incoming connection.
459
 * @param callid    Hash of the opening IPC_M_CONNECT_ME_TO call.
2534 jermar 460
 *          If callid is zero, the connection was opened by
461
 *          accepting the IPC_M_CONNECT_TO_ME call and this function
462
 *          is called directly by the server.
2490 jermar 463
 * @param call      Call data of the opening call.
464
 * @param cfibril   Fibril function that should be called upon opening the
465
 *          connection.
466
 *
467
 * @return      New fibril id or NULL on failure.
1392 palkovsky 468
 */
2482 jermar 469
fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
470
    ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *))
1392 palkovsky 471
{
472
    connection_t *conn;
473
    unsigned long key;
474
 
475
    conn = malloc(sizeof(*conn));
476
    if (!conn) {
2534 jermar 477
        if (callid)
2619 jermar 478
            ipc_answer_0(callid, ENOMEM);
1407 palkovsky 479
        return NULL;
1392 palkovsky 480
    }
1452 palkovsky 481
    conn->in_phone_hash = in_phone_hash;
1392 palkovsky 482
    list_initialize(&conn->msg_queue);
483
    conn->callid = callid;
1648 palkovsky 484
    conn->close_callid = 0;
1453 palkovsky 485
    if (call)
486
        conn->call = *call;
2490 jermar 487
    conn->wdata.active = 1; /* We will activate the fibril ASAP */
2482 jermar 488
    conn->cfibril = cfibril;
1500 palkovsky 489
 
2482 jermar 490
    conn->wdata.fid = fibril_create(connection_fibril, conn);
491
    if (!conn->wdata.fid) {
1392 palkovsky 492
        free(conn);
2534 jermar 493
        if (callid)
2619 jermar 494
            ipc_answer_0(callid, ENOMEM);
1407 palkovsky 495
        return NULL;
1392 palkovsky 496
    }
2490 jermar 497
    /* Add connection to the connection hash table */
1392 palkovsky 498
    key = conn->in_phone_hash;
1427 palkovsky 499
    futex_down(&async_futex);
1392 palkovsky 500
    hash_table_insert(&conn_hash_table, &key, &conn->link);
1427 palkovsky 501
    futex_up(&async_futex);
1392 palkovsky 502
 
2482 jermar 503
    fibril_add_ready(conn->wdata.fid);
1407 palkovsky 504
 
2482 jermar 505
    return conn->wdata.fid;
1392 palkovsky 506
}
507
 
2490 jermar 508
/** Handle a call that was received.
509
 *
510
 * If the call has the IPC_M_CONNECT_ME_TO method, a new connection is created.
511
 * Otherwise the call is routed to its connection fibril.
512
 *
513
 * @param callid    Hash of the incoming call.
514
 * @param call      Data of the incoming call.
515
 */
1392 palkovsky 516
static void handle_call(ipc_callid_t callid, ipc_call_t *call)
517
{
1452 palkovsky 518
    /* Unrouted call - do some default behaviour */
1694 palkovsky 519
    if ((callid & IPC_CALLID_NOTIFICATION)) {
1610 palkovsky 520
        in_interrupt_handler = 1;
2569 jermar 521
        (*interrupt_received)(callid, call);
1610 palkovsky 522
        in_interrupt_handler = 0;
1452 palkovsky 523
        return;
1694 palkovsky 524
    }      
525
 
526
    switch (IPC_GET_METHOD(*call)) {
1392 palkovsky 527
    case IPC_M_CONNECT_ME_TO:
2485 jermar 528
        /* Open new connection with fibril etc. */
2482 jermar 529
        async_new_connection(IPC_GET_ARG3(*call), callid, call,
530
            client_connection);
1452 palkovsky 531
        return;
1392 palkovsky 532
    }
1452 palkovsky 533
 
2490 jermar 534
    /* Try to route the call through the connection hash table */
1452 palkovsky 535
    if (route_call(callid, call))
536
        return;
537
 
538
    /* Unknown call from unknown phone - hang it up */
2619 jermar 539
    ipc_answer_0(callid, EHANGUP);
1392 palkovsky 540
}
541
 
2485 jermar 542
/** Fire all timeouts that expired. */
1441 palkovsky 543
static void handle_expired_timeouts(void)
544
{
545
    struct timeval tv;
1500 palkovsky 546
    awaiter_t *waiter;
1441 palkovsky 547
    link_t *cur;
548
 
2490 jermar 549
    gettimeofday(&tv, NULL);
1441 palkovsky 550
    futex_down(&async_futex);
551
 
552
    cur = timeout_list.next;
553
    while (cur != &timeout_list) {
2482 jermar 554
        waiter = list_get_instance(cur, awaiter_t, link);
1500 palkovsky 555
        if (tv_gt(&waiter->expires, &tv))
1441 palkovsky 556
            break;
557
        cur = cur->next;
1500 palkovsky 558
        list_remove(&waiter->link);
559
        waiter->inlist = 0;
560
        waiter->timedout = 1;
2490 jermar 561
        /*
562
         * Redundant condition?
563
         * The fibril should not be active when it gets here.
1441 palkovsky 564
         */
1500 palkovsky 565
        if (!waiter->active) {
566
            waiter->active = 1;
2482 jermar 567
            fibril_add_ready(waiter->fid);
1441 palkovsky 568
        }
569
    }
570
 
571
    futex_up(&async_futex);
572
}
573
 
2490 jermar 574
/** Endless loop dispatching incoming calls and answers.
575
 *
576
 * @return      Never returns.
577
 */
1610 palkovsky 578
static int async_manager_worker(void)
1392 palkovsky 579
{
580
    ipc_call_t call;
581
    ipc_callid_t callid;
1435 palkovsky 582
    int timeout;
1500 palkovsky 583
    awaiter_t *waiter;
1441 palkovsky 584
    struct timeval tv;
1392 palkovsky 585
 
586
    while (1) {
2568 jermar 587
        if (fibril_switch(FIBRIL_FROM_MANAGER)) {
1719 decky 588
            futex_up(&async_futex);
2490 jermar 589
            /*
590
             * async_futex is always held when entering a manager
591
             * fibril.
1719 decky 592
             */
1392 palkovsky 593
            continue;
594
        }
1441 palkovsky 595
        futex_down(&async_futex);
596
        if (!list_empty(&timeout_list)) {
2482 jermar 597
            waiter = list_get_instance(timeout_list.next, awaiter_t,
598
                link);
599
            gettimeofday(&tv, NULL);
1500 palkovsky 600
            if (tv_gteq(&tv, &waiter->expires)) {
1536 palkovsky 601
                futex_up(&async_futex);
1441 palkovsky 602
                handle_expired_timeouts();
603
                continue;
604
            } else
1500 palkovsky 605
                timeout = tv_sub(&waiter->expires, &tv);
1441 palkovsky 606
        } else
1435 palkovsky 607
            timeout = SYNCH_NO_TIMEOUT;
1441 palkovsky 608
        futex_up(&async_futex);
609
 
1503 jermar 610
        callid = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE);
1392 palkovsky 611
 
1435 palkovsky 612
        if (!callid) {
1441 palkovsky 613
            handle_expired_timeouts();
1435 palkovsky 614
            continue;
615
        }
616
 
1610 palkovsky 617
        if (callid & IPC_CALLID_ANSWERED) {
1392 palkovsky 618
            continue;
1610 palkovsky 619
        }
1427 palkovsky 620
 
1392 palkovsky 621
        handle_call(callid, &call);
622
    }
1719 decky 623
 
624
    return 0;
1392 palkovsky 625
}
626
 
2490 jermar 627
/** Function to start async_manager as a standalone fibril.
1404 palkovsky 628
 *
2490 jermar 629
 * When more kernel threads are used, one async manager should exist per thread.
630
 *
631
 * @param arg       Unused.
632
 *
633
 * @return      Never returns.
1404 palkovsky 634
 */
2484 jermar 635
static int async_manager_fibril(void *arg)
1392 palkovsky 636
{
1719 decky 637
    futex_up(&async_futex);
2490 jermar 638
    /*
639
     * async_futex is always locked when entering manager
640
     */
1610 palkovsky 641
    async_manager_worker();
1719 decky 642
 
643
    return 0;
1392 palkovsky 644
}
645
 
2490 jermar 646
/** Add one manager to manager list. */
1392 palkovsky 647
void async_create_manager(void)
648
{
2482 jermar 649
    fid_t fid;
1392 palkovsky 650
 
2484 jermar 651
    fid = fibril_create(async_manager_fibril, NULL);
2482 jermar 652
    fibril_add_manager(fid);
1392 palkovsky 653
}
654
 
655
/** Remove one manager from manager list */
656
void async_destroy_manager(void)
657
{
2482 jermar 658
    fibril_remove_manager();
1392 palkovsky 659
}
660
 
2490 jermar 661
/** Initialize the async framework.
662
 *
663
 * @return      Zero on success or an error code.
664
 */
1392 palkovsky 665
int _async_init(void)
666
{
2482 jermar 667
    if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1,
668
        &conn_hash_table_ops)) {
1392 palkovsky 669
        printf("%s: cannot create hash table\n", "async");
670
        return ENOMEM;
671
    }
672
 
1719 decky 673
    return 0;
1392 palkovsky 674
}
1427 palkovsky 675
 
2490 jermar 676
/** Reply received callback.
1427 palkovsky 677
 *
2490 jermar 678
 * This function is called whenever a reply for an asynchronous message sent out
679
 * by the asynchronous framework is received.
680
 *
681
 * Notify the fibril which is waiting for this message that it has arrived.
682
 *
683
 * @param private   Pointer to the asynchronous message record.
684
 * @param retval    Value returned in the answer.
685
 * @param data      Call data of the answer.
1427 palkovsky 686
 */
2485 jermar 687
static void reply_received(void *private, int retval, ipc_call_t *data)
1427 palkovsky 688
{
689
    amsg_t *msg = (amsg_t *) private;
690
 
691
    msg->retval = retval;
692
 
693
    futex_down(&async_futex);
2490 jermar 694
    /* Copy data after futex_down, just in case the call was detached */
1427 palkovsky 695
    if (msg->dataptr)
696
        *msg->dataptr = *data;
1435 palkovsky 697
 
1441 palkovsky 698
    write_barrier();
699
    /* Remove message from timeout list */
1500 palkovsky 700
    if (msg->wdata.inlist)
701
        list_remove(&msg->wdata.link);
1427 palkovsky 702
    msg->done = 1;
2490 jermar 703
    if (!msg->wdata.active) {
1500 palkovsky 704
        msg->wdata.active = 1;
2482 jermar 705
        fibril_add_ready(msg->wdata.fid);
1427 palkovsky 706
    }
707
    futex_up(&async_futex);
708
}
709
 
2490 jermar 710
/** Send message and return id of the sent message.
1427 palkovsky 711
 *
2490 jermar 712
 * The return value can be used as input for async_wait() to wait for
713
 * completion.
714
 *
715
 * @param phoneid   Handle of the phone that will be used for the send.
716
 * @param method    Service-defined method.
717
 * @param arg1      Service-defined payload argument.
718
 * @param arg2      Service-defined payload argument.
719
 * @param dataptr   If non-NULL, storage where the reply data will be
720
 *          stored.
721
 *
722
 * @return      Hash of the sent message.
1427 palkovsky 723
 */
724
aid_t async_send_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
2485 jermar 725
    ipc_call_t *dataptr)
1427 palkovsky 726
{
727
    amsg_t *msg;
728
 
1610 palkovsky 729
    if (in_interrupt_handler) {
2482 jermar 730
        printf("Cannot send asynchronous request in interrupt "
731
            "handler.\n");
1610 palkovsky 732
        _exit(1);
733
    }
734
 
1427 palkovsky 735
    msg = malloc(sizeof(*msg));
736
    msg->done = 0;
737
    msg->dataptr = dataptr;
1500 palkovsky 738
 
2490 jermar 739
    /* We may sleep in the next method, but it will use its own mechanism */
740
    msg->wdata.active = 1;
741
 
2482 jermar 742
    ipc_call_async_2(phoneid, method, arg1, arg2, msg, reply_received, 1);
1427 palkovsky 743
 
744
    return (aid_t) msg;
745
}
746
 
1547 palkovsky 747
/** Send message and return id of the sent message
748
 *
2490 jermar 749
 * The return value can be used as input for async_wait() to wait for
750
 * completion.
751
 *
752
 * @param phoneid   Handle of the phone that will be used for the send.
753
 * @param method    Service-defined method.
754
 * @param arg1      Service-defined payload argument.
755
 * @param arg2      Service-defined payload argument.
756
 * @param arg3      Service-defined payload argument.
757
 * @param dataptr   If non-NULL, storage where the reply data will be
758
 *          stored.
759
 *
760
 * @return      Hash of the sent message.
1547 palkovsky 761
 */
762
aid_t async_send_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
2485 jermar 763
    ipcarg_t arg3, ipc_call_t *dataptr)
1547 palkovsky 764
{
765
    amsg_t *msg;
766
 
1610 palkovsky 767
    if (in_interrupt_handler) {
2490 jermar 768
        printf("Cannot send asynchronous request in interrupt "
769
            "handler.\n");
1610 palkovsky 770
        _exit(1);
771
    }
772
 
1547 palkovsky 773
    msg = malloc(sizeof(*msg));
774
    msg->done = 0;
775
    msg->dataptr = dataptr;
776
 
2490 jermar 777
    /* We may sleep in next method, but it will use its own mechanism */
778
    msg->wdata.active = 1;
779
 
2482 jermar 780
    ipc_call_async_3(phoneid, method, arg1, arg2, arg3, msg, reply_received,
781
        1);
1547 palkovsky 782
 
783
    return (aid_t) msg;
784
}
785
 
2490 jermar 786
/** Wait for a message sent by the async framework.
1427 palkovsky 787
 *
2490 jermar 788
 * @param amsgid    Hash of the message to wait for.
789
 * @param retval    Pointer to storage where the retval of the answer will
790
 *          be stored.
1427 palkovsky 791
 */
792
void async_wait_for(aid_t amsgid, ipcarg_t *retval)
793
{
794
    amsg_t *msg = (amsg_t *) amsgid;
795
 
796
    futex_down(&async_futex);
797
    if (msg->done) {
798
        futex_up(&async_futex);
799
        goto done;
800
    }
801
 
2482 jermar 802
    msg->wdata.fid = fibril_get_id();
1500 palkovsky 803
    msg->wdata.active = 0;
804
    msg->wdata.inlist = 0;
2490 jermar 805
    /* Leave the async_futex locked when entering this function */
2568 jermar 806
    fibril_switch(FIBRIL_TO_MANAGER);
807
    /* futex is up automatically after fibril_switch...*/
1427 palkovsky 808
done:
809
    if (retval)
810
        *retval = msg->retval;
811
    free(msg);
812
}
1435 palkovsky 813
 
2490 jermar 814
/** Wait for a message sent by the async framework, timeout variant.
1441 palkovsky 815
 *
2490 jermar 816
 * @param amsgid    Hash of the message to wait for.
817
 * @param retval    Pointer to storage where the retval of the answer will
818
 *          be stored.
819
 * @param timeout   Timeout in microseconds.
1441 palkovsky 820
 *
2490 jermar 821
 * @return      Zero on success, ETIMEOUT if the timeout has expired.
1441 palkovsky 822
 */
823
int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, suseconds_t timeout)
824
{
825
    amsg_t *msg = (amsg_t *) amsgid;
1435 palkovsky 826
 
1532 palkovsky 827
    /* TODO: Let it go through the event read at least once */
828
    if (timeout < 0)
829
        return ETIMEOUT;
830
 
1441 palkovsky 831
    futex_down(&async_futex);
832
    if (msg->done) {
833
        futex_up(&async_futex);
834
        goto done;
835
    }
1435 palkovsky 836
 
1500 palkovsky 837
    gettimeofday(&msg->wdata.expires, NULL);
838
    tv_add(&msg->wdata.expires, timeout);
1435 palkovsky 839
 
2482 jermar 840
    msg->wdata.fid = fibril_get_id();
1500 palkovsky 841
    msg->wdata.active = 0;
842
    insert_timeout(&msg->wdata);
843
 
2490 jermar 844
    /* Leave the async_futex locked when entering this function */
2568 jermar 845
    fibril_switch(FIBRIL_TO_MANAGER);
846
    /* futex is up automatically after fibril_switch...*/
1435 palkovsky 847
 
1441 palkovsky 848
    if (!msg->done)
849
        return ETIMEOUT;
850
 
851
done:
852
    if (retval)
853
        *retval = msg->retval;
854
    free(msg);
855
 
856
    return 0;
857
}
858
 
2490 jermar 859
/** Wait for specified time.
1452 palkovsky 860
 *
2490 jermar 861
 * The current fibril is suspended but the thread continues to execute.
862
 *
863
 * @param timeout   Duration of the wait in microseconds.
1452 palkovsky 864
 */
865
void async_usleep(suseconds_t timeout)
866
{
867
    amsg_t *msg;
868
 
1610 palkovsky 869
    if (in_interrupt_handler) {
870
        printf("Cannot call async_usleep in interrupt handler.\n");
871
        _exit(1);
872
    }
873
 
1452 palkovsky 874
    msg = malloc(sizeof(*msg));
875
    if (!msg)
876
        return;
877
 
2482 jermar 878
    msg->wdata.fid = fibril_get_id();
1500 palkovsky 879
    msg->wdata.active = 0;
1452 palkovsky 880
 
1500 palkovsky 881
    gettimeofday(&msg->wdata.expires, NULL);
882
    tv_add(&msg->wdata.expires, timeout);
1452 palkovsky 883
 
884
    futex_down(&async_futex);
1500 palkovsky 885
    insert_timeout(&msg->wdata);
2490 jermar 886
    /* Leave the async_futex locked when entering this function */
2568 jermar 887
    fibril_switch(FIBRIL_TO_MANAGER);
888
    /* futex is up automatically after fibril_switch()...*/
1452 palkovsky 889
    free(msg);
890
}
1490 palkovsky 891
 
2490 jermar 892
/** Setter for client_connection function pointer.
1490 palkovsky 893
 *
2490 jermar 894
 * @param conn      Function that will implement a new connection fibril.
1490 palkovsky 895
 */
896
void async_set_client_connection(async_client_conn_t conn)
897
{
898
    client_connection = conn;
899
}
2490 jermar 900
 
901
/** Setter for interrupt_received function pointer.
902
 *
903
 * @param conn      Function that will implement a new interrupt
904
 *          notification fibril.
905
 */
1596 palkovsky 906
void async_set_interrupt_received(async_client_conn_t conn)
907
{
908
    interrupt_received = conn;
909
}
1610 palkovsky 910
 
911
/* Primitive functions for simple communication */
912
void async_msg_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
913
         ipcarg_t arg2, ipcarg_t arg3)
914
{
2482 jermar 915
    ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL,
916
        !in_interrupt_handler);
1610 palkovsky 917
}
918
 
919
void async_msg_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
920
{
2482 jermar 921
    ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL,
922
        !in_interrupt_handler);
1610 palkovsky 923
}
1653 cejka 924
 
1719 decky 925
/** @}
1653 cejka 926
 */
2490 jermar 927