Changeset d1e196f7 in mainline for uspace/lib/c
- Timestamp:
- 2011-08-21T12:04:27Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 8a6ba94
- Parents:
- 1877128 (diff), a6480d5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- uspace/lib/c
- Files:
-
- 17 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/arch/ia32/Makefile.common
r1877128 rd1e196f7 28 28 29 29 CLANG_ARCH = i386 30 GCC_CFLAGS += -march=pentium -fno-omit-frame-pointer 30 31 ifeq ($(PROCESSOR),i486) 32 GCC_CFLAGS += -march=i486 -fno-omit-frame-pointer 33 else 34 GCC_CFLAGS += -march=pentium -fno-omit-frame-pointer 35 endif 31 36 32 37 ENDIANESS = LE -
uspace/lib/c/arch/ia32/Makefile.inc
r1877128 rd1e196f7 28 28 29 29 ARCH_SOURCES = \ 30 arch/$(UARCH)/src/entry. s\30 arch/$(UARCH)/src/entry.S \ 31 31 arch/$(UARCH)/src/entryjmp.s \ 32 32 arch/$(UARCH)/src/thread_entry.s \ -
uspace/lib/c/arch/ia32/include/ddi.h
r1877128 rd1e196f7 41 41 static inline uint8_t pio_read_8(ioport8_t *port) 42 42 { 43 uint8_t val; 44 45 asm volatile ( 46 "inb %w[port], %b[val]\n" 47 : [val] "=a" (val) 48 : [port] "d" (port) 49 ); 50 51 return val; 43 if (port < (ioport8_t *) IO_SPACE_BOUNDARY) { 44 uint8_t val; 45 46 asm volatile ( 47 "inb %w[port], %b[val]\n" 48 : [val] "=a" (val) 49 : [port] "d" (port) 50 ); 51 52 return val; 53 } else 54 return (uint8_t) *port; 52 55 } 53 56 54 57 static inline uint16_t pio_read_16(ioport16_t *port) 55 58 { 56 uint16_t val; 57 58 asm volatile ( 59 "inw %w[port], %w[val]\n" 60 : [val] "=a" (val) 61 : [port] "d" (port) 62 ); 63 64 return val; 59 if (port < (ioport16_t *) IO_SPACE_BOUNDARY) { 60 uint16_t val; 61 62 asm volatile ( 63 "inw %w[port], %w[val]\n" 64 : [val] "=a" (val) 65 : [port] "d" (port) 66 ); 67 68 return val; 69 } else 70 return (uint16_t) *port; 65 71 } 66 72 67 73 static inline uint32_t pio_read_32(ioport32_t *port) 68 74 { 69 uint32_t val; 70 71 asm volatile ( 72 "inl %w[port], %[val]\n" 73 : [val] "=a" (val) 74 : [port] "d" (port) 75 ); 76 77 return val; 75 if (port < (ioport32_t *) IO_SPACE_BOUNDARY) { 76 uint32_t val; 77 78 asm volatile ( 79 "inl %w[port], %[val]\n" 80 : [val] "=a" (val) 81 : [port] "d" (port) 82 ); 83 84 return val; 85 } else 86 return (uint32_t) *port; 78 87 } 79 88 80 89 static inline void pio_write_8(ioport8_t *port, uint8_t val) 81 90 { 82 asm volatile ( 83 "outb %b[val], %w[port]\n" 84 :: [val] "a" (val), [port] "d" (port) 85 ); 91 if (port < (ioport8_t *) IO_SPACE_BOUNDARY) { 92 asm volatile ( 93 "outb %b[val], %w[port]\n" 94 :: [val] "a" (val), [port] "d" (port) 95 ); 96 } else 97 *port = val; 86 98 } 87 99 88 100 static inline void pio_write_16(ioport16_t *port, uint16_t val) 89 101 { 90 asm volatile ( 91 "outw %w[val], %w[port]\n" 92 :: [val] "a" (val), [port] "d" (port) 93 ); 102 if (port < (ioport16_t *) IO_SPACE_BOUNDARY) { 103 asm volatile ( 104 "outw %w[val], %w[port]\n" 105 :: [val] "a" (val), [port] "d" (port) 106 ); 107 } else 108 *port = val; 94 109 } 95 110 96 111 static inline void pio_write_32(ioport32_t *port, uint32_t val) 97 112 { 98 asm volatile ( 99 "outl %[val], %w[port]\n" 100 :: [val] "a" (val), [port] "d" (port) 101 ); 113 if (port < (ioport32_t *) IO_SPACE_BOUNDARY) { 114 asm volatile ( 115 "outl %[val], %w[port]\n" 116 :: [val] "a" (val), [port] "d" (port) 117 ); 118 } else 119 *port = val; 102 120 } 103 121 -
uspace/lib/c/arch/ia32/src/entry.S
r1877128 rd1e196f7 47 47 # Do not set %gs, it contains descriptor that can see TLS 48 48 49 #ifndef PROCESSOR_i486 49 50 # Detect the mechanism used for making syscalls 50 51 movl $(INTEL_CPUID_STANDARD), %eax … … 52 53 bt $(INTEL_SEP), %edx 53 54 jnc 0f 54 leal __syscall_fast_func, %eax 55 movl $__syscall_fast, (%eax) 56 0: 55 leal __syscall_fast_func, %eax 56 movl $__syscall_fast, (%eax) 57 0: 58 #endif 59 57 60 # 58 61 # Create the first stack frame. -
uspace/lib/c/generic/async.c
r1877128 rd1e196f7 98 98 #include <ipc/ipc.h> 99 99 #include <async.h> 100 #include "private/async.h" 100 101 #undef LIBC_ASYNC_C_ 101 102 … … 112 113 #include <mem.h> 113 114 #include <stdlib.h> 114 #include "private/async.h"115 #include <macros.h> 115 116 116 117 #define CLIENT_HASH_TABLE_BUCKETS 32 … … 138 139 link_t link; 139 140 140 sysarg_t in_task_hash;141 task_id_t in_task_id; 141 142 atomic_t refcnt; 142 143 void *data; … … 150 151 link_t link; 151 152 152 /** Incoming client task hash. */153 sysarg_t in_task_hash;153 /** Incoming client task ID. */ 154 task_id_t in_task_id; 154 155 155 156 /** Incoming phone hash. */ … … 283 284 { 284 285 assert(key); 286 assert(keys == 2); 285 287 assert(item); 286 288 287 289 client_t *client = hash_table_get_instance(item, client_t, link); 288 return (key[0] == client->in_task_hash); 290 return (key[0] == LOWER32(client->in_task_id) && 291 (key[1] == UPPER32(client->in_task_id))); 289 292 } 290 293 … … 574 577 } 575 578 576 static client_t *async_client_get(sysarg_t client_hash, bool create) 577 { 578 unsigned long key = client_hash; 579 static client_t *async_client_get(task_id_t client_id, bool create) 580 { 581 unsigned long key[2] = { 582 LOWER32(client_id), 583 UPPER32(client_id), 584 }; 579 585 client_t *client = NULL; 580 586 581 587 futex_down(&async_futex); 582 link_t *lnk = hash_table_find(&client_hash_table, &key);588 link_t *lnk = hash_table_find(&client_hash_table, key); 583 589 if (lnk) { 584 590 client = hash_table_get_instance(lnk, client_t, link); … … 587 593 client = malloc(sizeof(client_t)); 588 594 if (client) { 589 client->in_task_ hash = client_hash;595 client->in_task_id = client_id; 590 596 client->data = async_client_data_create(); 591 597 592 598 atomic_set(&client->refcnt, 1); 593 hash_table_insert(&client_hash_table, &key, &client->link);599 hash_table_insert(&client_hash_table, key, &client->link); 594 600 } 595 601 } … … 602 608 { 603 609 bool destroy; 604 unsigned long key = client->in_task_hash; 610 unsigned long key[2] = { 611 LOWER32(client->in_task_id), 612 UPPER32(client->in_task_id) 613 }; 605 614 606 615 futex_down(&async_futex); 607 616 608 617 if (atomic_predec(&client->refcnt) == 0) { 609 hash_table_remove(&client_hash_table, &key, 1);618 hash_table_remove(&client_hash_table, key, 2); 610 619 destroy = true; 611 620 } else … … 628 637 } 629 638 630 void *async_get_client_data_by_ hash(sysarg_t client_hash)631 { 632 client_t *client = async_client_get(client_ hash, false);639 void *async_get_client_data_by_id(task_id_t client_id) 640 { 641 client_t *client = async_client_get(client_id, false); 633 642 if (!client) 634 643 return NULL; … … 641 650 } 642 651 643 void async_put_client_data_by_ hash(sysarg_t client_hash)644 { 645 client_t *client = async_client_get(client_ hash, false);652 void async_put_client_data_by_id(task_id_t client_id) 653 { 654 client_t *client = async_client_get(client_id, false); 646 655 647 656 assert(client); … … 680 689 */ 681 690 682 client_t *client = async_client_get(fibril_connection->in_task_ hash, true);691 client_t *client = async_client_get(fibril_connection->in_task_id, true); 683 692 if (!client) { 684 693 ipc_answer_0(fibril_connection->callid, ENOMEM); … … 737 746 * particular fibrils. 738 747 * 739 * @param in_task_ hashIdentification of the incoming connection.748 * @param in_task_id Identification of the incoming connection. 740 749 * @param in_phone_hash Identification of the incoming connection. 741 750 * @param callid Hash of the opening IPC_M_CONNECT_ME_TO call. … … 751 760 * 752 761 */ 753 fid_t async_new_connection( sysarg_t in_task_hash, sysarg_t in_phone_hash,762 fid_t async_new_connection(task_id_t in_task_id, sysarg_t in_phone_hash, 754 763 ipc_callid_t callid, ipc_call_t *call, 755 764 async_client_conn_t cfibril, void *carg) … … 763 772 } 764 773 765 conn->in_task_ hash = in_task_hash;774 conn->in_task_id = in_task_id; 766 775 conn->in_phone_hash = in_phone_hash; 767 776 list_initialize(&conn->msg_queue); … … 822 831 case IPC_M_CONNECT_ME_TO: 823 832 /* Open new connection with fibril, etc. */ 824 async_new_connection(call->in_task_ hash, IPC_GET_ARG5(*call),833 async_new_connection(call->in_task_id, IPC_GET_ARG5(*call), 825 834 callid, call, client_connection, NULL); 826 835 return; … … 970 979 { 971 980 if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 972 1, &client_hash_table_ops))981 2, &client_hash_table_ops)) 973 982 abort(); 974 983 … … 986 995 session_ns->arg2 = 0; 987 996 session_ns->arg3 = 0; 997 998 fibril_mutex_initialize(&session_ns->remote_state_mtx); 999 session_ns->remote_state_data = NULL; 988 1000 989 1001 list_initialize(&session_ns->exch_list); … … 1463 1475 return ENOENT; 1464 1476 1465 sysarg_t task_hash;1466 1477 sysarg_t phone_hash; 1467 int rc = async_req_3_5(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, 1468 NULL, NULL, NULL, &task_hash, &phone_hash); 1478 sysarg_t rc; 1479 1480 aid_t req; 1481 ipc_call_t answer; 1482 req = async_send_3(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, 1483 &answer); 1484 async_wait_for(req, &rc); 1469 1485 if (rc != EOK) 1470 return rc; 1471 1486 return (int) rc; 1487 1488 phone_hash = IPC_GET_ARG5(answer); 1489 1472 1490 if (client_receiver != NULL) 1473 async_new_connection( task_hash, phone_hash, 0, NULL,1491 async_new_connection(answer.in_task_id, phone_hash, 0, NULL, 1474 1492 client_receiver, carg); 1475 1493 … … 1546 1564 sess->arg3 = 0; 1547 1565 1566 fibril_mutex_initialize(&sess->remote_state_mtx); 1567 sess->remote_state_data = NULL; 1568 1548 1569 list_initialize(&sess->exch_list); 1549 1570 fibril_mutex_initialize(&sess->mutex); … … 1627 1648 sess->arg3 = arg3; 1628 1649 1650 fibril_mutex_initialize(&sess->remote_state_mtx); 1651 sess->remote_state_data = NULL; 1652 1629 1653 list_initialize(&sess->exch_list); 1630 1654 fibril_mutex_initialize(&sess->mutex); … … 1632 1656 1633 1657 return sess; 1658 } 1659 1660 /** Set arguments for new connections. 1661 * 1662 * FIXME This is an ugly hack to work around the problem that parallel 1663 * exchanges are implemented using parallel connections. When we create 1664 * a callback session, the framework does not know arguments for the new 1665 * connections. 1666 * 1667 * The proper solution seems to be to implement parallel exchanges using 1668 * tagging. 1669 */ 1670 void async_sess_args_set(async_sess_t *sess, sysarg_t arg1, sysarg_t arg2, 1671 sysarg_t arg3) 1672 { 1673 sess->arg1 = arg1; 1674 sess->arg2 = arg2; 1675 sess->arg3 = arg3; 1634 1676 } 1635 1677 … … 1677 1719 sess->arg3 = arg3; 1678 1720 1721 fibril_mutex_initialize(&sess->remote_state_mtx); 1722 sess->remote_state_data = NULL; 1723 1679 1724 list_initialize(&sess->exch_list); 1680 1725 fibril_mutex_initialize(&sess->mutex); … … 1707 1752 sess->arg2 = 0; 1708 1753 sess->arg3 = 0; 1754 1755 fibril_mutex_initialize(&sess->remote_state_mtx); 1756 sess->remote_state_data = NULL; 1709 1757 1710 1758 list_initialize(&sess->exch_list); … … 2371 2419 sess->arg3 = 0; 2372 2420 2421 fibril_mutex_initialize(&sess->remote_state_mtx); 2422 sess->remote_state_data = NULL; 2423 2373 2424 list_initialize(&sess->exch_list); 2374 2425 fibril_mutex_initialize(&sess->mutex); … … 2417 2468 sess->arg3 = 0; 2418 2469 2470 fibril_mutex_initialize(&sess->remote_state_mtx); 2471 sess->remote_state_data = NULL; 2472 2419 2473 list_initialize(&sess->exch_list); 2420 2474 fibril_mutex_initialize(&sess->mutex); … … 2458 2512 sess->arg2 = 0; 2459 2513 sess->arg3 = 0; 2514 2515 fibril_mutex_initialize(&sess->remote_state_mtx); 2516 sess->remote_state_data = NULL; 2460 2517 2461 2518 list_initialize(&sess->exch_list); … … 2499 2556 } 2500 2557 2558 /** Lock and get session remote state 2559 * 2560 * Lock and get the local replica of the remote state 2561 * in stateful sessions. The call should be paired 2562 * with async_remote_state_release*(). 2563 * 2564 * @param[in] sess Stateful session. 2565 * 2566 * @return Local replica of the remote state. 2567 * 2568 */ 2569 void *async_remote_state_acquire(async_sess_t *sess) 2570 { 2571 fibril_mutex_lock(&sess->remote_state_mtx); 2572 return sess->remote_state_data; 2573 } 2574 2575 /** Update the session remote state 2576 * 2577 * Update the local replica of the remote state 2578 * in stateful sessions. The remote state must 2579 * be already locked. 2580 * 2581 * @param[in] sess Stateful session. 2582 * @param[in] state New local replica of the remote state. 2583 * 2584 */ 2585 void async_remote_state_update(async_sess_t *sess, void *state) 2586 { 2587 assert(fibril_mutex_is_locked(&sess->remote_state_mtx)); 2588 sess->remote_state_data = state; 2589 } 2590 2591 /** Release the session remote state 2592 * 2593 * Unlock the local replica of the remote state 2594 * in stateful sessions. 2595 * 2596 * @param[in] sess Stateful session. 2597 * 2598 */ 2599 void async_remote_state_release(async_sess_t *sess) 2600 { 2601 assert(fibril_mutex_is_locked(&sess->remote_state_mtx)); 2602 2603 fibril_mutex_unlock(&sess->remote_state_mtx); 2604 } 2605 2606 /** Release the session remote state and end an exchange 2607 * 2608 * Unlock the local replica of the remote state 2609 * in stateful sessions. This is convenience function 2610 * which gets the session pointer from the exchange 2611 * and also ends the exchange. 2612 * 2613 * @param[in] exch Stateful session's exchange. 2614 * 2615 */ 2616 void async_remote_state_release_exchange(async_exch_t *exch) 2617 { 2618 if (exch == NULL) 2619 return; 2620 2621 async_sess_t *sess = exch->sess; 2622 assert(fibril_mutex_is_locked(&sess->remote_state_mtx)); 2623 2624 async_exchange_end(exch); 2625 fibril_mutex_unlock(&sess->remote_state_mtx); 2626 } 2627 2501 2628 /** @} 2502 2629 */ -
uspace/lib/c/generic/async_obsolete.c
r1877128 rd1e196f7 38 38 #include <async.h> 39 39 #include <async_obsolete.h> 40 #include "private/async.h" 40 41 #undef LIBC_ASYNC_C_ 41 42 #undef LIBC_ASYNC_OBSOLETE_C_ … … 44 45 #include <malloc.h> 45 46 #include <errno.h> 46 #include "private/async.h"47 47 48 48 /** Send message and return id of the sent message. -
uspace/lib/c/generic/devman.c
r1877128 rd1e196f7 1 1 /* 2 2 * Copyright (c) 2007 Josef Cejka 3 * Copyright (c) 20 09Jiri Svoboda3 * Copyright (c) 2011 Jiri Svoboda 4 4 * Copyright (c) 2010 Lenka Trochtova 5 5 * All rights reserved. … … 89 89 if (devman_driver_block_sess == NULL) 90 90 devman_driver_block_sess = 91 service_connect_blocking(EXCHANGE_ SERIALIZE,91 service_connect_blocking(EXCHANGE_PARALLEL, 92 92 SERVICE_DEVMAN, DEVMAN_DRIVER, 0); 93 93 } … … 138 138 if (devman_driver_sess == NULL) 139 139 devman_driver_sess = 140 service_connect(EXCHANGE_ SERIALIZE, SERVICE_DEVMAN,140 service_connect(EXCHANGE_PARALLEL, SERVICE_DEVMAN, 141 141 DEVMAN_DRIVER, 0); 142 142 … … 195 195 196 196 exch = devman_exchange_begin(DEVMAN_DRIVER); 197 async_connect_to_me(exch, 0, 0, 0, NULL, NULL);197 async_connect_to_me(exch, 0, 0, 0, conn, NULL); 198 198 devman_exchange_end(exch); 199 199 … … 342 342 } 343 343 344 int devman_ device_get_handle(const char *pathname, devman_handle_t *handle,344 int devman_fun_get_handle(const char *pathname, devman_handle_t *handle, 345 345 unsigned int flags) 346 346 { … … 383 383 } 384 384 385 int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size) 385 static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf, 386 size_t buf_size) 387 { 388 async_exch_t *exch; 389 ipc_call_t dreply; 390 size_t act_size; 391 sysarg_t dretval; 392 393 exch = devman_exchange_begin_blocking(LOC_PORT_CONSUMER); 394 395 ipc_call_t answer; 396 aid_t req = async_send_1(exch, method, arg1, &answer); 397 aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply); 398 async_wait_for(dreq, &dretval); 399 400 devman_exchange_end(exch); 401 402 if (dretval != EOK) { 403 async_wait_for(req, NULL); 404 return dretval; 405 } 406 407 sysarg_t retval; 408 async_wait_for(req, &retval); 409 410 if (retval != EOK) 411 return retval; 412 413 act_size = IPC_GET_ARG2(dreply); 414 assert(act_size <= buf_size - 1); 415 buf[act_size] = '\0'; 416 417 return EOK; 418 } 419 420 int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size) 421 { 422 return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf, 423 buf_size); 424 } 425 426 int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size) 427 { 428 return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf, 429 buf_size); 430 } 431 432 static int devman_get_handles_once(sysarg_t method, sysarg_t arg1, 433 devman_handle_t *handle_buf, size_t buf_size, size_t *act_size) 434 { 435 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_CLIENT); 436 437 ipc_call_t answer; 438 aid_t req = async_send_1(exch, method, arg1, &answer); 439 int rc = async_data_read_start(exch, handle_buf, buf_size); 440 441 devman_exchange_end(exch); 442 443 if (rc != EOK) { 444 async_wait_for(req, NULL); 445 return rc; 446 } 447 448 sysarg_t retval; 449 async_wait_for(req, &retval); 450 451 if (retval != EOK) { 452 return retval; 453 } 454 455 *act_size = IPC_GET_ARG1(answer); 456 return EOK; 457 } 458 459 /** Get list of handles. 460 * 461 * Returns an allocated array of handles. 462 * 463 * @param method IPC method 464 * @param arg1 IPC argument 1 465 * @param data Place to store pointer to array of handles 466 * @param count Place to store number of handles 467 * @return EOK on success or negative error code 468 */ 469 static int devman_get_handles_internal(sysarg_t method, sysarg_t arg1, 470 devman_handle_t **data, size_t *count) 471 { 472 devman_handle_t *handles; 473 size_t act_size; 474 size_t alloc_size; 475 int rc; 476 477 *data = NULL; 478 act_size = 0; /* silence warning */ 479 480 rc = devman_get_handles_once(method, arg1, NULL, 0, 481 &act_size); 482 if (rc != EOK) 483 return rc; 484 485 alloc_size = act_size; 486 handles = malloc(alloc_size); 487 if (handles == NULL) 488 return ENOMEM; 489 490 while (true) { 491 rc = devman_get_handles_once(method, arg1, handles, alloc_size, 492 &act_size); 493 if (rc != EOK) 494 return rc; 495 496 if (act_size <= alloc_size) 497 break; 498 499 alloc_size *= 2; 500 free(handles); 501 502 handles = malloc(alloc_size); 503 if (handles == NULL) 504 return ENOMEM; 505 } 506 507 *count = act_size / sizeof(devman_handle_t); 508 *data = handles; 509 return EOK; 510 } 511 512 int devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh) 386 513 { 387 514 async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT); … … 389 516 return ENOMEM; 390 517 391 ipc_call_t answer; 392 aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_DEVICE_PATH, 393 handle, &answer); 394 395 ipc_call_t data_request_call; 396 aid_t data_request = async_data_read(exch, path, path_size, 397 &data_request_call); 398 399 devman_exchange_end(exch); 400 401 if (data_request == 0) { 402 async_wait_for(req, NULL); 403 return ENOMEM; 404 } 405 406 sysarg_t data_request_rc; 407 async_wait_for(data_request, &data_request_rc); 408 409 sysarg_t opening_request_rc; 410 async_wait_for(req, &opening_request_rc); 411 412 if (data_request_rc != EOK) { 413 /* Prefer the return code of the opening request. */ 414 if (opening_request_rc != EOK) 415 return (int) opening_request_rc; 416 else 417 return (int) data_request_rc; 418 } 419 420 if (opening_request_rc != EOK) 421 return (int) opening_request_rc; 422 423 /* To be on the safe-side. */ 424 path[path_size - 1] = 0; 425 size_t transferred_size = IPC_GET_ARG2(data_request_call); 426 if (transferred_size >= path_size) 427 return ELIMIT; 428 429 /* Terminate the string (trailing 0 not send over IPC). */ 430 path[transferred_size] = 0; 431 return EOK; 518 sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD, 519 funh, devh); 520 521 devman_exchange_end(exch); 522 return (int) retval; 523 } 524 525 int devman_dev_get_functions(devman_handle_t devh, devman_handle_t **funcs, 526 size_t *count) 527 { 528 return devman_get_handles_internal(DEVMAN_DEV_GET_FUNCTIONS, 529 devh, funcs, count); 432 530 } 433 531 -
uspace/lib/c/generic/io/printf_core.c
r1877128 rd1e196f7 206 206 } 207 207 208 return (int) (counter + 1);208 return (int) (counter); 209 209 } 210 210 … … 244 244 } 245 245 246 return (int) (counter + 1);246 return (int) (counter); 247 247 } 248 248 -
uspace/lib/c/generic/ipc.c
r1877128 rd1e196f7 47 47 #include <futex.h> 48 48 #include <fibril.h> 49 #include <macros.h> 49 50 50 51 /** … … 611 612 /** Request callback connection. 612 613 * 613 * The @a task hashand @a phonehash identifiers returned614 * The @a task_id and @a phonehash identifiers returned 614 615 * by the kernel can be used for connection tracking. 615 616 * … … 618 619 * @param arg2 User defined argument. 619 620 * @param arg3 User defined argument. 620 * @param task hash Opaque identifier of the client task.621 * @param task_id Identifier of the client task. 621 622 * @param phonehash Opaque identifier of the phone that will 622 623 * be used for incoming calls. … … 626 627 */ 627 628 int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, 628 sysarg_t *taskhash, sysarg_t *phonehash) 629 { 630 return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2, 631 arg3, NULL, NULL, NULL, taskhash, phonehash); 629 task_id_t *task_id, sysarg_t *phonehash) 630 { 631 ipc_call_t data; 632 int rc = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, 633 IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, (sysarg_t) &data); 634 if (rc == EOK) { 635 *task_id = data.in_task_id; 636 *phonehash = IPC_GET_ARG5(data); 637 } 638 return rc; 632 639 } 633 640 -
uspace/lib/c/generic/loader.c
r1877128 rd1e196f7 263 263 264 264 int i; 265 for (i = 0; files[i]; i++) 266 ; 265 for (i = 0; files[i]; i++); 267 266 268 267 ipc_call_t answer; -
uspace/lib/c/generic/loc.c
r1877128 rd1e196f7 315 315 /** Register new service. 316 316 * 317 * @param fqsn 318 * @param sid 317 * @param fqsn Fully qualified service name 318 * @param sid Output: ID of new service 319 319 * 320 320 */ -
uspace/lib/c/generic/ns.c
r1877128 rd1e196f7 56 56 async_exchange_end(exch); 57 57 58 /* 59 * FIXME Ugly hack to work around limitation of implementing 60 * parallel exchanges using multiple connections. Shift out 61 * first argument for non-initial connections. 62 */ 63 async_sess_args_set(sess, arg2, arg3, 0); 64 58 65 return sess; 59 66 } … … 66 73 async_connect_me_to_blocking(mgmt, exch, service, arg2, arg3); 67 74 async_exchange_end(exch); 75 76 /* 77 * FIXME Ugly hack to work around limitation of implementing 78 * parallel exchanges using multiple connections. Shift out 79 * first argument for non-initial connections. 80 */ 81 async_sess_args_set(sess, arg2, arg3, 0); 68 82 69 83 return sess; -
uspace/lib/c/generic/private/async.h
r1877128 rd1e196f7 36 36 #define LIBC_PRIVATE_ASYNC_H_ 37 37 38 #include < ipc/common.h>38 #include <async.h> 39 39 #include <adt/list.h> 40 40 #include <fibril.h> 41 #include <fibril_synch.h> 41 42 #include <sys/time.h> 42 43 #include <bool.h> 44 45 /** Session data */ 46 struct _async_sess { 47 /** List of inactive exchanges */ 48 list_t exch_list; 49 50 /** Exchange management style */ 51 exch_mgmt_t mgmt; 52 53 /** Session identification */ 54 int phone; 55 56 /** First clone connection argument */ 57 sysarg_t arg1; 58 59 /** Second clone connection argument */ 60 sysarg_t arg2; 61 62 /** Third clone connection argument */ 63 sysarg_t arg3; 64 65 /** Exchange mutex */ 66 fibril_mutex_t mutex; 67 68 /** Number of opened exchanges */ 69 atomic_t refcnt; 70 71 /** Mutex for stateful connections */ 72 fibril_mutex_t remote_state_mtx; 73 74 /** Data for stateful connections */ 75 void *remote_state_data; 76 }; 77 78 /** Exchange data */ 79 struct _async_exch { 80 /** Link into list of inactive exchanges */ 81 link_t sess_link; 82 83 /** Link into global list of inactive exchanges */ 84 link_t global_link; 85 86 /** Session pointer */ 87 async_sess_t *sess; 88 89 /** Exchange identification */ 90 int phone; 91 }; 43 92 44 93 /** Structures of this type are used to track the timeout events. */ -
uspace/lib/c/include/async.h
r1877128 rd1e196f7 42 42 #include <ipc/common.h> 43 43 #include <fibril.h> 44 #include <fibril_synch.h>45 44 #include <sys/time.h> 46 45 #include <atomic.h> … … 96 95 } exch_mgmt_t; 97 96 98 /** Session data */ 99 typedef struct { 100 /** List of inactive exchanges */ 101 list_t exch_list; 102 103 /** Exchange management style */ 104 exch_mgmt_t mgmt; 105 106 /** Session identification */ 107 int phone; 108 109 /** First clone connection argument */ 110 sysarg_t arg1; 111 112 /** Second clone connection argument */ 113 sysarg_t arg2; 114 115 /** Third clone connection argument */ 116 sysarg_t arg3; 117 118 /** Exchange mutex */ 119 fibril_mutex_t mutex; 120 121 /** Number of opened exchanges */ 122 atomic_t refcnt; 123 } async_sess_t; 124 125 /** Exchange data */ 126 typedef struct { 127 /** Link into list of inactive exchanges */ 128 link_t sess_link; 129 130 /** Link into global list of inactive exchanges */ 131 link_t global_link; 132 133 /** Session pointer */ 134 async_sess_t *sess; 135 136 /** Exchange identification */ 137 int phone; 138 } async_exch_t; 97 /** Forward declarations */ 98 struct _async_exch; 99 struct _async_sess; 100 101 typedef struct _async_sess async_sess_t; 102 typedef struct _async_exch async_exch_t; 139 103 140 104 extern atomic_t threads_in_ipc_wait; … … 176 140 extern int async_wait_timeout(aid_t, sysarg_t *, suseconds_t); 177 141 178 extern fid_t async_new_connection( sysarg_t, sysarg_t, ipc_callid_t,142 extern fid_t async_new_connection(task_id_t, sysarg_t, ipc_callid_t, 179 143 ipc_call_t *, async_client_conn_t, void *); 180 144 … … 186 150 extern void async_set_client_data_destructor(async_client_data_dtor_t); 187 151 extern void *async_get_client_data(void); 188 extern void *async_get_client_data_by_ hash(sysarg_t);189 extern void async_put_client_data_by_ hash(sysarg_t);152 extern void *async_get_client_data_by_id(task_id_t); 153 extern void async_put_client_data_by_id(task_id_t); 190 154 191 155 extern void async_set_client_connection(async_client_conn_t); … … 373 337 374 338 /* 339 * FIXME These functions just work around problems with parallel exchange 340 * management. Proper solution needs to be implemented. 341 */ 342 void async_sess_args_set(async_sess_t *sess, sysarg_t, sysarg_t, sysarg_t); 343 344 /* 375 345 * User-friendly wrappers for async_share_in_start(). 376 346 */ … … 485 455 extern int async_state_change_finalize(ipc_callid_t, async_exch_t *); 486 456 457 extern void *async_remote_state_acquire(async_sess_t *); 458 extern void async_remote_state_update(async_sess_t *, void *); 459 extern void async_remote_state_release(async_sess_t *); 460 extern void async_remote_state_release_exchange(async_exch_t *); 461 487 462 #endif 488 463 -
uspace/lib/c/include/devman.h
r1877128 rd1e196f7 56 56 unsigned int); 57 57 58 extern int devman_ device_get_handle(const char *, devman_handle_t *,58 extern int devman_fun_get_handle(const char *, devman_handle_t *, 59 59 unsigned int); 60 extern int devman_get_device_path(devman_handle_t, char *, size_t); 60 extern int devman_fun_get_child(devman_handle_t, devman_handle_t *); 61 extern int devman_dev_get_functions(devman_handle_t, devman_handle_t **, 62 size_t *); 63 extern int devman_fun_get_name(devman_handle_t, char *, size_t); 64 extern int devman_fun_get_path(devman_handle_t, char *, size_t); 61 65 62 66 extern int devman_add_device_to_category(devman_handle_t, const char *); -
uspace/lib/c/include/ipc/common.h
r1877128 rd1e196f7 39 39 #include <abi/ipc/ipc.h> 40 40 #include <atomic.h> 41 #include <task.h> 41 42 42 43 #define IPC_FLAG_BLOCKING 0x01 … … 44 45 typedef struct { 45 46 sysarg_t args[IPC_CALL_LEN]; 46 sysarg_t in_task_hash;47 task_id_t in_task_id; 47 48 sysarg_t in_phone_hash; 48 49 } ipc_call_t; -
uspace/lib/c/include/ipc/devman.h
r1877128 rd1e196f7 149 149 typedef enum { 150 150 DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD, 151 DEVMAN_DEVICE_GET_DEVICE_PATH, 151 DEVMAN_DEV_GET_FUNCTIONS, 152 DEVMAN_FUN_GET_CHILD, 153 DEVMAN_FUN_GET_NAME, 154 DEVMAN_FUN_GET_PATH, 152 155 DEVMAN_FUN_SID_TO_HANDLE 153 156 } client_to_devman_t; -
uspace/lib/c/include/ipc/ipc.h
r1877128 rd1e196f7 254 254 sysarg_t, sysarg_t, void *, ipc_async_callback_t, bool); 255 255 256 extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t *,256 extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, task_id_t *, 257 257 sysarg_t *); 258 258 extern int ipc_connect_me(int);
Note:
See TracChangeset
for help on using the changeset viewer.