Index: uspace/lib/block/libblock.c =================================================================== --- uspace/lib/block/libblock.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/block/libblock.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -44,5 +44,4 @@ #include #include -#include #include #include @@ -177,5 +176,5 @@ if (rc != EOK) { munmap(comm_area, comm_size); - ipc_hangup(dev_phone); + async_hangup(dev_phone); return rc; } @@ -183,5 +182,5 @@ if (get_block_size(dev_phone, &bsize) != EOK) { munmap(comm_area, comm_size); - ipc_hangup(dev_phone); + async_hangup(dev_phone); return rc; } @@ -190,5 +189,5 @@ if (rc != EOK) { munmap(comm_area, comm_size); - ipc_hangup(dev_phone); + async_hangup(dev_phone); return rc; } @@ -211,5 +210,5 @@ munmap(devcon->comm_area, devcon->comm_size); - ipc_hangup(devcon->dev_phone); + async_hangup(devcon->dev_phone); free(devcon); @@ -295,6 +294,8 @@ /* Allow 1:1 or small-to-large block size translation */ - if (cache->lblock_size % devcon->pblock_size != 0) + if (cache->lblock_size % devcon->pblock_size != 0) { + free(cache); return ENOTSUP; + } cache->blocks_cluster = cache->lblock_size / devcon->pblock_size; @@ -437,4 +438,5 @@ if (!b->data) { free(b); + b = NULL; goto recycle; } @@ -564,4 +566,5 @@ assert(devcon); assert(devcon->cache); + assert(block->refcnt >= 1); cache = devcon->cache; @@ -623,6 +626,6 @@ unsigned long key = block->lba; hash_table_remove(&cache->block_hash, &key, 1); + free(block->data); free(block); - free(block->data); cache->blocks_cached--; fibril_mutex_unlock(&cache->lock); Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/Makefile (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -83,4 +83,5 @@ generic/io/console.c \ generic/io/screenbuffer.c \ + generic/ipc/ns.c \ generic/malloc.c \ generic/sysinfo.c \ @@ -96,5 +97,4 @@ generic/adt/char_map.c \ generic/time.c \ - generic/err.c \ generic/stdlib.c \ generic/mman.c \ Index: uspace/lib/c/arch/abs32le/_link.ld.in =================================================================== --- uspace/lib/c/arch/abs32le/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/abs32le/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -44,8 +44,4 @@ } :data - . = ALIGN(0x1000); - - _heap = .; - /DISCARD/ : { *(*); Index: uspace/lib/c/arch/abs32le/src/entry.c =================================================================== --- uspace/lib/c/arch/abs32le/src/entry.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/abs32le/src/entry.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -30,12 +30,11 @@ */ -#include #include #include +#include "../../../generic/private/libc.h" void __entry(void) { __main(NULL); - __exit(); } Index: uspace/lib/c/arch/abs32le/src/thread_entry.c =================================================================== --- uspace/lib/c/arch/abs32le/src/thread_entry.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/abs32le/src/thread_entry.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -31,5 +31,5 @@ #include -#include +#include "../../../generic/private/thread.h" void __thread_entry(void) Index: uspace/lib/c/arch/amd64/_link.ld.in =================================================================== --- uspace/lib/c/arch/amd64/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/amd64/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -5,4 +5,5 @@ text PT_LOAD FLAGS(5); data PT_LOAD FLAGS(6); + debug PT_NOTE; } @@ -13,14 +14,16 @@ *(.init); } :text + .text : { *(.text); *(.rodata*); } :text - + . = . + 0x1000; - + .data : { *(.data); } :data + .tdata : { _tdata_start = .; @@ -31,16 +34,27 @@ _tbss_end = .; } :data + _tls_alignment = ALIGNOF(.tdata); + .bss : { *(COMMON); *(.bss); } :data - - . = ALIGN(0x1000); - _heap = .; + +#ifdef CONFIG_LINE_DEBUG + .comment 0 : { *(.comment); } :debug + .debug_abbrev 0 : { *(.debug_abbrev); } :debug + .debug_aranges 0 : { *(.debug_aranges); } :debug + .debug_info 0 : { *(.debug_info); } :debug + .debug_line 0 : { *(.debug_line); } :debug + .debug_loc 0 : { *(.debug_loc); } :debug + .debug_pubnames 0 : { *(.debug_pubnames); } :debug + .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug + .debug_ranges 0 : { *(.debug_ranges); } :debug + .debug_str 0 : { *(.debug_str); } :debug +#endif /DISCARD/ : { *(*); } - } Index: uspace/lib/c/arch/amd64/src/entry.s =================================================================== --- uspace/lib/c/arch/amd64/src/entry.s (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/amd64/src/entry.s (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -47,4 +47,2 @@ # Pass PCB pointer to __main (no operation) call __main - - call __exit Index: uspace/lib/c/arch/arm32/_link.ld.in =================================================================== --- uspace/lib/c/arch/arm32/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/arm32/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -9,15 +9,16 @@ SECTIONS { . = 0x1000 + SIZEOF_HEADERS; - + .init : { *(.init); - } : text + } :text + .text : { *(.text); - *(.rodata*); + *(.rodata*); } :text - + . = . + 0x1000; - + .data : { *(.opd); @@ -25,4 +26,5 @@ *(.sdata); } :data + .tdata : { _tdata_start = .; @@ -33,18 +35,16 @@ _tbss_end = .; } :data + _tls_alignment = ALIGNOF(.tdata); + .bss : { *(.sbss); *(.scommon); - *(COMMON); - *(.bss); + *(COMMON); + *(.bss); } :data - - . = ALIGN(0x1000); - _heap = .; /DISCARD/ : { *(*); } - } Index: uspace/lib/c/arch/arm32/src/entry.s =================================================================== --- uspace/lib/c/arch/arm32/src/entry.s (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/arm32/src/entry.s (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -42,5 +42,5 @@ ldr r0, =ras_page str r2, [r0] - + # # Create the first stack frame. @@ -50,10 +50,8 @@ push {fp, ip, lr, pc} sub fp, ip, #4 - + # Pass pcb_ptr to __main as the first argument (in r0) mov r0, r1 bl __main - - bl __exit .data @@ -62,3 +60,2 @@ ras_page: .long 0 - Index: uspace/lib/c/arch/ia32/_link.ld.in =================================================================== --- uspace/lib/c/arch/ia32/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/ia32/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -5,4 +5,5 @@ text PT_LOAD FLAGS(5); data PT_LOAD FLAGS(6); + debug PT_NOTE; } @@ -42,7 +43,16 @@ } :data - . = ALIGN(0x1000); - - _heap = .; +#ifdef CONFIG_LINE_DEBUG + .comment 0 : { *(.comment); } :debug + .debug_abbrev 0 : { *(.debug_abbrev); } :debug + .debug_aranges 0 : { *(.debug_aranges); } :debug + .debug_info 0 : { *(.debug_info); } :debug + .debug_line 0 : { *(.debug_line); } :debug + .debug_loc 0 : { *(.debug_loc); } :debug + .debug_pubnames 0 : { *(.debug_pubnames); } :debug + .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug + .debug_ranges 0 : { *(.debug_ranges); } :debug + .debug_str 0 : { *(.debug_str); } :debug +#endif /DISCARD/ : { Index: uspace/lib/c/arch/ia32/src/entry.s =================================================================== --- uspace/lib/c/arch/ia32/src/entry.s (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/ia32/src/entry.s (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -46,5 +46,5 @@ mov %ax, %fs # Do not set %gs, it contains descriptor that can see TLS - + # Detect the mechanism used for making syscalls movl $(INTEL_CPUID_STANDARD), %eax @@ -58,10 +58,8 @@ # Create the first stack frame. # - pushl $0 + pushl $0 movl %esp, %ebp - + # Pass the PCB pointer to __main as the first argument pushl %edi call __main - - call __exit Index: uspace/lib/c/arch/ia64/_link.ld.in =================================================================== --- uspace/lib/c/arch/ia64/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/ia64/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -9,19 +9,21 @@ SECTIONS { . = 0x4000 + SIZEOF_HEADERS; - + .init : { *(.init); - } : text + } :text + .text : { *(.text); *(.rodata*); } :text - + . = . + 0x4000; - + .got : { _gp = .; *(.got*); - } :data + } :data + .data : { *(.opd); @@ -29,4 +31,5 @@ *(.sdata); } :data + .tdata : { _tdata_start = .; @@ -37,5 +40,7 @@ _tbss_end = .; } :data + _tls_alignment = ALIGNOF(.tdata); + .bss : { *(.sbss); @@ -44,10 +49,7 @@ *(.bss); } :data - - . = ALIGN(0x4000); - _heap = .; - + /DISCARD/ : { *(*); - } + } } Index: uspace/lib/c/arch/ia64/src/entry.s =================================================================== --- uspace/lib/c/arch/ia64/src/entry.s (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/ia64/src/entry.s (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -40,8 +40,6 @@ alloc loc0 = ar.pfs, 0, 1, 2, 0 movl gp = _gp - + # Pass PCB pointer as the first argument to __main mov out0 = r2 br.call.sptk.many b0 = __main -0: - br.call.sptk.many b0 = __exit Index: uspace/lib/c/arch/mips32/_link.ld.in =================================================================== --- uspace/lib/c/arch/mips32/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/mips32/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -13,43 +13,46 @@ *(.init); } :text + .text : { - *(.text); + *(.text); *(.rodata*); } :text - + . = . + 0x4000; - + .data : { *(.data); *(.data.rel*); } :data - + .got : { _gp = .; *(.got); } :data - + .tdata : { _tdata_start = .; *(.tdata); _tdata_end = .; + } :data + + .tbss : { _tbss_start = .; *(.tbss); _tbss_end = .; } :data - _tls_alignment = ALIGNOF(.tdata); - + + _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss)); + .sbss : { *(.scommon); *(.sbss); - } + } + .bss : { *(.bss); *(COMMON); } :data - - . = ALIGN(0x4000); - _heap = .; - + /DISCARD/ : { *(*); Index: uspace/lib/c/arch/mips32/src/entry.s =================================================================== --- uspace/lib/c/arch/mips32/src/entry.s (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/mips32/src/entry.s (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -29,6 +29,7 @@ .text .section .init, "ax" + .global __entry -.global __entry_driver + .set noreorder .option pic2 @@ -56,10 +57,3 @@ jal __main nop - - jal __exit - nop .end - -# Alignment of output section data to 0x4000 -.section .data -.align 14 Index: uspace/lib/c/arch/ppc32/_link.ld.in =================================================================== --- uspace/lib/c/arch/ppc32/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/ppc32/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -9,19 +9,21 @@ SECTIONS { . = 0x1000 + SIZEOF_HEADERS; - + .init : { *(.init); } :text + .text : { *(.text); *(.rodata*); } :text - + . = . + 0x1000; - + .data : { *(.data); *(.sdata); } :data + .tdata : { _tdata_start = .; @@ -32,5 +34,7 @@ _tbss_end = .; } :data + _tls_alignment = ALIGNOF(.tdata); + .bss : { *(.sbss); @@ -38,11 +42,7 @@ *(.bss); } :data - - . = ALIGN(0x1000); - _heap = .; /DISCARD/ : { *(*); } - } Index: uspace/lib/c/arch/ppc32/src/entry.s =================================================================== --- uspace/lib/c/arch/ppc32/src/entry.s (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/ppc32/src/entry.s (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -44,9 +44,7 @@ stw %r3, 0(%r1) stwu %r1, -16(%r1) - + # Pass the PCB pointer to __main() as the first argument. # The first argument is passed in r3. mr %r3, %r6 bl __main - - bl __exit Index: uspace/lib/c/arch/sparc64/_link.ld.in =================================================================== --- uspace/lib/c/arch/sparc64/_link.ld.in (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/sparc64/_link.ld.in (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -9,23 +9,26 @@ SECTIONS { . = 0x4000 + SIZEOF_HEADERS; - + .init : { *(.init); } :text + .text : { *(.text); *(.rodata*); } :text - + . = . + 0x4000; - + .got : { _gp = .; *(.got*); } :data + .data : { *(.data); *(.sdata); } :data + .tdata : { _tdata_start = .; @@ -36,5 +39,7 @@ _tbss_end = .; } :data + _tls_alignment = ALIGNOF(.tdata); + .bss : { *(.sbss); @@ -42,11 +47,7 @@ *(.bss); } :data - - . = ALIGN(0x4000); - _heap = .; /DISCARD/ : { *(*); } - } Index: uspace/lib/c/arch/sparc64/src/entry.s =================================================================== --- uspace/lib/c/arch/sparc64/src/entry.s (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/arch/sparc64/src/entry.s (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -45,5 +45,5 @@ flushw add %g0, -0x7ff, %fp - + # Pass pcb_ptr as the first argument to __main() mov %i1, %o0 @@ -51,5 +51,2 @@ call __main or %l7, %lo(_gp), %l7 - - call __exit - nop Index: uspace/lib/c/generic/as.c =================================================================== --- uspace/lib/c/generic/as.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/as.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,7 +41,5 @@ #include #include - -/** Last position allocated by as_get_mappable_page */ -static uintptr_t last_allocated = 0; +#include "private/libc.h" /** Create address space area. @@ -104,27 +102,15 @@ } -/** Return pointer to some unmapped area, where fits new as_area +/** Return pointer to unmapped address space area * * @param size Requested size of the allocation. * - * @return pointer to the beginning + * @return Pointer to the beginning of unmapped address space area. * */ void *as_get_mappable_page(size_t size) { - if (size == 0) - return NULL; - - size_t sz = 1 << (fnzb(size - 1) + 1); - if (last_allocated == 0) - last_allocated = get_max_heap_addr(); - - /* - * Make sure we allocate from naturally aligned address. - */ - uintptr_t res = ALIGN_UP(last_allocated, sz); - last_allocated = res + ALIGN_UP(size, PAGE_SIZE); - - return ((void *) res); + return (void *) __SYSCALL2(SYS_AS_GET_UNMAPPED_AREA, + (sysarg_t) __entry, (sysarg_t) size); } Index: uspace/lib/c/generic/async.c =================================================================== --- uspace/lib/c/generic/async.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/async.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -43,9 +43,4 @@ * 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): * @@ -58,5 +53,5 @@ * int fibril1(void *arg) * { - * conn = ipc_connect_me_to(); + * conn = async_connect_me_to(); * c1 = async_send(conn); * c2 = async_send(conn); @@ -77,12 +72,12 @@ * { * if (want_refuse) { - * ipc_answer_0(icallid, ELIMIT); + * async_answer_0(icallid, ELIMIT); * return; * } - * ipc_answer_0(icallid, EOK); + * async_answer_0(icallid, EOK); * * callid = async_get_call(&call); * somehow_handle_the_call(callid, call); - * ipc_answer_2(callid, 1, 2, 3); + * async_answer_2(callid, 1, 2, 3); * * callid = async_get_call(&call); @@ -92,12 +87,14 @@ */ +#define LIBC_ASYNC_C_ +#include +#include +#undef LIBC_ASYNC_C_ + #include -#include -#include #include #include #include #include -#include #include #include @@ -105,4 +102,5 @@ #include #include +#include "private/async.h" atomic_t async_futex = FUTEX_INITIALIZER; @@ -124,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 { @@ -153,5 +151,5 @@ /** Link to the client tracking structure. */ client_t *client; - + /** Messages that should be delivered to this fibril. */ link_t msg_queue; @@ -170,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) @@ -199,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); +} /** @@ -210,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) +{ +} /** @@ -221,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); } @@ -254,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); } @@ -271,21 +290,11 @@ 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 hash table removal callback function. - * - * This function is called whenever a connection is removed from the connection - * hash table. - * - * @param item Connection hash table item being removed. - * - */ + connection_t *conn = hash_table_get_instance(item, connection_t, link); + return (key[0] == conn->in_phone_hash); +} + static void conn_remove(link_t *item) { - free(hash_table_get_instance(item, connection_t, link)); -} - +} /** Operations for the connection hash table. */ @@ -308,9 +317,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; } @@ -329,5 +339,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. * */ @@ -420,4 +430,10 @@ fid_t fid = fibril_create(notification_fibril, msg); + if (fid == 0) { + free(msg); + futex_up(&async_futex); + return false; + } + fibril_add_ready(fid); @@ -466,5 +482,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)); @@ -473,5 +489,5 @@ return conn->close_callid; } - + if (usecs) async_insert_timeout(&conn->wdata); @@ -511,29 +527,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. * @@ -548,14 +539,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 @@ -563,28 +551,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. @@ -596,17 +591,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. @@ -621,8 +622,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); @@ -637,4 +638,5 @@ ipc_answer_0(FIBRIL_connection->close_callid, EOK); + free(FIBRIL_connection); return 0; } @@ -667,4 +669,5 @@ if (callid) ipc_answer_0(callid, ENOMEM); + return (uintptr_t) NULL; } @@ -684,8 +687,10 @@ conn->wdata.fid = fibril_create(connection_fibril, conn); - if (!conn->wdata.fid) { + if (conn->wdata.fid == 0) { free(conn); + if (callid) ipc_answer_0(callid, ENOMEM); + return (uintptr_t) NULL; } @@ -714,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; } @@ -723,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: - ; } @@ -751,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; @@ -785,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 @@ -808,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); @@ -822,5 +822,5 @@ atomic_dec(&threads_in_ipc_wait); - + if (!callid) { handle_expired_timeouts(); @@ -861,5 +861,6 @@ { fid_t fid = fibril_create(async_manager_fibril, NULL); - fibril_add_manager(fid); + if (fid != 0) + fibril_add_manager(fid); } @@ -872,17 +873,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(); } @@ -897,4 +895,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) @@ -944,5 +943,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) @@ -953,5 +952,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; @@ -984,5 +987,5 @@ ipc_call_t *dataptr) { - amsg_t *msg = malloc(sizeof(*msg)); + amsg_t *msg = malloc(sizeof(amsg_t)); if (!msg) @@ -993,5 +996,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; @@ -1092,5 +1099,5 @@ void async_usleep(suseconds_t timeout) { - amsg_t *msg = malloc(sizeof(*msg)); + amsg_t *msg = malloc(sizeof(amsg_t)); if (!msg) @@ -1235,78 +1242,215 @@ } +void async_msg_0(int phone, sysarg_t imethod) +{ + ipc_call_async_0(phone, imethod, NULL, NULL, true); +} + +void async_msg_1(int phone, sysarg_t imethod, sysarg_t arg1) +{ + ipc_call_async_1(phone, imethod, arg1, NULL, NULL, true); +} + +void async_msg_2(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2) +{ + ipc_call_async_2(phone, imethod, arg1, arg2, NULL, NULL, true); +} + +void async_msg_3(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3) +{ + ipc_call_async_3(phone, imethod, arg1, arg2, arg3, NULL, NULL, true); +} + +void async_msg_4(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3, sysarg_t arg4) +{ + ipc_call_async_4(phone, imethod, arg1, arg2, arg3, arg4, NULL, NULL, + true); +} + +void async_msg_5(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3, sysarg_t arg4, sysarg_t arg5) +{ + ipc_call_async_5(phone, imethod, arg1, arg2, arg3, arg4, arg5, NULL, + NULL, true); +} + +sysarg_t async_answer_0(ipc_callid_t callid, sysarg_t retval) +{ + return ipc_answer_0(callid, retval); +} + +sysarg_t async_answer_1(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1) +{ + return ipc_answer_1(callid, retval, arg1); +} + +sysarg_t async_answer_2(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, + sysarg_t arg2) +{ + return ipc_answer_2(callid, retval, arg1, arg2); +} + +sysarg_t async_answer_3(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3) +{ + return ipc_answer_3(callid, retval, arg1, arg2, arg3); +} + +sysarg_t async_answer_4(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4) +{ + return ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4); +} + +sysarg_t async_answer_5(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5) +{ + return ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5); +} + +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, sysarg_t imethod, + sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, + unsigned int mode) +{ + return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4, + arg5, mode); +} + +/** Wrapper for making IPC_M_CONNECT_TO_ME calls using the async framework. + * + * Ask through phone for a new connection to some service. + * + * @param phone Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * @param client_receiver Connection handing routine. + * + * @return New phone handle on success or a negative error code. + * + */ +int async_connect_to_me(int phone, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3, async_client_conn_t client_receiver) +{ + sysarg_t task_hash; + sysarg_t phone_hash; + int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, + NULL, NULL, NULL, &task_hash, &phone_hash); + if (rc != EOK) + return rc; + + if (client_receiver != NULL) + async_new_connection(task_hash, phone_hash, 0, NULL, + client_receiver); + + return EOK; +} + /** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. - * + * * Ask through phone for a new connection to some service. * - * @param phoneid Phone handle used for contacting the other side. - * @param arg1 User defined argument. - * @param arg2 User defined argument. - * @param arg3 User defined argument. - * - * @return New phone handle on success or a negative error code. - */ -int -async_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3) -{ - int rc; + * @param phone Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New phone handle on success or a negative error code. + * + */ +int async_connect_me_to(int phone, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3) +{ sysarg_t newphid; - - rc = async_req_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL, - NULL, NULL, NULL, &newphid); - - if (rc != EOK) + int rc = async_req_3_5(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, + NULL, NULL, NULL, NULL, &newphid); + + if (rc != EOK) return rc; - + return newphid; } /** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework. - * + * * Ask through phone for a new connection to some service and block until * success. * - * @param phoneid Phone handle used for contacting the other side. - * @param arg1 User defined argument. - * @param arg2 User defined argument. - * @param arg3 User defined argument. - * - * @return New phone handle on success or a negative error code. - */ -int -async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2, + * @param phoneid Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New phone handle on success or a negative error code. + * + */ +int async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3) { - int rc; sysarg_t newphid; - - rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, + int rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid); - if (rc != EOK) + if (rc != EOK) return rc; - + return newphid; } -/** 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. +/** Connect to a task specified by id. + * + */ +int async_connect_kbox(task_id_t id) +{ + return ipc_connect_kbox(id); +} + +/** Wrapper for ipc_hangup. + * + * @param phone Phone handle to hung up. + * + * @return Zero on success or a negative error code. + * + */ +int async_hangup(int phone) +{ + return ipc_hangup(phone); +} + +/** Interrupt one thread of this task from waiting for IPC. */ +void async_poke(void) +{ + ipc_poke(); +} + +/** 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; } @@ -1314,54 +1458,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, @@ -1371,42 +1520,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) @@ -1415,12 +1567,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) @@ -1432,41 +1584,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) @@ -1476,5 +1632,4 @@ /** Wrapper for forwarding any read request - * * */ @@ -1509,5 +1664,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. @@ -1526,37 +1681,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. @@ -1654,5 +1809,5 @@ * */ -void async_data_write_void(const int retval) +void async_data_write_void(sysarg_t retval) { ipc_callid_t callid; @@ -1662,5 +1817,4 @@ /** Wrapper for forwarding any data that is about to be received - * * */ Index: uspace/lib/c/generic/async_sess.c =================================================================== --- uspace/lib/c/generic/async_sess.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/async_sess.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -99,5 +99,4 @@ #include -#include #include #include @@ -106,4 +105,5 @@ #include #include +#include "private/async_sess.h" /** An inactive open connection. */ @@ -138,6 +138,7 @@ * * Needs to be called prior to any other interface in this file. - */ -void _async_sess_init(void) + * + */ +void __async_sess_init(void) { fibril_mutex_initialize(&async_sess_mutex); @@ -200,5 +201,5 @@ list_remove(&conn->global_link); - ipc_hangup(conn->data_phone); + async_hangup(conn->data_phone); free(conn); } @@ -260,5 +261,5 @@ data_phone = conn->data_phone; free(conn); - ipc_hangup(data_phone); + async_hangup(data_phone); goto retry; } else { @@ -292,5 +293,5 @@ * means that we simply hang up. */ - ipc_hangup(data_phone); + async_hangup(data_phone); fibril_mutex_unlock(&async_sess_mutex); return; Index: uspace/lib/c/generic/clipboard.c =================================================================== --- uspace/lib/c/generic/clipboard.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/clipboard.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,4 +39,5 @@ #include +#include #include #include @@ -54,5 +55,5 @@ { while (clip_phone < 0) - clip_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_CLIPBOARD, 0, 0); + clip_phone = service_connect_blocking(SERVICE_CLIPBOARD, 0, 0); } Index: uspace/lib/c/generic/ddi.c =================================================================== --- uspace/lib/c/generic/ddi.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/ddi.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -127,4 +127,33 @@ } +/** Register IRQ notification. + * + * @param inr IRQ number. + * @param devno Device number of the device generating inr. + * @param method Use this method for notifying me. + * @param ucode Top-half pseudocode handler. + * + * @return Value returned by the kernel. + * + */ +int register_irq(int inr, int devno, int method, irq_code_t *ucode) +{ + return __SYSCALL4(SYS_REGISTER_IRQ, inr, devno, method, + (sysarg_t) ucode); +} + +/** Unregister IRQ notification. + * + * @param inr IRQ number. + * @param devno Device number of the device generating inr. + * + * @return Value returned by the kernel. + * + */ +int unregister_irq(int inr, int devno) +{ + return __SYSCALL2(SYS_UNREGISTER_IRQ, inr, devno); +} + /** @} */ Index: uspace/lib/c/generic/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/devman.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -28,6 +28,6 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ - - /** @addtogroup libc + +/** @addtogroup libc * @{ */ @@ -37,5 +37,4 @@ #include #include -#include #include #include @@ -116,5 +115,5 @@ async_set_client_connection(conn); - ipc_connect_to_me(phone, 0, 0, 0, NULL, NULL); + async_connect_to_me(phone, 0, 0, 0, NULL); async_wait_for(req, &retval); @@ -221,5 +220,5 @@ case DEVMAN_DRIVER: if (devman_phone_driver >= 0) { - ipc_hangup(devman_phone_driver); + async_hangup(devman_phone_driver); devman_phone_driver = -1; } @@ -227,5 +226,5 @@ case DEVMAN_CLIENT: if (devman_phone_client >= 0) { - ipc_hangup(devman_phone_client); + async_hangup(devman_phone_client); devman_phone_client = -1; } Index: uspace/lib/c/generic/devmap.c =================================================================== --- uspace/lib/c/generic/devmap.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/devmap.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -29,6 +29,6 @@ #include -#include #include +#include #include #include @@ -50,9 +50,9 @@ if (flags & IPC_FLAG_BLOCKING) - devmap_phone_driver = ipc_connect_me_to_blocking(PHONE_NS, - SERVICE_DEVMAP, DEVMAP_DRIVER, 0); + devmap_phone_driver = service_connect_blocking(SERVICE_DEVMAP, + DEVMAP_DRIVER, 0); else - devmap_phone_driver = ipc_connect_me_to(PHONE_NS, - SERVICE_DEVMAP, DEVMAP_DRIVER, 0); + devmap_phone_driver = service_connect(SERVICE_DEVMAP, + DEVMAP_DRIVER, 0); return devmap_phone_driver; @@ -62,9 +62,9 @@ if (flags & IPC_FLAG_BLOCKING) - devmap_phone_client = ipc_connect_me_to_blocking(PHONE_NS, - SERVICE_DEVMAP, DEVMAP_CLIENT, 0); + devmap_phone_client = service_connect_blocking(SERVICE_DEVMAP, + DEVMAP_CLIENT, 0); else - devmap_phone_client = ipc_connect_me_to(PHONE_NS, - SERVICE_DEVMAP, DEVMAP_CLIENT, 0); + devmap_phone_client = service_connect(SERVICE_DEVMAP, + DEVMAP_CLIENT, 0); return devmap_phone_client; @@ -79,5 +79,5 @@ case DEVMAP_DRIVER: if (devmap_phone_driver >= 0) { - ipc_hangup(devmap_phone_driver); + async_hangup(devmap_phone_driver); devmap_phone_driver = -1; } @@ -85,5 +85,5 @@ case DEVMAP_CLIENT: if (devmap_phone_client >= 0) { - ipc_hangup(devmap_phone_client); + async_hangup(devmap_phone_client); devmap_phone_client = -1; } @@ -116,5 +116,5 @@ async_set_client_connection(conn); - ipc_connect_to_me(phone, 0, 0, 0, NULL, NULL); + async_connect_to_me(phone, 0, 0, 0, NULL); async_wait_for(req, &retval); Index: uspace/lib/c/generic/err.c =================================================================== --- uspace/lib/c/generic/err.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ (revision ) @@ -1,46 +1,0 @@ -/* - * Copyright (c) 2006 Ondrej Palkovsky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - */ - -#include -#include - -/* TODO -void errx(int __status, __const char *__format, ...) -{ - _exit(0); -} -*/ - -/** @} - */ Index: uspace/lib/c/generic/event.c =================================================================== --- uspace/lib/c/generic/event.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/event.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -35,10 +35,9 @@ */ /** @file - */ + */ #include #include #include -#include /** Subscribe for event notifications. Index: uspace/lib/c/generic/fibril_synch.c =================================================================== --- uspace/lib/c/generic/fibril_synch.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/fibril_synch.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,4 @@ #include #include -#include #include #include @@ -44,4 +43,5 @@ #include #include +#include "private/async.h" static void optimize_execution_power(void) @@ -55,5 +55,5 @@ */ if (atomic_get(&threads_in_ipc_wait) > 0) - ipc_poke(); + async_poke(); } @@ -105,5 +105,5 @@ if (fibril_get_sercount() != 0) - core(); + abort(); futex_down(&async_futex); @@ -198,5 +198,5 @@ if (fibril_get_sercount() != 0) - core(); + abort(); futex_down(&async_futex); @@ -226,5 +226,5 @@ if (fibril_get_sercount() != 0) - core(); + abort(); futex_down(&async_futex); Index: uspace/lib/c/generic/io/io.c =================================================================== --- uspace/lib/c/generic/io/io.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/io/io.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,8 +41,10 @@ #include #include +#include #include #include #include #include +#include "../private/io.h" static void _ffillbuf(FILE *stream); @@ -322,5 +324,5 @@ if (stream->phone >= 0) - ipc_hangup(stream->phone); + async_hangup(stream->phone); if (stream->fd >= 0) Index: uspace/lib/c/generic/ipc.c =================================================================== --- uspace/lib/c/generic/ipc.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/ipc.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -45,21 +45,17 @@ #include #include -#include -#include #include -#include -#include #include -#include /** - * Structures of this type are used for keeping track of sent asynchronous calls - * and queing unsent calls. + * Structures of this type are used for keeping track + * of sent asynchronous calls and queing unsent calls. */ typedef struct { link_t list; - + ipc_async_callback_t callback; void *private; + union { ipc_callid_t callid; @@ -69,5 +65,7 @@ } msg; } u; - fid_t fid; /**< Fibril waiting for sending this call. */ + + /** Fibril waiting for sending this call. */ + fid_t fid; } async_call_t; @@ -76,6 +74,7 @@ /** List of asynchronous calls that were not accepted by kernel. * - * It is protected by async_futex, because if the call cannot be sent into the - * kernel, the async framework is used automatically. + * Protected by async_futex, because if the call is not accepted + * by the kernel, the async framework is used automatically. + * */ LIST_INITIALIZE(queued_calls); @@ -83,36 +82,35 @@ static atomic_t ipc_futex = FUTEX_INITIALIZER; -/** Make a fast synchronous call. - * - * Only three payload arguments can be passed using this function. However, this - * function is faster than the generic ipc_call_sync_slow() because the payload - * is passed directly in registers. - * - * @param phoneid Phone handle for the call. - * @param method Requested method. - * @param arg1 Service-defined payload argument. - * @param arg2 Service-defined payload argument. - * @param arg3 Service-defined payload argument. - * @param result1 If non-NULL, the return ARG1 will be stored there. - * @param result2 If non-NULL, the return ARG2 will be stored there. - * @param result3 If non-NULL, the return ARG3 will be stored there. - * @param result4 If non-NULL, the return ARG4 will be stored there. - * @param result5 If non-NULL, the return ARG5 will be stored there. - * - * @return Negative values represent errors returned by IPC. - * Otherwise the RETVAL of the answer is returned. - */ -int -ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1, sysarg_t arg2, - sysarg_t arg3, sysarg_t *result1, sysarg_t *result2, sysarg_t *result3, - sysarg_t *result4, sysarg_t *result5) +/** Fast synchronous call. + * + * Only three payload arguments can be passed using this function. However, + * this function is faster than the generic ipc_call_sync_slow() because + * the payload is passed directly in registers. + * + * @param phoneid Phone handle for the call. + * @param method Requested method. + * @param arg1 Service-defined payload argument. + * @param arg2 Service-defined payload argument. + * @param arg3 Service-defined payload argument. + * @param result1 If non-NULL, the return ARG1 will be stored there. + * @param result2 If non-NULL, the return ARG2 will be stored there. + * @param result3 If non-NULL, the return ARG3 will be stored there. + * @param result4 If non-NULL, the return ARG4 will be stored there. + * @param result5 If non-NULL, the return ARG5 will be stored there. + * + * @return Negative values representing IPC errors. + * @return Otherwise the RETVAL of the answer. + * + */ +int ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t *result1, sysarg_t *result2, + sysarg_t *result3, sysarg_t *result4, sysarg_t *result5) { ipc_call_t resdata; - int callres; - - callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1, + int callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1, arg2, arg3, (sysarg_t) &resdata); if (callres) return callres; + if (result1) *result1 = IPC_GET_ARG1(resdata); @@ -125,9 +123,9 @@ if (result5) *result5 = IPC_GET_ARG5(resdata); - + return IPC_GET_RETVAL(resdata); } -/** Make a synchronous call transmitting 5 arguments of payload. +/** Synchronous call transmitting 5 arguments of payload. * * @param phoneid Phone handle for the call. @@ -144,12 +142,12 @@ * @param result5 If non-NULL, storage for the fifth return argument. * - * @return Negative value means IPC error. - * Otherwise the RETVAL of the answer. - * - */ -int -ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, - sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *result1, - sysarg_t *result2, sysarg_t *result3, sysarg_t *result4, sysarg_t *result5) + * @return Negative values representing IPC errors. + * @return Otherwise the RETVAL of the answer. + * + */ +int ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1, + sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, + sysarg_t *result1, sysarg_t *result2, sysarg_t *result3, sysarg_t *result4, + sysarg_t *result5) { ipc_call_t data; @@ -181,5 +179,5 @@ } -/** Syscall to send asynchronous message. +/** Send asynchronous message via syscall. * * @param phoneid Phone handle for the call. @@ -189,66 +187,72 @@ * */ -static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data) +static ipc_callid_t ipc_call_async_internal(int phoneid, ipc_call_t *data) { return __SYSCALL2(SYS_IPC_CALL_ASYNC_SLOW, phoneid, (sysarg_t) data); } -/** Prolog to ipc_call_async_*() functions. - * - * @param private Argument for the answer/error callback. - * @param callback Answer/error callback. - * - * @return New, partially initialized async_call structure or NULL. +/** Prolog for ipc_call_async_*() functions. + * + * @param private Argument for the answer/error callback. + * @param callback Answer/error callback. + * + * @return New, partially initialized async_call structure or NULL. + * */ static inline async_call_t *ipc_prepare_async(void *private, ipc_async_callback_t callback) { - async_call_t *call; - - call = malloc(sizeof(*call)); + async_call_t *call = + (async_call_t *) malloc(sizeof(async_call_t)); if (!call) { if (callback) callback(private, ENOMEM, NULL); + return NULL; } + call->callback = callback; call->private = private; - + return call; } -/** Epilogue of ipc_call_async_*() functions. - * - * @param callid Value returned by the SYS_IPC_CALL_ASYNC_* syscall. - * @param phoneid Phone handle through which the call was made. - * @param call async_call structure returned by ipc_prepare_async(). - * @param can_preempt If non-zero, the current fibril can be preempted in this - * call. +/** Epilog for ipc_call_async_*() functions. + * + * @param callid Value returned by the SYS_IPC_CALL_ASYNC_* syscall. + * @param phoneid Phone handle through which the call was made. + * @param call Structure returned by ipc_prepare_async(). + * @param can_preempt If true, the current fibril can be preempted + * in this call. + * */ static inline void ipc_finish_async(ipc_callid_t callid, int phoneid, - async_call_t *call, int can_preempt) -{ - if (!call) { /* Nothing to do regardless if failed or not */ + async_call_t *call, bool can_preempt) +{ + if (!call) { + /* Nothing to do regardless if failed or not */ futex_up(&ipc_futex); return; } - + if (callid == (ipc_callid_t) IPC_CALLRET_FATAL) { futex_up(&ipc_futex); + /* Call asynchronous handler with error code */ if (call->callback) call->callback(call->private, ENOENT, NULL); + free(call); return; } - + if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) { futex_up(&ipc_futex); - + call->u.msg.phoneid = phoneid; futex_down(&async_futex); list_append(&call->list, &queued_calls); - + if (can_preempt) { call->fid = fibril_get_id(); @@ -259,14 +263,16 @@ futex_up(&async_futex); } + return; } + call->u.callid = callid; + /* Add call to the list of dispatched calls */ list_append(&call->list, &dispatched_calls); futex_up(&ipc_futex); - -} - -/** Make a fast asynchronous call. +} + +/** Fast asynchronous call. * * This function can only handle four arguments of payload. It is, however, @@ -274,7 +280,8 @@ * * Note that this function is a void function. - * During normal opertation, answering this call will trigger the callback. - * In case of fatal error, call the callback handler with the proper error code. - * If the call cannot be temporarily made, queue it. + * + * During normal operation, answering this call will trigger the callback. + * In case of fatal error, the callback handler is called with the proper + * error code. If the call cannot be temporarily made, it is queued. * * @param phoneid Phone handle for the call. @@ -286,5 +293,5 @@ * @param private Argument to be passed to the answer/error callback. * @param callback Answer or error callback. - * @param can_preempt If non-zero, the current fibril will be preempted in + * @param can_preempt If true, the current fibril will be preempted in * case the kernel temporarily refuses to accept more * asynchronous calls. @@ -293,5 +300,5 @@ void ipc_call_async_fast(int phoneid, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, void *private, - ipc_async_callback_t callback, int can_preempt) + ipc_async_callback_t callback, bool can_preempt) { async_call_t *call = NULL; @@ -304,7 +311,8 @@ /* - * We need to make sure that we get callid before another thread - * accesses the queue again. + * We need to make sure that we get callid + * before another thread accesses the queue again. */ + futex_down(&ipc_futex); ipc_callid_t callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid, @@ -317,4 +325,5 @@ return; } + IPC_SET_IMETHOD(call->u.msg.data, imethod); IPC_SET_ARG1(call->u.msg.data, arg1); @@ -322,19 +331,23 @@ IPC_SET_ARG3(call->u.msg.data, arg3); IPC_SET_ARG4(call->u.msg.data, arg4); + /* * To achieve deterministic behavior, we always zero out the * arguments that are beyond the limits of the fast version. */ + IPC_SET_ARG5(call->u.msg.data, 0); } + ipc_finish_async(callid, phoneid, call, can_preempt); } -/** Make an asynchronous call transmitting the entire payload. +/** Asynchronous call transmitting the entire payload. * * Note that this function is a void function. - * During normal opertation, answering this call will trigger the callback. - * In case of fatal error, call the callback handler with the proper error code. - * If the call cannot be temporarily made, queue it. + * + * During normal operation, answering this call will trigger the callback. + * In case of fatal error, the callback handler is called with the proper + * error code. If the call cannot be temporarily made, it is queued. * * @param phoneid Phone handle for the call. @@ -347,5 +360,5 @@ * @param private Argument to be passed to the answer/error callback. * @param callback Answer or error callback. - * @param can_preempt If non-zero, the current fibril will be preempted in + * @param can_preempt If true, the current fibril will be preempted in * case the kernel temporarily refuses to accept more * asynchronous calls. @@ -354,13 +367,10 @@ void ipc_call_async_slow(int phoneid, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, void *private, - ipc_async_callback_t callback, int can_preempt) -{ - async_call_t *call; - ipc_callid_t callid; - - call = ipc_prepare_async(private, callback); + ipc_async_callback_t callback, bool can_preempt) +{ + async_call_t *call = ipc_prepare_async(private, callback); if (!call) return; - + IPC_SET_IMETHOD(call->u.msg.data, imethod); IPC_SET_ARG1(call->u.msg.data, arg1); @@ -369,28 +379,32 @@ IPC_SET_ARG4(call->u.msg.data, arg4); IPC_SET_ARG5(call->u.msg.data, arg5); + /* - * We need to make sure that we get callid before another thread - * accesses the queue again. + * We need to make sure that we get callid + * before another threadaccesses the queue again. */ + futex_down(&ipc_futex); - callid = _ipc_call_async(phoneid, &call->u.msg.data); - + ipc_callid_t callid = + ipc_call_async_internal(phoneid, &call->u.msg.data); + ipc_finish_async(callid, phoneid, call, can_preempt); } - -/** Answer a received call - fast version. +/** Answer received call (fast version). * * The fast answer makes use of passing retval and first four arguments in * registers. If you need to return more, use the ipc_answer_slow() instead. * - * @param callid Hash of the call being answered. - * @param retval Return value. - * @param arg1 First return argument. - * @param arg2 Second return argument. - * @param arg3 Third return argument. - * @param arg4 Fourth return argument. - * - * @return Zero on success or a value from @ref errno.h on failure. + * @param callid Hash of the call being answered. + * @param retval Return value. + * @param arg1 First return argument. + * @param arg2 Second return argument. + * @param arg3 Third return argument. + * @param arg4 Fourth return argument. + * + * @return Zero on success. + * @return Value from @ref errno.h on failure. + * */ sysarg_t ipc_answer_fast(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, @@ -401,15 +415,17 @@ } -/** Answer a received call - slow full version. - * - * @param callid Hash of the call being answered. - * @param retval Return value. - * @param arg1 First return argument. - * @param arg2 Second return argument. - * @param arg3 Third return argument. - * @param arg4 Fourth return argument. - * @param arg5 Fifth return argument. - * - * @return Zero on success or a value from @ref errno.h on failure. +/** Answer received call (entire payload). + * + * @param callid Hash of the call being answered. + * @param retval Return value. + * @param arg1 First return argument. + * @param arg2 Second return argument. + * @param arg3 Third return argument. + * @param arg4 Fourth return argument. + * @param arg5 Fifth return argument. + * + * @return Zero on success. + * @return Value from @ref errno.h on failure. + * */ sysarg_t ipc_answer_slow(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1, @@ -417,5 +433,5 @@ { ipc_call_t data; - + IPC_SET_RETVAL(data, retval); IPC_SET_ARG1(data, arg1); @@ -424,30 +440,33 @@ IPC_SET_ARG4(data, arg4); IPC_SET_ARG5(data, arg5); - + return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data); } - -/** Try to dispatch queued calls from the async queue. */ -static void try_dispatch_queued_calls(void) -{ - async_call_t *call; - ipc_callid_t callid; - +/** Try to dispatch queued calls from the async queue. + * + */ +static void dispatch_queued_calls(void) +{ /** @todo - * Integrate intelligently ipc_futex, so that it is locked during - * ipc_call_async_*(), until it is added to dispatched_calls. + * Integrate intelligently ipc_futex so that it is locked during + * ipc_call_async_*() until it is added to dispatched_calls. */ + futex_down(&async_futex); + while (!list_empty(&queued_calls)) { - call = list_get_instance(queued_calls.next, async_call_t, list); - callid = _ipc_call_async(call->u.msg.phoneid, - &call->u.msg.data); - if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) { + async_call_t *call = + list_get_instance(queued_calls.next, async_call_t, list); + ipc_callid_t callid = + ipc_call_async_internal(call->u.msg.phoneid, &call->u.msg.data); + + if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) break; - } + list_remove(&call->list); - + futex_up(&async_futex); + if (call->fid) fibril_add_ready(call->fid); @@ -456,94 +475,114 @@ if (call->callback) call->callback(call->private, ENOENT, NULL); + free(call); } else { call->u.callid = callid; + futex_down(&ipc_futex); list_append(&call->list, &dispatched_calls); futex_up(&ipc_futex); } + futex_down(&async_futex); } + futex_up(&async_futex); } -/** Handle a received answer. +/** Handle received answer. * * Find the hash of the answer and call the answer callback. * - * @todo Make it use hash table. - * - * @param callid Hash of the received answer. - * The answer has the same hash as the request OR'ed with - * the IPC_CALLID_ANSWERED bit. - * @param data Call data of the answer. + * The answer has the same hash as the request OR'ed with + * the IPC_CALLID_ANSWERED bit. + * + * @todo Use hash table. + * + * @param callid Hash of the received answer. + * @param data Call data of the answer. + * */ static void handle_answer(ipc_callid_t callid, ipc_call_t *data) { + callid &= ~IPC_CALLID_ANSWERED; + + futex_down(&ipc_futex); + link_t *item; - async_call_t *call; - - callid &= ~IPC_CALLID_ANSWERED; - - futex_down(&ipc_futex); for (item = dispatched_calls.next; item != &dispatched_calls; item = item->next) { - call = list_get_instance(item, async_call_t, list); + async_call_t *call = + list_get_instance(item, async_call_t, list); + if (call->u.callid == callid) { list_remove(&call->list); + futex_up(&ipc_futex); + if (call->callback) - call->callback(call->private, + call->callback(call->private, IPC_GET_RETVAL(*data), data); + free(call); return; } } + futex_up(&ipc_futex); } - -/** Wait for a first call to come. - * - * @param call Storage where the incoming call data will be stored. - * @param usec Timeout in microseconds - * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking). - * - * @return Hash of the call. Note that certain bits have special - * meaning. IPC_CALLID_ANSWERED will be set in an answer - * and IPC_CALLID_NOTIFICATION is used for notifications. - * - */ -ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags) -{ - ipc_callid_t callid; - - callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags); +/** Wait for first IPC call to come. + * + * @param call Incoming call storage. + * @param usec Timeout in microseconds + * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking). + * + * @return Hash of the call. Note that certain bits have special + * meaning: IPC_CALLID_ANSWERED is set in an answer + * and IPC_CALLID_NOTIFICATION is used for notifications. + * + */ +ipc_callid_t ipc_wait_cycle(ipc_call_t *call, sysarg_t usec, + unsigned int flags) +{ + ipc_callid_t callid = + __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags); + /* Handle received answers */ if (callid & IPC_CALLID_ANSWERED) { handle_answer(callid, call); - try_dispatch_queued_calls(); + dispatch_queued_calls(); } - + return callid; } -/** Wait some time for an IPC call. - * - * The call will return after an answer is received. - * - * @param call Storage where the incoming call data will be stored. - * @param usec Timeout in microseconds. - * - * @return Hash of the answer. - */ -ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec) +/** Interrupt one thread of this task from waiting for IPC. + * + */ +void ipc_poke(void) +{ + __SYSCALL0(SYS_IPC_POKE); +} + +/** Wait for first IPC call to come. + * + * Only requests are returned, answers are processed internally. + * + * @param call Incoming call storage. + * @param usec Timeout in microseconds + * + * @return Hash of the call. + * + */ +ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, sysarg_t usec) { ipc_callid_t callid; - + do { callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE); } while (callid & IPC_CALLID_ANSWERED); - + return callid; } @@ -551,41 +590,40 @@ /** Check if there is an IPC call waiting to be picked up. * - * @param call Storage where the incoming call will be stored. - * @return Hash of the answer. + * Only requests are returned, answers are processed internally. + * + * @param call Incoming call storage. + * + * @return Hash of the call. + * */ ipc_callid_t ipc_trywait_for_call(ipc_call_t *call) { ipc_callid_t callid; - + do { callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING); } while (callid & IPC_CALLID_ANSWERED); - + return callid; } -/** Interrupt one thread of this task from waiting for IPC. */ -void ipc_poke(void) -{ - __SYSCALL0(SYS_IPC_POKE); -} - -/** Ask destination to do a callback connection. - * - * @param phoneid Phone handle used for contacting the other side. - * @param arg1 Service-defined argument. - * @param arg2 Service-defined argument. - * @param arg3 Service-defined argument. - * @param taskhash Storage where the kernel will store an opaque - * identifier of the client task. - * @param phonehash Storage where the kernel will store an opaque - * identifier of the phone that will be used for incoming - * calls. This identifier can be used for connection - * tracking. - * - * @return Zero on success or a negative error code. - */ -int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3, +/** Request callback connection. + * + * The @a taskhash and @a phonehash identifiers returned + * by the kernel can be used for connection tracking. + * + * @param phoneid Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * @param taskhash Opaque identifier of the client task. + * @param phonehash Opaque identifier of the phone that will + * be used for incoming calls. + * + * @return Zero on success or a negative error code. + * + */ +int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *taskhash, sysarg_t *phonehash) { @@ -594,46 +632,48 @@ } -/** Ask through phone for a new connection to some service. - * - * @param phoneid Phone handle used for contacting the other side. - * @param arg1 User defined argument. - * @param arg2 User defined argument. - * @param arg3 User defined argument. - * - * @return New phone handle on success or a negative error code. - */ -int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3) +/** Request new connection. + * + * @param phoneid Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New phone handle on success or a negative error code. + * + */ +int ipc_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3) { sysarg_t newphid; - int res; - - res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, + int res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL, NULL, NULL, NULL, &newphid); if (res) return res; + return newphid; } -/** Ask through phone for a new connection to some service. +/** Request new connection (blocking) * * If the connection is not available at the moment, the - * call will block. - * - * @param phoneid Phone handle used for contacting the other side. - * @param arg1 User defined argument. - * @param arg2 User defined argument. - * @param arg3 User defined argument. - * - * @return New phone handle on success or a negative error code. - */ -int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3) + * call should block. This has to be, however, implemented + * on the server side. + * + * @param phoneid Phone handle used for contacting the other side. + * @param arg1 User defined argument. + * @param arg2 User defined argument. + * @param arg3 User defined argument. + * + * @return New phone handle on success or a negative error code. + * + */ +int ipc_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2, + sysarg_t arg3) { sysarg_t newphid; - int res; - - res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, + int res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid); if (res) return res; + return newphid; } @@ -641,7 +681,8 @@ /** Hang up a phone. * - * @param phoneid Handle of the phone to be hung up. - * - * @return Zero on success or a negative error code. + * @param phoneid Handle of the phone to be hung up. + * + * @return Zero on success or a negative error code. + * */ int ipc_hangup(int phoneid) @@ -650,32 +691,10 @@ } -/** Register IRQ notification. - * - * @param inr IRQ number. - * @param devno Device number of the device generating inr. - * @param method Use this method for notifying me. - * @param ucode Top-half pseudocode handler. - * - * @return Value returned by the kernel. - */ -int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode) -{ - return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method, - (sysarg_t) ucode); -} - -/** Unregister IRQ notification. - * - * @param inr IRQ number. - * @param devno Device number of the device generating inr. - * - * @return Value returned by the kernel. - */ -int ipc_unregister_irq(int inr, int devno) -{ - return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno); -} - /** Forward a received call to another destination. + * + * For non-system methods, the old method, arg1 and arg2 are rewritten + * by the new values. For system methods, the new method, arg1 and arg2 + * are written to the old arg1, arg2 and arg3, respectivelly. Calls with + * immutable methods are forwarded verbatim. * * @param callid Hash of the call to forward. @@ -688,11 +707,7 @@ * @return Zero on success or an error code. * - * For non-system methods, the old method, arg1 and arg2 are rewritten by the - * new values. For system methods, the new method, arg1 and arg2 are written - * to the old arg1, arg2 and arg3, respectivelly. Calls with immutable - * methods are forwarded verbatim. - */ -int ipc_forward_fast(ipc_callid_t callid, int phoneid, int imethod, - sysarg_t arg1, sysarg_t arg2, int mode) + */ +int ipc_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod, + sysarg_t arg1, sysarg_t arg2, unsigned int mode) { return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, imethod, arg1, @@ -700,8 +715,7 @@ } - -int ipc_forward_slow(ipc_callid_t callid, int phoneid, int imethod, +int ipc_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) { ipc_call_t data; @@ -714,20 +728,21 @@ IPC_SET_ARG5(data, arg5); - return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, mode); -} - -/** Wrapper for making IPC_M_SHARE_IN calls. - * - * @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. + return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, + mode); +} + +/** Wrapper for IPC_M_SHARE_IN calls. + * + * @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 received flags. Can be NULL. + * + * @return Zero on success or a negative error code from errno.h. + * */ int ipc_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg, - int *flags) + unsigned int *flags) { sysarg_t tmp_flags = 0; @@ -736,5 +751,5 @@ if (flags) - *flags = tmp_flags; + *flags = (unsigned int) tmp_flags; return res; @@ -743,27 +758,30 @@ /** Wrapper for answering the IPC_M_SHARE_IN calls. * - * 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 ipc_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 ipc_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags) { return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) flags); } -/** Wrapper for making IPC_M_SHARE_OUT calls. - * - * @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 ipc_share_out_start(int phoneid, void *src, int flags) +/** Wrapper for IPC_M_SHARE_OUT calls. + * + * @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 ipc_share_out_start(int phoneid, void *src, unsigned int flags) { return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0, @@ -773,11 +791,13 @@ /** Wrapper for answering the IPC_M_SHARE_OUT calls. * - * 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 ipc_share_out_finalize(ipc_callid_t callid, void *dst) @@ -786,12 +806,12 @@ } - -/** Wrapper for making IPC_M_DATA_READ calls. - * - * @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. + * + * @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 ipc_data_read_start(int phoneid, void *dst, size_t size) @@ -803,13 +823,15 @@ /** Wrapper for answering the IPC_M_DATA_READ calls. * - * 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 ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size) @@ -818,11 +840,12 @@ } -/** Wrapper for making IPC_M_DATA_WRITE calls. - * - * @param phoneid Phone that will be used to contact the receiving side. - * @param src Address of the beginning of the source buffer. - * @param size Size of the source buffer. - * - * @return Zero on success or a negative error code from errno.h. +/** Wrapper for IPC_M_DATA_WRITE calls. + * + * @param phoneid Phone that will be used to contact the receiving side. + * @param src Address of the beginning of the source buffer. + * @param size Size of the source buffer. + * + * @return Zero on success or a negative error code from errno.h. + * */ int ipc_data_write_start(int phoneid, const void *src, size_t size) @@ -834,12 +857,14 @@ /** Wrapper for answering the IPC_M_DATA_WRITE calls. * - * 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. - * @param dst Final destination address for the IPC_M_DATA_WRITE call. - * @param size Final size for the IPC_M_DATA_WRITE call. - * - * @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_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. + * @param dst Final destination address for the IPC_M_DATA_WRITE call. + * @param size Final size for the IPC_M_DATA_WRITE call. + * + * @return Zero on success or a value from @ref errno.h on failure. + * */ int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size) Index: uspace/lib/c/generic/ipc/ns.c =================================================================== --- uspace/lib/c/generic/ipc/ns.c (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/generic/ipc/ns.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#include +#include + +int service_register(sysarg_t service) +{ + return async_connect_to_me(PHONE_NS, service, 0, 0, NULL); +} + +int service_connect(sysarg_t service, sysarg_t arg2, sysarg_t arg3) +{ + return async_connect_me_to(PHONE_NS, service, arg2, arg3); +} + +int service_connect_blocking(sysarg_t service, sysarg_t arg2, sysarg_t arg3) +{ + return async_connect_me_to_blocking(PHONE_NS, service, arg2, arg3); +} + +/** @} + */ Index: uspace/lib/c/generic/libc.c =================================================================== --- uspace/lib/c/generic/libc.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/libc.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -42,28 +42,28 @@ #include -#include -#include -#include +#include #include -#include #include -#include -#include -#include +#include #include +#include "private/libc.h" +#include "private/async.h" +#include "private/async_sess.h" +#include "private/malloc.h" +#include "private/io.h" -extern int main(int argc, char *argv[]); - -void _exit(int status) -{ - thread_exit(status); -} +static bool env_setup = false; void __main(void *pcb_ptr) { /* Initialize user task run-time environment */ - __heap_init(); + __malloc_init(); __async_init(); + __async_sess_init(); + fibril_t *fibril = fibril_setup(); + if (fibril == NULL) + abort(); + __tcb_set(fibril->tcb); @@ -71,9 +71,14 @@ __pcb = (pcb_t *) pcb_ptr; + /* The basic run-time environment is setup */ + env_setup = true; + int argc; char **argv; - /* Get command line arguments and initialize - standard input and output */ + /* + * Get command line arguments and initialize + * standard input and output + */ if (__pcb == NULL) { argc = 0; @@ -87,14 +92,32 @@ } - /* Run main() and set task return value - according the result */ - (void) task_retval(main(argc, argv)); + /* + * Run main() and set task return value + * according the result + */ + int retval = main(argc, argv); + exit(retval); } -void __exit(void) +void exit(int status) { - __stdio_done(); - fibril_teardown(__tcb_get()->fibril_data); - _exit(0); + if (env_setup) { + __stdio_done(); + task_retval(status); + fibril_teardown(__tcb_get()->fibril_data); + } + + __SYSCALL1(SYS_TASK_EXIT, false); + + /* Unreachable */ + while (1); +} + +void abort(void) +{ + __SYSCALL1(SYS_TASK_EXIT, true); + + /* Unreachable */ + while (1); } Index: uspace/lib/c/generic/loader.c =================================================================== --- uspace/lib/c/generic/loader.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/loader.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,7 +33,7 @@ */ -#include #include #include +#include #include #include @@ -63,5 +63,5 @@ loader_t *loader_connect(void) { - int phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0); + int phone_id = service_connect_blocking(SERVICE_LOAD, 0, 0); if (phone_id < 0) return NULL; @@ -319,5 +319,5 @@ return rc; - ipc_hangup(ldr->phone_id); + async_hangup(ldr->phone_id); ldr->phone_id = 0; return EOK; @@ -337,5 +337,5 @@ void loader_abort(loader_t *ldr) { - ipc_hangup(ldr->phone_id); + async_hangup(ldr->phone_id); ldr->phone_id = 0; } Index: uspace/lib/c/generic/malloc.c =================================================================== --- uspace/lib/c/generic/malloc.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/malloc.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -45,34 +45,79 @@ #include #include - -/* Magic used in heap headers. */ -#define HEAP_BLOCK_HEAD_MAGIC 0xBEEF0101 - -/* Magic used in heap footers. */ -#define HEAP_BLOCK_FOOT_MAGIC 0xBEEF0202 - -/** Allocation alignment (this also covers the alignment of fields - in the heap header and footer) */ +#include "private/malloc.h" + +/** Magic used in heap headers. */ +#define HEAP_BLOCK_HEAD_MAGIC UINT32_C(0xBEEF0101) + +/** Magic used in heap footers. */ +#define HEAP_BLOCK_FOOT_MAGIC UINT32_C(0xBEEF0202) + +/** Magic used in heap descriptor. */ +#define HEAP_AREA_MAGIC UINT32_C(0xBEEFCAFE) + +/** Allocation alignment. + * + * This also covers the alignment of fields + * in the heap header and footer. + * + */ #define BASE_ALIGN 16 -/** - * Either 4 * 256M on 32-bit architecures or 16 * 256M on 64-bit architectures - */ -#define MAX_HEAP_SIZE (sizeof(uintptr_t) << 28) - -/** - * - */ -#define STRUCT_OVERHEAD (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t)) - -/** - * Calculate real size of a heap block (with header and footer) +/** Overhead of each heap block. */ +#define STRUCT_OVERHEAD \ + (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t)) + +/** Calculate real size of a heap block. + * + * Add header and footer size. + * */ #define GROSS_SIZE(size) ((size) + STRUCT_OVERHEAD) -/** - * Calculate net size of a heap block (without header and footer) +/** Calculate net size of a heap block. + * + * Subtract header and footer size. + * */ #define NET_SIZE(size) ((size) - STRUCT_OVERHEAD) + +/** Get first block in heap area. + * + */ +#define AREA_FIRST_BLOCK(area) \ + (ALIGN_UP(((uintptr_t) (area)) + sizeof(heap_area_t), BASE_ALIGN)) + +/** Get footer in heap block. + * + */ +#define BLOCK_FOOT(head) \ + ((heap_block_foot_t *) \ + (((uintptr_t) head) + head->size - sizeof(heap_block_foot_t))) + +/** Heap area. + * + * The memory managed by the heap allocator is divided into + * multiple discontinuous heaps. Each heap is represented + * by a separate address space area which has this structure + * at its very beginning. + * + */ +typedef struct heap_area { + /** Start of the heap area (including this structure) + * + * Aligned on page boundary. + * + */ + void *start; + + /** End of the heap area (aligned on page boundary) */ + void *end; + + /** Next heap area */ + struct heap_area *next; + + /** A magic value */ + uint32_t magic; +} heap_area_t; /** Header of a heap block @@ -86,4 +131,7 @@ bool free; + /** Heap area this block belongs to */ + heap_area_t *area; + /* A magic value to detect overwrite of heap header */ uint32_t magic; @@ -101,25 +149,19 @@ } heap_block_foot_t; -/** Linker heap symbol */ -extern char _heap; +/** First heap area */ +static heap_area_t *first_heap_area = NULL; + +/** Last heap area */ +static heap_area_t *last_heap_area = NULL; + +/** Next heap block to examine (next fit algorithm) */ +static heap_block_head_t *next = NULL; /** Futex for thread-safe heap manipulation */ static futex_t malloc_futex = FUTEX_INITIALIZER; -/** Address of heap start */ -static void *heap_start = 0; - -/** Address of heap end */ -static void *heap_end = 0; - -/** Maximum heap size */ -static size_t max_heap_size = (size_t) -1; - -/** Current number of pages of heap area */ -static size_t heap_pages = 0; - /** Initialize a heap block * - * Fills in the structures related to a heap block. + * Fill in the structures related to a heap block. * Should be called only inside the critical section. * @@ -127,16 +169,18 @@ * @param size Size of the block including the header and the footer. * @param free Indication of a free block. - * - */ -static void block_init(void *addr, size_t size, bool free) + * @param area Heap area the block belongs to. + * + */ +static void block_init(void *addr, size_t size, bool free, heap_area_t *area) { /* Calculate the position of the header and the footer */ heap_block_head_t *head = (heap_block_head_t *) addr; - heap_block_foot_t *foot = - (heap_block_foot_t *) (addr + size - sizeof(heap_block_foot_t)); head->size = size; head->free = free; + head->area = area; head->magic = HEAP_BLOCK_HEAD_MAGIC; + + heap_block_foot_t *foot = BLOCK_FOOT(head); foot->size = size; @@ -159,6 +203,5 @@ assert(head->magic == HEAP_BLOCK_HEAD_MAGIC); - heap_block_foot_t *foot = - (heap_block_foot_t *) (addr + head->size - sizeof(heap_block_foot_t)); + heap_block_foot_t *foot = BLOCK_FOOT(head); assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC); @@ -166,92 +209,143 @@ } -/** Increase the heap area size - * - * Should be called only inside the critical section. - * - * @param size Number of bytes to grow the heap by. - * - */ -static bool grow_heap(size_t size) +/** Check a heap area structure + * + * @param addr Address of the heap area. + * + */ +static void area_check(void *addr) +{ + heap_area_t *area = (heap_area_t *) addr; + + assert(area->magic == HEAP_AREA_MAGIC); + assert(area->start < area->end); + assert(((uintptr_t) area->start % PAGE_SIZE) == 0); + assert(((uintptr_t) area->end % PAGE_SIZE) == 0); +} + +/** Create new heap area + * + * @param start Preffered starting address of the new area. + * @param size Size of the area. + * + */ +static bool area_create(size_t size) +{ + void *start = as_get_mappable_page(size); + if (start == NULL) + return false; + + /* Align the heap area on page boundary */ + void *astart = (void *) ALIGN_UP((uintptr_t) start, PAGE_SIZE); + size_t asize = ALIGN_UP(size, PAGE_SIZE); + + astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ); + if (astart == (void *) -1) + return false; + + heap_area_t *area = (heap_area_t *) astart; + + area->start = astart; + area->end = (void *) + ALIGN_DOWN((uintptr_t) astart + asize, BASE_ALIGN); + area->next = NULL; + area->magic = HEAP_AREA_MAGIC; + + void *block = (void *) AREA_FIRST_BLOCK(area); + size_t bsize = (size_t) (area->end - block); + + block_init(block, bsize, true, area); + + if (last_heap_area == NULL) { + first_heap_area = area; + last_heap_area = area; + } else { + last_heap_area->next = area; + last_heap_area = area; + } + + return true; +} + +/** Try to enlarge a heap area + * + * @param area Heap area to grow. + * @param size Gross size of item to allocate (bytes). + * + */ +static bool area_grow(heap_area_t *area, size_t size) { if (size == 0) + return true; + + area_check(area); + + size_t asize = ALIGN_UP((size_t) (area->end - area->start) + size, + PAGE_SIZE); + + /* New heap area size */ + void *end = (void *) + ALIGN_DOWN((uintptr_t) area->start + asize, BASE_ALIGN); + + /* Check for overflow */ + if (end < area->start) return false; - - if ((heap_start + size < heap_start) || (heap_end + size < heap_end)) + + /* Resize the address space area */ + int ret = as_area_resize(area->start, asize, 0); + if (ret != EOK) return false; - size_t heap_size = (size_t) (heap_end - heap_start); - - if ((max_heap_size != (size_t) -1) && (heap_size + size > max_heap_size)) - return false; - - size_t pages = (size - 1) / PAGE_SIZE + 1; - - if (as_area_resize((void *) &_heap, (heap_pages + pages) * PAGE_SIZE, 0) - == EOK) { - void *end = (void *) ALIGN_DOWN(((uintptr_t) &_heap) + - (heap_pages + pages) * PAGE_SIZE, BASE_ALIGN); - block_init(heap_end, end - heap_end, true); - heap_pages += pages; - heap_end = end; + /* Add new free block */ + block_init(area->end, (size_t) (end - area->end), true, area); + + /* Update heap area parameters */ + area->end = end; + + return true; +} + +/** Try to enlarge any of the heap areas + * + * @param size Gross size of item to allocate (bytes). + * + */ +static bool heap_grow(size_t size) +{ + if (size == 0) return true; - } - - return false; -} - -/** Decrease the heap area - * - * Should be called only inside the critical section. - * - * @param size Number of bytes to shrink the heap by. - * - */ -static void shrink_heap(void) -{ - // TODO + + /* First try to enlarge some existing area */ + heap_area_t *area; + for (area = first_heap_area; area != NULL; area = area->next) { + if (area_grow(area, size)) + return true; + } + + /* Eventually try to create a new area */ + return area_create(AREA_FIRST_BLOCK(size)); +} + +/** Try to shrink heap space + * + * In all cases the next pointer is reset. + * + */ +static void heap_shrink(void) +{ + next = NULL; } /** Initialize the heap allocator * - * Find how much physical memory we have and create - * the heap management structures that mark the whole - * physical memory as a single free block. - * - */ -void __heap_init(void) -{ - futex_down(&malloc_futex); - - if (as_area_create((void *) &_heap, PAGE_SIZE, - AS_AREA_WRITE | AS_AREA_READ)) { - heap_pages = 1; - heap_start = (void *) ALIGN_UP((uintptr_t) &_heap, BASE_ALIGN); - heap_end = - (void *) ALIGN_DOWN(((uintptr_t) &_heap) + PAGE_SIZE, BASE_ALIGN); - - /* Make the entire area one large block. */ - block_init(heap_start, heap_end - heap_start, true); - } - - futex_up(&malloc_futex); -} - -/** Get maximum heap address - * - */ -uintptr_t get_max_heap_addr(void) -{ - futex_down(&malloc_futex); - - if (max_heap_size == (size_t) -1) - max_heap_size = - max((size_t) (heap_end - heap_start), MAX_HEAP_SIZE); - - uintptr_t max_heap_addr = (uintptr_t) heap_start + max_heap_size; - - futex_up(&malloc_futex); - - return max_heap_addr; + * Create initial heap memory area. This routine is + * only called from libc initialization, thus we do not + * take any locks. + * + */ +void __malloc_init(void) +{ + if (!area_create(PAGE_SIZE)) + abort(); } @@ -275,6 +369,6 @@ /* Block big enough -> split. */ void *next = ((void *) cur) + size; - block_init(next, cur->size - size, true); - block_init(cur, size, false); + block_init(next, cur->size - size, true, cur->area); + block_init(cur, size, false, cur->area); } else { /* Block too small -> use as is. */ @@ -283,43 +377,53 @@ } -/** Allocate a memory block +/** Allocate memory from heap area starting from given block * * Should be called only inside the critical section. - * - * @param size The size of the block to allocate. - * @param align Memory address alignment. - * - * @return the address of the block or NULL when not enough memory. - * - */ -static void *malloc_internal(const size_t size, const size_t align) -{ - if (align == 0) - return NULL; - - size_t falign = lcm(align, BASE_ALIGN); - size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign)); - - bool grown = false; - void *result; - -loop: - result = NULL; - heap_block_head_t *cur = (heap_block_head_t *) heap_start; - - while ((result == NULL) && ((void *) cur < heap_end)) { + * As a side effect this function also sets the current + * pointer on successful allocation. + * + * @param area Heap area where to allocate from. + * @param first_block Starting heap block. + * @param final_block Heap block where to finish the search + * (may be NULL). + * @param real_size Gross number of bytes to allocate. + * @param falign Physical alignment of the block. + * + * @return Address of the allocated block or NULL on not enough memory. + * + */ +static void *malloc_area(heap_area_t *area, heap_block_head_t *first_block, + heap_block_head_t *final_block, size_t real_size, size_t falign) +{ + area_check((void *) area); + assert((void *) first_block >= (void *) AREA_FIRST_BLOCK(area)); + assert((void *) first_block < area->end); + + heap_block_head_t *cur; + for (cur = first_block; (void *) cur < area->end; + cur = (heap_block_head_t *) (((void *) cur) + cur->size)) { block_check(cur); + + /* Finish searching on the final block */ + if ((final_block != NULL) && (cur == final_block)) + break; /* Try to find a block that is free and large enough. */ if ((cur->free) && (cur->size >= real_size)) { - /* We have found a suitable block. - Check for alignment properties. */ - void *addr = ((void *) cur) + sizeof(heap_block_head_t); - void *aligned = (void *) ALIGN_UP(addr, falign); + /* + * We have found a suitable block. + * Check for alignment properties. + */ + void *addr = (void *) + ((uintptr_t) cur + sizeof(heap_block_head_t)); + void *aligned = (void *) + ALIGN_UP((uintptr_t) addr, falign); if (addr == aligned) { /* Exact block start including alignment. */ split_mark(cur, real_size); - result = addr; + + next = cur; + return addr; } else { /* Block start has to be aligned */ @@ -327,15 +431,19 @@ if (cur->size >= real_size + excess) { - /* The current block is large enough to fit - data in including alignment */ - if ((void *) cur > heap_start) { - /* There is a block before the current block. - This previous block can be enlarged to compensate - for the alignment excess */ - heap_block_foot_t *prev_foot = - ((void *) cur) - sizeof(heap_block_foot_t); + /* + * The current block is large enough to fit + * data in (including alignment). + */ + if ((void *) cur > (void *) AREA_FIRST_BLOCK(area)) { + /* + * There is a block before the current block. + * This previous block can be enlarged to + * compensate for the alignment excess. + */ + heap_block_foot_t *prev_foot = (heap_block_foot_t *) + ((void *) cur - sizeof(heap_block_foot_t)); - heap_block_head_t *prev_head = - (heap_block_head_t *) (((void *) cur) - prev_foot->size); + heap_block_head_t *prev_head = (heap_block_head_t *) + ((void *) cur - prev_foot->size); block_check(prev_head); @@ -344,25 +452,38 @@ heap_block_head_t *next_head = ((void *) cur) + excess; - if ((!prev_head->free) && (excess >= STRUCT_OVERHEAD)) { - /* The previous block is not free and there is enough - space to fill in a new free block between the previous - and current block */ - block_init(cur, excess, true); + if ((!prev_head->free) && + (excess >= STRUCT_OVERHEAD)) { + /* + * The previous block is not free and there + * is enough free space left to fill in + * a new free block between the previous + * and current block. + */ + block_init(cur, excess, true, area); } else { - /* The previous block is free (thus there is no need to - induce additional fragmentation to the heap) or the - excess is small, thus just enlarge the previous block */ - block_init(prev_head, prev_head->size + excess, prev_head->free); + /* + * The previous block is free (thus there + * is no need to induce additional + * fragmentation to the heap) or the + * excess is small. Therefore just enlarge + * the previous block. + */ + block_init(prev_head, prev_head->size + excess, + prev_head->free, area); } - block_init(next_head, reduced_size, true); + block_init(next_head, reduced_size, true, area); split_mark(next_head, real_size); - result = aligned; - cur = next_head; + + next = next_head; + return aligned; } else { - /* The current block is the first block on the heap. - We have to make sure that the alignment excess - is large enough to fit a new free block just - before the current block */ + /* + * The current block is the first block + * in the heap area. We have to make sure + * that the alignment excess is large enough + * to fit a new free block just before the + * current block. + */ while (excess < STRUCT_OVERHEAD) { aligned += falign; @@ -373,10 +494,14 @@ if (cur->size >= real_size + excess) { size_t reduced_size = cur->size - excess; - cur = (heap_block_head_t *) (heap_start + excess); + cur = (heap_block_head_t *) + (AREA_FIRST_BLOCK(area) + excess); - block_init(heap_start, excess, true); - block_init(cur, reduced_size, true); + block_init((void *) AREA_FIRST_BLOCK(area), excess, + true, area); + block_init(cur, reduced_size, true, area); split_mark(cur, real_size); - result = aligned; + + next = cur; + return aligned; } } @@ -384,17 +509,67 @@ } } - - /* Advance to the next block. */ - cur = (heap_block_head_t *) (((void *) cur) + cur->size); - } - - if ((result == NULL) && (!grown)) { - if (grow_heap(real_size)) { - grown = true; + } + + return NULL; +} + +/** Allocate a memory block + * + * Should be called only inside the critical section. + * + * @param size The size of the block to allocate. + * @param align Memory address alignment. + * + * @return Address of the allocated block or NULL on not enough memory. + * + */ +static void *malloc_internal(const size_t size, const size_t align) +{ + assert(first_heap_area != NULL); + + if (align == 0) + return NULL; + + size_t falign = lcm(align, BASE_ALIGN); + size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign)); + + bool retry = false; + heap_block_head_t *split; + +loop: + + /* Try the next fit approach */ + split = next; + + if (split != NULL) { + void *addr = malloc_area(split->area, split, NULL, real_size, + falign); + + if (addr != NULL) + return addr; + } + + /* Search the entire heap */ + heap_area_t *area; + for (area = first_heap_area; area != NULL; area = area->next) { + heap_block_head_t *first = (heap_block_head_t *) + AREA_FIRST_BLOCK(area); + + void *addr = malloc_area(area, first, split, real_size, + falign); + + if (addr != NULL) + return addr; + } + + if (!retry) { + /* Try to grow the heap space */ + if (heap_grow(real_size)) { + retry = true; goto loop; } } - return result; + return NULL; } @@ -475,9 +650,12 @@ (heap_block_head_t *) (addr - sizeof(heap_block_head_t)); - assert((void *) head >= heap_start); - assert((void *) head < heap_end); - block_check(head); assert(!head->free); + + heap_area_t *area = head->area; + + area_check(area); + assert((void *) head >= (void *) AREA_FIRST_BLOCK(area)); + assert((void *) head < area->end); void *ptr = NULL; @@ -489,29 +667,34 @@ /* Shrink */ if (orig_size - real_size >= STRUCT_OVERHEAD) { - /* Split the original block to a full block - and a trailing free block */ - block_init((void *) head, real_size, false); + /* + * Split the original block to a full block + * and a trailing free block. + */ + block_init((void *) head, real_size, false, area); block_init((void *) head + real_size, - orig_size - real_size, true); - shrink_heap(); + orig_size - real_size, true, area); + heap_shrink(); } ptr = ((void *) head) + sizeof(heap_block_head_t); } else { - /* Look at the next block. If it is free and the size is - sufficient then merge the two. Otherwise just allocate - a new block, copy the original data into it and - free the original block. */ + /* + * Look at the next block. If it is free and the size is + * sufficient then merge the two. Otherwise just allocate + * a new block, copy the original data into it and + * free the original block. + */ heap_block_head_t *next_head = (heap_block_head_t *) (((void *) head) + head->size); - if (((void *) next_head < heap_end) && + if (((void *) next_head < area->end) && (head->size + next_head->size >= real_size) && (next_head->free)) { block_check(next_head); - block_init(head, head->size + next_head->size, false); + block_init(head, head->size + next_head->size, false, area); split_mark(head, real_size); ptr = ((void *) head) + sizeof(heap_block_head_t); + next = NULL; } else reloc = true; @@ -544,9 +727,12 @@ = (heap_block_head_t *) (addr - sizeof(heap_block_head_t)); - assert((void *) head >= heap_start); - assert((void *) head < heap_end); - block_check(head); assert(!head->free); + + heap_area_t *area = head->area; + + area_check(area); + assert((void *) head >= (void *) AREA_FIRST_BLOCK(area)); + assert((void *) head < area->end); /* Mark the block itself as free. */ @@ -557,12 +743,12 @@ = (heap_block_head_t *) (((void *) head) + head->size); - if ((void *) next_head < heap_end) { + if ((void *) next_head < area->end) { block_check(next_head); if (next_head->free) - block_init(head, head->size + next_head->size, true); + block_init(head, head->size + next_head->size, true, area); } /* Look at the previous block. If it is free, merge the two. */ - if ((void *) head > heap_start) { + if ((void *) head > (void *) AREA_FIRST_BLOCK(area)) { heap_block_foot_t *prev_foot = (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t)); @@ -574,8 +760,9 @@ if (prev_head->free) - block_init(prev_head, prev_head->size + head->size, true); - } - - shrink_heap(); + block_init(prev_head, prev_head->size + head->size, true, + area); + } + + heap_shrink(); futex_up(&malloc_futex); Index: uspace/lib/c/generic/net/icmp_api.c =================================================================== --- uspace/lib/c/generic/net/icmp_api.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/net/icmp_api.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,11 +41,8 @@ #include #include - #include #include #include #include - -#include #include #include Index: uspace/lib/c/generic/net/modules.c =================================================================== --- uspace/lib/c/generic/net/modules.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/net/modules.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -43,8 +43,5 @@ #include #include - -#include #include - #include @@ -67,21 +64,21 @@ switch (count) { case 0: - ipc_answer_0(callid, (sysarg_t) result); + async_answer_0(callid, (sysarg_t) result); break; case 1: - ipc_answer_1(callid, (sysarg_t) result, + async_answer_1(callid, (sysarg_t) result, IPC_GET_ARG1(*answer)); break; case 2: - ipc_answer_2(callid, (sysarg_t) result, + async_answer_2(callid, (sysarg_t) result, IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer)); break; case 3: - ipc_answer_3(callid, (sysarg_t) result, + async_answer_3(callid, (sysarg_t) result, IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer)); break; case 4: - ipc_answer_4(callid, (sysarg_t) result, + async_answer_4(callid, (sysarg_t) result, IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer)); @@ -89,5 +86,5 @@ case 5: default: - ipc_answer_5(callid, (sysarg_t) result, + async_answer_5(callid, (sysarg_t) result, IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer), @@ -137,21 +134,13 @@ sysarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout) { - int rc; - /* Connect to the needed service */ int phone = connect_to_service_timeout(need, timeout); if (phone >= 0) { /* Request the bidirectional connection */ - sysarg_t taskhash; - sysarg_t phonehash; - - rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &taskhash, - &phonehash); + int rc = async_connect_to_me(phone, arg1, arg2, arg3, client_receiver); if (rc != EOK) { - ipc_hangup(phone); + async_hangup(phone); return rc; } - async_new_connection(taskhash, phonehash, 0, NULL, - client_receiver); } Index: uspace/lib/c/generic/net/socket_client.c =================================================================== --- uspace/lib/c/generic/net/socket_client.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/net/socket_client.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -43,8 +43,7 @@ #include #include - +#include #include #include - #include #include @@ -278,5 +277,5 @@ } - ipc_answer_0(callid, (sysarg_t) rc); + async_answer_0(callid, (sysarg_t) rc); goto loop; } @@ -687,5 +686,5 @@ /* Read address */ - ipc_data_read_start(socket->phone, cliaddr, *addrlen); + async_data_read_start(socket->phone, cliaddr, *addrlen); fibril_rwlock_write_unlock(&socket_globals.lock); async_wait_for(message_id, &ipc_result); Index: uspace/lib/c/generic/private/async.h =================================================================== --- uspace/lib/c/generic/private/async.h (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/generic/private/async.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_ASYNC_H_ +#define LIBC_PRIVATE_ASYNC_H_ + +#include +#include +#include +#include + +/** Structures of this type are used to track the timeout events. */ +typedef struct { + /** If true, this struct is in the timeout list. */ + bool inlist; + + /** Timeout list link. */ + link_t link; + + /** If true, we have timed out. */ + bool occurred; + + /** Expiration time. */ + struct timeval expires; +} to_event_t; + +/** Structures of this type are used to track the wakeup events. */ +typedef struct { + /** If true, this struct is in a synchronization object wait queue. */ + bool inlist; + + /** Wait queue linkage. */ + link_t link; +} wu_event_t; + +/** Structures of this type represent a waiting fibril. */ +typedef struct { + /** Identification of and link to the waiting fibril. */ + fid_t fid; + + /** If true, this fibril is currently active. */ + bool active; + + /** Timeout wait data. */ + to_event_t to_event; + /** Wakeup wait data. */ + wu_event_t wu_event; +} awaiter_t; + +extern void __async_init(void); +extern void async_insert_timeout(awaiter_t *); + +#endif + +/** @} + */ Index: uspace/lib/c/generic/private/async_sess.h =================================================================== --- uspace/lib/c/generic/private/async_sess.h (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/generic/private/async_sess.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_ASYNC_SESS_H_ +#define LIBC_PRIVATE_ASYNC_SESS_H_ + +extern void __async_sess_init(void); + +#endif + +/** @} + */ Index: uspace/lib/c/generic/private/io.h =================================================================== --- uspace/lib/c/generic/private/io.h (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/generic/private/io.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_IO_H_ +#define LIBC_PRIVATE_IO_H_ + +#include + +extern void __stdio_init(int filc, fdi_node_t *filv[]); +extern void __stdio_done(void); + +#endif + +/** @} + */ Index: uspace/lib/c/generic/private/libc.h =================================================================== --- uspace/lib/c/generic/private/libc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/generic/private/libc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_LIBC_H_ +#define LIBC_PRIVATE_LIBC_H_ + +extern void __entry(void); +extern void __main(void *) __attribute__((noreturn)); +extern int main(int, char *[]); + +#endif + +/** @} + */ Index: uspace/lib/c/generic/private/malloc.h =================================================================== --- uspace/lib/c/generic/private/malloc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/generic/private/malloc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_MALLOC_H_ +#define LIBC_PRIVATE_MALLOC_H_ + +extern void __malloc_init(void); + +#endif + +/** @} + */ Index: uspace/lib/c/generic/private/thread.h =================================================================== --- uspace/lib/c/generic/private/thread.h (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/generic/private/thread.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_PRIVATE_THREAD_H_ +#define LIBC_PRIVATE_THREAD_H_ + +#include + +extern void __thread_entry(void); +extern void __thread_main(uspace_arg_t *); + +#endif + +/** @} + */ Index: uspace/lib/c/generic/thread.c =================================================================== --- uspace/lib/c/generic/thread.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/thread.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -31,5 +31,5 @@ */ /** @file - */ + */ #include @@ -41,4 +41,5 @@ #include #include +#include "private/thread.h" #ifndef THREAD_INITIAL_STACK_PAGES_NO @@ -50,25 +51,27 @@ * This function is called from __thread_entry() and is used * to call the thread's implementing function and perform cleanup - * and exit when thread returns back. Do not call this function - * directly. + * and exit when thread returns back. * * @param uarg Pointer to userspace argument structure. + * */ void __thread_main(uspace_arg_t *uarg) { - fibril_t *f; - - f = fibril_setup(); - __tcb_set(f->tcb); - + fibril_t *fibril = fibril_setup(); + if (fibril == NULL) + thread_exit(0); + + __tcb_set(fibril->tcb); + uarg->uspace_thread_function(uarg->uspace_thread_arg); - /* XXX: we cannot free the userspace stack while running on it */ -// free(uarg->uspace_stack); -// free(uarg); - + /* XXX: we cannot free the userspace stack while running on it + free(uarg->uspace_stack); + free(uarg); + */ + /* If there is a manager, destroy it */ async_destroy_manager(); - fibril_teardown(f); - + fibril_teardown(fibril); + thread_exit(0); } @@ -127,10 +130,12 @@ * * @param status Exit status. Currently not used. + * */ void thread_exit(int status) { __SYSCALL1(SYS_THREAD_EXIT, (sysarg_t) status); - for (;;) - ; + + /* Unreachable */ + while (1); } Index: uspace/lib/c/generic/time.c =================================================================== --- uspace/lib/c/generic/time.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/time.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -34,21 +34,15 @@ #include -#include -#include -#include +#include +#include #include -#include -#include -#include -#include -#include - +#include +#include #include #include #include - -#include - -/* Pointers to public variables with time */ +#include + +/** Pointer to kernel shared variables with time */ struct { volatile sysarg_t seconds1; @@ -59,6 +53,7 @@ /** Add microseconds to given timeval. * - * @param tv Destination timeval. - * @param usecs Number of microseconds to add. + * @param tv Destination timeval. + * @param usecs Number of microseconds to add. + * */ void tv_add(struct timeval *tv, suseconds_t usecs) @@ -66,4 +61,5 @@ tv->tv_sec += usecs / 1000000; tv->tv_usec += usecs % 1000000; + if (tv->tv_usec > 1000000) { tv->tv_sec++; @@ -74,104 +70,117 @@ /** Subtract two timevals. * - * @param tv1 First timeval. - * @param tv2 Second timeval. - * - * @return Return difference between tv1 and tv2 (tv1 - tv2) in - * microseconds. + * @param tv1 First timeval. + * @param tv2 Second timeval. + * + * @return Difference between tv1 and tv2 (tv1 - tv2) in + * microseconds. + * */ suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2) { - suseconds_t result; - - result = tv1->tv_usec - tv2->tv_usec; - result += (tv1->tv_sec - tv2->tv_sec) * 1000000; - - return result; + return (tv1->tv_usec - tv2->tv_usec) + + ((tv1->tv_sec - tv2->tv_sec) * 1000000); } /** Decide if one timeval is greater than the other. * - * @param t1 First timeval. - * @param t2 Second timeval. - * - * @return Return true tv1 is greater than tv2. Otherwise return - * false. + * @param t1 First timeval. + * @param t2 Second timeval. + * + * @return True if tv1 is greater than tv2. + * @return False otherwise. + * */ int tv_gt(struct timeval *tv1, struct timeval *tv2) { if (tv1->tv_sec > tv2->tv_sec) - return 1; - if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec > tv2->tv_usec) - return 1; - return 0; + return true; + + if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec > tv2->tv_usec)) + return true; + + return false; } /** Decide if one timeval is greater than or equal to the other. * - * @param tv1 First timeval. - * @param tv2 Second timeval. - * - * @return Return true if tv1 is greater than or equal to tv2. - * Otherwise return false. + * @param tv1 First timeval. + * @param tv2 Second timeval. + * + * @return True if tv1 is greater than or equal to tv2. + * @return False otherwise. + * */ int tv_gteq(struct timeval *tv1, struct timeval *tv2) { if (tv1->tv_sec > tv2->tv_sec) - return 1; - if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec >= tv2->tv_usec) - return 1; - return 0; -} - - -/** POSIX gettimeofday - * - * The time variables are memory mapped(RO) from kernel, which updates - * them periodically. As it is impossible to read 2 values atomically, we - * use a trick: First read a seconds, then read microseconds, then - * read seconds again. If a second elapsed in the meantime, set it to zero. - * This provides assurance, that at least the - * sequence of subsequent gettimeofday calls is ordered. + return true; + + if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec >= tv2->tv_usec)) + return true; + + return false; +} + +/** Get time of day + * + * The time variables are memory mapped (read-only) from kernel which + * updates them periodically. + * + * As it is impossible to read 2 values atomically, we use a trick: + * First we read the seconds, then we read the microseconds, then we + * read the seconds again. If a second elapsed in the meantime, set + * the microseconds to zero. + * + * This assures that the values returned by two subsequent calls + * to gettimeofday() are monotonous. + * */ int gettimeofday(struct timeval *tv, struct timezone *tz) { - void *mapping; - sysarg_t s1, s2; - int rights; - int res; - - if (!ktime) { - mapping = as_get_mappable_page(PAGE_SIZE); - /* Get the mapping of kernel clock */ - res = ipc_share_in_start_1_1(PHONE_NS, mapping, PAGE_SIZE, - SERVICE_MEM_REALTIME, &rights); - if (res) { - printf("Failed to initialize timeofday memarea\n"); - _exit(1); + if (ktime == NULL) { + uintptr_t faddr; + int rc = sysinfo_get_value("clock.faddr", &faddr); + if (rc != EOK) { + errno = rc; + return -1; } - if (!(rights & AS_AREA_READ)) { - printf("Received bad rights on time area: %X\n", - rights); - as_area_destroy(mapping); - _exit(1); + + void *addr = as_get_mappable_page(PAGE_SIZE); + if (addr == NULL) { + errno = ENOMEM; + return -1; } - ktime = mapping; - } + + rc = physmem_map((void *) faddr, addr, 1, + AS_AREA_READ | AS_AREA_CACHEABLE); + if (rc != EOK) { + as_area_destroy(addr); + errno = rc; + return -1; + } + + ktime = addr; + } + if (tz) { tz->tz_minuteswest = 0; tz->tz_dsttime = DST_NONE; } - - s2 = ktime->seconds2; + + sysarg_t s2 = ktime->seconds2; + read_barrier(); tv->tv_usec = ktime->useconds; + read_barrier(); - s1 = ktime->seconds1; + sysarg_t s1 = ktime->seconds1; + if (s1 != s2) { + tv->tv_sec = max(s1, s2); tv->tv_usec = 0; - tv->tv_sec = s1 > s2 ? s1 : s2; } else tv->tv_sec = s1; - + return 0; } @@ -180,13 +189,16 @@ { struct timeval tv; - if (gettimeofday(&tv, NULL)) return (time_t) -1; + if (tloc) *tloc = tv.tv_sec; + return tv.tv_sec; } -/** Wait unconditionally for specified number of microseconds */ +/** Wait unconditionally for specified number of microseconds + * + */ int usleep(useconds_t usec) { @@ -195,15 +207,21 @@ } -/** Wait unconditionally for specified number of seconds */ +/** Wait unconditionally for specified number of seconds + * + */ unsigned int sleep(unsigned int sec) { - /* Sleep in 1000 second steps to support - full argument range */ + /* + * Sleep in 1000 second steps to support + * full argument range + */ + while (sec > 0) { unsigned int period = (sec > 1000) ? 1000 : sec; - + usleep(period * 1000000); sec -= period; } + return 0; } Index: uspace/lib/c/generic/udebug.c =================================================================== --- uspace/lib/c/generic/udebug.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/udebug.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -31,9 +31,8 @@ */ /** @file - */ + */ #include #include -#include #include Index: uspace/lib/c/generic/vfs/vfs.c =================================================================== --- uspace/lib/c/generic/vfs/vfs.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/generic/vfs/vfs.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -1,4 +1,4 @@ /* - * Copyright (c) 2008 Jakub Jermar + * Copyright (c) 2008 Jakub Jermar * All rights reserved. * @@ -43,6 +43,6 @@ #include #include -#include #include +#include #include #include @@ -118,8 +118,6 @@ static void vfs_connect(void) { - while (vfs_phone < 0) { - vfs_phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, - 0, 0); - } + while (vfs_phone < 0) + vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0); async_session_create(&vfs_session, vfs_phone, 0); Index: uspace/lib/c/include/as.h =================================================================== --- uspace/lib/c/include/as.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/as.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,4 +41,17 @@ #include +static inline size_t SIZE2PAGES(size_t size) +{ + if (size == 0) + return 0; + + return (size_t) ((size - 1) >> PAGE_WIDTH) + 1; +} + +static inline size_t PAGES2SIZE(size_t pages) +{ + return (size_t) (pages << PAGE_WIDTH); +} + extern void *as_area_create(void *address, size_t size, int flags); extern int as_area_resize(void *address, size_t size, int flags); Index: uspace/lib/c/include/assert.h =================================================================== --- uspace/lib/c/include/assert.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/assert.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -57,6 +57,4 @@ printf("Assertion failed (%s) at file '%s', " \ "line %d.\n", #expr, __FILE__, __LINE__); \ - stacktrace_print(); \ - core(); \ abort(); \ } \ Index: uspace/lib/c/include/async.h =================================================================== --- uspace/lib/c/include/async.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/async.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,8 +33,12 @@ */ +#if ((defined(LIBC_IPC_H_)) && (!defined(LIBC_ASYNC_C_))) + #error Do not intermix low-level IPC interface and async framework +#endif + #ifndef LIBC_ASYNC_H_ #define LIBC_ASYNC_H_ -#include +#include #include #include @@ -42,4 +46,5 @@ #include #include +#include typedef ipc_callid_t aid_t; @@ -50,20 +55,13 @@ typedef void (*async_client_conn_t)(ipc_callid_t, ipc_call_t *); -extern atomic_t async_futex; - extern atomic_t threads_in_ipc_wait; -extern int __async_init(void); +#define async_manager() \ + fibril_switch(FIBRIL_TO_MANAGER) + +#define async_get_call(data) \ + async_get_call_timeout(data, 0) + extern ipc_callid_t async_get_call_timeout(ipc_call_t *, suseconds_t); - -static inline ipc_callid_t async_get_call(ipc_call_t *data) -{ - return async_get_call_timeout(data, 0); -} - -static inline void async_manager(void) -{ - fibril_switch(FIBRIL_TO_MANAGER); -} /* @@ -110,22 +108,38 @@ extern void async_set_interrupt_received(async_client_conn_t); -/* Wrappers for simple communication */ -#define async_msg_0(phone, method) \ - ipc_call_async_0((phone), (method), NULL, NULL, true) -#define async_msg_1(phone, method, arg1) \ - ipc_call_async_1((phone), (method), (arg1), NULL, NULL, \ - true) -#define async_msg_2(phone, method, arg1, arg2) \ - ipc_call_async_2((phone), (method), (arg1), (arg2), NULL, NULL, \ - true) -#define async_msg_3(phone, method, arg1, arg2, arg3) \ - ipc_call_async_3((phone), (method), (arg1), (arg2), (arg3), NULL, NULL, \ - true) -#define async_msg_4(phone, method, arg1, arg2, arg3, arg4) \ - ipc_call_async_4((phone), (method), (arg1), (arg2), (arg3), (arg4), NULL, \ - NULL, true) -#define async_msg_5(phone, method, arg1, arg2, arg3, arg4, arg5) \ - ipc_call_async_5((phone), (method), (arg1), (arg2), (arg3), (arg4), \ - (arg5), NULL, NULL, true) +/* + * Wrappers for simple communication. + */ + +extern void async_msg_0(int, sysarg_t); +extern void async_msg_1(int, sysarg_t, sysarg_t); +extern void async_msg_2(int, sysarg_t, sysarg_t, sysarg_t); +extern void async_msg_3(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t); +extern void async_msg_4(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t); +extern void async_msg_5(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, + sysarg_t); + +/* + * Wrappers for answer routines. + */ + +extern sysarg_t async_answer_0(ipc_callid_t, sysarg_t); +extern sysarg_t async_answer_1(ipc_callid_t, sysarg_t, sysarg_t); +extern sysarg_t async_answer_2(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t); +extern sysarg_t async_answer_3(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t, + sysarg_t); +extern sysarg_t async_answer_4(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t); +extern sysarg_t async_answer_5(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t); + +/* + * Wrappers for forwarding routines. + */ + +extern int async_forward_fast(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t, + unsigned int); +extern int async_forward_slow(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, unsigned int); /* @@ -135,4 +149,5 @@ * and slow verion based on m. */ + #define async_req_0_0(phoneid, method) \ async_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \ @@ -266,10 +281,16 @@ } +extern int async_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, + async_client_conn_t); extern int async_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t); extern int async_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t); +extern int async_connect_kbox(task_id_t); +extern int async_hangup(int); +extern void async_poke(void); /* * User-friendly wrappers for async_share_in_start(). */ + #define async_share_in_start_0_0(phoneid, dst, size) \ async_share_in_start((phoneid), (dst), (size), 0, NULL) @@ -281,9 +302,10 @@ async_share_in_start((phoneid), (dst), (size), (arg), (flags)) -extern int async_share_in_start(int, void *, size_t, sysarg_t, int *); -extern int async_share_in_receive(ipc_callid_t *, size_t *); -extern int async_share_in_finalize(ipc_callid_t, void *, int ); -extern int async_share_out_start(int, void *, int); -extern int async_share_out_receive(ipc_callid_t *, size_t *, int *); +extern int async_share_in_start(int, void *, size_t, sysarg_t, unsigned int *); +extern bool async_share_in_receive(ipc_callid_t *, size_t *); +extern int async_share_in_finalize(ipc_callid_t, void *, unsigned int); + +extern int async_share_out_start(int, void *, unsigned int); +extern bool async_share_out_receive(ipc_callid_t *, size_t *, unsigned int *); extern int async_share_out_finalize(ipc_callid_t, void *); @@ -291,4 +313,5 @@ * User-friendly wrappers for async_data_read_forward_fast(). */ + #define async_data_read_forward_0_0(phoneid, method, answer) \ async_data_read_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL) @@ -318,5 +341,5 @@ extern int async_data_read_start(int, void *, size_t); -extern int async_data_read_receive(ipc_callid_t *, size_t *); +extern bool async_data_read_receive(ipc_callid_t *, size_t *); extern int async_data_read_finalize(ipc_callid_t, const void *, size_t); @@ -327,4 +350,5 @@ * User-friendly wrappers for async_data_write_forward_fast(). */ + #define async_data_write_forward_0_0(phoneid, method, answer) \ async_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL) @@ -356,10 +380,10 @@ extern int async_data_write_start(int, const void *, size_t); -extern int async_data_write_receive(ipc_callid_t *, size_t *); +extern bool async_data_write_receive(ipc_callid_t *, size_t *); extern int async_data_write_finalize(ipc_callid_t, void *, size_t); extern int async_data_write_accept(void **, const bool, const size_t, const size_t, const size_t, size_t *); -extern void async_data_write_void(const int); +extern void async_data_write_void(sysarg_t); extern int async_data_write_forward_fast(int, sysarg_t, sysarg_t, sysarg_t, Index: uspace/lib/c/include/async_priv.h =================================================================== --- uspace/lib/c/include/async_priv.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ (revision ) @@ -1,87 +1,0 @@ -/* - * Copyright (c) 2006 Ondrej Palkovsky - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup libc - * @{ - */ -/** @file - */ - -#ifndef LIBC_ASYNC_PRIV_H_ -#define LIBC_ASYNC_PRIV_H_ - -#include -#include -#include -#include - -/** Structures of this type are used to track the timeout events. */ -typedef struct { - /** If true, this struct is in the timeout list. */ - bool inlist; - - /** Timeout list link. */ - link_t link; - - /** If true, we have timed out. */ - bool occurred; - - /** Expiration time. */ - struct timeval expires; -} to_event_t; - -/** Structures of this type are used to track the wakeup events. */ -typedef struct { - /** If true, this struct is in a synchronization object wait queue. */ - bool inlist; - - /** Wait queue linkage. */ - link_t link; -} wu_event_t; - - -/** Structures of this type represent a waiting fibril. */ -typedef struct { - /** Identification of and link to the waiting fibril. */ - fid_t fid; - - /** If true, this fibril is currently active. */ - bool active; - - /** Timeout wait data. */ - to_event_t to_event; - /** Wakeup wait data. */ - wu_event_t wu_event; -} awaiter_t; - -extern void async_insert_timeout(awaiter_t *wd); - -#endif - -/** @} - */ Index: uspace/lib/c/include/async_sess.h =================================================================== --- uspace/lib/c/include/async_sess.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/async_sess.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -45,5 +45,4 @@ } async_sess_t; -extern void _async_sess_init(void); extern void async_session_create(async_sess_t *, int, sysarg_t); extern void async_session_destroy(async_sess_t *); Index: uspace/lib/c/include/byteorder.h =================================================================== --- uspace/lib/c/include/byteorder.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/byteorder.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -80,8 +80,8 @@ #endif -#define htons(n) host2uint16_t_be((n)) -#define htonl(n) host2uint32_t_be((n)) -#define ntohs(n) uint16_t_be2host((n)) -#define ntohl(n) uint32_t_be2host((n)) +#define htons(n) host2uint16_t_be((n)) +#define htonl(n) host2uint32_t_be((n)) +#define ntohs(n) uint16_t_be2host((n)) +#define ntohl(n) uint32_t_be2host((n)) static inline uint64_t uint64_t_byteorder_swap(uint64_t n) Index: uspace/lib/c/include/ddi.h =================================================================== --- uspace/lib/c/include/ddi.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ddi.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,4 +36,6 @@ #define LIBC_DDI_H_ +#include +#include #include @@ -42,4 +44,6 @@ extern int iospace_enable(task_id_t, void *, unsigned long); extern int pio_enable(void *, size_t, void **); +extern int register_irq(int, int, int, irq_code_t *); +extern int unregister_irq(int, int); #endif Index: uspace/lib/c/include/devman.h =================================================================== --- uspace/lib/c/include/devman.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/devman.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,5 +41,4 @@ #include - extern int devman_get_phone(devman_interface_t, unsigned int); extern void devman_hangup_phone(devman_interface_t); Index: uspace/lib/c/include/err.h =================================================================== --- uspace/lib/c/include/err.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/err.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,8 +39,8 @@ #define errx(status, fmt, ...) \ - { \ + do { \ printf((fmt), ##__VA_ARGS__); \ - _exit(status); \ - } + exit(status); \ + } while (0) #endif Index: uspace/lib/c/include/errno.h =================================================================== --- uspace/lib/c/include/errno.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/errno.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,7 +39,7 @@ #include +#define errno _errno + extern int _errno; - -#define errno _errno #define EMFILE (-18) @@ -57,36 +57,35 @@ /** An API function is called while another blocking function is in progress. */ -#define EINPROGRESS (-10036) +#define EINPROGRESS (-10036) /** The socket identifier is not valid. */ -#define ENOTSOCK (-10038) +#define ENOTSOCK (-10038) /** The destination address required. */ -#define EDESTADDRREQ (-10039) +#define EDESTADDRREQ (-10039) /** Protocol is not supported. */ -#define EPROTONOSUPPORT (-10043) +#define EPROTONOSUPPORT (-10043) /** Socket type is not supported. */ -#define ESOCKTNOSUPPORT (-10044) +#define ESOCKTNOSUPPORT (-10044) /** Protocol family is not supported. */ -#define EPFNOSUPPORT (-10046) +#define EPFNOSUPPORT (-10046) /** Address family is not supported. */ -#define EAFNOSUPPORT (-10047) +#define EAFNOSUPPORT (-10047) /** Address is already in use. */ -#define EADDRINUSE (-10048) +#define EADDRINUSE (-10048) /** The socket is not connected or bound. */ -#define ENOTCONN (-10057) +#define ENOTCONN (-10057) /** The requested operation was not performed. Try again later. */ -#define EAGAIN (-11002) +#define EAGAIN (-11002) -/** No data. - */ -#define NO_DATA (-11004) +/** No data. */ +#define NO_DATA (-11004) #endif Index: uspace/lib/c/include/event.h =================================================================== --- uspace/lib/c/include/event.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/event.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -37,5 +37,4 @@ #include -#include extern int event_subscribe(event_type_t, sysarg_t); Index: uspace/lib/c/include/io/console.h =================================================================== --- uspace/lib/c/include/io/console.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/io/console.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,4 @@ #define LIBC_IO_CONSOLE_H_ -#include #include Index: uspace/lib/c/include/io/screenbuffer.h =================================================================== --- uspace/lib/c/include/io/screenbuffer.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/io/screenbuffer.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,4 @@ #include #include -#include #include Index: uspace/lib/c/include/ipc/adb.h =================================================================== --- uspace/lib/c/include/ipc/adb.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/adb.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -32,15 +32,14 @@ /** @file * @brief ADB device interface. - */ + */ #ifndef LIBC_IPC_ADB_H_ #define LIBC_IPC_ADB_H_ -#include +#include typedef enum { ADB_REG_WRITE = IPC_FIRST_USER_METHOD } adb_request_t; - typedef enum { Index: uspace/lib/c/include/ipc/arp.h =================================================================== --- uspace/lib/c/include/ipc/arp.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/arp.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,5 +39,4 @@ #define LIBC_ARP_MESSAGES_ -#include #include Index: uspace/lib/c/include/ipc/bd.h =================================================================== --- uspace/lib/c/include/ipc/bd.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/bd.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -31,10 +31,10 @@ */ /** @file - */ + */ #ifndef LIBC_IPC_BD_H_ #define LIBC_IPC_BD_H_ -#include +#include typedef enum { Index: uspace/lib/c/include/ipc/char.h =================================================================== --- uspace/lib/c/include/ipc/char.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/char.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -32,15 +32,14 @@ /** @file * @brief Character device interface. - */ + */ #ifndef LIBC_IPC_CHAR_H_ #define LIBC_IPC_CHAR_H_ -#include +#include typedef enum { CHAR_WRITE_BYTE = IPC_FIRST_USER_METHOD } char_request_t; - typedef enum { Index: uspace/lib/c/include/ipc/clipboard.h =================================================================== --- uspace/lib/c/include/ipc/clipboard.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/clipboard.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,6 +36,4 @@ #define LIBC_IPC_CLIPBOARD_H_ -#include - typedef enum { CLIPBOARD_PUT_DATA = IPC_FIRST_USER_METHOD, Index: uspace/lib/c/include/ipc/common.h =================================================================== --- uspace/lib/c/include/ipc/common.h (revision 0397e5a488c166a87563157012b79e2195f21d04) +++ uspace/lib/c/include/ipc/common.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2011 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libcipc + * @{ + */ +/** @file + */ + +#ifndef LIBC_IPC_COMMON_H_ +#define LIBC_IPC_COMMON_H_ + +#include +#include +#include + +#define IPC_FLAG_BLOCKING 0x01 + +typedef struct { + sysarg_t args[IPC_CALL_LEN]; + sysarg_t in_task_hash; + sysarg_t in_phone_hash; +} ipc_call_t; + +typedef sysarg_t ipc_callid_t; + +extern atomic_t async_futex; + +#endif + +/** @} + */ Index: uspace/lib/c/include/ipc/console.h =================================================================== --- uspace/lib/c/include/ipc/console.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/console.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,4 @@ #define LIBC_IPC_CONSOLE_H_ -#include #include Index: uspace/lib/c/include/ipc/dev_iface.h =================================================================== --- uspace/lib/c/include/ipc/dev_iface.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/dev_iface.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -30,5 +30,4 @@ #define LIBC_IPC_DEV_IFACE_H_ -#include #include #include Index: uspace/lib/c/include/ipc/devman.h =================================================================== --- uspace/lib/c/include/ipc/devman.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/devman.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -30,15 +30,14 @@ * @{ */ - + #ifndef LIBC_IPC_DEVMAN_H_ #define LIBC_IPC_DEVMAN_H_ +#include #include -#include -#include -#include -#include +#include +#include -#define DEVMAN_NAME_MAXLEN 256 +#define DEVMAN_NAME_MAXLEN 256 typedef sysarg_t devman_handle_t; @@ -67,6 +66,5 @@ } match_id_list_t; - -static inline match_id_t * create_match_id() +static inline match_id_t *create_match_id(void) { match_id_t *id = malloc(sizeof(match_id_t)); @@ -85,8 +83,8 @@ } -static inline void add_match_id(match_id_list_t *ids, match_id_t *id) +static inline void add_match_id(match_id_list_t *ids, match_id_t *id) { match_id_t *mid = NULL; - link_t *link = ids->ids.next; + link_t *link = ids->ids.next; while (link != &ids->ids) { @@ -98,5 +96,5 @@ } - list_insert_before(&id->link, link); + list_insert_before(&id->link, link); } Index: uspace/lib/c/include/ipc/devmap.h =================================================================== --- uspace/lib/c/include/ipc/devmap.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/devmap.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -34,7 +34,5 @@ #define DEVMAP_DEVMAP_H_ -#include -#include -#include +#include #define DEVMAP_NAME_MAXLEN 255 Index: uspace/lib/c/include/ipc/fb.h =================================================================== --- uspace/lib/c/include/ipc/fb.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/fb.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -31,10 +31,10 @@ */ /** @file - */ + */ #ifndef LIBC_FB_H_ #define LIBC_FB_H_ -#include +#include typedef enum { Index: uspace/lib/c/include/ipc/icmp.h =================================================================== --- uspace/lib/c/include/ipc/icmp.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/icmp.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,9 +39,7 @@ #define LIBC_ICMP_MESSAGES_ -#include #include #include #include - #include Index: uspace/lib/c/include/ipc/il.h =================================================================== --- uspace/lib/c/include/ipc/il.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/il.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -40,5 +40,4 @@ #define LIBC_IL_MESSAGES_H_ -#include #include Index: uspace/lib/c/include/ipc/ip.h =================================================================== --- uspace/lib/c/include/ipc/ip.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/ip.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,7 +39,5 @@ #define LIBC_IP_MESSAGES_H_ -#include #include - #include #include Index: uspace/lib/c/include/ipc/ipc.h =================================================================== --- uspace/lib/c/include/ipc/ipc.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/ipc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,24 +33,17 @@ */ -#ifndef LIBIPC_IPC_H_ -#define LIBIPC_IPC_H_ - +#if ((defined(LIBC_ASYNC_H_)) && (!defined(LIBC_ASYNC_C_))) + #error Do not intermix low-level IPC interface and async framework +#endif + +#ifndef LIBC_IPC_H_ +#define LIBC_IPC_H_ + +#include +#include +#include #include -#include -#include -#include -#include - -#define IPC_FLAG_BLOCKING 0x01 - -typedef struct { - sysarg_t args[IPC_CALL_LEN]; - sysarg_t in_task_hash; - sysarg_t in_phone_hash; -} ipc_call_t; - -typedef sysarg_t ipc_callid_t; - -typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *); + +typedef void (*ipc_async_callback_t)(void *, int, ipc_call_t *); /* @@ -60,4 +53,5 @@ * possible, the fast version is used. */ + #define ipc_call_sync_0_0(phoneid, method) \ ipc_call_sync_fast((phoneid), (method), 0, 0, 0, 0, 0, 0, 0, 0) @@ -189,13 +183,11 @@ sysarg_t *); -extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int); -extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t); +extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, sysarg_t, unsigned int); extern void ipc_poke(void); -static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data) -{ - return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT); -} - +#define ipc_wait_for_call(data) \ + ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT); + +extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, sysarg_t); extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *); @@ -206,4 +198,5 @@ * to m. */ + #define ipc_answer_0(callid, retval) \ ipc_answer_fast((callid), (retval), 0, 0, 0, 0) @@ -230,4 +223,5 @@ * to m. */ + #define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \ ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \ @@ -255,21 +249,24 @@ extern void ipc_call_async_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, - sysarg_t, void *, ipc_async_callback_t, int); + sysarg_t, void *, ipc_async_callback_t, bool); extern void ipc_call_async_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, - sysarg_t, sysarg_t, void *, ipc_async_callback_t, int); - -extern int ipc_connect_to_me(int, int, int, int, sysarg_t *, sysarg_t *); -extern int ipc_connect_me_to(int, int, int, int); -extern int ipc_connect_me_to_blocking(int, int, int, int); + sysarg_t, sysarg_t, void *, ipc_async_callback_t, bool); + +extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t *, + sysarg_t *); +extern int ipc_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t); +extern int ipc_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t); + extern int ipc_hangup(int); -extern int ipc_register_irq(int, int, int, irq_code_t *); -extern int ipc_unregister_irq(int, int); -extern int ipc_forward_fast(ipc_callid_t, int, int, sysarg_t, sysarg_t, int); -extern int ipc_forward_slow(ipc_callid_t, int, int, sysarg_t, sysarg_t, - sysarg_t, sysarg_t, sysarg_t, int); + +extern int ipc_forward_fast(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t, + unsigned int); +extern int ipc_forward_slow(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t, + sysarg_t, sysarg_t, sysarg_t, unsigned int); /* * User-friendly wrappers for ipc_share_in_start(). */ + #define ipc_share_in_start_0_0(phoneid, dst, size) \ ipc_share_in_start((phoneid), (dst), (size), 0, NULL) @@ -281,7 +278,7 @@ ipc_share_in_start((phoneid), (dst), (size), (arg), (flags)) -extern int ipc_share_in_start(int, void *, size_t, sysarg_t, int *); -extern int ipc_share_in_finalize(ipc_callid_t, void *, int ); -extern int ipc_share_out_start(int, void *, int); +extern int ipc_share_in_start(int, void *, size_t, sysarg_t, unsigned int *); +extern int ipc_share_in_finalize(ipc_callid_t, void *, unsigned int); +extern int ipc_share_out_start(int, void *, unsigned int); extern int ipc_share_out_finalize(ipc_callid_t, void *); extern int ipc_data_read_start(int, void *, size_t); Index: uspace/lib/c/include/ipc/irc.h =================================================================== --- uspace/lib/c/include/ipc/irc.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/irc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,5 @@ #define LIBC_IRC_H_ -#include +#include typedef enum { Index: uspace/lib/c/include/ipc/kbd.h =================================================================== --- uspace/lib/c/include/ipc/kbd.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/kbd.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,5 @@ #define LIBC_IPC_KBD_H_ -#include +#include #include Index: uspace/lib/c/include/ipc/loader.h =================================================================== --- uspace/lib/c/include/ipc/loader.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/loader.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -31,10 +31,10 @@ */ /** @file - */ + */ #ifndef LIBC_IPC_LOADER_H_ #define LIBC_IPC_LOADER_H_ -#include +#include typedef enum { Index: uspace/lib/c/include/ipc/mouse.h =================================================================== --- uspace/lib/c/include/ipc/mouse.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/mouse.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -37,5 +37,5 @@ #define LIBC_IPC_MOUSE_H_ -#include +#include typedef enum { Index: uspace/lib/c/include/ipc/net.h =================================================================== --- uspace/lib/c/include/ipc/net.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/net.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,7 +38,5 @@ #define LIBC_NET_MESSAGES_H_ -#include #include - #include #include Index: uspace/lib/c/include/ipc/net_net.h =================================================================== --- uspace/lib/c/include/ipc/net_net.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/net_net.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,5 +39,4 @@ #define LIBC_NET_NET_MESSAGES_H_ -#include #include Index: uspace/lib/c/include/ipc/netif.h =================================================================== --- uspace/lib/c/include/ipc/netif.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/netif.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,4 @@ #define LIBC_NETIF_MESSAGES_H_ -#include #include Index: uspace/lib/c/include/ipc/nil.h =================================================================== --- uspace/lib/c/include/ipc/nil.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/nil.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,4 @@ #define LIBC_NIL_MESSAGES_H_ -#include #include Index: uspace/lib/c/include/ipc/ns.h =================================================================== --- uspace/lib/c/include/ipc/ns.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/ns.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,8 +33,9 @@ */ -#ifndef LIBIPC_NS_H_ -#define LIBIPC_NS_H_ +#ifndef LIBC_NS_H_ +#define LIBC_NS_H_ -#include +#include +#include typedef enum { @@ -45,4 +46,8 @@ } ns_request_t; +extern int service_register(sysarg_t); +extern int service_connect(sysarg_t, sysarg_t, sysarg_t); +extern int service_connect_blocking(sysarg_t, sysarg_t, sysarg_t); + #endif Index: uspace/lib/c/include/ipc/packet.h =================================================================== --- uspace/lib/c/include/ipc/packet.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/packet.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,4 @@ #define LIBC_PACKET_MESSAGES_ -#include #include Index: uspace/lib/c/include/ipc/services.h =================================================================== --- uspace/lib/c/include/ipc/services.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/services.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -35,6 +35,6 @@ */ -#ifndef LIBIPC_SERVICES_H_ -#define LIBIPC_SERVICES_H_ +#ifndef LIBC_SERVICES_H_ +#define LIBC_SERVICES_H_ typedef enum { @@ -66,8 +66,4 @@ } services_t; -/* Memory area to be received from NS */ -#define SERVICE_MEM_REALTIME 1 -#define SERVICE_MEM_KLOG 2 - #endif Index: uspace/lib/c/include/ipc/socket.h =================================================================== --- uspace/lib/c/include/ipc/socket.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/socket.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,4 @@ #define LIBC_SOCKET_MESSAGES_H_ -#include #include Index: uspace/lib/c/include/ipc/tl.h =================================================================== --- uspace/lib/c/include/ipc/tl.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/tl.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,5 +39,4 @@ #define LIBC_TL_MESSAGES_H_ -#include #include Index: uspace/lib/c/include/ipc/vfs.h =================================================================== --- uspace/lib/c/include/ipc/vfs.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/ipc/vfs.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,5 @@ #define LIBC_IPC_VFS_H_ -#include +#include #include #include Index: uspace/lib/c/include/libc.h =================================================================== --- uspace/lib/c/include/libc.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/libc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -62,7 +62,4 @@ __syscall6(p1, p2, p3, p4, p5, p6, id) -extern void __main(void *pcb_ptr); -extern void __exit(void); - #endif Index: uspace/lib/c/include/loader/pcb.h =================================================================== --- uspace/lib/c/include/loader/pcb.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/loader/pcb.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -52,5 +52,5 @@ /** Program entry point. */ entry_point_t entry; - + /** Current working directory. */ char *cwd; Index: uspace/lib/c/include/malloc.h =================================================================== --- uspace/lib/c/include/malloc.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/malloc.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,7 +38,4 @@ #include -extern void __heap_init(void); -extern uintptr_t get_max_heap_addr(void); - extern void *malloc(const size_t size) __attribute__((malloc)); Index: uspace/lib/c/include/net/modules.h =================================================================== --- uspace/lib/c/include/net/modules.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/net/modules.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -43,8 +43,5 @@ #include - -#include #include - #include Index: uspace/lib/c/include/setjmp.h =================================================================== --- uspace/lib/c/include/setjmp.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/setjmp.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,5 +41,5 @@ extern int setjmp(jmp_buf env); -extern void longjmp(jmp_buf env,int val) __attribute__((__noreturn__)); +extern void longjmp(jmp_buf env, int val) __attribute__((noreturn)); #endif Index: uspace/lib/c/include/stdlib.h =================================================================== --- uspace/lib/c/include/stdlib.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/stdlib.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -40,29 +40,13 @@ #include -#define abort() \ - do { \ - stacktrace_print(); \ - _exit(1); \ - } while (0) +#define RAND_MAX 714025 -#define core() \ - *((int *) 0) = 0xbadbad; - -#define exit(status) _exit((status)) - -#define RAND_MAX 714025 +#define rand() random() +#define srand(seed) srandom(seed) extern long int random(void); extern void srandom(unsigned int seed); -static inline int rand(void) -{ - return random(); -} - -static inline void srand(unsigned int seed) -{ - srandom(seed); -} +extern void abort(void) __attribute__((noreturn)); #endif Index: uspace/lib/c/include/syscall.h =================================================================== --- uspace/lib/c/include/syscall.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/syscall.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -32,7 +32,7 @@ /** * @file - * @brief Syscall function declaration for architectures that don't - * inline syscalls or architectures that handle syscalls - * according to the number of arguments. + * @brief Syscall function declaration for architectures that don't + * inline syscalls or architectures that handle syscalls + * according to the number of arguments. */ @@ -40,6 +40,6 @@ #define LIBC_SYSCALL_H_ -#ifndef LIBARCH_SYSCALL_GENERIC -#error "You can't include this file directly." +#ifndef LIBARCH_SYSCALL_GENERIC + #error You cannot include this file directly #endif @@ -47,11 +47,11 @@ #include -#define __syscall0 __syscall -#define __syscall1 __syscall -#define __syscall2 __syscall -#define __syscall3 __syscall -#define __syscall4 __syscall -#define __syscall5 __syscall -#define __syscall6 __syscall +#define __syscall0 __syscall +#define __syscall1 __syscall +#define __syscall2 __syscall +#define __syscall3 __syscall +#define __syscall4 __syscall +#define __syscall5 __syscall +#define __syscall6 __syscall extern sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2, Index: uspace/lib/c/include/thread.h =================================================================== --- uspace/lib/c/include/thread.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/thread.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,4 @@ #define LIBC_THREAD_H_ -#include #include #include @@ -42,9 +41,6 @@ typedef uint64_t thread_id_t; -extern void __thread_entry(void); -extern void __thread_main(uspace_arg_t *); - extern int thread_create(void (*)(void *), void *, const char *, thread_id_t *); -extern void thread_exit(int) __attribute__ ((noreturn)); +extern void thread_exit(int) __attribute__((noreturn)); extern void thread_detach(thread_id_t); extern int thread_join(thread_id_t); Index: uspace/lib/c/include/tls.h =================================================================== --- uspace/lib/c/include/tls.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/tls.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -57,4 +57,5 @@ extern void tls_free_variant_1(tcb_t *, size_t); #endif + #ifdef CONFIG_TLS_VARIANT_2 extern tcb_t *tls_alloc_variant_2(void **, size_t); Index: uspace/lib/c/include/udebug.h =================================================================== --- uspace/lib/c/include/udebug.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/udebug.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,23 +38,18 @@ #include #include -#include typedef sysarg_t thash_t; -int udebug_begin(int phoneid); -int udebug_end(int phoneid); -int udebug_set_evmask(int phoneid, udebug_evmask_t mask); -int udebug_thread_read(int phoneid, void *buffer, size_t n, - size_t *copied, size_t *needed); -int udebug_name_read(int phoneid, void *buffer, size_t n, - size_t *copied, size_t *needed); -int udebug_areas_read(int phoneid, void *buffer, size_t n, - size_t *copied, size_t *needed); -int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n); -int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer); -int udebug_regs_read(int phoneid, thash_t tid, void *buffer); -int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type, - sysarg_t *val0, sysarg_t *val1); -int udebug_stop(int phoneid, thash_t tid); +int udebug_begin(int); +int udebug_end(int); +int udebug_set_evmask(int, udebug_evmask_t); +int udebug_thread_read(int, void *, size_t , size_t *, size_t *); +int udebug_name_read(int, void *, size_t, size_t *, size_t *); +int udebug_areas_read(int, void *, size_t, size_t *, size_t *); +int udebug_mem_read(int, void *, uintptr_t, size_t); +int udebug_args_read(int, thash_t, sysarg_t *); +int udebug_regs_read(int, thash_t, void *); +int udebug_go(int, thash_t, udebug_event_t *, sysarg_t *, sysarg_t *); +int udebug_stop(int, thash_t); #endif Index: uspace/lib/c/include/unistd.h =================================================================== --- uspace/lib/c/include/unistd.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/unistd.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,8 +41,6 @@ #ifndef NULL - #define NULL ((void *) 0) + #define NULL ((void *) 0) #endif - -#define getpagesize() (PAGE_SIZE) #ifndef SEEK_SET @@ -57,4 +55,6 @@ #define SEEK_END 2 #endif + +#define getpagesize() (PAGE_SIZE) extern int dup2(int oldfd, int newfd); @@ -74,5 +74,5 @@ extern int chdir(const char *); -extern void _exit(int) __attribute__((noreturn)); +extern void exit(int) __attribute__((noreturn)); extern int usleep(useconds_t); extern unsigned int sleep(unsigned int); Index: uspace/lib/c/include/vfs/vfs.h =================================================================== --- uspace/lib/c/include/vfs/vfs.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/c/include/vfs/vfs.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -57,7 +57,4 @@ extern int unmount(const char *); -extern void __stdio_init(int filc, fdi_node_t *filv[]); -extern void __stdio_done(void); - extern int open_node(fdi_node_t *, int); extern int fd_phone(int); Index: uspace/lib/clui/tinput.h =================================================================== --- uspace/lib/clui/tinput.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/clui/tinput.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,6 +36,4 @@ #ifndef LIBCLUI_TINPUT_H_ #define LIBCLUI_TINPUT_H_ - -#include #define HISTORY_LEN 10 Index: uspace/lib/drv/generic/driver.c =================================================================== --- uspace/lib/drv/generic/driver.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/drv/generic/driver.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -186,5 +186,5 @@ pseudocode = &default_pseudocode; - int res = ipc_register_irq(irq, dev->handle, ctx->id, pseudocode); + int res = register_irq(irq, dev->handle, ctx->id, pseudocode); if (res != EOK) { remove_interrupt_context(&interrupt_contexts, ctx); @@ -199,5 +199,5 @@ interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts, dev, irq); - int res = ipc_unregister_irq(irq, dev->handle); + int res = unregister_irq(irq, dev->handle); if (ctx != NULL) { @@ -272,5 +272,5 @@ } - ipc_answer_0(iid, res); + async_answer_0(iid, res); } @@ -278,5 +278,5 @@ { /* Accept connection */ - ipc_answer_0(iid, EOK); + async_answer_0(iid, EOK); bool cont = true; @@ -293,5 +293,5 @@ break; default: - ipc_answer_0(callid, ENOENT); + async_answer_0(callid, ENOENT); } } @@ -316,5 +316,5 @@ printf("%s: driver_connection_gen error - no device with handle" " %" PRIun " was found.\n", driver->name, handle); - ipc_answer_0(iid, ENOENT); + async_answer_0(iid, ENOENT); return; } @@ -331,5 +331,5 @@ ret = (*dev->ops->open)(dev); - ipc_answer_0(iid, ret); + async_answer_0(iid, ret); if (ret != EOK) return; @@ -347,5 +347,5 @@ if (dev->ops != NULL && dev->ops->close != NULL) (*dev->ops->close)(dev); - ipc_answer_0(callid, EOK); + async_answer_0(callid, EOK); return; default: @@ -368,5 +368,5 @@ "invalid interface id %d.", driver->name, iface_idx); - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); break; } @@ -381,5 +381,5 @@ printf("device with handle %" PRIun " has no interface " "with id %d.\n", handle, iface_idx); - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); break; } @@ -400,5 +400,5 @@ printf("%s: driver_connection_gen error - " "invalid interface method.", driver->name); - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); break; } @@ -446,5 +446,5 @@ default: /* No such interface */ - ipc_answer_0(iid, ENOENT); + async_answer_0(iid, ENOENT); } } Index: uspace/lib/drv/generic/remote_char_dev.c =================================================================== --- uspace/lib/drv/generic/remote_char_dev.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/drv/generic/remote_char_dev.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,5 +33,4 @@ */ -#include #include #include @@ -81,5 +80,5 @@ if (!async_data_read_receive(&cid, &len)) { /* TODO handle protocol error. */ - ipc_answer_0(callid, EINVAL); + async_answer_0(callid, EINVAL); return; } @@ -87,5 +86,5 @@ if (!char_dev_ops->read) { async_data_read_finalize(cid, NULL, 0); - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -100,5 +99,5 @@ /* Some error occured. */ async_data_read_finalize(cid, buf, 0); - ipc_answer_0(callid, ret); + async_answer_0(callid, ret); return; } @@ -106,5 +105,5 @@ /* The operation was successful, return the number of data read. */ async_data_read_finalize(cid, buf, ret); - ipc_answer_1(callid, EOK, ret); + async_answer_1(callid, EOK, ret); } @@ -128,5 +127,5 @@ if (!async_data_write_receive(&cid, &len)) { /* TODO handle protocol error. */ - ipc_answer_0(callid, EINVAL); + async_answer_0(callid, EINVAL); return; } @@ -134,5 +133,5 @@ if (!char_dev_ops->write) { async_data_write_finalize(cid, NULL, 0); - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -148,5 +147,5 @@ if (ret < 0) { /* Some error occured. */ - ipc_answer_0(callid, ret); + async_answer_0(callid, ret); } else { /* @@ -154,5 +153,5 @@ * written. */ - ipc_answer_1(callid, EOK, ret); + async_answer_1(callid, EOK, ret); } } Index: uspace/lib/drv/generic/remote_hw_res.c =================================================================== --- uspace/lib/drv/generic/remote_hw_res.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/drv/generic/remote_hw_res.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,5 +33,4 @@ */ -#include #include #include @@ -62,9 +61,9 @@ if (hw_res_ops->enable_interrupt == NULL) - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); else if (hw_res_ops->enable_interrupt(dev)) - ipc_answer_0(callid, EOK); + async_answer_0(callid, EOK); else - ipc_answer_0(callid, EREFUSED); + async_answer_0(callid, EREFUSED); } @@ -75,5 +74,5 @@ if (hw_res_ops->get_resource_list == NULL) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -81,9 +80,9 @@ hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(dev); if (hw_resources == NULL){ - ipc_answer_0(callid, ENOENT); + async_answer_0(callid, ENOENT); return; } - ipc_answer_1(callid, EOK, hw_resources->count); + async_answer_1(callid, EOK, hw_resources->count); size_t len; Index: uspace/lib/drv/generic/remote_usb.c =================================================================== --- uspace/lib/drv/generic/remote_usb.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/drv/generic/remote_usb.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,5 +33,4 @@ */ -#include #include #include @@ -64,5 +63,5 @@ if (usb_iface->get_hc_handle == NULL) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -71,8 +70,8 @@ int rc = usb_iface->get_hc_handle(device, &handle); if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); } - ipc_answer_1(callid, EOK, (sysarg_t) handle); + async_answer_1(callid, EOK, (sysarg_t) handle); } Index: uspace/lib/drv/generic/remote_usbhc.c =================================================================== --- uspace/lib/drv/generic/remote_usbhc.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/drv/generic/remote_usbhc.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,5 +33,4 @@ */ -#include #include #include @@ -141,5 +140,5 @@ if (!usb_iface->tell_address) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -150,7 +149,7 @@ int rc = usb_iface->tell_address(device, handle, &address); if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); } else { - ipc_answer_1(callid, EOK, address); + async_answer_1(callid, EOK, address); } } @@ -162,9 +161,9 @@ async_transaction_t * trans = (async_transaction_t *)buffer_hash; if (trans == NULL) { - ipc_answer_0(callid, ENOENT); + async_answer_0(callid, ENOENT); return; } if (trans->buffer == NULL) { - ipc_answer_0(callid, EINVAL); + async_answer_0(callid, EINVAL); async_transaction_destroy(trans); return; @@ -174,5 +173,5 @@ size_t accepted_size; if (!async_data_read_receive(&cid, &accepted_size)) { - ipc_answer_0(callid, EINVAL); + async_answer_0(callid, EINVAL); async_transaction_destroy(trans); return; @@ -184,5 +183,5 @@ async_data_read_finalize(cid, trans->buffer, accepted_size); - ipc_answer_1(callid, EOK, accepted_size); + async_answer_1(callid, EOK, accepted_size); async_transaction_destroy(trans); @@ -195,5 +194,5 @@ if (!usb_iface->reserve_default_address) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -201,5 +200,5 @@ int rc = usb_iface->reserve_default_address(device); - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); } @@ -210,5 +209,5 @@ if (!usb_iface->release_default_address) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -216,5 +215,5 @@ int rc = usb_iface->release_default_address(device); - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); } @@ -225,5 +224,5 @@ if (!usb_iface->request_address) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -232,7 +231,7 @@ int rc = usb_iface->request_address(device, &address); if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); } else { - ipc_answer_1(callid, EOK, (sysarg_t) address); + async_answer_1(callid, EOK, (sysarg_t) address); } } @@ -244,5 +243,5 @@ if (!usb_iface->bind_address) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -253,5 +252,5 @@ int rc = usb_iface->bind_address(device, address, handle); - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); } @@ -262,5 +261,5 @@ if (!usb_iface->release_address) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -270,5 +269,5 @@ int rc = usb_iface->release_address(device, address); - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); } @@ -279,5 +278,5 @@ async_transaction_t *trans = (async_transaction_t *)arg; - ipc_answer_0(trans->caller, outcome); + async_answer_0(trans->caller, outcome); async_transaction_destroy(trans); @@ -290,5 +289,5 @@ if (outcome != USB_OUTCOME_OK) { - ipc_answer_0(trans->caller, outcome); + async_answer_0(trans->caller, outcome); async_transaction_destroy(trans); return; @@ -296,5 +295,5 @@ trans->size = actual_size; - ipc_answer_1(trans->caller, USB_OUTCOME_OK, (sysarg_t)trans); + async_answer_1(trans->caller, USB_OUTCOME_OK, (sysarg_t)trans); } @@ -311,5 +310,5 @@ { if (!transfer_func) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -329,5 +328,5 @@ if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); return; } @@ -339,5 +338,5 @@ free(buffer); } - ipc_answer_0(callid, ENOMEM); + async_answer_0(callid, ENOMEM); return; } @@ -350,5 +349,5 @@ if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); async_transaction_destroy(trans); } @@ -367,5 +366,5 @@ { if (!transfer_func) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -379,5 +378,5 @@ async_transaction_t *trans = async_transaction_create(callid); if (trans == NULL) { - ipc_answer_0(callid, ENOMEM); + async_answer_0(callid, ENOMEM); return; } @@ -389,5 +388,5 @@ if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); async_transaction_destroy(trans); } @@ -414,5 +413,5 @@ case USB_DIRECTION_IN: if (!transfer_in_func) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -420,5 +419,5 @@ case USB_DIRECTION_OUT: if (!transfer_out_func) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -436,5 +435,5 @@ async_transaction_t *trans = async_transaction_create(callid); if (trans == NULL) { - ipc_answer_0(callid, ENOMEM); + async_answer_0(callid, ENOMEM); return; } @@ -456,5 +455,5 @@ if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); async_transaction_destroy(trans); } @@ -549,5 +548,5 @@ if (!usb_iface->control_write) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -568,5 +567,5 @@ 1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len); if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); return; } @@ -574,5 +573,5 @@ 1, USB_MAX_PAYLOAD_SIZE, 0, &data_buffer_len); if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); free(setup_packet); return; @@ -581,5 +580,5 @@ async_transaction_t *trans = async_transaction_create(callid); if (trans == NULL) { - ipc_answer_0(callid, ENOMEM); + async_answer_0(callid, ENOMEM); free(setup_packet); free(data_buffer); @@ -596,5 +595,5 @@ if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); async_transaction_destroy(trans); } @@ -609,5 +608,5 @@ if (!usb_iface->control_read) { - ipc_answer_0(callid, ENOTSUP); + async_answer_0(callid, ENOTSUP); return; } @@ -627,5 +626,5 @@ 1, USB_MAX_PAYLOAD_SIZE, 0, &setup_packet_len); if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); return; } @@ -633,5 +632,5 @@ async_transaction_t *trans = async_transaction_create(callid); if (trans == NULL) { - ipc_answer_0(callid, ENOMEM); + async_answer_0(callid, ENOMEM); free(setup_packet); return; @@ -641,5 +640,5 @@ trans->buffer = malloc(data_len); if (trans->buffer == NULL) { - ipc_answer_0(callid, ENOMEM); + async_answer_0(callid, ENOMEM); async_transaction_destroy(trans); return; @@ -652,5 +651,5 @@ if (rc != EOK) { - ipc_answer_0(callid, rc); + async_answer_0(callid, rc); async_transaction_destroy(trans); } Index: uspace/lib/drv/include/dev_iface.h =================================================================== --- uspace/lib/drv/include/dev_iface.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/drv/include/dev_iface.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,4 +36,5 @@ #define LIBDRV_DEV_IFACE_H_ +#include #include Index: uspace/lib/drv/include/driver.h =================================================================== --- uspace/lib/drv/include/driver.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/drv/include/driver.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,6 +36,7 @@ #define LIBDRV_DRIVER_H_ +#include +#include #include -#include #include #include Index: uspace/lib/fs/libfs.c =================================================================== --- uspace/lib/fs/libfs.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/fs/libfs.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -40,5 +40,4 @@ #include #include -#include #include #include @@ -58,5 +57,5 @@ #define answer_and_return(rid, rc) \ do { \ - ipc_answer_0((rid), (rc)); \ + async_answer_0((rid), (rc)); \ return; \ } while (0) @@ -102,6 +101,5 @@ * Ask VFS for callback connection. */ - sysarg_t taskhash; - ipc_connect_to_me(vfs_phone, 0, 0, 0, &taskhash, ®->vfs_phonehash); + async_connect_to_me(vfs_phone, 0, 0, 0, conn); /* @@ -128,9 +126,4 @@ async_wait_for(req, NULL); reg->fs_handle = (int) IPC_GET_ARG1(answer); - - /* - * Create a connection fibril to handle the callback connection. - */ - async_new_connection(taskhash, reg->vfs_phonehash, 0, NULL, conn); /* @@ -166,26 +159,26 @@ if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) || (mountee_phone < 0)) { - ipc_answer_0(callid, EINVAL); - ipc_answer_0(rid, EINVAL); + async_answer_0(callid, EINVAL); + async_answer_0(rid, EINVAL); return; } /* Acknowledge the mountee_phone */ - ipc_answer_0(callid, EOK); + async_answer_0(callid, EOK); fs_node_t *fn; res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); if ((res != EOK) || (!fn)) { - ipc_hangup(mountee_phone); + async_hangup(mountee_phone); async_data_write_void(combine_rc(res, ENOENT)); - ipc_answer_0(rid, combine_rc(res, ENOENT)); + async_answer_0(rid, combine_rc(res, ENOENT)); return; } if (fn->mp_data.mp_active) { - ipc_hangup(mountee_phone); + async_hangup(mountee_phone); (void) ops->node_put(fn); async_data_write_void(EBUSY); - ipc_answer_0(rid, EBUSY); + async_answer_0(rid, EBUSY); return; } @@ -193,8 +186,8 @@ rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME); if (rc != EOK) { - ipc_hangup(mountee_phone); + async_hangup(mountee_phone); (void) ops->node_put(fn); async_data_write_void(rc); - ipc_answer_0(rid, rc); + async_answer_0(rid, rc); return; } @@ -214,5 +207,5 @@ * Do not release the FS node so that it stays in memory. */ - ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer), + async_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer), IPC_GET_ARG3(answer)); } @@ -227,5 +220,5 @@ res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); if ((res != EOK) || (!fn)) { - ipc_answer_0(rid, combine_rc(res, ENOENT)); + async_answer_0(rid, combine_rc(res, ENOENT)); return; } @@ -236,5 +229,5 @@ if (!fn->mp_data.mp_active) { (void) ops->node_put(fn); - ipc_answer_0(rid, EINVAL); + async_answer_0(rid, EINVAL); return; } @@ -250,5 +243,5 @@ */ if (res == EOK) { - ipc_hangup(fn->mp_data.phone); + async_hangup(fn->mp_data.phone); fn->mp_data.mp_active = false; fn->mp_data.fs_handle = 0; @@ -260,5 +253,5 @@ (void) ops->node_put(fn); - ipc_answer_0(rid, res); + async_answer_0(rid, res); } @@ -300,5 +293,5 @@ if (cur->mp_data.mp_active) { - ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP, + async_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP, next, last, cur->mp_data.devmap_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); @@ -324,5 +317,5 @@ if (len + 1 == NAME_MAX) { /* Component length overflow */ - ipc_answer_0(rid, ENAMETOOLONG); + async_answer_0(rid, ENAMETOOLONG); goto out; } @@ -358,5 +351,5 @@ next--; - ipc_forward_slow(rid, tmp->mp_data.phone, + async_forward_slow(rid, tmp->mp_data.phone, VFS_OUT_LOOKUP, next, last, tmp->mp_data.devmap_handle, lflag, index, IPC_FF_ROUTE_FROM_ME); @@ -372,5 +365,5 @@ if (next <= last) { /* There are unprocessed components */ - ipc_answer_0(rid, ENOENT); + async_answer_0(rid, ENOENT); goto out; } @@ -380,5 +373,5 @@ /* Request to create a new link */ if (!ops->is_directory(cur)) { - ipc_answer_0(rid, ENOTDIR); + async_answer_0(rid, ENOTDIR); goto out; } @@ -398,8 +391,8 @@ if (lflag & L_CREATE) (void) ops->destroy(fn); - ipc_answer_0(rid, rc); + async_answer_0(rid, rc); } else { aoff64_t size = ops->size_get(fn); - ipc_answer_5(rid, fs_handle, + async_answer_5(rid, fs_handle, devmap_handle, ops->index_get(fn), @@ -410,10 +403,10 @@ } } else - ipc_answer_0(rid, ENOSPC); + async_answer_0(rid, ENOSPC); goto out; } - ipc_answer_0(rid, ENOENT); + async_answer_0(rid, ENOENT); goto out; } @@ -441,5 +434,5 @@ if (lflag & (L_CREATE | L_LINK)) { if (!ops->is_directory(cur)) { - ipc_answer_0(rid, ENOTDIR); + async_answer_0(rid, ENOTDIR); goto out; } @@ -450,5 +443,5 @@ if (ops->plb_get_char(next) == '/') { /* More than one component */ - ipc_answer_0(rid, ENOENT); + async_answer_0(rid, ENOENT); goto out; } @@ -456,5 +449,5 @@ if (len + 1 == NAME_MAX) { /* Component length overflow */ - ipc_answer_0(rid, ENAMETOOLONG); + async_answer_0(rid, ENAMETOOLONG); goto out; } @@ -480,8 +473,8 @@ if (lflag & L_CREATE) (void) ops->destroy(fn); - ipc_answer_0(rid, rc); + async_answer_0(rid, rc); } else { aoff64_t size = ops->size_get(fn); - ipc_answer_5(rid, fs_handle, + async_answer_5(rid, fs_handle, devmap_handle, ops->index_get(fn), @@ -492,10 +485,10 @@ } } else - ipc_answer_0(rid, ENOSPC); + async_answer_0(rid, ENOSPC); goto out; } - ipc_answer_0(rid, ENOENT); + async_answer_0(rid, ENOENT); goto out; } @@ -510,9 +503,9 @@ if (rc == EOK) { aoff64_t size = ops->size_get(cur); - ipc_answer_5(rid, fs_handle, devmap_handle, + async_answer_5(rid, fs_handle, devmap_handle, ops->index_get(cur), LOWER32(size), UPPER32(size), old_lnkcnt); } else - ipc_answer_0(rid, rc); + async_answer_0(rid, rc); goto out; @@ -521,20 +514,20 @@ if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) || (lflag & L_LINK)) { - ipc_answer_0(rid, EEXIST); + async_answer_0(rid, EEXIST); goto out; } if ((lflag & L_FILE) && (ops->is_directory(cur))) { - ipc_answer_0(rid, EISDIR); + async_answer_0(rid, EISDIR); goto out; } if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) { - ipc_answer_0(rid, ENOTDIR); + async_answer_0(rid, ENOTDIR); goto out; } if ((lflag & L_ROOT) && par) { - ipc_answer_0(rid, EINVAL); + async_answer_0(rid, EINVAL); goto out; } @@ -548,12 +541,12 @@ if (rc == EOK) { aoff64_t size = ops->size_get(cur); - ipc_answer_5(rid, fs_handle, devmap_handle, + async_answer_5(rid, fs_handle, devmap_handle, ops->index_get(cur), LOWER32(size), UPPER32(size), ops->lnkcnt_get(cur)); } else - ipc_answer_0(rid, rc); + async_answer_0(rid, rc); } else - ipc_answer_0(rid, rc); + async_answer_0(rid, rc); out: @@ -584,6 +577,6 @@ (size != sizeof(struct stat))) { ops->node_put(fn); - ipc_answer_0(callid, EINVAL); - ipc_answer_0(rid, EINVAL); + async_answer_0(callid, EINVAL); + async_answer_0(rid, EINVAL); return; } @@ -604,5 +597,5 @@ async_data_read_finalize(callid, &stat, sizeof(struct stat)); - ipc_answer_0(rid, EOK); + async_answer_0(rid, EOK); } @@ -626,5 +619,5 @@ if (fn == NULL) { - ipc_answer_0(rid, ENOENT); + async_answer_0(rid, ENOENT); return; } @@ -632,5 +625,5 @@ rc = ops->node_open(fn); aoff64_t size = ops->size_get(fn); - ipc_answer_4(rid, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn), + async_answer_4(rid, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn), (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0)); Index: uspace/lib/fs/libfs.h =================================================================== --- uspace/lib/fs/libfs.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/fs/libfs.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,5 +39,4 @@ #include #include -#include #include #include @@ -86,5 +85,4 @@ typedef struct { int fs_handle; /**< File system handle. */ - sysarg_t vfs_phonehash; /**< Initial VFS phonehash. */ uint8_t *plb_ro; /**< Read-only PLB view. */ } fs_reg_t; Index: uspace/lib/net/generic/generic.c =================================================================== --- uspace/lib/net/generic/generic.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/generic/generic.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,9 +36,6 @@ #include - #include -#include #include - #include #include Index: uspace/lib/net/generic/packet_remote.c =================================================================== --- uspace/lib/net/generic/packet_remote.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/generic/packet_remote.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,4 @@ #include #include -#include #include #include Index: uspace/lib/net/il/arp_remote.c =================================================================== --- uspace/lib/net/il/arp_remote.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/il/arp_remote.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,5 +41,4 @@ #include #include -#include #include #include Index: uspace/lib/net/il/il_skel.c =================================================================== --- uspace/lib/net/il/il_skel.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/il/il_skel.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -54,5 +54,5 @@ * the initial IPC_M_CONNECT_ME_TO call. */ - ipc_answer_0(iid, EOK); + async_answer_0(iid, EOK); while (true) { @@ -115,5 +115,5 @@ goto out; - rc = ipc_connect_to_me(PHONE_NS, service, 0, 0, NULL, NULL); + rc = async_connect_to_me(PHONE_NS, service, 0, 0, NULL); if (rc != EOK) goto out; Index: uspace/lib/net/include/generic.h =================================================================== --- uspace/lib/net/include/generic.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/include/generic.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -39,5 +39,4 @@ #include -#include #include Index: uspace/lib/net/include/il_skel.h =================================================================== --- uspace/lib/net/include/il_skel.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/include/il_skel.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,5 +41,4 @@ #include #include -#include #include Index: uspace/lib/net/include/netif_skel.h =================================================================== --- uspace/lib/net/include/netif_skel.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/include/netif_skel.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,5 +41,4 @@ #include #include -#include #include Index: uspace/lib/net/include/nil_skel.h =================================================================== --- uspace/lib/net/include/nil_skel.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/include/nil_skel.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,5 +41,4 @@ #include #include -#include #include Index: uspace/lib/net/include/tl_skel.h =================================================================== --- uspace/lib/net/include/tl_skel.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/include/tl_skel.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -41,5 +41,4 @@ #include #include -#include #include Index: uspace/lib/net/netif/netif_skel.c =================================================================== --- uspace/lib/net/netif/netif_skel.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/netif/netif_skel.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -40,5 +40,4 @@ #include #include -#include #include #include @@ -369,5 +368,5 @@ * the initial IPC_M_CONNECT_ME_TO call. */ - ipc_answer_0(iid, EOK); + async_answer_0(iid, EOK); while (true) { Index: uspace/lib/net/nil/nil_skel.c =================================================================== --- uspace/lib/net/nil/nil_skel.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/nil/nil_skel.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -54,5 +54,5 @@ * the initial IPC_M_CONNECT_ME_TO call. */ - ipc_answer_0(iid, EOK); + async_answer_0(iid, EOK); while (true) { @@ -115,5 +115,5 @@ goto out; - rc = ipc_connect_to_me(PHONE_NS, service, 0, 0, NULL, NULL); + rc = async_connect_to_me(PHONE_NS, service, 0, 0, NULL); if (rc != EOK) goto out; Index: uspace/lib/net/tl/icmp_remote.c =================================================================== --- uspace/lib/net/tl/icmp_remote.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/tl/icmp_remote.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -42,5 +42,4 @@ #include #include -#include #include #include Index: uspace/lib/net/tl/tl_skel.c =================================================================== --- uspace/lib/net/tl/tl_skel.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/net/tl/tl_skel.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -54,5 +54,5 @@ * the initial IPC_M_CONNECT_ME_TO call. */ - ipc_answer_0(iid, EOK); + async_answer_0(iid, EOK); /* Per-connection initialization */ @@ -117,5 +117,5 @@ goto out; - rc = ipc_connect_to_me(PHONE_NS, service, 0, 0, NULL, NULL); + rc = async_connect_to_me(PHONE_NS, service, 0, 0, NULL); if (rc != EOK) goto out; Index: uspace/lib/packet/generic/packet_server.c =================================================================== --- uspace/lib/packet/generic/packet_server.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/packet/generic/packet_server.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -44,9 +44,6 @@ #include #include - -#include #include #include - #include #include @@ -292,10 +289,10 @@ if (!async_share_in_receive(&callid, &size)) { - ipc_answer_0(callid, EINVAL); + async_answer_0(callid, EINVAL); return EINVAL; } if (size != packet->length) { - ipc_answer_0(callid, ENOMEM); + async_answer_0(callid, ENOMEM); return ENOMEM; } Index: uspace/lib/packet/include/packet_server.h =================================================================== --- uspace/lib/packet/include/packet_server.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/packet/include/packet_server.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -45,5 +45,5 @@ #define LIBPACKET_PACKET_SERVER_H_ -#include +#include extern int packet_server_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, Index: uspace/lib/usb/include/usb/descriptor.h =================================================================== --- uspace/lib/usb/include/usb/descriptor.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usb/include/usb/descriptor.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,4 @@ #define LIBUSB_DESCRIPTOR_H_ -#include #include Index: uspace/lib/usb/include/usb/devreq.h =================================================================== --- uspace/lib/usb/include/usb/devreq.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usb/include/usb/devreq.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -36,5 +36,4 @@ #define LIBUSB_DEVREQ_H_ -#include #include #include Index: uspace/lib/usb/include/usb/usb.h =================================================================== --- uspace/lib/usb/include/usb/usb.h (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usb/include/usb/usb.h (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -38,5 +38,4 @@ #include #include -#include /** Convert 16bit value from native (host) endianness to USB endianness. */ Index: uspace/lib/usb/src/pipes.c =================================================================== --- uspace/lib/usb/src/pipes.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usb/src/pipes.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -90,5 +90,5 @@ leave: - ipc_hangup(hc_phone); + async_hangup(hc_phone); return rc; } @@ -211,5 +211,5 @@ } - int rc = ipc_hangup(pipe->hc_phone); + int rc = async_hangup(pipe->hc_phone); if (rc != EOK) { return rc; Index: uspace/lib/usb/src/recognise.c =================================================================== --- uspace/lib/usb/src/recognise.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usb/src/recognise.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -33,4 +33,5 @@ * @brief Functions for recognising kind of attached devices. */ +#include #include #include Index: uspace/lib/usb/src/usbdrv.c =================================================================== --- uspace/lib/usb/src/usbdrv.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usb/src/usbdrv.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -80,5 +80,5 @@ IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h); - ipc_hangup(parent_phone); + async_hangup(parent_phone); if (rc != EOK) { Index: uspace/lib/usbvirt/src/callback.c =================================================================== --- uspace/lib/usbvirt/src/callback.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usbvirt/src/callback.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -54,15 +54,15 @@ if (address != device->address) { - ipc_answer_0(iid, EADDRNOTAVAIL); + async_answer_0(iid, EADDRNOTAVAIL); return; } if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { - ipc_answer_0(iid, EINVAL); + async_answer_0(iid, EINVAL); return; } if (expected_len == 0) { - ipc_answer_0(iid, EINVAL); + async_answer_0(iid, EINVAL); return; } @@ -74,5 +74,5 @@ if (rc != EOK) { - ipc_answer_0(iid, rc); + async_answer_0(iid, rc); return; } @@ -80,5 +80,5 @@ rc = device->transaction_setup(device, endpoint, buffer, len); - ipc_answer_0(iid, rc); + async_answer_0(iid, rc); } @@ -92,10 +92,10 @@ if (address != device->address) { - ipc_answer_0(iid, EADDRNOTAVAIL); + async_answer_0(iid, EADDRNOTAVAIL); return; } if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { - ipc_answer_0(iid, EINVAL); + async_answer_0(iid, EINVAL); return; } @@ -111,5 +111,5 @@ if (rc != EOK) { - ipc_answer_0(iid, rc); + async_answer_0(iid, rc); return; } @@ -122,5 +122,5 @@ } - ipc_answer_0(iid, rc); + async_answer_0(iid, rc); } @@ -135,10 +135,10 @@ if (address != device->address) { - ipc_answer_0(iid, EADDRNOTAVAIL); + async_answer_0(iid, EADDRNOTAVAIL); return; } if ((endpoint < 0) || (endpoint >= USB11_ENDPOINT_MAX)) { - ipc_answer_0(iid, EINVAL); + async_answer_0(iid, EINVAL); return; } @@ -157,5 +157,5 @@ ipc_callid_t callid; if (!async_data_read_receive(&callid, &receive_len)) { - ipc_answer_0(iid, EINVAL); + async_answer_0(iid, EINVAL); return; } @@ -166,5 +166,5 @@ } - ipc_answer_1(iid, rc, len); + async_answer_1(iid, rc, len); } @@ -174,5 +174,5 @@ { if (device->name == NULL) { - ipc_answer_0(iid, ENOENT); + async_answer_0(iid, ENOENT); } @@ -182,5 +182,5 @@ size_t accepted_size; if (!async_data_read_receive(&callid, &accepted_size)) { - ipc_answer_0(iid, EINVAL); + async_answer_0(iid, EINVAL); return; } @@ -191,5 +191,5 @@ async_data_read_finalize(callid, device->name, accepted_size); - ipc_answer_1(iid, EOK, accepted_size); + async_answer_1(iid, EOK, accepted_size); } @@ -197,5 +197,5 @@ void device_callback_connection(usbvirt_device_t *device, ipc_callid_t iid, ipc_call_t *icall) { - ipc_answer_0(iid, EOK); + async_answer_0(iid, EOK); while (true) { @@ -206,5 +206,5 @@ switch (IPC_GET_IMETHOD(call)) { case IPC_M_PHONE_HUNGUP: - ipc_answer_0(callid, EOK); + async_answer_0(callid, EOK); return; @@ -226,5 +226,5 @@ default: - ipc_answer_0(callid, EINVAL); + async_answer_0(callid, EINVAL); break; } Index: uspace/lib/usbvirt/src/main.c =================================================================== --- uspace/lib/usbvirt/src/main.c (revision e778543f4755da04d0813045d56c3cf431812035) +++ uspace/lib/usbvirt/src/main.c (revision 0397e5a488c166a87563157012b79e2195f21d04) @@ -159,5 +159,5 @@ { if (dev->vhcd_phone > 0) { - ipc_hangup(dev->vhcd_phone); + async_hangup(dev->vhcd_phone); } @@ -173,5 +173,5 @@ virtual_device_t *dev = find_device_by_id(0); if (dev == NULL) { - ipc_answer_0(iid, EINVAL); + async_answer_0(iid, EINVAL); printf("Ooops\n"); return; @@ -220,7 +220,5 @@ } - sysarg_t phonehash; - sysarg_t taskhash; - rc = ipc_connect_to_me(hcd_phone, 0, 0, 0, &taskhash, &phonehash); + rc = async_connect_to_me(hcd_phone, 0, 0, 0, callback_connection); if (rc != EOK) { printf("ipc_connect_to_me() failed\n"); @@ -233,6 +231,4 @@ virtual_device->vhcd_phone = hcd_phone; virtual_device->id = 0; - - async_new_connection(taskhash, phonehash, 0, NULL, callback_connection); return EOK;