Changes in uspace/lib/c/generic/async.c [23882034:9c31643] in mainline
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/generic/async.c
r23882034 r9c31643 43 43 * framework will automatically take care of most synchronization problems. 44 44 * 45 * Default semantics:46 * - async_send_*(): Send asynchronously. If the kernel refuses to send47 * more messages, [ try to get responses from kernel, if48 * nothing found, might try synchronous ]49 *50 45 * Example of use (pseudo C): 51 46 * … … 58 53 * int fibril1(void *arg) 59 54 * { 60 * conn = ipc_connect_me_to();55 * conn = async_connect_me_to(); 61 56 * c1 = async_send(conn); 62 57 * c2 = async_send(conn); … … 77 72 * { 78 73 * if (want_refuse) { 79 * ipc_answer_0(icallid, ELIMIT);74 * async_answer_0(icallid, ELIMIT); 80 75 * return; 81 76 * } 82 * ipc_answer_0(icallid, EOK);77 * async_answer_0(icallid, EOK); 83 78 * 84 79 * callid = async_get_call(&call); 85 80 * somehow_handle_the_call(callid, call); 86 * ipc_answer_2(callid, 1, 2, 3);81 * async_answer_2(callid, 1, 2, 3); 87 82 * 88 83 * callid = async_get_call(&call); … … 92 87 */ 93 88 89 #define LIBC_ASYNC_C_ 90 #include <ipc/ipc.h> 91 #include <async.h> 92 #undef LIBC_ASYNC_C_ 93 94 94 #include <futex.h> 95 #include <async.h>96 #include <async_priv.h>97 95 #include <fibril.h> 98 96 #include <stdio.h> 99 97 #include <adt/hash_table.h> 100 98 #include <adt/list.h> 101 #include <ipc/ipc.h>102 99 #include <assert.h> 103 100 #include <errno.h> … … 105 102 #include <arch/barrier.h> 106 103 #include <bool.h> 104 #include "private/async.h" 107 105 108 106 atomic_t async_futex = FUTEX_INITIALIZER; … … 124 122 125 123 /** 126 * Structures of this type are used to group information about a call and a127 * message queue link.124 * Structures of this type are used to group information about 125 * a call and about a message queue link. 128 126 */ 129 127 typedef struct { … … 153 151 /** Link to the client tracking structure. */ 154 152 client_t *client; 155 153 156 154 /** Messages that should be delivered to this fibril. */ 157 155 link_t msg_queue; … … 170 168 171 169 /** Identifier of the incoming connection handled by the current fibril. */ 172 fibril_local connection_t *FIBRIL_connection;170 static fibril_local connection_t *FIBRIL_connection; 173 171 174 172 static void *default_client_data_constructor(void) … … 199 197 { 200 198 assert(FIBRIL_connection); 201 202 199 return FIBRIL_connection->client->data; 203 200 } 204 201 205 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call); 206 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call); 202 /** Default fibril function that gets called to handle new connection. 203 * 204 * This function is defined as a weak symbol - to be redefined in user code. 205 * 206 * @param callid Hash of the incoming call. 207 * @param call Data of the incoming call. 208 * 209 */ 210 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call) 211 { 212 ipc_answer_0(callid, ENOENT); 213 } 207 214 208 215 /** … … 210 217 */ 211 218 static async_client_conn_t client_connection = default_client_connection; 219 220 /** Default fibril function that gets called to handle interrupt notifications. 221 * 222 * This function is defined as a weak symbol - to be redefined in user code. 223 * 224 * @param callid Hash of the incoming call. 225 * @param call Data of the incoming call. 226 * 227 */ 228 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call) 229 { 230 } 212 231 213 232 /** … … 221 240 static LIST_INITIALIZE(timeout_list); 222 241 223 #define CLIENT_HASH_TABLE_BUCKETS 224 #define CONN_HASH_TABLE_BUCKETS 225 226 static hash_index_t client_hash(unsigned long *key)242 #define CLIENT_HASH_TABLE_BUCKETS 32 243 #define CONN_HASH_TABLE_BUCKETS 32 244 245 static hash_index_t client_hash(unsigned long key[]) 227 246 { 228 247 assert(key); 229 return ((( *key) >> 4) % CLIENT_HASH_TABLE_BUCKETS);248 return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS); 230 249 } 231 250 232 251 static int client_compare(unsigned long key[], hash_count_t keys, link_t *item) 233 252 { 234 client_t *cl = hash_table_get_instance(item, client_t, link);235 return (key[0] == cl ->in_task_hash);253 client_t *client = hash_table_get_instance(item, client_t, link); 254 return (key[0] == client->in_task_hash); 236 255 } 237 256 … … 254 273 * 255 274 */ 256 static hash_index_t conn_hash(unsigned long *key)275 static hash_index_t conn_hash(unsigned long key[]) 257 276 { 258 277 assert(key); 259 return ((( *key) >> 4) % CONN_HASH_TABLE_BUCKETS);278 return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS); 260 279 } 261 280 … … 271 290 static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item) 272 291 { 273 connection_t *hs = hash_table_get_instance(item, connection_t, link); 274 return (key[0] == hs->in_phone_hash); 275 } 276 277 /** Connection hash table removal callback function. 278 * 279 * This function is called whenever a connection is removed from the connection 280 * hash table. 281 * 282 * @param item Connection hash table item being removed. 283 * 284 */ 292 connection_t *conn = hash_table_get_instance(item, connection_t, link); 293 return (key[0] == conn->in_phone_hash); 294 } 295 285 296 static void conn_remove(link_t *item) 286 297 { 287 free(hash_table_get_instance(item, connection_t, link)); 288 } 289 298 } 290 299 291 300 /** Operations for the connection hash table. */ … … 308 317 link_t *tmp = timeout_list.next; 309 318 while (tmp != &timeout_list) { 310 awaiter_t *cur ;311 312 cur = list_get_instance(tmp, awaiter_t, to_event.link);319 awaiter_t *cur 320 = list_get_instance(tmp, awaiter_t, to_event.link); 321 313 322 if (tv_gteq(&cur->to_event.expires, &wd->to_event.expires)) 314 323 break; 324 315 325 tmp = tmp->next; 316 326 } … … 329 339 * 330 340 * @return False if the call doesn't match any connection. 331 * 341 * @return True if the call was passed to the respective connection fibril. 332 342 * 333 343 */ … … 466 476 * the first IPC_M_PHONE_HUNGUP call and continues to 467 477 * call async_get_call_timeout(). Repeat 468 * IPC_M_PHONE_HUNGUP until the caller notices. 478 * IPC_M_PHONE_HUNGUP until the caller notices. 469 479 */ 470 480 memset(call, 0, sizeof(ipc_call_t)); … … 473 483 return conn->close_callid; 474 484 } 475 485 476 486 if (usecs) 477 487 async_insert_timeout(&conn->wdata); … … 511 521 } 512 522 513 /** Default fibril function that gets called to handle new connection.514 *515 * This function is defined as a weak symbol - to be redefined in user code.516 *517 * @param callid Hash of the incoming call.518 * @param call Data of the incoming call.519 *520 */521 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)522 {523 ipc_answer_0(callid, ENOENT);524 }525 526 /** Default fibril function that gets called to handle interrupt notifications.527 *528 * This function is defined as a weak symbol - to be redefined in user code.529 *530 * @param callid Hash of the incoming call.531 * @param call Data of the incoming call.532 *533 */534 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)535 {536 }537 538 523 /** Wrapper for client connection fibril. 539 524 * … … 548 533 static int connection_fibril(void *arg) 549 534 { 550 unsigned long key;551 client_t *cl;552 link_t *lnk;553 bool destroy = false;554 555 535 /* 556 536 * Setup fibril-local connection pointer. 557 537 */ 558 538 FIBRIL_connection = (connection_t *) arg; 559 539 540 futex_down(&async_futex); 541 560 542 /* 561 543 * Add our reference for the current connection in the client task … … 563 545 * hash in a new tracking structure. 564 546 */ 565 futex_down(&async_futex); 566 key = FIBRIL_connection->in_task_hash; 567 lnk = hash_table_find(&client_hash_table, &key); 547 548 unsigned long key = FIBRIL_connection->in_task_hash; 549 link_t *lnk = hash_table_find(&client_hash_table, &key); 550 551 client_t *client; 552 568 553 if (lnk) { 569 cl = hash_table_get_instance(lnk, client_t, link);570 cl ->refcnt++;554 client = hash_table_get_instance(lnk, client_t, link); 555 client->refcnt++; 571 556 } else { 572 cl = malloc(sizeof(client_t));573 if (!cl ) {557 client = malloc(sizeof(client_t)); 558 if (!client) { 574 559 ipc_answer_0(FIBRIL_connection->callid, ENOMEM); 575 560 futex_up(&async_futex); 576 561 return 0; 577 562 } 578 cl->in_task_hash = FIBRIL_connection->in_task_hash; 563 564 client->in_task_hash = FIBRIL_connection->in_task_hash; 565 579 566 async_serialize_start(); 580 cl ->data = async_client_data_create();567 client->data = async_client_data_create(); 581 568 async_serialize_end(); 582 cl->refcnt = 1; 583 hash_table_insert(&client_hash_table, &key, &cl->link); 584 } 569 570 client->refcnt = 1; 571 hash_table_insert(&client_hash_table, &key, &client->link); 572 } 573 585 574 futex_up(&async_futex); 586 587 FIBRIL_connection->client = cl ;588 575 576 FIBRIL_connection->client = client; 577 589 578 /* 590 579 * Call the connection handler function. … … 596 585 * Remove the reference for this client task connection. 597 586 */ 587 bool destroy; 588 598 589 futex_down(&async_futex); 599 if (--cl->refcnt == 0) { 590 591 if (--client->refcnt == 0) { 600 592 hash_table_remove(&client_hash_table, &key, 1); 601 593 destroy = true; 602 } 594 } else 595 destroy = false; 596 603 597 futex_up(&async_futex); 604 598 605 599 if (destroy) { 606 if (cl->data) 607 async_client_data_destroy(cl->data); 608 free(cl); 609 } 610 600 if (client->data) 601 async_client_data_destroy(client->data); 602 603 free(client); 604 } 605 611 606 /* 612 607 * Remove myself from the connection hash table. … … 621 616 */ 622 617 while (!list_empty(&FIBRIL_connection->msg_queue)) { 623 msg_t *msg ;624 625 msg = list_get_instance(FIBRIL_connection->msg_queue.next,626 msg_t, link);618 msg_t *msg = 619 list_get_instance(FIBRIL_connection->msg_queue.next, msg_t, 620 link); 621 627 622 list_remove(&msg->link); 628 623 ipc_answer_0(msg->callid, EHANGUP); … … 637 632 ipc_answer_0(FIBRIL_connection->close_callid, EOK); 638 633 634 free(FIBRIL_connection); 639 635 return 0; 640 636 } … … 667 663 if (callid) 668 664 ipc_answer_0(callid, ENOMEM); 665 669 666 return (uintptr_t) NULL; 670 667 } … … 714 711 static void handle_call(ipc_callid_t callid, ipc_call_t *call) 715 712 { 716 /* Unrouted call - do some default behaviour*/713 /* Unrouted call - take some default action */ 717 714 if ((callid & IPC_CALLID_NOTIFICATION)) { 718 715 process_notification(callid, call); 719 goto out;716 return; 720 717 } 721 718 … … 723 720 case IPC_M_CONNECT_ME: 724 721 case IPC_M_CONNECT_ME_TO: 725 /* Open new connection with fibril etc. */722 /* Open new connection with fibril, etc. */ 726 723 async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call), 727 724 callid, call, client_connection); 728 goto out;725 return; 729 726 } 730 727 731 728 /* Try to route the call through the connection hash table */ 732 729 if (route_call(callid, call)) 733 goto out;730 return; 734 731 735 732 /* Unknown call from unknown phone - hang it up */ 736 733 ipc_answer_0(callid, EHANGUP); 737 return;738 739 out:740 ;741 734 } 742 735 … … 751 744 link_t *cur = timeout_list.next; 752 745 while (cur != &timeout_list) { 753 awaiter_t *waiter ;754 755 waiter = list_get_instance(cur, awaiter_t, to_event.link);746 awaiter_t *waiter = 747 list_get_instance(cur, awaiter_t, to_event.link); 748 756 749 if (tv_gt(&waiter->to_event.expires, &tv)) 757 750 break; 758 751 759 752 cur = cur->next; 760 753 761 754 list_remove(&waiter->to_event.link); 762 755 waiter->to_event.inlist = false; … … 785 778 while (true) { 786 779 if (fibril_switch(FIBRIL_FROM_MANAGER)) { 787 futex_up(&async_futex); 780 futex_up(&async_futex); 788 781 /* 789 782 * async_futex is always held when entering a manager … … 808 801 continue; 809 802 } else 810 timeout = tv_sub(&waiter->to_event.expires, 811 &tv); 803 timeout = tv_sub(&waiter->to_event.expires, &tv); 812 804 } else 813 805 timeout = SYNCH_NO_TIMEOUT; 814 806 815 807 futex_up(&async_futex); 816 808 817 809 atomic_inc(&threads_in_ipc_wait); 818 810 … … 822 814 823 815 atomic_dec(&threads_in_ipc_wait); 824 816 825 817 if (!callid) { 826 818 handle_expired_timeouts(); … … 872 864 /** Initialize the async framework. 873 865 * 874 * @return Zero on success or an error code. 875 */ 876 int __async_init(void) 866 */ 867 void __async_init(void) 877 868 { 878 869 if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1, 879 &client_hash_table_ops) || !hash_table_create(&conn_hash_table, 880 CONN_HASH_TABLE_BUCKETS, 1, &conn_hash_table_ops)) { 881 return ENOMEM; 882 } 883 884 _async_sess_init(); 885 886 return 0; 870 &client_hash_table_ops)) 871 abort(); 872 873 if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, 1, 874 &conn_hash_table_ops)) 875 abort(); 887 876 } 888 877 … … 897 886 * @param retval Value returned in the answer. 898 887 * @param data Call data of the answer. 888 * 899 889 */ 900 890 static void reply_received(void *arg, int retval, ipc_call_t *data) … … 944 934 sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr) 945 935 { 946 amsg_t *msg = malloc(sizeof( *msg));936 amsg_t *msg = malloc(sizeof(amsg_t)); 947 937 948 938 if (!msg) … … 953 943 954 944 msg->wdata.to_event.inlist = false; 955 /* We may sleep in the next method, but it will use its own mechanism */ 945 946 /* 947 * We may sleep in the next method, 948 * but it will use its own means 949 */ 956 950 msg->wdata.active = true; 957 951 … … 984 978 ipc_call_t *dataptr) 985 979 { 986 amsg_t *msg = malloc(sizeof( *msg));980 amsg_t *msg = malloc(sizeof(amsg_t)); 987 981 988 982 if (!msg) … … 993 987 994 988 msg->wdata.to_event.inlist = false; 995 /* We may sleep in next method, but it will use its own mechanism */ 989 990 /* 991 * We may sleep in the next method, 992 * but it will use its own means 993 */ 996 994 msg->wdata.active = true; 997 995 … … 1092 1090 void async_usleep(suseconds_t timeout) 1093 1091 { 1094 amsg_t *msg = malloc(sizeof( *msg));1092 amsg_t *msg = malloc(sizeof(amsg_t)); 1095 1093 1096 1094 if (!msg) … … 1235 1233 } 1236 1234 1235 void async_msg_0(int phone, sysarg_t imethod) 1236 { 1237 ipc_call_async_0(phone, imethod, NULL, NULL, true); 1238 } 1239 1240 void async_msg_1(int phone, sysarg_t imethod, sysarg_t arg1) 1241 { 1242 ipc_call_async_1(phone, imethod, arg1, NULL, NULL, true); 1243 } 1244 1245 void async_msg_2(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2) 1246 { 1247 ipc_call_async_2(phone, imethod, arg1, arg2, NULL, NULL, true); 1248 } 1249 1250 void async_msg_3(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, 1251 sysarg_t arg3) 1252 { 1253 ipc_call_async_3(phone, imethod, arg1, arg2, arg3, NULL, NULL, true); 1254 } 1255 1256 void async_msg_4(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, 1257 sysarg_t arg3, sysarg_t arg4) 1258 { 1259 ipc_call_async_4(phone, imethod, arg1, arg2, arg3, arg4, NULL, NULL, 1260 true); 1261 } 1262 1263 void async_msg_5(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, 1264 sysarg_t arg3, sysarg_t arg4, sysarg_t arg5) 1265 { 1266 ipc_call_async_5(phone, imethod, arg1, arg2, arg3, arg4, arg5, NULL, 1267 NULL, true); 1268 } 1269 1270 sysarg_t async_answer_0(ipc_callid_t callid, sysarg_t retval) 1271 { 1272 return ipc_answer_0(callid, retval); 1273 } 1274 1275 sysarg_t async_answer_1(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1) 1276 { 1277 return ipc_answer_1(callid, retval, arg1); 1278 } 1279 1280 sysarg_t async_answer_2(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, 1281 sysarg_t arg2) 1282 { 1283 return ipc_answer_2(callid, retval, arg1, arg2); 1284 } 1285 1286 sysarg_t async_answer_3(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, 1287 sysarg_t arg2, sysarg_t arg3) 1288 { 1289 return ipc_answer_3(callid, retval, arg1, arg2, arg3); 1290 } 1291 1292 sysarg_t async_answer_4(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, 1293 sysarg_t arg2, sysarg_t arg3, sysarg_t arg4) 1294 { 1295 return ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4); 1296 } 1297 1298 sysarg_t async_answer_5(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, 1299 sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5) 1300 { 1301 return ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5); 1302 } 1303 1304 int async_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod, 1305 sysarg_t arg1, sysarg_t arg2, unsigned int mode) 1306 { 1307 return ipc_forward_fast(callid, phoneid, imethod, arg1, arg2, mode); 1308 } 1309 1310 int async_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod, 1311 sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, 1312 unsigned int mode) 1313 { 1314 return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4, 1315 arg5, mode); 1316 } 1317 1318 /** Wrapper for making IPC_M_CONNECT_TO_ME calls using the async framework. 1319 * 1320 * Ask through phone for a new connection to some service. 1321 * 1322 * @param phone Phone handle used for contacting the other side. 1323 * @param arg1 User defined argument. 1324 * @param arg2 User defined argument. 1325 * @param arg3 User defined argument. 1326 * @param client_receiver Connection handing routine. 1327 * 1328 * @return New phone handle on success or a negative error code. 1329 * 1330 */ 1331 int async_connect_to_me(int phone, sysarg_t arg1, sysarg_t arg2, 1332 sysarg_t arg3, async_client_conn_t client_receiver) 1333 { 1334 sysarg_t task_hash; 1335 sysarg_t phone_hash; 1336 int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, 1337 NULL, NULL, NULL, &task_hash, &phone_hash); 1338 if (rc != EOK) 1339 return rc; 1340 1341 if (client_receiver != NULL) 1342 async_new_connection(task_hash, phone_hash, 0, NULL, 1343 client_receiver); 1344 1345 return EOK; 1346 } 1347 1237 1348 /** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. 1238 * 1349 * 1239 1350 * Ask through phone for a new connection to some service. 1240 1351 * 1241 * @param phone idPhone handle used for contacting the other side.1242 * @param arg1 1243 * @param arg2 1244 * @param arg3 1245 * 1246 * @return 1247 * /1248 int 1249 async_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3) 1250 { 1251 int rc; 1352 * @param phone Phone handle used for contacting the other side. 1353 * @param arg1 User defined argument. 1354 * @param arg2 User defined argument. 1355 * @param arg3 User defined argument. 1356 * 1357 * @return New phone handle on success or a negative error code. 1358 * 1359 */ 1360 int async_connect_me_to(int phone, sysarg_t arg1, sysarg_t arg2, 1361 sysarg_t arg3) 1362 { 1252 1363 sysarg_t newphid; 1253 1254 rc = async_req_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL, 1255 NULL, NULL, NULL, &newphid); 1256 1257 if (rc != EOK) 1364 int rc = async_req_3_5(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, 1365 NULL, NULL, NULL, NULL, &newphid); 1366 1367 if (rc != EOK) 1258 1368 return rc; 1259 1369 1260 1370 return newphid; 1261 1371 } 1262 1372 1263 1373 /** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. 1264 * 1374 * 1265 1375 * Ask through phone for a new connection to some service and block until 1266 1376 * success. 1267 1377 * 1268 * @param phoneid 1269 * @param arg1 1270 * @param arg2 1271 * @param arg3 1272 * 1273 * @return 1274 * /1275 int 1276 async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,1378 * @param phoneid Phone handle used for contacting the other side. 1379 * @param arg1 User defined argument. 1380 * @param arg2 User defined argument. 1381 * @param arg3 User defined argument. 1382 * 1383 * @return New phone handle on success or a negative error code. 1384 * 1385 */ 1386 int async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2, 1277 1387 sysarg_t arg3) 1278 1388 { 1279 int rc;1280 1389 sysarg_t newphid; 1281 1282 rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, 1390 int rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, 1283 1391 IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid); 1284 1392 1285 if (rc != EOK) 1393 if (rc != EOK) 1286 1394 return rc; 1287 1395 1288 1396 return newphid; 1289 1397 } 1290 1398 1291 /** Wrapper for making IPC_M_SHARE_IN calls using the async framework. 1292 * 1293 * @param phoneid Phone that will be used to contact the receiving side. 1294 * @param dst Destination address space area base. 1295 * @param size Size of the destination address space area. 1296 * @param arg User defined argument. 1297 * @param flags Storage where the received flags will be stored. Can be 1298 * NULL. 1299 * 1300 * @return Zero on success or a negative error code from errno.h. 1399 /** Connect to a task specified by id. 1400 * 1401 */ 1402 int async_connect_kbox(task_id_t id) 1403 { 1404 return ipc_connect_kbox(id); 1405 } 1406 1407 /** Wrapper for ipc_hangup. 1408 * 1409 * @param phone Phone handle to hung up. 1410 * 1411 * @return Zero on success or a negative error code. 1412 * 1413 */ 1414 int async_hangup(int phone) 1415 { 1416 return ipc_hangup(phone); 1417 } 1418 1419 /** Interrupt one thread of this task from waiting for IPC. */ 1420 void async_poke(void) 1421 { 1422 ipc_poke(); 1423 } 1424 1425 /** Wrapper for IPC_M_SHARE_IN calls using the async framework. 1426 * 1427 * @param phoneid Phone that will be used to contact the receiving side. 1428 * @param dst Destination address space area base. 1429 * @param size Size of the destination address space area. 1430 * @param arg User defined argument. 1431 * @param flags Storage for the received flags. Can be NULL. 1432 * 1433 * @return Zero on success or a negative error code from errno.h. 1434 * 1301 1435 */ 1302 1436 int async_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg, 1303 int *flags) 1304 { 1305 int res; 1437 unsigned int *flags) 1438 { 1306 1439 sysarg_t tmp_flags; 1307 res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,1440 int res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst, 1308 1441 (sysarg_t) size, arg, NULL, &tmp_flags); 1442 1309 1443 if (flags) 1310 *flags = tmp_flags; 1444 *flags = (unsigned int) tmp_flags; 1445 1311 1446 return res; 1312 1447 } … … 1314 1449 /** Wrapper for receiving the IPC_M_SHARE_IN calls using the async framework. 1315 1450 * 1316 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN calls 1317 * so that the user doesn't have to remember the meaning of each IPC argument. 1451 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN 1452 * calls so that the user doesn't have to remember the meaning of each IPC 1453 * argument. 1318 1454 * 1319 1455 * So far, this wrapper is to be used from within a connection fibril. 1320 1456 * 1321 * @param callid Storage where the hash of the IPC_M_SHARE_IN call will 1322 * be stored. 1323 * @param size Destination address space area size. 1324 * 1325 * @return Non-zero on success, zero on failure. 1326 */ 1327 int async_share_in_receive(ipc_callid_t *callid, size_t *size) 1328 { 1329 ipc_call_t data; 1330 1457 * @param callid Storage for the hash of the IPC_M_SHARE_IN call. 1458 * @param size Destination address space area size. 1459 * 1460 * @return True on success, false on failure. 1461 * 1462 */ 1463 bool async_share_in_receive(ipc_callid_t *callid, size_t *size) 1464 { 1331 1465 assert(callid); 1332 1466 assert(size); 1333 1467 1468 ipc_call_t data; 1334 1469 *callid = async_get_call(&data); 1470 1335 1471 if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN) 1336 return 0; 1472 return false; 1473 1337 1474 *size = (size_t) IPC_GET_ARG2(data); 1338 return 1;1475 return true; 1339 1476 } 1340 1477 1341 1478 /** Wrapper for answering the IPC_M_SHARE_IN calls using the async framework. 1342 1479 * 1343 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls 1344 * so that the user doesn't have to remember the meaning of each IPC argument. 1345 * 1346 * @param callid Hash of the IPC_M_DATA_READ call to answer. 1347 * @param src Source address space base. 1348 * @param flags Flags to be used for sharing. Bits can be only cleared. 1349 * 1350 * @return Zero on success or a value from @ref errno.h on failure. 1351 */ 1352 int async_share_in_finalize(ipc_callid_t callid, void *src, int flags) 1480 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ 1481 * calls so that the user doesn't have to remember the meaning of each IPC 1482 * argument. 1483 * 1484 * @param callid Hash of the IPC_M_DATA_READ call to answer. 1485 * @param src Source address space base. 1486 * @param flags Flags to be used for sharing. Bits can be only cleared. 1487 * 1488 * @return Zero on success or a value from @ref errno.h on failure. 1489 * 1490 */ 1491 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags) 1353 1492 { 1354 1493 return ipc_share_in_finalize(callid, src, flags); 1355 1494 } 1356 1495 1357 /** Wrapper for making IPC_M_SHARE_OUT calls using the async framework. 1358 * 1359 * @param phoneid Phone that will be used to contact the receiving side. 1360 * @param src Source address space area base address. 1361 * @param flags Flags to be used for sharing. Bits can be only cleared. 1362 * 1363 * @return Zero on success or a negative error code from errno.h. 1364 */ 1365 int async_share_out_start(int phoneid, void *src, int flags) 1496 /** Wrapper for IPC_M_SHARE_OUT calls using the async framework. 1497 * 1498 * @param phoneid Phone that will be used to contact the receiving side. 1499 * @param src Source address space area base address. 1500 * @param flags Flags to be used for sharing. Bits can be only cleared. 1501 * 1502 * @return Zero on success or a negative error code from errno.h. 1503 * 1504 */ 1505 int async_share_out_start(int phoneid, void *src, unsigned int flags) 1366 1506 { 1367 1507 return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0, … … 1371 1511 /** Wrapper for receiving the IPC_M_SHARE_OUT calls using the async framework. 1372 1512 * 1373 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT calls 1374 * so that the user doesn't have to remember the meaning of each IPC argument. 1513 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT 1514 * calls so that the user doesn't have to remember the meaning of each IPC 1515 * argument. 1375 1516 * 1376 1517 * So far, this wrapper is to be used from within a connection fibril. 1377 1518 * 1378 * @param callid Storage where the hash of the IPC_M_SHARE_OUT call will 1379 * be stored. 1380 * @param size Storage where the source address space area size will be 1381 * stored. 1382 * @param flags Storage where the sharing flags will be stored. 1383 * 1384 * @return Non-zero on success, zero on failure. 1385 */ 1386 int async_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags) 1387 { 1388 ipc_call_t data; 1389 1519 * @param callid Storage for the hash of the IPC_M_SHARE_OUT call. 1520 * @param size Storage for the source address space area size. 1521 * @param flags Storage for the sharing flags. 1522 * 1523 * @return True on success, false on failure. 1524 * 1525 */ 1526 bool async_share_out_receive(ipc_callid_t *callid, size_t *size, unsigned int *flags) 1527 { 1390 1528 assert(callid); 1391 1529 assert(size); 1392 1530 assert(flags); 1393 1531 1532 ipc_call_t data; 1394 1533 *callid = async_get_call(&data); 1534 1395 1535 if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT) 1396 return 0; 1536 return false; 1537 1397 1538 *size = (size_t) IPC_GET_ARG2(data); 1398 *flags = ( int) IPC_GET_ARG3(data);1399 return 1;1539 *flags = (unsigned int) IPC_GET_ARG3(data); 1540 return true; 1400 1541 } 1401 1542 1402 1543 /** Wrapper for answering the IPC_M_SHARE_OUT calls using the async framework. 1403 1544 * 1404 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls 1405 * so that the user doesn't have to remember the meaning of each IPC argument. 1406 * 1407 * @param callid Hash of the IPC_M_DATA_WRITE call to answer. 1408 * @param dst Destination address space area base address. 1409 * 1410 * @return Zero on success or a value from @ref errno.h on failure. 1545 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT 1546 * calls so that the user doesn't have to remember the meaning of each IPC 1547 * argument. 1548 * 1549 * @param callid Hash of the IPC_M_DATA_WRITE call to answer. 1550 * @param dst Destination address space area base address. 1551 * 1552 * @return Zero on success or a value from @ref errno.h on failure. 1553 * 1411 1554 */ 1412 1555 int async_share_out_finalize(ipc_callid_t callid, void *dst) … … 1415 1558 } 1416 1559 1417 1418 /** Wrapper for making IPC_M_DATA_READ calls using the async framework. 1419 * 1420 * @param phoneid Phone that will be used to contact the receiving side.1421 * @param dst Address of the beginningof the destination buffer.1422 * @param size Size of the destination buffer.1423 * 1424 * @return Zero on success or a negative error code from errno.h.1560 /** Wrapper for IPC_M_DATA_READ calls using the async framework. 1561 * 1562 * @param phoneid Phone that will be used to contact the receiving side. 1563 * @param dst Address of the beginning of the destination buffer. 1564 * @param size Size of the destination buffer. 1565 * 1566 * @return Zero on success or a negative error code from errno.h. 1567 * 1425 1568 */ 1426 1569 int async_data_read_start(int phoneid, void *dst, size_t size) … … 1432 1575 /** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework. 1433 1576 * 1434 * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ calls 1435 * so that the user doesn't have to remember the meaning of each IPC argument. 1577 * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ 1578 * calls so that the user doesn't have to remember the meaning of each IPC 1579 * argument. 1436 1580 * 1437 1581 * So far, this wrapper is to be used from within a connection fibril. 1438 1582 * 1439 * @param callid Storage where the hash of the IPC_M_DATA_READ call will 1440 * be stored. 1441 * @param size Storage where the maximum size will be stored. Can be 1442 * NULL. 1443 * 1444 * @return Non-zero on success, zero on failure. 1445 */ 1446 int async_data_read_receive(ipc_callid_t *callid, size_t *size) 1447 { 1583 * @param callid Storage for the hash of the IPC_M_DATA_READ. 1584 * @param size Storage for the maximum size. Can be NULL. 1585 * 1586 * @return True on success, false on failure. 1587 * 1588 */ 1589 bool async_data_read_receive(ipc_callid_t *callid, size_t *size) 1590 { 1591 assert(callid); 1592 1448 1593 ipc_call_t data; 1449 1450 assert(callid);1451 1452 1594 *callid = async_get_call(&data); 1595 1453 1596 if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ) 1454 return 0; 1597 return false; 1598 1455 1599 if (size) 1456 1600 *size = (size_t) IPC_GET_ARG2(data); 1457 return 1; 1601 1602 return true; 1458 1603 } 1459 1604 1460 1605 /** Wrapper for answering the IPC_M_DATA_READ calls using the async framework. 1461 1606 * 1462 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls 1463 * so that the user doesn't have to remember the meaning of each IPC argument. 1464 * 1465 * @param callid Hash of the IPC_M_DATA_READ call to answer. 1466 * @param src Source address for the IPC_M_DATA_READ call. 1467 * @param size Size for the IPC_M_DATA_READ call. Can be smaller than 1468 * the maximum size announced by the sender. 1469 * 1470 * @return Zero on success or a value from @ref errno.h on failure. 1607 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ 1608 * calls so that the user doesn't have to remember the meaning of each IPC 1609 * argument. 1610 * 1611 * @param callid Hash of the IPC_M_DATA_READ call to answer. 1612 * @param src Source address for the IPC_M_DATA_READ call. 1613 * @param size Size for the IPC_M_DATA_READ call. Can be smaller than 1614 * the maximum size announced by the sender. 1615 * 1616 * @return Zero on success or a value from @ref errno.h on failure. 1617 * 1471 1618 */ 1472 1619 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size) … … 1476 1623 1477 1624 /** Wrapper for forwarding any read request 1478 *1479 1625 * 1480 1626 */ … … 1509 1655 } 1510 1656 1511 /** Wrapper for makingIPC_M_DATA_WRITE calls using the async framework.1657 /** Wrapper for IPC_M_DATA_WRITE calls using the async framework. 1512 1658 * 1513 1659 * @param phoneid Phone that will be used to contact the receiving side. … … 1526 1672 /** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework. 1527 1673 * 1528 * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE calls 1529 * so that the user doesn't have to remember the meaning of each IPC argument. 1674 * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE 1675 * calls so that the user doesn't have to remember the meaning of each IPC 1676 * argument. 1530 1677 * 1531 1678 * So far, this wrapper is to be used from within a connection fibril. 1532 1679 * 1533 * @param callid Storage where the hash of the IPC_M_DATA_WRITE call will1534 * be stored.1535 * @param size Storage where the suggested size will be stored. May be1536 * NULL1537 * 1538 * @return Non-zero on success, zero on failure.1539 * 1540 */ 1541 int async_data_write_receive(ipc_callid_t *callid, size_t *size) 1542 { 1680 * @param callid Storage for the hash of the IPC_M_DATA_WRITE. 1681 * @param size Storage for the suggested size. May be NULL. 1682 * 1683 * @return True on success, false on failure. 1684 * 1685 */ 1686 bool async_data_write_receive(ipc_callid_t *callid, size_t *size) 1687 { 1688 assert(callid); 1689 1543 1690 ipc_call_t data; 1544 1545 assert(callid);1546 1547 1691 *callid = async_get_call(&data); 1692 1548 1693 if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE) 1549 return 0;1694 return false; 1550 1695 1551 1696 if (size) 1552 1697 *size = (size_t) IPC_GET_ARG2(data); 1553 1698 1554 return 1;1699 return true; 1555 1700 } 1556 1701 1557 1702 /** Wrapper for answering the IPC_M_DATA_WRITE calls using the async framework. 1558 1703 * 1559 * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls 1560 * so that the user doesn't have to remember the meaning of each IPC argument. 1704 * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE 1705 * calls so that the user doesn't have to remember the meaning of each IPC 1706 * argument. 1561 1707 * 1562 1708 * @param callid Hash of the IPC_M_DATA_WRITE call to answer. … … 1654 1800 * 1655 1801 */ 1656 void async_data_write_void( const int retval)1802 void async_data_write_void(sysarg_t retval) 1657 1803 { 1658 1804 ipc_callid_t callid; … … 1662 1808 1663 1809 /** Wrapper for forwarding any data that is about to be received 1664 *1665 1810 * 1666 1811 */
Note:
See TracChangeset
for help on using the changeset viewer.