Changes in uspace/lib/c/generic/async.c [bc216a0:d7978525] in mainline
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/generic/async.c
rbc216a0 rd7978525 114 114 #include <stdlib.h> 115 115 #include <macros.h> 116 116 #include "private/libc.h" 117 118 #define CLIENT_HASH_TABLE_BUCKETS 32 119 #define CONN_HASH_TABLE_BUCKETS 32 117 120 118 121 /** Session data */ … … 202 205 /* Client connection data */ 203 206 typedef struct { 204 ht_link_t link;207 link_t link; 205 208 206 209 task_id_t in_task_id; … … 214 217 215 218 /** Hash table link. */ 216 ht_link_t link;219 link_t link; 217 220 218 221 /** Incoming client task ID. */ … … 390 393 static LIST_INITIALIZE(timeout_list); 391 394 392 static size_t client_key_hash(void *k) 393 { 394 task_id_t key = *(task_id_t*)k; 395 return key; 396 } 397 398 static size_t client_hash(const ht_link_t *item) 399 { 400 client_t *client = hash_table_get_inst(item, client_t, link); 401 return client_key_hash(&client->in_task_id); 402 } 403 404 static bool client_key_equal(void *k, const ht_link_t *item) 405 { 406 task_id_t key = *(task_id_t*)k; 407 client_t *client = hash_table_get_inst(item, client_t, link); 408 return key == client->in_task_id; 409 } 410 395 static hash_index_t client_hash(unsigned long key[]) 396 { 397 assert(key); 398 399 return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS); 400 } 401 402 static int client_compare(unsigned long key[], hash_count_t keys, link_t *item) 403 { 404 assert(key); 405 assert(keys == 2); 406 assert(item); 407 408 client_t *client = hash_table_get_instance(item, client_t, link); 409 return (key[0] == LOWER32(client->in_task_id) && 410 (key[1] == UPPER32(client->in_task_id))); 411 } 412 413 static void client_remove(link_t *item) 414 { 415 } 411 416 412 417 /** Operations for the client hash table. */ 413 static hash_table_op s_t client_hash_table_ops = {418 static hash_table_operations_t client_hash_table_ops = { 414 419 .hash = client_hash, 415 .key_hash = client_key_hash, 416 .key_equal = client_key_equal, 417 .equal = 0, 418 .remove_callback = 0 420 .compare = client_compare, 421 .remove_callback = client_remove 419 422 }; 420 423 … … 426 429 * 427 430 */ 428 static size_t conn_key_hash(void *key) 429 { 430 sysarg_t in_phone_hash = *(sysarg_t*)key; 431 return in_phone_hash ; 432 } 433 434 static size_t conn_hash(const ht_link_t *item) 435 { 436 connection_t *conn = hash_table_get_inst(item, connection_t, link); 437 return conn_key_hash(&conn->in_phone_hash); 438 } 439 440 static bool conn_key_equal(void *key, const ht_link_t *item) 441 { 442 sysarg_t in_phone_hash = *(sysarg_t*)key; 443 connection_t *conn = hash_table_get_inst(item, connection_t, link); 444 return (in_phone_hash == conn->in_phone_hash); 445 } 446 431 static hash_index_t conn_hash(unsigned long key[]) 432 { 433 assert(key); 434 435 return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS); 436 } 437 438 /** Compare hash table item with a key. 439 * 440 * @param key Array containing the source phone hash as the only item. 441 * @param keys Expected 1 but ignored. 442 * @param item Connection hash table item. 443 * 444 * @return True on match, false otherwise. 445 * 446 */ 447 static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item) 448 { 449 assert(key); 450 assert(item); 451 452 connection_t *conn = hash_table_get_instance(item, connection_t, link); 453 return (key[0] == conn->in_phone_hash); 454 } 455 456 static void conn_remove(link_t *item) 457 { 458 } 447 459 448 460 /** Operations for the connection hash table. */ 449 static hash_table_op s_t conn_hash_table_ops = {461 static hash_table_operations_t conn_hash_table_ops = { 450 462 .hash = conn_hash, 451 .key_hash = conn_key_hash, 452 .key_equal = conn_key_equal, 453 .equal = 0, 454 .remove_callback = 0 463 .compare = conn_compare, 464 .remove_callback = conn_remove 455 465 }; 456 466 … … 500 510 futex_down(&async_futex); 501 511 502 ht_link_t *hlp = hash_table_find(&conn_hash_table, &call->in_phone_hash); 512 unsigned long key = call->in_phone_hash; 513 link_t *hlp = hash_table_find(&conn_hash_table, &key); 503 514 504 515 if (!hlp) { … … 507 518 } 508 519 509 connection_t *conn = hash_table_get_inst (hlp, connection_t, link);520 connection_t *conn = hash_table_get_instance(hlp, connection_t, link); 510 521 511 522 msg_t *msg = malloc(sizeof(*msg)); … … 687 698 static client_t *async_client_get(task_id_t client_id, bool create) 688 699 { 700 unsigned long key[2] = { 701 LOWER32(client_id), 702 UPPER32(client_id), 703 }; 689 704 client_t *client = NULL; 690 705 691 706 futex_down(&async_futex); 692 ht_link_t *lnk = hash_table_find(&client_hash_table, &client_id);707 link_t *lnk = hash_table_find(&client_hash_table, key); 693 708 if (lnk) { 694 client = hash_table_get_inst (lnk, client_t, link);709 client = hash_table_get_instance(lnk, client_t, link); 695 710 atomic_inc(&client->refcnt); 696 711 } else if (create) { … … 701 716 702 717 atomic_set(&client->refcnt, 1); 703 hash_table_insert(&client_hash_table, &client->link);718 hash_table_insert(&client_hash_table, key, &client->link); 704 719 } 705 720 } … … 712 727 { 713 728 bool destroy; 714 729 unsigned long key[2] = { 730 LOWER32(client->in_task_id), 731 UPPER32(client->in_task_id) 732 }; 733 715 734 futex_down(&async_futex); 716 735 717 736 if (atomic_predec(&client->refcnt) == 0) { 718 hash_table_remove(&client_hash_table, &client->in_task_id);737 hash_table_remove(&client_hash_table, key, 2); 719 738 destroy = true; 720 739 } else … … 812 831 */ 813 832 futex_down(&async_futex); 814 hash_table_remove(&conn_hash_table, &fibril_connection->in_phone_hash); 833 unsigned long key = fibril_connection->in_phone_hash; 834 hash_table_remove(&conn_hash_table, &key, 1); 815 835 futex_up(&async_futex); 816 836 … … 896 916 897 917 /* Add connection to the connection hash table */ 918 unsigned long key = conn->in_phone_hash; 898 919 899 920 futex_down(&async_futex); 900 hash_table_insert(&conn_hash_table, & conn->link);921 hash_table_insert(&conn_hash_table, &key, &conn->link); 901 922 futex_up(&async_futex); 902 923 … … 1090 1111 void __async_init(void) 1091 1112 { 1092 if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops)) 1113 if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1114 2, &client_hash_table_ops)) 1093 1115 abort(); 1094 1116 1095 if (!hash_table_create(&conn_hash_table, 0, 0, &conn_hash_table_ops)) 1117 if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, 1118 1, &conn_hash_table_ops)) 1096 1119 abort(); 1097 1120 … … 2144 2167 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags) 2145 2168 { 2146 return ipc_share_in_finalize(callid, src, flags); 2169 return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags, 2170 (sysarg_t) __entry); 2147 2171 } 2148 2172 … … 2211 2235 int async_share_out_finalize(ipc_callid_t callid, void **dst) 2212 2236 { 2213 return ipc_ share_out_finalize(callid,dst);2237 return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst); 2214 2238 } 2215 2239 … … 2295 2319 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size) 2296 2320 { 2297 return ipc_ data_read_finalize(callid, src,size);2321 return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size); 2298 2322 } 2299 2323 … … 2398 2422 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size) 2399 2423 { 2400 return ipc_ data_write_finalize(callid, dst,size);2424 return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size); 2401 2425 } 2402 2426
Note:
See TracChangeset
for help on using the changeset viewer.