Index: uspace/lib/c/generic/async.c =================================================================== --- uspace/lib/c/generic/async.c (revision 64d2b101abaf56a6f7c27f0d6b099785aa173f36) +++ uspace/lib/c/generic/async.c (revision 0dfaa099a12cf0db2564585eada36845dc3a6e97) @@ -42,9 +42,4 @@ * 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 ] * * Example of use (pseudo C): @@ -127,6 +122,6 @@ /** - * Structures of this type are used to group information about a call and a - * message queue link. + * Structures of this type are used to group information about + * a call and about a message queue link. */ typedef struct { @@ -156,5 +151,5 @@ /** Link to the client tracking structure. */ client_t *client; - + /** Messages that should be delivered to this fibril. */ link_t msg_queue; @@ -173,5 +168,5 @@ /** Identifier of the incoming connection handled by the current fibril. */ -fibril_local connection_t *FIBRIL_connection; +static fibril_local connection_t *FIBRIL_connection; static void *default_client_data_constructor(void) @@ -202,10 +197,19 @@ { assert(FIBRIL_connection); - return FIBRIL_connection->client->data; } -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); +/** Default fibril function that gets called to handle new connection. + * + * 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_client_connection(ipc_callid_t callid, ipc_call_t *call) +{ + ipc_answer_0(callid, ENOENT); +} /** @@ -213,4 +217,16 @@ */ static async_client_conn_t client_connection = default_client_connection; + +/** Default fibril function that gets called to handle interrupt notifications. + * + * 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) +{ +} /** @@ -224,17 +240,17 @@ static LIST_INITIALIZE(timeout_list); -#define CLIENT_HASH_TABLE_BUCKETS 32 -#define CONN_HASH_TABLE_BUCKETS 32 - -static hash_index_t client_hash(unsigned long *key) +#define CLIENT_HASH_TABLE_BUCKETS 32 +#define CONN_HASH_TABLE_BUCKETS 32 + +static hash_index_t client_hash(unsigned long key[]) { assert(key); - return (((*key) >> 4) % CLIENT_HASH_TABLE_BUCKETS); + return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS); } static int client_compare(unsigned long key[], hash_count_t keys, link_t *item) { - client_t *cl = hash_table_get_instance(item, client_t, link); - return (key[0] == cl->in_task_hash); + client_t *client = hash_table_get_instance(item, client_t, link); + return (key[0] == client->in_task_hash); } @@ -257,8 +273,8 @@ * */ -static hash_index_t conn_hash(unsigned long *key) +static hash_index_t conn_hash(unsigned long key[]) { assert(key); - return (((*key) >> 4) % CONN_HASH_TABLE_BUCKETS); + return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS); } @@ -274,6 +290,6 @@ static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item) { - connection_t *hs = hash_table_get_instance(item, connection_t, link); - return (key[0] == hs->in_phone_hash); + connection_t *conn = hash_table_get_instance(item, connection_t, link); + return (key[0] == conn->in_phone_hash); } @@ -290,5 +306,4 @@ free(hash_table_get_instance(item, connection_t, link)); } - /** Operations for the connection hash table. */ @@ -311,9 +326,10 @@ link_t *tmp = timeout_list.next; while (tmp != &timeout_list) { - awaiter_t *cur; - - cur = list_get_instance(tmp, awaiter_t, to_event.link); + awaiter_t *cur + = list_get_instance(tmp, awaiter_t, to_event.link); + if (tv_gteq(&cur->to_event.expires, &wd->to_event.expires)) break; + tmp = tmp->next; } @@ -332,5 +348,5 @@ * * @return False if the call doesn't match any connection. - * True if the call was passed to the respective connection fibril. + * @return True if the call was passed to the respective connection fibril. * */ @@ -469,5 +485,5 @@ * the first IPC_M_PHONE_HUNGUP call and continues to * call async_get_call_timeout(). Repeat - * IPC_M_PHONE_HUNGUP until the caller notices. + * IPC_M_PHONE_HUNGUP until the caller notices. */ memset(call, 0, sizeof(ipc_call_t)); @@ -476,5 +492,5 @@ return conn->close_callid; } - + if (usecs) async_insert_timeout(&conn->wdata); @@ -514,29 +530,4 @@ } -/** Default fibril function that gets called to handle new connection. - * - * 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_client_connection(ipc_callid_t callid, ipc_call_t *call) -{ - ipc_answer_0(callid, ENOENT); -} - -/** Default fibril function that gets called to handle interrupt notifications. - * - * 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) -{ -} - /** Wrapper for client connection fibril. * @@ -551,14 +542,11 @@ static int connection_fibril(void *arg) { - unsigned long key; - client_t *cl; - link_t *lnk; - bool destroy = false; - /* * Setup fibril-local connection pointer. */ FIBRIL_connection = (connection_t *) arg; - + + futex_down(&async_futex); + /* * Add our reference for the current connection in the client task @@ -566,28 +554,35 @@ * hash in a new tracking structure. */ - futex_down(&async_futex); - key = FIBRIL_connection->in_task_hash; - lnk = hash_table_find(&client_hash_table, &key); + + unsigned long key = FIBRIL_connection->in_task_hash; + link_t *lnk = hash_table_find(&client_hash_table, &key); + + client_t *client; + if (lnk) { - cl = hash_table_get_instance(lnk, client_t, link); - cl->refcnt++; + client = hash_table_get_instance(lnk, client_t, link); + client->refcnt++; } else { - cl = malloc(sizeof(client_t)); - if (!cl) { + client = malloc(sizeof(client_t)); + if (!client) { ipc_answer_0(FIBRIL_connection->callid, ENOMEM); futex_up(&async_futex); return 0; } - cl->in_task_hash = FIBRIL_connection->in_task_hash; + + client->in_task_hash = FIBRIL_connection->in_task_hash; + async_serialize_start(); - cl->data = async_client_data_create(); + client->data = async_client_data_create(); async_serialize_end(); - cl->refcnt = 1; - hash_table_insert(&client_hash_table, &key, &cl->link); - } + + client->refcnt = 1; + hash_table_insert(&client_hash_table, &key, &client->link); + } + futex_up(&async_futex); - - FIBRIL_connection->client = cl; - + + FIBRIL_connection->client = client; + /* * Call the connection handler function. @@ -599,17 +594,23 @@ * Remove the reference for this client task connection. */ + bool destroy; + futex_down(&async_futex); - if (--cl->refcnt == 0) { + + if (--client->refcnt == 0) { hash_table_remove(&client_hash_table, &key, 1); destroy = true; - } + } else + destroy = false; + futex_up(&async_futex); - + if (destroy) { - if (cl->data) - async_client_data_destroy(cl->data); - free(cl); - } - + if (client->data) + async_client_data_destroy(client->data); + + free(client); + } + /* * Remove myself from the connection hash table. @@ -624,8 +625,8 @@ */ while (!list_empty(&FIBRIL_connection->msg_queue)) { - msg_t *msg; - - 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); ipc_answer_0(msg->callid, EHANGUP); @@ -670,4 +671,5 @@ if (callid) ipc_answer_0(callid, ENOMEM); + return (uintptr_t) NULL; } @@ -717,8 +719,8 @@ static void handle_call(ipc_callid_t callid, ipc_call_t *call) { - /* Unrouted call - do some default behaviour */ + /* Unrouted call - take some default action */ if ((callid & IPC_CALLID_NOTIFICATION)) { process_notification(callid, call); - goto out; + return; } @@ -726,20 +728,16 @@ case IPC_M_CONNECT_ME: case IPC_M_CONNECT_ME_TO: - /* Open new connection with fibril etc. */ + /* Open new connection with fibril, etc. */ async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call), callid, call, client_connection); - goto out; + return; } /* Try to route the call through the connection hash table */ if (route_call(callid, call)) - goto out; + return; /* Unknown call from unknown phone - hang it up */ ipc_answer_0(callid, EHANGUP); - return; - -out: - ; } @@ -754,12 +752,12 @@ link_t *cur = timeout_list.next; while (cur != &timeout_list) { - awaiter_t *waiter; - - waiter = list_get_instance(cur, awaiter_t, to_event.link); + awaiter_t *waiter = + list_get_instance(cur, awaiter_t, to_event.link); + if (tv_gt(&waiter->to_event.expires, &tv)) break; - + cur = cur->next; - + list_remove(&waiter->to_event.link); waiter->to_event.inlist = false; @@ -788,5 +786,5 @@ while (true) { if (fibril_switch(FIBRIL_FROM_MANAGER)) { - futex_up(&async_futex); + futex_up(&async_futex); /* * async_futex is always held when entering a manager @@ -811,11 +809,10 @@ continue; } else - timeout = tv_sub(&waiter->to_event.expires, - &tv); + timeout = tv_sub(&waiter->to_event.expires, &tv); } else timeout = SYNCH_NO_TIMEOUT; futex_up(&async_futex); - + atomic_inc(&threads_in_ipc_wait); @@ -825,5 +822,5 @@ atomic_dec(&threads_in_ipc_wait); - + if (!callid) { handle_expired_timeouts(); @@ -875,17 +872,14 @@ /** Initialize the async framework. * - * @return Zero on success or an error code. - */ -int __async_init(void) + */ +void __async_init(void) { if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1, - &client_hash_table_ops) || !hash_table_create(&conn_hash_table, - CONN_HASH_TABLE_BUCKETS, 1, &conn_hash_table_ops)) { - return ENOMEM; - } - - _async_sess_init(); - - return 0; + &client_hash_table_ops)) + abort(); + + if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, 1, + &conn_hash_table_ops)) + abort(); } @@ -900,4 +894,5 @@ * @param retval Value returned in the answer. * @param data Call data of the answer. + * */ static void reply_received(void *arg, int retval, ipc_call_t *data) @@ -947,5 +942,5 @@ sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr) { - amsg_t *msg = malloc(sizeof(*msg)); + amsg_t *msg = malloc(sizeof(amsg_t)); if (!msg) @@ -956,5 +951,9 @@ msg->wdata.to_event.inlist = false; - /* We may sleep in the next method, but it will use its own mechanism */ + + /* + * We may sleep in the next method, + * but it will use its own means + */ msg->wdata.active = true; @@ -987,5 +986,5 @@ ipc_call_t *dataptr) { - amsg_t *msg = malloc(sizeof(*msg)); + amsg_t *msg = malloc(sizeof(amsg_t)); if (!msg) @@ -996,5 +995,9 @@ msg->wdata.to_event.inlist = false; - /* We may sleep in next method, but it will use its own mechanism */ + + /* + * We may sleep in the next method, + * but it will use its own means + */ msg->wdata.active = true; @@ -1095,5 +1098,5 @@ void async_usleep(suseconds_t timeout) { - amsg_t *msg = malloc(sizeof(*msg)); + amsg_t *msg = malloc(sizeof(amsg_t)); if (!msg) @@ -1307,13 +1310,13 @@ } -int async_forward_fast(ipc_callid_t callid, int phoneid, int imethod, - sysarg_t arg1, sysarg_t arg2, int mode) +int async_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod, + sysarg_t arg1, sysarg_t arg2, unsigned int mode) { return ipc_forward_fast(callid, phoneid, imethod, arg1, arg2, mode); } -int async_forward_slow(ipc_callid_t callid, int phoneid, int imethod, +int async_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, - int mode) + unsigned int mode) { return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4, @@ -1428,24 +1431,25 @@ } -/** Wrapper for making IPC_M_SHARE_IN calls using the async framework. - * - * @param phoneid Phone that will be used to contact the receiving side. - * @param dst Destination address space area base. - * @param size Size of the destination address space area. - * @param arg User defined argument. - * @param flags Storage where the received flags will be stored. Can be - * NULL. - * - * @return Zero on success or a negative error code from errno.h. +/** Wrapper for IPC_M_SHARE_IN calls using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param dst Destination address space area base. + * @param size Size of the destination address space area. + * @param arg User defined argument. + * @param flags Storage for the received flags. Can be NULL. + * + * @return Zero on success or a negative error code from errno.h. + * */ int async_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg, - int *flags) -{ - int res; + unsigned int *flags) +{ sysarg_t tmp_flags; - res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst, + int res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst, (sysarg_t) size, arg, NULL, &tmp_flags); + if (flags) - *flags = tmp_flags; + *flags = (unsigned int) tmp_flags; + return res; } @@ -1453,54 +1457,59 @@ /** Wrapper for receiving the IPC_M_SHARE_IN calls using the async framework. * - * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN calls - * so that the user doesn't have to remember the meaning of each IPC argument. + * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. * * So far, this wrapper is to be used from within a connection fibril. * - * @param callid Storage where the hash of the IPC_M_SHARE_IN call will - * be stored. - * @param size Destination address space area size. - * - * @return Non-zero on success, zero on failure. - */ -int async_share_in_receive(ipc_callid_t *callid, size_t *size) -{ - ipc_call_t data; - + * @param callid Storage for the hash of the IPC_M_SHARE_IN call. + * @param size Destination address space area size. + * + * @return True on success, false on failure. + * + */ +bool async_share_in_receive(ipc_callid_t *callid, size_t *size) +{ assert(callid); assert(size); - + + ipc_call_t data; *callid = async_get_call(&data); + if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN) - return 0; + return false; + *size = (size_t) IPC_GET_ARG2(data); - return 1; + return true; } /** Wrapper for answering the IPC_M_SHARE_IN calls using the async framework. * - * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls - * so that the user doesn't have to remember the meaning of each IPC argument. - * - * @param callid Hash of the IPC_M_DATA_READ call to answer. - * @param src Source address space base. - * @param flags Flags to be used for sharing. Bits can be only cleared. - * - * @return Zero on success or a value from @ref errno.h on failure. - */ -int async_share_in_finalize(ipc_callid_t callid, void *src, int flags) + * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. + * + * @param callid Hash of the IPC_M_DATA_READ call to answer. + * @param src Source address space base. + * @param flags Flags to be used for sharing. Bits can be only cleared. + * + * @return Zero on success or a value from @ref errno.h on failure. + * + */ +int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags) { return ipc_share_in_finalize(callid, src, flags); } -/** Wrapper for making IPC_M_SHARE_OUT calls using the async framework. - * - * @param phoneid Phone that will be used to contact the receiving side. - * @param src Source address space area base address. - * @param flags Flags to be used for sharing. Bits can be only cleared. - * - * @return Zero on success or a negative error code from errno.h. - */ -int async_share_out_start(int phoneid, void *src, int flags) +/** Wrapper for IPC_M_SHARE_OUT calls using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param src Source address space area base address. + * @param flags Flags to be used for sharing. Bits can be only cleared. + * + * @return Zero on success or a negative error code from errno.h. + * + */ +int async_share_out_start(int phoneid, void *src, unsigned int flags) { return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0, @@ -1510,42 +1519,45 @@ /** Wrapper for receiving the IPC_M_SHARE_OUT calls using the async framework. * - * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT calls - * so that the user doesn't have to remember the meaning of each IPC argument. + * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. * * So far, this wrapper is to be used from within a connection fibril. * - * @param callid Storage where the hash of the IPC_M_SHARE_OUT call will - * be stored. - * @param size Storage where the source address space area size will be - * stored. - * @param flags Storage where the sharing flags will be stored. - * - * @return Non-zero on success, zero on failure. - */ -int async_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags) -{ - ipc_call_t data; - + * @param callid Storage for the hash of the IPC_M_SHARE_OUT call. + * @param size Storage for the source address space area size. + * @param flags Storage for the sharing flags. + * + * @return True on success, false on failure. + * + */ +bool async_share_out_receive(ipc_callid_t *callid, size_t *size, unsigned int *flags) +{ assert(callid); assert(size); assert(flags); - + + ipc_call_t data; *callid = async_get_call(&data); + if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT) - return 0; + return false; + *size = (size_t) IPC_GET_ARG2(data); - *flags = (int) IPC_GET_ARG3(data); - return 1; + *flags = (unsigned int) IPC_GET_ARG3(data); + return true; } /** Wrapper for answering the IPC_M_SHARE_OUT calls using the async framework. * - * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls - * so that the user doesn't have to remember the meaning of each IPC argument. - * - * @param callid Hash of the IPC_M_DATA_WRITE call to answer. - * @param dst Destination address space area base address. - * - * @return Zero on success or a value from @ref errno.h on failure. + * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. + * + * @param callid Hash of the IPC_M_DATA_WRITE call to answer. + * @param dst Destination address space area base address. + * + * @return Zero on success or a value from @ref errno.h on failure. + * */ int async_share_out_finalize(ipc_callid_t callid, void *dst) @@ -1554,12 +1566,12 @@ } - -/** Wrapper for making IPC_M_DATA_READ calls using the async framework. - * - * @param phoneid Phone that will be used to contact the receiving side. - * @param dst Address of the beginning of the destination buffer. - * @param size Size of the destination buffer. - * - * @return Zero on success or a negative error code from errno.h. +/** Wrapper for IPC_M_DATA_READ calls using the async framework. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param dst Address of the beginning of the destination buffer. + * @param size Size of the destination buffer. + * + * @return Zero on success or a negative error code from errno.h. + * */ int async_data_read_start(int phoneid, void *dst, size_t size) @@ -1571,41 +1583,45 @@ /** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework. * - * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ calls - * so that the user doesn't have to remember the meaning of each IPC argument. + * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. * * So far, this wrapper is to be used from within a connection fibril. * - * @param callid Storage where the hash of the IPC_M_DATA_READ call will - * be stored. - * @param size Storage where the maximum size will be stored. Can be - * NULL. - * - * @return Non-zero on success, zero on failure. - */ -int async_data_read_receive(ipc_callid_t *callid, size_t *size) -{ + * @param callid Storage for the hash of the IPC_M_DATA_READ. + * @param size Storage for the maximum size. Can be NULL. + * + * @return True on success, false on failure. + * + */ +bool async_data_read_receive(ipc_callid_t *callid, size_t *size) +{ + assert(callid); + ipc_call_t data; - - assert(callid); - *callid = async_get_call(&data); + if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ) - return 0; + return false; + if (size) *size = (size_t) IPC_GET_ARG2(data); - return 1; + + return true; } /** Wrapper for answering the IPC_M_DATA_READ calls using the async framework. * - * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls - * so that the user doesn't have to remember the meaning of each IPC argument. - * - * @param callid Hash of the IPC_M_DATA_READ call to answer. - * @param src Source address for the IPC_M_DATA_READ call. - * @param size Size for the IPC_M_DATA_READ call. Can be smaller than - * the maximum size announced by the sender. - * - * @return Zero on success or a value from @ref errno.h on failure. + * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. + * + * @param callid Hash of the IPC_M_DATA_READ call to answer. + * @param src Source address for the IPC_M_DATA_READ call. + * @param size Size for the IPC_M_DATA_READ call. Can be smaller than + * the maximum size announced by the sender. + * + * @return Zero on success or a value from @ref errno.h on failure. + * */ int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size) @@ -1647,5 +1663,5 @@ } -/** Wrapper for making IPC_M_DATA_WRITE calls using the async framework. +/** Wrapper for IPC_M_DATA_WRITE calls using the async framework. * * @param phoneid Phone that will be used to contact the receiving side. @@ -1664,37 +1680,37 @@ /** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework. * - * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE calls - * so that the user doesn't have to remember the meaning of each IPC argument. + * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. * * So far, this wrapper is to be used from within a connection fibril. * - * @param callid Storage where the hash of the IPC_M_DATA_WRITE call will - * be stored. - * @param size Storage where the suggested size will be stored. May be - * NULL - * - * @return Non-zero on success, zero on failure. - * - */ -int async_data_write_receive(ipc_callid_t *callid, size_t *size) -{ + * @param callid Storage for the hash of the IPC_M_DATA_WRITE. + * @param size Storage for the suggested size. May be NULL. + * + * @return True on success, false on failure. + * + */ +bool async_data_write_receive(ipc_callid_t *callid, size_t *size) +{ + assert(callid); + ipc_call_t data; - - assert(callid); - *callid = async_get_call(&data); + if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE) - return 0; + return false; if (size) *size = (size_t) IPC_GET_ARG2(data); - return 1; + return true; } /** Wrapper for answering the IPC_M_DATA_WRITE calls using the async framework. * - * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls - * so that the user doesn't have to remember the meaning of each IPC argument. + * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE + * calls so that the user doesn't have to remember the meaning of each IPC + * argument. * * @param callid Hash of the IPC_M_DATA_WRITE call to answer. @@ -1792,5 +1808,5 @@ * */ -void async_data_write_void(const int retval) +void async_data_write_void(sysarg_t retval) { ipc_callid_t callid;