| 30,64 → 30,65 |
|---|
| * @{ |
| */ |
| /** @file |
| */ |
| */ |
| |
| /** |
| * Asynchronous library |
| * |
| * The aim of this library is facilitating writing programs utilizing the |
| * asynchronous nature of HelenOS IPC, yet using a normal way of programming. |
| * The aim of this library is to provide a facility for writing programs which |
| * utilize the asynchronous nature of HelenOS IPC, yet using a normal way of |
| * programming. |
| * |
| * You should be able to write very simple multithreaded programs, the async |
| * framework will automatically take care of most synchronization problems. |
| * |
| * Default semantics: |
| * - async_send_*(): send asynchronously. If the kernel refuses to send |
| * more messages, [ try to get responses from kernel, if |
| * nothing found, might try synchronous ] |
| * - async_send_*(): Send asynchronously. If the kernel refuses to send |
| * more messages, [ try to get responses from kernel, if |
| * nothing found, might try synchronous ] |
| * |
| * Example of use (pseudo C): |
| * |
| * |
| * 1) Multithreaded client application |
| * |
| * fibril_create(fibril1, ...); |
| * fibril_create(fibril2, ...); |
| * ... |
| * |
| * int fibril1(void *arg) |
| * { |
| * conn = ipc_connect_me_to(); |
| * c1 = async_send(conn); |
| * c2 = async_send(conn); |
| * async_wait_for(c1); |
| * async_wait_for(c2); |
| * ... |
| * } |
| * fibril_create(fibril1, ...); |
| * fibril_create(fibril2, ...); |
| * ... |
| * |
| * int fibril1(void *arg) |
| * { |
| * conn = ipc_connect_me_to(); |
| * c1 = async_send(conn); |
| * c2 = async_send(conn); |
| * async_wait_for(c1); |
| * async_wait_for(c2); |
| * ... |
| * } |
| * |
| * |
| * 2) Multithreaded server application |
| * main() |
| * { |
| * async_manager(); |
| * } |
| * |
| * |
| * my_client_connection(icallid, *icall) |
| * { |
| * if (want_refuse) { |
| * ipc_answer_0(icallid, ELIMIT); |
| * return; |
| * } |
| * ipc_answer_0(icallid, EOK); |
| * main() |
| * { |
| * async_manager(); |
| * } |
| * |
| * callid = async_get_call(&call); |
| * handle_call(callid, call); |
| * ipc_answer_2(callid, 1, 2, 3); |
| * my_client_connection(icallid, *icall) |
| * { |
| * if (want_refuse) { |
| * ipc_answer_0(icallid, ELIMIT); |
| * return; |
| * } |
| * ipc_answer_0(icallid, EOK); |
| * |
| * callid = async_get_call(&call); |
| * .... |
| * } |
| * callid = async_get_call(&call); |
| * handle_call(callid, call); |
| * ipc_answer_2(callid, 1, 2, 3); |
| * |
| * callid = async_get_call(&call); |
| * ... |
| * } |
| * |
| */ |
| |
| #include <futex.h> |
| 104,24 → 105,26 |
|---|
| #include <bool.h> |
| |
| atomic_t async_futex = FUTEX_INITIALIZER; |
| static hash_table_t conn_hash_table; |
| static LIST_INITIALIZE(timeout_list); |
| |
| /** Structures of this type represent a waiting fibril. */ |
| typedef struct { |
| /** Expiration time. */ |
| struct timeval expires; |
| struct timeval expires; |
| |
| /** If true, this struct is in the timeout list. */ |
| int inlist; |
| bool inlist; |
| |
| /** Timeout list link. */ |
| link_t link; |
| |
| |
| /** Identification of and link to the waiting fibril. */ |
| fid_t fid; |
| |
| /** If true, this fibril is currently active. */ |
| int active; |
| bool active; |
| |
| /** If true, we have timed out. */ |
| int timedout; |
| bool timedout; |
| } awaiter_t; |
| |
| typedef struct { |
| 128,10 → 131,11 |
|---|
| awaiter_t wdata; |
| |
| /** If reply was received. */ |
| int done; |
| bool done; |
| |
| /** Pointer to where the answer data is stored. */ |
| ipc_call_t *dataptr; |
| |
| ipc_call_t *dataptr; |
| |
| ipcarg_t retval; |
| } amsg_t; |
| |
| 147,24 → 151,24 |
|---|
| |
| typedef struct { |
| awaiter_t wdata; |
| |
| |
| /** Hash table link. */ |
| link_t link; |
| |
| |
| /** Incoming phone hash. */ |
| ipcarg_t in_phone_hash; |
| |
| ipcarg_t in_phone_hash; |
| |
| /** Messages that should be delivered to this fibril. */ |
| link_t msg_queue; |
| |
| link_t msg_queue; |
| |
| /** Identification of the opening call. */ |
| ipc_callid_t callid; |
| /** Call data of the opening call. */ |
| ipc_call_t call; |
| |
| |
| /** Identification of the closing call. */ |
| ipc_callid_t close_callid; |
| |
| |
| /** Fibril function that will be used to handle the connection. */ |
| void (*cfibril)(ipc_callid_t, ipc_call_t *); |
| } connection_t; |
| 172,12 → 176,6 |
|---|
| /** Identifier of the incoming connection handled by the current fibril. */ |
| __thread connection_t *FIBRIL_connection; |
| |
| /** |
| * If true, it is forbidden to use async_req functions and all preemption is |
| * disabled. |
| */ |
| __thread int _in_interrupt_handler; |
| |
| static void default_client_connection(ipc_callid_t callid, ipc_call_t *call); |
| static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call); |
| |
| 185,6 → 183,7 |
|---|
| * Pointer to a fibril function that will be used to handle connections. |
| */ |
| static async_client_conn_t client_connection = default_client_connection; |
| |
| /** |
| * Pointer to a fibril function that will be used to handle interrupt |
| * notifications. |
| 191,46 → 190,39 |
|---|
| */ |
| static async_client_conn_t interrupt_received = default_interrupt_received; |
| |
| /* |
| * Getter for _in_interrupt_handler. We need to export the value of this thread |
| * local variable to other modules, but the binutils 2.18 linkers die on an |
| * attempt to export this symbol in the header file. For now, consider this as a |
| * workaround. |
| */ |
| bool in_interrupt_handler(void) |
| { |
| return _in_interrupt_handler; |
| } |
| |
| #define CONN_HASH_TABLE_CHAINS 32 |
| static hash_table_t conn_hash_table; |
| static LIST_INITIALIZE(timeout_list); |
| |
| |
| #define CONN_HASH_TABLE_CHAINS 32 |
| |
| /** Compute hash into the connection hash table based on the source phone hash. |
| * |
| * @param key Pointer to source phone hash. |
| * @param key Pointer to source phone hash. |
| * |
| * @return Index into the connection hash table. |
| * @return Index into the connection hash table. |
| * |
| */ |
| static hash_index_t conn_hash(unsigned long *key) |
| { |
| assert(key); |
| return ((*key) >> 4) % CONN_HASH_TABLE_CHAINS; |
| return (((*key) >> 4) % CONN_HASH_TABLE_CHAINS); |
| } |
| |
| /** Compare hash table item with a key. |
| * |
| * @param key Array containing the source phone hash as the only item. |
| * @param keys Expected 1 but ignored. |
| * @param item Connection hash table item. |
| * @param key Array containing the source phone hash as the only item. |
| * @param keys Expected 1 but ignored. |
| * @param item Connection hash table item. |
| * |
| * @return True on match, false otherwise. |
| * @return True on match, false otherwise. |
| * |
| */ |
| static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item) |
| { |
| connection_t *hs; |
| |
| hs = hash_table_get_instance(item, connection_t, link); |
| |
| return key[0] == hs->in_phone_hash; |
| connection_t *hs = hash_table_get_instance(item, connection_t, link); |
| return (key[0] == hs->in_phone_hash); |
| } |
| |
| /** Connection hash table removal callback function. |
| 238,7 → 230,8 |
|---|
| * This function is called whenever a connection is removed from the connection |
| * hash table. |
| * |
| * @param item Connection hash table item being removed. |
| * @param item Connection hash table item being removed. |
| * |
| */ |
| static void conn_remove(link_t *item) |
| { |
| 255,23 → 248,24 |
|---|
| |
| /** Sort in current fibril's timeout request. |
| * |
| * @param wd Wait data of the current fibril. |
| * @param wd Wait data of the current fibril. |
| * |
| */ |
| static void insert_timeout(awaiter_t *wd) |
| { |
| link_t *tmp; |
| awaiter_t *cur; |
| |
| wd->timedout = 0; |
| wd->inlist = 1; |
| |
| tmp = timeout_list.next; |
| wd->timedout = false; |
| wd->inlist = true; |
| |
| link_t *tmp = timeout_list.next; |
| while (tmp != &timeout_list) { |
| cur = list_get_instance(tmp, awaiter_t, link); |
| awaiter_t *cur = list_get_instance(tmp, awaiter_t, link); |
| |
| if (tv_gteq(&cur->expires, &wd->expires)) |
| break; |
| |
| tmp = tmp->next; |
| } |
| |
| list_append(&wd->link, tmp); |
| } |
| |
| 281,93 → 275,146 |
|---|
| * its message queue. If the fibril was not active, it is activated and all |
| * timeouts are unregistered. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| * @return Zero if the call doesn't match any connection. |
| * One if the call was passed to the respective connection |
| * fibril. |
| * @return False if the call doesn't match any connection. |
| * True if the call was passed to the respective connection fibril. |
| * |
| */ |
| static int route_call(ipc_callid_t callid, ipc_call_t *call) |
| static bool route_call(ipc_callid_t callid, ipc_call_t *call) |
| { |
| connection_t *conn; |
| msg_t *msg; |
| link_t *hlp; |
| unsigned long key; |
| |
| futex_down(&async_futex); |
| |
| key = call->in_phone_hash; |
| hlp = hash_table_find(&conn_hash_table, &key); |
| |
| unsigned long key = call->in_phone_hash; |
| link_t *hlp = hash_table_find(&conn_hash_table, &key); |
| |
| if (!hlp) { |
| futex_up(&async_futex); |
| return 0; |
| return false; |
| } |
| conn = hash_table_get_instance(hlp, connection_t, link); |
| |
| msg = malloc(sizeof(*msg)); |
| |
| connection_t *conn = hash_table_get_instance(hlp, connection_t, link); |
| |
| msg_t *msg = malloc(sizeof(*msg)); |
| if (!msg) { |
| futex_up(&async_futex); |
| return false; |
| } |
| |
| msg->callid = callid; |
| msg->call = *call; |
| list_append(&msg->link, &conn->msg_queue); |
| |
| |
| if (IPC_GET_METHOD(*call) == IPC_M_PHONE_HUNGUP) |
| conn->close_callid = callid; |
| |
| /* If the connection fibril is waiting for an event, activate it */ |
| if (!conn->wdata.active) { |
| |
| /* If in timeout list, remove it */ |
| if (conn->wdata.inlist) { |
| conn->wdata.inlist = 0; |
| conn->wdata.inlist = false; |
| list_remove(&conn->wdata.link); |
| } |
| conn->wdata.active = 1; |
| |
| conn->wdata.active = true; |
| fibril_add_ready(conn->wdata.fid); |
| } |
| |
| |
| futex_up(&async_futex); |
| return true; |
| } |
| |
| return 1; |
| /** Notification fibril. |
| * |
| * When a notification arrives, a fibril with this implementing function is |
| * created. It calls interrupt_received() and does the final cleanup. |
| * |
| * @param arg Message structure pointer. |
| * |
| * @return Always zero. |
| * |
| */ |
| static int notification_fibril(void *arg) |
| { |
| msg_t *msg = (msg_t *) arg; |
| interrupt_received(msg->callid, &msg->call); |
| |
| free(msg); |
| return 0; |
| } |
| |
| /** Process interrupt notification. |
| * |
| * A new fibril is created which would process the notification. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| * @return False if an error occured. |
| * True if the call was passed to the notification fibril. |
| * |
| */ |
| static bool process_notification(ipc_callid_t callid, ipc_call_t *call) |
| { |
| futex_down(&async_futex); |
| |
| msg_t *msg = malloc(sizeof(*msg)); |
| if (!msg) { |
| futex_up(&async_futex); |
| return false; |
| } |
| |
| msg->callid = callid; |
| msg->call = *call; |
| |
| fid_t fid = fibril_create(notification_fibril, msg); |
| fibril_add_ready(fid); |
| |
| futex_up(&async_futex); |
| return true; |
| } |
| |
| /** Return new incoming message for the current (fibril-local) connection. |
| * |
| * @param call Storage where the incoming call data will be stored. |
| * @param usecs Timeout in microseconds. Zero denotes no timeout. |
| * @param call Storage where the incoming call data will be stored. |
| * @param usecs Timeout in microseconds. Zero denotes no timeout. |
| * |
| * @return If no timeout was specified, then a hash of the |
| * incoming call is returned. If a timeout is specified, |
| * then a hash of the incoming call is returned unless |
| * the timeout expires prior to receiving a message. In |
| * that case zero is returned. |
| * @return If no timeout was specified, then a hash of the |
| * incoming call is returned. If a timeout is specified, |
| * then a hash of the incoming call is returned unless |
| * the timeout expires prior to receiving a message. In |
| * that case zero is returned. |
| * |
| */ |
| ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs) |
| { |
| msg_t *msg; |
| ipc_callid_t callid; |
| connection_t *conn; |
| assert(FIBRIL_connection); |
| |
| assert(FIBRIL_connection); |
| /* GCC 4.1.0 coughs on FIBRIL_connection-> dereference, |
| /* Why doing this? |
| * GCC 4.1.0 coughs on FIBRIL_connection-> dereference. |
| * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot. |
| * I would never expect to find so many errors in |
| * a compiler *($&$(*&$ |
| * I would never expect to find so many errors in |
| * a compiler. |
| */ |
| conn = FIBRIL_connection; |
| |
| connection_t *conn = FIBRIL_connection; |
| |
| futex_down(&async_futex); |
| |
| |
| if (usecs) { |
| gettimeofday(&conn->wdata.expires, NULL); |
| tv_add(&conn->wdata.expires, usecs); |
| } else { |
| conn->wdata.inlist = 0; |
| } |
| } else |
| conn->wdata.inlist = false; |
| |
| /* If nothing in queue, wait until something arrives */ |
| while (list_empty(&conn->msg_queue)) { |
| if (usecs) |
| insert_timeout(&conn->wdata); |
| |
| conn->wdata.active = 0; |
| |
| conn->wdata.active = false; |
| |
| /* |
| * Note: the current fibril will be rescheduled either due to a |
| * timeout or due to an arriving message destined to it. In the |
| 375,13 → 422,14 |
|---|
| * case, route_call() will perform the wakeup. |
| */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| |
| /* |
| * Futex is up after getting back from async_manager get it |
| * again. |
| * Futex is up after getting back from async_manager. |
| * Get it again. |
| */ |
| futex_down(&async_futex); |
| if (usecs && conn->wdata.timedout && |
| list_empty(&conn->msg_queue)) { |
| if ((usecs) && (conn->wdata.timedout) |
| && (list_empty(&conn->msg_queue))) { |
| /* If we timed out -> exit */ |
| futex_up(&async_futex); |
| return 0; |
| 388,9 → 436,10 |
|---|
| } |
| } |
| |
| msg = list_get_instance(conn->msg_queue.next, msg_t, link); |
| msg_t *msg = list_get_instance(conn->msg_queue.next, msg_t, link); |
| list_remove(&msg->link); |
| callid = msg->callid; |
| |
| ipc_callid_t callid = msg->callid; |
| *call = msg->call; |
| free(msg); |
| |
| 402,8 → 451,9 |
|---|
| * |
| * This function is defined as a weak symbol - to be redefined in user code. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| */ |
| static void default_client_connection(ipc_callid_t callid, ipc_call_t *call) |
| { |
| 412,8 → 462,11 |
|---|
| |
| /** Default fibril function that gets called to handle interrupt notifications. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * This function is defined as a weak symbol - to be redefined in user code. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| */ |
| static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call) |
| { |
| 424,17 → 477,17 |
|---|
| * When a new connection arrives, a fibril with this implementing function is |
| * created. It calls client_connection() and does the final cleanup. |
| * |
| * @param arg Connection structure pointer. |
| * @param arg Connection structure pointer. |
| * |
| * @return Always zero. |
| * @return Always zero. |
| * |
| */ |
| static int connection_fibril(void *arg) |
| static int connection_fibril(void *arg) |
| { |
| unsigned long key; |
| msg_t *msg; |
| int close_answered = 0; |
| |
| /* Setup fibril-local connection pointer */ |
| /* |
| * Setup fibril-local connection pointer and call client_connection(). |
| * |
| */ |
| FIBRIL_connection = (connection_t *) arg; |
| FIBRIL_connection->cfibril(FIBRIL_connection->callid, |
| &FIBRIL_connection->call); |
| 441,20 → 494,20 |
|---|
| |
| /* Remove myself from the connection hash table */ |
| futex_down(&async_futex); |
| key = FIBRIL_connection->in_phone_hash; |
| unsigned long key = FIBRIL_connection->in_phone_hash; |
| hash_table_remove(&conn_hash_table, &key, 1); |
| futex_up(&async_futex); |
| |
| /* Answer all remaining messages with EHANGUP */ |
| while (!list_empty(&FIBRIL_connection->msg_queue)) { |
| msg = list_get_instance(FIBRIL_connection->msg_queue.next, |
| msg_t, link); |
| msg_t *msg |
| = list_get_instance(FIBRIL_connection->msg_queue.next, msg_t, link); |
| |
| list_remove(&msg->link); |
| if (msg->callid == FIBRIL_connection->close_callid) |
| close_answered = 1; |
| ipc_answer_0(msg->callid, EHANGUP); |
| free(msg); |
| } |
| |
| if (FIBRIL_connection->close_callid) |
| ipc_answer_0(FIBRIL_connection->close_callid, EOK); |
| |
| 463,43 → 516,45 |
|---|
| |
| /** Create a new fibril for a new connection. |
| * |
| * Creates new fibril for connection, fills in connection structures and inserts |
| * Create new fibril for connection, fill in connection structures and inserts |
| * it into the hash table, so that later we can easily do routing of messages to |
| * particular fibrils. |
| * |
| * @param in_phone_hash Identification of the incoming connection. |
| * @param callid Hash of the opening IPC_M_CONNECT_ME_TO call. |
| * If callid is zero, the connection was opened by |
| * accepting the IPC_M_CONNECT_TO_ME call and this function |
| * is called directly by the server. |
| * @param call Call data of the opening call. |
| * @param cfibril Fibril function that should be called upon opening the |
| * connection. |
| * @param in_phone_hash Identification of the incoming connection. |
| * @param callid Hash of the opening IPC_M_CONNECT_ME_TO call. |
| * If callid is zero, the connection was opened by |
| * accepting the IPC_M_CONNECT_TO_ME call and this function |
| * is called directly by the server. |
| * @param call Call data of the opening call. |
| * @param cfibril Fibril function that should be called upon opening the |
| * connection. |
| * |
| * @return New fibril id or NULL on failure. |
| * @return New fibril id or NULL on failure. |
| * |
| */ |
| fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid, |
| ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *)) |
| { |
| connection_t *conn; |
| unsigned long key; |
| |
| conn = malloc(sizeof(*conn)); |
| connection_t *conn = malloc(sizeof(*conn)); |
| if (!conn) { |
| if (callid) |
| ipc_answer_0(callid, ENOMEM); |
| return NULL; |
| } |
| |
| conn->in_phone_hash = in_phone_hash; |
| list_initialize(&conn->msg_queue); |
| conn->callid = callid; |
| conn->close_callid = 0; |
| conn->close_callid = false; |
| |
| if (call) |
| conn->call = *call; |
| conn->wdata.active = 1; /* We will activate the fibril ASAP */ |
| |
| /* We will activate the fibril ASAP */ |
| conn->wdata.active = true; |
| conn->cfibril = cfibril; |
| conn->wdata.fid = fibril_create(connection_fibril, conn); |
| |
| conn->wdata.fid = fibril_create(connection_fibril, conn); |
| if (!conn->wdata.fid) { |
| free(conn); |
| if (callid) |
| 508,7 → 563,8 |
|---|
| } |
| |
| /* Add connection to the connection hash table */ |
| key = conn->in_phone_hash; |
| ipcarg_t key = conn->in_phone_hash; |
| |
| futex_down(&async_futex); |
| hash_table_insert(&conn_hash_table, &key, &conn->link); |
| futex_up(&async_futex); |
| 523,8 → 579,8 |
|---|
| * If the call has the IPC_M_CONNECT_ME_TO method, a new connection is created. |
| * Otherwise the call is routed to its connection fibril. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| */ |
| static void handle_call(ipc_callid_t callid, ipc_call_t *call) |
| 531,9 → 587,7 |
|---|
| { |
| /* Unrouted call - do some default behaviour */ |
| if ((callid & IPC_CALLID_NOTIFICATION)) { |
| _in_interrupt_handler = 1; |
| (*interrupt_received)(callid, call); |
| _in_interrupt_handler = 0; |
| process_notification(callid, call); |
| return; |
| } |
| |
| 557,47 → 611,44 |
|---|
| static void handle_expired_timeouts(void) |
| { |
| struct timeval tv; |
| awaiter_t *waiter; |
| link_t *cur; |
| |
| gettimeofday(&tv, NULL); |
| |
| futex_down(&async_futex); |
| |
| cur = timeout_list.next; |
| |
| link_t *cur = timeout_list.next; |
| while (cur != &timeout_list) { |
| waiter = list_get_instance(cur, awaiter_t, link); |
| awaiter_t *waiter = list_get_instance(cur, awaiter_t, link); |
| |
| if (tv_gt(&waiter->expires, &tv)) |
| break; |
| |
| cur = cur->next; |
| |
| list_remove(&waiter->link); |
| waiter->inlist = 0; |
| waiter->timedout = 1; |
| waiter->inlist = false; |
| waiter->timedout = true; |
| |
| /* |
| * Redundant condition? |
| * The fibril should not be active when it gets here. |
| * Redundant condition? |
| * The fibril should not be active when it gets here. |
| */ |
| if (!waiter->active) { |
| waiter->active = 1; |
| waiter->active = true; |
| fibril_add_ready(waiter->fid); |
| } |
| } |
| |
| |
| futex_up(&async_futex); |
| } |
| |
| /** Endless loop dispatching incoming calls and answers. |
| * |
| * @return Never returns. |
| * @return Never returns. |
| * |
| */ |
| static int async_manager_worker(void) |
| { |
| ipc_call_t call; |
| ipc_callid_t callid; |
| int timeout; |
| awaiter_t *waiter; |
| struct timeval tv; |
| |
| while (1) { |
| while (true) { |
| if (fibril_switch(FIBRIL_FROM_MANAGER)) { |
| futex_up(&async_futex); |
| /* |
| 606,11 → 657,17 |
|---|
| */ |
| continue; |
| } |
| |
| futex_down(&async_futex); |
| |
| suseconds_t timeout; |
| if (!list_empty(&timeout_list)) { |
| waiter = list_get_instance(timeout_list.next, awaiter_t, |
| link); |
| awaiter_t *waiter |
| = list_get_instance(timeout_list.next, awaiter_t, link); |
| |
| struct timeval tv; |
| gettimeofday(&tv, NULL); |
| |
| if (tv_gteq(&tv, &waiter->expires)) { |
| futex_up(&async_futex); |
| handle_expired_timeouts(); |
| 619,19 → 676,21 |
|---|
| timeout = tv_sub(&waiter->expires, &tv); |
| } else |
| timeout = SYNCH_NO_TIMEOUT; |
| |
| futex_up(&async_futex); |
| |
| callid = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE); |
| |
| |
| ipc_call_t call; |
| ipc_callid_t callid |
| = ipc_wait_cycle(&call, timeout, SYNCH_FLAGS_NONE); |
| |
| if (!callid) { |
| handle_expired_timeouts(); |
| continue; |
| } |
| |
| if (callid & IPC_CALLID_ANSWERED) { |
| |
| if (callid & IPC_CALLID_ANSWERED) |
| continue; |
| } |
| |
| |
| handle_call(callid, &call); |
| } |
| |
| 639,16 → 698,17 |
|---|
| } |
| |
| /** Function to start async_manager as a standalone fibril. |
| * |
| * |
| * When more kernel threads are used, one async manager should exist per thread. |
| * |
| * @param arg Unused. |
| * @param arg Unused. |
| * @return Never returns. |
| * |
| * @return Never returns. |
| */ |
| static int async_manager_fibril(void *arg) |
| { |
| futex_up(&async_futex); |
| |
| /* |
| * async_futex is always locked when entering manager |
| */ |
| 660,9 → 720,7 |
|---|
| /** Add one manager to manager list. */ |
| void async_create_manager(void) |
| { |
| fid_t fid; |
| |
| fid = fibril_create(async_manager_fibril, NULL); |
| fid_t fid = fibril_create(async_manager_fibril, NULL); |
| fibril_add_manager(fid); |
| } |
| |
| 674,7 → 732,7 |
|---|
| |
| /** Initialize the async framework. |
| * |
| * @return Zero on success or an error code. |
| * @return Zero on success or an error code. |
| */ |
| int _async_init(void) |
| { |
| 694,30 → 752,33 |
|---|
| * |
| * Notify the fibril which is waiting for this message that it has arrived. |
| * |
| * @param private Pointer to the asynchronous message record. |
| * @param retval Value returned in the answer. |
| * @param data Call data of the answer. |
| * @param arg Pointer to the asynchronous message record. |
| * @param retval Value returned in the answer. |
| * @param data Call data of the answer. |
| */ |
| static void reply_received(void *private, int retval, ipc_call_t *data) |
| static void reply_received(void *arg, int retval, ipc_call_t *data) |
| { |
| amsg_t *msg = (amsg_t *) private; |
| |
| amsg_t *msg = (amsg_t *) arg; |
| msg->retval = retval; |
| |
| |
| futex_down(&async_futex); |
| |
| /* Copy data after futex_down, just in case the call was detached */ |
| if (msg->dataptr) |
| *msg->dataptr = *data; |
| |
| *msg->dataptr = *data; |
| |
| write_barrier(); |
| |
| /* Remove message from timeout list */ |
| if (msg->wdata.inlist) |
| list_remove(&msg->wdata.link); |
| msg->done = 1; |
| |
| msg->done = true; |
| if (!msg->wdata.active) { |
| msg->wdata.active = 1; |
| msg->wdata.active = true; |
| fibril_add_ready(msg->wdata.fid); |
| } |
| |
| futex_up(&async_futex); |
| } |
| |
| 726,31 → 787,34 |
|---|
| * The return value can be used as input for async_wait() to wait for |
| * completion. |
| * |
| * @param phoneid Handle of the phone that will be used for the send. |
| * @param method Service-defined method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param dataptr If non-NULL, storage where the reply data will be |
| * stored. |
| * @param phoneid Handle of the phone that will be used for the send. |
| * @param method Service-defined method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param dataptr If non-NULL, storage where the reply data will be |
| * stored. |
| * |
| * @return Hash of the sent message. |
| * @return Hash of the sent message or 0 on error. |
| * |
| */ |
| aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr) |
| { |
| amsg_t *msg; |
| amsg_t *msg = malloc(sizeof(*msg)); |
| |
| msg = malloc(sizeof(*msg)); |
| msg->done = 0; |
| if (!msg) |
| return 0; |
| |
| msg->done = false; |
| msg->dataptr = dataptr; |
| |
| /* We may sleep in the next method, but it will use its own mechanism */ |
| msg->wdata.active = 1; |
| |
| msg->wdata.active = true; |
| |
| ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg, |
| reply_received, !_in_interrupt_handler); |
| reply_received, true); |
| |
| return (aid_t) msg; |
| } |
| 760,33 → 824,36 |
|---|
| * The return value can be used as input for async_wait() to wait for |
| * completion. |
| * |
| * @param phoneid Handle of the phone that will be used for the send. |
| * @param method Service-defined method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param dataptr If non-NULL, storage where the reply data will be |
| * stored. |
| * @param phoneid Handle of the phone that will be used for the send. |
| * @param method Service-defined method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param dataptr If non-NULL, storage where the reply data will be |
| * stored. |
| * |
| * @return Hash of the sent message. |
| * @return Hash of the sent message or 0 on error. |
| * |
| */ |
| aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, |
| ipc_call_t *dataptr) |
| { |
| amsg_t *msg; |
| amsg_t *msg = malloc(sizeof(*msg)); |
| |
| msg = malloc(sizeof(*msg)); |
| msg->done = 0; |
| if (!msg) |
| return 0; |
| |
| msg->done = false; |
| msg->dataptr = dataptr; |
| |
| /* We may sleep in next method, but it will use its own mechanism */ |
| msg->wdata.active = 1; |
| msg->wdata.active = true; |
| |
| ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg, |
| reply_received, !_in_interrupt_handler); |
| reply_received, true); |
| |
| return (aid_t) msg; |
| } |
| 793,74 → 860,82 |
|---|
| |
| /** Wait for a message sent by the async framework. |
| * |
| * @param amsgid Hash of the message to wait for. |
| * @param retval Pointer to storage where the retval of the answer will |
| * be stored. |
| * @param amsgid Hash of the message to wait for. |
| * @param retval Pointer to storage where the retval of the answer will |
| * be stored. |
| * |
| */ |
| void async_wait_for(aid_t amsgid, ipcarg_t *retval) |
| { |
| amsg_t *msg = (amsg_t *) amsgid; |
| |
| |
| futex_down(&async_futex); |
| if (msg->done) { |
| futex_up(&async_futex); |
| goto done; |
| } |
| |
| |
| msg->wdata.fid = fibril_get_id(); |
| msg->wdata.active = 0; |
| msg->wdata.inlist = 0; |
| msg->wdata.active = false; |
| msg->wdata.inlist = false; |
| |
| /* Leave the async_futex locked when entering this function */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* futex is up automatically after fibril_switch...*/ |
| |
| /* Futex is up automatically after fibril_switch */ |
| |
| done: |
| if (retval) |
| *retval = msg->retval; |
| |
| free(msg); |
| } |
| |
| /** Wait for a message sent by the async framework, timeout variant. |
| * |
| * @param amsgid Hash of the message to wait for. |
| * @param retval Pointer to storage where the retval of the answer will |
| * be stored. |
| * @param timeout Timeout in microseconds. |
| * @param amsgid Hash of the message to wait for. |
| * @param retval Pointer to storage where the retval of the answer will |
| * be stored. |
| * @param timeout Timeout in microseconds. |
| * |
| * @return Zero on success, ETIMEOUT if the timeout has expired. |
| * @return Zero on success, ETIMEOUT if the timeout has expired. |
| * |
| */ |
| int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, suseconds_t timeout) |
| { |
| amsg_t *msg = (amsg_t *) amsgid; |
| |
| |
| /* TODO: Let it go through the event read at least once */ |
| if (timeout < 0) |
| return ETIMEOUT; |
| |
| |
| futex_down(&async_futex); |
| if (msg->done) { |
| futex_up(&async_futex); |
| goto done; |
| } |
| |
| |
| gettimeofday(&msg->wdata.expires, NULL); |
| tv_add(&msg->wdata.expires, timeout); |
| |
| |
| msg->wdata.fid = fibril_get_id(); |
| msg->wdata.active = 0; |
| msg->wdata.active = false; |
| insert_timeout(&msg->wdata); |
| |
| |
| /* Leave the async_futex locked when entering this function */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* futex is up automatically after fibril_switch...*/ |
| |
| |
| /* Futex is up automatically after fibril_switch */ |
| |
| if (!msg->done) |
| return ETIMEOUT; |
| |
| |
| done: |
| if (retval) |
| *retval = msg->retval; |
| |
| free(msg); |
| |
| |
| return 0; |
| } |
| |
| 868,33 → 943,38 |
|---|
| * |
| * The current fibril is suspended but the thread continues to execute. |
| * |
| * @param timeout Duration of the wait in microseconds. |
| * @param timeout Duration of the wait in microseconds. |
| * |
| */ |
| void async_usleep(suseconds_t timeout) |
| { |
| amsg_t *msg; |
| amsg_t *msg = malloc(sizeof(*msg)); |
| |
| msg = malloc(sizeof(*msg)); |
| if (!msg) |
| return; |
| |
| msg->wdata.fid = fibril_get_id(); |
| msg->wdata.active = 0; |
| msg->wdata.active = false; |
| |
| gettimeofday(&msg->wdata.expires, NULL); |
| tv_add(&msg->wdata.expires, timeout); |
| |
| futex_down(&async_futex); |
| |
| insert_timeout(&msg->wdata); |
| |
| /* Leave the async_futex locked when entering this function */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* futex is up automatically after fibril_switch()...*/ |
| |
| /* Futex is up automatically after fibril_switch() */ |
| |
| free(msg); |
| } |
| |
| /** Setter for client_connection function pointer. |
| * |
| * @param conn Function that will implement a new connection fibril. |
| * @param conn Function that will implement a new connection fibril. |
| * |
| */ |
| void async_set_client_connection(async_client_conn_t conn) |
| { |
| 903,12 → 983,12 |
|---|
| |
| /** Setter for interrupt_received function pointer. |
| * |
| * @param conn Function that will implement a new interrupt |
| * notification fibril. |
| * @param intr Function that will implement a new interrupt |
| * notification fibril. |
| */ |
| void async_set_interrupt_received(async_client_conn_t conn) |
| void async_set_interrupt_received(async_client_conn_t intr) |
| { |
| interrupt_received = conn; |
| interrupt_received = intr; |
| } |
| |
| /** Pseudo-synchronous message sending - fast version. |
| 918,18 → 998,20 |
|---|
| * This function can only transfer 4 register payload arguments. For |
| * transferring more arguments, see the slower async_req_slow(). |
| * |
| * @param phoneid Hash of the phone through which to make the call. |
| * @param method Method of the call. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param r1 If non-NULL, storage for the 1st reply argument. |
| * @param r2 If non-NULL, storage for the 2nd reply argument. |
| * @param r3 If non-NULL, storage for the 3rd reply argument. |
| * @param r4 If non-NULL, storage for the 4th reply argument. |
| * @param r5 If non-NULL, storage for the 5th reply argument. |
| * @return Return code of the reply or a negative error code. |
| * @param phoneid Hash of the phone through which to make the call. |
| * @param method Method of the call. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param r1 If non-NULL, storage for the 1st reply argument. |
| * @param r2 If non-NULL, storage for the 2nd reply argument. |
| * @param r3 If non-NULL, storage for the 3rd reply argument. |
| * @param r4 If non-NULL, storage for the 4th reply argument. |
| * @param r5 If non-NULL, storage for the 5th reply argument. |
| * |
| * @return Return code of the reply or a negative error code. |
| * |
| */ |
| ipcarg_t async_req_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t *r1, ipcarg_t *r2, |
| 936,21 → 1018,27 |
|---|
| ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5) |
| { |
| ipc_call_t result; |
| ipcarg_t rc; |
| |
| aid_t eid = async_send_4(phoneid, method, arg1, arg2, arg3, arg4, |
| &result); |
| |
| ipcarg_t rc; |
| async_wait_for(eid, &rc); |
| if (r1) |
| |
| if (r1) |
| *r1 = IPC_GET_ARG1(result); |
| |
| if (r2) |
| *r2 = IPC_GET_ARG2(result); |
| |
| if (r3) |
| *r3 = IPC_GET_ARG3(result); |
| |
| if (r4) |
| *r4 = IPC_GET_ARG4(result); |
| |
| if (r5) |
| *r5 = IPC_GET_ARG5(result); |
| |
| return rc; |
| } |
| |
| 958,19 → 1046,21 |
|---|
| * |
| * Send message asynchronously and return only after the reply arrives. |
| * |
| * @param phoneid Hash of the phone through which to make the call. |
| * @param method Method of the call. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param r1 If non-NULL, storage for the 1st reply argument. |
| * @param r2 If non-NULL, storage for the 2nd reply argument. |
| * @param r3 If non-NULL, storage for the 3rd reply argument. |
| * @param r4 If non-NULL, storage for the 4th reply argument. |
| * @param r5 If non-NULL, storage for the 5th reply argument. |
| * @return Return code of the reply or a negative error code. |
| * @param phoneid Hash of the phone through which to make the call. |
| * @param method Method of the call. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param r1 If non-NULL, storage for the 1st reply argument. |
| * @param r2 If non-NULL, storage for the 2nd reply argument. |
| * @param r3 If non-NULL, storage for the 3rd reply argument. |
| * @param r4 If non-NULL, storage for the 4th reply argument. |
| * @param r5 If non-NULL, storage for the 5th reply argument. |
| * |
| * @return Return code of the reply or a negative error code. |
| * |
| */ |
| ipcarg_t async_req_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *r1, |
| 977,21 → 1067,27 |
|---|
| ipcarg_t *r2, ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5) |
| { |
| ipc_call_t result; |
| ipcarg_t rc; |
| |
| aid_t eid = async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, |
| &result); |
| |
| ipcarg_t rc; |
| async_wait_for(eid, &rc); |
| if (r1) |
| |
| if (r1) |
| *r1 = IPC_GET_ARG1(result); |
| |
| if (r2) |
| *r2 = IPC_GET_ARG2(result); |
| |
| if (r3) |
| *r3 = IPC_GET_ARG3(result); |
| |
| if (r4) |
| *r4 = IPC_GET_ARG4(result); |
| |
| if (r5) |
| *r5 = IPC_GET_ARG5(result); |
| |
| return rc; |
| } |
| |