Changeset 8b5690f in mainline for uspace/lib/c


Ignore:
Timestamp:
2011-02-03T05:11:01Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ba38f72c
Parents:
22027b6e (diff), 86d7bfa (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/lib/c
Files:
2 added
88 edited
6 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r22027b6e r8b5690f  
    8383        generic/io/console.c \
    8484        generic/io/screenbuffer.c \
     85        generic/ipc/ns.c \
    8586        generic/malloc.c \
    8687        generic/sysinfo.c \
    … …  
    9697        generic/adt/char_map.c \
    9798        generic/time.c \
    98         generic/err.c \
    9999        generic/stdlib.c \
    100100        generic/mman.c \

  • uspace/lib/c/arch/abs32le/src/entry.c

    r22027b6e r8b5690f  
    3030 */
    3131
    32 #include <libc.h>
    3332#include <unistd.h>
    3433#include <libarch/entry.h>
     34#include "../../../generic/private/libc.h"
    3535
    3636void __entry(void)
    3737{
    3838        __main(NULL);
    39         __exit();
    4039}
    4140

  • uspace/lib/c/arch/abs32le/src/thread_entry.c

    r22027b6e r8b5690f  
    3131
    3232#include <unistd.h>
    33 #include <thread.h>
     33#include "../../../generic/private/thread.h"
    3434
    3535void __thread_entry(void)

  • uspace/lib/c/arch/amd64/_link.ld.in

    r22027b6e r8b5690f  
    55        text PT_LOAD FLAGS(5);
    66        data PT_LOAD FLAGS(6);
     7        debug PT_NOTE;
    78}
    89
    … …  
    1314                *(.init);
    1415        } :text
     16       
    1517        .text : {
    1618                *(.text);
    1719                *(.rodata*);
    1820        } :text
    19 
     21       
    2022        . = . + 0x1000;
    21 
     23       
    2224        .data : {
    2325                *(.data);
    2426        } :data
     27       
    2528        .tdata : {
    2629                _tdata_start = .;
    … …  
    3134                _tbss_end = .;
    3235        } :data
     36       
    3337        _tls_alignment = ALIGNOF(.tdata);
     38       
    3439        .bss : {
    3540                *(COMMON);
    3641                *(.bss);
    3742        } :data
    38 
     43       
    3944        . = ALIGN(0x1000);
    4045        _heap = .;
     46       
     47#ifdef CONFIG_LINE_DEBUG
     48        .comment 0 : { *(.comment); } :debug
     49        .debug_abbrev 0 : { *(.debug_abbrev); } :debug
     50        .debug_aranges 0 : { *(.debug_aranges); } :debug
     51        .debug_info 0 : { *(.debug_info); } :debug
     52        .debug_line 0 : { *(.debug_line); } :debug
     53        .debug_loc 0 : { *(.debug_loc); } :debug
     54        .debug_pubnames 0 : { *(.debug_pubnames); } :debug
     55        .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
     56        .debug_ranges 0 : { *(.debug_ranges); } :debug
     57        .debug_str 0 : { *(.debug_str); } :debug
     58#endif
    4159       
    4260        /DISCARD/ : {

  • uspace/lib/c/arch/amd64/src/entry.s

    r22027b6e r8b5690f  
    4747        # Pass PCB pointer to __main (no operation)
    4848        call __main
    49 
    50         call __exit

  • uspace/lib/c/arch/arm32/src/entry.s

    r22027b6e r8b5690f  
    4242        ldr r0, =ras_page
    4343        str r2, [r0]
    44 
     44       
    4545        #
    4646        # Create the first stack frame.
    … …  
    5050        push {fp, ip, lr, pc}
    5151        sub fp, ip, #4
    52 
     52       
    5353        # Pass pcb_ptr to __main as the first argument (in r0)
    5454        mov r0, r1
    5555        bl __main
    56 
    57         bl __exit
    5856
    5957.data
    … …  
    6260ras_page:
    6361        .long 0
    64 

  • uspace/lib/c/arch/ia32/_link.ld.in

    r22027b6e r8b5690f  
    55        text PT_LOAD FLAGS(5);
    66        data PT_LOAD FLAGS(6);
     7        debug PT_NOTE;
    78}
    89
    … …  
    4344       
    4445        . = ALIGN(0x1000);
     46        _heap = .;
    4547       
    46         _heap = .;
     48#ifdef CONFIG_LINE_DEBUG
     49        .comment 0 : { *(.comment); } :debug
     50        .debug_abbrev 0 : { *(.debug_abbrev); } :debug
     51        .debug_aranges 0 : { *(.debug_aranges); } :debug
     52        .debug_info 0 : { *(.debug_info); } :debug
     53        .debug_line 0 : { *(.debug_line); } :debug
     54        .debug_loc 0 : { *(.debug_loc); } :debug
     55        .debug_pubnames 0 : { *(.debug_pubnames); } :debug
     56        .debug_pubtypes 0 : { *(.debug_pubtypes); } :debug
     57        .debug_ranges 0 : { *(.debug_ranges); } :debug
     58        .debug_str 0 : { *(.debug_str); } :debug
     59#endif
    4760       
    4861        /DISCARD/ : {

  • uspace/lib/c/arch/ia32/src/entry.s

    r22027b6e r8b5690f  
    4646        mov %ax, %fs
    4747        # Do not set %gs, it contains descriptor that can see TLS
    48 
     48       
    4949        # Detect the mechanism used for making syscalls
    5050        movl $(INTEL_CPUID_STANDARD), %eax
    … …  
    5858        # Create the first stack frame.
    5959        #
    60         pushl $0 
     60        pushl $0
    6161        movl %esp, %ebp
    62 
     62       
    6363        # Pass the PCB pointer to __main as the first argument
    6464        pushl %edi
    6565        call __main
    66 
    67         call __exit

  • uspace/lib/c/arch/ia64/src/entry.s

    r22027b6e r8b5690f  
    4040        alloc loc0 = ar.pfs, 0, 1, 2, 0
    4141        movl gp = _gp
    42 
     42       
    4343        # Pass PCB pointer as the first argument to __main
    4444        mov out0 = r2
    4545        br.call.sptk.many b0 = __main
    46 0:
    47         br.call.sptk.many b0 = __exit

  • uspace/lib/c/arch/mips32/src/entry.s

    r22027b6e r8b5690f  
    5656        jal __main
    5757        nop
    58        
    59         jal __exit
    60         nop
    6158.end
    6259

  • uspace/lib/c/arch/ppc32/src/entry.s

    r22027b6e r8b5690f  
    4444        stw %r3, 0(%r1)
    4545        stwu %r1, -16(%r1)
    46 
     46       
    4747        # Pass the PCB pointer to __main() as the first argument.
    4848        # The first argument is passed in r3.
    4949        mr %r3, %r6
    5050        bl __main
    51 
    52         bl __exit

  • uspace/lib/c/arch/sparc64/src/entry.s

    r22027b6e r8b5690f  
    4545        flushw
    4646        add %g0, -0x7ff, %fp
    47 
     47       
    4848        # Pass pcb_ptr as the first argument to __main()
    4949        mov %i1, %o0
    … …  
    5151        call __main
    5252        or %l7, %lo(_gp), %l7
    53 
    54         call __exit
    55         nop

  • uspace/lib/c/generic/async.c

    r22027b6e r8b5690f  
    4343 * framework will automatically take care of most synchronization problems.
    4444 *
    45  * Default semantics:
    46  * - async_send_*(): Send asynchronously. If the kernel refuses to send
    47  *                   more messages, [ try to get responses from kernel, if
    48  *                   nothing found, might try synchronous ]
    49  *
    5045 * Example of use (pseudo C):
    5146 *
    … …  
    5853 *   int fibril1(void *arg)
    5954 *   {
    60  *     conn = ipc_connect_me_to();
     55 *     conn = async_connect_me_to();
    6156 *     c1 = async_send(conn);
    6257 *     c2 = async_send(conn);
    … …  
    7772 *   {
    7873 *     if (want_refuse) {
    79  *       ipc_answer_0(icallid, ELIMIT);
     74 *       async_answer_0(icallid, ELIMIT);
    8075 *       return;
    8176 *     }
    82  *     ipc_answer_0(icallid, EOK);
     77 *     async_answer_0(icallid, EOK);
    8378 *
    8479 *     callid = async_get_call(&call);
    8580 *     somehow_handle_the_call(callid, call);
    86  *     ipc_answer_2(callid, 1, 2, 3);
     81 *     async_answer_2(callid, 1, 2, 3);
    8782 *
    8883 *     callid = async_get_call(&call);
    … …  
    9287 */
    9388
     89#define LIBC_ASYNC_C_
     90#include <ipc/ipc.h>
     91#include <async.h>
     92#undef LIBC_ASYNC_C_
     93
    9494#include <futex.h>
    95 #include <async.h>
    96 #include <async_priv.h>
    9795#include <fibril.h>
    9896#include <stdio.h>
    9997#include <adt/hash_table.h>
    10098#include <adt/list.h>
    101 #include <ipc/ipc.h>
    10299#include <assert.h>
    103100#include <errno.h>
    … …  
    105102#include <arch/barrier.h>
    106103#include <bool.h>
     104#include "private/async.h"
    107105
    108106atomic_t async_futex = FUTEX_INITIALIZER;
    … …  
    124122
    125123/**
    126  * Structures of this type are used to group information about a call and a
    127  * message queue link.
     124 * Structures of this type are used to group information about
     125 * a call and about a message queue link.
    128126 */
    129127typedef struct {
    … …  
    134132
    135133typedef struct {
     134        sysarg_t in_task_hash;
     135        link_t link;
     136        int refcnt;
     137        void *data;
     138} client_t;
     139
     140typedef struct {
    136141        awaiter_t wdata;
    137142       
    … …  
    139144        link_t link;
    140145       
     146        /** Incoming client task hash. */
     147        sysarg_t in_task_hash;
    141148        /** Incoming phone hash. */
    142149        sysarg_t in_phone_hash;
     150       
     151        /** Link to the client tracking structure. */
     152        client_t *client;
    143153       
    144154        /** Messages that should be delivered to this fibril. */
    … …  
    158168
    159169/** Identifier of the incoming connection handled by the current fibril. */
    160 fibril_local connection_t *FIBRIL_connection;
    161 
    162 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
    163 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call);
     170static fibril_local connection_t *FIBRIL_connection;
     171
     172static void *default_client_data_constructor(void)
     173{
     174        return NULL;
     175}
     176
     177static void default_client_data_destructor(void *data)
     178{
     179}
     180
     181static async_client_data_ctor_t async_client_data_create =
     182    default_client_data_constructor;
     183static async_client_data_dtor_t async_client_data_destroy =
     184    default_client_data_destructor;
     185
     186void async_set_client_data_constructor(async_client_data_ctor_t ctor)
     187{
     188        async_client_data_create = ctor;
     189}
     190
     191void async_set_client_data_destructor(async_client_data_dtor_t dtor)
     192{
     193        async_client_data_destroy = dtor;
     194}
     195
     196void *async_client_data_get(void)
     197{
     198        assert(FIBRIL_connection);
     199        return FIBRIL_connection->client->data;
     200}
     201
     202/** Default fibril function that gets called to handle new connection.
     203 *
     204 * This function is defined as a weak symbol - to be redefined in user code.
     205 *
     206 * @param callid Hash of the incoming call.
     207 * @param call   Data of the incoming call.
     208 *
     209 */
     210static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
     211{
     212        ipc_answer_0(callid, ENOENT);
     213}
    164214
    165215/**
    … …  
    167217 */
    168218static async_client_conn_t client_connection = default_client_connection;
     219
     220/** Default fibril function that gets called to handle interrupt notifications.
     221 *
     222 * This function is defined as a weak symbol - to be redefined in user code.
     223 *
     224 * @param callid Hash of the incoming call.
     225 * @param call   Data of the incoming call.
     226 *
     227 */
     228static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
     229{
     230}
    169231
    170232/**
    … …  
    174236static async_client_conn_t interrupt_received = default_interrupt_received;
    175237
     238static hash_table_t client_hash_table;
    176239static hash_table_t conn_hash_table;
    177240static LIST_INITIALIZE(timeout_list);
    178241
    179 #define CONN_HASH_TABLE_CHAINS  32
     242#define CLIENT_HASH_TABLE_BUCKETS  32
     243#define CONN_HASH_TABLE_BUCKETS    32
     244
     245static hash_index_t client_hash(unsigned long key[])
     246{
     247        assert(key);
     248        return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS);
     249}
     250
     251static int client_compare(unsigned long key[], hash_count_t keys, link_t *item)
     252{
     253        client_t *client = hash_table_get_instance(item, client_t, link);
     254        return (key[0] == client->in_task_hash);
     255}
     256
     257static void client_remove(link_t *item)
     258{
     259}
     260
     261/** Operations for the client hash table. */
     262static hash_table_operations_t client_hash_table_ops = {
     263        .hash = client_hash,
     264        .compare = client_compare,
     265        .remove_callback = client_remove
     266};
    180267
    181268/** Compute hash into the connection hash table based on the source phone hash.
    … …  
    186273 *
    187274 */
    188 static hash_index_t conn_hash(unsigned long *key)
     275static hash_index_t conn_hash(unsigned long key[])
    189276{
    190277        assert(key);
    191         return (((*key) >> 4) % CONN_HASH_TABLE_CHAINS);
     278        return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS);
    192279}
    193280
    … …  
    203290static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
    204291{
    205         connection_t *hs = hash_table_get_instance(item, connection_t, link);
    206         return (key[0] == hs->in_phone_hash);
     292        connection_t *conn = hash_table_get_instance(item, connection_t, link);
     293        return (key[0] == conn->in_phone_hash);
    207294}
    208295
    … …  
    219306        free(hash_table_get_instance(item, connection_t, link));
    220307}
    221 
    222308
    223309/** Operations for the connection hash table. */
    … …  
    240326        link_t *tmp = timeout_list.next;
    241327        while (tmp != &timeout_list) {
    242                 awaiter_t *cur;
    243                
    244                 cur = list_get_instance(tmp, awaiter_t, to_event.link);
     328                awaiter_t *cur
     329                    = list_get_instance(tmp, awaiter_t, to_event.link);
     330               
    245331                if (tv_gteq(&cur->to_event.expires, &wd->to_event.expires))
    246332                        break;
     333               
    247334                tmp = tmp->next;
    248335        }
    … …  
    261348 *
    262349 * @return False if the call doesn't match any connection.
    263  *         True if the call was passed to the respective connection fibril.
     350 * @return True if the call was passed to the respective connection fibril.
    264351 *
    265352 */
    … …  
    352439       
    353440        fid_t fid = fibril_create(notification_fibril, msg);
     441        if (fid == 0) {
     442                free(msg);
     443                futex_up(&async_futex);
     444                return false;
     445        }
     446       
    354447        fibril_add_ready(fid);
    355448       
    … …  
    398491                         * the first IPC_M_PHONE_HUNGUP call and continues to
    399492                         * call async_get_call_timeout(). Repeat
    400                          * IPC_M_PHONE_HUNGUP until the caller notices. 
     493                         * IPC_M_PHONE_HUNGUP until the caller notices.
    401494                         */
    402495                        memset(call, 0, sizeof(ipc_call_t));
    … …  
    405498                        return conn->close_callid;
    406499                }
    407 
     500               
    408501                if (usecs)
    409502                        async_insert_timeout(&conn->wdata);
    … …  
    443536}
    444537
    445 /** Default fibril function that gets called to handle new connection.
    446  *
    447  * This function is defined as a weak symbol - to be redefined in user code.
    448  *
    449  * @param callid Hash of the incoming call.
    450  * @param call   Data of the incoming call.
    451  *
    452  */
    453 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
    454 {
    455         ipc_answer_0(callid, ENOENT);
    456 }
    457 
    458 /** Default fibril function that gets called to handle interrupt notifications.
    459  *
    460  * This function is defined as a weak symbol - to be redefined in user code.
    461  *
    462  * @param callid Hash of the incoming call.
    463  * @param call   Data of the incoming call.
    464  *
    465  */
    466 static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
    467 {
    468 }
    469 
    470538/** Wrapper for client connection fibril.
    471539 *
    … …  
    481549{
    482550        /*
    483          * Setup fibril-local connection pointer and call client_connection().
    484          *
     551         * Setup fibril-local connection pointer.
    485552         */
    486553        FIBRIL_connection = (connection_t *) arg;
     554       
     555        futex_down(&async_futex);
     556       
     557        /*
     558         * Add our reference for the current connection in the client task
     559         * tracking structure. If this is the first reference, create and
     560         * hash in a new tracking structure.
     561         */
     562       
     563        unsigned long key = FIBRIL_connection->in_task_hash;
     564        link_t *lnk = hash_table_find(&client_hash_table, &key);
     565       
     566        client_t *client;
     567       
     568        if (lnk) {
     569                client = hash_table_get_instance(lnk, client_t, link);
     570                client->refcnt++;
     571        } else {
     572                client = malloc(sizeof(client_t));
     573                if (!client) {
     574                        ipc_answer_0(FIBRIL_connection->callid, ENOMEM);
     575                        futex_up(&async_futex);
     576                        return 0;
     577                }
     578               
     579                client->in_task_hash = FIBRIL_connection->in_task_hash;
     580               
     581                async_serialize_start();
     582                client->data = async_client_data_create();
     583                async_serialize_end();
     584               
     585                client->refcnt = 1;
     586                hash_table_insert(&client_hash_table, &key, &client->link);
     587        }
     588       
     589        futex_up(&async_futex);
     590       
     591        FIBRIL_connection->client = client;
     592       
     593        /*
     594         * Call the connection handler function.
     595         */
    487596        FIBRIL_connection->cfibril(FIBRIL_connection->callid,
    488597            &FIBRIL_connection->call);
    489598       
    490         /* Remove myself from the connection hash table */
     599        /*
     600         * Remove the reference for this client task connection.
     601         */
     602        bool destroy;
     603       
    491604        futex_down(&async_futex);
    492         unsigned long key = FIBRIL_connection->in_phone_hash;
     605       
     606        if (--client->refcnt == 0) {
     607                hash_table_remove(&client_hash_table, &key, 1);
     608                destroy = true;
     609        } else
     610                destroy = false;
     611       
     612        futex_up(&async_futex);
     613       
     614        if (destroy) {
     615                if (client->data)
     616                        async_client_data_destroy(client->data);
     617               
     618                free(client);
     619        }
     620       
     621        /*
     622         * Remove myself from the connection hash table.
     623         */
     624        futex_down(&async_futex);
     625        key = FIBRIL_connection->in_phone_hash;
    493626        hash_table_remove(&conn_hash_table, &key, 1);
    494627        futex_up(&async_futex);
    495628       
    496         /* Answer all remaining messages with EHANGUP */
     629        /*
     630         * Answer all remaining messages with EHANGUP.
     631         */
    497632        while (!list_empty(&FIBRIL_connection->msg_queue)) {
    498                 msg_t *msg;
    499                
    500                 msg = list_get_instance(FIBRIL_connection->msg_queue.next,
    501                     msg_t, link);
     633                msg_t *msg =
     634                    list_get_instance(FIBRIL_connection->msg_queue.next, msg_t,
     635                    link);
     636               
    502637                list_remove(&msg->link);
    503638                ipc_answer_0(msg->callid, EHANGUP);
    … …  
    505640        }
    506641       
     642        /*
     643         * If the connection was hung-up, answer the last call,
     644         * i.e. IPC_M_PHONE_HUNGUP.
     645         */
    507646        if (FIBRIL_connection->close_callid)
    508647                ipc_answer_0(FIBRIL_connection->close_callid, EOK);
    … …  
    517656 * particular fibrils.
    518657 *
     658 * @param in_task_hash  Identification of the incoming connection.
    519659 * @param in_phone_hash Identification of the incoming connection.
    520660 * @param callid        Hash of the opening IPC_M_CONNECT_ME_TO call.
    … …  
    529669 *
    530670 */
    531 fid_t async_new_connection(sysarg_t in_phone_hash, ipc_callid_t callid,
    532     ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *))
     671fid_t async_new_connection(sysarg_t in_task_hash, sysarg_t in_phone_hash,
     672    ipc_callid_t callid, ipc_call_t *call,
     673    void (*cfibril)(ipc_callid_t, ipc_call_t *))
    533674{
    534675        connection_t *conn = malloc(sizeof(*conn));
    … …  
    536677                if (callid)
    537678                        ipc_answer_0(callid, ENOMEM);
     679               
    538680                return (uintptr_t) NULL;
    539681        }
    540682       
     683        conn->in_task_hash = in_task_hash;
    541684        conn->in_phone_hash = in_phone_hash;
    542685        list_initialize(&conn->msg_queue);
    … …  
    552695        conn->wdata.fid = fibril_create(connection_fibril, conn);
    553696       
    554         if (!conn->wdata.fid) {
     697        if (conn->wdata.fid == 0) {
    555698                free(conn);
     699               
    556700                if (callid)
    557701                        ipc_answer_0(callid, ENOMEM);
     702               
    558703                return (uintptr_t) NULL;
    559704        }
    … …  
    582727static void handle_call(ipc_callid_t callid, ipc_call_t *call)
    583728{
    584         /* Unrouted call - do some default behaviour */
     729        /* Unrouted call - take some default action */
    585730        if ((callid & IPC_CALLID_NOTIFICATION)) {
    586731                process_notification(callid, call);
    587                 goto out;
     732                return;
    588733        }
    589734       
    … …  
    591736        case IPC_M_CONNECT_ME:
    592737        case IPC_M_CONNECT_ME_TO:
    593                 /* Open new connection with fibril etc. */
    594                 async_new_connection(IPC_GET_ARG5(*call), callid, call,
    595                     client_connection);
    596                 goto out;
     738                /* Open new connection with fibril, etc. */
     739                async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call),
     740                    callid, call, client_connection);
     741                return;
    597742        }
    598743       
    599744        /* Try to route the call through the connection hash table */
    600745        if (route_call(callid, call))
    601                 goto out;
     746                return;
    602747       
    603748        /* Unknown call from unknown phone - hang it up */
    604749        ipc_answer_0(callid, EHANGUP);
    605         return;
    606        
    607 out:
    608         ;
    609750}
    610751
    … …  
    619760        link_t *cur = timeout_list.next;
    620761        while (cur != &timeout_list) {
    621                 awaiter_t *waiter;
    622                
    623                 waiter = list_get_instance(cur, awaiter_t, to_event.link);
     762                awaiter_t *waiter =
     763                    list_get_instance(cur, awaiter_t, to_event.link);
     764               
    624765                if (tv_gt(&waiter->to_event.expires, &tv))
    625766                        break;
    626 
     767               
    627768                cur = cur->next;
    628 
     769               
    629770                list_remove(&waiter->to_event.link);
    630771                waiter->to_event.inlist = false;
    … …  
    653794        while (true) {
    654795                if (fibril_switch(FIBRIL_FROM_MANAGER)) {
    655                         futex_up(&async_futex); 
     796                        futex_up(&async_futex);
    656797                        /*
    657798                         * async_futex is always held when entering a manager
    … …  
    676817                                continue;
    677818                        } else
    678                                 timeout = tv_sub(&waiter->to_event.expires,
    679                                     &tv);
     819                                timeout = tv_sub(&waiter->to_event.expires, &tv);
    680820                } else
    681821                        timeout = SYNCH_NO_TIMEOUT;
    682822               
    683823                futex_up(&async_futex);
    684 
     824               
    685825                atomic_inc(&threads_in_ipc_wait);
    686826               
    … …  
    690830               
    691831                atomic_dec(&threads_in_ipc_wait);
    692 
     832               
    693833                if (!callid) {
    694834                        handle_expired_timeouts();
    … …  
    729869{
    730870        fid_t fid = fibril_create(async_manager_fibril, NULL);
    731         fibril_add_manager(fid);
     871        if (fid != 0)
     872                fibril_add_manager(fid);
    732873}
    733874
    … …  
    740881/** Initialize the async framework.
    741882 *
    742  * @return Zero on success or an error code.
    743  */
    744 int __async_init(void)
    745 {
    746         if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1,
    747             &conn_hash_table_ops)) {
    748                 printf("%s: Cannot create async hash table\n", "libc");
    749                 return ENOMEM;
    750         }
    751 
    752         _async_sess_init();
    753        
    754         return 0;
     883 */
     884void __async_init(void)
     885{
     886        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1,
     887            &client_hash_table_ops))
     888                abort();
     889       
     890        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, 1,
     891            &conn_hash_table_ops))
     892                abort();
    755893}
    756894
    … …  
    765903 * @param retval Value returned in the answer.
    766904 * @param data   Call data of the answer.
     905 *
    767906 */
    768907static void reply_received(void *arg, int retval, ipc_call_t *data)
    … …  
    812951    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
    813952{
    814         amsg_t *msg = malloc(sizeof(*msg));
     953        amsg_t *msg = malloc(sizeof(amsg_t));
    815954       
    816955        if (!msg)
    … …  
    821960       
    822961        msg->wdata.to_event.inlist = false;
    823         /* We may sleep in the next method, but it will use its own mechanism */
     962       
     963        /*
     964         * We may sleep in the next method,
     965         * but it will use its own means
     966         */
    824967        msg->wdata.active = true;
    825968       
    … …  
    852995    ipc_call_t *dataptr)
    853996{
    854         amsg_t *msg = malloc(sizeof(*msg));
     997        amsg_t *msg = malloc(sizeof(amsg_t));
    855998       
    856999        if (!msg)
    … …  
    8611004       
    8621005        msg->wdata.to_event.inlist = false;
    863         /* We may sleep in next method, but it will use its own mechanism */
     1006       
     1007        /*
     1008         * We may sleep in the next method,
     1009         * but it will use its own means
     1010         */
    8641011        msg->wdata.active = true;
    8651012       
    … …  
    9601107void async_usleep(suseconds_t timeout)
    9611108{
    962         amsg_t *msg = malloc(sizeof(*msg));
     1109        amsg_t *msg = malloc(sizeof(amsg_t));
    9631110       
    9641111        if (!msg)
    … …  
    11031250}
    11041251
     1252void async_msg_0(int phone, sysarg_t imethod)
     1253{
     1254        ipc_call_async_0(phone, imethod, NULL, NULL, true);
     1255}
     1256
     1257void async_msg_1(int phone, sysarg_t imethod, sysarg_t arg1)
     1258{
     1259        ipc_call_async_1(phone, imethod, arg1, NULL, NULL, true);
     1260}
     1261
     1262void async_msg_2(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2)
     1263{
     1264        ipc_call_async_2(phone, imethod, arg1, arg2, NULL, NULL, true);
     1265}
     1266
     1267void async_msg_3(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
     1268    sysarg_t arg3)
     1269{
     1270        ipc_call_async_3(phone, imethod, arg1, arg2, arg3, NULL, NULL, true);
     1271}
     1272
     1273void async_msg_4(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
     1274    sysarg_t arg3, sysarg_t arg4)
     1275{
     1276        ipc_call_async_4(phone, imethod, arg1, arg2, arg3, arg4, NULL, NULL,
     1277            true);
     1278}
     1279
     1280void async_msg_5(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
     1281    sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
     1282{
     1283        ipc_call_async_5(phone, imethod, arg1, arg2, arg3, arg4, arg5, NULL,
     1284            NULL, true);
     1285}
     1286
     1287sysarg_t async_answer_0(ipc_callid_t callid, sysarg_t retval)
     1288{
     1289        return ipc_answer_0(callid, retval);
     1290}
     1291
     1292sysarg_t async_answer_1(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1)
     1293{
     1294        return ipc_answer_1(callid, retval, arg1);
     1295}
     1296
     1297sysarg_t async_answer_2(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1298    sysarg_t arg2)
     1299{
     1300        return ipc_answer_2(callid, retval, arg1, arg2);
     1301}
     1302
     1303sysarg_t async_answer_3(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1304    sysarg_t arg2, sysarg_t arg3)
     1305{
     1306        return ipc_answer_3(callid, retval, arg1, arg2, arg3);
     1307}
     1308
     1309sysarg_t async_answer_4(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1310    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
     1311{
     1312        return ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4);
     1313}
     1314
     1315sysarg_t async_answer_5(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     1316    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
     1317{
     1318        return ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5);
     1319}
     1320
     1321int async_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod,
     1322    sysarg_t arg1, sysarg_t arg2, unsigned int mode)
     1323{
     1324        return ipc_forward_fast(callid, phoneid, imethod, arg1, arg2, mode);
     1325}
     1326
     1327int async_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod,
     1328    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
     1329    unsigned int mode)
     1330{
     1331        return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4,
     1332            arg5, mode);
     1333}
     1334
     1335/** Wrapper for making IPC_M_CONNECT_TO_ME calls using the async framework.
     1336 *
     1337 * Ask through phone for a new connection to some service.
     1338 *
     1339 * @param phone           Phone handle used for contacting the other side.
     1340 * @param arg1            User defined argument.
     1341 * @param arg2            User defined argument.
     1342 * @param arg3            User defined argument.
     1343 * @param client_receiver Connection handing routine.
     1344 *
     1345 * @return New phone handle on success or a negative error code.
     1346 *
     1347 */
     1348int async_connect_to_me(int phone, sysarg_t arg1, sysarg_t arg2,
     1349    sysarg_t arg3, async_client_conn_t client_receiver)
     1350{
     1351        sysarg_t task_hash;
     1352        sysarg_t phone_hash;
     1353        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
     1354            NULL, NULL, NULL, &task_hash, &phone_hash);
     1355        if (rc != EOK)
     1356                return rc;
     1357       
     1358        if (client_receiver != NULL)
     1359                async_new_connection(task_hash, phone_hash, 0, NULL,
     1360                    client_receiver);
     1361       
     1362        return EOK;
     1363}
     1364
    11051365/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework.
    1106  * 
     1366 *
    11071367 * Ask through phone for a new connection to some service.
    11081368 *
    1109  * @param phoneid       Phone handle used for contacting the other side.
    1110  * @param arg1          User defined argument.
    1111  * @param arg2          User defined argument.
    1112  * @param arg3          User defined argument.
    1113  *
    1114  * @return              New phone handle on success or a negative error code.
    1115  */
    1116 int
    1117 async_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
    1118 {
    1119         int rc;
     1369 * @param phone Phone handle used for contacting the other side.
     1370 * @param arg1  User defined argument.
     1371 * @param arg2  User defined argument.
     1372 * @param arg3  User defined argument.
     1373 *
     1374 * @return New phone handle on success or a negative error code.
     1375 *
     1376 */
     1377int async_connect_me_to(int phone, sysarg_t arg1, sysarg_t arg2,
     1378    sysarg_t arg3)
     1379{
    11201380        sysarg_t newphid;
    1121 
    1122         rc = async_req_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL,
    1123             NULL, NULL, NULL, &newphid);
    1124        
    1125         if (rc != EOK) 
     1381        int rc = async_req_3_5(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
     1382            NULL, NULL, NULL, NULL, &newphid);
     1383       
     1384        if (rc != EOK)
    11261385                return rc;
    1127 
     1386       
    11281387        return newphid;
    11291388}
    11301389
    11311390/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework.
    1132  * 
     1391 *
    11331392 * Ask through phone for a new connection to some service and block until
    11341393 * success.
    11351394 *
    1136  * @param phoneid       Phone handle used for contacting the other side.
    1137  * @param arg1          User defined argument.
    1138  * @param arg2          User defined argument.
    1139  * @param arg3          User defined argument.
    1140  *
    1141  * @return              New phone handle on success or a negative error code.
    1142  */
    1143 int
    1144 async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
     1395 * @param phoneid Phone handle used for contacting the other side.
     1396 * @param arg1    User defined argument.
     1397 * @param arg2    User defined argument.
     1398 * @param arg3    User defined argument.
     1399 *
     1400 * @return New phone handle on success or a negative error code.
     1401 *
     1402 */
     1403int async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
    11451404    sysarg_t arg3)
    11461405{
    1147         int rc;
    11481406        sysarg_t newphid;
    1149 
    1150         rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
     1407        int rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
    11511408            IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
    11521409       
    1153         if (rc != EOK) 
     1410        if (rc != EOK)
    11541411                return rc;
    1155 
     1412       
    11561413        return newphid;
    11571414}
    11581415
    1159 /** Wrapper for making IPC_M_SHARE_IN calls using the async framework.
    1160  *
    1161  * @param phoneid       Phone that will be used to contact the receiving side.
    1162  * @param dst           Destination address space area base.
    1163  * @param size          Size of the destination address space area.
    1164  * @param arg           User defined argument.
    1165  * @param flags         Storage where the received flags will be stored. Can be
    1166  *                      NULL.
    1167  *
    1168  * @return              Zero on success or a negative error code from errno.h.
     1416/** Connect to a task specified by id.
     1417 *
     1418 */
     1419int async_connect_kbox(task_id_t id)
     1420{
     1421        return ipc_connect_kbox(id);
     1422}
     1423
     1424/** Wrapper for ipc_hangup.
     1425 *
     1426 * @param phone Phone handle to hung up.
     1427 *
     1428 * @return Zero on success or a negative error code.
     1429 *
     1430 */
     1431int async_hangup(int phone)
     1432{
     1433        return ipc_hangup(phone);
     1434}
     1435
     1436/** Interrupt one thread of this task from waiting for IPC. */
     1437void async_poke(void)
     1438{
     1439        ipc_poke();
     1440}
     1441
     1442/** Wrapper for IPC_M_SHARE_IN calls using the async framework.
     1443 *
     1444 * @param phoneid Phone that will be used to contact the receiving side.
     1445 * @param dst     Destination address space area base.
     1446 * @param size    Size of the destination address space area.
     1447 * @param arg     User defined argument.
     1448 * @param flags   Storage for the received flags. Can be NULL.
     1449 *
     1450 * @return Zero on success or a negative error code from errno.h.
     1451 *
    11691452 */
    11701453int async_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
    1171     int *flags)
    1172 {
    1173         int res;
     1454    unsigned int *flags)
     1455{
    11741456        sysarg_t tmp_flags;
    1175         res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
     1457        int res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
    11761458            (sysarg_t) size, arg, NULL, &tmp_flags);
     1459       
    11771460        if (flags)
    1178                 *flags = tmp_flags;
     1461                *flags = (unsigned int) tmp_flags;
     1462       
    11791463        return res;
    11801464}
    … …  
    11821466/** Wrapper for receiving the IPC_M_SHARE_IN calls using the async framework.
    11831467 *
    1184  * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN calls
    1185  * so that the user doesn't have to remember the meaning of each IPC argument.
     1468 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN
     1469 * calls so that the user doesn't have to remember the meaning of each IPC
     1470 * argument.
    11861471 *
    11871472 * So far, this wrapper is to be used from within a connection fibril.
    11881473 *
    1189  * @param callid        Storage where the hash of the IPC_M_SHARE_IN call will
    1190  *                      be stored.
    1191  * @param size          Destination address space area size.   
    1192  *
    1193  * @return              Non-zero on success, zero on failure.
    1194  */
    1195 int async_share_in_receive(ipc_callid_t *callid, size_t *size)
    1196 {
    1197         ipc_call_t data;
    1198        
     1474 * @param callid Storage for the hash of the IPC_M_SHARE_IN call.
     1475 * @param size   Destination address space area size.
     1476 *
     1477 * @return True on success, false on failure.
     1478 *
     1479 */
     1480bool async_share_in_receive(ipc_callid_t *callid, size_t *size)
     1481{
    11991482        assert(callid);
    12001483        assert(size);
    1201 
     1484       
     1485        ipc_call_t data;
    12021486        *callid = async_get_call(&data);
     1487       
    12031488        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN)
    1204                 return 0;
     1489                return false;
     1490       
    12051491        *size = (size_t) IPC_GET_ARG2(data);
    1206         return 1;
     1492        return true;
    12071493}
    12081494
    12091495/** Wrapper for answering the IPC_M_SHARE_IN calls using the async framework.
    12101496 *
    1211  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
    1212  * so that the user doesn't have to remember the meaning of each IPC argument.
    1213  *
    1214  * @param callid        Hash of the IPC_M_DATA_READ call to answer.
    1215  * @param src           Source address space base.
    1216  * @param flags         Flags to be used for sharing. Bits can be only cleared.
    1217  *
    1218  * @return              Zero on success or a value from @ref errno.h on failure.
    1219  */
    1220 int async_share_in_finalize(ipc_callid_t callid, void *src, int flags)
     1497 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
     1498 * calls so that the user doesn't have to remember the meaning of each IPC
     1499 * argument.
     1500 *
     1501 * @param callid Hash of the IPC_M_DATA_READ call to answer.
     1502 * @param src    Source address space base.
     1503 * @param flags  Flags to be used for sharing. Bits can be only cleared.
     1504 *
     1505 * @return Zero on success or a value from @ref errno.h on failure.
     1506 *
     1507 */
     1508int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
    12211509{
    12221510        return ipc_share_in_finalize(callid, src, flags);
    12231511}
    12241512
    1225 /** Wrapper for making IPC_M_SHARE_OUT calls using the async framework.
    1226  *
    1227  * @param phoneid       Phone that will be used to contact the receiving side.
    1228  * @param src           Source address space area base address.
    1229  * @param flags         Flags to be used for sharing. Bits can be only cleared.
    1230  *
    1231  * @return              Zero on success or a negative error code from errno.h.
    1232  */
    1233 int async_share_out_start(int phoneid, void *src, int flags)
     1513/** Wrapper for IPC_M_SHARE_OUT calls using the async framework.
     1514 *
     1515 * @param phoneid Phone that will be used to contact the receiving side.
     1516 * @param src     Source address space area base address.
     1517 * @param flags   Flags to be used for sharing. Bits can be only cleared.
     1518 *
     1519 * @return Zero on success or a negative error code from errno.h.
     1520 *
     1521 */
     1522int async_share_out_start(int phoneid, void *src, unsigned int flags)
    12341523{
    12351524        return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
    … …  
    12391528/** Wrapper for receiving the IPC_M_SHARE_OUT calls using the async framework.
    12401529 *
    1241  * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT calls
    1242  * so that the user doesn't have to remember the meaning of each IPC argument.
     1530 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT
     1531 * calls so that the user doesn't have to remember the meaning of each IPC
     1532 * argument.
    12431533 *
    12441534 * So far, this wrapper is to be used from within a connection fibril.
    12451535 *
    1246  * @param callid        Storage where the hash of the IPC_M_SHARE_OUT call will
    1247  *                      be stored.
    1248  * @param size          Storage where the source address space area size will be
    1249  *                      stored.
    1250  * @param flags         Storage where the sharing flags will be stored.
    1251  *
    1252  * @return              Non-zero on success, zero on failure.
    1253  */
    1254 int async_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags)
    1255 {
    1256         ipc_call_t data;
    1257        
     1536 * @param callid Storage for the hash of the IPC_M_SHARE_OUT call.
     1537 * @param size   Storage for the source address space area size.
     1538 * @param flags  Storage for the sharing flags.
     1539 *
     1540 * @return True on success, false on failure.
     1541 *
     1542 */
     1543bool async_share_out_receive(ipc_callid_t *callid, size_t *size, unsigned int *flags)
     1544{
    12581545        assert(callid);
    12591546        assert(size);
    12601547        assert(flags);
    1261 
     1548       
     1549        ipc_call_t data;
    12621550        *callid = async_get_call(&data);
     1551       
    12631552        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT)
    1264                 return 0;
     1553                return false;
     1554       
    12651555        *size = (size_t) IPC_GET_ARG2(data);
    1266         *flags = (int) IPC_GET_ARG3(data);
    1267         return 1;
     1556        *flags = (unsigned int) IPC_GET_ARG3(data);
     1557        return true;
    12681558}
    12691559
    12701560/** Wrapper for answering the IPC_M_SHARE_OUT calls using the async framework.
    12711561 *
    1272  * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls
    1273  * so that the user doesn't have to remember the meaning of each IPC argument.
    1274  *
    1275  * @param callid        Hash of the IPC_M_DATA_WRITE call to answer.
    1276  * @param dst           Destination address space area base address.   
    1277  *
    1278  * @return              Zero on success or a value from @ref errno.h on failure.
     1562 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT
     1563 * calls so that the user doesn't have to remember the meaning of each IPC
     1564 * argument.
     1565 *
     1566 * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
     1567 * @param dst    Destination address space area base address.
     1568 *
     1569 * @return Zero on success or a value from @ref errno.h on failure.
     1570 *
    12791571 */
    12801572int async_share_out_finalize(ipc_callid_t callid, void *dst)
    … …  
    12831575}
    12841576
    1285 
    1286 /** Wrapper for making IPC_M_DATA_READ calls using the async framework.
    1287  *
    1288  * @param phoneid       Phone that will be used to contact the receiving side.
    1289  * @param dst           Address of the beginning of the destination buffer.
    1290  * @param size          Size of the destination buffer.
    1291  *
    1292  * @return              Zero on success or a negative error code from errno.h.
     1577/** Wrapper for IPC_M_DATA_READ calls using the async framework.
     1578 *
     1579 * @param phoneid Phone that will be used to contact the receiving side.
     1580 * @param dst     Address of the beginning of the destination buffer.
     1581 * @param size    Size of the destination buffer.
     1582 *
     1583 * @return Zero on success or a negative error code from errno.h.
     1584 *
    12931585 */
    12941586int async_data_read_start(int phoneid, void *dst, size_t size)
    … …  
    13001592/** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
    13011593 *
    1302  * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ calls
    1303  * so that the user doesn't have to remember the meaning of each IPC argument.
     1594 * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ
     1595 * calls so that the user doesn't have to remember the meaning of each IPC
     1596 * argument.
    13041597 *
    13051598 * So far, this wrapper is to be used from within a connection fibril.
    13061599 *
    1307  * @param callid        Storage where the hash of the IPC_M_DATA_READ call will
    1308  *                      be stored.
    1309  * @param size          Storage where the maximum size will be stored. Can be
    1310  *                      NULL.
    1311  *
    1312  * @return              Non-zero on success, zero on failure.
    1313  */
    1314 int async_data_read_receive(ipc_callid_t *callid, size_t *size)
    1315 {
     1600 * @param callid Storage for the hash of the IPC_M_DATA_READ.
     1601 * @param size   Storage for the maximum size. Can be NULL.
     1602 *
     1603 * @return True on success, false on failure.
     1604 *
     1605 */
     1606bool async_data_read_receive(ipc_callid_t *callid, size_t *size)
     1607{
     1608        assert(callid);
     1609       
    13161610        ipc_call_t data;
    1317        
    1318         assert(callid);
    1319 
    13201611        *callid = async_get_call(&data);
     1612       
    13211613        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
    1322                 return 0;
     1614                return false;
     1615       
    13231616        if (size)
    13241617                *size = (size_t) IPC_GET_ARG2(data);
    1325         return 1;
     1618       
     1619        return true;
    13261620}
    13271621
    13281622/** Wrapper for answering the IPC_M_DATA_READ calls using the async framework.
    13291623 *
    1330  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
    1331  * so that the user doesn't have to remember the meaning of each IPC argument.
    1332  *
    1333  * @param callid        Hash of the IPC_M_DATA_READ call to answer.
    1334  * @param src           Source address for the IPC_M_DATA_READ call.
    1335  * @param size          Size for the IPC_M_DATA_READ call. Can be smaller than
    1336  *                      the maximum size announced by the sender.
    1337  *
    1338  * @return              Zero on success or a value from @ref errno.h on failure.
     1624 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
     1625 * calls so that the user doesn't have to remember the meaning of each IPC
     1626 * argument.
     1627 *
     1628 * @param callid Hash of the IPC_M_DATA_READ call to answer.
     1629 * @param src    Source address for the IPC_M_DATA_READ call.
     1630 * @param size   Size for the IPC_M_DATA_READ call. Can be smaller than
     1631 *               the maximum size announced by the sender.
     1632 *
     1633 * @return Zero on success or a value from @ref errno.h on failure.
     1634 *
    13391635 */
    13401636int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
    … …  
    13441640
    13451641/** Wrapper for forwarding any read request
    1346  *
    13471642 *
    13481643 */
    … …  
    13771672}
    13781673
    1379 /** Wrapper for making IPC_M_DATA_WRITE calls using the async framework.
     1674/** Wrapper for IPC_M_DATA_WRITE calls using the async framework.
    13801675 *
    13811676 * @param phoneid Phone that will be used to contact the receiving side.
    … …  
    13941689/** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
    13951690 *
    1396  * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE calls
    1397  * so that the user doesn't have to remember the meaning of each IPC argument.
     1691 * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE
     1692 * calls so that the user doesn't have to remember the meaning of each IPC
     1693 * argument.
    13981694 *
    13991695 * So far, this wrapper is to be used from within a connection fibril.
    14001696 *
    1401  * @param callid Storage where the hash of the IPC_M_DATA_WRITE call will
    1402  *               be stored.
    1403  * @param size   Storage where the suggested size will be stored. May be
    1404  *               NULL
    1405  *
    1406  * @return Non-zero on success, zero on failure.
    1407  *
    1408  */
    1409 int async_data_write_receive(ipc_callid_t *callid, size_t *size)
    1410 {
     1697 * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
     1698 * @param size   Storage for the suggested size. May be NULL.
     1699 *
     1700 * @return True on success, false on failure.
     1701 *
     1702 */
     1703bool async_data_write_receive(ipc_callid_t *callid, size_t *size)
     1704{
     1705        assert(callid);
     1706       
    14111707        ipc_call_t data;
    1412        
    1413         assert(callid);
    1414        
    14151708        *callid = async_get_call(&data);
     1709       
    14161710        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
    1417                 return 0;
     1711                return false;
    14181712       
    14191713        if (size)
    14201714                *size = (size_t) IPC_GET_ARG2(data);
    14211715       
    1422         return 1;
     1716        return true;
    14231717}
    14241718
    14251719/** Wrapper for answering the IPC_M_DATA_WRITE calls using the async framework.
    14261720 *
    1427  * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls
    1428  * so that the user doesn't have to remember the meaning of each IPC argument.
     1721 * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE
     1722 * calls so that the user doesn't have to remember the meaning of each IPC
     1723 * argument.
    14291724 *
    14301725 * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
    … …  
    15221817 *
    15231818 */
    1524 void async_data_write_void(const int retval)
     1819void async_data_write_void(sysarg_t retval)
    15251820{
    15261821        ipc_callid_t callid;
    … …  
    15301825
    15311826/** Wrapper for forwarding any data that is about to be received
    1532  *
    15331827 *
    15341828 */

  • uspace/lib/c/generic/async_sess.c

    r22027b6e r8b5690f  
    9999
    100100#include <async_sess.h>
    101 #include <ipc/ipc.h>
    102101#include <fibril_synch.h>
    103102#include <adt/list.h>
    … …  
    106105#include <errno.h>
    107106#include <assert.h>
     107#include "private/async_sess.h"
    108108
    109109/** An inactive open connection. */
    110110typedef struct {
    111111        link_t sess_link;       /**< Link for the session list of inactive connections. */
    112         link_t global_link;     /**< Link for the global list of inactive connectinos. */
     112        link_t global_link;     /**< Link for the global list of inactive connections. */
    113113        int data_phone;         /**< Connected data phone. */
    114114} conn_node_t;
    115115
    116116/**
    117  * Mutex protecting the inactive_conn_head list and the session list.
     117 * Mutex protecting the inactive_conn_head list, the session list and the
     118 * avail_phone condition variable.
    118119 */
    119120static fibril_mutex_t async_sess_mutex;
    … …  
    129130static LIST_INITIALIZE(session_list_head);
    130131
     132/**
     133 * Condition variable used to wait for a phone to become available.
     134 */
     135static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv);
     136
    131137/** Initialize the async_sess subsystem.
    132138 *
    133139 * Needs to be called prior to any other interface in this file.
    134  */
    135 void _async_sess_init(void)
     140 *
     141 */
     142void __async_sess_init(void)
    136143{
    137144        fibril_mutex_initialize(&async_sess_mutex);
    … …  
    194201                list_remove(&conn->global_link);
    195202               
    196                 ipc_hangup(conn->data_phone);
     203                async_hangup(conn->data_phone);
    197204                free(conn);
    198205        }
     206       
     207        fibril_condvar_broadcast(&avail_phone_cv);
    199208}
    200209
    … …  
    252261                        data_phone = conn->data_phone;
    253262                        free(conn);
    254                         ipc_hangup(data_phone);
     263                        async_hangup(data_phone);
    255264                        goto retry;
    256265                } else {
    257266                        /*
    258                          * This is unfortunate. We failed both to find a cached
    259                          * connection or to create a new one even after cleaning up
    260                          * the cache. This is most likely due to too many
    261                          * open sessions (connected session phones).
     267                         * Wait for a phone to become available.
    262268                         */
    263                         data_phone = ELIMIT;
     269                        fibril_condvar_wait(&avail_phone_cv, &async_sess_mutex);
     270                        goto retry;
    264271                }
    265272        }
    … …  
    279286
    280287        fibril_mutex_lock(&async_sess_mutex);
     288        fibril_condvar_signal(&avail_phone_cv);
    281289        conn = (conn_node_t *) malloc(sizeof(conn_node_t));
    282290        if (!conn) {
    … …  
    285293                 * means that we simply hang up.
    286294                 */
     295                async_hangup(data_phone);
    287296                fibril_mutex_unlock(&async_sess_mutex);
    288                 ipc_hangup(data_phone);
    289297                return;
    290298        }

  • uspace/lib/c/generic/clipboard.c

    r22027b6e r8b5690f  
    3939
    4040#include <clipboard.h>
     41#include <ipc/ns.h>
    4142#include <ipc/services.h>
    4243#include <ipc/clipboard.h>
    … …  
    5455{
    5556        while (clip_phone < 0)
    56                 clip_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_CLIPBOARD, 0, 0);
     57                clip_phone = service_connect_blocking(SERVICE_CLIPBOARD, 0, 0);
    5758}
    5859

  • uspace/lib/c/generic/ddi.c

    r22027b6e r8b5690f  
    9696}
    9797
    98 /** Enable an interrupt.
    99  *
    100  * @param irq the interrupt.
    101  *
    102  * @return Zero on success, negative error code otherwise.
    103  */
    104 int interrupt_enable(int irq)
    105 {
    106         return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 1);
    107 }
    108 
    109 /** Disable an interrupt.
    110  *
    111  * @param irq the interrupt.
    112  *
    113  * @return Zero on success, negative error code otherwise.
    114  */
    115 int interrupt_disable(int irq)
    116 {
    117         return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 0);
    118 }
    119 
    12098/** Enable PIO for specified I/O range.
    12199 *
    … …  
    149127}
    150128
     129/** Register IRQ notification.
     130 *
     131 * @param inr    IRQ number.
     132 * @param devno  Device number of the device generating inr.
     133 * @param method Use this method for notifying me.
     134 * @param ucode  Top-half pseudocode handler.
     135 *
     136 * @return Value returned by the kernel.
     137 *
     138 */
     139int register_irq(int inr, int devno, int method, irq_code_t *ucode)
     140{
     141        return __SYSCALL4(SYS_REGISTER_IRQ, inr, devno, method,
     142            (sysarg_t) ucode);
     143}
     144
     145/** Unregister IRQ notification.
     146 *
     147 * @param inr   IRQ number.
     148 * @param devno Device number of the device generating inr.
     149 *
     150 * @return Value returned by the kernel.
     151 *
     152 */
     153int unregister_irq(int inr, int devno)
     154{
     155        return __SYSCALL2(SYS_UNREGISTER_IRQ, inr, devno);
     156}
     157
    151158/** @}
    152159 */

  • uspace/lib/c/generic/devman.c

    r22027b6e r8b5690f  
    2828 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929 */
    30  
    31  /** @addtogroup libc
     30
     31/** @addtogroup libc
    3232 * @{
    3333 */
    … …  
    3737#include <str.h>
    3838#include <stdio.h>
    39 #include <ipc/ipc.h>
    4039#include <ipc/services.h>
    4140#include <ipc/devman.h>
    4241#include <devman.h>
    4342#include <async.h>
     43#include <fibril_synch.h>
    4444#include <errno.h>
    4545#include <malloc.h>
    … …  
    5050static int devman_phone_client = -1;
    5151
     52static FIBRIL_MUTEX_INITIALIZE(devman_phone_mutex);
     53
    5254int devman_get_phone(devman_interface_t iface, unsigned int flags)
    5355{
    5456        switch (iface) {
    5557        case DEVMAN_DRIVER:
    56                 if (devman_phone_driver >= 0)
     58                fibril_mutex_lock(&devman_phone_mutex);
     59                if (devman_phone_driver >= 0) {
     60                        fibril_mutex_unlock(&devman_phone_mutex);
    5761                        return devman_phone_driver;
     62                }
    5863               
    5964                if (flags & IPC_FLAG_BLOCKING)
    … …  
    6469                            SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
    6570               
     71                fibril_mutex_unlock(&devman_phone_mutex);
    6672                return devman_phone_driver;
    6773        case DEVMAN_CLIENT:
    68                 if (devman_phone_client >= 0)
     74                fibril_mutex_lock(&devman_phone_mutex);
     75                if (devman_phone_client >= 0) {
     76                        fibril_mutex_unlock(&devman_phone_mutex);
    6977                        return devman_phone_client;
    70                
    71                 if (flags & IPC_FLAG_BLOCKING)
     78                }
     79               
     80                if (flags & IPC_FLAG_BLOCKING) {
    7281                        devman_phone_client = async_connect_me_to_blocking(
    7382                            PHONE_NS, SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
    74                 else
     83                } else {
    7584                        devman_phone_client = async_connect_me_to(PHONE_NS,
    7685                            SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
    77                
     86                }
     87               
     88                fibril_mutex_unlock(&devman_phone_mutex);
    7889                return devman_phone_client;
    7990        default:
    … …  
    104115        async_set_client_connection(conn);
    105116       
    106         sysarg_t callback_phonehash;
    107         ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
     117        async_connect_to_me(phone, 0, 0, 0, NULL);
    108118        async_wait_for(req, &retval);
    109119       
    … …  
    210220        case DEVMAN_DRIVER:
    211221                if (devman_phone_driver >= 0) {
    212                         ipc_hangup(devman_phone_driver);
     222                        async_hangup(devman_phone_driver);
    213223                        devman_phone_driver = -1;
    214224                }
    … …  
    216226        case DEVMAN_CLIENT:
    217227                if (devman_phone_client >= 0) {
    218                         ipc_hangup(devman_phone_client);
     228                        async_hangup(devman_phone_client);
    219229                        devman_phone_client = -1;
    220230                }

  • uspace/lib/c/generic/devmap.c

    r22027b6e r8b5690f  
    2929
    3030#include <str.h>
    31 #include <ipc/ipc.h>
    3231#include <ipc/services.h>
     32#include <ipc/ns.h>
    3333#include <ipc/devmap.h>
    3434#include <devmap.h>
    … …  
    5050               
    5151                if (flags & IPC_FLAG_BLOCKING)
    52                         devmap_phone_driver = ipc_connect_me_to_blocking(PHONE_NS,
    53                             SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
     52                        devmap_phone_driver = service_connect_blocking(SERVICE_DEVMAP,
     53                            DEVMAP_DRIVER, 0);
    5454                else
    55                         devmap_phone_driver = ipc_connect_me_to(PHONE_NS,
    56                             SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
     55                        devmap_phone_driver = service_connect(SERVICE_DEVMAP,
     56                            DEVMAP_DRIVER, 0);
    5757               
    5858                return devmap_phone_driver;
    … …  
    6262               
    6363                if (flags & IPC_FLAG_BLOCKING)
    64                         devmap_phone_client = ipc_connect_me_to_blocking(PHONE_NS,
    65                             SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
     64                        devmap_phone_client = service_connect_blocking(SERVICE_DEVMAP,
     65                            DEVMAP_CLIENT, 0);
    6666                else
    67                         devmap_phone_client = ipc_connect_me_to(PHONE_NS,
    68                             SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
     67                        devmap_phone_client = service_connect(SERVICE_DEVMAP,
     68                            DEVMAP_CLIENT, 0);
    6969               
    7070                return devmap_phone_client;
    … …  
    7979        case DEVMAP_DRIVER:
    8080                if (devmap_phone_driver >= 0) {
    81                         ipc_hangup(devmap_phone_driver);
     81                        async_hangup(devmap_phone_driver);
    8282                        devmap_phone_driver = -1;
    8383                }
    … …  
    8585        case DEVMAP_CLIENT:
    8686                if (devmap_phone_client >= 0) {
    87                         ipc_hangup(devmap_phone_client);
     87                        async_hangup(devmap_phone_client);
    8888                        devmap_phone_client = -1;
    8989                }
    … …  
    116116        async_set_client_connection(conn);
    117117       
    118         sysarg_t callback_phonehash;
    119         ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
     118        async_connect_to_me(phone, 0, 0, 0, NULL);
    120119        async_wait_for(req, &retval);
    121120       

  • uspace/lib/c/generic/event.c

    r22027b6e r8b5690f  
    3535 */
    3636/** @file
    37  */ 
     37 */
    3838
    3939#include <libc.h>
    4040#include <event.h>
    4141#include <kernel/ipc/event_types.h>
    42 #include <ipc/ipc.h>
    4342
    4443/** Subscribe for event notifications.

  • uspace/lib/c/generic/fibril_synch.c

    r22027b6e r8b5690f  
    3636#include <fibril.h>
    3737#include <async.h>
    38 #include <async_priv.h>
    3938#include <adt/list.h>
    4039#include <futex.h>
    … …  
    4443#include <stacktrace.h>
    4544#include <stdlib.h>
     45#include "private/async.h"
    4646
    4747static void optimize_execution_power(void)
    … …  
    5555         */
    5656        if (atomic_get(&threads_in_ipc_wait) > 0)
    57                 ipc_poke();
     57                async_poke();
    5858}
    5959
    … …  
    103103{
    104104        fibril_t *f = (fibril_t *) fibril_get_id();
     105
     106        if (fibril_get_sercount() != 0)
     107                abort();
    105108
    106109        futex_down(&async_futex);
    … …  
    194197        fibril_t *f = (fibril_t *) fibril_get_id();
    195198       
     199        if (fibril_get_sercount() != 0)
     200                abort();
     201
    196202        futex_down(&async_futex);
    197203        if (frw->writers) {
    … …  
    219225        fibril_t *f = (fibril_t *) fibril_get_id();
    220226       
     227        if (fibril_get_sercount() != 0)
     228                abort();
     229
    221230        futex_down(&async_futex);
    222231        if (frw->writers || frw->readers) {

  • uspace/lib/c/generic/io/io.c

    r22027b6e r8b5690f  
    4141#include <bool.h>
    4242#include <malloc.h>
     43#include <async.h>
    4344#include <io/klog.h>
    4445#include <vfs/vfs.h>
    4546#include <ipc/devmap.h>
    4647#include <adt/list.h>
     48#include "../private/io.h"
    4749
    4850static void _ffillbuf(FILE *stream);
    … …  
    322324       
    323325        if (stream->phone >= 0)
    324                 ipc_hangup(stream->phone);
     326                async_hangup(stream->phone);
    325327       
    326328        if (stream->fd >= 0)

  • uspace/lib/c/generic/ipc.c

    r22027b6e r8b5690f  
    4545#include <errno.h>
    4646#include <adt/list.h>
    47 #include <stdio.h>
    48 #include <unistd.h>
    4947#include <futex.h>
    50 #include <kernel/synch/synch.h>
    51 #include <async.h>
    5248#include <fibril.h>
    53 #include <assert.h>
    5449
    5550/**
    56  * Structures of this type are used for keeping track of sent asynchronous calls
    57  * and queing unsent calls.
     51 * Structures of this type are used for keeping track
     52 * of sent asynchronous calls and queing unsent calls.
    5853 */
    5954typedef struct {
    6055        link_t list;
    61 
     56       
    6257        ipc_async_callback_t callback;
    6358        void *private;
     59       
    6460        union {
    6561                ipc_callid_t callid;
    … …  
    6965                } msg;
    7066        } u;
    71         fid_t fid;      /**< Fibril waiting for sending this call. */
     67       
     68        /** Fibril waiting for sending this call. */
     69        fid_t fid;
    7270} async_call_t;
    7371
    … …  
    7674/** List of asynchronous calls that were not accepted by kernel.
    7775 *
    78  * It is protected by async_futex, because if the call cannot be sent into the
    79  * kernel, the async framework is used automatically.
     76 * Protected by async_futex, because if the call is not accepted
     77 * by the kernel, the async framework is used automatically.
     78 *
    8079 */
    8180LIST_INITIALIZE(queued_calls);
    … …  
    8382static atomic_t ipc_futex = FUTEX_INITIALIZER;
    8483
    85 /** Make a fast synchronous call.
    86  *
    87  * Only three payload arguments can be passed using this function. However, this
    88  * function is faster than the generic ipc_call_sync_slow() because the payload
    89  * is passed directly in registers.
    90  *
    91  * @param phoneid       Phone handle for the call.
    92  * @param method        Requested method.
    93  * @param arg1          Service-defined payload argument.
    94  * @param arg2          Service-defined payload argument.
    95  * @param arg3          Service-defined payload argument.
    96  * @param result1       If non-NULL, the return ARG1 will be stored there.
    97  * @param result2       If non-NULL, the return ARG2 will be stored there.
    98  * @param result3       If non-NULL, the return ARG3 will be stored there.
    99  * @param result4       If non-NULL, the return ARG4 will be stored there.
    100  * @param result5       If non-NULL, the return ARG5 will be stored there.
    101  *
    102  * @return              Negative values represent errors returned by IPC.
    103  *                      Otherwise the RETVAL of the answer is returned.
    104  */
    105 int
    106 ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1, sysarg_t arg2,
    107     sysarg_t arg3, sysarg_t *result1, sysarg_t *result2, sysarg_t *result3,
    108     sysarg_t *result4, sysarg_t *result5)
     84/** Fast synchronous call.
     85 *
     86 * Only three payload arguments can be passed using this function. However,
     87 * this function is faster than the generic ipc_call_sync_slow() because
     88 * the payload is passed directly in registers.
     89 *
     90 * @param phoneid Phone handle for the call.
     91 * @param method  Requested method.
     92 * @param arg1    Service-defined payload argument.
     93 * @param arg2    Service-defined payload argument.
     94 * @param arg3    Service-defined payload argument.
     95 * @param result1 If non-NULL, the return ARG1 will be stored there.
     96 * @param result2 If non-NULL, the return ARG2 will be stored there.
     97 * @param result3 If non-NULL, the return ARG3 will be stored there.
     98 * @param result4 If non-NULL, the return ARG4 will be stored there.
     99 * @param result5 If non-NULL, the return ARG5 will be stored there.
     100 *
     101 * @return Negative values representing IPC errors.
     102 * @return Otherwise the RETVAL of the answer.
     103 *
     104 */
     105int ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     106    sysarg_t arg2, sysarg_t arg3, sysarg_t *result1, sysarg_t *result2,
     107    sysarg_t *result3, sysarg_t *result4, sysarg_t *result5)
    109108{
    110109        ipc_call_t resdata;
    111         int callres;
    112        
    113         callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
     110        int callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
    114111            arg2, arg3, (sysarg_t) &resdata);
    115112        if (callres)
    116113                return callres;
     114       
    117115        if (result1)
    118116                *result1 = IPC_GET_ARG1(resdata);
    … …  
    125123        if (result5)
    126124                *result5 = IPC_GET_ARG5(resdata);
    127 
     125       
    128126        return IPC_GET_RETVAL(resdata);
    129127}
    130128
    131 /** Make a synchronous call transmitting 5 arguments of payload.
     129/** Synchronous call transmitting 5 arguments of payload.
    132130 *
    133131 * @param phoneid Phone handle for the call.
    … …  
    144142 * @param result5 If non-NULL, storage for the fifth return argument.
    145143 *
    146  * @return Negative value means IPC error.
    147  *         Otherwise the RETVAL of the answer.
    148  *
    149  */
    150 int
    151 ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
    152     sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *result1,
    153     sysarg_t *result2, sysarg_t *result3, sysarg_t *result4, sysarg_t *result5)
     144 * @return Negative values representing IPC errors.
     145 * @return Otherwise the RETVAL of the answer.
     146 *
     147 */
     148int ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
     149    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
     150    sysarg_t *result1, sysarg_t *result2, sysarg_t *result3, sysarg_t *result4,
     151    sysarg_t *result5)
    154152{
    155153        ipc_call_t data;
    … …  
    181179}
    182180
    183 /** Syscall to send asynchronous message.
     181/** Send asynchronous message via syscall.
    184182 *
    185183 * @param phoneid Phone handle for the call.
    … …  
    189187 *
    190188 */
    191 static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
     189static ipc_callid_t ipc_call_async_internal(int phoneid, ipc_call_t *data)
    192190{
    193191        return __SYSCALL2(SYS_IPC_CALL_ASYNC_SLOW, phoneid, (sysarg_t) data);
    194192}
    195193
    196 /** Prolog to ipc_call_async_*() functions.
    197  *
    198  * @param private       Argument for the answer/error callback.
    199  * @param callback      Answer/error callback.
    200  *
    201  * @return              New, partially initialized async_call structure or NULL.
     194/** Prolog for ipc_call_async_*() functions.
     195 *
     196 * @param private  Argument for the answer/error callback.
     197 * @param callback Answer/error callback.
     198 *
     199 * @return New, partially initialized async_call structure or NULL.
     200 *
    202201 */
    203202static inline async_call_t *ipc_prepare_async(void *private,
    204203    ipc_async_callback_t callback)
    205204{
    206         async_call_t *call;
    207 
    208         call = malloc(sizeof(*call));
     205        async_call_t *call =
     206            (async_call_t *) malloc(sizeof(async_call_t));
    209207        if (!call) {
    210208                if (callback)
    211209                        callback(private, ENOMEM, NULL);
     210               
    212211                return NULL;
    213212        }
     213       
    214214        call->callback = callback;
    215215        call->private = private;
    216 
     216       
    217217        return call;
    218218}
    219219
    220 /** Epilogue of ipc_call_async_*() functions.
    221  *
    222  * @param callid        Value returned by the SYS_IPC_CALL_ASYNC_* syscall.
    223  * @param phoneid       Phone handle through which the call was made.
    224  * @param call          async_call structure returned by ipc_prepare_async().
    225  * @param can_preempt   If non-zero, the current fibril can be preempted in this
    226  *                      call.
     220/** Epilog for ipc_call_async_*() functions.
     221 *
     222 * @param callid      Value returned by the SYS_IPC_CALL_ASYNC_* syscall.
     223 * @param phoneid     Phone handle through which the call was made.
     224 * @param call        Structure returned by ipc_prepare_async().
     225 * @param can_preempt If true, the current fibril can be preempted
     226 *                    in this call.
     227 *
    227228 */
    228229static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
    229     async_call_t *call, int can_preempt)
    230 {
    231         if (!call) { /* Nothing to do regardless if failed or not */
     230    async_call_t *call, bool can_preempt)
     231{
     232        if (!call) {
     233                /* Nothing to do regardless if failed or not */
    232234                futex_up(&ipc_futex);
    233235                return;
    234236        }
    235 
     237       
    236238        if (callid == (ipc_callid_t) IPC_CALLRET_FATAL) {
    237239                futex_up(&ipc_futex);
     240               
    238241                /* Call asynchronous handler with error code */
    239242                if (call->callback)
    240243                        call->callback(call->private, ENOENT, NULL);
     244               
    241245                free(call);
    242246                return;
    243247        }
    244 
     248       
    245249        if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
    246250                futex_up(&ipc_futex);
    247 
     251               
    248252                call->u.msg.phoneid = phoneid;
    249253               
    250254                futex_down(&async_futex);
    251255                list_append(&call->list, &queued_calls);
    252 
     256               
    253257                if (can_preempt) {
    254258                        call->fid = fibril_get_id();
    … …  
    259263                        futex_up(&async_futex);
    260264                }
     265               
    261266                return;
    262267        }
     268       
    263269        call->u.callid = callid;
     270       
    264271        /* Add call to the list of dispatched calls */
    265272        list_append(&call->list, &dispatched_calls);
    266273        futex_up(&ipc_futex);
    267        
    268 }
    269 
    270 /** Make a fast asynchronous call.
     274}
     275
     276/** Fast asynchronous call.
    271277 *
    272278 * This function can only handle four arguments of payload. It is, however,
    … …  
    274280 *
    275281 * Note that this function is a void function.
    276  * During normal opertation, answering this call will trigger the callback.
    277  * In case of fatal error, call the callback handler with the proper error code.
    278  * If the call cannot be temporarily made, queue it.
     282 *
     283 * During normal operation, answering this call will trigger the callback.
     284 * In case of fatal error, the callback handler is called with the proper
     285 * error code. If the call cannot be temporarily made, it is queued.
    279286 *
    280287 * @param phoneid     Phone handle for the call.
    … …  
    286293 * @param private     Argument to be passed to the answer/error callback.
    287294 * @param callback    Answer or error callback.
    288  * @param can_preempt If non-zero, the current fibril will be preempted in
     295 * @param can_preempt If true, the current fibril will be preempted in
    289296 *                    case the kernel temporarily refuses to accept more
    290297 *                    asynchronous calls.
    … …  
    293300void ipc_call_async_fast(int phoneid, sysarg_t imethod, sysarg_t arg1,
    294301    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, void *private,
    295     ipc_async_callback_t callback, int can_preempt)
     302    ipc_async_callback_t callback, bool can_preempt)
    296303{
    297304        async_call_t *call = NULL;
    … …  
    304311       
    305312        /*
    306          * We need to make sure that we get callid before another thread
    307          * accesses the queue again.
     313         * We need to make sure that we get callid
     314         * before another thread accesses the queue again.
    308315         */
     316       
    309317        futex_down(&ipc_futex);
    310318        ipc_callid_t callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid,
    … …  
    317325                                return;
    318326                }
     327               
    319328                IPC_SET_IMETHOD(call->u.msg.data, imethod);
    320329                IPC_SET_ARG1(call->u.msg.data, arg1);
    … …  
    322331                IPC_SET_ARG3(call->u.msg.data, arg3);
    323332                IPC_SET_ARG4(call->u.msg.data, arg4);
     333               
    324334                /*
    325335                 * To achieve deterministic behavior, we always zero out the
    326336                 * arguments that are beyond the limits of the fast version.
    327337                 */
     338               
    328339                IPC_SET_ARG5(call->u.msg.data, 0);
    329340        }
     341       
    330342        ipc_finish_async(callid, phoneid, call, can_preempt);
    331343}
    332344
    333 /** Make an asynchronous call transmitting the entire payload.
     345/** Asynchronous call transmitting the entire payload.
    334346 *
    335347 * Note that this function is a void function.
    336  * During normal opertation, answering this call will trigger the callback.
    337  * In case of fatal error, call the callback handler with the proper error code.
    338  * If the call cannot be temporarily made, queue it.
     348 *
     349 * During normal operation, answering this call will trigger the callback.
     350 * In case of fatal error, the callback handler is called with the proper
     351 * error code. If the call cannot be temporarily made, it is queued.
    339352 *
    340353 * @param phoneid     Phone handle for the call.
    … …  
    347360 * @param private     Argument to be passed to the answer/error callback.
    348361 * @param callback    Answer or error callback.
    349  * @param can_preempt If non-zero, the current fibril will be preempted in
     362 * @param can_preempt If true, the current fibril will be preempted in
    350363 *                    case the kernel temporarily refuses to accept more
    351364 *                    asynchronous calls.
    … …  
    354367void ipc_call_async_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
    355368    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, void *private,
    356     ipc_async_callback_t callback, int can_preempt)
    357 {
    358         async_call_t *call;
    359         ipc_callid_t callid;
    360 
    361         call = ipc_prepare_async(private, callback);
     369    ipc_async_callback_t callback, bool can_preempt)
     370{
     371        async_call_t *call = ipc_prepare_async(private, callback);
    362372        if (!call)
    363373                return;
    364 
     374       
    365375        IPC_SET_IMETHOD(call->u.msg.data, imethod);
    366376        IPC_SET_ARG1(call->u.msg.data, arg1);
    … …  
    369379        IPC_SET_ARG4(call->u.msg.data, arg4);
    370380        IPC_SET_ARG5(call->u.msg.data, arg5);
     381       
    371382        /*
    372          * We need to make sure that we get callid before another thread
    373          * accesses the queue again.
     383         * We need to make sure that we get callid
     384         * before another threadaccesses the queue again.
    374385         */
     386       
    375387        futex_down(&ipc_futex);
    376         callid = _ipc_call_async(phoneid, &call->u.msg.data);
    377 
     388        ipc_callid_t callid =
     389            ipc_call_async_internal(phoneid, &call->u.msg.data);
     390       
    378391        ipc_finish_async(callid, phoneid, call, can_preempt);
    379392}
    380393
    381 
    382 /** Answer a received call - fast version.
     394/** Answer received call (fast version).
    383395 *
    384396 * The fast answer makes use of passing retval and first four arguments in
    385397 * registers. If you need to return more, use the ipc_answer_slow() instead.
    386398 *
    387  * @param callid        Hash of the call being answered.
    388  * @param retval        Return value.
    389  * @param arg1          First return argument.
    390  * @param arg2          Second return argument.
    391  * @param arg3          Third return argument.
    392  * @param arg4          Fourth return argument.
    393  *
    394  * @return              Zero on success or a value from @ref errno.h on failure.
     399 * @param callid Hash of the call being answered.
     400 * @param retval Return value.
     401 * @param arg1   First return argument.
     402 * @param arg2   Second return argument.
     403 * @param arg3   Third return argument.
     404 * @param arg4   Fourth return argument.
     405 *
     406 * @return Zero on success.
     407 * @return Value from @ref errno.h on failure.
     408 *
    395409 */
    396410sysarg_t ipc_answer_fast(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
    … …  
    401415}
    402416
    403 /** Answer a received call - slow full version.
    404  *
    405  * @param callid        Hash of the call being answered.
    406  * @param retval        Return value.
    407  * @param arg1          First return argument.
    408  * @param arg2          Second return argument.
    409  * @param arg3          Third return argument.
    410  * @param arg4          Fourth return argument.
    411  * @param arg5          Fifth return argument.
    412  *
    413  * @return              Zero on success or a value from @ref errno.h on failure.
     417/** Answer received call (entire payload).
     418 *
     419 * @param callid Hash of the call being answered.
     420 * @param retval Return value.
     421 * @param arg1   First return argument.
     422 * @param arg2   Second return argument.
     423 * @param arg3   Third return argument.
     424 * @param arg4   Fourth return argument.
     425 * @param arg5   Fifth return argument.
     426 *
     427 * @return Zero on success.
     428 * @return Value from @ref errno.h on failure.
     429 *
    414430 */
    415431sysarg_t ipc_answer_slow(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
    … …  
    417433{
    418434        ipc_call_t data;
    419 
     435       
    420436        IPC_SET_RETVAL(data, retval);
    421437        IPC_SET_ARG1(data, arg1);
    … …  
    424440        IPC_SET_ARG4(data, arg4);
    425441        IPC_SET_ARG5(data, arg5);
    426 
     442       
    427443        return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data);
    428444}
    429445
    430 
    431 /** Try to dispatch queued calls from the async queue. */
    432 static void try_dispatch_queued_calls(void)
    433 {
    434         async_call_t *call;
    435         ipc_callid_t callid;
    436 
     446/** Try to dispatch queued calls from the async queue.
     447 *
     448 */
     449static void dispatch_queued_calls(void)
     450{
    437451        /** @todo
    438          * Integrate intelligently ipc_futex, so that it is locked during
    439          * ipc_call_async_*(), until it is added to dispatched_calls.
     452         * Integrate intelligently ipc_futex so that it is locked during
     453         * ipc_call_async_*() until it is added to dispatched_calls.
    440454         */
     455       
    441456        futex_down(&async_futex);
     457       
    442458        while (!list_empty(&queued_calls)) {
    443                 call = list_get_instance(queued_calls.next, async_call_t, list);
    444                 callid = _ipc_call_async(call->u.msg.phoneid,
    445                     &call->u.msg.data);
    446                 if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
     459                async_call_t *call =
     460                    list_get_instance(queued_calls.next, async_call_t, list);
     461                ipc_callid_t callid =
     462                    ipc_call_async_internal(call->u.msg.phoneid, &call->u.msg.data);
     463               
     464                if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY)
    447465                        break;
    448                 }
     466               
    449467                list_remove(&call->list);
    450 
     468               
    451469                futex_up(&async_futex);
     470               
    452471                if (call->fid)
    453472                        fibril_add_ready(call->fid);
    … …  
    456475                        if (call->callback)
    457476                                call->callback(call->private, ENOENT, NULL);
     477                       
    458478                        free(call);
    459479                } else {
    460480                        call->u.callid = callid;
     481                       
    461482                        futex_down(&ipc_futex);
    462483                        list_append(&call->list, &dispatched_calls);
    463484                        futex_up(&ipc_futex);
    464485                }
     486               
    465487                futex_down(&async_futex);
    466488        }
     489       
    467490        futex_up(&async_futex);
    468491}
    469492
    470 /** Handle a received answer.
     493/** Handle received answer.
    471494 *
    472495 * Find the hash of the answer and call the answer callback.
    473496 *
    474  * @todo Make it use hash table.
    475  *
    476  * @param callid        Hash of the received answer.
    477  *                      The answer has the same hash as the request OR'ed with
    478  *                      the IPC_CALLID_ANSWERED bit.
    479  * @param data          Call data of the answer.
     497 * The answer has the same hash as the request OR'ed with
     498 * the IPC_CALLID_ANSWERED bit.
     499 *
     500 * @todo Use hash table.
     501 *
     502 * @param callid Hash of the received answer.
     503 * @param data   Call data of the answer.
     504 *
    480505 */
    481506static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
    482507{
     508        callid &= ~IPC_CALLID_ANSWERED;
     509       
     510        futex_down(&ipc_futex);
     511       
    483512        link_t *item;
    484         async_call_t *call;
    485 
    486         callid &= ~IPC_CALLID_ANSWERED;
    487        
    488         futex_down(&ipc_futex);
    489513        for (item = dispatched_calls.next; item != &dispatched_calls;
    490514            item = item->next) {
    491                 call = list_get_instance(item, async_call_t, list);
     515                async_call_t *call =
     516                    list_get_instance(item, async_call_t, list);
     517               
    492518                if (call->u.callid == callid) {
    493519                        list_remove(&call->list);
     520                       
    494521                        futex_up(&ipc_futex);
     522                       
    495523                        if (call->callback)
    496                                 call->callback(call->private, 
     524                                call->callback(call->private,
    497525                                    IPC_GET_RETVAL(*data), data);
     526                       
    498527                        free(call);
    499528                        return;
    500529                }
    501530        }
     531       
    502532        futex_up(&ipc_futex);
    503533}
    504534
    505 
    506 /** Wait for a first call to come.
    507  *
    508  * @param call          Storage where the incoming call data will be stored.
    509  * @param usec          Timeout in microseconds
    510  * @param flags         Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
    511  *
    512  * @return              Hash of the call. Note that certain bits have special
    513  *                      meaning. IPC_CALLID_ANSWERED will be set in an answer
    514  *                      and IPC_CALLID_NOTIFICATION is used for notifications.
    515  *                     
    516  */
    517 ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
    518 {
    519         ipc_callid_t callid;
    520 
    521         callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
     535/** Wait for first IPC call to come.
     536 *
     537 * @param call  Incoming call storage.
     538 * @param usec  Timeout in microseconds
     539 * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
     540 *
     541 * @return Hash of the call. Note that certain bits have special
     542 *         meaning: IPC_CALLID_ANSWERED is set in an answer
     543 *         and IPC_CALLID_NOTIFICATION is used for notifications.
     544 *
     545 */
     546ipc_callid_t ipc_wait_cycle(ipc_call_t *call, sysarg_t usec,
     547    unsigned int flags)
     548{
     549        ipc_callid_t callid =
     550            __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
     551       
    522552        /* Handle received answers */
    523553        if (callid & IPC_CALLID_ANSWERED) {
    524554                handle_answer(callid, call);
    525                 try_dispatch_queued_calls();
     555                dispatch_queued_calls();
    526556        }
    527 
     557       
    528558        return callid;
    529559}
    530560
    531 /** Wait some time for an IPC call.
    532  *
    533  * The call will return after an answer is received.
    534  *
    535  * @param call          Storage where the incoming call data will be stored.
    536  * @param usec          Timeout in microseconds.
    537  *
    538  * @return              Hash of the answer.
    539  */
    540 ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
     561/** Interrupt one thread of this task from waiting for IPC.
     562 *
     563 */
     564void ipc_poke(void)
     565{
     566        __SYSCALL0(SYS_IPC_POKE);
     567}
     568
     569/** Wait for first IPC call to come.
     570 *
     571 * Only requests are returned, answers are processed internally.
     572 *
     573 * @param call Incoming call storage.
     574 * @param usec Timeout in microseconds
     575 *
     576 * @return Hash of the call.
     577 *
     578 */
     579ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, sysarg_t usec)
    541580{
    542581        ipc_callid_t callid;
    543 
     582       
    544583        do {
    545584                callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
    546585        } while (callid & IPC_CALLID_ANSWERED);
    547 
     586       
    548587        return callid;
    549588}
    … …  
    551590/** Check if there is an IPC call waiting to be picked up.
    552591 *
    553  * @param call          Storage where the incoming call will be stored.
    554  * @return              Hash of the answer.
     592 * Only requests are returned, answers are processed internally.
     593 *
     594 * @param call Incoming call storage.
     595 *
     596 * @return Hash of the call.
     597 *
    555598 */
    556599ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
    557600{
    558601        ipc_callid_t callid;
    559 
     602       
    560603        do {
    561604                callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT,
    562605                    SYNCH_FLAGS_NON_BLOCKING);
    563606        } while (callid & IPC_CALLID_ANSWERED);
    564 
     607       
    565608        return callid;
    566609}
    567610
    568 /** Interrupt one thread of this task from waiting for IPC. */
    569 void ipc_poke(void)
    570 {
    571         __SYSCALL0(SYS_IPC_POKE);
    572 }
    573 
    574 /** Ask destination to do a callback connection.
    575  *
    576  * @param phoneid       Phone handle used for contacting the other side.
    577  * @param arg1          Service-defined argument.
    578  * @param arg2          Service-defined argument.
    579  * @param arg3          Service-defined argument.
    580  * @param phonehash     Storage where the library will store an opaque
    581  *                      identifier of the phone that will be used for incoming
    582  *                      calls. This identifier can be used for connection
    583  *                      tracking.
    584  *
    585  * @return              Zero on success or a negative error code.
    586  */
    587 int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
    588     sysarg_t *phonehash)
     611/** Request callback connection.
     612 *
     613 * The @a taskhash and @a phonehash identifiers returned
     614 * by the kernel can be used for connection tracking.
     615 *
     616 * @param phoneid   Phone handle used for contacting the other side.
     617 * @param arg1      User defined argument.
     618 * @param arg2      User defined argument.
     619 * @param arg3      User defined argument.
     620 * @param taskhash  Opaque identifier of the client task.
     621 * @param phonehash Opaque identifier of the phone that will
     622 *                  be used for incoming calls.
     623 *
     624 * @return Zero on success or a negative error code.
     625 *
     626 */
     627int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
     628    sysarg_t *taskhash, sysarg_t *phonehash)
    589629{
    590630        return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
    591             arg3, NULL, NULL, NULL, NULL, phonehash);
    592 }
    593 
    594 /** Ask through phone for a new connection to some service.
    595  *
    596  * @param phoneid       Phone handle used for contacting the other side.
    597  * @param arg1          User defined argument.
    598  * @param arg2          User defined argument.
    599  * @param arg3          User defined argument.
    600  *
    601  * @return              New phone handle on success or a negative error code.
    602  */
    603 int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3)
     631            arg3, NULL, NULL, NULL, taskhash, phonehash);
     632}
     633
     634/** Request new connection.
     635 *
     636 * @param phoneid Phone handle used for contacting the other side.
     637 * @param arg1    User defined argument.
     638 * @param arg2    User defined argument.
     639 * @param arg3    User defined argument.
     640 *
     641 * @return New phone handle on success or a negative error code.
     642 *
     643 */
     644int ipc_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
    604645{
    605646        sysarg_t newphid;
    606         int res;
    607 
    608         res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
     647        int res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
    609648            NULL, NULL, NULL, NULL, &newphid);
    610649        if (res)
    611650                return res;
     651       
    612652        return newphid;
    613653}
    614654
    615 /** Ask through phone for a new connection to some service.
     655/** Request new connection (blocking)
    616656 *
    617657 * If the connection is not available at the moment, the
    618  * call will block.
    619  *
    620  * @param phoneid       Phone handle used for contacting the other side.
    621  * @param arg1          User defined argument.
    622  * @param arg2          User defined argument.
    623  * @param arg3          User defined argument.
    624  *
    625  * @return              New phone handle on success or a negative error code.
    626  */
    627 int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3)
     658 * call should block. This has to be, however, implemented
     659 * on the server side.
     660 *
     661 * @param phoneid Phone handle used for contacting the other side.
     662 * @param arg1    User defined argument.
     663 * @param arg2    User defined argument.
     664 * @param arg3    User defined argument.
     665 *
     666 * @return New phone handle on success or a negative error code.
     667 *
     668 */
     669int ipc_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
     670    sysarg_t arg3)
    628671{
    629672        sysarg_t newphid;
    630         int res;
    631 
    632         res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
     673        int res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
    633674            IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
    634675        if (res)
    635676                return res;
     677       
    636678        return newphid;
    637679}
    … …  
    639681/** Hang up a phone.
    640682 *
    641  * @param phoneid       Handle of the phone to be hung up.
    642  *
    643  * @return              Zero on success or a negative error code.
     683 * @param phoneid Handle of the phone to be hung up.
     684 *
     685 * @return Zero on success or a negative error code.
     686 *
    644687 */
    645688int ipc_hangup(int phoneid)
    … …  
    648691}
    649692
    650 /** Register IRQ notification.
    651  *
    652  * @param inr           IRQ number.
    653  * @param devno         Device number of the device generating inr.
    654  * @param method        Use this method for notifying me.
    655  * @param ucode         Top-half pseudocode handler.
    656  *
    657  * @return              Value returned by the kernel.
    658  */
    659 int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode)
    660 {
    661         return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method,
    662             (sysarg_t) ucode);
    663 }
    664 
    665 /** Unregister IRQ notification.
    666  *
    667  * @param inr           IRQ number.
    668  * @param devno         Device number of the device generating inr.
    669  *
    670  * @return              Value returned by the kernel.
    671  */
    672 int ipc_unregister_irq(int inr, int devno)
    673 {
    674         return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
    675 }
    676 
    677693/** Forward a received call to another destination.
     694 *
     695 * For non-system methods, the old method, arg1 and arg2 are rewritten
     696 * by the new values. For system methods, the new method, arg1 and arg2
     697 * are written to the old arg1, arg2 and arg3, respectivelly. Calls with
     698 * immutable methods are forwarded verbatim.
    678699 *
    679700 * @param callid  Hash of the call to forward.
    … …  
    686707 * @return Zero on success or an error code.
    687708 *
    688  * For non-system methods, the old method, arg1 and arg2 are rewritten by the
    689  * new values. For system methods, the new method, arg1 and arg2 are written
    690  * to the old arg1, arg2 and arg3, respectivelly. Calls with immutable
    691  * methods are forwarded verbatim.
    692  */
    693 int ipc_forward_fast(ipc_callid_t callid, int phoneid, int imethod,
    694     sysarg_t arg1, sysarg_t arg2, int mode)
     709 */
     710int ipc_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod,
     711    sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    695712{
    696713        return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, imethod, arg1,
    … …  
    698715}
    699716
    700 
    701 int ipc_forward_slow(ipc_callid_t callid, int phoneid, int imethod,
     717int ipc_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod,
    702718    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    703     int mode)
     719    unsigned int mode)
    704720{
    705721        ipc_call_t data;
    … …  
    712728        IPC_SET_ARG5(data, arg5);
    713729       
    714         return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, mode);
    715 }
    716 
    717 /** Wrapper for making IPC_M_SHARE_IN calls.
    718  *
    719  * @param phoneid       Phone that will be used to contact the receiving side.
    720  * @param dst           Destination address space area base.
    721  * @param size          Size of the destination address space area.
    722  * @param arg           User defined argument.
    723  * @param flags         Storage where the received flags will be stored. Can be
    724  *                      NULL.
    725  *
    726  * @return              Zero on success or a negative error code from errno.h.
     730        return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data,
     731            mode);
     732}
     733
     734/** Wrapper for IPC_M_SHARE_IN calls.
     735 *
     736 * @param phoneid Phone that will be used to contact the receiving side.
     737 * @param dst     Destination address space area base.
     738 * @param size    Size of the destination address space area.
     739 * @param arg     User defined argument.
     740 * @param flags   Storage for received flags. Can be NULL.
     741 *
     742 * @return Zero on success or a negative error code from errno.h.
     743 *
    727744 */
    728745int ipc_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
    729     int *flags)
     746    unsigned int *flags)
    730747{
    731748        sysarg_t tmp_flags = 0;
    … …  
    734751       
    735752        if (flags)
    736                 *flags = tmp_flags;
     753                *flags = (unsigned int) tmp_flags;
    737754       
    738755        return res;
    … …  
    741758/** Wrapper for answering the IPC_M_SHARE_IN calls.
    742759 *
    743  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
    744  * so that the user doesn't have to remember the meaning of each IPC argument.
    745  *
    746  * @param callid        Hash of the IPC_M_DATA_READ call to answer.
    747  * @param src           Source address space base.
    748  * @param flags         Flags to be used for sharing. Bits can be only cleared.
    749  *
    750  * @return              Zero on success or a value from @ref errno.h on failure.
    751  */
    752 int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags)
     760 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
     761 * calls so that the user doesn't have to remember the meaning of each
     762 * IPC argument.
     763 *
     764 * @param callid Hash of the IPC_M_DATA_READ call to answer.
     765 * @param src    Source address space base.
     766 * @param flags Flags to be used for sharing. Bits can be only cleared.
     767 *
     768 * @return Zero on success or a value from @ref errno.h on failure.
     769 *
     770 */
     771int ipc_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
    753772{
    754773        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) flags);
    755774}
    756775
    757 /** Wrapper for making IPC_M_SHARE_OUT calls.
    758  *
    759  * @param phoneid       Phone that will be used to contact the receiving side.
    760  * @param src           Source address space area base address.
    761  * @param flags         Flags to be used for sharing. Bits can be only cleared.
    762  *
    763  * @return              Zero on success or a negative error code from errno.h.
    764  */
    765 int ipc_share_out_start(int phoneid, void *src, int flags)
     776/** Wrapper for IPC_M_SHARE_OUT calls.
     777 *
     778 * @param phoneid Phone that will be used to contact the receiving side.
     779 * @param src     Source address space area base address.
     780 * @param flags   Flags to be used for sharing. Bits can be only cleared.
     781 *
     782 * @return Zero on success or a negative error code from errno.h.
     783 *
     784 */
     785int ipc_share_out_start(int phoneid, void *src, unsigned int flags)
    766786{
    767787        return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
    … …  
    771791/** Wrapper for answering the IPC_M_SHARE_OUT calls.
    772792 *
    773  * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls
    774  * so that the user doesn't have to remember the meaning of each IPC argument.
    775  *
    776  * @param callid        Hash of the IPC_M_DATA_WRITE call to answer.
    777  * @param dst           Destination address space area base address.   
    778  *
    779  * @return              Zero on success or a value from @ref errno.h on failure.
     793 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT
     794 * calls so that the user doesn't have to remember the meaning of each
     795 * IPC argument.
     796 *
     797 * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
     798 * @param dst    Destination address space area base address.
     799 *
     800 * @return Zero on success or a value from @ref errno.h on failure.
     801 *
    780802 */
    781803int ipc_share_out_finalize(ipc_callid_t callid, void *dst)
    … …  
    784806}
    785807
    786 
    787 /** Wrapper for making IPC_M_DATA_READ calls.
    788  *
    789  * @param phoneid       Phone that will be used to contact the receiving side.
    790  * @param dst           Address of the beginning of the destination buffer.
    791  * @param size          Size of the destination buffer.
    792  *
    793  * @return              Zero on success or a negative error code from errno.h.
     808/** Wrapper for IPC_M_DATA_READ calls.
     809 *
     810 * @param phoneid Phone that will be used to contact the receiving side.
     811 * @param dst     Address of the beginning of the destination buffer.
     812 * @param size    Size of the destination buffer.
     813 *
     814 * @return Zero on success or a negative error code from errno.h.
     815 *
    794816 */
    795817int ipc_data_read_start(int phoneid, void *dst, size_t size)
    … …  
    801823/** Wrapper for answering the IPC_M_DATA_READ calls.
    802824 *
    803  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
    804  * so that the user doesn't have to remember the meaning of each IPC argument.
    805  *
    806  * @param callid        Hash of the IPC_M_DATA_READ call to answer.
    807  * @param src           Source address for the IPC_M_DATA_READ call.
    808  * @param size          Size for the IPC_M_DATA_READ call. Can be smaller than
    809  *                      the maximum size announced by the sender.
    810  *
    811  * @return              Zero on success or a value from @ref errno.h on failure.
     825 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
     826 * calls so that the user doesn't have to remember the meaning of each
     827 * IPC argument.
     828 *
     829 * @param callid Hash of the IPC_M_DATA_READ call to answer.
     830 * @param src    Source address for the IPC_M_DATA_READ call.
     831 * @param size   Size for the IPC_M_DATA_READ call. Can be smaller than
     832 *               the maximum size announced by the sender.
     833 *
     834 * @return Zero on success or a value from @ref errno.h on failure.
     835 *
    812836 */
    813837int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
    … …  
    816840}
    817841
    818 /** Wrapper for making IPC_M_DATA_WRITE calls.
    819  *
    820  * @param phoneid       Phone that will be used to contact the receiving side.
    821  * @param src           Address of the beginning of the source buffer.
    822  * @param size          Size of the source buffer.
    823  *
    824  * @return              Zero on success or a negative error code from errno.h.
     842/** Wrapper for IPC_M_DATA_WRITE calls.
     843 *
     844 * @param phoneid Phone that will be used to contact the receiving side.
     845 * @param src     Address of the beginning of the source buffer.
     846 * @param size    Size of the source buffer.
     847 *
     848 * @return Zero on success or a negative error code from errno.h.
     849 *
    825850 */
    826851int ipc_data_write_start(int phoneid, const void *src, size_t size)
    … …  
    832857/** Wrapper for answering the IPC_M_DATA_WRITE calls.
    833858 *
    834  * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls
    835  * so that the user doesn't have to remember the meaning of each IPC argument.
    836  *
    837  * @param callid        Hash of the IPC_M_DATA_WRITE call to answer.
    838  * @param dst           Final destination address for the IPC_M_DATA_WRITE call.
    839  * @param size          Final size for the IPC_M_DATA_WRITE call.
    840  *
    841  * @return              Zero on success or a value from @ref errno.h on failure.
     859 * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE
     860 * calls so that the user doesn't have to remember the meaning of each
     861 * IPC argument.
     862 *
     863 * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
     864 * @param dst    Final destination address for the IPC_M_DATA_WRITE call.
     865 * @param size   Final size for the IPC_M_DATA_WRITE call.
     866 *
     867 * @return Zero on success or a value from @ref errno.h on failure.
     868 *
    842869 */
    843870int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)

  • uspace/lib/c/generic/libc.c

    r22027b6e r8b5690f  
    4242
    4343#include <libc.h>
    44 #include <stdio.h>
    45 #include <unistd.h>
    46 #include <malloc.h>
     44#include <stdlib.h>
    4745#include <tls.h>
    48 #include <thread.h>
    4946#include <fibril.h>
    50 #include <ipc/ipc.h>
    51 #include <async.h>
    52 #include <as.h>
     47#include <task.h>
    5348#include <loader/pcb.h>
     49#include "private/libc.h"
     50#include "private/async.h"
     51#include "private/async_sess.h"
     52#include "private/malloc.h"
     53#include "private/io.h"
    5454
    55 extern int main(int argc, char *argv[]);
    56 
    57 void _exit(int status)
    58 {
    59         thread_exit(status);
    60 }
     55static bool env_setup = false;
    6156
    6257void __main(void *pcb_ptr)
    6358{
    6459        /* Initialize user task run-time environment */
    65         __heap_init();
     60        __malloc_init();
    6661        __async_init();
     62        __async_sess_init();
     63       
    6764        fibril_t *fibril = fibril_setup();
     65        if (fibril == NULL)
     66                abort();
     67       
    6868        __tcb_set(fibril->tcb);
    6969       
    … …  
    7171        __pcb = (pcb_t *) pcb_ptr;
    7272       
     73        /* The basic run-time environment is setup */
     74        env_setup = true;
     75       
    7376        int argc;
    7477        char **argv;
    7578       
    76         /* Get command line arguments and initialize
    77            standard input and output */
     79        /*
     80         * Get command line arguments and initialize
     81         * standard input and output
     82         */
    7883        if (__pcb == NULL) {
    7984                argc = 0;
    … …  
    8792        }
    8893       
    89         /* Run main() and set task return value
    90            according the result */
    91         (void) task_retval(main(argc, argv));
     94        /*
     95         * Run main() and set task return value
     96         * according the result
     97         */
     98        int retval = main(argc, argv);
     99        exit(retval);
    92100}
    93101
    94 void __exit(void)
     102void exit(int status)
    95103{
    96         __stdio_done();
    97         fibril_teardown(__tcb_get()->fibril_data);
    98         _exit(0);
     104        if (env_setup) {
     105                __stdio_done();
     106                task_retval(status);
     107                fibril_teardown(__tcb_get()->fibril_data);
     108        }
     109       
     110        __SYSCALL1(SYS_TASK_EXIT, false);
     111       
     112        /* Unreachable */
     113        while (1);
     114}
     115
     116void abort(void)
     117{
     118        __SYSCALL1(SYS_TASK_EXIT, true);
     119       
     120        /* Unreachable */
     121        while (1);
    99122}
    100123

  • uspace/lib/c/generic/loader.c

    r22027b6e r8b5690f  
    3333 */
    3434
    35 #include <ipc/ipc.h>
    3635#include <ipc/loader.h>
    3736#include <ipc/services.h>
     37#include <ipc/ns.h>
    3838#include <libc.h>
    3939#include <task.h>
    … …  
    6363loader_t *loader_connect(void)
    6464{
    65         int phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0);
     65        int phone_id = service_connect_blocking(SERVICE_LOAD, 0, 0);
    6666        if (phone_id < 0)
    6767                return NULL;
    … …  
    319319                return rc;
    320320       
    321         ipc_hangup(ldr->phone_id);
     321        async_hangup(ldr->phone_id);
    322322        ldr->phone_id = 0;
    323323        return EOK;
    … …  
    337337void loader_abort(loader_t *ldr)
    338338{
    339         ipc_hangup(ldr->phone_id);
     339        async_hangup(ldr->phone_id);
    340340        ldr->phone_id = 0;
    341341}

  • uspace/lib/c/generic/malloc.c

    r22027b6e r8b5690f  
    4545#include <futex.h>
    4646#include <adt/gcdlcm.h>
     47#include "private/malloc.h"
    4748
    4849/* Magic used in heap headers. */
    … …  
    215216/** Initialize the heap allocator
    216217 *
    217  * Find how much physical memory we have and create
    218  * the heap management structures that mark the whole
    219  * physical memory as a single free block.
    220  *
    221  */
    222 void __heap_init(void)
    223 {
    224         futex_down(&malloc_futex);
    225        
    226         if (as_area_create((void *) &_heap, PAGE_SIZE,
    227             AS_AREA_WRITE | AS_AREA_READ)) {
    228                 heap_pages = 1;
    229                 heap_start = (void *) ALIGN_UP((uintptr_t) &_heap, BASE_ALIGN);
    230                 heap_end =
    231                     (void *) ALIGN_DOWN(((uintptr_t) &_heap) + PAGE_SIZE, BASE_ALIGN);
    232                
    233                 /* Make the entire area one large block. */
    234                 block_init(heap_start, heap_end - heap_start, true);
    235         }
    236        
    237         futex_up(&malloc_futex);
     218 * Create initial heap memory area. This routine is
     219 * only called from libc initialization, thus we do not
     220 * take any locks.
     221 *
     222 */
     223void __malloc_init(void)
     224{
     225        if (!as_area_create((void *) &_heap, PAGE_SIZE,
     226            AS_AREA_WRITE | AS_AREA_READ))
     227                abort();
     228       
     229        heap_pages = 1;
     230        heap_start = (void *) ALIGN_UP((uintptr_t) &_heap, BASE_ALIGN);
     231        heap_end =
     232            (void *) ALIGN_DOWN(((uintptr_t) &_heap) + PAGE_SIZE, BASE_ALIGN);
     233       
     234        /* Make the entire area one large block. */
     235        block_init(heap_start, heap_end - heap_start, true);
    238236}
    239237

  • uspace/lib/c/generic/net/icmp_api.c

    r22027b6e r8b5690f  
    4141#include <net/modules.h>
    4242#include <net/ip_codes.h>
    43 
    4443#include <async.h>
    4544#include <sys/types.h>
    4645#include <sys/time.h>
    4746#include <errno.h>
    48 
    49 #include <ipc/ipc.h>
    5047#include <ipc/services.h>
    5148#include <ipc/icmp.h>

  • uspace/lib/c/generic/net/icmp_common.c

    r22027b6e r8b5690f  
    2727 */
    2828
    29 /** @addtogroup libc 
     29/** @addtogroup libc
    3030 *  @{
    3131 */
    … …  
    3838#include <net/modules.h>
    3939#include <net/icmp_common.h>
    40 
    4140#include <ipc/services.h>
    4241#include <ipc/icmp.h>
    43 
    4442#include <sys/time.h>
    4543#include <async.h>
    4644
    47 /** Connects to the ICMP module.
     45/** Connect to the ICMP module.
    4846 *
    49  * @param service       The ICMP module service. Ignored parameter.
    50  * @param[in] timeout   The connection timeout in microseconds. No timeout if
    51  *                      set to zero.
    52  * @return              The ICMP module phone on success.
    53  * @return              ETIMEOUT if the connection timeouted.
     47 * @param[in] timeout Connection timeout in microseconds, zero
     48 *                    for no timeout.
     49 *
     50 * @return ICMP module phone on success.
     51 * @return ETIMEOUT if the connection timeouted.
     52 *
    5453 */
    55 int icmp_connect_module(services_t service, suseconds_t timeout)
     54int icmp_connect_module(suseconds_t timeout)
    5655{
    57         int phone;
    58 
    59         phone = connect_to_service_timeout(SERVICE_ICMP, timeout);
    60         if (phone >= 0)
    61                 async_req_0_0(phone, NET_ICMP_INIT);
    62 
    63         return phone;
     56        return connect_to_service_timeout(SERVICE_ICMP, timeout);
    6457}
    6558

  • uspace/lib/c/generic/net/modules.c

    r22027b6e r8b5690f  
    3232
    3333/** @file
    34  * Generic module functions implementation. 
     34 * Generic module functions implementation.
    3535 *
    3636 * @todo MAKE IT POSSIBLE TO REMOVE THIS FILE VIA EITHER REPLACING PART OF ITS
    … …  
    4343#include <errno.h>
    4444#include <sys/time.h>
    45 
    46 #include <ipc/ipc.h>
    4745#include <ipc/services.h>
    48 
    4946#include <net/modules.h>
    5047
    … …  
    5249#define MODULE_WAIT_TIME        (10 * 1000)
    5350
    54 /** Answers the call.
    55  *
    56  * @param[in] callid    The call identifier.
    57  * @param[in] result    The message processing result.
    58  * @param[in] answer    The message processing answer.
    59  * @param[in] answer_count The number of answer parameters.
    60  */
    61 void
    62 answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
    63     int answer_count)
    64 {
    65         /* Choose the most efficient answer function */
    66         if (answer || (!answer_count)) {
    67                 switch (answer_count) {
     51/** Answer a call.
     52 *
     53 * @param[in] callid Call identifier.
     54 * @param[in] result Message processing result.
     55 * @param[in] answer Message processing answer.
     56 * @param[in] count  Number of answer parameters.
     57 *
     58 */
     59void answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
     60    size_t count)
     61{
     62        /* Choose the most efficient function */
     63        if ((answer != NULL) || (count == 0)) {
     64                switch (count) {
    6865                case 0:
    69                         ipc_answer_0(callid, (sysarg_t) result);
     66                        async_answer_0(callid, (sysarg_t) result);
    7067                        break;
    7168                case 1:
    72                         ipc_answer_1(callid, (sysarg_t) result,
     69                        async_answer_1(callid, (sysarg_t) result,
    7370                            IPC_GET_ARG1(*answer));
    7471                        break;
    7572                case 2:
    76                         ipc_answer_2(callid, (sysarg_t) result,
     73                        async_answer_2(callid, (sysarg_t) result,
    7774                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer));
    7875                        break;
    7976                case 3:
    80                         ipc_answer_3(callid, (sysarg_t) result,
     77                        async_answer_3(callid, (sysarg_t) result,
    8178                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    8279                            IPC_GET_ARG3(*answer));
    8380                        break;
    8481                case 4:
    85                         ipc_answer_4(callid, (sysarg_t) result,
     82                        async_answer_4(callid, (sysarg_t) result,
    8683                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    8784                            IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer));
    … …  
    8986                case 5:
    9087                default:
    91                         ipc_answer_5(callid, (sysarg_t) result,
     88                        async_answer_5(callid, (sysarg_t) result,
    9289                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    9390                            IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer),
    … …  
    137134    sysarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
    138135{
    139         int rc;
    140        
    141136        /* Connect to the needed service */
    142137        int phone = connect_to_service_timeout(need, timeout);
    143138        if (phone >= 0) {
    144139                /* Request the bidirectional connection */
    145                 sysarg_t phonehash;
    146                
    147                 rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &phonehash);
     140                int rc = async_connect_to_me(phone, arg1, arg2, arg3, client_receiver);
    148141                if (rc != EOK) {
    149                         ipc_hangup(phone);
     142                        async_hangup(phone);
    150143                        return rc;
    151144                }
    152                 async_new_connection(phonehash, 0, NULL, client_receiver);
    153145        }
    154146       
    … …  
    228220}
    229221
    230 /** Refreshes answer structure and parameters count.
    231  *
    232  * Erases all attributes.
    233  *
    234  * @param[in,out] answer The message processing answer structure.
    235  * @param[in,out] answer_count The number of answer parameters.
    236  */
    237 void refresh_answer(ipc_call_t *answer, int *answer_count)
    238 {
    239         if (answer_count)
    240                 *answer_count = 0;
    241 
    242         if (answer) {
     222/** Refresh answer structure and argument count.
     223 *
     224 * Erase all arguments.
     225 *
     226 * @param[in,out] answer Message processing answer structure.
     227 * @param[in,out] count  Number of answer arguments.
     228 *
     229 */
     230void refresh_answer(ipc_call_t *answer, size_t *count)
     231{
     232        if (count != NULL)
     233                *count = 0;
     234       
     235        if (answer != NULL) {
    243236                IPC_SET_RETVAL(*answer, 0);
    244                 /* Just to be precise */
    245237                IPC_SET_IMETHOD(*answer, 0);
    246238                IPC_SET_ARG1(*answer, 0);

  • uspace/lib/c/generic/net/socket_client.c

    r22027b6e r8b5690f  
    4343#include <stdlib.h>
    4444#include <errno.h>
    45 
     45#include <task.h>
    4646#include <ipc/services.h>
    4747#include <ipc/socket.h>
    48 
    4948#include <net/modules.h>
    5049#include <net/in.h>
    … …  
    278277        }
    279278
    280         ipc_answer_0(callid, (sysarg_t) rc);
     279        async_answer_0(callid, (sysarg_t) rc);
    281280        goto loop;
    282281}
    … …  
    687686
    688687        /* Read address */
    689         ipc_data_read_start(socket->phone, cliaddr, *addrlen);
     688        async_data_read_start(socket->phone, cliaddr, *addrlen);
    690689        fibril_rwlock_write_unlock(&socket_globals.lock);
    691690        async_wait_for(message_id, &ipc_result);

  • uspace/lib/c/generic/private/async.h

    r22027b6e r8b5690f  
    3333 */
    3434
    35 #ifndef LIBC_ASYNC_PRIV_H_
    36 #define LIBC_ASYNC_PRIV_H_
     35#ifndef LIBC_PRIVATE_ASYNC_H_
     36#define LIBC_PRIVATE_ASYNC_H_
    3737
    3838#include <adt/list.h>
    … …  
    5151        /** If true, we have timed out. */
    5252        bool occurred;
    53 
     53       
    5454        /** Expiration time. */
    5555        struct timeval expires;
    … …  
    6565} wu_event_t;
    6666
    67 
    6867/** Structures of this type represent a waiting fibril. */
    6968typedef struct {
    … …  
    7372        /** If true, this fibril is currently active. */
    7473        bool active;
    75 
     74       
    7675        /** Timeout wait data. */
    7776        to_event_t to_event;
    … …  
    8079} awaiter_t;
    8180
    82 extern void async_insert_timeout(awaiter_t *wd);
     81extern void __async_init(void);
     82extern void async_insert_timeout(awaiter_t *);
    8383
    8484#endif

  • uspace/lib/c/generic/private/async_sess.h

    r22027b6e r8b5690f  
    11/*
    2  * Copyright (c) 2006 Ondrej Palkovsky
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    3333 */
    3434
    35 #include <stdio.h>
    36 #include <stdlib.h>
     35#ifndef LIBC_PRIVATE_ASYNC_SESS_H_
     36#define LIBC_PRIVATE_ASYNC_SESS_H_
    3737
    38 /* TODO
    39 void errx(int __status, __const char *__format, ...)
    40 {
    41         _exit(0);
    42 }
    43 */
     38extern void __async_sess_init(void);
     39
     40#endif
    4441
    4542/** @}

  • uspace/lib/c/generic/private/io.h

    r22027b6e r8b5690f  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup ip
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * IP module functions.
    35  * The functions are used as IP module entry points.
    3633 */
    3734
    38 #ifndef NET_IP_MODULE_H_
    39 #define NET_IP_MODULE_H_
     35#ifndef LIBC_PRIVATE_IO_H_
     36#define LIBC_PRIVATE_IO_H_
    4037
    41 #include <ipc/ipc.h>
     38#include <vfs/vfs.h>
    4239
    43 extern int ip_initialize(async_client_conn_t);
    44 extern int ip_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
    45     int *);
     40extern void __stdio_init(int filc, fdi_node_t *filv[]);
     41extern void __stdio_done(void);
    4642
    4743#endif

  • uspace/lib/c/generic/private/libc.h

    r22027b6e r8b5690f  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup arp
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * ARP module functions.
    35  * The functions are used as ARP module entry points.
    3633 */
    3734
    38 #ifndef NET_ARP_MODULE_H_
    39 #define NET_ARP_MODULE_H_
     35#ifndef LIBC_PRIVATE_LIBC_H_
     36#define LIBC_PRIVATE_LIBC_H_
    4037
    41 #include <ipc/ipc.h>
    42 #include <async.h>
    43 
    44 extern int arp_initialize(async_client_conn_t);
    45 extern int arp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
    46     int *);
     38extern int main(int, char *[]);
     39extern void __main(void *) __attribute__((noreturn));
    4740
    4841#endif

  • uspace/lib/c/generic/private/thread.h

    r22027b6e r8b5690f  
    11/*
    2  * Copyright (c) 2008 Lukas Mejdrech
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup tcp
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * TCP module functions.
    35  * The functions are used as TCP module entry points.
    3633 */
    3734
    38 #ifndef NET_TCP_MODULE_H_
    39 #define NET_TCP_MODULE_H_
     35#ifndef LIBC_PRIVATE_THREAD_H_
     36#define LIBC_PRIVATE_THREAD_H_
    4037
    41 #include <async.h>
    42 #include <ipc/ipc.h>
     38#include <kernel/proc/uarg.h>
    4339
    44 extern int tcp_initialize(async_client_conn_t);
    45 extern int tcp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
    46     int *);
     40extern void __thread_entry(void);
     41extern void __thread_main(uspace_arg_t *);
    4742
    4843#endif

  • uspace/lib/c/generic/stats.c

    r22027b6e r8b5690f  
    3636#include <stats.h>
    3737#include <sysinfo.h>
    38 #include <assert.h>
    3938#include <errno.h>
    4039#include <stdio.h>
    4140#include <inttypes.h>
     41#include <malloc.h>
    4242
    4343#define SYSINFO_STATS_MAX_PATH  64
    … …  
    7171            (stats_cpu_t *) sysinfo_get_data("system.cpus", &size);
    7272       
    73         assert((size % sizeof(stats_cpu_t)) == 0);
     73        if ((size % sizeof(stats_cpu_t)) != 0) {
     74                if (stats_cpus != NULL)
     75                        free(stats_cpus);
     76                *count = 0;
     77                return NULL;
     78        }
    7479       
    7580        *count = size / sizeof(stats_cpu_t);
    … …  
    9196            (stats_physmem_t *) sysinfo_get_data("system.physmem", &size);
    9297       
    93         assert((size == sizeof(stats_physmem_t)) || (size == 0));
     98        if (size != sizeof(stats_physmem_t)) {
     99                if (stats_physmem != NULL)
     100                        free(stats_physmem);
     101                return NULL;
     102        }
    94103       
    95104        return stats_physmem;
    … …  
    111120            (stats_task_t *) sysinfo_get_data("system.tasks", &size);
    112121       
    113         assert((size % sizeof(stats_task_t)) == 0);
     122        if ((size % sizeof(stats_task_t)) != 0) {
     123                if (stats_tasks != NULL)
     124                        free(stats_tasks);
     125                *count = 0;
     126                return NULL;
     127        }
    114128       
    115129        *count = size / sizeof(stats_task_t);
    … …  
    135149            (stats_task_t *) sysinfo_get_data(name, &size);
    136150       
    137         assert((size == sizeof(stats_task_t)) || (size == 0));
     151        if (size != sizeof(stats_task_t)) {
     152                if (stats_task != NULL)
     153                        free(stats_task);
     154                return NULL;
     155        }
    138156       
    139157        return stats_task;
    … …  
    155173            (stats_thread_t *) sysinfo_get_data("system.threads", &size);
    156174       
    157         assert((size % sizeof(stats_thread_t)) == 0);
     175        if ((size % sizeof(stats_thread_t)) != 0) {
     176                if (stats_threads != NULL)
     177                        free(stats_threads);
     178                *count = 0;
     179                return NULL;
     180        }
    158181       
    159182        *count = size / sizeof(stats_thread_t);
    … …  
    179202            (stats_thread_t *) sysinfo_get_data(name, &size);
    180203       
    181         assert((size == sizeof(stats_thread_t)) || (size == 0));
     204        if (size != sizeof(stats_thread_t)) {
     205                if (stats_thread != NULL)
     206                        free(stats_thread);
     207                return NULL;
     208        }
    182209       
    183210        return stats_thread;
    … …  
    199226            (stats_exc_t *) sysinfo_get_data("system.exceptions", &size);
    200227       
    201         assert((size % sizeof(stats_exc_t)) == 0);
     228        if ((size % sizeof(stats_exc_t)) != 0) {
     229                if (stats_exceptions != NULL)
     230                        free(stats_exceptions);
     231                *count = 0;
     232                return NULL;
     233        }
    202234       
    203235        *count = size / sizeof(stats_exc_t);
    … …  
    217249{
    218250        char name[SYSINFO_STATS_MAX_PATH];
    219         snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptionss.%u", excn);
     251        snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptions.%u", excn);
    220252       
    221253        size_t size = 0;
    … …  
    223255            (stats_exc_t *) sysinfo_get_data(name, &size);
    224256       
    225         assert((size == sizeof(stats_exc_t)) || (size == 0));
     257        if (size != sizeof(stats_exc_t)) {
     258                if (stats_exception != NULL)
     259                        free(stats_exception);
     260                return NULL;
     261        }
    226262       
    227263        return stats_exception;
    … …  
    243279            (load_t *) sysinfo_get_data("system.load", &size);
    244280       
    245         assert((size % sizeof(load_t)) == 0);
     281        if ((size % sizeof(load_t)) != 0) {
     282                if (load != NULL)
     283                        free(load);
     284                *count = 0;
     285                return NULL;
     286        }
    246287       
    247288        *count = size / sizeof(load_t);

  • uspace/lib/c/generic/sysinfo.c

    r22027b6e r8b5690f  
    9696void *sysinfo_get_data(const char *path, size_t *size)
    9797{
    98         /* The binary data size might change during time.
    99            Unfortunatelly we cannot allocate the buffer
    100            and transfer the data as a single atomic operation.
     98        /*
     99         * The binary data size might change during time.
     100         * Unfortunatelly we cannot allocate the buffer
     101         * and transfer the data as a single atomic operation.
     102         */
    101103       
    102            Let's hope that the number of iterations is bounded
    103            in common cases. */
    104        
    105         void *data = NULL;
    106        
    107         while (true) {
    108                 /* Get the binary data size */
    109                 int ret = sysinfo_get_data_size(path, size);
    110                 if ((ret != EOK) || (size == 0)) {
    111                         /* Not a binary data item
    112                            or an empty item */
    113                         break;
    114                 }
    115                
    116                 data = realloc(data, *size);
    117                 if (data == NULL)
    118                         break;
    119                
    120                 /* Get the data */
    121                 ret = __SYSCALL4(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
    122                     (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size);
    123                 if (ret == EOK)
    124                         return data;
    125                
    126                 if (ret != ENOMEM) {
    127                         /* The failure to get the data was not caused
    128                            by wrong buffer size */
    129                         break;
    130                 }
     104        /* Get the binary data size */
     105        int ret = sysinfo_get_data_size(path, size);
     106        if ((ret != EOK) || (size == 0)) {
     107                /*
     108                 * Not a binary data item
     109                 * or an empty item.
     110                 */
     111                *size = 0;
     112                return NULL;
    131113        }
    132114       
    133         if (data != NULL)
    134                 free(data);
     115        void *data = malloc(*size);
     116        if (data == NULL) {
     117                *size = 0;
     118                return NULL;
     119        }
    135120       
     121        /* Get the data */
     122        size_t sz;
     123        ret = __SYSCALL5(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
     124            (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
     125            (sysarg_t) &sz);
     126        if (ret == EOK) {
     127                *size = sz;
     128                return data;
     129        }
     130       
     131        free(data);
    136132        *size = 0;
    137133        return NULL;

  • uspace/lib/c/generic/thread.c

    r22027b6e r8b5690f  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#include <thread.h>
    … …  
    4141#include <str.h>
    4242#include <async.h>
     43#include "private/thread.h"
    4344
    4445#ifndef THREAD_INITIAL_STACK_PAGES_NO
    … …  
    5051 * This function is called from __thread_entry() and is used
    5152 * to call the thread's implementing function and perform cleanup
    52  * and exit when thread returns back. Do not call this function
    53  * directly.
     53 * and exit when thread returns back.
    5454 *
    5555 * @param uarg Pointer to userspace argument structure.
     56 *
    5657 */
    5758void __thread_main(uspace_arg_t *uarg)
    5859{
    59         fibril_t *f;
    60 
    61         f = fibril_setup();
    62         __tcb_set(f->tcb);
    63 
     60        fibril_t *fibril = fibril_setup();
     61        if (fibril == NULL)
     62                thread_exit(0);
     63       
     64        __tcb_set(fibril->tcb);
     65       
    6466        uarg->uspace_thread_function(uarg->uspace_thread_arg);
    65         /* XXX: we cannot free the userspace stack while running on it */
    66 //      free(uarg->uspace_stack);
    67 //      free(uarg);
    68 
     67        /* XXX: we cannot free the userspace stack while running on it
     68                free(uarg->uspace_stack);
     69                free(uarg);
     70        */
     71       
    6972        /* If there is a manager, destroy it */
    7073        async_destroy_manager();
    71         fibril_teardown(f);
    72 
     74        fibril_teardown(fibril);
     75       
    7376        thread_exit(0);
    7477}
    … …  
    127130 *
    128131 * @param status Exit status. Currently not used.
     132 *
    129133 */
    130134void thread_exit(int status)
    131135{
    132136        __SYSCALL1(SYS_THREAD_EXIT, (sysarg_t) status);
    133         for (;;)
    134                 ;
     137       
     138        /* Unreachable */
     139        while (1);
    135140}
    136141

  • uspace/lib/c/generic/time.c

    r22027b6e r8b5690f  
    3434
    3535#include <sys/time.h>
    36 #include <unistd.h>
    37 #include <ipc/ipc.h>
    38 #include <stdio.h>
     36#include <time.h>
     37#include <bool.h>
    3938#include <arch/barrier.h>
    40 #include <unistd.h>
    41 #include <atomic.h>
    42 #include <sysinfo.h>
    43 #include <ipc/services.h>
    44 #include <libc.h>
    45 
     39#include <macros.h>
     40#include <errno.h>
    4641#include <sysinfo.h>
    4742#include <as.h>
    4843#include <ddi.h>
    49 
    50 #include <time.h>
    51 
    52 /* Pointers to public variables with time */
     44#include <libc.h>
     45
     46/** Pointer to kernel shared variables with time */
    5347struct {
    5448        volatile sysarg_t seconds1;
    … …  
    5953/** Add microseconds to given timeval.
    6054 *
    61  * @param tv            Destination timeval.
    62  * @param usecs         Number of microseconds to add.
     55 * @param tv    Destination timeval.
     56 * @param usecs Number of microseconds to add.
     57 *
    6358 */
    6459void tv_add(struct timeval *tv, suseconds_t usecs)
    … …  
    6661        tv->tv_sec += usecs / 1000000;
    6762        tv->tv_usec += usecs % 1000000;
     63       
    6864        if (tv->tv_usec > 1000000) {
    6965                tv->tv_sec++;
    … …  
    7470/** Subtract two timevals.
    7571 *
    76  * @param tv1           First timeval.
    77  * @param tv2           Second timeval.
    78  *
    79  * @return              Return difference between tv1 and tv2 (tv1 - tv2) in
    80  *                      microseconds.
     72 * @param tv1 First timeval.
     73 * @param tv2 Second timeval.
     74 *
     75 * @return Difference between tv1 and tv2 (tv1 - tv2) in
     76 *         microseconds.
     77 *
    8178 */
    8279suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2)
    8380{
    84         suseconds_t result;
    85 
    86         result = tv1->tv_usec - tv2->tv_usec;
    87         result += (tv1->tv_sec - tv2->tv_sec) * 1000000;
    88 
    89         return result;
     81        return (tv1->tv_usec - tv2->tv_usec) +
     82            ((tv1->tv_sec - tv2->tv_sec) * 1000000);
    9083}
    9184
    9285/** Decide if one timeval is greater than the other.
    9386 *
    94  * @param t1            First timeval.
    95  * @param t2            Second timeval.
    96  *
    97  * @return              Return true tv1 is greater than tv2. Otherwise return
    98  *                      false.
     87 * @param t1 First timeval.
     88 * @param t2 Second timeval.
     89 *
     90 * @return True if tv1 is greater than tv2.
     91 * @return False otherwise.
     92 *
    9993 */
    10094int tv_gt(struct timeval *tv1, struct timeval *tv2)
    10195{
    10296        if (tv1->tv_sec > tv2->tv_sec)
    103                 return 1;
    104         if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec > tv2->tv_usec)
    105                 return 1;
    106         return 0;
     97                return true;
     98       
     99        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec > tv2->tv_usec))
     100                return true;
     101       
     102        return false;
    107103}
    108104
    109105/** Decide if one timeval is greater than or equal to the other.
    110106 *
    111  * @param tv1           First timeval.
    112  * @param tv2           Second timeval.
    113  *
    114  * @return              Return true if tv1 is greater than or equal to tv2.
    115  *                      Otherwise return false.
     107 * @param tv1 First timeval.
     108 * @param tv2 Second timeval.
     109 *
     110 * @return True if tv1 is greater than or equal to tv2.
     111 * @return False otherwise.
     112 *
    116113 */
    117114int tv_gteq(struct timeval *tv1, struct timeval *tv2)
    118115{
    119116        if (tv1->tv_sec > tv2->tv_sec)
    120                 return 1;
    121         if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec >= tv2->tv_usec)
    122                 return 1;
    123         return 0;
    124 }
    125 
    126 
    127 /** POSIX gettimeofday
    128  *
    129  * The time variables are memory mapped(RO) from kernel, which updates
    130  * them periodically. As it is impossible to read 2 values atomically, we
    131  * use a trick: First read a seconds, then read microseconds, then
    132  * read seconds again. If a second elapsed in the meantime, set it to zero.
    133  * This provides assurance, that at least the
    134  * sequence of subsequent gettimeofday calls is ordered.
     117                return true;
     118       
     119        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec >= tv2->tv_usec))
     120                return true;
     121       
     122        return false;
     123}
     124
     125/** Get time of day
     126 *
     127 * The time variables are memory mapped (read-only) from kernel which
     128 * updates them periodically.
     129 *
     130 * As it is impossible to read 2 values atomically, we use a trick:
     131 * First we read the seconds, then we read the microseconds, then we
     132 * read the seconds again. If a second elapsed in the meantime, set
     133 * the microseconds to zero.
     134 *
     135 * This assures that the values returned by two subsequent calls
     136 * to gettimeofday() are monotonous.
     137 *
    135138 */
    136139int gettimeofday(struct timeval *tv, struct timezone *tz)
    137140{
    138         void *mapping;
    139         sysarg_t s1, s2;
    140         int rights;
    141         int res;
    142 
    143         if (!ktime) {
    144                 mapping = as_get_mappable_page(PAGE_SIZE);
    145                 /* Get the mapping of kernel clock */
    146                 res = ipc_share_in_start_1_1(PHONE_NS, mapping, PAGE_SIZE,
    147                     SERVICE_MEM_REALTIME, &rights);
    148                 if (res) {
    149                         printf("Failed to initialize timeofday memarea\n");
    150                         _exit(1);
     141        if (ktime == NULL) {
     142                uintptr_t faddr;
     143                int rc = sysinfo_get_value("clock.faddr", &faddr);
     144                if (rc != EOK) {
     145                        errno = rc;
     146                        return -1;
    151147                }
    152                 if (!(rights & AS_AREA_READ)) {
    153                         printf("Received bad rights on time area: %X\n",
    154                             rights);
    155                         as_area_destroy(mapping);
    156                         _exit(1);
     148               
     149                void *addr = as_get_mappable_page(PAGE_SIZE);
     150                if (addr == NULL) {
     151                        errno = ENOMEM;
     152                        return -1;
    157153                }
    158                 ktime = mapping;
    159         }
     154               
     155                rc = physmem_map((void *) faddr, addr, 1,
     156                    AS_AREA_READ | AS_AREA_CACHEABLE);
     157                if (rc != EOK) {
     158                        as_area_destroy(addr);
     159                        errno = rc;
     160                        return -1;
     161                }
     162               
     163                ktime = addr;
     164        }
     165       
    160166        if (tz) {
    161167                tz->tz_minuteswest = 0;
    162168                tz->tz_dsttime = DST_NONE;
    163169        }
    164 
    165         s2 = ktime->seconds2;
     170       
     171        sysarg_t s2 = ktime->seconds2;
     172       
    166173        read_barrier();
    167174        tv->tv_usec = ktime->useconds;
     175       
    168176        read_barrier();
    169         s1 = ktime->seconds1;
     177        sysarg_t s1 = ktime->seconds1;
     178       
    170179        if (s1 != s2) {
     180                tv->tv_sec = max(s1, s2);
    171181                tv->tv_usec = 0;
    172                 tv->tv_sec = s1 > s2 ? s1 : s2;
    173182        } else
    174183                tv->tv_sec = s1;
    175 
     184       
    176185        return 0;
    177186}
    … …  
    180189{
    181190        struct timeval tv;
    182 
    183191        if (gettimeofday(&tv, NULL))
    184192                return (time_t) -1;
     193       
    185194        if (tloc)
    186195                *tloc = tv.tv_sec;
     196       
    187197        return tv.tv_sec;
    188198}
    189199
    190 /** Wait unconditionally for specified number of microseconds */
     200/** Wait unconditionally for specified number of microseconds
     201 *
     202 */
    191203int usleep(useconds_t usec)
    192204{
    … …  
    195207}
    196208
    197 /** Wait unconditionally for specified number of seconds */
     209/** Wait unconditionally for specified number of seconds
     210 *
     211 */
    198212unsigned int sleep(unsigned int sec)
    199213{
    200         /* Sleep in 1000 second steps to support
    201            full argument range */
     214        /*
     215         * Sleep in 1000 second steps to support
     216         * full argument range
     217         */
     218       
    202219        while (sec > 0) {
    203220                unsigned int period = (sec > 1000) ? 1000 : sec;
    204        
     221               
    205222                usleep(period * 1000000);
    206223                sec -= period;
    207224        }
     225       
    208226        return 0;
    209227}

  • uspace/lib/c/generic/udebug.c

    r22027b6e r8b5690f  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#include <udebug.h>
    3636#include <sys/types.h>
    37 #include <ipc/ipc.h>
    3837#include <async.h>
    3938

  • uspace/lib/c/generic/vfs/vfs.c

    r22027b6e r8b5690f  
    11/*
    2  * Copyright (c) 2008 Jakub Jermar 
     2 * Copyright (c) 2008 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    4343#include <sys/stat.h>
    4444#include <sys/types.h>
    45 #include <ipc/ipc.h>
    4645#include <ipc/services.h>
     46#include <ipc/ns.h>
    4747#include <async.h>
    48 #include <atomic.h>
    49 #include <futex.h>
     48#include <fibril_synch.h>
    5049#include <errno.h>
     50#include <assert.h>
    5151#include <str.h>
    5252#include <devmap.h>
    … …  
    5454#include <ipc/devmap.h>
    5555
     56static async_sess_t vfs_session;
     57
     58static FIBRIL_MUTEX_INITIALIZE(vfs_phone_mutex);
    5659static int vfs_phone = -1;
    57 static futex_t vfs_phone_futex = FUTEX_INITIALIZER;
    58 static futex_t cwd_futex = FUTEX_INITIALIZER;
     60
     61static FIBRIL_MUTEX_INITIALIZE(cwd_mutex);
    5962
    6063static int cwd_fd = -1;
    … …  
    6770        char *ncwd_path_nc;
    6871
    69         futex_down(&cwd_futex);
     72        fibril_mutex_lock(&cwd_mutex);
    7073        size_t size = str_size(path);
    7174        if (*path != '/') {
    7275                if (!cwd_path) {
    73                         futex_up(&cwd_futex);
     76                        fibril_mutex_unlock(&cwd_mutex);
    7477                        return NULL;
    7578                }
    7679                ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
    7780                if (!ncwd_path_nc) {
    78                         futex_up(&cwd_futex);
     81                        fibril_mutex_unlock(&cwd_mutex);
    7982                        return NULL;
    8083                }
    … …  
    8588                ncwd_path_nc = malloc(size + 1);
    8689                if (!ncwd_path_nc) {
    87                         futex_up(&cwd_futex);
     90                        fibril_mutex_unlock(&cwd_mutex);
    8891                        return NULL;
    8992                }
    … …  
    9396        ncwd_path = canonify(ncwd_path_nc, retlen);
    9497        if (!ncwd_path) {
    95                 futex_up(&cwd_futex);
     98                fibril_mutex_unlock(&cwd_mutex);
    9699                free(ncwd_path_nc);
    97100                return NULL;
    … …  
    105108        free(ncwd_path_nc);
    106109        if (!ncwd_path) {
    107                 futex_up(&cwd_futex);
     110                fibril_mutex_unlock(&cwd_mutex);
    108111                return NULL;
    109112        }
    110         futex_up(&cwd_futex);
     113        fibril_mutex_unlock(&cwd_mutex);
    111114        return ncwd_path;
    112115}
    113116
     117/** Connect to VFS service and create session. */
    114118static void vfs_connect(void)
    115119{
    116120        while (vfs_phone < 0)
    117                 vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
     121                vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
     122       
     123        async_session_create(&vfs_session, vfs_phone, 0);
     124}
     125
     126/** Start an async exchange on the VFS session.
     127 *
     128 * @return              New phone to be used during the exchange.
     129 */
     130static int vfs_exchange_begin(void)
     131{
     132        fibril_mutex_lock(&vfs_phone_mutex);
     133        if (vfs_phone < 0)
     134                vfs_connect();
     135        fibril_mutex_unlock(&vfs_phone_mutex);
     136
     137        return async_exchange_begin(&vfs_session);
     138}
     139
     140/** End an async exchange on the VFS session.
     141 *
     142 * @param phone         Phone used during the exchange.
     143 */
     144static void vfs_exchange_end(int phone)
     145{
     146        async_exchange_end(&vfs_session, phone);
    118147}
    119148
    … …  
    154183        }
    155184       
    156         futex_down(&vfs_phone_futex);
    157         async_serialize_start();
    158         vfs_connect();
    159        
     185        int vfs_phone = vfs_exchange_begin();
     186
    160187        sysarg_t rc_orig;
    161188        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL);
    162189        sysarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    163190        if (rc != EOK) {
    164                 async_wait_for(req, &rc_orig);
    165                 async_serialize_end();
    166                 futex_up(&vfs_phone_futex);
     191                vfs_exchange_end(vfs_phone);
    167192                free(mpa);
     193                async_wait_for(req, &rc_orig);
    168194               
    169195                if (null_id != -1)
    … …  
    178204        rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
    179205        if (rc != EOK) {
    180                 async_wait_for(req, &rc_orig);
    181                 async_serialize_end();
    182                 futex_up(&vfs_phone_futex);
     206                vfs_exchange_end(vfs_phone);
    183207                free(mpa);
     208                async_wait_for(req, &rc_orig);
    184209               
    185210                if (null_id != -1)
    … …  
    194219        rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    195220        if (rc != EOK) {
    196                 async_wait_for(req, &rc_orig);
    197                 async_serialize_end();
    198                 futex_up(&vfs_phone_futex);
     221                vfs_exchange_end(vfs_phone);
    199222                free(mpa);
     223                async_wait_for(req, &rc_orig);
    200224               
    201225                if (null_id != -1)
    … …  
    211235        rc = async_req_0_0(vfs_phone, IPC_M_PING);
    212236        if (rc != EOK) {
    213                 async_wait_for(req, &rc_orig);
    214                 async_serialize_end();
    215                 futex_up(&vfs_phone_futex);
     237                vfs_exchange_end(vfs_phone);
    216238                free(mpa);
     239                async_wait_for(req, &rc_orig);
    217240               
    218241                if (null_id != -1)
    … …  
    225248        }
    226249       
    227         async_wait_for(req, &rc);
    228         async_serialize_end();
    229         futex_up(&vfs_phone_futex);
     250        vfs_exchange_end(vfs_phone);
    230251        free(mpa);
     252        async_wait_for(req, &rc);
    231253       
    232254        if ((rc != EOK) && (null_id != -1))
    … …  
    248270                return ENOMEM;
    249271       
    250         futex_down(&vfs_phone_futex);
    251         async_serialize_start();
    252         vfs_connect();
     272        int vfs_phone = vfs_exchange_begin();
    253273       
    254274        req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL);
    255275        rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    256276        if (rc != EOK) {
    257                 async_wait_for(req, &rc_orig);
    258                 async_serialize_end();
    259                 futex_up(&vfs_phone_futex);
     277                vfs_exchange_end(vfs_phone);
    260278                free(mpa);
    261                 if (rc_orig == EOK)
    262                         return (int) rc;
    263                 else
    264                         return (int) rc_orig;
    265         }
    266        
    267 
    268         async_wait_for(req, &rc);
    269         async_serialize_end();
    270         futex_up(&vfs_phone_futex);
     279                async_wait_for(req, &rc_orig);
     280                if (rc_orig == EOK)
     281                        return (int) rc;
     282                else
     283                        return (int) rc_orig;
     284        }
     285       
     286
     287        vfs_exchange_end(vfs_phone);
    271288        free(mpa);
     289        async_wait_for(req, &rc);
    272290       
    273291        return (int) rc;
    … …  
    276294static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag)
    277295{
    278         futex_down(&vfs_phone_futex);
    279         async_serialize_start();
    280         vfs_connect();
     296        int vfs_phone = vfs_exchange_begin();
    281297       
    282298        ipc_call_t answer;
    … …  
    285301       
    286302        if (rc != EOK) {
     303                vfs_exchange_end(vfs_phone);
     304
    287305                sysarg_t rc_orig;
    288306                async_wait_for(req, &rc_orig);
    289307               
    290                 async_serialize_end();
    291                 futex_up(&vfs_phone_futex);
    292                
    293                 if (rc_orig == EOK)
    294                         return (int) rc;
    295                 else
    296                         return (int) rc_orig;
    297         }
    298        
    299         async_wait_for(req, &rc);
    300         async_serialize_end();
    301         futex_up(&vfs_phone_futex);
     308                if (rc_orig == EOK)
     309                        return (int) rc;
     310                else
     311                        return (int) rc_orig;
     312        }
     313       
     314        vfs_exchange_end(vfs_phone);
     315        async_wait_for(req, &rc);
    302316       
    303317        if (rc != EOK)
    … …  
    322336int open_node(fdi_node_t *node, int oflag)
    323337{
    324         futex_down(&vfs_phone_futex);
    325         async_serialize_start();
    326         vfs_connect();
     338        int vfs_phone = vfs_exchange_begin();
    327339       
    328340        ipc_call_t answer;
    … …  
    330342            node->devmap_handle, node->index, oflag, &answer);
    331343       
    332         sysarg_t rc;
    333         async_wait_for(req, &rc);
    334         async_serialize_end();
    335         futex_up(&vfs_phone_futex);
     344        vfs_exchange_end(vfs_phone);
     345
     346        sysarg_t rc;
     347        async_wait_for(req, &rc);
    336348       
    337349        if (rc != EOK)
    … …  
    345357        sysarg_t rc;
    346358       
    347         futex_down(&vfs_phone_futex);
    348         async_serialize_start();
    349         vfs_connect();
     359        int vfs_phone = vfs_exchange_begin();
    350360       
    351361        rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes);
    352362       
    353         async_serialize_end();
    354         futex_up(&vfs_phone_futex);
     363        vfs_exchange_end(vfs_phone);
    355364       
    356365        return (int)rc;
    … …  
    363372        aid_t req;
    364373
    365         futex_down(&vfs_phone_futex);
    366         async_serialize_start();
    367         vfs_connect();
     374        int vfs_phone = vfs_exchange_begin();
    368375       
    369376        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
    370377        rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
    371378        if (rc != EOK) {
     379                vfs_exchange_end(vfs_phone);
     380
    372381                sysarg_t rc_orig;
    373        
    374                 async_wait_for(req, &rc_orig);
    375                 async_serialize_end();
    376                 futex_up(&vfs_phone_futex);
     382                async_wait_for(req, &rc_orig);
     383
    377384                if (rc_orig == EOK)
    378385                        return (ssize_t) rc;
    … …  
    380387                        return (ssize_t) rc_orig;
    381388        }
    382         async_wait_for(req, &rc);
    383         async_serialize_end();
    384         futex_up(&vfs_phone_futex);
     389        vfs_exchange_end(vfs_phone);
     390        async_wait_for(req, &rc);
    385391        if (rc == EOK)
    386392                return (ssize_t) IPC_GET_ARG1(answer);
    … …  
    395401        aid_t req;
    396402
    397         futex_down(&vfs_phone_futex);
    398         async_serialize_start();
    399         vfs_connect();
     403        int vfs_phone = vfs_exchange_begin();
    400404       
    401405        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
    402406        rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
    403407        if (rc != EOK) {
     408                vfs_exchange_end(vfs_phone);
     409
    404410                sysarg_t rc_orig;
    405        
    406                 async_wait_for(req, &rc_orig);
    407                 async_serialize_end();
    408                 futex_up(&vfs_phone_futex);
     411                async_wait_for(req, &rc_orig);
     412
    409413                if (rc_orig == EOK)
    410414                        return (ssize_t) rc;
    … …  
    412416                        return (ssize_t) rc_orig;
    413417        }
    414         async_wait_for(req, &rc);
    415         async_serialize_end();
    416         futex_up(&vfs_phone_futex);
     418        vfs_exchange_end(vfs_phone);
     419        async_wait_for(req, &rc);
    417420        if (rc == EOK)
    418421                return (ssize_t) IPC_GET_ARG1(answer);
    … …  
    423426int fsync(int fildes)
    424427{
    425         futex_down(&vfs_phone_futex);
    426         async_serialize_start();
    427         vfs_connect();
     428        int vfs_phone = vfs_exchange_begin();
    428429       
    429430        sysarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
    430431       
    431         async_serialize_end();
    432         futex_up(&vfs_phone_futex);
     432        vfs_exchange_end(vfs_phone);
    433433       
    434434        return (int) rc;
    … …  
    437437off64_t lseek(int fildes, off64_t offset, int whence)
    438438{
    439         futex_down(&vfs_phone_futex);
    440         async_serialize_start();
    441         vfs_connect();
     439        int vfs_phone = vfs_exchange_begin();
    442440       
    443441        sysarg_t newoff_lo;
    … …  
    447445            &newoff_lo, &newoff_hi);
    448446       
    449         async_serialize_end();
    450         futex_up(&vfs_phone_futex);
     447        vfs_exchange_end(vfs_phone);
    451448       
    452449        if (rc != EOK)
    … …  
    460457        sysarg_t rc;
    461458       
    462         futex_down(&vfs_phone_futex);
    463         async_serialize_start();
    464         vfs_connect();
     459        int vfs_phone = vfs_exchange_begin();
    465460       
    466461        rc = async_req_3_0(vfs_phone, VFS_IN_TRUNCATE, fildes,
    467462            LOWER32(length), UPPER32(length));
    468         async_serialize_end();
    469         futex_up(&vfs_phone_futex);
     463        vfs_exchange_end(vfs_phone);
    470464       
    471465        return (int) rc;
    … …  
    477471        aid_t req;
    478472
    479         futex_down(&vfs_phone_futex);
    480         async_serialize_start();
    481         vfs_connect();
     473        int vfs_phone = vfs_exchange_begin();
    482474       
    483475        req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
    484476        rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat));
    485477        if (rc != EOK) {
     478                vfs_exchange_end(vfs_phone);
     479
    486480                sysarg_t rc_orig;
    487                
    488                 async_wait_for(req, &rc_orig);
    489                 async_serialize_end();
    490                 futex_up(&vfs_phone_futex);
     481                async_wait_for(req, &rc_orig);
     482
    491483                if (rc_orig == EOK)
    492484                        return (ssize_t) rc;
    … …  
    494486                        return (ssize_t) rc_orig;
    495487        }
    496         async_wait_for(req, &rc);
    497         async_serialize_end();
    498         futex_up(&vfs_phone_futex);
     488        vfs_exchange_end(vfs_phone);
     489        async_wait_for(req, &rc);
    499490
    500491        return rc;
    … …  
    512503                return ENOMEM;
    513504       
    514         futex_down(&vfs_phone_futex);
    515         async_serialize_start();
    516         vfs_connect();
     505        int vfs_phone = vfs_exchange_begin();
    517506       
    518507        req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
    519508        rc = async_data_write_start(vfs_phone, pa, pa_size);
    520509        if (rc != EOK) {
    521                 async_wait_for(req, &rc_orig);
    522                 async_serialize_end();
    523                 futex_up(&vfs_phone_futex);
     510                vfs_exchange_end(vfs_phone);
    524511                free(pa);
     512                async_wait_for(req, &rc_orig);
    525513                if (rc_orig == EOK)
    526514                        return (int) rc;
    … …  
    530518        rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat));
    531519        if (rc != EOK) {
    532                 async_wait_for(req, &rc_orig);
    533                 async_serialize_end();
    534                 futex_up(&vfs_phone_futex);
     520                vfs_exchange_end(vfs_phone);
    535521                free(pa);
    536                 if (rc_orig == EOK)
    537                         return (int) rc;
    538                 else
    539                         return (int) rc_orig;
    540         }
    541         async_wait_for(req, &rc);
    542         async_serialize_end();
    543         futex_up(&vfs_phone_futex);
     522                async_wait_for(req, &rc_orig);
     523                if (rc_orig == EOK)
     524                        return (int) rc;
     525                else
     526                        return (int) rc_orig;
     527        }
     528        vfs_exchange_end(vfs_phone);
    544529        free(pa);
     530        async_wait_for(req, &rc);
    545531        return rc;
    546532}
    … …  
    601587                return ENOMEM;
    602588       
    603         futex_down(&vfs_phone_futex);
    604         async_serialize_start();
    605         vfs_connect();
     589        int vfs_phone = vfs_exchange_begin();
    606590       
    607591        req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
    608592        rc = async_data_write_start(vfs_phone, pa, pa_size);
    609593        if (rc != EOK) {
     594                vfs_exchange_end(vfs_phone);
     595                free(pa);
     596
    610597                sysarg_t rc_orig;
    611        
    612                 async_wait_for(req, &rc_orig);
    613                 async_serialize_end();
    614                 futex_up(&vfs_phone_futex);
    615                 free(pa);
    616                 if (rc_orig == EOK)
    617                         return (int) rc;
    618                 else
    619                         return (int) rc_orig;
    620         }
    621         async_wait_for(req, &rc);
    622         async_serialize_end();
    623         futex_up(&vfs_phone_futex);
     598                async_wait_for(req, &rc_orig);
     599
     600                if (rc_orig == EOK)
     601                        return (int) rc;
     602                else
     603                        return (int) rc_orig;
     604        }
     605        vfs_exchange_end(vfs_phone);
    624606        free(pa);
     607        async_wait_for(req, &rc);
    625608        return rc;
    626609}
    … …  
    636619                return ENOMEM;
    637620
    638         futex_down(&vfs_phone_futex);
    639         async_serialize_start();
    640         vfs_connect();
     621        int vfs_phone = vfs_exchange_begin();
    641622       
    642623        req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
    643624        rc = async_data_write_start(vfs_phone, pa, pa_size);
    644625        if (rc != EOK) {
     626                vfs_exchange_end(vfs_phone);
     627                free(pa);
     628
    645629                sysarg_t rc_orig;
    646 
    647                 async_wait_for(req, &rc_orig);
    648                 async_serialize_end();
    649                 futex_up(&vfs_phone_futex);
    650                 free(pa);
    651                 if (rc_orig == EOK)
    652                         return (int) rc;
    653                 else
    654                         return (int) rc_orig;
    655         }
    656         async_wait_for(req, &rc);
    657         async_serialize_end();
    658         futex_up(&vfs_phone_futex);
     630                async_wait_for(req, &rc_orig);
     631
     632                if (rc_orig == EOK)
     633                        return (int) rc;
     634                else
     635                        return (int) rc_orig;
     636        }
     637        vfs_exchange_end(vfs_phone);
    659638        free(pa);
     639        async_wait_for(req, &rc);
    660640        return rc;
    661641}
    … …  
    689669        }
    690670
    691         futex_down(&vfs_phone_futex);
    692         async_serialize_start();
    693         vfs_connect();
     671        int vfs_phone = vfs_exchange_begin();
    694672       
    695673        req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
    696674        rc = async_data_write_start(vfs_phone, olda, olda_size);
    697675        if (rc != EOK) {
    698                 async_wait_for(req, &rc_orig);
    699                 async_serialize_end();
    700                 futex_up(&vfs_phone_futex);
     676                vfs_exchange_end(vfs_phone);
    701677                free(olda);
    702678                free(newa);
     679                async_wait_for(req, &rc_orig);
    703680                if (rc_orig == EOK)
    704681                        return (int) rc;
    … …  
    708685        rc = async_data_write_start(vfs_phone, newa, newa_size);
    709686        if (rc != EOK) {
    710                 async_wait_for(req, &rc_orig);
    711                 async_serialize_end();
    712                 futex_up(&vfs_phone_futex);
     687                vfs_exchange_end(vfs_phone);
    713688                free(olda);
    714689                free(newa);
    715                 if (rc_orig == EOK)
    716                         return (int) rc;
    717                 else
    718                         return (int) rc_orig;
    719         }
    720         async_wait_for(req, &rc);
    721         async_serialize_end();
    722         futex_up(&vfs_phone_futex);
     690                async_wait_for(req, &rc_orig);
     691                if (rc_orig == EOK)
     692                        return (int) rc;
     693                else
     694                        return (int) rc_orig;
     695        }
     696        vfs_exchange_end(vfs_phone);
    723697        free(olda);
    724698        free(newa);
     699        async_wait_for(req, &rc);
    725700        return rc;
    726701}
    … …  
    740715        }
    741716       
    742         futex_down(&cwd_futex);
     717        fibril_mutex_lock(&cwd_mutex);
    743718       
    744719        if (cwd_fd >= 0)
    … …  
    753728        cwd_size = abs_size;
    754729       
    755         futex_up(&cwd_futex);
     730        fibril_mutex_unlock(&cwd_mutex);
    756731        return EOK;
    757732}
    … …  
    762737                return NULL;
    763738       
    764         futex_down(&cwd_futex);
     739        fibril_mutex_lock(&cwd_mutex);
    765740       
    766741        if ((cwd_size == 0) || (size < cwd_size + 1)) {
    767                 futex_up(&cwd_futex);
     742                fibril_mutex_unlock(&cwd_mutex);
    768743                return NULL;
    769744        }
    770745       
    771746        str_cpy(buf, size, cwd_path);
    772         futex_up(&cwd_futex);
     747        fibril_mutex_unlock(&cwd_mutex);
    773748       
    774749        return buf;
    … …  
    806781int dup2(int oldfd, int newfd)
    807782{
    808         futex_down(&vfs_phone_futex);
    809         async_serialize_start();
    810         vfs_connect();
     783        int vfs_phone = vfs_exchange_begin();
    811784       
    812785        sysarg_t ret;
    813786        sysarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret);
    814787       
    815         async_serialize_end();
    816         futex_up(&vfs_phone_futex);
     788        vfs_exchange_end(vfs_phone);
    817789       
    818790        if (rc == EOK)

  • uspace/lib/c/include/adt/hash_table.h

    r22027b6e r8b5690f  
    4141typedef unsigned long hash_count_t;
    4242typedef unsigned long hash_index_t;
    43 typedef struct hash_table hash_table_t;
    44 typedef struct hash_table_operations hash_table_operations_t;
     43
     44/** Set of operations for hash table. */
     45typedef struct {
     46        /** Hash function.
     47         *
     48         * @param key Array of keys needed to compute hash index.
     49         *            All keys must be passed.
     50         *
     51         * @return Index into hash table.
     52         *
     53         */
     54        hash_index_t (*hash)(unsigned long key[]);
     55       
     56        /** Hash table item comparison function.
     57         *
     58         * @param key Array of keys that will be compared with item. It is
     59         *            not necessary to pass all keys.
     60         *
     61         * @return True if the keys match, false otherwise.
     62         *
     63         */
     64        int (*compare)(unsigned long key[], hash_count_t keys, link_t *item);
     65       
     66        /** Hash table item removal callback.
     67         *
     68         * @param item Item that was removed from the hash table.
     69         *
     70         */
     71        void (*remove_callback)(link_t *item);
     72} hash_table_operations_t;
    4573
    4674/** Hash table structure. */
    47 struct hash_table {
     75typedef struct {
    4876        link_t *entry;
    4977        hash_count_t entries;
    5078        hash_count_t max_keys;
    5179        hash_table_operations_t *op;
    52 };
    53 
    54 /** Set of operations for hash table. */
    55 struct hash_table_operations {
    56         /** Hash function.
    57          *
    58          * @param key   Array of keys needed to compute hash index. All keys
    59          *              must be passed.
    60          *
    61          * @return      Index into hash table.
    62          */
    63         hash_index_t (* hash)(unsigned long key[]);
    64        
    65         /** Hash table item comparison function.
    66          *
    67          * @param key   Array of keys that will be compared with item. It is
    68          *              not necessary to pass all keys.
    69          *
    70          * @return      true if the keys match, false otherwise.
    71          */
    72         int (*compare)(unsigned long key[], hash_count_t keys, link_t *item);
    73 
    74         /** Hash table item removal callback.
    75          *
    76          * @param item  Item that was removed from the hash table.
    77          */
    78         void (*remove_callback)(link_t *item);
    79 };
     80} hash_table_t;
    8081
    8182#define hash_table_get_instance(item, type, member) \

  • uspace/lib/c/include/async.h

    r22027b6e r8b5690f  
    3333 */
    3434
     35#if ((defined(LIBC_IPC_H_)) && (!defined(LIBC_ASYNC_C_)))
     36        #error Do not intermix low-level IPC interface and async framework
     37#endif
     38
    3539#ifndef LIBC_ASYNC_H_
    3640#define LIBC_ASYNC_H_
    3741
    38 #include <ipc/ipc.h>
     42#include <ipc/common.h>
    3943#include <async_sess.h>
    4044#include <fibril.h>
    … …  
    4246#include <atomic.h>
    4347#include <bool.h>
     48#include <task.h>
    4449
    4550typedef ipc_callid_t aid_t;
    46 typedef void (*async_client_conn_t)(ipc_callid_t callid, ipc_call_t *call);
    47 
    48 extern atomic_t async_futex;
     51
     52typedef void *(*async_client_data_ctor_t)(void);
     53typedef void (*async_client_data_dtor_t)(void *);
     54
     55typedef void (*async_client_conn_t)(ipc_callid_t, ipc_call_t *);
    4956
    5057extern atomic_t threads_in_ipc_wait;
    5158
    52 extern int __async_init(void);
    53 extern ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs);
    54 
    55 static inline ipc_callid_t async_get_call(ipc_call_t *data)
    56 {
    57         return async_get_call_timeout(data, 0);
    58 }
    59 
    60 static inline void async_manager(void)
    61 {
    62         fibril_switch(FIBRIL_TO_MANAGER);
    63 }
     59#define async_manager() \
     60        fibril_switch(FIBRIL_TO_MANAGER)
     61
     62#define async_get_call(data) \
     63        async_get_call_timeout(data, 0)
     64
     65extern ipc_callid_t async_get_call_timeout(ipc_call_t *, suseconds_t);
    6466
    6567/*
    … …  
    8587            (arg5), (dataptr))
    8688
    87 extern aid_t async_send_fast(int phoneid, sysarg_t method, sysarg_t arg1,
    88     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr);
    89 extern aid_t async_send_slow(int phoneid, sysarg_t method, sysarg_t arg1,
    90     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    91     ipc_call_t *dataptr);
    92 extern void async_wait_for(aid_t amsgid, sysarg_t *result);
    93 extern int async_wait_timeout(aid_t amsgid, sysarg_t *retval,
    94     suseconds_t timeout);
    95 
    96 extern fid_t async_new_connection(sysarg_t in_phone_hash, ipc_callid_t callid,
    97     ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *));
    98 extern void async_usleep(suseconds_t timeout);
     89extern aid_t async_send_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     90    sysarg_t, ipc_call_t *);
     91extern aid_t async_send_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     92    sysarg_t, sysarg_t, ipc_call_t *);
     93extern void async_wait_for(aid_t, sysarg_t *);
     94extern int async_wait_timeout(aid_t, sysarg_t *, suseconds_t);
     95
     96extern fid_t async_new_connection(sysarg_t, sysarg_t, ipc_callid_t,
     97    ipc_call_t *, void (*)(ipc_callid_t, ipc_call_t *));
     98extern void async_usleep(suseconds_t);
    9999extern void async_create_manager(void);
    100100extern void async_destroy_manager(void);
    101101
    102 extern void async_set_client_connection(async_client_conn_t conn);
    103 extern void async_set_interrupt_received(async_client_conn_t conn);
    104 
    105 /* Wrappers for simple communication */
    106 #define async_msg_0(phone, method) \
    107         ipc_call_async_0((phone), (method), NULL, NULL, true)
    108 #define async_msg_1(phone, method, arg1) \
    109         ipc_call_async_1((phone), (method), (arg1), NULL, NULL, \
    110             true)
    111 #define async_msg_2(phone, method, arg1, arg2) \
    112         ipc_call_async_2((phone), (method), (arg1), (arg2), NULL, NULL, \
    113             true)
    114 #define async_msg_3(phone, method, arg1, arg2, arg3) \
    115         ipc_call_async_3((phone), (method), (arg1), (arg2), (arg3), NULL, NULL, \
    116             true)
    117 #define async_msg_4(phone, method, arg1, arg2, arg3, arg4) \
    118         ipc_call_async_4((phone), (method), (arg1), (arg2), (arg3), (arg4), NULL, \
    119             NULL, true)
    120 #define async_msg_5(phone, method, arg1, arg2, arg3, arg4, arg5) \
    121         ipc_call_async_5((phone), (method), (arg1), (arg2), (arg3), (arg4), \
    122             (arg5), NULL, NULL, true)
     102extern void async_set_client_data_constructor(async_client_data_ctor_t);
     103extern void async_set_client_data_destructor(async_client_data_dtor_t);
     104
     105extern void *async_client_data_get(void);
     106
     107extern void async_set_client_connection(async_client_conn_t);
     108extern void async_set_interrupt_received(async_client_conn_t);
     109
     110/*
     111 * Wrappers for simple communication.
     112 */
     113
     114extern void async_msg_0(int, sysarg_t);
     115extern void async_msg_1(int, sysarg_t, sysarg_t);
     116extern void async_msg_2(int, sysarg_t, sysarg_t, sysarg_t);
     117extern void async_msg_3(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
     118extern void async_msg_4(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
     119extern void async_msg_5(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     120    sysarg_t);
     121
     122/*
     123 * Wrappers for answer routines.
     124 */
     125
     126extern sysarg_t async_answer_0(ipc_callid_t, sysarg_t);
     127extern sysarg_t async_answer_1(ipc_callid_t, sysarg_t, sysarg_t);
     128extern sysarg_t async_answer_2(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t);
     129extern sysarg_t async_answer_3(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     130    sysarg_t);
     131extern sysarg_t async_answer_4(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     132    sysarg_t, sysarg_t);
     133extern sysarg_t async_answer_5(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     134    sysarg_t, sysarg_t, sysarg_t);
     135
     136/*
     137 * Wrappers for forwarding routines.
     138 */
     139
     140extern int async_forward_fast(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t,
     141    unsigned int);
     142extern int async_forward_slow(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t,
     143    sysarg_t, sysarg_t, sysarg_t, unsigned int);
    123144
    124145/*
    … …  
    128149 * and slow verion based on m.
    129150 */
     151
    130152#define async_req_0_0(phoneid, method) \
    131153        async_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \
    … …  
    243265            (arg5), (rc1), (rc2), (rc3), (rc4), (rc5))
    244266
    245 extern sysarg_t async_req_fast(int phoneid, sysarg_t method, sysarg_t arg1,
    246     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
    247     sysarg_t *r3, sysarg_t *r4, sysarg_t *r5);
    248 extern sysarg_t async_req_slow(int phoneid, sysarg_t method, sysarg_t arg1,
    249     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
    250     sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5);
     267extern sysarg_t async_req_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     268    sysarg_t, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *);
     269extern sysarg_t async_req_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     270    sysarg_t, sysarg_t, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *,
     271    sysarg_t *);
    251272
    252273static inline void async_serialize_start(void)
    … …  
    260281}
    261282
     283extern int async_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t,
     284    async_client_conn_t);
    262285extern int async_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
    263286extern int async_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);
     287extern int async_connect_kbox(task_id_t);
     288extern int async_hangup(int);
     289extern void async_poke(void);
    264290
    265291/*
    266292 * User-friendly wrappers for async_share_in_start().
    267293 */
     294
    268295#define async_share_in_start_0_0(phoneid, dst, size) \
    269296        async_share_in_start((phoneid), (dst), (size), 0, NULL)
    … …  
    275302        async_share_in_start((phoneid), (dst), (size), (arg), (flags))
    276303
    277 extern int async_share_in_start(int, void *, size_t, sysarg_t, int *);
    278 extern int async_share_in_receive(ipc_callid_t *, size_t *);
    279 extern int async_share_in_finalize(ipc_callid_t, void *, int );
    280 extern int async_share_out_start(int, void *, int);
    281 extern int async_share_out_receive(ipc_callid_t *, size_t *, int *);
     304extern int async_share_in_start(int, void *, size_t, sysarg_t, unsigned int *);
     305extern bool async_share_in_receive(ipc_callid_t *, size_t *);
     306extern int async_share_in_finalize(ipc_callid_t, void *, unsigned int);
     307
     308extern int async_share_out_start(int, void *, unsigned int);
     309extern bool async_share_out_receive(ipc_callid_t *, size_t *, unsigned int *);
    282310extern int async_share_out_finalize(ipc_callid_t, void *);
    283311
    … …  
    285313 * User-friendly wrappers for async_data_read_forward_fast().
    286314 */
     315
    287316#define async_data_read_forward_0_0(phoneid, method, answer) \
    288317        async_data_read_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL)
    … …  
    312341
    313342extern int async_data_read_start(int, void *, size_t);
    314 extern int async_data_read_receive(ipc_callid_t *, size_t *);
     343extern bool async_data_read_receive(ipc_callid_t *, size_t *);
    315344extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    316345
    … …  
    321350 * User-friendly wrappers for async_data_write_forward_fast().
    322351 */
     352
    323353#define async_data_write_forward_0_0(phoneid, method, answer) \
    324354        async_data_write_forward_fast((phoneid), (method), 0, 0, 0, 0, NULL)
    … …  
    350380
    351381extern int async_data_write_start(int, const void *, size_t);
    352 extern int async_data_write_receive(ipc_callid_t *, size_t *);
     382extern bool async_data_write_receive(ipc_callid_t *, size_t *);
    353383extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
    354384
    355385extern int async_data_write_accept(void **, const bool, const size_t,
    356386    const size_t, const size_t, size_t *);
    357 extern void async_data_write_void(const int);
     387extern void async_data_write_void(sysarg_t);
    358388
    359389extern int async_data_write_forward_fast(int, sysarg_t, sysarg_t, sysarg_t,

  • uspace/lib/c/include/async_sess.h

    r22027b6e r8b5690f  
    4545} async_sess_t;
    4646
    47 extern void _async_sess_init(void);
    4847extern void async_session_create(async_sess_t *, int, sysarg_t);
    4948extern void async_session_destroy(async_sess_t *);

  • uspace/lib/c/include/byteorder.h

    r22027b6e r8b5690f  
    8080#endif
    8181
    82 #define htons(n)        host2uint16_t_be((n))
    83 #define htonl(n)        host2uint32_t_be((n))
    84 #define ntohs(n)        uint16_t_be2host((n))
    85 #define ntohl(n)        uint32_t_be2host((n))
     82#define htons(n)  host2uint16_t_be((n))
     83#define htonl(n)  host2uint32_t_be((n))
     84#define ntohs(n)  uint16_t_be2host((n))
     85#define ntohl(n)  uint32_t_be2host((n))
    8686
    8787static inline uint64_t uint64_t_byteorder_swap(uint64_t n)

  • uspace/lib/c/include/ddi.h

    r22027b6e r8b5690f  
    3636#define LIBC_DDI_H_
    3737
     38#include <sys/types.h>
     39#include <kernel/ddi/irq.h>
    3840#include <task.h>
    3941
    … …  
    4244extern int iospace_enable(task_id_t, void *, unsigned long);
    4345extern int pio_enable(void *, size_t, void **);
    44 extern int interrupt_enable(int);
    45 extern int interrupt_disable(int);
     46extern int register_irq(int, int, int, irq_code_t *);
     47extern int unregister_irq(int, int);
    4648
    4749#endif

  • uspace/lib/c/include/devman.h

    r22027b6e r8b5690f  
    4141#include <bool.h>
    4242
    43 
    4443extern int devman_get_phone(devman_interface_t, unsigned int);
    4544extern void devman_hangup_phone(devman_interface_t);

  • uspace/lib/c/include/err.h

    r22027b6e r8b5690f  
    3939
    4040#define errx(status, fmt, ...) \
    41         { \
     41        do { \
    4242                printf((fmt), ##__VA_ARGS__); \
    43                 _exit(status); \
    44         }
     43                exit(status); \
     44        } while (0)
    4545
    4646#endif

  • uspace/lib/c/include/errno.h

    r22027b6e r8b5690f  
    3939#include <fibril.h>
    4040
     41#define errno _errno
     42
    4143extern int _errno;
    42 
    43 #define errno _errno
    4444
    4545#define EMFILE        (-18)
    … …  
    5757
    5858/** An API function is called while another blocking function is in progress. */
    59 #define EINPROGRESS     (-10036)
     59#define EINPROGRESS  (-10036)
    6060
    6161/** The socket identifier is not valid. */
    62 #define ENOTSOCK        (-10038)
     62#define ENOTSOCK  (-10038)
    6363
    6464/** The destination address required. */
    65 #define EDESTADDRREQ    (-10039)
     65#define EDESTADDRREQ  (-10039)
    6666
    6767/** Protocol is not supported.  */
    68 #define EPROTONOSUPPORT (-10043)
     68#define EPROTONOSUPPORT  (-10043)
    6969
    7070/** Socket type is not supported. */
    71 #define ESOCKTNOSUPPORT (-10044)
     71#define ESOCKTNOSUPPORT  (-10044)
    7272
    7373/** Protocol family is not supported. */
    74 #define EPFNOSUPPORT    (-10046)
     74#define EPFNOSUPPORT  (-10046)
    7575
    7676/** Address family is not supported. */
    77 #define EAFNOSUPPORT    (-10047)
     77#define EAFNOSUPPORT  (-10047)
    7878
    7979/** Address is already in use. */
    80 #define EADDRINUSE      (-10048)
     80#define EADDRINUSE  (-10048)
    8181
    8282/** The socket is not connected or bound. */
    83 #define ENOTCONN        (-10057)
     83#define ENOTCONN  (-10057)
    8484
    8585/** The requested operation was not performed. Try again later. */
    86 #define EAGAIN          (-11002)
     86#define EAGAIN  (-11002)
    8787
    88 /** No data.
    89  */
    90 #define NO_DATA         (-11004)
     88/** No data. */
     89#define NO_DATA (-11004)
    9190
    9291#endif

  • uspace/lib/c/include/event.h

    r22027b6e r8b5690f  
    3737
    3838#include <kernel/ipc/event_types.h>
    39 #include <ipc/ipc.h>
    4039
    4140extern int event_subscribe(event_type_t, sysarg_t);

  • uspace/lib/c/include/io/console.h

    r22027b6e r8b5690f  
    3636#define LIBC_IO_CONSOLE_H_
    3737
    38 #include <ipc/ipc.h>
    3938#include <bool.h>
    4039

  • uspace/lib/c/include/io/screenbuffer.h

    r22027b6e r8b5690f  
    3838#include <stdint.h>
    3939#include <sys/types.h>
    40 #include <ipc/ipc.h>
    4140#include <bool.h>
    4241

  • uspace/lib/c/include/ipc/adb.h

    r22027b6e r8b5690f  
    3232/** @file
    3333 * @brief ADB device interface.
    34  */ 
     34 */
    3535
    3636#ifndef LIBC_IPC_ADB_H_
    3737#define LIBC_IPC_ADB_H_
    3838
    39 #include <ipc/ipc.h>
     39#include <ipc/common.h>
    4040
    4141typedef enum {
    4242        ADB_REG_WRITE = IPC_FIRST_USER_METHOD
    4343} adb_request_t;
    44 
    4544
    4645typedef enum {

  • uspace/lib/c/include/ipc/arp.h

    r22027b6e r8b5690f  
    3939#define LIBC_ARP_MESSAGES_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342
    … …  
    6968/*@{*/
    7069
    71 /** Returns the protocol service message parameter.
    72  * @param[in] call The message call structure.
     70/** Return the protocol service message parameter.
     71 *
     72 * @param[in] call Message call structure.
     73 *
    7374 */
    74 #define ARP_GET_NETIF(call) \
    75         ({ \
    76                 services_t service = (services_t) IPC_GET_ARG2(*call); \
    77                 service; \
    78         })
     75#define ARP_GET_NETIF(call) ((services_t) IPC_GET_ARG2(call))
    7976
    8077/*@}*/

  • uspace/lib/c/include/ipc/bd.h

    r22027b6e r8b5690f  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#ifndef LIBC_IPC_BD_H_
    3636#define LIBC_IPC_BD_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/char.h

    r22027b6e r8b5690f  
    3232/** @file
    3333 * @brief Character device interface.
    34  */ 
     34 */
    3535
    3636#ifndef LIBC_IPC_CHAR_H_
    3737#define LIBC_IPC_CHAR_H_
    3838
    39 #include <ipc/ipc.h>
     39#include <ipc/common.h>
    4040
    4141typedef enum {
    4242        CHAR_WRITE_BYTE = IPC_FIRST_USER_METHOD
    4343} char_request_t;
    44 
    4544
    4645typedef enum {

  • uspace/lib/c/include/ipc/clipboard.h

    r22027b6e r8b5690f  
    3636#define LIBC_IPC_CLIPBOARD_H_
    3737
    38 #include <ipc/ipc.h>
    39 
    4038typedef enum {
    4139        CLIPBOARD_PUT_DATA = IPC_FIRST_USER_METHOD,

  • uspace/lib/c/include/ipc/common.h

    r22027b6e r8b5690f  
    11/*
    2  * Copyright (c) 2008 Lukas Mejdrech
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup icmp
     29/** @addtogroup libcipc
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * ICMP module functions.
    35  * The functions are used as ICMP module entry points.
    3633 */
    3734
    38 #ifndef NET_ICMP_MODULE_H_
    39 #define NET_ICMP_MODULE_H_
     35#ifndef LIBC_IPC_COMMON_H_
     36#define LIBC_IPC_COMMON_H_
    4037
    41 #include <async.h>
    42 #include <ipc/ipc.h>
     38#include <sys/types.h>
     39#include <atomic.h>
     40#include <kernel/ipc/ipc.h>
    4341
    44 extern int icmp_initialize(async_client_conn_t);
    45 extern int icmp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
    46     int *);
     42#define IPC_FLAG_BLOCKING  0x01
     43
     44typedef struct {
     45        sysarg_t args[IPC_CALL_LEN];
     46        sysarg_t in_task_hash;
     47        sysarg_t in_phone_hash;
     48} ipc_call_t;
     49
     50typedef sysarg_t ipc_callid_t;
     51
     52extern atomic_t async_futex;
    4753
    4854#endif

  • uspace/lib/c/include/ipc/console.h

    r22027b6e r8b5690f  
    3636#define LIBC_IPC_CONSOLE_H_
    3737
    38 #include <ipc/ipc.h>
    3938#include <ipc/vfs.h>
    4039

  • uspace/lib/c/include/ipc/dev_iface.h

    r22027b6e r8b5690f  
    3030#define LIBC_IPC_DEV_IFACE_H_
    3131
    32 #include <ipc/ipc.h>
    3332#include <malloc.h>
    3433#include <unistd.h>

  • uspace/lib/c/include/ipc/devman.h

    r22027b6e r8b5690f  
    3030 * @{
    3131 */
    32  
     32
    3333#ifndef LIBC_IPC_DEVMAN_H_
    3434#define LIBC_IPC_DEVMAN_H_
    3535
     36#include <ipc/common.h>
    3637#include <adt/list.h>
    37 #include <ipc/ipc.h>
    38 #include <stdlib.h>
    39 #include <stdio.h>
    40 #include <str.h>
     38#include <malloc.h>
     39#include <mem.h>
    4140
    42 #define DEVMAN_NAME_MAXLEN 256
     41#define DEVMAN_NAME_MAXLEN  256
    4342
    4443typedef sysarg_t devman_handle_t;
    … …  
    6766} match_id_list_t;
    6867
    69 
    70 static inline match_id_t * create_match_id()
     68static inline match_id_t *create_match_id(void)
    7169{
    7270        match_id_t *id = malloc(sizeof(match_id_t));
    … …  
    8583}
    8684
    87 static inline void add_match_id(match_id_list_t *ids, match_id_t *id) 
     85static inline void add_match_id(match_id_list_t *ids, match_id_t *id)
    8886{
    8987        match_id_t *mid = NULL;
    90         link_t *link = ids->ids.next;   
     88        link_t *link = ids->ids.next;
    9189       
    9290        while (link != &ids->ids) {
    … …  
    9896        }
    9997       
    100         list_insert_before(&id->link, link);   
     98        list_insert_before(&id->link, link);
    10199}
    102100

  • uspace/lib/c/include/ipc/devmap.h

    r22027b6e r8b5690f  
    3434#define DEVMAP_DEVMAP_H_
    3535
    36 #include <atomic.h>
    37 #include <ipc/ipc.h>
    38 #include <adt/list.h>
     36#include <ipc/common.h>
    3937
    4038#define DEVMAP_NAME_MAXLEN  255

  • uspace/lib/c/include/ipc/fb.h

    r22027b6e r8b5690f  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#ifndef LIBC_FB_H_
    3636#define LIBC_FB_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/icmp.h

    r22027b6e r8b5690f  
    3333/** @file
    3434 * ICMP module messages.
    35  * @see icmp_interface.h
     35 * @see icmp_remote.h
    3636 */
    3737
    … …  
    3939#define LIBC_ICMP_MESSAGES_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342#include <sys/types.h>
    4443#include <sys/time.h>
    45 
    4644#include <net/icmp_codes.h>
    4745
    4846/** ICMP module messages. */
    4947typedef enum {
    50         /** Sends echo request. @see icmp_echo() */
     48        /** Send echo request. @see icmp_echo() */
    5149        NET_ICMP_ECHO = NET_ICMP_FIRST,
    5250       
    5351        /**
    54          * Sends destination unreachable error message.
     52         * Send destination unreachable error message.
    5553         * @see icmp_destination_unreachable_msg()
    5654         */
    … …  
    5856       
    5957        /**
    60          * Sends source quench error message.
     58         * Send source quench error message.
    6159         * @see icmp_source_quench_msg()
    6260         */
    … …  
    6462       
    6563        /**
    66          * Sends time exceeded error message.
     64         * Send time exceeded error message.
    6765         * @see icmp_time_exceeded_msg()
    6866         */
    … …  
    7068       
    7169        /**
    72          * Sends parameter problem error message.
     70         * Send parameter problem error message.
    7371         * @see icmp_parameter_problem_msg()
    7472         */
    75         NET_ICMP_PARAMETERPROB,
    76        
    77         /** Initializes new connection. */
    78         NET_ICMP_INIT
    79 } icmp_messages;
     73        NET_ICMP_PARAMETERPROB
     74} icmp_messages_t;
    8075
    8176/** @name ICMP specific message parameters definitions */
    8277/*@{*/
    8378
    84 /** Returns the ICMP code message parameter.
     79/** Return the ICMP code message parameter.
    8580 *
    86  * @param[in] call      The message call structure.
     81 * @param[in] call Message call structure.
     82 *
    8783 */
    88 #define ICMP_GET_CODE(call) \
    89         ({ \
    90                 icmp_code_t code = (icmp_code_t) IPC_GET_ARG1(*call); \
    91                 code; \
    92         })
     84#define ICMP_GET_CODE(call)  ((icmp_code_t) IPC_GET_ARG1(call))
    9385
    94 /** Returns the ICMP link MTU message parameter.
     86/** Return the ICMP link MTU message parameter.
    9587 *
    96  * @param[in] call      The message call structure.
     88 * @param[in] call Message call structure.
     89 *
    9790 */
    98 #define ICMP_GET_MTU(call) \
    99         ({ \
    100                 icmp_param_t mtu = (icmp_param_t) IPC_GET_ARG3(*call); \
    101                 mtu; \
    102         })
     91#define ICMP_GET_MTU(call)  ((icmp_param_t) IPC_GET_ARG3(call))
    10392
    104 /** Returns the pointer message parameter.
     93/** Return the pointer message parameter.
    10594 *
    106  * @param[in] call      The message call structure.
     95 * @param[in] call Message call structure.
     96 *
    10797 */
    108 #define ICMP_GET_POINTER(call) \
    109         ({ \
    110                 icmp_param_t pointer = (icmp_param_t) IPC_GET_ARG3(*call); \
    111                 pointer; \
    112         })
     98#define ICMP_GET_POINTER(call)  ((icmp_param_t) IPC_GET_ARG3(call))
    11399
    114 /** Returns the size message parameter.
     100/** Return the size message parameter.
    115101 *
    116  * @param[in] call      The message call structure.
     102 * @param[in] call Message call structure.
     103 *
    117104 */
    118 #define ICMP_GET_SIZE(call) \
    119         ({ \
    120                 size_t size = (size_t) IPC_GET_ARG1(call); \
    121                 size; \
    122         })
     105#define ICMP_GET_SIZE(call)  ((size_t) IPC_GET_ARG1(call))
    123106
    124 /** Returns the timeout message parameter.
     107/** Return the timeout message parameter.
    125108 *
    126  * @param[in] call      The message call structure.
     109 * @param[in] call Message call structure.
     110 *
    127111 */
    128 #define ICMP_GET_TIMEOUT(call) \
    129         ({ \
    130                 suseconds_t timeout = (suseconds_t) IPC_GET_ARG2(call); \
    131                 timeout; \
    132         })
     112#define ICMP_GET_TIMEOUT(call)  ((suseconds_t) IPC_GET_ARG2(call))
    133113
    134 /** Returns the time to live message parameter.
     114/** Return the time to live message parameter.
    135115 *
    136  * @param[in] call      The message call structure.
     116 * @param[in] call Message call structure.
     117 *
    137118 */
    138 #define ICMP_GET_TTL(call) \
    139         ({ \
    140                 ip_ttl_t ttl = (ip_ttl_t) IPC_GET_ARG3(call); \
    141                 ttl; \
    142         })
     119#define ICMP_GET_TTL(call)  ((ip_ttl_t) IPC_GET_ARG3(call))
    143120
    144 /** Returns the type of service message parameter.
     121/** Return the type of service message parameter.
    145122 *
    146  * @param[in] call      The message call structure.
     123 * @param[in] call Message call structure.
     124 *
    147125 */
    148 #define ICMP_GET_TOS(call) \
    149         ({ \
    150                 ip_tos_t tos = (ip_tos_t) IPC_GET_ARG4(call); \
    151                 tos; \
    152         })
     126#define ICMP_GET_TOS(call)  ((ip_tos_t) IPC_GET_ARG4(call))
    153127
    154 /** Returns the dont fragment message parameter.
     128/** Return the dont fragment message parameter.
    155129 *
    156  * @param[in] call      The message call structure.
     130 * @param[in] call Message call structure.
    157131 */
    158 #define ICMP_GET_DONT_FRAGMENT(call) \
    159         ({ \
    160                 int dont_fragment = (int) IPC_GET_ARG5(call); \
    161                 dont_fragment; \
    162         })
     132#define ICMP_GET_DONT_FRAGMENT(call)  ((int) IPC_GET_ARG5(call))
    163133
    164134/*@}*/

  • uspace/lib/c/include/ipc/il.h

    r22027b6e r8b5690f  
    3333/** @file
    3434 * Internetwork layer modules messages.
    35  * @see il_interface.h
     35 * @see il_remote.h
    3636 * @see ip_interface.h
    3737 */
    … …  
    4040#define LIBC_IL_MESSAGES_H_
    4141
    42 #include <ipc/ipc.h>
    4342#include <ipc/net.h>
    4443
    4544/** Internet layer modules messages. */
    4645typedef enum {
    47         /** New device message.
    48          * @see ip_device_req()
    49          */
    50         NET_IL_DEVICE = NET_IL_FIRST,
    5146        /** Device state changed message.
    5247         * @see il_device_state_msg()
    5348         */
    54         NET_IL_DEVICE_STATE,
     49        NET_IL_DEVICE_STATE = NET_IL_FIRST,
     50       
    5551        /** Device MTU changed message.
    5652         * @see il_mtu_changed_msg()
    5753         */
    5854        NET_IL_MTU_CHANGED,
    59         /** Packet size message.
    60          * @see il_packet_size_req()
    61          */
    62         NET_IL_PACKET_SPACE,
     55       
    6356        /** Packet received message.
    6457         * @see il_received_msg()
    6558         */
    66         NET_IL_RECEIVED,
    67         /** Packet send message.
    68          * @see il_send_msg()
    69          */
    70         NET_IL_SEND
     59        NET_IL_RECEIVED
    7160} il_messages;
    7261
    … …  
    7564
    7665/** Return the protocol number message parameter.
    77  * @param[in] call The message call structure.
     66 *
     67 * @param[in] call Message call structure.
     68 *
    7869 */
    79 #define IL_GET_PROTO(call)      (int) IPC_GET_ARG1(*call)
     70#define IL_GET_PROTO(call)  ((int) IPC_GET_ARG1(call))
    8071
    8172/** Return the registering service message parameter.
    82  * @param[in] call The message call structure.
     73 *
     74 * @param[in] call Message call structure.
     75 *
    8376 */
    84 #define IL_GET_SERVICE(call)    (services_t) IPC_GET_ARG2(*call)
     77#define IL_GET_SERVICE(call)  ((services_t) IPC_GET_ARG2(call))
    8578
    8679/*@}*/

  • uspace/lib/c/include/ipc/ip.h

    r22027b6e r8b5690f  
    3939#define LIBC_IP_MESSAGES_H_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    43 
    4442#include <net/in.h>
    4543#include <net/ip_codes.h>
    … …  
    4745/** IP module messages. */
    4846typedef enum {
     47        /** New device message.
     48         * @see ip_device_req()
     49         */
     50        NET_IP_DEVICE = NET_IP_FIRST,
     51       
    4952        /** Adds the routing entry.
    5053         * @see ip_add_route()
    5154         */
    52         NET_IP_ADD_ROUTE = NET_IP_FIRST,
     55        NET_IP_ADD_ROUTE,
     56       
    5357        /** Gets the actual route information.
    5458         * @see ip_get_route()
    5559         */
    5660        NET_IP_GET_ROUTE,
     61       
    5762        /** Processes the received error notification.
    5863         * @see ip_received_error_msg()
    5964         */
    6065        NET_IP_RECEIVED_ERROR,
     66       
    6167        /** Sets the default gateway.
    6268         * @see ip_set_default_gateway()
    6369         */
    64         NET_IP_SET_GATEWAY
     70        NET_IP_SET_GATEWAY,
     71       
     72        /** Packet size message.
     73         * @see ip_packet_size_req()
     74         */
     75        NET_IP_PACKET_SPACE,
     76       
     77        /** Packet send message.
     78         * @see ip_send_msg()
     79         */
     80        NET_IP_SEND
    6581} ip_messages;
    6682
    … …  
    6884/*@{*/
    6985
    70 /** Returns the address message parameter.
    71  * @param[in] call The message call structure.
     86/** Return the address message parameter.
     87 *
     88 * @param[in] call Message call structure.
     89 *
    7290 */
    7391#define IP_GET_ADDRESS(call) \
    7492        ({ \
    7593                in_addr_t addr; \
    76                 addr.s_addr = IPC_GET_ARG3(*call); \
     94                addr.s_addr = IPC_GET_ARG3(call); \
    7795                addr; \
    7896        })
    7997
    80 /** Returns the gateway message parameter.
    81  * @param[in] call The message call structure.
     98/** Return the gateway message parameter.
     99 *
     100 * @param[in] call Message call structure.
     101 *
    82102 */
    83103#define IP_GET_GATEWAY(call) \
    84104        ({ \
    85105                in_addr_t addr; \
    86                 addr.s_addr = IPC_GET_ARG2(*call); \
     106                addr.s_addr = IPC_GET_ARG2(call); \
    87107                addr; \
    88108        })
    89109
    90 /** Sets the header length in the message answer.
    91  * @param[out] answer The message answer structure.
     110/** Set the header length in the message answer.
     111 *
     112 * @param[out] answer Message answer structure.
     113 *
    92114 */
    93 #define IP_SET_HEADERLEN(answer, value) \
    94         do { \
    95                 sysarg_t argument = (sysarg_t) (value); \
    96                 IPC_SET_ARG2(*answer, argument); \
    97         } while (0)
     115#define IP_SET_HEADERLEN(answer, value)  IPC_SET_ARG2(answer, (sysarg_t) (value))
    98116
    99 /** Returns the network mask message parameter.
    100  * @param[in] call The message call structure.
     117/** Return the network mask message parameter.
     118 *
     119 * @param[in] call Message call structure.
     120 *
    101121 */
    102122#define IP_GET_NETMASK(call) \
    103123        ({ \
    104124                in_addr_t addr; \
    105                 addr.s_addr = IPC_GET_ARG4(*call); \
     125                addr.s_addr = IPC_GET_ARG4(call); \
    106126                addr; \
    107127        })
    108128
    109 /** Returns the protocol message parameter.
    110  * @param[in] call The message call structure.
     129/** Return the protocol message parameter.
     130 *
     131 * @param[in] call Message call structure.
     132 *
    111133 */
    112 #define IP_GET_PROTOCOL(call) \
    113         ({ \
    114                 ip_protocol_t protocol = (ip_protocol_t) IPC_GET_ARG1(*call); \
    115                 protocol; \
    116         })
     134#define IP_GET_PROTOCOL(call)  ((ip_protocol_t) IPC_GET_ARG1(call))
    117135
    118136/*@}*/

  • uspace/lib/c/include/ipc/ipc.h

    r22027b6e r8b5690f  
    3333 */
    3434
    35 #ifndef LIBIPC_IPC_H_
    36 #define LIBIPC_IPC_H_
    37 
     35#if ((defined(LIBC_ASYNC_H_)) && (!defined(LIBC_ASYNC_C_)))
     36        #error Do not intermix low-level IPC interface and async framework
     37#endif
     38
     39#ifndef LIBC_IPC_H_
     40#define LIBC_IPC_H_
     41
     42#include <sys/types.h>
     43#include <ipc/common.h>
     44#include <kernel/synch/synch.h>
    3845#include <task.h>
    39 #include <kernel/ipc/ipc.h>
    40 #include <kernel/ddi/irq.h>
    41 #include <sys/types.h>
    42 #include <kernel/synch/synch.h>
    43 
    44 #define IPC_FLAG_BLOCKING  0x01
    45 
    46 typedef struct {
    47         sysarg_t args[IPC_CALL_LEN];
    48         sysarg_t in_phone_hash;
    49 } ipc_call_t;
    50 
    51 typedef sysarg_t ipc_callid_t;
    52 
    53 typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
     46
     47typedef void (*ipc_async_callback_t)(void *, int, ipc_call_t *);
    5448
    5549/*
    … …  
    5953 * possible, the fast version is used.
    6054 */
     55
    6156#define ipc_call_sync_0_0(phoneid, method) \
    6257        ipc_call_sync_fast((phoneid), (method), 0, 0, 0, 0, 0, 0, 0, 0)
    … …  
    188183    sysarg_t *);
    189184
    190 extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
    191 extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
     185extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, sysarg_t, unsigned int);
    192186extern void ipc_poke(void);
    193187
    194 static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)
    195 {
    196         return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT);
    197 }
    198 
     188#define ipc_wait_for_call(data) \
     189        ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT);
     190
     191extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, sysarg_t);
    199192extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *);
    200193
    … …  
    205198 * to m.
    206199 */
     200
    207201#define ipc_answer_0(callid, retval) \
    208202        ipc_answer_fast((callid), (retval), 0, 0, 0, 0)
    … …  
    229223 * to m.
    230224 */
     225
    231226#define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \
    232227        ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \
    … …  
    254249
    255250extern void ipc_call_async_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
    256     sysarg_t, void *, ipc_async_callback_t, int);
     251    sysarg_t, void *, ipc_async_callback_t, bool);
    257252extern void ipc_call_async_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
    258     sysarg_t, sysarg_t, void *, ipc_async_callback_t, int);
    259 
    260 extern int ipc_connect_to_me(int, int, int, int, sysarg_t *);
    261 extern int ipc_connect_me_to(int, int, int, int);
    262 extern int ipc_connect_me_to_blocking(int, int, int, int);
     253    sysarg_t, sysarg_t, void *, ipc_async_callback_t, bool);
     254
     255extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t *,
     256    sysarg_t *);
     257extern int ipc_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
     258extern int ipc_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);
     259
    263260extern int ipc_hangup(int);
    264 extern int ipc_register_irq(int, int, int, irq_code_t *);
    265 extern int ipc_unregister_irq(int, int);
    266 extern int ipc_forward_fast(ipc_callid_t, int, int, sysarg_t, sysarg_t, int);
    267 extern int ipc_forward_slow(ipc_callid_t, int, int, sysarg_t, sysarg_t,
    268     sysarg_t, sysarg_t, sysarg_t, int);
     261
     262extern int ipc_forward_fast(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t,
     263    unsigned int);
     264extern int ipc_forward_slow(ipc_callid_t, int, sysarg_t, sysarg_t, sysarg_t,
     265    sysarg_t, sysarg_t, sysarg_t, unsigned int);
    269266
    270267/*
    271268 * User-friendly wrappers for ipc_share_in_start().
    272269 */
     270
    273271#define ipc_share_in_start_0_0(phoneid, dst, size) \
    274272        ipc_share_in_start((phoneid), (dst), (size), 0, NULL)
    … …  
    280278        ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
    281279
    282 extern int ipc_share_in_start(int, void *, size_t, sysarg_t, int *);
    283 extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
    284 extern int ipc_share_out_start(int, void *, int);
     280extern int ipc_share_in_start(int, void *, size_t, sysarg_t, unsigned int *);
     281extern int ipc_share_in_finalize(ipc_callid_t, void *, unsigned int);
     282extern int ipc_share_out_start(int, void *, unsigned int);
    285283extern int ipc_share_out_finalize(ipc_callid_t, void *);
    286284extern int ipc_data_read_start(int, void *, size_t);

  • uspace/lib/c/include/ipc/irc.h

    r22027b6e r8b5690f  
    3636#define LIBC_IRC_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/kbd.h

    r22027b6e r8b5690f  
    3838#define LIBC_IPC_KBD_H_
    3939
    40 #include <ipc/ipc.h>
     40#include <ipc/common.h>
    4141
    4242typedef enum {

  • uspace/lib/c/include/ipc/loader.h

    r22027b6e r8b5690f  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    3535#ifndef LIBC_IPC_LOADER_H_
    3636#define LIBC_IPC_LOADER_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939
    4040typedef enum {

  • uspace/lib/c/include/ipc/mouse.h

    r22027b6e r8b5690f  
    3737#define LIBC_IPC_MOUSE_H_
    3838
    39 #include <ipc/ipc.h>
     39#include <ipc/common.h>
    4040
    4141typedef enum {

  • uspace/lib/c/include/ipc/net.h

    r22027b6e r8b5690f  
    3838#define LIBC_NET_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/services.h>
    42 
    4341#include <net/device.h>
    4442#include <net/packet.h>
    4543
    46 /** Returns a value indicating whether the value is in the interval.
    47  * @param[in] item      The value to be checked.
    48  * @param[in] first_inclusive The first value in the interval inclusive.
    49  * @param[in] last_exclusive The first value after the interval.
     44/** Return a value indicating whether the value is in the interval.
     45 *
     46 * @param[in] item            Value to be checked.
     47 * @param[in] first_inclusive First value in the interval inclusive.
     48 * @param[in] last_exclusive  First value after the interval.
     49 *
    5050 */
    5151#define IS_IN_INTERVAL(item, first_inclusive, last_exclusive) \
    … …  
    5555/*@{*/
    5656
    57 /** The number of ARP messages. */
    58 #define NET_ARP_COUNT           5
    59 
    60 /** The number of Ethernet messages. */
    61 #define NET_ETH_COUNT           0
    62 
    63 /** The number of ICMP messages. */
    64 #define NET_ICMP_COUNT          6
    65 
    66 /** The number of inter-network messages. */
    67 #define NET_IL_COUNT            6
    68 
    69 /** The number of IP messages. */
    70 #define NET_IP_COUNT            4
    71 
    72 /** The number of general networking messages. */
    73 #define NET_NET_COUNT           3
    74 
    75 /** The number of network interface driver messages. */
    76 #define NET_NETIF_COUNT         6
    77 
    78 /** The number of network interface layer messages. */
    79 #define NET_NIL_COUNT           7
    80 
    81 /** The number of packet management system messages. */
    82 #define NET_PACKET_COUNT        5
    83 
    84 /** The number of socket messages. */
    85 #define NET_SOCKET_COUNT        14
    86 
    87 /** The number of TCP messages. */
    88 #define NET_TCP_COUNT           0
    89 
    90 /** The number of transport layer messages. */
    91 #define NET_TL_COUNT            1
    92 
    93 /** The number of UDP messages. */
    94 #define NET_UDP_COUNT           0
     57#define NET_ARP_COUNT     5   /**< Number of ARP messages. */
     58#define NET_ETH_COUNT     0   /**< Number of Ethernet messages. */
     59#define NET_ICMP_COUNT    6   /**< Number of ICMP messages. */
     60#define NET_IL_COUNT      6   /**< Number of inter-network messages. */
     61#define NET_IP_COUNT      4   /**< Number of IP messages. */
     62#define NET_NET_COUNT     3   /**< Number of general networking messages. */
     63#define NET_NETIF_COUNT   6   /**< Number of network interface driver messages. */
     64#define NET_NIL_COUNT     7   /**< Number of network interface layer messages. */
     65#define NET_PACKET_COUNT  5   /**< Number of packet management system messages. */
     66#define NET_SOCKET_COUNT  14  /**< Number of socket messages. */
     67#define NET_TCP_COUNT     0   /**< Number of TCP messages. */
     68#define NET_TL_COUNT      1   /**< Number of transport layer messages. */
     69#define NET_UDP_COUNT     0   /**< Number of UDP messages. */
    9570
    9671/*@}*/
    … …  
    10075/*@{*/
    10176
    102 /** The first networking message. */
    103 #define NET_FIRST               2000
    104 
    105 /** The first network interface layer message. */
    106 #define NET_NETIF_FIRST         NET_FIRST
    107 
    108 /** The last network interface layer message. */
    109 #define NET_NETIF_LAST          (NET_NETIF_FIRST + NET_NETIF_COUNT)
    110 
    111 /** The first general networking message. */
    112 #define NET_NET_FIRST           (NET_NETIF_LAST + 0)
    113 
    114 /** The last general networking message. */
    115 #define NET_NET_LAST            (NET_NET_FIRST + NET_NET_COUNT)
    116 
    117 /** The first network interface layer message. */
    118 #define NET_NIL_FIRST           (NET_NET_LAST + 0)
    119 
    120 /** The last network interface layer message. */
    121 #define NET_NIL_LAST            (NET_NIL_FIRST + NET_NIL_COUNT)
    122 
    123 /** The first Ethernet message. */
    124 #define NET_ETH_FIRST           (NET_NIL_LAST + 0)
    125 
    126 /** The last Ethernet message. */
    127 #define NET_ETH_LAST            (NET_ETH_FIRST + NET_ETH_COUNT)
    128 
    129 /** The first inter-network message. */
    130 #define NET_IL_FIRST            (NET_ETH_LAST + 0)
    131 
    132 /** The last inter-network message. */
    133 #define NET_IL_LAST             (NET_IL_FIRST + NET_IL_COUNT)
    134 
    135 /** The first IP message. */
    136 #define NET_IP_FIRST            (NET_IL_LAST + 0)
    137 
    138 /** The last IP message. */
    139 #define NET_IP_LAST             (NET_IP_FIRST + NET_IP_COUNT)
    140 
    141 /** The first ARP message. */
    142 #define NET_ARP_FIRST           (NET_IP_LAST + 0)
    143 
    144 /** The last ARP message. */
    145 #define NET_ARP_LAST            (NET_ARP_FIRST + NET_ARP_COUNT)
    146 
    147 /** The first ICMP message. */
    148 #define NET_ICMP_FIRST          (NET_ARP_LAST + 0)
    149 
    150 /** The last ICMP message. */
    151 #define NET_ICMP_LAST           (NET_ICMP_FIRST + NET_ICMP_COUNT)
    152 
    153 /** The first ICMP message. */
    154 #define NET_TL_FIRST            (NET_ICMP_LAST + 0)
    155 
    156 /** The last ICMP message. */
    157 #define NET_TL_LAST             (NET_TL_FIRST + NET_TL_COUNT)
    158 
    159 /** The first UDP message. */
    160 #define NET_UDP_FIRST           (NET_TL_LAST + 0)
    161 
    162 /** The last UDP message. */
    163 #define NET_UDP_LAST            (NET_UDP_FIRST + NET_UDP_COUNT)
    164 
    165 /** The first TCP message. */
    166 #define NET_TCP_FIRST           (NET_UDP_LAST + 0)
    167 
    168 /** The last TCP message. */
    169 #define NET_TCP_LAST            (NET_TCP_FIRST + NET_TCP_COUNT)
    170 
    171 /** The first socket message. */
    172 #define NET_SOCKET_FIRST        (NET_TCP_LAST + 0)
    173 
    174 /** The last socket message. */
    175 #define NET_SOCKET_LAST         (NET_SOCKET_FIRST + NET_SOCKET_COUNT)
    176 
    177 /** The first packet management system message. */
    178 #define NET_PACKET_FIRST        (NET_SOCKET_LAST + 0)
    179 
    180 /** The last packet management system message. */
    181 #define NET_PACKET_LAST         (NET_PACKET_FIRST + NET_PACKET_COUNT)
    182 
    183 /** The last networking message. */
    184 #define NET_LAST                NET_PACKET_LAST
    185 
    186 /** The number of networking messages. */
    187 #define NET_COUNT               (NET_LAST - NET_FIRST)
    188 
    189 /** Returns a value indicating whether the IPC call is a generic networking
    190  * message.
    191  * @param[in] call The IPC call to be checked.
     77
     78/** First networking message. */
     79#define NET_FIRST  2000
     80
     81/** First network interface layer message. */
     82#define NET_NETIF_FIRST  NET_FIRST
     83
     84/** Last network interface layer message. */
     85#define NET_NETIF_LAST  (NET_NETIF_FIRST + NET_NETIF_COUNT)
     86
     87/** First general networking message. */
     88#define NET_NET_FIRST  (NET_NETIF_LAST + 0)
     89
     90/** Last general networking message. */
     91#define NET_NET_LAST  (NET_NET_FIRST + NET_NET_COUNT)
     92
     93/** First network interface layer message. */
     94#define NET_NIL_FIRST  (NET_NET_LAST + 0)
     95
     96/** Last network interface layer message. */
     97#define NET_NIL_LAST  (NET_NIL_FIRST + NET_NIL_COUNT)
     98
     99/** First Ethernet message. */
     100#define NET_ETH_FIRST  (NET_NIL_LAST + 0)
     101
     102/** Last Ethernet message. */
     103#define NET_ETH_LAST  (NET_ETH_FIRST + NET_ETH_COUNT)
     104
     105/** First inter-network message. */
     106#define NET_IL_FIRST  (NET_ETH_LAST + 0)
     107
     108/** Last inter-network message. */
     109#define NET_IL_LAST  (NET_IL_FIRST + NET_IL_COUNT)
     110
     111/** First IP message. */
     112#define NET_IP_FIRST  (NET_IL_LAST + 0)
     113
     114/** Last IP message. */
     115#define NET_IP_LAST  (NET_IP_FIRST + NET_IP_COUNT)
     116
     117/** First ARP message. */
     118#define NET_ARP_FIRST  (NET_IP_LAST + 0)
     119
     120/** Last ARP message. */
     121#define NET_ARP_LAST  (NET_ARP_FIRST + NET_ARP_COUNT)
     122
     123/** First ICMP message. */
     124#define NET_ICMP_FIRST  (NET_ARP_LAST + 0)
     125
     126/** Last ICMP message. */
     127#define NET_ICMP_LAST  (NET_ICMP_FIRST + NET_ICMP_COUNT)
     128
     129/** First ICMP message. */
     130#define NET_TL_FIRST  (NET_ICMP_LAST + 0)
     131
     132/** Last ICMP message. */
     133#define NET_TL_LAST  (NET_TL_FIRST + NET_TL_COUNT)
     134
     135/** First UDP message. */
     136#define NET_UDP_FIRST  (NET_TL_LAST + 0)
     137
     138/** Last UDP message. */
     139#define NET_UDP_LAST  (NET_UDP_FIRST + NET_UDP_COUNT)
     140
     141/** First TCP message. */
     142#define NET_TCP_FIRST  (NET_UDP_LAST + 0)
     143
     144/** Last TCP message. */
     145#define NET_TCP_LAST  (NET_TCP_FIRST + NET_TCP_COUNT)
     146
     147/** First socket message. */
     148#define NET_SOCKET_FIRST  (NET_TCP_LAST + 0)
     149
     150/** Last socket message. */
     151#define NET_SOCKET_LAST  (NET_SOCKET_FIRST + NET_SOCKET_COUNT)
     152
     153/** First packet management system message. */
     154#define NET_PACKET_FIRST  (NET_SOCKET_LAST + 0)
     155
     156/** Last packet management system message. */
     157#define NET_PACKET_LAST  (NET_PACKET_FIRST + NET_PACKET_COUNT)
     158
     159/** Last networking message. */
     160#define NET_LAST  NET_PACKET_LAST
     161
     162/** Number of networking messages. */
     163#define NET_COUNT  (NET_LAST - NET_FIRST)
     164
     165/** Check if the IPC call is a generic networking message.
     166 *
     167 * @param[in] call IPC call to be checked.
     168 *
    192169 */
    193170#define IS_NET_MESSAGE(call) \
    194         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_FIRST, NET_LAST)
    195 
    196 /** Returns a value indicating whether the IPC call is an ARP message.
    197  * @param[in] call The IPC call to be checked.
     171        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_FIRST, NET_LAST)
     172
     173/** Check if the IPC call is an ARP message.
     174 *
     175 * @param[in] call IPC call to be checked.
     176 *
    198177 */
    199178#define IS_NET_ARP_MESSAGE(call) \
    200         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_ARP_FIRST, NET_ARP_LAST)
    201 
    202 /** Returns a value indicating whether the IPC call is an Ethernet message.
    203  * @param[in] call The IPC call to be checked.
     179        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_ARP_FIRST, NET_ARP_LAST)
     180
     181/** Check if the IPC call is an Ethernet message.
     182 *
     183 * @param[in] call IPC call to be checked.
     184 *
    204185 */
    205186#define IS_NET_ETH_MESSAGE(call) \
    206         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_ETH_FIRST, NET_ETH_LAST)
    207 
    208 /** Returns a value indicating whether the IPC call is an ICMP message.
    209  * @param[in] call The IPC call to be checked.
     187        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_ETH_FIRST, NET_ETH_LAST)
     188
     189/** Check if the IPC call is an ICMP message.
     190 *
     191 * @param[in] call IPC call to be checked.
     192 *
    210193 */
    211194#define IS_NET_ICMP_MESSAGE(call) \
    212         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_ICMP_FIRST, NET_ICMP_LAST)
    213 
    214 /** Returns a value indicating whether the IPC call is an inter-network layer
    215  * message.
    216  * @param[in] call The IPC call to be checked.
     195        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_ICMP_FIRST, NET_ICMP_LAST)
     196
     197/** Check if the IPC call is an inter-network layer message.
     198 *
     199 * @param[in] call IPC call to be checked.
     200 *
    217201 */
    218202#define IS_NET_IL_MESSAGE(call) \
    219         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_IL_FIRST, NET_IL_LAST)
    220 
    221 /** Returns a value indicating whether the IPC call is an IP message.
    222  * @param[in] call The IPC call to be checked.
     203        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_IL_FIRST, NET_IL_LAST)
     204
     205/** Check if the IPC call is an IP message.
     206 *
     207 * @param[in] call IPC call to be checked.
     208 *
    223209 */
    224210#define IS_NET_IP_MESSAGE(call) \
    225         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_IP_FIRST, NET_IP_LAST)
    226 
    227 /** Returns a value indicating whether the IPC call is a generic networking
    228  * message.
    229  * @param[in] call The IPC call to be checked.
     211        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_IP_FIRST, NET_IP_LAST)
     212
     213/** Check if the IPC call is a generic networking message.
     214 *
     215 * @param[in] call IPC call to be checked.
     216 *
    230217 */
    231218#define IS_NET_NET_MESSAGE(call) \
    232         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_NET_FIRST, NET_NET_LAST)
    233 
    234 /** Returns a value indicating whether the IPC call is a network interface layer
    235  * message.
    236  * @param[in] call The IPC call to be checked.
     219        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_NET_FIRST, NET_NET_LAST)
     220
     221/** Check if the IPC call is a network interface layer message.
     222 *
     223 * @param[in] call IPC call to be checked.
     224 *
    237225 */
    238226#define IS_NET_NIL_MESSAGE(call) \
    239         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_NIL_FIRST, NET_NIL_LAST)
    240 
    241 /** Returns a value indicating whether the IPC call is a packet manaagement
    242  * system message.
    243  * @param[in] call The IPC call to be checked.
     227        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_NIL_FIRST, NET_NIL_LAST)
     228
     229/** Check if the IPC call is a packet manaagement system message.
     230 *
     231 * @param[in] call IPC call to be checked.
     232 *
    244233 */
    245234#define IS_NET_PACKET_MESSAGE(call) \
    246         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_PACKET_FIRST, NET_PACKET_LAST)
    247 
    248 /** Returns a value indicating whether the IPC call is a socket message.
    249  * @param[in] call The IPC call to be checked.
     235        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_PACKET_FIRST, NET_PACKET_LAST)
     236
     237/** Check if the IPC call is a socket message.
     238 *
     239 * @param[in] call IPC call to be checked.
     240 *
    250241 */
    251242#define IS_NET_SOCKET_MESSAGE(call) \
    252         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_SOCKET_FIRST, NET_SOCKET_LAST)
    253 
    254 /** Returns a value indicating whether the IPC call is a TCP message.
    255  * @param[in] call The IPC call to be checked.
     243        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_SOCKET_FIRST, NET_SOCKET_LAST)
     244
     245/** Check if the IPC call is a TCP message.
     246 *
     247 * @param[in] call IPC call to be checked.
     248 *
    256249 */
    257250#define IS_NET_TCP_MESSAGE(call) \
    258         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_TCP_FIRST, NET_TCP_LAST)
    259 
    260 /** Returns a value indicating whether the IPC call is a transport layer message.
    261  * @param[in] call The IPC call to be checked.
     251        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_TCP_FIRST, NET_TCP_LAST)
     252
     253/** Check if the IPC call is a transport layer message.
     254 *
     255 * @param[in] call IPC call to be checked.
     256 *
    262257 */
    263258#define IS_NET_TL_MESSAGE(call) \
    264         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_TL_FIRST, NET_TL_LAST)
    265 
    266 /** Returns a value indicating whether the IPC call is a UDP message.
    267  * @param[in] call The IPC call to be checked.
     259        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_TL_FIRST, NET_TL_LAST)
     260
     261/** Check if the IPC call is a UDP message.
     262 *
     263 * @param[in] call IPC call to be checked.
     264 *
    268265 */
    269266#define IS_NET_UDP_MESSAGE(call) \
    270         IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_UDP_FIRST, NET_UDP_LAST)
     267        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_UDP_FIRST, NET_UDP_LAST)
    271268
    272269/*@}*/
    … …  
    275272/*@{*/
    276273
    277 /** Returns the device identifier message argument.
    278  * @param[in] call The message call structure.
    279  */
    280 #define IPC_GET_DEVICE(call) \
    281         ({ \
    282                 device_id_t device_id = (device_id_t) IPC_GET_ARG1(*call); \
    283                 device_id; \
    284         })
    285 
    286 /** Returns the packet identifier message argument.
    287  * @param[in] call The message call structure.
    288  */
    289 #define IPC_GET_PACKET(call) \
    290         ({ \
    291                 packet_id_t packet_id = (packet_id_t) IPC_GET_ARG2(*call); \
    292                 packet_id; \
    293         })
    294 
    295 /** Returns the count message argument.
    296  * @param[in] call The message call structure.
    297  */
    298 #define IPC_GET_COUNT(call) \
    299         ({ \
    300                 size_t size = (size_t) IPC_GET_ARG2(*call); \
    301                 size; \
    302         })
    303 
    304 /** Returns the device state message argument.
    305  * @param[in] call The message call structure.
    306  */
    307 #define IPC_GET_STATE(call) \
    308         ({ \
    309                 device_state_t state = (device_state_t) IPC_GET_ARG2(*call); \
    310                 state; \
    311         })
    312 
    313 /** Returns the maximum transmission unit message argument.
    314  * @param[in] call The message call structure.
    315  */
    316 #define IPC_GET_MTU(call) \
    317         ({ \
    318                 size_t size = (size_t) IPC_GET_ARG2(*call); \
    319                 size; \
    320         })
    321 
    322 /** Returns the device driver service message argument.
    323  * @param[in] call The message call structure.
    324  */
    325 #define IPC_GET_SERVICE(call) \
    326         ({ \
    327                 services_t service = (services_t) IPC_GET_ARG3(*call); \
    328                 service; \
    329         })
    330 
    331 /** Returns the target service message argument.
    332  * @param[in] call The message call structure.
    333  */
    334 #define IPC_GET_TARGET(call) \
    335         ({ \
    336                 services_t service = (services_t) IPC_GET_ARG3(*call); \
    337                 service; \
    338         })
    339 
    340 /** Returns the sender service message argument.
    341  * @param[in] call The message call structure.
    342  */
    343 #define IPC_GET_SENDER(call) \
    344         ({ \
    345                 services_t service = (services_t) IPC_GET_ARG3(*call); \
    346                 service; \
    347         })
    348 
    349 /** Returns the error service message argument.
    350  * @param[in] call The message call structure.
    351  */
    352 #define IPC_GET_ERROR(call) \
    353         ({ \
    354                 services_t service = (services_t) IPC_GET_ARG4(*call); \
    355                 service; \
    356         })
    357 
    358 /** Returns the phone message argument.
    359  * @param[in] call The message call structure.
    360  */
    361 #define IPC_GET_PHONE(call) \
    362         ({ \
    363                 int phone = (int) IPC_GET_ARG5(*call); \
    364                 phone; \
    365         })
    366 
    367 /** Sets the device identifier in the message answer.
    368  * @param[out] answer The message answer structure.
    369  */
    370 #define IPC_SET_DEVICE(answer, value) \
    371         do { \
    372                 sysarg_t argument = (sysarg_t) (value); \
    373                 IPC_SET_ARG1(*answer, argument); \
    374         } while (0)
    375 
    376 /** Sets the minimum address length in the message answer.
    377  * @param[out] answer The message answer structure.
    378  */
    379 #define IPC_SET_ADDR(answer, value) \
    380         do { \
    381                 sysarg_t argument = (sysarg_t) (value); \
    382                 IPC_SET_ARG1(*answer, argument); \
    383         } while (0)
    384 
    385 /** Sets the minimum prefix size in the message answer.
    386  * @param[out] answer The message answer structure.
    387  */
    388 #define IPC_SET_PREFIX(answer, value) \
    389         do { \
    390                 sysarg_t argument = (sysarg_t) (value); \
    391                 IPC_SET_ARG2(*answer, argument); \
    392         } while (0)
    393 
    394 /** Sets the maximum content size in the message answer.
    395  * @param[out] answer The message answer structure.
    396  */
    397 #define IPC_SET_CONTENT(answer, value) \
    398         do { \
    399                 sysarg_t argument = (sysarg_t) (value); \
    400                 IPC_SET_ARG3(*answer, argument); \
    401         } while (0)
    402 
    403 /** Sets the minimum suffix size in the message answer.
    404  * @param[out] answer The message answer structure.
    405  */
    406 #define IPC_SET_SUFFIX(answer, value) \
    407         do { \
    408                 sysarg_t argument = (sysarg_t) (value); \
    409                 IPC_SET_ARG4(*answer, argument); \
    410         } while (0)
     274/** Return the device identifier message argument.
     275 *
     276 * @param[in] call Message call structure.
     277 *
     278 */
     279#define IPC_GET_DEVICE(call)  ((device_id_t) IPC_GET_ARG1(call))
     280
     281/** Return the packet identifier message argument.
     282 *
     283 * @param[in] call Message call structure.
     284 *
     285 */
     286#define IPC_GET_PACKET(call)  ((packet_id_t) IPC_GET_ARG2(call))
     287
     288/** Return the count message argument.
     289 *
     290 * @param[in] call Message call structure.
     291 *
     292 */
     293#define IPC_GET_COUNT(call)  ((size_t) IPC_GET_ARG2(call))
     294
     295/** Return the device state message argument.
     296 *
     297 * @param[in] call Message call structure.
     298 *
     299 */
     300#define IPC_GET_STATE(call)  ((device_state_t) IPC_GET_ARG2(call))
     301
     302/** Return the maximum transmission unit message argument.
     303 *
     304 * @param[in] call Message call structure.
     305 *
     306 */
     307#define IPC_GET_MTU(call)  ((size_t) IPC_GET_ARG2(call))
     308
     309/** Return the device driver service message argument.
     310 *
     311 * @param[in] call Message call structure.
     312 *
     313 */
     314#define IPC_GET_SERVICE(call)  ((services_t) IPC_GET_ARG3(call))
     315
     316/** Return the target service message argument.
     317 *
     318 * @param[in] call Message call structure.
     319 *
     320 */
     321#define IPC_GET_TARGET(call)  ((services_t) IPC_GET_ARG3(call))
     322
     323/** Return the sender service message argument.
     324 *
     325 * @param[in] call Message call structure.
     326 *
     327 */
     328#define IPC_GET_SENDER(call)  ((services_t) IPC_GET_ARG3(call))
     329
     330/** Return the error service message argument.
     331 &
     332 * @param[in] call Message call structure.
     333 *
     334 */
     335#define IPC_GET_ERROR(call)  ((services_t) IPC_GET_ARG4(call))
     336
     337/** Return the phone message argument.
     338 *
     339 * @param[in] call Message call structure.
     340 *
     341 */
     342#define IPC_GET_PHONE(call)  ((int) IPC_GET_ARG5(call))
     343
     344/** Set the device identifier in the message answer.
     345 *
     346 * @param[out] answer Message answer structure.
     347 * @param[in]  value  Value to set.
     348 *
     349 */
     350#define IPC_SET_DEVICE(answer, value)  IPC_SET_ARG1(answer, (sysarg_t) (value))
     351
     352/** Set the minimum address length in the message answer.
     353 *
     354 * @param[out] answer Message answer structure.
     355 * @param[in]  value  Value to set.
     356 *
     357 */
     358#define IPC_SET_ADDR(answer, value)  IPC_SET_ARG1(answer, (sysarg_t) (value))
     359
     360/** Set the minimum prefix size in the message answer.
     361 *
     362 * @param[out] answer Message answer structure.
     363 * @param[in]  value  Value to set.
     364 *
     365 */
     366#define IPC_SET_PREFIX(answer, value)  IPC_SET_ARG2(answer, (sysarg_t) (value))
     367
     368/** Set the maximum content size in the message answer.
     369 *
     370 * @param[out] answer Message answer structure.
     371 * @param[in]  value  Value to set.
     372 *
     373 */
     374#define IPC_SET_CONTENT(answer, value)  IPC_SET_ARG3(answer, (sysarg_t) (value))
     375
     376/** Set the minimum suffix size in the message answer.
     377 *
     378 * @param[out] answer Message answer structure.
     379 * @param[in]  value  Value to set.
     380 *
     381 */
     382#define IPC_SET_SUFFIX(answer, value)  IPC_SET_ARG4(answer, (sysarg_t) (value))
    411383
    412384/*@}*/

  • uspace/lib/c/include/ipc/net_net.h

    r22027b6e r8b5690f  
    3939#define LIBC_NET_NET_MESSAGES_H_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342

  • uspace/lib/c/include/ipc/netif.h

    r22027b6e r8b5690f  
    3838#define LIBC_NETIF_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241
    … …  
    4746         */
    4847        NET_NETIF_PROBE = NET_NETIF_FIRST,
     48       
    4949        /** Send packet message.
    5050         * @see netif_send_msg()
    5151         */
    5252        NET_NETIF_SEND,
     53       
    5354        /** Start device message.
    5455         * @see netif_start_req()
    5556         */
    5657        NET_NETIF_START,
     58       
    5759        /** Get device usage statistics message.
    5860         * @see netif_stats_req()
    5961         */
    6062        NET_NETIF_STATS,
     63       
    6164        /** Stop device message.
    6265         * @see netif_stop_req()
    6366         */
    6467        NET_NETIF_STOP,
     68       
    6569        /** Get device address message.
    6670         * @see netif_get_addr_req()
    … …  
    7377
    7478/** Return the interrupt number message parameter.
    75  * @param[in] call The message call structure.
     79 *
     80 * @param[in] call Mmessage call structure.
     81 *
    7682 */
    77 #define NETIF_GET_IRQ(call) \
    78         ({ \
    79                 int irq = (int) IPC_GET_ARG2(*call); \
    80                 irq; \
    81         })
     83#define NETIF_GET_IRQ(call) ((int) IPC_GET_ARG2(call))
    8284
    8385/** Return the input/output address message parameter.
    84  * @param[in] call The message call structure.
     86 *
     87 * @param[in] call Message call structure.
     88 *
    8589 */
    86 #define NETIF_GET_IO(call) \
    87         ({ \
    88                 int io = (int) IPC_GET_ARG3(*call); \
    89                 io; \
    90         })
     90#define NETIF_GET_IO(call) ((void *) IPC_GET_ARG3(call))
    9191
    9292/*@}*/

  • uspace/lib/c/include/ipc/nil.h

    r22027b6e r8b5690f  
    3838#define LIBC_NIL_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241
    … …  
    7776
    7877/** Return the protocol service message parameter. */
    79 #define NIL_GET_PROTO(call) \
    80         ({ \
    81                 services_t service = (services_t) IPC_GET_ARG2(*call); \
    82                 service; \
    83         })
     78#define NIL_GET_PROTO(call)  ((services_t) IPC_GET_ARG2(call))
    8479
    8580/*@}*/

  • uspace/lib/c/include/ipc/ns.h

    r22027b6e r8b5690f  
    3333 */
    3434
    35 #ifndef LIBIPC_NS_H_
    36 #define LIBIPC_NS_H_
     35#ifndef LIBC_NS_H_
     36#define LIBC_NS_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <sys/types.h>
     39#include <ipc/common.h>
    3940
    4041typedef enum {
    … …  
    4546} ns_request_t;
    4647
     48extern int service_register(sysarg_t);
     49extern int service_connect(sysarg_t, sysarg_t, sysarg_t);
     50extern int service_connect_blocking(sysarg_t, sysarg_t, sysarg_t);
     51
    4752#endif
    4853

  • uspace/lib/c/include/ipc/packet.h

    r22027b6e r8b5690f  
    3838#define LIBC_PACKET_MESSAGES_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241
    … …  
    7069} packet_messages;
    7170
    72 /** Returns the protocol service message parameter. */
    73 #define ARP_GET_PROTO(call)     (services_t) IPC_GET_ARG2(*call)
     71/** Return the protocol service message parameter. */
     72#define ARP_GET_PROTO(call)  ((services_t) IPC_GET_ARG2(call))
    7473
    75 /** Returns the packet identifier message parameter. */
    76 #define IPC_GET_ID(call)        (packet_id_t) IPC_GET_ARG1(*call)
     74/** Return the packet identifier message parameter. */
     75#define IPC_GET_ID(call)  ((packet_id_t) IPC_GET_ARG1(call))
    7776
    78 /** Returns the maximal content length message parameter. */
    79 #define IPC_GET_CONTENT(call)   (size_t) IPC_GET_ARG1(*call)
     77/** Return the maximal content length message parameter. */
     78#define IPC_GET_CONTENT(call)  ((size_t) IPC_GET_ARG1(call))
    8079
    81 /** Returns the maximal address length message parameter. */
    82 #define IPC_GET_ADDR_LEN(call)  (size_t) IPC_GET_ARG2(*call)
     80/** Return the maximal address length message parameter. */
     81#define IPC_GET_ADDR_LEN(call)  ((size_t) IPC_GET_ARG2(call))
    8382
    84 /** Returns the maximal prefix length message parameter. */
    85 #define IPC_GET_PREFIX(call)    (size_t) IPC_GET_ARG3(*call)
     83/** Return the maximal prefix length message parameter. */
     84#define IPC_GET_PREFIX(call)  ((size_t) IPC_GET_ARG3(call))
    8685
    87 /** Returns the maximal suffix length message parameter. */
    88 #define IPC_GET_SUFFIX(call)    (size_t) IPC_GET_ARG4(*call)
     86/** Return the maximal suffix length message parameter. */
     87#define IPC_GET_SUFFIX(call)  ((size_t) IPC_GET_ARG4(call))
    8988
    9089#endif

  • uspace/lib/c/include/ipc/services.h

    r22027b6e r8b5690f  
    3535 */
    3636
    37 #ifndef LIBIPC_SERVICES_H_
    38 #define LIBIPC_SERVICES_H_
     37#ifndef LIBC_SERVICES_H_
     38#define LIBC_SERVICES_H_
    3939
    4040typedef enum {
    … …  
    5454        SERVICE_NETWORKING,
    5555        SERVICE_LO,
    56         SERVICE_DP8390,
     56        SERVICE_NE2000,
    5757        SERVICE_ETHERNET,
    5858        SERVICE_NILDUMMY,
    … …  
    6666} services_t;
    6767
    68 /* Memory area to be received from NS */
    69 #define SERVICE_MEM_REALTIME    1
    70 #define SERVICE_MEM_KLOG        2
    71 
    7268#endif
    7369

  • uspace/lib/c/include/ipc/socket.h

    r22027b6e r8b5690f  
    3838#define LIBC_SOCKET_MESSAGES_H_
    3939
    40 #include <ipc/ipc.h>
    4140#include <ipc/net.h>
    4241

  • uspace/lib/c/include/ipc/tl.h

    r22027b6e r8b5690f  
    3939#define LIBC_TL_MESSAGES_H_
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/net.h>
    4342

  • uspace/lib/c/include/ipc/vfs.h

    r22027b6e r8b5690f  
    3636#define LIBC_IPC_VFS_H_
    3737
    38 #include <ipc/ipc.h>
     38#include <ipc/common.h>
    3939#include <sys/types.h>
    4040#include <bool.h>

  • uspace/lib/c/include/libc.h

    r22027b6e r8b5690f  
    6262        __syscall6(p1, p2, p3, p4, p5, p6, id)
    6363
    64 extern void __main(void *pcb_ptr);
    65 extern void __exit(void);
    66 
    6764#endif
    6865

  • uspace/lib/c/include/loader/pcb.h

    r22027b6e r8b5690f  
    5252        /** Program entry point. */
    5353        entry_point_t entry;
    54 
     54       
    5555        /** Current working directory. */
    5656        char *cwd;

  • uspace/lib/c/include/malloc.h

    r22027b6e r8b5690f  
    3838#include <sys/types.h>
    3939
    40 extern void __heap_init(void);
    4140extern uintptr_t get_max_heap_addr(void);
    4241

  • uspace/lib/c/include/net/icmp_common.h

    r22027b6e r8b5690f  
    4141#include <sys/time.h>
    4242
    43 /** Default timeout for incoming connections in microseconds. */
    44 #define ICMP_CONNECT_TIMEOUT    (1 * 1000 * 1000)
     43/** Default timeout for incoming connections in microseconds (1 sec). */
     44#define ICMP_CONNECT_TIMEOUT  1000000
    4545
    46 extern int icmp_connect_module(services_t, suseconds_t);
     46extern int icmp_connect_module(suseconds_t);
    4747
    4848#endif

  • uspace/lib/c/include/net/in.h

    r22027b6e r8b5690f  
    4343
    4444/** INET string address maximum length. */
    45 #define INET_ADDRSTRLEN         (4 * 3 + 3 + 1)
     45#define INET_ADDRSTRLEN  (4 * 3 + 3 + 1)
    4646
    4747/** Type definition of the INET address.
    4848 * @see in_addr
    4949 */
    50 typedef struct in_addr          in_addr_t;
     50typedef struct in_addr in_addr_t;
    5151
    5252/** Type definition of the INET socket address.

  • uspace/lib/c/include/net/modules.h

    r22027b6e r8b5690f  
    4343
    4444#include <async.h>
    45 
    46 #include <ipc/ipc.h>
    4745#include <ipc/services.h>
    48 
    4946#include <sys/time.h>
    5047
    5148/** Connect to the needed module function type definition.
    5249 *
    53  * @param[in] need      The needed module service.
    54  * @return              The phone of the needed service.
     50 * @param[in] need The needed module service.
     51 *
     52 * @return The phone of the needed service.
     53 *
    5554 */
    5655typedef int connect_module_t(services_t need);
    5756
    58 extern void answer_call(ipc_callid_t, int, ipc_call_t *, int);
     57extern void answer_call(ipc_callid_t, int, ipc_call_t *, size_t);
    5958extern int bind_service(services_t, sysarg_t, sysarg_t, sysarg_t,
    6059    async_client_conn_t);
    … …  
    6463extern int connect_to_service_timeout(services_t, suseconds_t);
    6564extern int data_reply(void *, size_t);
    66 extern void refresh_answer(ipc_call_t *, int *);
     65extern void refresh_answer(ipc_call_t *, size_t *);
    6766
    6867#endif

  • uspace/lib/c/include/setjmp.h

    r22027b6e r8b5690f  
    4141
    4242extern int setjmp(jmp_buf env);
    43 extern void longjmp(jmp_buf env,int val) __attribute__((__noreturn__));
     43extern void longjmp(jmp_buf env, int val) __attribute__((noreturn));
    4444
    4545#endif

  • uspace/lib/c/include/stdlib.h

    r22027b6e r8b5690f  
    4040#include <stacktrace.h>
    4141
    42 #define abort() \
    43         do { \
    44                 stacktrace_print(); \
    45                 _exit(1); \
    46         } while (0)
     42#define RAND_MAX  714025
    4743
    48 #define core() \
    49         *((int *) 0) = 0xbadbad;
    50 
    51 #define exit(status)  _exit((status))
    52 
    53 #define RAND_MAX  714025
     44#define rand()       random()
     45#define srand(seed)  srandom(seed)
    5446
    5547extern long int random(void);
    5648extern void srandom(unsigned int seed);
    5749
    58 static inline int rand(void)
    59 {
    60         return random();
    61 }
    62 
    63 static inline void srand(unsigned int seed)
    64 {
    65         srandom(seed);
    66 }
     50extern void abort(void) __attribute__((noreturn));
    6751
    6852#endif

  • uspace/lib/c/include/syscall.h

    r22027b6e r8b5690f  
    3232/**
    3333 * @file
    34  * @brief       Syscall function declaration for architectures that don't
    35  *              inline syscalls or architectures that handle syscalls
    36  *              according to the number of arguments.
     34 * @brief Syscall function declaration for architectures that don't
     35 *        inline syscalls or architectures that handle syscalls
     36 *        according to the number of arguments.
    3737 */
    3838
    … …  
    4040#define LIBC_SYSCALL_H_
    4141
    42 #ifndef LIBARCH_SYSCALL_GENERIC
    43 #error "You can't include this file directly."
     42#ifndef LIBARCH_SYSCALL_GENERIC
     43        #error You cannot include this file directly
    4444#endif
    4545
    … …  
    4747#include <kernel/syscall/syscall.h>
    4848
    49 #define __syscall0      __syscall
    50 #define __syscall1      __syscall
    51 #define __syscall2      __syscall
    52 #define __syscall3      __syscall
    53 #define __syscall4      __syscall
    54 #define __syscall5      __syscall
    55 #define __syscall6      __syscall
     49#define __syscall0  __syscall
     50#define __syscall1  __syscall
     51#define __syscall2  __syscall
     52#define __syscall3  __syscall
     53#define __syscall4  __syscall
     54#define __syscall5  __syscall
     55#define __syscall6  __syscall
    5656
    5757extern sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2,

  • uspace/lib/c/include/thread.h

    r22027b6e r8b5690f  
    3636#define LIBC_THREAD_H_
    3737
    38 #include <kernel/proc/uarg.h>
    3938#include <libarch/thread.h>
    4039#include <sys/types.h>
    … …  
    4241typedef uint64_t thread_id_t;
    4342
    44 extern void __thread_entry(void);
    45 extern void __thread_main(uspace_arg_t *);
    46 
    4743extern int thread_create(void (*)(void *), void *, const char *, thread_id_t *);
    48 extern void thread_exit(int) __attribute__ ((noreturn));
     44extern void thread_exit(int) __attribute__((noreturn));
    4945extern void thread_detach(thread_id_t);
    5046extern int thread_join(thread_id_t);

  • uspace/lib/c/include/tls.h

    r22027b6e r8b5690f  
    5757extern void tls_free_variant_1(tcb_t *, size_t);
    5858#endif
     59
    5960#ifdef CONFIG_TLS_VARIANT_2
    6061extern tcb_t *tls_alloc_variant_2(void **, size_t);

  • uspace/lib/c/include/udebug.h

    r22027b6e r8b5690f  
    3838#include <kernel/udebug/udebug.h>
    3939#include <sys/types.h>
    40 #include <libarch/types.h>
    4140
    4241typedef sysarg_t thash_t;
    4342
    44 int udebug_begin(int phoneid);
    45 int udebug_end(int phoneid);
    46 int udebug_set_evmask(int phoneid, udebug_evmask_t mask);
    47 int udebug_thread_read(int phoneid, void *buffer, size_t n,
    48         size_t *copied, size_t *needed);
    49 int udebug_name_read(int phoneid, void *buffer, size_t n,
    50         size_t *copied, size_t *needed);
    51 int udebug_areas_read(int phoneid, void *buffer, size_t n,
    52         size_t *copied, size_t *needed);
    53 int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n);
    54 int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer);
    55 int udebug_regs_read(int phoneid, thash_t tid, void *buffer);
    56 int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
    57         sysarg_t *val0, sysarg_t *val1);
    58 int udebug_stop(int phoneid, thash_t tid);
     43int udebug_begin(int);
     44int udebug_end(int);
     45int udebug_set_evmask(int, udebug_evmask_t);
     46int udebug_thread_read(int, void *, size_t , size_t *, size_t *);
     47int udebug_name_read(int, void *, size_t, size_t *, size_t *);
     48int udebug_areas_read(int, void *, size_t, size_t *, size_t *);
     49int udebug_mem_read(int, void *, uintptr_t, size_t);
     50int udebug_args_read(int, thash_t, sysarg_t *);
     51int udebug_regs_read(int, thash_t, void *);
     52int udebug_go(int, thash_t, udebug_event_t *, sysarg_t *, sysarg_t *);
     53int udebug_stop(int, thash_t);
    5954
    6055#endif

  • uspace/lib/c/include/unistd.h

    r22027b6e r8b5690f  
    4141
    4242#ifndef NULL
    43         #define NULL    ((void *) 0)
     43        #define NULL  ((void *) 0)
    4444#endif
    4545
    … …  
    7474extern int chdir(const char *);
    7575
    76 extern void _exit(int) __attribute__((noreturn));
     76extern void exit(int) __attribute__((noreturn));
    7777extern int usleep(useconds_t);
    7878extern unsigned int sleep(unsigned int);

  • uspace/lib/c/include/vfs/vfs.h

    r22027b6e r8b5690f  
    5757extern int unmount(const char *);
    5858
    59 extern void __stdio_init(int filc, fdi_node_t *filv[]);
    60 extern void __stdio_done(void);
    61 
    6259extern int open_node(fdi_node_t *, int);
    6360extern int fd_phone(int);
Note: See TracChangeset for help on using the changeset viewer.