Changeset 357b5f5 in mainline for uspace/lib/c


Ignore:
Timestamp:
2011-01-23T20:09:13Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
fdb9982c
Parents:
cead2aa (diff), 7e36c8d (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:
1 added
1 deleted
74 edited
4 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    rcead2aa r357b5f5  
    5959        generic/devman.c \
    6060        generic/device/hw_res.c \
    61         generic/device/char.c \
     61        generic/device/char_dev.c \
    6262        generic/event.c \
    6363        generic/errno.c \
    … …  
    8787        generic/ipc.c \
    8888        generic/async.c \
    89         generic/async_rel.c \
     89        generic/async_sess.c \
    9090        generic/loader.c \
    9191        generic/getopt.c \

  • uspace/lib/c/arch/abs32le/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_abs32le_INTTYPES_H_
    3535
    36 #define PRIdn  PRId32  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu32  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId32  /**< Format for native_t. */
     37#define PRIun  PRIu32  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu32  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/arch/amd64/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_amd64_INTTYPES_H_
    3535
    36 #define PRIdn  PRId64  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu64  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx64  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId64  /**< Format for native_t. */
     37#define PRIun  PRIu64  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx64  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu64  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/arch/arm32/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_arm32_INTTYPES_H_
    3535
    36 #define PRIdn  PRId32  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu32  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId32  /**< Format for native_t. */
     37#define PRIun  PRIu32  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu32  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/arch/ia32/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_ia32_INTTYPES_H_
    3535
    36 #define PRIdn  PRId32  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu32  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId32  /**< Format for native_t. */
     37#define PRIun  PRIu32  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu32  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/arch/ia64/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_ia64_INTTYPES_H_
    3535
    36 #define PRIdn  PRId64  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu64  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx64  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId64  /**< Format for native_t. */
     37#define PRIun  PRIu64  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx64  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu64  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/arch/mips32/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_mips32_INTTYPES_H_
    3535
    36 #define PRIdn  PRId32  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu32  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId32  /**< Format for native_t. */
     37#define PRIun  PRIu32  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu32  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/arch/ppc32/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_ppc32_INTTYPES_H_
    3535
    36 #define PRIdn  PRId32  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu32  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId32  /**< Format for native_t. */
     37#define PRIun  PRIu32  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx32  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu32  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/arch/sparc64/include/inttypes.h

    rcead2aa r357b5f5  
    3434#define LIBC_sparc64_INTTYPES_H_
    3535
    36 #define PRIdn  PRId64  /**< Format for sysarg_t, ipcarg_t, etc. */
    37 #define PRIun  PRIu64  /**< Format for sysarg_t, ipcarg_t, etc. */
    38 #define PRIxn  PRIx64  /**< Format for hexadecimal sysarg_t, ipcarg_t, etc. */
     36#define PRIdn  PRId64  /**< Format for native_t. */
     37#define PRIun  PRIu64  /**< Format for sysarg_t. */
     38#define PRIxn  PRIx64  /**< Format for hexadecimal sysarg_t. */
    3939#define PRIua  PRIu64  /**< Format for atomic_count_t. */
    4040

  • uspace/lib/c/generic/adt/char_map.c

    rcead2aa r357b5f5  
    6565 */
    6666static int
    67 char_map_add_item(char_map_t *map, const char *identifier, size_t length,
     67char_map_add_item(char_map_t *map, const uint8_t *identifier, size_t length,
    6868    const int value)
    6969{
    … …  
    9090        }
    9191
    92         map->items[map->next]->c = * identifier;
    93         ++ identifier;
    94         ++ map->next;
    95         if ((length > 1) || ((length == 0) && (*identifier))) {
     92        map->items[map->next]->c = *identifier;
     93        identifier++;
     94        map->next++;
     95        if ((length > 1) || ((length == 0) && *identifier)) {
    9696                map->items[map->next - 1]->value = CHAR_MAP_NULL;
    9797                return char_map_add_item(map->items[map->next - 1], identifier,
    … …  
    139139 */
    140140int
    141 char_map_add(char_map_t *map, const char *identifier, size_t length,
     141char_map_add(char_map_t *map, const uint8_t *identifier, size_t length,
    142142    const int value)
    143143{
    144         if (char_map_is_valid(map) && (identifier) &&
    145             ((length) || (*identifier))) {
     144        if (char_map_is_valid(map) && identifier && (length || *identifier)) {
    146145                int index;
    147146
    148                 for (index = 0; index < map->next; ++ index) {
     147                for (index = 0; index < map->next; index++) {
    149148                        if (map->items[index]->c != *identifier)
    150149                                continue;
    151150                               
    152                         ++ identifier;
    153                         if((length > 1) || ((length == 0) && (*identifier))) {
     151                        identifier++;
     152                        if((length > 1) || ((length == 0) && *identifier)) {
    154153                                return char_map_add(map->items[index],
    155154                                    identifier, length ? length - 1 : 0, value);
    … …  
    178177
    179178                map->magic = 0;
    180                 for (index = 0; index < map->next; ++index)
     179                for (index = 0; index < map->next; index++)
    181180                        char_map_destroy(map->items[index]);
    182181
    … …  
    201200 */
    202201static char_map_t *
    203 char_map_find_node(const char_map_t *map, const char *identifier,
     202char_map_find_node(const char_map_t *map, const uint8_t *identifier,
    204203    size_t length)
    205204{
    … …  
    207206                return NULL;
    208207
    209         if (length || (*identifier)) {
     208        if (length || *identifier) {
    210209                int index;
    211210
    212                 for (index = 0; index < map->next; ++index) {
     211                for (index = 0; index < map->next; index++) {
    213212                        if (map->items[index]->c == *identifier) {
    214                                 ++identifier;
     213                                identifier++;
    215214                                if (length == 1)
    216215                                        return map->items[index];
    … …  
    242241 * @return              CHAR_MAP_NULL if the key is not assigned a value.
    243242 */
    244 int char_map_exclude(char_map_t *map, const char *identifier, size_t length)
     243int char_map_exclude(char_map_t *map, const uint8_t *identifier, size_t length)
    245244{
    246245        char_map_t *node;
    … …  
    270269 *  @return             CHAR_MAP_NULL if the key is not assigned a value.
    271270 */
    272 int char_map_find(const char_map_t *map, const char *identifier, size_t length)
     271int char_map_find(const char_map_t *map, const uint8_t *identifier, size_t length)
    273272{
    274273        char_map_t *node;
    … …  
    330329 */
    331330int
    332 char_map_update(char_map_t *map, const char *identifier, const size_t length,
     331char_map_update(char_map_t *map, const uint8_t *identifier, const size_t length,
    333332    const int value)
    334333{

  • uspace/lib/c/generic/adt/measured_strings.c

    rcead2aa r357b5f5  
    5959 */
    6060measured_string_t *
    61 measured_string_create_bulk(const char *string, size_t length)
     61measured_string_create_bulk(const uint8_t *string, size_t length)
    6262{
    6363        measured_string_t *new;
    … …  
    6868        }
    6969        new = (measured_string_t *) malloc(sizeof(measured_string_t) +
    70             (sizeof(char) * (length + 1)));
     70            (sizeof(uint8_t) * (length + 1)));
    7171        if (!new)
    7272                return NULL;
    7373
    7474        new->length = length;
    75         new->value = ((char *) new) + sizeof(measured_string_t);
     75        new->value = ((uint8_t *) new) + sizeof(measured_string_t);
    7676        // append terminating zero explicitly - to be safe
    7777        memcpy(new->value, string, new->length);
    … …  
    9797        new = (measured_string_t *) malloc(sizeof(measured_string_t));
    9898        if (new) {
    99                 new->value = (char *) malloc(source->length + 1);
     99                new->value = (uint8_t *) malloc(source->length + 1);
    100100                if (new->value) {
    101101                        new->length = source->length;
    … …  
    131131 */
    132132int
    133 measured_strings_receive(measured_string_t **strings, char **data,
     133measured_strings_receive(measured_string_t **strings, uint8_t **data,
    134134    size_t count)
    135135{
    … …  
    137137        size_t index;
    138138        size_t length;
    139         char *next;
     139        uint8_t *next;
    140140        ipc_callid_t callid;
    141141        int rc;
    … …  
    311311 */
    312312int
    313 measured_strings_return(int phone, measured_string_t **strings, char **data,
     313measured_strings_return(int phone, measured_string_t **strings, uint8_t **data,
    314314    size_t count)
    315315{
    316316        size_t *lengths;
    317317        size_t index;
    318         char *next;
     318        uint8_t *next;
    319319        int rc;
    320320

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

    rcead2aa r357b5f5  
    120120        ipc_call_t *dataptr;
    121121       
    122         ipcarg_t retval;
     122        sysarg_t retval;
    123123} amsg_t;
    124124
    … …  
    140140       
    141141        /** Incoming phone hash. */
    142         ipcarg_t in_phone_hash;
     142        sysarg_t in_phone_hash;
    143143       
    144144        /** Messages that should be delivered to this fibril. */
    … …  
    288288        list_append(&msg->link, &conn->msg_queue);
    289289       
    290         if (IPC_GET_METHOD(*call) == IPC_M_PHONE_HUNGUP)
     290        if (IPC_GET_IMETHOD(*call) == IPC_M_PHONE_HUNGUP)
    291291                conn->close_callid = callid;
    292292       
    … …  
    401401                         */
    402402                        memset(call, 0, sizeof(ipc_call_t));
    403                         IPC_SET_METHOD(*call, IPC_M_PHONE_HUNGUP);
     403                        IPC_SET_IMETHOD(*call, IPC_M_PHONE_HUNGUP);
    404404                        futex_up(&async_futex);
    405405                        return conn->close_callid;
    … …  
    529529 *
    530530 */
    531 fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
     531fid_t async_new_connection(sysarg_t in_phone_hash, ipc_callid_t callid,
    532532    ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *))
    533533{
    … …  
    588588        }
    589589       
    590         switch (IPC_GET_METHOD(*call)) {
     590        switch (IPC_GET_IMETHOD(*call)) {
    591591        case IPC_M_CONNECT_ME:
    592592        case IPC_M_CONNECT_ME_TO:
    … …  
    749749                return ENOMEM;
    750750        }
     751
     752        _async_sess_init();
    751753       
    752754        return 0;
    … …  
    807809 *
    808810 */
    809 aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    810     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
     811aid_t async_send_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     812    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
    811813{
    812814        amsg_t *msg = malloc(sizeof(*msg));
    … …  
    846848 *
    847849 */
    848 aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
    849     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
     850aid_t async_send_slow(int phoneid, sysarg_t method, sysarg_t arg1,
     851    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    850852    ipc_call_t *dataptr)
    851853{
    … …  
    875877 *
    876878 */
    877 void async_wait_for(aid_t amsgid, ipcarg_t *retval)
     879void async_wait_for(aid_t amsgid, sysarg_t *retval)
    878880{
    879881        amsg_t *msg = (amsg_t *) amsgid;
    … …  
    911913 *
    912914 */
    913 int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, suseconds_t timeout)
     915int async_wait_timeout(aid_t amsgid, sysarg_t *retval, suseconds_t timeout)
    914916{
    915917        amsg_t *msg = (amsg_t *) amsgid;
    … …  
    10231025 *
    10241026 */
    1025 ipcarg_t async_req_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    1026     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t *r1, ipcarg_t *r2,
    1027     ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5)
     1027sysarg_t async_req_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     1028    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
     1029    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    10281030{
    10291031        ipc_call_t result;
    … …  
    10311033            &result);
    10321034       
    1033         ipcarg_t rc;
     1035        sysarg_t rc;
    10341036        async_wait_for(eid, &rc);
    10351037       
    … …  
    10721074 *
    10731075 */
    1074 ipcarg_t async_req_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
    1075     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *r1,
    1076     ipcarg_t *r2, ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5)
     1076sysarg_t async_req_slow(int phoneid, sysarg_t method, sysarg_t arg1,
     1077    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     1078    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    10771079{
    10781080        ipc_call_t result;
    … …  
    10801082            &result);
    10811083       
    1082         ipcarg_t rc;
     1084        sysarg_t rc;
    10831085        async_wait_for(eid, &rc);
    10841086       
    … …  
    11131115 */
    11141116int
    1115 async_connect_me_to(int phoneid, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3)
     1117async_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
    11161118{
    11171119        int rc;
    1118         ipcarg_t newphid;
     1120        sysarg_t newphid;
    11191121
    11201122        rc = async_req_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL,
    … …  
    11401142 */
    11411143int
    1142 async_connect_me_to_blocking(int phoneid, ipcarg_t arg1, ipcarg_t arg2,
    1143     ipcarg_t arg3)
     1144async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
     1145    sysarg_t arg3)
    11441146{
    11451147        int rc;
    1146         ipcarg_t newphid;
     1148        sysarg_t newphid;
    11471149
    11481150        rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
    … …  
    11661168 * @return              Zero on success or a negative error code from errno.h.
    11671169 */
    1168 int async_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
     1170int async_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
    11691171    int *flags)
    11701172{
    11711173        int res;
    11721174        sysarg_t tmp_flags;
    1173         res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
    1174             (ipcarg_t) size, arg, NULL, &tmp_flags);
     1175        res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
     1176            (sysarg_t) size, arg, NULL, &tmp_flags);
    11751177        if (flags)
    11761178                *flags = tmp_flags;
    … …  
    11991201
    12001202        *callid = async_get_call(&data);
    1201         if (IPC_GET_METHOD(data) != IPC_M_SHARE_IN)
     1203        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN)
    12021204                return 0;
    12031205        *size = (size_t) IPC_GET_ARG2(data);
    … …  
    12311233int async_share_out_start(int phoneid, void *src, int flags)
    12321234{
    1233         return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
    1234             (ipcarg_t) flags);
     1235        return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
     1236            (sysarg_t) flags);
    12351237}
    12361238
    … …  
    12591261
    12601262        *callid = async_get_call(&data);
    1261         if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT)
     1263        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT)
    12621264                return 0;
    12631265        *size = (size_t) IPC_GET_ARG2(data);
    … …  
    12921294int async_data_read_start(int phoneid, void *dst, size_t size)
    12931295{
    1294         return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
    1295             (ipcarg_t) size);
     1296        return async_req_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
     1297            (sysarg_t) size);
    12961298}
    12971299
    … …  
    13171319
    13181320        *callid = async_get_call(&data);
    1319         if (IPC_GET_METHOD(data) != IPC_M_DATA_READ)
     1321        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
    13201322                return 0;
    13211323        if (size)
    … …  
    13451347 *
    13461348 */
    1347 int async_data_read_forward_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    1348     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
     1349int async_data_read_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     1350    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
    13491351{
    13501352        ipc_callid_t callid;
    … …  
    13691371        }
    13701372       
    1371         ipcarg_t rc;
     1373        sysarg_t rc;
    13721374        async_wait_for(msg, &rc);
    13731375       
    … …  
    13861388int async_data_write_start(int phoneid, const void *src, size_t size)
    13871389{
    1388         return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
    1389             (ipcarg_t) size);
     1390        return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
     1391            (sysarg_t) size);
    13901392}
    13911393
    … …  
    14121414       
    14131415        *callid = async_get_call(&data);
    1414         if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
     1416        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
    14151417                return 0;
    14161418       
    … …  
    15311533 *
    15321534 */
    1533 int async_data_write_forward_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    1534     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr)
     1535int async_data_write_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     1536    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
    15351537{
    15361538        ipc_callid_t callid;
    … …  
    15551557        }
    15561558       
    1557         ipcarg_t rc;
     1559        sysarg_t rc;
    15581560        async_wait_for(msg, &rc);
    15591561       

  • uspace/lib/c/generic/cap.c

    rcead2aa r357b5f5  
    3131 */
    3232/**
    33  * @file        cap.c
    34  * @brief       Functions to grant/revoke capabilities to/from a task.
     33 * @file  cap.c
     34 * @brief Functions to grant/revoke capabilities to/from a task.
    3535 */
    3636
    … …  
    3838#include <task.h>
    3939#include <libc.h>
    40 #include <kernel/syscall/sysarg64.h>
    4140
    4241/** Grant capabilities to a task.
    4342 *
    44  * @param id Destination task ID.
     43 * @param id   Destination task ID.
    4544 * @param caps Capabilities to grant.
    4645 *
    4746 * @return Zero on success or a value from @ref errno.h on failure.
     47 *
    4848 */
    4949int cap_grant(task_id_t id, unsigned int caps)
    5050{
    51         sysarg64_t arg;
     51#ifdef __32_BITS__
     52        sysarg64_t arg = (sysarg64_t) id;
     53        return __SYSCALL2(SYS_CAP_GRANT, (sysarg_t) &arg, (sysarg_t) caps);
     54#endif
    5255       
    53         arg.value = (unsigned long long) id;
    54 
    55         return __SYSCALL2(SYS_CAP_GRANT, (sysarg_t) &arg, (sysarg_t) caps);
     56#ifdef __64_BITS__
     57        return __SYSCALL2(SYS_CAP_GRANT, (sysarg_t) id, (sysarg_t) caps);
     58#endif
    5659}
    5760
    5861/** Revoke capabilities from a task.
    5962 *
    60  * @param id Destination task ID.
     63 * @param id   Destination task ID.
    6164 * @param caps Capabilities to revoke.
    6265 *
    6366 * @return Zero on success or a value from @ref errno.h on failure.
     67 *
    6468 */
    6569int cap_revoke(task_id_t id, unsigned int caps)
    6670{
    67         sysarg64_t arg;
     71#ifdef __32_BITS__
     72        sysarg64_t arg = (sysarg64_t) id;
     73        return __SYSCALL2(SYS_CAP_REVOKE, (sysarg_t) &arg, (sysarg_t) caps);
     74#endif
    6875       
    69         arg.value = (unsigned long long) id;
    70 
    71         return __SYSCALL2(SYS_CAP_REVOKE, (sysarg_t) &arg, (sysarg_t) caps);
     76#ifdef __64_BITS__
     77        return __SYSCALL2(SYS_CAP_REVOKE, (sysarg_t) id, (sysarg_t) caps);
     78#endif
    7279}
    7380

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

    rcead2aa r357b5f5  
    7575                clip_connect();
    7676               
    77                 ipcarg_t rc = async_req_1_0(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_NONE);
     77                sysarg_t rc = async_req_1_0(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_NONE);
    7878               
    7979                async_serialize_end();
    … …  
    8585               
    8686                aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, NULL);
    87                 ipcarg_t rc = async_data_write_start(clip_phone, (void *) str, size);
     87                sysarg_t rc = async_data_write_start(clip_phone, (void *) str, size);
    8888                if (rc != EOK) {
    89                         ipcarg_t rc_orig;
     89                        sysarg_t rc_orig;
    9090                        async_wait_for(req, &rc_orig);
    9191                        async_serialize_end();
    … …  
    119119                clip_connect();
    120120               
    121                 ipcarg_t size;
    122                 ipcarg_t tag;
    123                 ipcarg_t rc = async_req_0_2(clip_phone, CLIPBOARD_CONTENT, &size, &tag);
     121                sysarg_t size;
     122                sysarg_t tag;
     123                sysarg_t rc = async_req_0_2(clip_phone, CLIPBOARD_CONTENT, &size, &tag);
    124124               
    125125                async_serialize_end();
    … …  
    158158                       
    159159                        if (rc != EOK) {
    160                                 ipcarg_t rc_orig;
     160                                sysarg_t rc_orig;
    161161                                async_wait_for(req, &rc_orig);
    162162                                async_serialize_end();

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

    rcead2aa r357b5f5  
    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 *

  • uspace/lib/c/generic/device/char_dev.c

    rcead2aa r357b5f5  
    3434
    3535#include <ipc/dev_iface.h>
    36 #include <device/char.h>
     36#include <device/char_dev.h>
    3737#include <errno.h>
    3838#include <async.h>
    … …  
    4545 * using its character interface.
    4646 *
    47  * @param dev_phone Phone to the device.
    48  * @param buf       Buffer for the data read
    49  *                  from or written to the device.
    50  * @param len       Maximum length of the data to be
    51  *                  read or written.
    52  * @param read      Read from the device if true,
    53  *                  write to it otherwise.
     47 * @param dev_phone     Phone to the device.
     48 * @param buf           Buffer for the data read from or written to the device.
     49 * @param size          Maximum size of data (in bytes) to be read or written.
     50 * @param read          Read from the device if true, write to it otherwise.
    5451 *
    55  * @return Non-negative number of bytes actually read
    56  *         from or written to the device on success,
    57  *         negative error number otherwise.
    58  *
     52 * @return              Non-negative number of bytes actually read from or
     53 *                      written to the device on success, negative error number
     54 *                      otherwise.
    5955 */
    60 static ssize_t rw_dev(int dev_phone, void *buf, size_t len, bool read)
     56static ssize_t char_dev_rw(int dev_phone, void *buf, size_t size, bool read)
    6157{
    6258        async_serialize_start();
    … …  
    6864        if (read) {
    6965                req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE),
    70                     CHAR_READ_DEV, &answer);
    71                 ret = async_data_read_start(dev_phone, buf, len);
     66                    CHAR_DEV_READ, &answer);
     67                ret = async_data_read_start(dev_phone, buf, size);
    7268        } else {
    7369                req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE),
    74                     CHAR_WRITE_DEV, &answer);
    75                 ret = async_data_write_start(dev_phone, buf, len);
     70                    CHAR_DEV_WRITE, &answer);
     71                ret = async_data_write_start(dev_phone, buf, size);
    7672        }
    7773       
    78         ipcarg_t rc;
     74        sysarg_t rc;
    7975        if (ret != EOK) {
    8076                async_wait_for(req, &rc);
    … …  
    8278                if (rc == EOK)
    8379                        return (ssize_t) ret;
    84                        
     80               
    8581                return (ssize_t) rc;
    8682        }
    … …  
    9692}
    9793
    98 /** Read from device using its character interface.
     94/** Read from character device.
    9995 *
    100  * @param dev_phone Phone to the device.
    101  * @param buf       Output buffer for the data
    102  *                  read from the device.
    103  * @param len       Maximum length of the data to be read.
     96 * @param dev_phone     Phone to the device.
     97 * @param buf           Output buffer for the data read from the device.
     98 * @param size          Maximum size (in bytes) of the data to be read.
    10499 *
    105  * @return Non-negative number of bytes actually read
    106  *         from the device on success, negative error
    107  *         number otherwise.
    108  *
     100 * @return              Non-negative number of bytes actually read from the
     101 *                      device on success, negative error number otherwise.
    109102 */
    110 ssize_t read_dev(int dev_phone, void *buf, size_t len)
     103ssize_t char_dev_read(int dev_phone, void *buf, size_t size)
    111104{
    112         return rw_dev(dev_phone, buf, len, true);
     105        return char_dev_rw(dev_phone, buf, size, true);
    113106}
    114107
    115 /** Write to device using its character interface.
     108/** Write to character device.
    116109 *
    117  * @param dev_phone Phone to the device.
    118  * @param buf       Input buffer containg the data
    119  *                  to be written to the device.
    120  * @param len       Maximum length of the data to be written.
     110 * @param dev_phone     Phone to the device.
     111 * @param buf           Input buffer containg the data to be written to the
     112 *                      device.
     113 * @param size          Maximum size (in bytes) of the data to be written.
    121114 *
    122  * @return Non-negative number of bytes actually written
    123  *         to the device on success, negative error number
    124  *         otherwise.
    125  *
     115 * @return              Non-negative number of bytes actually written to the
     116 *                      device on success, negative error number otherwise.
    126117 */
    127 ssize_t write_dev(int dev_phone, void *buf, size_t len)
     118ssize_t char_dev_write(int dev_phone, void *buf, size_t size)
    128119{
    129         return rw_dev(dev_phone, buf, len, false);
     120        return char_dev_rw(dev_phone, buf, size, false);
    130121}
    131122

  • uspace/lib/c/generic/device/hw_res.c

    rcead2aa r357b5f5  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28  
     28
    2929 /** @addtogroup libc
    3030 * @{
    … …  
    3232/** @file
    3333 */
    34  
     34
    3535#include <device/hw_res.h>
    3636#include <errno.h>
    … …  
    3838#include <malloc.h>
    3939
    40 bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
     40int hw_res_get_resource_list(int dev_phone, hw_resource_list_t *hw_resources)
    4141{
    42         ipcarg_t count = 0;
    43         int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), GET_RESOURCE_LIST, &count);
     42        sysarg_t count = 0;
     43
     44        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     45            HW_RES_GET_RESOURCE_LIST, &count);
     46
    4447        hw_resources->count = count;
    45         if (EOK != rc) {
    46                 return false;
    47         }
     48        if (rc != EOK)
     49                return rc;
    4850       
    4951        size_t size = count * sizeof(hw_resource_t);
    5052        hw_resources->resources = (hw_resource_t *)malloc(size);
    51         if (NULL == hw_resources->resources) {
    52                 return false;
     53        if (!hw_resources->resources)
     54                return ENOMEM;
     55       
     56        rc = async_data_read_start(dev_phone, hw_resources->resources, size);
     57        if (rc != EOK) {
     58                free(hw_resources->resources);
     59                hw_resources->resources = NULL;
     60                return rc;
    5361        }
    5462       
    55         rc = async_data_read_start(dev_phone, hw_resources->resources, size);
    56         if (EOK != rc) {
    57                 free(hw_resources->resources);
    58                 hw_resources->resources = NULL;
    59                 return false;
    60         }
    61                  
    62         return true;     
     63        return EOK;
    6364}
    6465
    65 bool enable_interrupt(int dev_phone)
     66bool hw_res_enable_interrupt(int dev_phone)
    6667{
    67         int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), ENABLE_INTERRUPT);
     68        int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     69            HW_RES_ENABLE_INTERRUPT);
     70
    6871        return rc == EOK;
    6972}
    70  
    71  
    72  
    73  /** @}
     73
     74/** @}
    7475 */

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

    rcead2aa r357b5f5  
    4242#include <devman.h>
    4343#include <async.h>
     44#include <fibril_synch.h>
    4445#include <errno.h>
    4546#include <malloc.h>
    … …  
    5051static int devman_phone_client = -1;
    5152
     53static FIBRIL_MUTEX_INITIALIZE(devman_phone_mutex);
     54
    5255int devman_get_phone(devman_interface_t iface, unsigned int flags)
    5356{
    5457        switch (iface) {
    5558        case DEVMAN_DRIVER:
    56                 if (devman_phone_driver >= 0)
     59                fibril_mutex_lock(&devman_phone_mutex);
     60                if (devman_phone_driver >= 0) {
     61                        fibril_mutex_unlock(&devman_phone_mutex);
    5762                        return devman_phone_driver;
     63                }
    5864               
    5965                if (flags & IPC_FLAG_BLOCKING)
    60                         devman_phone_driver = ipc_connect_me_to_blocking(PHONE_NS,
     66                        devman_phone_driver = async_connect_me_to_blocking(
     67                            PHONE_NS, SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
     68                else
     69                        devman_phone_driver = async_connect_me_to(PHONE_NS,
    6170                            SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
    62                 else
    63                         devman_phone_driver = ipc_connect_me_to(PHONE_NS,
    64                             SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
    65                
     71               
     72                fibril_mutex_unlock(&devman_phone_mutex);
    6673                return devman_phone_driver;
    6774        case DEVMAN_CLIENT:
    68                 if (devman_phone_client >= 0)
     75                fibril_mutex_lock(&devman_phone_mutex);
     76                if (devman_phone_client >= 0) {
     77                        fibril_mutex_unlock(&devman_phone_mutex);
    6978                        return devman_phone_client;
    70                
    71                 if (flags & IPC_FLAG_BLOCKING)
    72                         devman_phone_client = ipc_connect_me_to_blocking(PHONE_NS,
     79                }
     80               
     81                if (flags & IPC_FLAG_BLOCKING) {
     82                        devman_phone_client = async_connect_me_to_blocking(
     83                            PHONE_NS, SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
     84                } else {
     85                        devman_phone_client = async_connect_me_to(PHONE_NS,
    7386                            SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
    74                 else
    75                         devman_phone_client = ipc_connect_me_to(PHONE_NS,
    76                             SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
    77                
     87                }
     88               
     89                fibril_mutex_unlock(&devman_phone_mutex);
    7890                return devman_phone_client;
    7991        default:
    … …  
    95107        aid_t req = async_send_2(phone, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
    96108       
    97         ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
     109        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
    98110        if (retval != EOK) {
    99111                async_wait_for(req, NULL);
    … …  
    104116        async_set_client_connection(conn);
    105117       
    106         ipcarg_t callback_phonehash;
     118        sysarg_t callback_phonehash;
    107119        ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
    108120        async_wait_for(req, &retval);
    … …  
    116128{
    117129        ipc_call_t answer;
    118         async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score, &answer);
     130        aid_t req = async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score, &answer);
    119131        int retval = async_data_write_start(phone, match_id->id, str_size(match_id->id));
    120         return retval; 
     132        async_wait_for(req, NULL);
     133        return retval;
    121134}
    122135
    … …  
    154167        aid_t req = async_send_2(phone, DEVMAN_ADD_CHILD_DEVICE, parent_handle, match_count, &answer);
    155168
    156         ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
     169        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
    157170        if (retval != EOK) {
    158171                async_wait_for(req, NULL);
    … …  
    191204        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, devman_handle, &answer);
    192205       
    193         ipcarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
     206        sysarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
    194207        if (retval != EOK) {
    195208                async_wait_for(req, NULL);
    … …  
    229242       
    230243        if (flags & IPC_FLAG_BLOCKING) {
    231                 phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
     244                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
    232245                    DEVMAN_CONNECT_TO_DEVICE, handle);
    233246        } else {
    234                 phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
     247                phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
    235248                    DEVMAN_CONNECT_TO_DEVICE, handle);
    236249        }
    … …  
    244257       
    245258        if (flags & IPC_FLAG_BLOCKING) {
    246                 phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
     259                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
    247260                    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
    248261        } else {
    249                 phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
     262                phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
    250263                    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
    251264        }
    … …  
    267280            &answer);
    268281       
    269         ipcarg_t retval = async_data_write_start(phone, pathname, str_size(pathname));
     282        sysarg_t retval = async_data_write_start(phone, pathname, str_size(pathname));
    270283        if (retval != EOK) {
    271284                async_wait_for(req, NULL);

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

    rcead2aa r357b5f5  
    107107        aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
    108108       
    109         ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
     109        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
    110110        if (retval != EOK) {
    111111                async_wait_for(req, NULL);
    … …  
    116116        async_set_client_connection(conn);
    117117       
    118         ipcarg_t callback_phonehash;
     118        sysarg_t callback_phonehash;
    119119        ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
    120120        async_wait_for(req, &retval);
    … …  
    127127/** Register new device.
    128128 *
    129  * @param namespace Namespace name.
     129 * The @p interface is used when forwarding connection to the driver.
     130 * If not 0, the first argument is the interface and the second argument
     131 * is the devmap handle of the device.
     132 * When the interface is zero (default), the first argument is directly
     133 * the handle (to ensure backward compatibility).
     134 *
     135 * @param fqdn Fully qualified device name.
     136 * @param[out] handle Handle to the created instance of device.
     137 * @param interface Interface when forwarding.
     138 *
     139 */
     140int devmap_device_register_with_iface(const char *fqdn,
     141    devmap_handle_t *handle, sysarg_t interface)
     142{
     143        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
     144       
     145        if (phone < 0)
     146                return phone;
     147       
     148        async_serialize_start();
     149       
     150        ipc_call_t answer;
     151        aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, interface, 0,
     152            &answer);
     153       
     154        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
     155        if (retval != EOK) {
     156                async_wait_for(req, NULL);
     157                async_serialize_end();
     158                return retval;
     159        }
     160       
     161        async_wait_for(req, &retval);
     162       
     163        async_serialize_end();
     164       
     165        if (retval != EOK) {
     166                if (handle != NULL)
     167                        *handle = -1;
     168                return retval;
     169        }
     170       
     171        if (handle != NULL)
     172                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
     173       
     174        return retval;
     175}
     176
     177/** Register new device.
     178 *
    130179 * @param fqdn      Fully qualified device name.
    131180 * @param handle    Output: Handle to the created instance of device.
    … …  
    134183int devmap_device_register(const char *fqdn, devmap_handle_t *handle)
    135184{
    136         int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
    137        
    138         if (phone < 0)
    139                 return phone;
    140        
    141         async_serialize_start();
    142        
    143         ipc_call_t answer;
    144         aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, 0, 0,
    145             &answer);
    146        
    147         ipcarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
    148         if (retval != EOK) {
    149                 async_wait_for(req, NULL);
    150                 async_serialize_end();
    151                 return retval;
    152         }
    153        
    154         async_wait_for(req, &retval);
    155        
    156         async_serialize_end();
    157        
    158         if (retval != EOK) {
    159                 if (handle != NULL)
    160                         *handle = -1;
    161                 return retval;
    162         }
    163        
    164         if (handle != NULL)
    165                 *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
    166        
    167         return retval;
    168 }
     185        return devmap_device_register_with_iface(fqdn, handle, 0);
     186}
     187
    169188
    170189int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags)
    … …  
    181200            &answer);
    182201       
    183         ipcarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
     202        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
    184203        if (retval != EOK) {
    185204                async_wait_for(req, NULL);
    … …  
    217236            &answer);
    218237       
    219         ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
     238        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
    220239        if (retval != EOK) {
    221240                async_wait_for(req, NULL);
    … …  
    247266                return phone;
    248267       
    249         ipcarg_t type;
     268        sysarg_t type;
    250269        int retval = async_req_1_1(phone, DEVMAP_HANDLE_PROBE, handle, &type);
    251270        if (retval != EOK)
    … …  
    260279       
    261280        if (flags & IPC_FLAG_BLOCKING) {
    262                 phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
     281                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
    263282                    DEVMAP_CONNECT_TO_DEVICE, handle);
    264283        } else {
    265                 phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
     284                phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
    266285                    DEVMAP_CONNECT_TO_DEVICE, handle);
    267286        }
    … …  
    277296                return -1;
    278297       
    279         ipcarg_t null_id;
     298        sysarg_t null_id;
    280299        int retval = async_req_0_1(phone, DEVMAP_NULL_CREATE, &null_id);
    281300        if (retval != EOK)
    … …  
    292311                return;
    293312       
    294         async_req_1_0(phone, DEVMAP_NULL_DESTROY, (ipcarg_t) null_id);
     313        async_req_1_0(phone, DEVMAP_NULL_DESTROY, (sysarg_t) null_id);
    295314}
    296315
    297316static size_t devmap_count_namespaces_internal(int phone)
    298317{
    299         ipcarg_t count;
     318        sysarg_t count;
    300319        int retval = async_req_0_1(phone, DEVMAP_GET_NAMESPACE_COUNT, &count);
    301320        if (retval != EOK)
    … …  
    307326static size_t devmap_count_devices_internal(int phone, devmap_handle_t ns_handle)
    308327{
    309         ipcarg_t count;
     328        sysarg_t count;
    310329        int retval = async_req_1_1(phone, DEVMAP_GET_DEVICE_COUNT, ns_handle, &count);
    311330        if (retval != EOK)
    … …  
    375394                }
    376395               
    377                 ipcarg_t retval;
     396                sysarg_t retval;
    378397                async_wait_for(req, &retval);
    379398                async_serialize_end();
    … …  
    427446                }
    428447               
    429                 ipcarg_t retval;
     448                sysarg_t retval;
    430449                async_wait_for(req, &retval);
    431450                async_serialize_end();

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

    rcead2aa r357b5f5  
    4949 * @return Value returned by the kernel.
    5050 */
    51 int event_subscribe(event_type_t e, ipcarg_t method)
     51int event_subscribe(event_type_t e, sysarg_t method)
    5252{
    5353        return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) e, (sysarg_t) method);

  • uspace/lib/c/generic/fibril.c

    rcead2aa r357b5f5  
    361361}
    362362
     363int fibril_get_sercount(void)
     364{
     365        return serialization_count;
     366}
     367
    363368/** @}
    364369 */

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

    rcead2aa r357b5f5  
    104104        fibril_t *f = (fibril_t *) fibril_get_id();
    105105
     106        if (fibril_get_sercount() != 0)
     107                core();
     108
    106109        futex_down(&async_futex);
    107110        if (fm->counter-- <= 0) {
    … …  
    139142static void _fibril_mutex_unlock_unsafe(fibril_mutex_t *fm)
    140143{
    141         assert(fm->counter <= 0);
    142144        if (fm->counter++ < 0) {
    143145                link_t *tmp;
    … …  
    165167void fibril_mutex_unlock(fibril_mutex_t *fm)
    166168{
     169        assert(fibril_mutex_is_locked(fm));
    167170        futex_down(&async_futex);
    168171        _fibril_mutex_unlock_unsafe(fm);
    169172        futex_up(&async_futex);
     173}
     174
     175bool fibril_mutex_is_locked(fibril_mutex_t *fm)
     176{
     177        bool locked = false;
     178       
     179        futex_down(&async_futex);
     180        if (fm->counter <= 0)
     181                locked = true;
     182        futex_up(&async_futex);
     183       
     184        return locked;
    170185}
    171186
    … …  
    182197        fibril_t *f = (fibril_t *) fibril_get_id();
    183198       
     199        if (fibril_get_sercount() != 0)
     200                core();
     201
    184202        futex_down(&async_futex);
    185203        if (frw->writers) {
    … …  
    207225        fibril_t *f = (fibril_t *) fibril_get_id();
    208226       
     227        if (fibril_get_sercount() != 0)
     228                core();
     229
    209230        futex_down(&async_futex);
    210231        if (frw->writers || frw->readers) {
    … …  
    230251{
    231252        futex_down(&async_futex);
    232         assert(frw->readers || (frw->writers == 1));
    233253        if (frw->readers) {
    234254                if (--frw->readers) {
    … …  
    296316void fibril_rwlock_read_unlock(fibril_rwlock_t *frw)
    297317{
     318        assert(fibril_rwlock_is_read_locked(frw));
    298319        _fibril_rwlock_common_unlock(frw);
    299320}
    … …  
    301322void fibril_rwlock_write_unlock(fibril_rwlock_t *frw)
    302323{
     324        assert(fibril_rwlock_is_write_locked(frw));
    303325        _fibril_rwlock_common_unlock(frw);
     326}
     327
     328bool fibril_rwlock_is_read_locked(fibril_rwlock_t *frw)
     329{
     330        bool locked = false;
     331
     332        futex_down(&async_futex);
     333        if (frw->readers)
     334                locked = true;
     335        futex_up(&async_futex);
     336
     337        return locked;
     338}
     339
     340bool fibril_rwlock_is_write_locked(fibril_rwlock_t *frw)
     341{
     342        bool locked = false;
     343
     344        futex_down(&async_futex);
     345        if (frw->writers) {
     346                assert(frw->writers == 1);
     347                locked = true;
     348        }
     349        futex_up(&async_futex);
     350
     351        return locked;
     352}
     353
     354bool fibril_rwlock_is_locked(fibril_rwlock_t *frw)
     355{
     356        return fibril_rwlock_is_read_locked(frw) ||
     357            fibril_rwlock_is_write_locked(frw);
    304358}
    305359
    … …  
    314368{
    315369        awaiter_t wdata;
     370
     371        assert(fibril_mutex_is_locked(fm));
    316372
    317373        if (timeout < 0)

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

    rcead2aa r357b5f5  
    4545}
    4646
    47 int console_get_size(int phone, ipcarg_t *cols, ipcarg_t *rows)
     47int console_get_size(int phone, sysarg_t *cols, sysarg_t *rows)
    4848{
    4949        return async_req_0_2(phone, CONSOLE_GET_SIZE, cols, rows);
    … …  
    7171}
    7272
    73 int console_get_color_cap(int phone, ipcarg_t *ccap)
     73int console_get_color_cap(int phone, sysarg_t *ccap)
    7474{
    7575        return async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, ccap);
    … …  
    8181}
    8282
    83 int console_get_pos(int phone, ipcarg_t *col, ipcarg_t *row)
     83int console_get_pos(int phone, sysarg_t *col, sysarg_t *row)
    8484{
    8585        return async_req_0_2(phone, CONSOLE_GET_POS, col, row);
    8686}
    8787
    88 void console_set_pos(int phone, ipcarg_t col, ipcarg_t row)
     88void console_set_pos(int phone, sysarg_t col, sysarg_t row)
    8989{
    9090        async_msg_2(phone, CONSOLE_GOTO, col, row);
    … …  
    9393bool console_get_event(int phone, console_event_t *event)
    9494{
    95         ipcarg_t type;
    96         ipcarg_t key;
    97         ipcarg_t mods;
    98         ipcarg_t c;
     95        sysarg_t type;
     96        sysarg_t key;
     97        sysarg_t mods;
     98        sysarg_t c;
    9999       
    100100        int rc = async_req_0_4(phone, CONSOLE_GET_EVENT, &type, &key, &mods, &c);

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

    rcead2aa r357b5f5  
    6767 *
    6868 */
    69 screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, ipcarg_t size_x,
    70     ipcarg_t size_y)
     69screenbuffer_t *screenbuffer_init(screenbuffer_t *scr, sysarg_t size_x,
     70    sysarg_t size_y)
    7171{
    7272        scr->buffer = (keyfield_t *) malloc(sizeof(keyfield_t) * size_x * size_y);
    … …  
    110110 *
    111111 */
    112 void screenbuffer_clear_line(screenbuffer_t *scr, ipcarg_t line)
     112void screenbuffer_clear_line(screenbuffer_t *scr, sysarg_t line)
    113113{
    114         ipcarg_t x;
     114        sysarg_t x;
    115115       
    116116        for (x = 0; x < scr->size_x; x++) {
    … …  
    141141 *
    142142 */
    143 void screenbuffer_goto(screenbuffer_t *scr, ipcarg_t x, ipcarg_t y)
     143void screenbuffer_goto(screenbuffer_t *scr, sysarg_t x, sysarg_t y)
    144144{
    145145        scr->position_x = x % scr->size_x;

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

    rcead2aa r357b5f5  
    3737#include <unistd.h>
    3838#include <io/printf_core.h>
    39 #include <futex.h>
     39#include <fibril_synch.h>
    4040#include <async.h>
    4141#include <str.h>
    4242
    43 static atomic_t printf_futex = FUTEX_INITIALIZER;
     43static FIBRIL_MUTEX_INITIALIZE(printf_mutex);
    4444
    4545static int vprintf_str_write(const char *str, size_t size, void *stream)
    … …  
    8585         * Prevent other threads to execute printf_core()
    8686         */
    87         futex_down(&printf_futex);
    88        
    89         /*
    90          * Prevent other fibrils of the same thread
    91          * to execute printf_core()
    92          */
    93         async_serialize_start();
     87        fibril_mutex_lock(&printf_mutex);
    9488       
    9589        int ret = printf_core(fmt, &ps, ap);
    9690       
    97         async_serialize_end();
    98         futex_up(&printf_futex);
     91        fibril_mutex_unlock(&printf_mutex);
    9992       
    10093        return ret;

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

    rcead2aa r357b5f5  
    3838 */
    3939/** @file
    40  */ 
     40 */
    4141
    4242#include <ipc/ipc.h>
    … …  
    104104 */
    105105int
    106 ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
    107     ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3,
    108     ipcarg_t *result4, ipcarg_t *result5)
     106ipc_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)
    109109{
    110110        ipc_call_t resdata;
    … …  
    131131/** Make a synchronous call transmitting 5 arguments of payload.
    132132 *
    133  * @param phoneid       Phone handle for the call.
    134  * @param method        Requested method.
    135  * @param arg1          Service-defined payload argument.
    136  * @param arg2          Service-defined payload argument.
    137  * @param arg3          Service-defined payload argument.
    138  * @param arg4          Service-defined payload argument.
    139  * @param arg5          Service-defined payload argument.
    140  * @param result1       If non-NULL, storage for the first return argument.
    141  * @param result2       If non-NULL, storage for the second return argument.
    142  * @param result3       If non-NULL, storage for the third return argument.
    143  * @param result4       If non-NULL, storage for the fourth return argument.
    144  * @param result5       If non-NULL, storage for the fifth return argument.
    145  *
    146  * @return              Negative value means IPC error.
    147  *                      Otherwise the RETVAL of the answer.
     133 * @param phoneid Phone handle for the call.
     134 * @param imethod Requested interface and method.
     135 * @param arg1    Service-defined payload argument.
     136 * @param arg2    Service-defined payload argument.
     137 * @param arg3    Service-defined payload argument.
     138 * @param arg4    Service-defined payload argument.
     139 * @param arg5    Service-defined payload argument.
     140 * @param result1 If non-NULL, storage for the first return argument.
     141 * @param result2 If non-NULL, storage for the second return argument.
     142 * @param result3 If non-NULL, storage for the third return argument.
     143 * @param result4 If non-NULL, storage for the fourth return argument.
     144 * @param result5 If non-NULL, storage for the fifth return argument.
     145 *
     146 * @return Negative value means IPC error.
     147 *         Otherwise the RETVAL of the answer.
     148 *
    148149 */
    149150int
    150 ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
    151     ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *result1,
    152     ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5)
     151ipc_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)
    153154{
    154155        ipc_call_t data;
    155         int callres;
    156 
    157         IPC_SET_METHOD(data, method);
     156       
     157        IPC_SET_IMETHOD(data, imethod);
    158158        IPC_SET_ARG1(data, arg1);
    159159        IPC_SET_ARG2(data, arg2);
    … …  
    161161        IPC_SET_ARG4(data, arg4);
    162162        IPC_SET_ARG5(data, arg5);
    163 
    164         callres = __SYSCALL3(SYS_IPC_CALL_SYNC_SLOW, phoneid, (sysarg_t) &data,
    165             (sysarg_t) &data);
     163       
     164        int callres = __SYSCALL3(SYS_IPC_CALL_SYNC_SLOW, phoneid,
     165            (sysarg_t) &data, (sysarg_t) &data);
    166166        if (callres)
    167167                return callres;
    168 
     168       
    169169        if (result1)
    170170                *result1 = IPC_GET_ARG1(data);
    … …  
    177177        if (result5)
    178178                *result5 = IPC_GET_ARG5(data);
    179 
     179       
    180180        return IPC_GET_RETVAL(data);
    181181}
    … …  
    183183/** Syscall to send asynchronous message.
    184184 *
    185  * @param phoneid       Phone handle for the call.
    186  * @param data          Call data with the request.
    187  *
    188  * @return              Hash of the call or an error code.
     185 * @param phoneid Phone handle for the call.
     186 * @param data    Call data with the request.
     187 *
     188 * @return Hash of the call or an error code.
     189 *
    189190 */
    190191static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
    … …  
    277278 * If the call cannot be temporarily made, queue it.
    278279 *
    279  * @param phoneid       Phone handle for the call.
    280  * @param method        Requested method.
    281  * @param arg1          Service-defined payload argument.
    282  * @param arg2          Service-defined payload argument.
    283  * @param arg3          Service-defined payload argument.
    284  * @param arg4          Service-defined payload argument.
    285  * @param private       Argument to be passed to the answer/error callback.
    286  * @param callback      Answer or error callback.
    287  * @param can_preempt   If non-zero, the current fibril will be preempted in
    288  *                      case the kernel temporarily refuses to accept more
    289  *                      asynchronous calls.
    290  */
    291 void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    292     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, void *private,
     280 * @param phoneid     Phone handle for the call.
     281 * @param imethod     Requested interface and method.
     282 * @param arg1        Service-defined payload argument.
     283 * @param arg2        Service-defined payload argument.
     284 * @param arg3        Service-defined payload argument.
     285 * @param arg4        Service-defined payload argument.
     286 * @param private     Argument to be passed to the answer/error callback.
     287 * @param callback    Answer or error callback.
     288 * @param can_preempt If non-zero, the current fibril will be preempted in
     289 *                    case the kernel temporarily refuses to accept more
     290 *                    asynchronous calls.
     291 *
     292 */
     293void ipc_call_async_fast(int phoneid, sysarg_t imethod, sysarg_t arg1,
     294    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, void *private,
    293295    ipc_async_callback_t callback, int can_preempt)
    294296{
    295297        async_call_t *call = NULL;
    296         ipc_callid_t callid;
    297 
     298       
    298299        if (callback) {
    299300                call = ipc_prepare_async(private, callback);
    … …  
    301302                        return;
    302303        }
    303 
     304       
    304305        /*
    305306         * We need to make sure that we get callid before another thread
    … …  
    307308         */
    308309        futex_down(&ipc_futex);
    309         callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1,
    310             arg2, arg3, arg4);
    311 
     310        ipc_callid_t callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid,
     311            imethod, arg1, arg2, arg3, arg4);
     312       
    312313        if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
    313314                if (!call) {
    … …  
    316317                                return;
    317318                }
    318                 IPC_SET_METHOD(call->u.msg.data, method);
     319                IPC_SET_IMETHOD(call->u.msg.data, imethod);
    319320                IPC_SET_ARG1(call->u.msg.data, arg1);
    320321                IPC_SET_ARG2(call->u.msg.data, arg2);
    … …  
    337338 * If the call cannot be temporarily made, queue it.
    338339 *
    339  * @param phoneid       Phone handle for the call.
    340  * @param method        Requested method.
    341  * @param arg1          Service-defined payload argument.
    342  * @param arg2          Service-defined payload argument.
    343  * @param arg3          Service-defined payload argument.
    344  * @param arg4          Service-defined payload argument.
    345  * @param arg5          Service-defined payload argument.
    346  * @param private       Argument to be passed to the answer/error callback.
    347  * @param callback      Answer or error callback.
    348  * @param can_preempt   If non-zero, the current fibril will be preempted in
    349  *                      case the kernel temporarily refuses to accept more
    350  *                      asynchronous calls.
    351  *
    352  */
    353 void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
    354     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private,
     340 * @param phoneid     Phone handle for the call.
     341 * @param imethod     Requested interface and method.
     342 * @param arg1        Service-defined payload argument.
     343 * @param arg2        Service-defined payload argument.
     344 * @param arg3        Service-defined payload argument.
     345 * @param arg4        Service-defined payload argument.
     346 * @param arg5        Service-defined payload argument.
     347 * @param private     Argument to be passed to the answer/error callback.
     348 * @param callback    Answer or error callback.
     349 * @param can_preempt If non-zero, the current fibril will be preempted in
     350 *                    case the kernel temporarily refuses to accept more
     351 *                    asynchronous calls.
     352 *
     353 */
     354void ipc_call_async_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
     355    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, void *private,
    355356    ipc_async_callback_t callback, int can_preempt)
    356357{
    … …  
    362363                return;
    363364
    364         IPC_SET_METHOD(call->u.msg.data, method);
     365        IPC_SET_IMETHOD(call->u.msg.data, imethod);
    365366        IPC_SET_ARG1(call->u.msg.data, arg1);
    366367        IPC_SET_ARG2(call->u.msg.data, arg2);
    … …  
    393394 * @return              Zero on success or a value from @ref errno.h on failure.
    394395 */
    395 ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
    396     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4)
     396sysarg_t ipc_answer_fast(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     397    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    397398{
    398399        return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3,
    … …  
    412413 * @return              Zero on success or a value from @ref errno.h on failure.
    413414 */
    414 ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
    415     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5)
     415sysarg_t ipc_answer_slow(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
     416    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
    416417{
    417418        ipc_call_t data;
    … …  
    585586 */
    586587int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
    587     ipcarg_t *phonehash)
     588    sysarg_t *phonehash)
    588589{
    589590        return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
    … …  
    602603int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3)
    603604{
    604         ipcarg_t newphid;
     605        sysarg_t newphid;
    605606        int res;
    606607
    … …  
    626627int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3)
    627628{
    628         ipcarg_t newphid;
     629        sysarg_t newphid;
    629630        int res;
    630631
    … …  
    676677/** Forward a received call to another destination.
    677678 *
    678  * @param callid        Hash of the call to forward.
    679  * @param phoneid       Phone handle to use for forwarding.
    680  * @param method        New method for the forwarded call.
    681  * @param arg1          New value of the first argument for the forwarded call.
    682  * @param arg2          New value of the second argument for the forwarded call.
    683  * @param mode          Flags specifying mode of the forward operation.
    684  *
    685  * @return              Zero on success or an error code.
     679 * @param callid  Hash of the call to forward.
     680 * @param phoneid Phone handle to use for forwarding.
     681 * @param imethod New interface and method for the forwarded call.
     682 * @param arg1    New value of the first argument for the forwarded call.
     683 * @param arg2    New value of the second argument for the forwarded call.
     684 * @param mode    Flags specifying mode of the forward operation.
     685 *
     686 * @return Zero on success or an error code.
    686687 *
    687688 * For non-system methods, the old method, arg1 and arg2 are rewritten by the
    … …  
    690691 * methods are forwarded verbatim.
    691692 */
    692 int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method,
    693     ipcarg_t arg1, ipcarg_t arg2, int mode)
    694 {
    695         return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1,
     693int ipc_forward_fast(ipc_callid_t callid, int phoneid, int imethod,
     694    sysarg_t arg1, sysarg_t arg2, int mode)
     695{
     696        return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, imethod, arg1,
    696697            arg2, mode);
    697698}
    698699
    699700
    700 int ipc_forward_slow(ipc_callid_t callid, int phoneid, int method,
    701     ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
     701int ipc_forward_slow(ipc_callid_t callid, int phoneid, int imethod,
     702    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    702703    int mode)
    703704{
    704705        ipc_call_t data;
    705 
    706         IPC_SET_METHOD(data, method);
     706       
     707        IPC_SET_IMETHOD(data, imethod);
    707708        IPC_SET_ARG1(data, arg1);
    708709        IPC_SET_ARG2(data, arg2);
    … …  
    710711        IPC_SET_ARG4(data, arg4);
    711712        IPC_SET_ARG5(data, arg5);
    712 
     713       
    713714        return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, mode);
    714715}
    … …  
    725726 * @return              Zero on success or a negative error code from errno.h.
    726727 */
    727 int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
     728int ipc_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
    728729    int *flags)
    729730{
    730731        sysarg_t tmp_flags = 0;
    731         int res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
    732             (ipcarg_t) size, arg, NULL, &tmp_flags);
     732        int res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
     733            (sysarg_t) size, arg, NULL, &tmp_flags);
    733734       
    734735        if (flags)
    … …  
    751752int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags)
    752753{
    753         return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) flags);
     754        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) flags);
    754755}
    755756
    … …  
    764765int ipc_share_out_start(int phoneid, void *src, int flags)
    765766{
    766         return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
    767             (ipcarg_t) flags);
     767        return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
     768            (sysarg_t) flags);
    768769}
    769770
    … …  
    780781int ipc_share_out_finalize(ipc_callid_t callid, void *dst)
    781782{
    782         return ipc_answer_1(callid, EOK, (ipcarg_t) dst);
     783        return ipc_answer_1(callid, EOK, (sysarg_t) dst);
    783784}
    784785
    … …  
    794795int ipc_data_read_start(int phoneid, void *dst, size_t size)
    795796{
    796         return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
    797             (ipcarg_t) size);
     797        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
     798            (sysarg_t) size);
    798799}
    799800
    … …  
    812813int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
    813814{
    814         return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size);
     815        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
    815816}
    816817
    … …  
    825826int ipc_data_write_start(int phoneid, const void *src, size_t size)
    826827{
    827         return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
    828             (ipcarg_t) size);
     828        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
     829            (sysarg_t) size);
    829830}
    830831
    … …  
    842843int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
    843844{
    844         return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size);
    845 }
    846 
    847 #include <kernel/syscall/sysarg64.h>
     845        return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
     846}
     847
    848848/** Connect to a task specified by id.
     849 *
    849850 */
    850851int ipc_connect_kbox(task_id_t id)
    851852{
    852         sysarg64_t arg;
    853 
    854         arg.value = (unsigned long long) id;
    855 
     853#ifdef __32_BITS__
     854        sysarg64_t arg = (sysarg64_t) id;
    856855        return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg);
    857 }
    858  
     856#endif
     857       
     858#ifdef __64_BITS__
     859        return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) id);
     860#endif
     861}
     862
    859863/** @}
    860864 */

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

    rcead2aa r357b5f5  
    5050#include <ipc/ipc.h>
    5151#include <async.h>
    52 #include <async_rel.h>
    5352#include <as.h>
    5453#include <loader/pcb.h>
    … …  
    6665        __heap_init();
    6766        __async_init();
    68         (void) async_rel_init();
    6967        fibril_t *fibril = fibril_setup();
    7068        __tcb_set(fibril->tcb);

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

    rcead2aa r357b5f5  
    9696        }
    9797       
    98         ipcarg_t retval;
     98        sysarg_t retval;
    9999        async_wait_for(req, &retval);
    100100        return (int) retval;
    … …  
    131131        }
    132132       
    133         ipcarg_t retval;
     133        sysarg_t retval;
    134134        async_wait_for(req, &retval);
    135135        return (int) retval;
    … …  
    166166        free(pa);
    167167       
    168         ipcarg_t retval;
     168        sysarg_t retval;
    169169        async_wait_for(req, &retval);
    170170        return (int) retval;
    … …  
    213213        ipc_call_t answer;
    214214        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
    215         ipcarg_t rc = async_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
     215        sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
    216216        if (rc != EOK) {
    217217                async_wait_for(req, NULL);
    … …  
    267267        ipc_call_t answer;
    268268        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer);
    269         ipcarg_t rc = async_data_write_start(ldr->phone_id, (void *) files_buf,
     269        sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) files_buf,
    270270            count * sizeof(fdi_node_t));
    271271        if (rc != EOK) {

  • uspace/lib/c/generic/mem.c

    rcead2aa r357b5f5  
    222222/** Compare two memory areas.
    223223 *
    224  * @param s1            Pointer to the first area to compare.
    225  * @param s2            Pointer to the second area to compare.
    226  * @param len           Size of the first area in bytes. Both areas must have
    227  *                      the same length.
    228  * @return              If len is 0, return zero. If the areas match, return
    229  *                      zero. Otherwise return non-zero.
    230  */
    231 int bcmp(const char *s1, const char *s2, size_t len)
    232 {
    233         for (; len && *s1++ == *s2++; len--)
    234                 ;
     224 * @param s1  Pointer to the first area to compare.
     225 * @param s2  Pointer to the second area to compare.
     226 * @param len Size of the first area in bytes. Both areas must have
     227 *            the same length.
     228 *
     229 * @return If len is 0, return zero. If the areas match, return
     230 *         zero. Otherwise return non-zero.
     231 *
     232 */
     233int bcmp(const void *s1, const void *s2, size_t len)
     234{
     235        uint8_t *u1 = (uint8_t *) s1;
     236        uint8_t *u2 = (uint8_t *) s2;
     237       
     238        for (; (len != 0) && (*u1++ == *u2++); len--);
     239       
    235240        return len;
    236241}

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

    rcead2aa r357b5f5  
    8181{
    8282        aid_t message_id;
    83         ipcarg_t result;
     83        sysarg_t result;
    8484
    8585        if (addrlen <= 0)
    … …  
    8787
    8888        message_id = async_send_5(icmp_phone, NET_ICMP_ECHO, size, timeout, ttl,
    89             tos, (ipcarg_t) dont_fragment, NULL);
     89            tos, (sysarg_t) dont_fragment, NULL);
    9090
    91         // send the address
     91        /* Send the address */
    9292        async_data_write_start(icmp_phone, addr, (size_t) addrlen);
    9393

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

    rcead2aa r357b5f5  
    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/inet.c

    rcead2aa r357b5f5  
    6464        switch (family) {
    6565        case AF_INET:
    66                 // check the output buffer size
     66                /* Check output buffer size */
    6767                if (length < INET_ADDRSTRLEN)
    6868                        return ENOMEM;
    6969                       
    70                 // fill the buffer with the IPv4 address
     70                /* Fill buffer with IPv4 address */
    7171                snprintf(address, length, "%hhu.%hhu.%hhu.%hhu",
    7272                    data[0], data[1], data[2], data[3]);
    … …  
    7575
    7676        case AF_INET6:
    77                 // check the output buffer size
     77                /* Check output buffer size */
    7878                if (length < INET6_ADDRSTRLEN)
    7979                        return ENOMEM;
    8080               
    81                 // fill the buffer with the IPv6 address
     81                /* Fill buffer with IPv6 address */
    8282                snprintf(address, length,
    8383                    "%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:"
    … …  
    124124                return EINVAL;
    125125
    126         // set the processing parameters
     126        /* Set processing parameters */
    127127        switch (family) {
    128128        case AF_INET:
    … …  
    142142        }
    143143
    144         // erase if no address
     144        /* Erase if no address */
    145145        if (!address) {
    146146                bzero(data, count);
    … …  
    148148        }
    149149
    150         // process the string from the beginning
     150        /* Process string from the beginning */
    151151        next = address;
    152152        index = 0;
    153153        do {
    154                 // if the actual character is set
     154                /* If the actual character is set */
    155155                if (next && *next) {
    156156
    157                         // if not on the first character
     157                        /* If not on the first character */
    158158                        if (index) {
    159                                 // move to the next character
     159                                /* Move to the next character */
    160160                                ++next;
    161161                        }
    162162
    163                         // parse the actual integral value
     163                        /* Parse the actual integral value */
    164164                        value = strtoul(next, &last, base);
    165                         // remember the last problematic character
    166                         // should be either '.' or ':' but is ignored to be more
    167                         // generic
     165                        /*
     166                         * Remember the last problematic character
     167                         * should be either '.' or ':' but is ignored to be
     168                         * more generic
     169                         */
    168170                        next = last;
    169171
    170                         // fill the address data byte by byte
     172                        /* Fill the address data byte by byte */
    171173                        shift = bytes - 1;
    172174                        do {
    173                                 // like little endian
     175                                /* like little endian */
    174176                                data[index + shift] = value;
    175177                                value >>= 8;
    … …  
    178180                        index += bytes;
    179181                } else {
    180                         // erase the rest of the address
     182                        /* Erase the rest of the address */
    181183                        bzero(data + index, count - index);
    182184                        return EOK;

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

    rcead2aa r357b5f5  
    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
    … …  
    5252#define MODULE_WAIT_TIME        (10 * 1000)
    5353
    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) {
     54/** Answer a call.
     55 *
     56 * @param[in] callid Call identifier.
     57 * @param[in] result Message processing result.
     58 * @param[in] answer Message processing answer.
     59 * @param[in] count  Number of answer parameters.
     60 *
     61 */
     62void answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
     63    size_t count)
     64{
     65        /* Choose the most efficient function */
     66        if ((answer != NULL) || (count == 0)) {
     67                switch (count) {
    6868                case 0:
    69                         ipc_answer_0(callid, (ipcarg_t) result);
     69                        ipc_answer_0(callid, (sysarg_t) result);
    7070                        break;
    7171                case 1:
    72                         ipc_answer_1(callid, (ipcarg_t) result,
     72                        ipc_answer_1(callid, (sysarg_t) result,
    7373                            IPC_GET_ARG1(*answer));
    7474                        break;
    7575                case 2:
    76                         ipc_answer_2(callid, (ipcarg_t) result,
     76                        ipc_answer_2(callid, (sysarg_t) result,
    7777                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer));
    7878                        break;
    7979                case 3:
    80                         ipc_answer_3(callid, (ipcarg_t) result,
     80                        ipc_answer_3(callid, (sysarg_t) result,
    8181                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    8282                            IPC_GET_ARG3(*answer));
    8383                        break;
    8484                case 4:
    85                         ipc_answer_4(callid, (ipcarg_t) result,
     85                        ipc_answer_4(callid, (sysarg_t) result,
    8686                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    8787                            IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer));
    … …  
    8989                case 5:
    9090                default:
    91                         ipc_answer_5(callid, (ipcarg_t) result,
     91                        ipc_answer_5(callid, (sysarg_t) result,
    9292                            IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
    9393                            IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer),
    … …  
    111111 *                      function.
    112112 */
    113 int bind_service(services_t need, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3,
     113int bind_service(services_t need, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
    114114    async_client_conn_t client_receiver)
    115115{
    … …  
    134134 *
    135135 */
    136 int bind_service_timeout(services_t need, ipcarg_t arg1, ipcarg_t arg2,
    137     ipcarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
     136int bind_service_timeout(services_t need, sysarg_t arg1, sysarg_t arg2,
     137    sysarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
    138138{
    139139        int rc;
    … …  
    143143        if (phone >= 0) {
    144144                /* Request the bidirectional connection */
    145                 ipcarg_t phonehash;
     145                sysarg_t phonehash;
    146146               
    147147                rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &phonehash);
    … …  
    178178        int phone;
    179179
    180         // if no timeout is set
     180        /* If no timeout is set */
    181181        if (timeout <= 0)
    182182                return async_connect_me_to_blocking(PHONE_NS, need, 0, 0);
    … …  
    187187                        return phone;
    188188
    189                 // end if no time is left
     189                /* Abort if no time is left */
    190190                if (timeout <= 0)
    191191                        return ETIMEOUT;
    192192
    193                 // wait the minimum of the module wait time and the timeout
     193                /* Wait the minimum of the module wait time and the timeout */
    194194                usleep((timeout <= MODULE_WAIT_TIME) ?
    195195                    timeout : MODULE_WAIT_TIME);
    196196                timeout -= MODULE_WAIT_TIME;
    197197        }
    198 }
    199 
    200 /** Receives data from the other party.
    201  *
    202  * The received data buffer is allocated and returned.
    203  *
    204  * @param[out] data     The data buffer to be filled.
    205  * @param[out] length   The buffer length.
    206  * @return              EOK on success.
    207  * @return              EBADMEM if the data or the length parameter is NULL.
    208  * @return              EINVAL if the client does not send data.
    209  * @return              ENOMEM if there is not enough memory left.
    210  * @return              Other error codes as defined for the
    211  *                      async_data_write_finalize() function.
    212  */
    213 int data_receive(void **data, size_t *length)
    214 {
    215         ipc_callid_t callid;
    216         int rc;
    217 
    218         if (!data || !length)
    219                 return EBADMEM;
    220 
    221         // fetch the request
    222         if (!async_data_write_receive(&callid, length))
    223                 return EINVAL;
    224 
    225         // allocate the buffer
    226         *data = malloc(*length);
    227         if (!*data)
    228                 return ENOMEM;
    229 
    230         // fetch the data
    231         rc = async_data_write_finalize(callid, *data, *length);
    232         if (rc != EOK) {
    233                 free(data);
    234                 return rc;
    235         }
    236 
    237         return EOK;
    238198}
    239199
    … …  
    254214        ipc_callid_t callid;
    255215
    256         // fetch the request
     216        /* Fetch the request */
    257217        if (!async_data_read_receive(&callid, &length))
    258218                return EINVAL;
    259219
    260         // check the requested data size
     220        /* Check the requested data size */
    261221        if (length < data_length) {
    262222                async_data_read_finalize(callid, data, length);
    … …  
    264224        }
    265225
    266         // send the data
     226        /* Send the data */
    267227        return async_data_read_finalize(callid, data, data_length);
    268228}
    269229
    270 /** Refreshes answer structure and parameters count.
    271  *
    272  * Erases all attributes.
    273  *
    274  * @param[in,out] answer The message processing answer structure.
    275  * @param[in,out] answer_count The number of answer parameters.
    276  */
    277 void refresh_answer(ipc_call_t *answer, int *answer_count)
    278 {
    279         if (answer_count)
    280                 *answer_count = 0;
    281 
    282         if (answer) {
     230/** Refresh answer structure and argument count.
     231 *
     232 * Erase all arguments.
     233 *
     234 * @param[in,out] answer Message processing answer structure.
     235 * @param[in,out] count  Number of answer arguments.
     236 *
     237 */
     238void refresh_answer(ipc_call_t *answer, size_t *count)
     239{
     240        if (count != NULL)
     241                *count = 0;
     242       
     243        if (answer != NULL) {
    283244                IPC_SET_RETVAL(*answer, 0);
    284                 // just to be precize
    285                 IPC_SET_METHOD(*answer, 0);
     245                IPC_SET_IMETHOD(*answer, 0);
    286246                IPC_SET_ARG1(*answer, 0);
    287247                IPC_SET_ARG2(*answer, 0);

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

    rcead2aa r357b5f5  
    191191        }
    192192        gpm_destroy(&pm_globals.packet_map);
    193         // leave locked
     193        /* leave locked */
    194194}
    195195

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

    rcead2aa r357b5f5  
    214214        callid = async_get_call(&call);
    215215
    216         switch (IPC_GET_METHOD(call)) {
     216        switch (IPC_GET_IMETHOD(call)) {
    217217        case NET_SOCKET_RECEIVED:
    218218        case NET_SOCKET_ACCEPTED:
    … …  
    220220                fibril_rwlock_read_lock(&socket_globals.lock);
    221221
    222                 // find the socket
     222                /* Find the socket */
    223223                socket = sockets_find(socket_get_sockets(),
    224224                    SOCKET_GET_SOCKET_ID(call));
    … …  
    229229                }
    230230               
    231                 switch (IPC_GET_METHOD(call)) {
     231                switch (IPC_GET_IMETHOD(call)) {
    232232                case NET_SOCKET_RECEIVED:
    233233                        fibril_mutex_lock(&socket->receive_lock);
    234                         // push the number of received packet fragments
     234                        /* Push the number of received packet fragments */
    235235                        rc = dyn_fifo_push(&socket->received,
    236236                            SOCKET_GET_DATA_FRAGMENTS(call),
    237237                            SOCKET_MAX_RECEIVED_SIZE);
    238238                        if (rc == EOK) {
    239                                 // signal the received packet
     239                                /* Signal the received packet */
    240240                                fibril_condvar_signal(&socket->receive_signal);
    241241                        }
    … …  
    244244
    245245                case NET_SOCKET_ACCEPTED:
    246                         // push the new socket identifier
     246                        /* Push the new socket identifier */
    247247                        fibril_mutex_lock(&socket->accept_lock);
    248248                        rc = dyn_fifo_push(&socket->accepted, 1,
    249249                            SOCKET_MAX_ACCEPTED_SIZE);
    250250                        if (rc == EOK) {
    251                                 // signal the accepted socket
     251                                /* Signal the accepted socket */
    252252                                fibril_condvar_signal(&socket->accept_signal);
    253253                        }
    … …  
    264264                        fibril_rwlock_write_lock(&socket->sending_lock);
    265265
    266                         // set the data fragment size
     266                        /* Set the data fragment size */
    267267                        socket->data_fragment_size =
    268268                            SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    … …  
    278278        }
    279279
    280         ipc_answer_0(callid, (ipcarg_t) rc);
     280        ipc_answer_0(callid, (sysarg_t) rc);
    281281        goto loop;
    282282}
    … …  
    342342                        socket_id = 1;
    343343                        ++count;
    344                 // only this branch for last_id
     344                /* Only this branch for last_id */
    345345                } else {
    346346                        if (socket_id < INT_MAX) {
    … …  
    404404        int socket_id;
    405405        services_t service;
    406         ipcarg_t fragment_size;
    407         ipcarg_t header_size;
     406        sysarg_t fragment_size;
     407        sysarg_t header_size;
    408408        int rc;
    409409
    410         // find the appropriate service
     410        /* Find the appropriate service */
    411411        switch (domain) {
    412412        case PF_INET:
    … …  
    457457                return phone;
    458458
    459         // create a new socket structure
     459        /* Create a new socket structure */
    460460        socket = (socket_t *) malloc(sizeof(socket_t));
    461461        if (!socket)
    … …  
    465465        fibril_rwlock_write_lock(&socket_globals.lock);
    466466
    467         // request a new socket
     467        /* Request a new socket */
    468468        socket_id = socket_generate_new_id();
    469469        if (socket_id <= 0) {
    … …  
    484484        socket->header_size = (size_t) header_size;
    485485
    486         // finish the new socket initialization
     486        /* Finish the new socket initialization */
    487487        socket_initialize(socket, socket_id, phone, service);
    488         // store the new socket
     488        /* Store the new socket */
    489489        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    490490
    … …  
    494494                dyn_fifo_destroy(&socket->accepted);
    495495                free(socket);
    496                 async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0,
     496                async_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
    497497                    service);
    498498                return rc;
    … …  
    516516 */
    517517static int
    518 socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2,
     518socket_send_data(int socket_id, sysarg_t message, sysarg_t arg2,
    519519    const void *data, size_t datalength)
    520520{
    521521        socket_t *socket;
    522522        aid_t message_id;
    523         ipcarg_t result;
     523        sysarg_t result;
    524524
    525525        if (!data)
    … …  
    531531        fibril_rwlock_read_lock(&socket_globals.lock);
    532532
    533         // find the socket
     533        /* Find the socket */
    534534        socket = sockets_find(socket_get_sockets(), socket_id);
    535535        if (!socket) {
    … …  
    538538        }
    539539
    540         // request the message
     540        /* Request the message */
    541541        message_id = async_send_3(socket->phone, message,
    542             (ipcarg_t) socket->socket_id, arg2, socket->service, NULL);
    543         // send the address
     542            (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
     543        /* Send the address */
    544544        async_data_write_start(socket->phone, data, datalength);
    545545
    … …  
    566566                return EINVAL;
    567567
    568         // send the address
     568        /* Send the address */
    569569        return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr,
    570570            (size_t) addrlen);
    … …  
    591591        fibril_rwlock_read_lock(&socket_globals.lock);
    592592
    593         // find the socket
     593        /* Find the socket */
    594594        socket = sockets_find(socket_get_sockets(), socket_id);
    595595        if (!socket) {
    … …  
    598598        }
    599599
    600         // request listen backlog change
     600        /* Request listen backlog change */
    601601        result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN,
    602             (ipcarg_t) socket->socket_id, (ipcarg_t) backlog, socket->service);
     602            (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
    603603
    604604        fibril_rwlock_read_unlock(&socket_globals.lock);
    … …  
    625625        socket_t *new_socket;
    626626        aid_t message_id;
    627         ipcarg_t ipc_result;
     627        sysarg_t ipc_result;
    628628        int result;
    629629        ipc_call_t answer;
    … …  
    634634        fibril_rwlock_write_lock(&socket_globals.lock);
    635635
    636         // find the socket
     636        /* Find the socket */
    637637        socket = sockets_find(socket_get_sockets(), socket_id);
    638638        if (!socket) {
    … …  
    643643        fibril_mutex_lock(&socket->accept_lock);
    644644
    645         // wait for an accepted socket
     645        /* Wait for an accepted socket */
    646646        ++ socket->blocked;
    647647        while (dyn_fifo_value(&socket->accepted) <= 0) {
    648648                fibril_rwlock_write_unlock(&socket_globals.lock);
    649649                fibril_condvar_wait(&socket->accept_signal, &socket->accept_lock);
    650                 // drop the accept lock to avoid deadlock
     650                /* Drop the accept lock to avoid deadlock */
    651651                fibril_mutex_unlock(&socket->accept_lock);
    652652                fibril_rwlock_write_lock(&socket_globals.lock);
    … …  
    655655        -- socket->blocked;
    656656
    657         // create a new scoket
     657        /* Create a new socket */
    658658        new_socket = (socket_t *) malloc(sizeof(socket_t));
    659659        if (!new_socket) {
    … …  
    681681        }
    682682
    683         // request accept
     683        /* Request accept */
    684684        message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT,
    685             (ipcarg_t) socket->socket_id, 0, socket->service, 0,
     685            (sysarg_t) socket->socket_id, 0, socket->service, 0,
    686686            new_socket->socket_id, &answer);
    687687
    688         // read address
     688        /* Read address */
    689689        ipc_data_read_start(socket->phone, cliaddr, *addrlen);
    690690        fibril_rwlock_write_unlock(&socket_globals.lock);
    … …  
    695695                        result = EINVAL;
    696696
    697                 // dequeue the accepted socket if successful
     697                /* Dequeue the accepted socket if successful */
    698698                dyn_fifo_pop(&socket->accepted);
    699                 // set address length
     699                /* Set address length */
    700700                *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    701701                new_socket->data_fragment_size =
    702702                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    703703        } else if (result == ENOTSOCK) {
    704                 // empty the queue if no accepted sockets
     704                /* Empty the queue if no accepted sockets */
    705705                while (dyn_fifo_pop(&socket->accepted) > 0)
    706706                        ;
    … …  
    731731                return EDESTADDRREQ;
    732732
    733         // send the address
     733        /* Send the address */
    734734        return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr,
    735735            addrlen);
    … …  
    744744        int accepted_id;
    745745
    746         // destroy all accepted sockets
     746        /* Destroy all accepted sockets */
    747747        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    748748                socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
    … …  
    780780        }
    781781
    782         // request close
     782        /* Request close */
    783783        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
    784             (ipcarg_t) socket->socket_id, 0, socket->service);
     784            (sysarg_t) socket->socket_id, 0, socket->service);
    785785        if (rc != EOK) {
    786786                fibril_rwlock_write_unlock(&socket_globals.lock);
    787787                return rc;
    788788        }
    789         // free the socket structure
     789        /* Free the socket structure */
    790790        socket_destroy(socket);
    791791
    … …  
    815815 */
    816816static int
    817 sendto_core(ipcarg_t message, int socket_id, const void *data,
     817sendto_core(sysarg_t message, int socket_id, const void *data,
    818818    size_t datalength, int flags, const struct sockaddr *toaddr,
    819819    socklen_t addrlen)
    … …  
    821821        socket_t *socket;
    822822        aid_t message_id;
    823         ipcarg_t result;
     823        sysarg_t result;
    824824        size_t fragments;
    825825        ipc_call_t answer;
    … …  
    833833        fibril_rwlock_read_lock(&socket_globals.lock);
    834834
    835         // find socket
     835        /* Find socket */
    836836        socket = sockets_find(socket_get_sockets(), socket_id);
    837837        if (!socket) {
    … …  
    842842        fibril_rwlock_read_lock(&socket->sending_lock);
    843843
    844         // compute data fragment count
     844        /* Compute data fragment count */
    845845        if (socket->data_fragment_size > 0) {
    846846                fragments = (datalength + socket->header_size) /
    … …  
    853853        }
    854854
    855         // request send
     855        /* Request send */
    856856        message_id = async_send_5(socket->phone, message,
    857             (ipcarg_t) socket->socket_id,
     857            (sysarg_t) socket->socket_id,
    858858            (fragments == 1 ? datalength : socket->data_fragment_size),
    859             socket->service, (ipcarg_t) flags, fragments, &answer);
    860 
    861         // send the address if given
     859            socket->service, (sysarg_t) flags, fragments, &answer);
     860
     861        /* Send the address if given */
    862862        if (!toaddr ||
    863863            (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
    864864                if (fragments == 1) {
    865                         // send all if only one fragment
     865                        /* Send all if only one fragment */
    866866                        async_data_write_start(socket->phone, data, datalength);
    867867                } else {
    868                         // send the first fragment
     868                        /* Send the first fragment */
    869869                        async_data_write_start(socket->phone, data,
    870870                            socket->data_fragment_size - socket->header_size);
    … …  
    872872                            socket->data_fragment_size - socket->header_size;
    873873       
    874                         // send the middle fragments
     874                        /* Send the middle fragments */
    875875                        while (--fragments > 1) {
    876876                                async_data_write_start(socket->phone, data,
    … …  
    880880                        }
    881881
    882                         // send the last fragment
     882                        /* Send the last fragment */
    883883                        async_data_write_start(socket->phone, data,
    884884                            (datalength + socket->header_size) %
    … …  
    892892            (SOCKET_GET_DATA_FRAGMENT_SIZE(answer) !=
    893893            socket->data_fragment_size)) {
    894                 // set the data fragment size
     894                /* Set the data fragment size */
    895895                socket->data_fragment_size =
    896896                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    … …  
    917917int send(int socket_id, void *data, size_t datalength, int flags)
    918918{
    919         // without the address
     919        /* Without the address */
    920920        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags,
    921921            NULL, 0);
    … …  
    950950                return EDESTADDRREQ;
    951951
    952         // with the address
     952        /* With the address */
    953953        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength,
    954954            flags, toaddr, addrlen);
    … …  
    966966 *                      read. The actual address length is set. Used only if
    967967 *                      fromaddr is not NULL.
    968  * @return              EOK on success.
     968 * @return              Positive received message size in bytes on success.
     969 * @return              Zero if no more data (other side closed the connection).
    969970 * @return              ENOTSOCK if the socket is not found.
    970971 * @return              EBADMEM if the data parameter is NULL.
    … …  
    972973 * @return              Other error codes as defined for the spcific message.
    973974 */
    974 static int
    975 recvfrom_core(ipcarg_t message, int socket_id, void *data, size_t datalength,
     975static ssize_t
     976recvfrom_core(sysarg_t message, int socket_id, void *data, size_t datalength,
    976977    int flags, struct sockaddr *fromaddr, socklen_t *addrlen)
    977978{
    978979        socket_t *socket;
    979980        aid_t message_id;
    980         ipcarg_t ipc_result;
     981        sysarg_t ipc_result;
    981982        int result;
    982983        size_t fragments;
    … …  
    984985        size_t index;
    985986        ipc_call_t answer;
     987        ssize_t retval;
    986988
    987989        if (!data)
    … …  
    996998        fibril_rwlock_read_lock(&socket_globals.lock);
    997999
    998         // find the socket
     1000        /* Find the socket */
    9991001        socket = sockets_find(socket_get_sockets(), socket_id);
    10001002        if (!socket) {
    … …  
    10041006
    10051007        fibril_mutex_lock(&socket->receive_lock);
    1006         // wait for a received packet
     1008        /* Wait for a received packet */
    10071009        ++socket->blocked;
    1008         while ((result = dyn_fifo_value(&socket->received)) <= 0) {
     1010        while ((result = dyn_fifo_value(&socket->received)) < 0) {
    10091011                fibril_rwlock_read_unlock(&socket_globals.lock);
    10101012                fibril_condvar_wait(&socket->receive_signal,
    10111013                    &socket->receive_lock);
    10121014
    1013                 // drop the receive lock to avoid deadlock
     1015                /* Drop the receive lock to avoid deadlock */
    10141016                fibril_mutex_unlock(&socket->receive_lock);
    10151017                fibril_rwlock_read_lock(&socket_globals.lock);
    … …  
    10191021        fragments = (size_t) result;
    10201022
    1021         // prepare lengths if more fragments
     1023        if (fragments == 0) {
     1024                /* No more data, other side has closed the connection. */
     1025                fibril_mutex_unlock(&socket->receive_lock);
     1026                fibril_rwlock_read_unlock(&socket_globals.lock);
     1027                return 0;
     1028        }
     1029
     1030        /* Prepare lengths if more fragments */
    10221031        if (fragments > 1) {
    10231032                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    … …  
    10291038                }
    10301039
    1031                 // request packet data
     1040                /* Request packet data */
    10321041                message_id = async_send_4(socket->phone, message,
    1033                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1034                     (ipcarg_t) flags, &answer);
    1035 
    1036                 // read the address if desired
     1042                    (sysarg_t) socket->socket_id, 0, socket->service,
     1043                    (sysarg_t) flags, &answer);
     1044
     1045                /* Read the address if desired */
    10371046                if(!fromaddr ||
    10381047                    (async_data_read_start(socket->phone, fromaddr,
    10391048                    *addrlen) == EOK)) {
    1040                         // read the fragment lengths
     1049                        /* Read the fragment lengths */
    10411050                        if (async_data_read_start(socket->phone, lengths,
    10421051                            sizeof(int) * (fragments + 1)) == EOK) {
    10431052                                if (lengths[fragments] <= datalength) {
    10441053
    1045                                         // read all fragments if long enough
     1054                                        /* Read all fragments if long enough */
    10461055                                        for (index = 0; index < fragments;
    10471056                                            ++index) {
    … …  
    10571066
    10581067                free(lengths);
    1059         } else {
    1060                 // request packet data
     1068        } else { /* fragments == 1 */
     1069                /* Request packet data */
    10611070                message_id = async_send_4(socket->phone, message,
    1062                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1063                     (ipcarg_t) flags, &answer);
    1064 
    1065                 // read the address if desired
     1071                    (sysarg_t) socket->socket_id, 0, socket->service,
     1072                    (sysarg_t) flags, &answer);
     1073
     1074                /* Read the address if desired */
    10661075                if (!fromaddr ||
    10671076                    (async_data_read_start(socket->phone, fromaddr,
    10681077                        *addrlen) == EOK)) {
    1069                         // read all if only one fragment
     1078                        /* Read all if only one fragment */
    10701079                        async_data_read_start(socket->phone, data, datalength);
    10711080                }
    … …  
    10751084        result = (int) ipc_result;
    10761085        if (result == EOK) {
    1077                 // dequeue the received packet
     1086                /* Dequeue the received packet */
    10781087                dyn_fifo_pop(&socket->received);
    1079                 // return read data length
    1080                 result = SOCKET_GET_READ_DATA_LENGTH(answer);
    1081                 // set address length
     1088                /* Return read data length */
     1089                retval = SOCKET_GET_READ_DATA_LENGTH(answer);
     1090                /* Set address length */
    10821091                if (fromaddr && addrlen)
    10831092                        *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
     1093        } else {
     1094                retval = (ssize_t) result;
    10841095        }
    10851096
    10861097        fibril_mutex_unlock(&socket->receive_lock);
    10871098        fibril_rwlock_read_unlock(&socket_globals.lock);
    1088         return result;
     1099        return retval;
    10891100}
    10901101
    … …  
    10951106 * @param[in] datalength The data length.
    10961107 * @param[in] flags     Various receive flags.
    1097  * @return              EOK on success.
     1108 * @return              Positive received message size in bytes on success.
     1109 * @return              Zero if no more data (other side closed the connection).
    10981110 * @return              ENOTSOCK if the socket is not found.
    10991111 * @return              EBADMEM if the data parameter is NULL.
    … …  
    11021114 *                      message.
    11031115 */
    1104 int recv(int socket_id, void *data, size_t datalength, int flags)
    1105 {
    1106         // without the address
     1116ssize_t recv(int socket_id, void *data, size_t datalength, int flags)
     1117{
     1118        /* Without the address */
    11071119        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength,
    11081120            flags, NULL, NULL);
    … …  
    11181130 * @param[in,out] addrlen The address length. The maximum address length is
    11191131 *                      read. The actual address length is set.
    1120  * @return              EOK on success.
     1132 * @return              Positive received message size in bytes on success.
     1133 * @return              Zero if no more data (other side closed the connection).
    11211134 * @return              ENOTSOCK if the socket is not found.
    11221135 * @return              EBADMEM if the data or fromaddr parameter is NULL.
    … …  
    11251138 *                      message.
    11261139 */
    1127 int
     1140ssize_t
    11281141recvfrom(int socket_id, void *data, size_t datalength, int flags,
    11291142    struct sockaddr *fromaddr, socklen_t *addrlen)
    … …  
    11351148                return NO_DATA;
    11361149
    1137         // with the address
     1150        /* With the address */
    11381151        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength,
    11391152            flags, fromaddr, addrlen);
    … …  
    11601173        socket_t *socket;
    11611174        aid_t message_id;
    1162         ipcarg_t result;
     1175        sysarg_t result;
    11631176
    11641177        if (!value || !optlen)
    … …  
    11701183        fibril_rwlock_read_lock(&socket_globals.lock);
    11711184
    1172         // find the socket
     1185        /* Find the socket */
    11731186        socket = sockets_find(socket_get_sockets(), socket_id);
    11741187        if (!socket) {
    … …  
    11771190        }
    11781191
    1179         // request option value
     1192        /* Request option value */
    11801193        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
    1181             (ipcarg_t) socket->socket_id, (ipcarg_t) optname, socket->service,
     1194            (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
    11821195            NULL);
    11831196
    1184         // read the length
     1197        /* Read the length */
    11851198        if (async_data_read_start(socket->phone, optlen,
    11861199            sizeof(*optlen)) == EOK) {
    1187                 // read the value
     1200                /* Read the value */
    11881201                async_data_read_start(socket->phone, value, *optlen);
    11891202        }
    … …  
    12121225    size_t optlen)
    12131226{
    1214         // send the value
     1227        /* Send the value */
    12151228        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT,
    1216             (ipcarg_t) optname, value, optlen);
     1229            (sysarg_t) optname, value, optlen);
    12171230}
    12181231

  • uspace/lib/c/generic/task.c

    rcead2aa r357b5f5  
    4747task_id_t task_get_id(void)
    4848{
     49#ifdef __32_BITS__
    4950        task_id_t task_id;
    5051        (void) __SYSCALL1(SYS_TASK_GET_ID, (sysarg_t) &task_id);
    5152       
    5253        return task_id;
     54#endif  /* __32_BITS__ */
     55       
     56#ifdef __64_BITS__
     57        return (task_id_t) __SYSCALL0(SYS_TASK_GET_ID);
     58#endif  /* __64_BITS__ */
    5359}
    5460
    … …  
    5965 *
    6066 * @return Zero on success or negative error code.
    61  *
    6267 */
    6368int task_set_name(const char *name)
    6469{
    6570        return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name));
     71}
     72
     73/** Kill a task.
     74 *
     75 * @param task_id ID of task to kill.
     76 *
     77 * @return Zero on success or negative error code.
     78 */
     79
     80int task_kill(task_id_t task_id)
     81{
     82        return (int) __SYSCALL1(SYS_TASK_KILL, (sysarg_t) &task_id);
    6683}
    6784
    … …  
    211228int task_wait(task_id_t id, task_exit_t *texit, int *retval)
    212229{
    213         ipcarg_t te, rv;
     230        sysarg_t te, rv;
    214231        int rc;
    215232

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

    rcead2aa r357b5f5  
    5757        size_t *copied, size_t *needed)
    5858{
    59         ipcarg_t a_copied, a_needed;
     59        sysarg_t a_copied, a_needed;
    6060        int rc;
    6161
    … …  
    7272        size_t *copied, size_t *needed)
    7373{
    74         ipcarg_t a_copied, a_needed;
     74        sysarg_t a_copied, a_needed;
    7575        int rc;
    7676
    … …  
    8787        size_t *copied, size_t *needed)
    8888{
    89         ipcarg_t a_copied, a_needed;
     89        sysarg_t a_copied, a_needed;
    9090        int rc;
    9191
    … …  
    120120    sysarg_t *val0, sysarg_t *val1)
    121121{
    122         ipcarg_t a_ev_type;
     122        sysarg_t a_ev_type;
    123123        int rc;
    124124

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

    rcead2aa r357b5f5  
    158158        vfs_connect();
    159159       
    160         ipcarg_t rc_orig;
     160        sysarg_t rc_orig;
    161161        aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL);
    162         ipcarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
     162        sysarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    163163        if (rc != EOK) {
    164164                async_wait_for(req, &rc_orig);
    … …  
    238238int unmount(const char *mp)
    239239{
    240         ipcarg_t rc;
    241         ipcarg_t rc_orig;
     240        sysarg_t rc;
     241        sysarg_t rc_orig;
    242242        aid_t req;
    243243        size_t mpa_size;
    … …  
    282282        ipc_call_t answer;
    283283        aid_t req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
    284         ipcarg_t rc = async_data_write_start(vfs_phone, abs, abs_size);
    285        
    286         if (rc != EOK) {
    287                 ipcarg_t rc_orig;
     284        sysarg_t rc = async_data_write_start(vfs_phone, abs, abs_size);
     285       
     286        if (rc != EOK) {
     287                sysarg_t rc_orig;
    288288                async_wait_for(req, &rc_orig);
    289289               
    … …  
    330330            node->devmap_handle, node->index, oflag, &answer);
    331331       
    332         ipcarg_t rc;
     332        sysarg_t rc;
    333333        async_wait_for(req, &rc);
    334334        async_serialize_end();
    … …  
    343343int close(int fildes)
    344344{
    345         ipcarg_t rc;
     345        sysarg_t rc;
    346346       
    347347        futex_down(&vfs_phone_futex);
    … …  
    359359ssize_t read(int fildes, void *buf, size_t nbyte)
    360360{
    361         ipcarg_t rc;
     361        sysarg_t rc;
    362362        ipc_call_t answer;
    363363        aid_t req;
    … …  
    370370        rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
    371371        if (rc != EOK) {
    372                 ipcarg_t rc_orig;
     372                sysarg_t rc_orig;
    373373       
    374374                async_wait_for(req, &rc_orig);
    … …  
    391391ssize_t write(int fildes, const void *buf, size_t nbyte)
    392392{
    393         ipcarg_t rc;
     393        sysarg_t rc;
    394394        ipc_call_t answer;
    395395        aid_t req;
    … …  
    402402        rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
    403403        if (rc != EOK) {
    404                 ipcarg_t rc_orig;
     404                sysarg_t rc_orig;
    405405       
    406406                async_wait_for(req, &rc_orig);
    … …  
    427427        vfs_connect();
    428428       
    429         ipcarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
     429        sysarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
    430430       
    431431        async_serialize_end();
    … …  
    441441        vfs_connect();
    442442       
    443         ipcarg_t newoff_lo;
    444         ipcarg_t newoff_hi;
    445         ipcarg_t rc = async_req_4_2(vfs_phone, VFS_IN_SEEK, fildes,
     443        sysarg_t newoff_lo;
     444        sysarg_t newoff_hi;
     445        sysarg_t rc = async_req_4_2(vfs_phone, VFS_IN_SEEK, fildes,
    446446            LOWER32(offset), UPPER32(offset), whence,
    447447            &newoff_lo, &newoff_hi);
    … …  
    458458int ftruncate(int fildes, aoff64_t length)
    459459{
    460         ipcarg_t rc;
     460        sysarg_t rc;
    461461       
    462462        futex_down(&vfs_phone_futex);
    … …  
    474474int fstat(int fildes, struct stat *stat)
    475475{
    476         ipcarg_t rc;
     476        sysarg_t rc;
    477477        aid_t req;
    478478
    … …  
    484484        rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat));
    485485        if (rc != EOK) {
    486                 ipcarg_t rc_orig;
     486                sysarg_t rc_orig;
    487487               
    488488                async_wait_for(req, &rc_orig);
    … …  
    503503int stat(const char *path, struct stat *stat)
    504504{
    505         ipcarg_t rc;
    506         ipcarg_t rc_orig;
     505        sysarg_t rc;
     506        sysarg_t rc_orig;
    507507        aid_t req;
    508508       
    … …  
    593593int mkdir(const char *path, mode_t mode)
    594594{
    595         ipcarg_t rc;
     595        sysarg_t rc;
    596596        aid_t req;
    597597       
    … …  
    608608        rc = async_data_write_start(vfs_phone, pa, pa_size);
    609609        if (rc != EOK) {
    610                 ipcarg_t rc_orig;
     610                sysarg_t rc_orig;
    611611       
    612612                async_wait_for(req, &rc_orig);
    … …  
    628628static int _unlink(const char *path, int lflag)
    629629{
    630         ipcarg_t rc;
     630        sysarg_t rc;
    631631        aid_t req;
    632632       
    … …  
    643643        rc = async_data_write_start(vfs_phone, pa, pa_size);
    644644        if (rc != EOK) {
    645                 ipcarg_t rc_orig;
     645                sysarg_t rc_orig;
    646646
    647647                async_wait_for(req, &rc_orig);
    … …  
    673673int rename(const char *old, const char *new)
    674674{
    675         ipcarg_t rc;
    676         ipcarg_t rc_orig;
     675        sysarg_t rc;
     676        sysarg_t rc_orig;
    677677        aid_t req;
    678678       
    … …  
    810810        vfs_connect();
    811811       
    812         ipcarg_t ret;
    813         ipcarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret);
     812        sysarg_t ret;
     813        sysarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret);
    814814       
    815815        async_serialize_end();

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

    rcead2aa r357b5f5  
    4141
    4242/** Invalid assigned value used also if an&nbsp;entry does not exist. */
    43 #define CHAR_MAP_NULL   (-1)
     43#define CHAR_MAP_NULL  (-1)
    4444
    4545/** Type definition of the character string to integer map.
    4646 *  @see char_map
    4747 */
    48 typedef struct char_map char_map_t;
     48typedef struct char_map char_map_t;
    4949
    5050/** Character string to integer map item.
    … …  
    5656struct char_map {
    5757        /** Actually mapped character. */
    58         char c;
     58        uint8_t c;
    5959        /** Stored integral value. */
    6060        int value;
    … …  
    7171extern int char_map_initialize(char_map_t *);
    7272extern void char_map_destroy(char_map_t *);
    73 extern int char_map_exclude(char_map_t *, const char *, size_t);
    74 extern int char_map_add(char_map_t *, const char *, size_t, const int);
    75 extern int char_map_find(const char_map_t *, const char *, size_t);
    76 extern int char_map_update(char_map_t *, const char *, size_t, const int);
     73extern int char_map_exclude(char_map_t *, const uint8_t *, size_t);
     74extern int char_map_add(char_map_t *, const uint8_t *, size_t, const int);
     75extern int char_map_find(const char_map_t *, const uint8_t *, size_t);
     76extern int char_map_update(char_map_t *, const uint8_t *, size_t, const int);
    7777
    7878#endif

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

    rcead2aa r357b5f5  
    6262        }; \
    6363        \
    64         int name##_add(name##_t *, const char *, const size_t, type *); \
     64        int name##_add(name##_t *, const uint8_t *, const size_t, type *); \
    6565        int name##_count(name##_t *); \
    6666        void name##_destroy(name##_t *); \
    67         void name##_exclude(name##_t *, const char *, const size_t); \
    68         type *name##_find(name##_t *, const char *, const size_t); \
     67        void name##_exclude(name##_t *, const uint8_t *, const size_t); \
     68        type *name##_find(name##_t *, const uint8_t *, const size_t); \
    6969        int name##_initialize(name##_t *); \
    7070        int name##_is_valid(name##_t *);
    … …  
    7474 * Should follow declaration with the same parameters.
    7575 *
    76  * @param[in] name      Name of the map.
    77  * @param[in] type      Inner object type.
     76 * @param[in] name Name of the map.
     77 * @param[in] type Inner object type.
     78 *
    7879 */
    7980#define GENERIC_CHAR_MAP_IMPLEMENT(name, type) \
    8081        GENERIC_FIELD_IMPLEMENT(name##_items, type) \
    8182        \
    82         int name##_add(name##_t *map, const char *name, const size_t length, \
     83        int name##_add(name##_t *map, const uint8_t *name, const size_t length, \
    8384             type *value) \
    8485        { \
    … …  
    112113        } \
    113114        \
    114         void name##_exclude(name##_t *map, const char *name, \
     115        void name##_exclude(name##_t *map, const uint8_t *name, \
    115116            const size_t length) \
    116117        { \
    … …  
    124125        } \
    125126        \
    126         type *name##_find(name##_t *map, const char *name, \
     127        type *name##_find(name##_t *map, const uint8_t *name, \
    127128            const size_t length) \
    128129        { \

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

    rcead2aa r357b5f5  
    9191                        } \
    9292                        field->items[field->next] = value; \
    93                         ++field->next; \
     93                        field->next++; \
    9494                        field->items[field->next] = NULL; \
    9595                        return field->next - 1; \
    … …  
    108108                        int index; \
    109109                        field->magic = 0; \
    110                         for (index = 0; index < field->next; ++ index) { \
     110                        for (index = 0; index < field->next; index++) { \
    111111                                if (field->items[index]) \
    112112                                        free(field->items[index]); \

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

    rcead2aa r357b5f5  
    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/adt/measured_strings.h

    rcead2aa r357b5f5  
    5454struct measured_string {
    5555        /** Character string data. */
    56         char *value;
     56        uint8_t *value;
    5757        /** Character string length. */
    5858        size_t length;
    5959};
    6060
    61 extern measured_string_t *measured_string_create_bulk(const char *, size_t);
     61extern measured_string_t *measured_string_create_bulk(const uint8_t *, size_t);
    6262extern measured_string_t *measured_string_copy(measured_string_t *);
    63 extern int measured_strings_receive(measured_string_t **, char **, size_t);
     63extern int measured_strings_receive(measured_string_t **, uint8_t **, size_t);
    6464extern int measured_strings_reply(const measured_string_t *, size_t);
    65 extern int measured_strings_return(int, measured_string_t **, char **, size_t);
     65extern int measured_strings_return(int, measured_string_t **, uint8_t **, size_t);
    6666extern int measured_strings_send(int, const measured_string_t *, size_t);
    6767

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

    rcead2aa r357b5f5  
    3737
    3838#include <ipc/ipc.h>
     39#include <async_sess.h>
    3940#include <fibril.h>
    4041#include <sys/time.h>
    … …  
    8485            (arg5), (dataptr))
    8586
    86 extern aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    87     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr);
    88 extern aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
    89     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
     87extern 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);
     89extern 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,
    9091    ipc_call_t *dataptr);
    91 extern void async_wait_for(aid_t amsgid, ipcarg_t *result);
    92 extern int async_wait_timeout(aid_t amsgid, ipcarg_t *retval,
     92extern void async_wait_for(aid_t amsgid, sysarg_t *result);
     93extern int async_wait_timeout(aid_t amsgid, sysarg_t *retval,
    9394    suseconds_t timeout);
    9495
    95 extern fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
     96extern fid_t async_new_connection(sysarg_t in_phone_hash, ipc_callid_t callid,
    9697    ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *));
    9798extern void async_usleep(suseconds_t timeout);
    … …  
    242243            (arg5), (rc1), (rc2), (rc3), (rc4), (rc5))
    243244
    244 extern ipcarg_t async_req_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
    245     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t *r1, ipcarg_t *r2,
    246     ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5);
    247 extern ipcarg_t async_req_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
    248     ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *r1,
    249     ipcarg_t *r2, ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5);
     245extern 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);
     248extern 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);
    250251
    251252static inline void async_serialize_start(void)
    … …  
    259260}
    260261
    261 extern int async_connect_me_to(int, ipcarg_t, ipcarg_t, ipcarg_t);
    262 extern int async_connect_me_to_blocking(int, ipcarg_t, ipcarg_t, ipcarg_t);
     262extern int async_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
     263extern int async_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);
    263264
    264265/*
    … …  
    274275        async_share_in_start((phoneid), (dst), (size), (arg), (flags))
    275276
    276 extern int async_share_in_start(int, void *, size_t, ipcarg_t, int *);
     277extern int async_share_in_start(int, void *, size_t, sysarg_t, int *);
    277278extern int async_share_in_receive(ipc_callid_t *, size_t *);
    278279extern int async_share_in_finalize(ipc_callid_t, void *, int );
    … …  
    314315extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    315316
    316 extern int async_data_read_forward_fast(int, ipcarg_t, ipcarg_t, ipcarg_t,
    317     ipcarg_t, ipcarg_t, ipc_call_t *);
     317extern int async_data_read_forward_fast(int, sysarg_t, sysarg_t, sysarg_t,
     318    sysarg_t, sysarg_t, ipc_call_t *);
    318319
    319320/*
    … …  
    356357extern void async_data_write_void(const int);
    357358
    358 extern int async_data_write_forward_fast(int, ipcarg_t, ipcarg_t, ipcarg_t,
    359     ipcarg_t, ipcarg_t, ipc_call_t *);
     359extern int async_data_write_forward_fast(int, sysarg_t, sysarg_t, sysarg_t,
     360    sysarg_t, sysarg_t, ipc_call_t *);
    360361
    361362#endif

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

    rcead2aa r357b5f5  
    11/*
    2  * Copyright (c) 2006 Jakub Jermar
     2 * Copyright (c) 2010 Jakub Jermar
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup generic
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 
    33 /**
    34  * @file
    35  * @brief Wrapper for explicit 64-bit arguments passed to syscalls.
     32/** @file
    3633 */
    3734
    38 #ifndef KERN_SYSARG64_H_
    39 #define KERN_SYSARG64_H_
     35#ifndef LIBC_ASYNC_SESS_H_
     36#define LIBC_ASYNC_SESS_H_
     37
     38#include <adt/list.h>
    4039
    4140typedef struct {
    42         unsigned long long value;
    43 } sysarg64_t;
     41        int sess_phone;         /**< Phone for cloning off the connections. */
     42        sysarg_t connect_arg1;  /**< Argument for CONNECT_ME_TO. */
     43        link_t conn_head;       /**< List of open data connections. */
     44        link_t sess_link;       /**< Link in global list of open sessions. */
     45} async_sess_t;
     46
     47extern void _async_sess_init(void);
     48extern void async_session_create(async_sess_t *, int, sysarg_t);
     49extern void async_session_destroy(async_sess_t *);
     50extern int async_exchange_begin(async_sess_t *);
     51extern void async_exchange_end(async_sess_t *, int);
    4452
    4553#endif

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

    rcead2aa r357b5f5  
    4242extern int iospace_enable(task_id_t, void *, unsigned long);
    4343extern int pio_enable(void *, size_t, void **);
    44 extern int interrupt_enable(int);
    45 extern int interrupt_disable(int);
    4644
    4745#endif

  • uspace/lib/c/include/device/char_dev.h

    rcead2aa r357b5f5  
    2727 */
    2828
    29  /** @addtogroup libc
     29/** @addtogroup libc
    3030 * @{
    3131 */
    … …  
    3333 */
    3434
    35 #ifndef LIBC_DEVICE_HW_RES_H_
    36 #define LIBC_DEVICE_HW_RES_H_
     35#ifndef LIBC_DEVICE_CHAR_DEV_H_
     36#define LIBC_DEVICE_CHAR_DEV_H_
    3737
    3838typedef enum {
    39         CHAR_READ_DEV = 0,
    40         CHAR_WRITE_DEV
    41 } hw_res_funcs_t;
     39        CHAR_DEV_READ = 0,
     40        CHAR_DEV_WRITE
     41} char_dev_method_t;
    4242
    43 ssize_t read_dev(int dev_phone, void *buf, size_t len);
    44 ssize_t write_dev(int dev_phone, void *buf, size_t len);
     43ssize_t char_dev_read(int dev_phone, void *buf, size_t len);
     44ssize_t char_dev_write(int dev_phone, void *buf, size_t len);
    4545
    4646#endif

  • uspace/lib/c/include/device/hw_res.h

    rcead2aa r357b5f5  
    2727 */
    2828 
    29  /** @addtogroup libc
     29/** @addtogroup libc
    3030 * @{
    3131 */
    … …  
    3939#include <bool.h>
    4040
    41 // HW resource provider interface
     41/** HW resource provider interface */
     42typedef enum {
     43        HW_RES_GET_RESOURCE_LIST = 0,
     44        HW_RES_ENABLE_INTERRUPT
     45} hw_res_method_t;
    4246
    43 typedef enum {
    44         GET_RESOURCE_LIST = 0,
    45         ENABLE_INTERRUPT       
    46 } hw_res_funcs_t;
    47 
    48 /** HW resource types. */
     47/** HW resource types */
    4948typedef enum {
    5049        INTERRUPT,
    … …  
    5857} endianness_t;
    5958
    60 
    61 /** HW resource (e.g. interrupt, memory register, i/o register etc.). */
    62 typedef struct hw_resource {
     59/** HW resource (e.g. interrupt, memory register, i/o register etc.) */
     60typedef struct {
    6361        hw_res_type_t type;
    6462        union {
    6563                struct {
    6664                        uint64_t address;
    67                         endianness_t endianness;                       
    68                         size_t size;                   
     65                        endianness_t endianness;
     66                        size_t size;
    6967                } mem_range;
     68
    7069                struct {
    7170                        uint64_t address;
    72                         endianness_t endianness;                       
    73                         size_t size;                   
     71                        endianness_t endianness;
     72                        size_t size;
    7473                } io_range;
     74
    7575                struct {
    76                         int irq;                       
    77                 } interrupt;           
    78         } res; 
     76                        int irq;
     77                } interrupt;
     78        } res;
    7979} hw_resource_t;
    8080
    81 typedef struct hw_resource_list {
     81typedef struct {
    8282        size_t count;
    83         hw_resource_t *resources;       
     83        hw_resource_t *resources;
    8484} hw_resource_list_t;
    8585
    86 static inline void clean_hw_resource_list(hw_resource_list_t *hw_res)
     86static inline void hw_res_clean_resource_list(hw_resource_list_t *hw_res)
    8787{
    88         if(NULL != hw_res->resources) {
     88        if (hw_res->resources != NULL) {
    8989                free(hw_res->resources);
     90
    9091                hw_res->resources = NULL;
    9192        }
    92         hw_res->count = 0;     
     93
     94        hw_res->count = 0;
    9395}
    9496
    95 
    96 
    97 bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources);
    98 
    99 bool enable_interrupt(int dev_phone);
    100 
     97extern int hw_res_get_resource_list(int, hw_resource_list_t *);
     98extern bool hw_res_enable_interrupt(int);
    10199
    102100#endif

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

    rcead2aa r357b5f5  
    4545extern int devmap_driver_register(const char *, async_client_conn_t);
    4646extern int devmap_device_register(const char *, devmap_handle_t *);
     47extern int devmap_device_register_with_iface(const char *, devmap_handle_t *, sysarg_t);
    4748
    4849extern int devmap_device_get_handle(const char *, devmap_handle_t *, unsigned int);

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

    rcead2aa r357b5f5  
    8383#define ENOTCONN        (-10057)
    8484
    85 /** The requested operation was not performed.
    86  *  Try again later.
    87  */
    88 #define TRY_AGAIN       (-11002)
     85/** The requested operation was not performed. Try again later. */
     86#define EAGAIN          (-11002)
    8987
    9088/** No data.

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

    rcead2aa r357b5f5  
    3939#include <ipc/ipc.h>
    4040
    41 extern int event_subscribe(event_type_t, ipcarg_t);
     41extern int event_subscribe(event_type_t, sysarg_t);
    4242
    4343#endif

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

    rcead2aa r357b5f5  
    9494extern void fibril_inc_sercount(void);
    9595extern void fibril_dec_sercount(void);
     96extern int fibril_get_sercount(void);
    9697
    9798static inline int fibril_yield(void)

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

    rcead2aa r357b5f5  
    105105extern bool fibril_mutex_trylock(fibril_mutex_t *);
    106106extern void fibril_mutex_unlock(fibril_mutex_t *);
     107extern bool fibril_mutex_is_locked(fibril_mutex_t *);
    107108
    108109extern void fibril_rwlock_initialize(fibril_rwlock_t *);
    … …  
    111112extern void fibril_rwlock_read_unlock(fibril_rwlock_t *);
    112113extern void fibril_rwlock_write_unlock(fibril_rwlock_t *);
     114extern bool fibril_rwlock_is_read_locked(fibril_rwlock_t *);
     115extern bool fibril_rwlock_is_write_locked(fibril_rwlock_t *);
     116extern bool fibril_rwlock_is_locked(fibril_rwlock_t *);
    113117
    114118extern void fibril_condvar_initialize(fibril_condvar_t *);

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

    rcead2aa r357b5f5  
    6868extern void console_clear(int phone);
    6969
    70 extern int console_get_size(int phone, ipcarg_t *cols, ipcarg_t *rows);
    71 extern int console_get_pos(int phone, ipcarg_t *col, ipcarg_t *row);
    72 extern void console_set_pos(int phone, ipcarg_t col, ipcarg_t row);
     70extern int console_get_size(int phone, sysarg_t *cols, sysarg_t *rows);
     71extern int console_get_pos(int phone, sysarg_t *col, sysarg_t *row);
     72extern void console_set_pos(int phone, sysarg_t col, sysarg_t row);
    7373
    7474extern void console_set_style(int phone, uint8_t style);
    … …  
    7878
    7979extern void console_cursor_visibility(int phone, bool show);
    80 extern int console_get_color_cap(int phone, ipcarg_t *ccap);
     80extern int console_get_color_cap(int phone, sysarg_t *ccap);
    8181extern void console_kcon_enable(int phone);
    8282

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

    rcead2aa r357b5f5  
    8484        keyfield_t *buffer;      /**< Screen content - characters and
    8585                                      their attributes (used as a circular buffer) */
    86         ipcarg_t size_x;         /**< Number of columns  */
    87         ipcarg_t size_y;         /**< Number of rows */
     86        sysarg_t size_x;         /**< Number of columns  */
     87        sysarg_t size_y;         /**< Number of rows */
    8888       
    8989        /** Coordinates of last printed character for determining cursor position */
    90         ipcarg_t position_x;
    91         ipcarg_t position_y;
     90        sysarg_t position_x;
     91        sysarg_t position_y;
    9292       
    9393        attrs_t attrs;           /**< Current attributes. */
    … …  
    109109 *
    110110 */
    111 static inline keyfield_t *get_field_at(screenbuffer_t *scr, ipcarg_t x, ipcarg_t y)
     111static inline keyfield_t *get_field_at(screenbuffer_t *scr, sysarg_t x, sysarg_t y)
    112112{
    113113        return scr->buffer + x + ((y + scr->top_line) % scr->size_y) * scr->size_x;
    … …  
    143143
    144144extern void screenbuffer_putchar(screenbuffer_t *, wchar_t);
    145 extern screenbuffer_t *screenbuffer_init(screenbuffer_t *, ipcarg_t, ipcarg_t);
     145extern screenbuffer_t *screenbuffer_init(screenbuffer_t *, sysarg_t, sysarg_t);
    146146
    147147extern void screenbuffer_clear(screenbuffer_t *);
    148 extern void screenbuffer_clear_line(screenbuffer_t *, ipcarg_t);
     148extern void screenbuffer_clear_line(screenbuffer_t *, sysarg_t);
    149149extern void screenbuffer_copy_buffer(screenbuffer_t *, keyfield_t *);
    150 extern void screenbuffer_goto(screenbuffer_t *, ipcarg_t, ipcarg_t);
     150extern void screenbuffer_goto(screenbuffer_t *, sysarg_t, sysarg_t);
    151151extern void screenbuffer_set_style(screenbuffer_t *, uint8_t);
    152152extern void screenbuffer_set_color(screenbuffer_t *, uint8_t, uint8_t, uint8_t);

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

    rcead2aa r357b5f5  
    6969/*@{*/
    7070
    71 /** Returns the protocol service message parameter.
    72  * @param[in] call The message call structure.
     71/** Return the protocol service message parameter.
     72 *
     73 * @param[in] call Message call structure.
     74 *
    7375 */
    74 #define ARP_GET_NETIF(call) \
    75         ({ \
    76                 services_t service = (services_t) IPC_GET_ARG2(*call); \
    77                 service; \
    78         })
     76#define ARP_GET_NETIF(call) ((services_t) IPC_GET_ARG2(call))
    7977
    8078/*@}*/

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

    rcead2aa r357b5f5  
    3535#include <libarch/types.h>
    3636
    37 typedef enum { 
    38         HW_RES_DEV_IFACE = 0,   
     37typedef enum {
     38        HW_RES_DEV_IFACE = 0,
    3939        CHAR_DEV_IFACE,
    40         // TODO add more interfaces
    4140        DEV_IFACE_MAX
    4241} dev_inferface_idx_t;

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

    rcead2aa r357b5f5  
    4242#define DEVMAN_NAME_MAXLEN 256
    4343
    44 typedef ipcarg_t devman_handle_t;
     44typedef sysarg_t devman_handle_t;
    4545
    4646/** Ids of device models used for device-to-driver matching.
    … …  
    123123        DEVMAN_CLIENT,
    124124        DEVMAN_CONNECT_TO_DEVICE,
     125        DEVMAN_CONNECT_FROM_DEVMAP,
    125126        DEVMAN_CONNECT_TO_PARENTS_DEVICE
    126127} devman_interface_t;

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

    rcead2aa r357b5f5  
    4040#define DEVMAP_NAME_MAXLEN  255
    4141
    42 typedef ipcarg_t devmap_handle_t;
     42typedef sysarg_t devmap_handle_t;
    4343
    4444typedef enum {

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

    rcead2aa r357b5f5  
    3333/** @file
    3434 * ICMP module messages.
    35  * @see icmp_interface.h
     35 * @see icmp_remote.h
    3636 */
    3737
    … …  
    4848/** ICMP module messages. */
    4949typedef enum {
    50         /** Sends echo request. @see icmp_echo() */
     50        /** Send echo request. @see icmp_echo() */
    5151        NET_ICMP_ECHO = NET_ICMP_FIRST,
    5252       
    5353        /**
    54          * Sends destination unreachable error message.
     54         * Send destination unreachable error message.
    5555         * @see icmp_destination_unreachable_msg()
    5656         */
    … …  
    5858       
    5959        /**
    60          * Sends source quench error message.
     60         * Send source quench error message.
    6161         * @see icmp_source_quench_msg()
    6262         */
    … …  
    6464       
    6565        /**
    66          * Sends time exceeded error message.
     66         * Send time exceeded error message.
    6767         * @see icmp_time_exceeded_msg()
    6868         */
    … …  
    7070       
    7171        /**
    72          * Sends parameter problem error message.
     72         * Send parameter problem error message.
    7373         * @see icmp_parameter_problem_msg()
    7474         */
    75         NET_ICMP_PARAMETERPROB,
    76        
    77         /** Initializes new connection. */
    78         NET_ICMP_INIT
    79 } icmp_messages;
     75        NET_ICMP_PARAMETERPROB
     76} icmp_messages_t;
    8077
    8178/** @name ICMP specific message parameters definitions */
    8279/*@{*/
    8380
    84 /** Returns the ICMP code message parameter.
     81/** Return the ICMP code message parameter.
    8582 *
    86  * @param[in] call      The message call structure.
     83 * @param[in] call Message call structure.
     84 *
    8785 */
    88 #define ICMP_GET_CODE(call) \
    89         ({ \
    90                 icmp_code_t code = (icmp_code_t) IPC_GET_ARG1(*call); \
    91                 code; \
    92         })
     86#define ICMP_GET_CODE(call)  ((icmp_code_t) IPC_GET_ARG1(call))
    9387
    94 /** Returns the ICMP link MTU message parameter.
     88/** Return the ICMP link MTU message parameter.
    9589 *
    96  * @param[in] call      The message call structure.
     90 * @param[in] call Message call structure.
     91 *
    9792 */
    98 #define ICMP_GET_MTU(call) \
    99         ({ \
    100                 icmp_param_t mtu = (icmp_param_t) IPC_GET_ARG3(*call); \
    101                 mtu; \
    102         })
     93#define ICMP_GET_MTU(call)  ((icmp_param_t) IPC_GET_ARG3(call))
    10394
    104 /** Returns the pointer message parameter.
     95/** Return the pointer message parameter.
    10596 *
    106  * @param[in] call      The message call structure.
     97 * @param[in] call Message call structure.
     98 *
    10799 */
    108 #define ICMP_GET_POINTER(call) \
    109         ({ \
    110                 icmp_param_t pointer = (icmp_param_t) IPC_GET_ARG3(*call); \
    111                 pointer; \
    112         })
     100#define ICMP_GET_POINTER(call)  ((icmp_param_t) IPC_GET_ARG3(call))
    113101
    114 /** Returns the size message parameter.
     102/** Return the size message parameter.
    115103 *
    116  * @param[in] call      The message call structure.
     104 * @param[in] call Message call structure.
     105 *
    117106 */
    118 #define ICMP_GET_SIZE(call) \
    119         ({ \
    120                 size_t size = (size_t) IPC_GET_ARG1(call); \
    121                 size; \
    122         })
     107#define ICMP_GET_SIZE(call)  ((size_t) IPC_GET_ARG1(call))
    123108
    124 /** Returns the timeout message parameter.
     109/** Return the timeout message parameter.
    125110 *
    126  * @param[in] call      The message call structure.
     111 * @param[in] call Message call structure.
     112 *
    127113 */
    128 #define ICMP_GET_TIMEOUT(call) \
    129         ({ \
    130                 suseconds_t timeout = (suseconds_t) IPC_GET_ARG2(call); \
    131                 timeout; \
    132         })
     114#define ICMP_GET_TIMEOUT(call)  ((suseconds_t) IPC_GET_ARG2(call))
    133115
    134 /** Returns the time to live message parameter.
     116/** Return the time to live message parameter.
    135117 *
    136  * @param[in] call      The message call structure.
     118 * @param[in] call Message call structure.
     119 *
    137120 */
    138 #define ICMP_GET_TTL(call) \
    139         ({ \
    140                 ip_ttl_t ttl = (ip_ttl_t) IPC_GET_ARG3(call); \
    141                 ttl; \
    142         })
     121#define ICMP_GET_TTL(call)  ((ip_ttl_t) IPC_GET_ARG3(call))
    143122
    144 /** Returns the type of service message parameter.
     123/** Return the type of service message parameter.
    145124 *
    146  * @param[in] call      The message call structure.
     125 * @param[in] call Message call structure.
     126 *
    147127 */
    148 #define ICMP_GET_TOS(call) \
    149         ({ \
    150                 ip_tos_t tos = (ip_tos_t) IPC_GET_ARG4(call); \
    151                 tos; \
    152         })
     128#define ICMP_GET_TOS(call)  ((ip_tos_t) IPC_GET_ARG4(call))
    153129
    154 /** Returns the dont fragment message parameter.
     130/** Return the dont fragment message parameter.
    155131 *
    156  * @param[in] call      The message call structure.
     132 * @param[in] call Message call structure.
    157133 */
    158 #define ICMP_GET_DONT_FRAGMENT(call) \
    159         ({ \
    160                 int dont_fragment = (int) IPC_GET_ARG5(call); \
    161                 dont_fragment; \
    162         })
     134#define ICMP_GET_DONT_FRAGMENT(call)  ((int) IPC_GET_ARG5(call))
    163135
    164136/*@}*/

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

    rcead2aa r357b5f5  
    3333/** @file
    3434 * Internetwork layer modules messages.
    35  * @see il_interface.h
     35 * @see il_remote.h
    3636 * @see ip_interface.h
    3737 */
    … …  
    4545/** Internet layer modules messages. */
    4646typedef enum {
    47         /** New device message.
    48          * @see ip_device_req()
    49          */
    50         NET_IL_DEVICE = NET_IL_FIRST,
    5147        /** Device state changed message.
    5248         * @see il_device_state_msg()
    5349         */
    54         NET_IL_DEVICE_STATE,
     50        NET_IL_DEVICE_STATE = NET_IL_FIRST,
     51       
    5552        /** Device MTU changed message.
    5653         * @see il_mtu_changed_msg()
    5754         */
    5855        NET_IL_MTU_CHANGED,
    59         /** Packet size message.
    60          * @see il_packet_size_req()
    61          */
    62         NET_IL_PACKET_SPACE,
     56       
    6357        /** Packet received message.
    6458         * @see il_received_msg()
    6559         */
    66         NET_IL_RECEIVED,
    67         /** Packet send message.
    68          * @see il_send_msg()
    69          */
    70         NET_IL_SEND
     60        NET_IL_RECEIVED
    7161} il_messages;
    7262
    … …  
    7565
    7666/** Return the protocol number message parameter.
    77  * @param[in] call The message call structure.
     67 *
     68 * @param[in] call Message call structure.
     69 *
    7870 */
    79 #define IL_GET_PROTO(call)      (int) IPC_GET_ARG1(*call)
     71#define IL_GET_PROTO(call)  ((int) IPC_GET_ARG1(call))
    8072
    8173/** Return the registering service message parameter.
    82  * @param[in] call The message call structure.
     74 *
     75 * @param[in] call Message call structure.
     76 *
    8377 */
    84 #define IL_GET_SERVICE(call)    (services_t) IPC_GET_ARG2(*call)
     78#define IL_GET_SERVICE(call)  ((services_t) IPC_GET_ARG2(call))
    8579
    8680/*@}*/

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

    rcead2aa r357b5f5  
    4747/** IP module messages. */
    4848typedef enum {
     49        /** New device message.
     50         * @see ip_device_req()
     51         */
     52        NET_IP_DEVICE = NET_IP_FIRST,
     53       
    4954        /** Adds the routing entry.
    5055         * @see ip_add_route()
    5156         */
    52         NET_IP_ADD_ROUTE = NET_IP_FIRST,
     57        NET_IP_ADD_ROUTE,
     58       
    5359        /** Gets the actual route information.
    5460         * @see ip_get_route()
    5561         */
    5662        NET_IP_GET_ROUTE,
     63       
    5764        /** Processes the received error notification.
    5865         * @see ip_received_error_msg()
    5966         */
    6067        NET_IP_RECEIVED_ERROR,
     68       
    6169        /** Sets the default gateway.
    6270         * @see ip_set_default_gateway()
    6371         */
    64         NET_IP_SET_GATEWAY
     72        NET_IP_SET_GATEWAY,
     73       
     74        /** Packet size message.
     75         * @see ip_packet_size_req()
     76         */
     77        NET_IP_PACKET_SPACE,
     78       
     79        /** Packet send message.
     80         * @see ip_send_msg()
     81         */
     82        NET_IP_SEND
    6583} ip_messages;
    6684
    … …  
    6886/*@{*/
    6987
    70 /** Returns the address message parameter.
    71  * @param[in] call The message call structure.
     88/** Return the address message parameter.
     89 *
     90 * @param[in] call Message call structure.
     91 *
    7292 */
    7393#define IP_GET_ADDRESS(call) \
    7494        ({ \
    7595                in_addr_t addr; \
    76                 addr.s_addr = IPC_GET_ARG3(*call); \
     96                addr.s_addr = IPC_GET_ARG3(call); \
    7797                addr; \
    7898        })
    7999
    80 /** Returns the gateway message parameter.
    81  * @param[in] call The message call structure.
     100/** Return the gateway message parameter.
     101 *
     102 * @param[in] call Message call structure.
     103 *
    82104 */
    83105#define IP_GET_GATEWAY(call) \
    84106        ({ \
    85107                in_addr_t addr; \
    86                 addr.s_addr = IPC_GET_ARG2(*call); \
     108                addr.s_addr = IPC_GET_ARG2(call); \
    87109                addr; \
    88110        })
    89111
    90 /** Sets the header length in the message answer.
    91  * @param[out] answer The message answer structure.
     112/** Set the header length in the message answer.
     113 *
     114 * @param[out] answer Message answer structure.
     115 *
    92116 */
    93 #define IP_SET_HEADERLEN(answer, value) \
    94         do { \
    95                 ipcarg_t argument = (ipcarg_t) (value); \
    96                 IPC_SET_ARG2(*answer, argument); \
    97         } while (0)
     117#define IP_SET_HEADERLEN(answer, value)  IPC_SET_ARG2(answer, (sysarg_t) (value))
    98118
    99 /** Returns the network mask message parameter.
    100  * @param[in] call The message call structure.
     119/** Return the network mask message parameter.
     120 *
     121 * @param[in] call Message call structure.
     122 *
    101123 */
    102124#define IP_GET_NETMASK(call) \
    103125        ({ \
    104126                in_addr_t addr; \
    105                 addr.s_addr = IPC_GET_ARG4(*call); \
     127                addr.s_addr = IPC_GET_ARG4(call); \
    106128                addr; \
    107129        })
    108130
    109 /** Returns the protocol message parameter.
    110  * @param[in] call The message call structure.
     131/** Return the protocol message parameter.
     132 *
     133 * @param[in] call Message call structure.
     134 *
    111135 */
    112 #define IP_GET_PROTOCOL(call) \
    113         ({ \
    114                 ip_protocol_t protocol = (ip_protocol_t) IPC_GET_ARG1(*call); \
    115                 protocol; \
    116         })
     136#define IP_GET_PROTOCOL(call)  ((ip_protocol_t) IPC_GET_ARG1(call))
    117137
    118138/*@}*/

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

    rcead2aa r357b5f5  
    4444#define IPC_FLAG_BLOCKING  0x01
    4545
    46 typedef sysarg_t ipcarg_t;
    47 
    4846typedef struct {
    49         ipcarg_t args[IPC_CALL_LEN];
    50         ipcarg_t in_phone_hash;
     47        sysarg_t args[IPC_CALL_LEN];
     48        sysarg_t in_phone_hash;
    5149} ipc_call_t;
    5250
    … …  
    183181            (arg4), (arg5), (res1), (res2), (res3), (res4), (res5))
    184182
    185 extern int ipc_call_sync_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
    186     ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *);
    187 
    188 extern int ipc_call_sync_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
    189     ipcarg_t, ipcarg_t, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *,
    190     ipcarg_t *);
     183extern int ipc_call_sync_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     184    sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *);
     185
     186extern int ipc_call_sync_slow(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     187    sysarg_t, sysarg_t, sysarg_t *, sysarg_t *, sysarg_t *, sysarg_t *,
     188    sysarg_t *);
    191189
    192190extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
    … …  
    220218        ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
    221219
    222 extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
    223     ipcarg_t, ipcarg_t);
    224 extern ipcarg_t ipc_answer_slow(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
    225     ipcarg_t, ipcarg_t, ipcarg_t);
     220extern sysarg_t ipc_answer_fast(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     221    sysarg_t, sysarg_t);
     222extern sysarg_t ipc_answer_slow(ipc_callid_t, sysarg_t, sysarg_t, sysarg_t,
     223    sysarg_t, sysarg_t, sysarg_t);
    226224
    227225/*
    … …  
    255253            (arg4), (arg5), (private), (callback), (can_preempt))
    256254
    257 extern void ipc_call_async_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
    258     ipcarg_t, void *, ipc_async_callback_t, int);
    259 extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
    260     ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int);
    261 
    262 extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *);
     255extern void ipc_call_async_fast(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     256    sysarg_t, void *, ipc_async_callback_t, int);
     257extern 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
     260extern int ipc_connect_to_me(int, int, int, int, sysarg_t *);
    263261extern int ipc_connect_me_to(int, int, int, int);
    264262extern int ipc_connect_me_to_blocking(int, int, int, int);
    … …  
    266264extern int ipc_register_irq(int, int, int, irq_code_t *);
    267265extern int ipc_unregister_irq(int, int);
    268 extern int ipc_forward_fast(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, int);
    269 extern int ipc_forward_slow(ipc_callid_t, int, int, ipcarg_t, ipcarg_t,
    270     ipcarg_t, ipcarg_t, ipcarg_t, int);
     266extern int ipc_forward_fast(ipc_callid_t, int, int, sysarg_t, sysarg_t, int);
     267extern int ipc_forward_slow(ipc_callid_t, int, int, sysarg_t, sysarg_t,
     268    sysarg_t, sysarg_t, sysarg_t, int);
    271269
    272270/*
    … …  
    282280        ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
    283281
    284 extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
     282extern int ipc_share_in_start(int, void *, size_t, sysarg_t, int *);
    285283extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
    286284extern int ipc_share_out_start(int, void *, int);

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

    rcead2aa r357b5f5  
    3131 */
    3232/** @file
    33  */ 
     33 */
    3434
    35 #ifndef LIBC_BUS_H_
    36 #define LIBC_BUS_H_
     35#ifndef LIBC_IRC_H_
     36#define LIBC_IRC_H_
    3737
    3838#include <ipc/ipc.h>
    3939
    4040typedef enum {
    41         BUS_CLEAR_INTERRUPT = IPC_FIRST_USER_METHOD
    42 } bus_request_t;
     41        IRC_ENABLE_INTERRUPT = IPC_FIRST_USER_METHOD,
     42        IRC_CLEAR_INTERRUPT
     43} irc_request_t;
    4344
    4445#endif

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

    rcead2aa r357b5f5  
    4444#include <net/packet.h>
    4545
    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.
     46/** Return a value indicating whether the value is in the interval.
     47 *
     48 * @param[in] item            Value to be checked.
     49 * @param[in] first_inclusive First value in the interval inclusive.
     50 * @param[in] last_exclusive  First value after the interval.
     51 *
    5052 */
    5153#define IS_IN_INTERVAL(item, first_inclusive, last_exclusive) \
    … …  
    5557/*@{*/
    5658
    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
     59#define NET_ARP_COUNT     5   /**< Number of ARP messages. */
     60#define NET_ETH_COUNT     0   /**< Number of Ethernet messages. */
     61#define NET_ICMP_COUNT    6   /**< Number of ICMP messages. */
     62#define NET_IL_COUNT      6   /**< Number of inter-network messages. */
     63#define NET_IP_COUNT      4   /**< Number of IP messages. */
     64#define NET_NET_COUNT     3   /**< Number of general networking messages. */
     65#define NET_NETIF_COUNT   6   /**< Number of network interface driver messages. */
     66#define NET_NIL_COUNT     7   /**< Number of network interface layer messages. */
     67#define NET_PACKET_COUNT  5   /**< Number of packet management system messages. */
     68#define NET_SOCKET_COUNT  14  /**< Number of socket messages. */
     69#define NET_TCP_COUNT     0   /**< Number of TCP messages. */
     70#define NET_TL_COUNT      1   /**< Number of transport layer messages. */
     71#define NET_UDP_COUNT     0   /**< Number of UDP messages. */
    9572
    9673/*@}*/
    … …  
    10077/*@{*/
    10178
    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.
     79
     80/** First networking message. */
     81#define NET_FIRST  2000
     82
     83/** First network interface layer message. */
     84#define NET_NETIF_FIRST  NET_FIRST
     85
     86/** Last network interface layer message. */
     87#define NET_NETIF_LAST  (NET_NETIF_FIRST + NET_NETIF_COUNT)
     88
     89/** First general networking message. */
     90#define NET_NET_FIRST  (NET_NETIF_LAST + 0)
     91
     92/** Last general networking message. */
     93#define NET_NET_LAST  (NET_NET_FIRST + NET_NET_COUNT)
     94
     95/** First network interface layer message. */
     96#define NET_NIL_FIRST  (NET_NET_LAST + 0)
     97
     98/** Last network interface layer message. */
     99#define NET_NIL_LAST  (NET_NIL_FIRST + NET_NIL_COUNT)
     100
     101/** First Ethernet message. */
     102#define NET_ETH_FIRST  (NET_NIL_LAST + 0)
     103
     104/** Last Ethernet message. */
     105#define NET_ETH_LAST  (NET_ETH_FIRST + NET_ETH_COUNT)
     106
     107/** First inter-network message. */
     108#define NET_IL_FIRST  (NET_ETH_LAST + 0)
     109
     110/** Last inter-network message. */
     111#define NET_IL_LAST  (NET_IL_FIRST + NET_IL_COUNT)
     112
     113/** First IP message. */
     114#define NET_IP_FIRST  (NET_IL_LAST + 0)
     115
     116/** Last IP message. */
     117#define NET_IP_LAST  (NET_IP_FIRST + NET_IP_COUNT)
     118
     119/** First ARP message. */
     120#define NET_ARP_FIRST  (NET_IP_LAST + 0)
     121
     122/** Last ARP message. */
     123#define NET_ARP_LAST  (NET_ARP_FIRST + NET_ARP_COUNT)
     124
     125/** First ICMP message. */
     126#define NET_ICMP_FIRST  (NET_ARP_LAST + 0)
     127
     128/** Last ICMP message. */
     129#define NET_ICMP_LAST  (NET_ICMP_FIRST + NET_ICMP_COUNT)
     130
     131/** First ICMP message. */
     132#define NET_TL_FIRST  (NET_ICMP_LAST + 0)
     133
     134/** Last ICMP message. */
     135#define NET_TL_LAST  (NET_TL_FIRST + NET_TL_COUNT)
     136
     137/** First UDP message. */
     138#define NET_UDP_FIRST  (NET_TL_LAST + 0)
     139
     140/** Last UDP message. */
     141#define NET_UDP_LAST  (NET_UDP_FIRST + NET_UDP_COUNT)
     142
     143/** First TCP message. */
     144#define NET_TCP_FIRST  (NET_UDP_LAST + 0)
     145
     146/** Last TCP message. */
     147#define NET_TCP_LAST  (NET_TCP_FIRST + NET_TCP_COUNT)
     148
     149/** First socket message. */
     150#define NET_SOCKET_FIRST  (NET_TCP_LAST + 0)
     151
     152/** Last socket message. */
     153#define NET_SOCKET_LAST  (NET_SOCKET_FIRST + NET_SOCKET_COUNT)
     154
     155/** First packet management system message. */
     156#define NET_PACKET_FIRST  (NET_SOCKET_LAST + 0)
     157
     158/** Last packet management system message. */
     159#define NET_PACKET_LAST  (NET_PACKET_FIRST + NET_PACKET_COUNT)
     160
     161/** Last networking message. */
     162#define NET_LAST  NET_PACKET_LAST
     163
     164/** Number of networking messages. */
     165#define NET_COUNT  (NET_LAST - NET_FIRST)
     166
     167/** Check if the IPC call is a generic networking message.
     168 *
     169 * @param[in] call IPC call to be checked.
     170 *
    192171 */
    193172#define IS_NET_MESSAGE(call) \
    194         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     173        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_FIRST, NET_LAST)
     174
     175/** Check if the IPC call is an ARP message.
     176 *
     177 * @param[in] call IPC call to be checked.
     178 *
    198179 */
    199180#define IS_NET_ARP_MESSAGE(call) \
    200         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     181        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_ARP_FIRST, NET_ARP_LAST)
     182
     183/** Check if the IPC call is an Ethernet message.
     184 *
     185 * @param[in] call IPC call to be checked.
     186 *
    204187 */
    205188#define IS_NET_ETH_MESSAGE(call) \
    206         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     189        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_ETH_FIRST, NET_ETH_LAST)
     190
     191/** Check if the IPC call is an ICMP message.
     192 *
     193 * @param[in] call IPC call to be checked.
     194 *
    210195 */
    211196#define IS_NET_ICMP_MESSAGE(call) \
    212         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     197        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_ICMP_FIRST, NET_ICMP_LAST)
     198
     199/** Check if the IPC call is an inter-network layer message.
     200 *
     201 * @param[in] call IPC call to be checked.
     202 *
    217203 */
    218204#define IS_NET_IL_MESSAGE(call) \
    219         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     205        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_IL_FIRST, NET_IL_LAST)
     206
     207/** Check if the IPC call is an IP message.
     208 *
     209 * @param[in] call IPC call to be checked.
     210 *
    223211 */
    224212#define IS_NET_IP_MESSAGE(call) \
    225         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     213        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_IP_FIRST, NET_IP_LAST)
     214
     215/** Check if the IPC call is a generic networking message.
     216 *
     217 * @param[in] call IPC call to be checked.
     218 *
    230219 */
    231220#define IS_NET_NET_MESSAGE(call) \
    232         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     221        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_NET_FIRST, NET_NET_LAST)
     222
     223/** Check if the IPC call is a network interface layer message.
     224 *
     225 * @param[in] call IPC call to be checked.
     226 *
    237227 */
    238228#define IS_NET_NIL_MESSAGE(call) \
    239         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     229        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_NIL_FIRST, NET_NIL_LAST)
     230
     231/** Check if the IPC call is a packet manaagement system message.
     232 *
     233 * @param[in] call IPC call to be checked.
     234 *
    244235 */
    245236#define IS_NET_PACKET_MESSAGE(call) \
    246         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     237        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_PACKET_FIRST, NET_PACKET_LAST)
     238
     239/** Check if the IPC call is a socket message.
     240 *
     241 * @param[in] call IPC call to be checked.
     242 *
    250243 */
    251244#define IS_NET_SOCKET_MESSAGE(call) \
    252         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     245        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_SOCKET_FIRST, NET_SOCKET_LAST)
     246
     247/** Check if the IPC call is a TCP message.
     248 *
     249 * @param[in] call IPC call to be checked.
     250 *
    256251 */
    257252#define IS_NET_TCP_MESSAGE(call) \
    258         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     253        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_TCP_FIRST, NET_TCP_LAST)
     254
     255/** Check if the IPC call is a transport layer message.
     256 *
     257 * @param[in] call IPC call to be checked.
     258 *
    262259 */
    263260#define IS_NET_TL_MESSAGE(call) \
    264         IS_IN_INTERVAL(IPC_GET_METHOD(*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.
     261        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_TL_FIRST, NET_TL_LAST)
     262
     263/** Check if the IPC call is a UDP message.
     264 *
     265 * @param[in] call IPC call to be checked.
     266 *
    268267 */
    269268#define IS_NET_UDP_MESSAGE(call) \
    270         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_UDP_FIRST, NET_UDP_LAST)
     269        IS_IN_INTERVAL(IPC_GET_IMETHOD(call), NET_UDP_FIRST, NET_UDP_LAST)
    271270
    272271/*@}*/
    … …  
    275274/*@{*/
    276275
    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                 ipcarg_t argument = (ipcarg_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                 ipcarg_t argument = (ipcarg_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                 ipcarg_t argument = (ipcarg_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                 ipcarg_t argument = (ipcarg_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                 ipcarg_t argument = (ipcarg_t) (value); \
    409                 IPC_SET_ARG4(*answer, argument); \
    410         } while (0)
     276/** Return the device identifier message argument.
     277 *
     278 * @param[in] call Message call structure.
     279 *
     280 */
     281#define IPC_GET_DEVICE(call)  ((device_id_t) IPC_GET_ARG1(call))
     282
     283/** Return the packet identifier message argument.
     284 *
     285 * @param[in] call Message call structure.
     286 *
     287 */
     288#define IPC_GET_PACKET(call)  ((packet_id_t) IPC_GET_ARG2(call))
     289
     290/** Return the count message argument.
     291 *
     292 * @param[in] call Message call structure.
     293 *
     294 */
     295#define IPC_GET_COUNT(call)  ((size_t) IPC_GET_ARG2(call))
     296
     297/** Return the device state message argument.
     298 *
     299 * @param[in] call Message call structure.
     300 *
     301 */
     302#define IPC_GET_STATE(call)  ((device_state_t) IPC_GET_ARG2(call))
     303
     304/** Return the maximum transmission unit message argument.
     305 *
     306 * @param[in] call Message call structure.
     307 *
     308 */
     309#define IPC_GET_MTU(call)  ((size_t) IPC_GET_ARG2(call))
     310
     311/** Return the device driver service message argument.
     312 *
     313 * @param[in] call Message call structure.
     314 *
     315 */
     316#define IPC_GET_SERVICE(call)  ((services_t) IPC_GET_ARG3(call))
     317
     318/** Return the target service message argument.
     319 *
     320 * @param[in] call Message call structure.
     321 *
     322 */
     323#define IPC_GET_TARGET(call)  ((services_t) IPC_GET_ARG3(call))
     324
     325/** Return the sender service message argument.
     326 *
     327 * @param[in] call Message call structure.
     328 *
     329 */
     330#define IPC_GET_SENDER(call)  ((services_t) IPC_GET_ARG3(call))
     331
     332/** Return the error service message argument.
     333 &
     334 * @param[in] call Message call structure.
     335 *
     336 */
     337#define IPC_GET_ERROR(call)  ((services_t) IPC_GET_ARG4(call))
     338
     339/** Return the phone message argument.
     340 *
     341 * @param[in] call Message call structure.
     342 *
     343 */
     344#define IPC_GET_PHONE(call)  ((int) IPC_GET_ARG5(call))
     345
     346/** Set the device identifier in the message answer.
     347 *
     348 * @param[out] answer Message answer structure.
     349 * @param[in]  value  Value to set.
     350 *
     351 */
     352#define IPC_SET_DEVICE(answer, value)  IPC_SET_ARG1(answer, (sysarg_t) (value))
     353
     354/** Set the minimum address length in the message answer.
     355 *
     356 * @param[out] answer Message answer structure.
     357 * @param[in]  value  Value to set.
     358 *
     359 */
     360#define IPC_SET_ADDR(answer, value)  IPC_SET_ARG1(answer, (sysarg_t) (value))
     361
     362/** Set the minimum prefix size in the message answer.
     363 *
     364 * @param[out] answer Message answer structure.
     365 * @param[in]  value  Value to set.
     366 *
     367 */
     368#define IPC_SET_PREFIX(answer, value)  IPC_SET_ARG2(answer, (sysarg_t) (value))
     369
     370/** Set the maximum content size in the message answer.
     371 *
     372 * @param[out] answer Message answer structure.
     373 * @param[in]  value  Value to set.
     374 *
     375 */
     376#define IPC_SET_CONTENT(answer, value)  IPC_SET_ARG3(answer, (sysarg_t) (value))
     377
     378/** Set the minimum suffix size in the message answer.
     379 *
     380 * @param[out] answer Message answer structure.
     381 * @param[in]  value  Value to set.
     382 *
     383 */
     384#define IPC_SET_SUFFIX(answer, value)  IPC_SET_ARG4(answer, (sysarg_t) (value))
    411385
    412386/*@}*/

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

    rcead2aa r357b5f5  
    4747         */
    4848        NET_NETIF_PROBE = NET_NETIF_FIRST,
     49       
    4950        /** Send packet message.
    5051         * @see netif_send_msg()
    5152         */
    5253        NET_NETIF_SEND,
     54       
    5355        /** Start device message.
    5456         * @see netif_start_req()
    5557         */
    5658        NET_NETIF_START,
     59       
    5760        /** Get device usage statistics message.
    5861         * @see netif_stats_req()
    5962         */
    6063        NET_NETIF_STATS,
     64       
    6165        /** Stop device message.
    6266         * @see netif_stop_req()
    6367         */
    6468        NET_NETIF_STOP,
     69       
    6570        /** Get device address message.
    6671         * @see netif_get_addr_req()
    … …  
    7378
    7479/** Return the interrupt number message parameter.
    75  * @param[in] call The message call structure.
     80 *
     81 * @param[in] call Mmessage call structure.
     82 *
    7683 */
    77 #define NETIF_GET_IRQ(call) \
    78         ({ \
    79                 int irq = (int) IPC_GET_ARG2(*call); \
    80                 irq; \
    81         })
     84#define NETIF_GET_IRQ(call) ((int) IPC_GET_ARG2(call))
    8285
    8386/** Return the input/output address message parameter.
    84  * @param[in] call The message call structure.
     87 *
     88 * @param[in] call Message call structure.
     89 *
    8590 */
    86 #define NETIF_GET_IO(call) \
    87         ({ \
    88                 int io = (int) IPC_GET_ARG3(*call); \
    89                 io; \
    90         })
     91#define NETIF_GET_IO(call) ((void *) IPC_GET_ARG3(call))
    9192
    9293/*@}*/

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

    rcead2aa r357b5f5  
    7777
    7878/** 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         })
     79#define NIL_GET_PROTO(call)  ((services_t) IPC_GET_ARG2(call))
    8480
    8581/*@}*/

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

    rcead2aa r357b5f5  
    7070} packet_messages;
    7171
    72 /** Returns the protocol service message parameter. */
    73 #define ARP_GET_PROTO(call)     (services_t) IPC_GET_ARG2(*call)
     72/** Return the protocol service message parameter. */
     73#define ARP_GET_PROTO(call)  ((services_t) IPC_GET_ARG2(call))
    7474
    75 /** Returns the packet identifier message parameter. */
    76 #define IPC_GET_ID(call)        (packet_id_t) IPC_GET_ARG1(*call)
     75/** Return the packet identifier message parameter. */
     76#define IPC_GET_ID(call)  ((packet_id_t) IPC_GET_ARG1(call))
    7777
    78 /** Returns the maximal content length message parameter. */
    79 #define IPC_GET_CONTENT(call)   (size_t) IPC_GET_ARG1(*call)
     78/** Return the maximal content length message parameter. */
     79#define IPC_GET_CONTENT(call)  ((size_t) IPC_GET_ARG1(call))
    8080
    81 /** Returns the maximal address length message parameter. */
    82 #define IPC_GET_ADDR_LEN(call)  (size_t) IPC_GET_ARG2(*call)
     81/** Return the maximal address length message parameter. */
     82#define IPC_GET_ADDR_LEN(call)  ((size_t) IPC_GET_ARG2(call))
    8383
    84 /** Returns the maximal prefix length message parameter. */
    85 #define IPC_GET_PREFIX(call)    (size_t) IPC_GET_ARG3(*call)
     84/** Return the maximal prefix length message parameter. */
     85#define IPC_GET_PREFIX(call)  ((size_t) IPC_GET_ARG3(call))
    8686
    87 /** Returns the maximal suffix length message parameter. */
    88 #define IPC_GET_SUFFIX(call)    (size_t) IPC_GET_ARG4(*call)
     87/** Return the maximal suffix length message parameter. */
     88#define IPC_GET_SUFFIX(call)  ((size_t) IPC_GET_ARG4(call))
    8989
    9090#endif

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

    rcead2aa r357b5f5  
    4949        SERVICE_FHC,
    5050        SERVICE_OBIO,
     51        SERVICE_APIC,
     52        SERVICE_I8259,
    5153        SERVICE_CLIPBOARD,
    5254        SERVICE_NETWORKING,
    5355        SERVICE_LO,
    54         SERVICE_DP8390,
     56        SERVICE_NE2000,
    5557        SERVICE_ETHERNET,
    5658        SERVICE_NILDUMMY,

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

    rcead2aa r357b5f5  
    8484#define SOCKET_SET_SOCKET_ID(answer, value) \
    8585        do { \
    86                 ipcarg_t argument = (ipcarg_t) (value); \
     86                sysarg_t argument = (sysarg_t) (value); \
    8787                IPC_SET_ARG1(answer, argument); \
    8888        } while (0)
    … …  
    102102#define SOCKET_SET_READ_DATA_LENGTH(answer, value) \
    103103        do { \
    104                 ipcarg_t argument = (ipcarg_t) (value); \
     104                sysarg_t argument = (sysarg_t) (value); \
    105105                IPC_SET_ARG1(answer, argument); \
    106106        } while (0)
    … …  
    147147#define SOCKET_SET_DATA_FRAGMENT_SIZE(answer, value) \
    148148        do { \
    149                 ipcarg_t argument = (ipcarg_t) (value); \
     149                sysarg_t argument = (sysarg_t) (value); \
    150150                IPC_SET_ARG2(answer, argument); \
    151151        } while (0)
    … …  
    156156#define SOCKET_SET_ADDRESS_LENGTH(answer, value) \
    157157        do { \
    158                 ipcarg_t argument = (ipcarg_t) (value); \
     158                sysarg_t argument = (sysarg_t) (value); \
    159159                IPC_SET_ARG3(answer, argument);\
    160160        } while (0)
    … …  
    174174#define SOCKET_SET_HEADER_SIZE(answer, value) \
    175175        do { \
    176                 ipcarg_t argument = (ipcarg_t) (value); \
     176                sysarg_t argument = (sysarg_t) (value); \
    177177                IPC_SET_ARG3(answer, argument); \
    178178        } while (0)

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

    rcead2aa r357b5f5  
    4040#include <libarch/syscall.h>
    4141
     42#ifdef __32_BITS__
     43
     44/** Explicit 64-bit arguments passed to syscalls. */
     45typedef uint64_t sysarg64_t;
     46
     47#endif /* __32_BITS__ */
     48
    4249#define __SYSCALL0(id) \
    4350        __syscall0(0, 0, 0, 0, 0, 0, id)
    … …  
    5360        __syscall5(p1, p2, p3, p4, p5, 0, id)
    5461#define __SYSCALL6(id, p1, p2, p3, p4, p5, p6) \
    55     __syscall6(p1, p2, p3, p4, p5, p6, id)
     62        __syscall6(p1, p2, p3, p4, p5, p6, id)
    5663
    5764extern void __main(void *pcb_ptr);

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

    rcead2aa r357b5f5  
    4444extern void *memmove(void *, const void *, size_t);
    4545
    46 extern int bcmp(const char *, const char *, size_t);
     46extern int bcmp(const void *, const void *, size_t);
    4747
    4848#endif

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

    rcead2aa r357b5f5  
    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

    rcead2aa r357b5f5  
    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

    rcead2aa r357b5f5  
    4949#include <sys/time.h>
    5050
    51 /** Converts the data length between different types.
    52  *
    53  * @param[in] type_from The source type.
    54  * @param[in] type_to   The destination type.
    55  * @param[in] count     The number units of the source type size.
    56  */
    57 #define CONVERT_SIZE(type_from, type_to, count) \
    58         ((sizeof(type_from) / sizeof(type_to)) * (count))
    59 
    60 /** Registers the module service at the name server.
    61  *
    62  * @param[in] me        The module service.
    63  * @param[out] phonehash The created phone hash.
    64  */
    65 #define REGISTER_ME(me, phonehash) \
    66         ipc_connect_to_me(PHONE_NS, (me), 0, 0, (phonehash))
    67 
    6851/** Connect to the needed module function type definition.
    6952 *
    70  * @param[in] need      The needed module service.
    71  * @return              The phone of the needed service.
     53 * @param[in] need The needed module service.
     54 *
     55 * @return The phone of the needed service.
     56 *
    7257 */
    7358typedef int connect_module_t(services_t need);
    7459
    75 extern void answer_call(ipc_callid_t, int, ipc_call_t *, int);
    76 extern int bind_service(services_t, ipcarg_t, ipcarg_t, ipcarg_t,
     60extern void answer_call(ipc_callid_t, int, ipc_call_t *, size_t);
     61extern int bind_service(services_t, sysarg_t, sysarg_t, sysarg_t,
    7762    async_client_conn_t);
    78 extern int bind_service_timeout(services_t, ipcarg_t, ipcarg_t, ipcarg_t,
     63extern int bind_service_timeout(services_t, sysarg_t, sysarg_t, sysarg_t,
    7964    async_client_conn_t, suseconds_t);
    8065extern int connect_to_service(services_t);
    8166extern int connect_to_service_timeout(services_t, suseconds_t);
    82 extern int data_receive(void **, size_t *);
    8367extern int data_reply(void *, size_t);
    84 extern void refresh_answer(ipc_call_t *, int *);
     68extern void refresh_answer(ipc_call_t *, size_t *);
    8569
    8670#endif

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

    rcead2aa r357b5f5  
    6060extern int sendto(int, const void *, size_t, int, const struct sockaddr *,
    6161    socklen_t);
    62 extern int recv(int, void *, size_t, int);
    63 extern int recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
     62extern ssize_t recv(int, void *, size_t, int);
     63extern ssize_t recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
    6464extern int getsockopt(int, int, int, void *, size_t *);
    6565extern int setsockopt(int, int, int, const void *, size_t);

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

    rcead2aa r357b5f5  
    4646        } while (0)
    4747
     48#define core() \
     49        *((int *) 0) = 0xbadbad;
     50
    4851#define exit(status)  _exit((status))
    4952

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

    rcead2aa r357b5f5  
    4747extern task_id_t task_get_id(void);
    4848extern int task_set_name(const char *);
     49extern int task_kill(task_id_t);
     50
    4951extern task_id_t task_spawn(const char *, const char *const[], int *);
    5052extern int task_spawnv(task_id_t *, const char *path, const char *const []);
Note: See TracChangeset for help on using the changeset viewer.