Changeset 87b4baa in mainline for uspace/lib


Ignore:
Timestamp:
2010-12-17T20:16:46Z (15 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
424558a
Parents:
463e734 (diff), bbc74af7 (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
Files:
58 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/block/libblock.c

    r463e734 r87b4baa  
    862862static int get_block_size(int dev_phone, size_t *bsize)
    863863{
    864         ipcarg_t bs;
     864        sysarg_t bs;
    865865        int rc;
    866866
    … …  
    875875static int get_num_blocks(int dev_phone, aoff64_t *nblocks)
    876876{
    877         ipcarg_t nb_l, nb_h;
     877        sysarg_t nb_l, nb_h;
    878878        int rc;
    879879

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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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,
    … …  
    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
    … …  
    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];

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

    r463e734 r87b4baa  
    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:
    … …  
    807807 *
    808808 */
    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)
     809aid_t async_send_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     810    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
    811811{
    812812        amsg_t *msg = malloc(sizeof(*msg));
    … …  
    846846 *
    847847 */
    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,
     848aid_t async_send_slow(int phoneid, sysarg_t method, sysarg_t arg1,
     849    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    850850    ipc_call_t *dataptr)
    851851{
    … …  
    875875 *
    876876 */
    877 void async_wait_for(aid_t amsgid, ipcarg_t *retval)
     877void async_wait_for(aid_t amsgid, sysarg_t *retval)
    878878{
    879879        amsg_t *msg = (amsg_t *) amsgid;
    … …  
    911911 *
    912912 */
    913 int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, suseconds_t timeout)
     913int async_wait_timeout(aid_t amsgid, sysarg_t *retval, suseconds_t timeout)
    914914{
    915915        amsg_t *msg = (amsg_t *) amsgid;
    … …  
    10231023 *
    10241024 */
    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)
     1025sysarg_t async_req_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     1026    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
     1027    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    10281028{
    10291029        ipc_call_t result;
    … …  
    10311031            &result);
    10321032       
    1033         ipcarg_t rc;
     1033        sysarg_t rc;
    10341034        async_wait_for(eid, &rc);
    10351035       
    … …  
    10721072 *
    10731073 */
    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)
     1074sysarg_t async_req_slow(int phoneid, sysarg_t method, sysarg_t arg1,
     1075    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     1076    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    10771077{
    10781078        ipc_call_t result;
    … …  
    10801080            &result);
    10811081       
    1082         ipcarg_t rc;
     1082        sysarg_t rc;
    10831083        async_wait_for(eid, &rc);
    10841084       
    … …  
    11131113 */
    11141114int
    1115 async_connect_me_to(int phoneid, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3)
     1115async_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
    11161116{
    11171117        int rc;
    1118         ipcarg_t newphid;
     1118        sysarg_t newphid;
    11191119
    11201120        rc = async_req_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL,
    … …  
    11401140 */
    11411141int
    1142 async_connect_me_to_blocking(int phoneid, ipcarg_t arg1, ipcarg_t arg2,
    1143     ipcarg_t arg3)
     1142async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
     1143    sysarg_t arg3)
    11441144{
    11451145        int rc;
    1146         ipcarg_t newphid;
     1146        sysarg_t newphid;
    11471147
    11481148        rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
    … …  
    11661166 * @return              Zero on success or a negative error code from errno.h.
    11671167 */
    1168 int async_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
     1168int async_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
    11691169    int *flags)
    11701170{
    11711171        int res;
    11721172        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);
     1173        res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
     1174            (sysarg_t) size, arg, NULL, &tmp_flags);
    11751175        if (flags)
    11761176                *flags = tmp_flags;
    … …  
    11991199
    12001200        *callid = async_get_call(&data);
    1201         if (IPC_GET_METHOD(data) != IPC_M_SHARE_IN)
     1201        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN)
    12021202                return 0;
    12031203        *size = (size_t) IPC_GET_ARG2(data);
    … …  
    12311231int async_share_out_start(int phoneid, void *src, int flags)
    12321232{
    1233         return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
    1234             (ipcarg_t) flags);
     1233        return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
     1234            (sysarg_t) flags);
    12351235}
    12361236
    … …  
    12591259
    12601260        *callid = async_get_call(&data);
    1261         if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT)
     1261        if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT)
    12621262                return 0;
    12631263        *size = (size_t) IPC_GET_ARG2(data);
    … …  
    12921292int async_data_read_start(int phoneid, void *dst, size_t size)
    12931293{
    1294         return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
    1295             (ipcarg_t) size);
     1294        return async_req_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
     1295            (sysarg_t) size);
    12961296}
    12971297
    … …  
    13171317
    13181318        *callid = async_get_call(&data);
    1319         if (IPC_GET_METHOD(data) != IPC_M_DATA_READ)
     1319        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
    13201320                return 0;
    13211321        if (size)
    … …  
    13451345 *
    13461346 */
    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)
     1347int async_data_read_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     1348    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
    13491349{
    13501350        ipc_callid_t callid;
    … …  
    13691369        }
    13701370       
    1371         ipcarg_t rc;
     1371        sysarg_t rc;
    13721372        async_wait_for(msg, &rc);
    13731373       
    … …  
    13861386int async_data_write_start(int phoneid, const void *src, size_t size)
    13871387{
    1388         return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
    1389             (ipcarg_t) size);
     1388        return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
     1389            (sysarg_t) size);
    13901390}
    13911391
    … …  
    14121412       
    14131413        *callid = async_get_call(&data);
    1414         if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
     1414        if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
    14151415                return 0;
    14161416       
    … …  
    15311531 *
    15321532 */
    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)
     1533int async_data_write_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     1534    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
    15351535{
    15361536        ipc_callid_t callid;
    … …  
    15551555        }
    15561556       
    1557         ipcarg_t rc;
     1557        sysarg_t rc;
    15581558        async_wait_for(msg, &rc);
    15591559       

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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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/device/char.c

    r463e734 r87b4baa  
    7676        }
    7777       
    78         ipcarg_t rc;
     78        sysarg_t rc;
    7979        if (ret != EOK) {
    8080                async_wait_for(req, &rc);

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

    r463e734 r87b4baa  
    4040bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
    4141{
    42         ipcarg_t count = 0;
     42        sysarg_t count = 0;
    4343        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), GET_RESOURCE_LIST, &count);
    4444        hw_resources->count = count;

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

    r463e734 r87b4baa  
    9595        aid_t req = async_send_2(phone, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
    9696       
    97         ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
     97        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
    9898        if (retval != EOK) {
    9999                async_wait_for(req, NULL);
    … …  
    104104        async_set_client_connection(conn);
    105105       
    106         ipcarg_t callback_phonehash;
     106        sysarg_t callback_phonehash;
    107107        ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
    108108        async_wait_for(req, &retval);
    … …  
    155155        aid_t req = async_send_2(phone, DEVMAN_ADD_CHILD_DEVICE, parent_handle, match_count, &answer);
    156156
    157         ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
     157        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
    158158        if (retval != EOK) {
    159159                async_wait_for(req, NULL);
    … …  
    192192        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, devman_handle, &answer);
    193193       
    194         ipcarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
     194        sysarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
    195195        if (retval != EOK) {
    196196                async_wait_for(req, NULL);
    … …  
    268268            &answer);
    269269       
    270         ipcarg_t retval = async_data_write_start(phone, pathname, str_size(pathname));
     270        sysarg_t retval = async_data_write_start(phone, pathname, str_size(pathname));
    271271        if (retval != EOK) {
    272272                async_wait_for(req, NULL);

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

    r463e734 r87b4baa  
    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);
    … …  
    145145            &answer);
    146146       
    147         ipcarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
     147        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
    148148        if (retval != EOK) {
    149149                async_wait_for(req, NULL);
    … …  
    181181            &answer);
    182182       
    183         ipcarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
     183        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
    184184        if (retval != EOK) {
    185185                async_wait_for(req, NULL);
    … …  
    217217            &answer);
    218218       
    219         ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
     219        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
    220220        if (retval != EOK) {
    221221                async_wait_for(req, NULL);
    … …  
    247247                return phone;
    248248       
    249         ipcarg_t type;
     249        sysarg_t type;
    250250        int retval = async_req_1_1(phone, DEVMAP_HANDLE_PROBE, handle, &type);
    251251        if (retval != EOK)
    … …  
    277277                return -1;
    278278       
    279         ipcarg_t null_id;
     279        sysarg_t null_id;
    280280        int retval = async_req_0_1(phone, DEVMAP_NULL_CREATE, &null_id);
    281281        if (retval != EOK)
    … …  
    292292                return;
    293293       
    294         async_req_1_0(phone, DEVMAP_NULL_DESTROY, (ipcarg_t) null_id);
     294        async_req_1_0(phone, DEVMAP_NULL_DESTROY, (sysarg_t) null_id);
    295295}
    296296
    297297static size_t devmap_count_namespaces_internal(int phone)
    298298{
    299         ipcarg_t count;
     299        sysarg_t count;
    300300        int retval = async_req_0_1(phone, DEVMAP_GET_NAMESPACE_COUNT, &count);
    301301        if (retval != EOK)
    … …  
    307307static size_t devmap_count_devices_internal(int phone, devmap_handle_t ns_handle)
    308308{
    309         ipcarg_t count;
     309        sysarg_t count;
    310310        int retval = async_req_1_1(phone, DEVMAP_GET_DEVICE_COUNT, ns_handle, &count);
    311311        if (retval != EOK)
    … …  
    375375                }
    376376               
    377                 ipcarg_t retval;
     377                sysarg_t retval;
    378378                async_wait_for(req, &retval);
    379379                async_serialize_end();
    … …  
    427427                }
    428428               
    429                 ipcarg_t retval;
     429                sysarg_t retval;
    430430                async_wait_for(req, &retval);
    431431                async_serialize_end();

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

    r463e734 r87b4baa  
    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/io/console.c

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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/ipc.c

    r463e734 r87b4baa  
    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/loader.c

    r463e734 r87b4baa  
    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/net/icmp_api.c

    r463e734 r87b4baa  
    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
    9191        // send the address

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

    r463e734 r87b4baa  
    6767                switch (answer_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);
    … …  
    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
    … …  
    283243                IPC_SET_RETVAL(*answer, 0);
    284244                // 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/socket_client.c

    r463e734 r87b4baa  
    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:
    … …  
    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);
    … …  
    278278        }
    279279
    280         ipc_answer_0(callid, (ipcarg_t) rc);
     280        ipc_answer_0(callid, (sysarg_t) rc);
    281281        goto loop;
    282282}
    … …  
    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
    … …  
    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)
    … …  
    540540        // request the message
    541541        message_id = async_send_3(socket->phone, message,
    542             (ipcarg_t) socket->socket_id, arg2, socket->service, NULL);
     542            (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
    543543        // send the address
    544544        async_data_write_start(socket->phone, data, datalength);
    … …  
    600600        // 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;
    … …  
    683683        // 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
    … …  
    782782        // 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);
    … …  
    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;
    … …  
    855855        // 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);
     859            socket->service, (sysarg_t) flags, fragments, &answer);
    860860
    861861        // send the address if given
    … …  
    973973 */
    974974static int
    975 recvfrom_core(ipcarg_t message, int socket_id, void *data, size_t datalength,
     975recvfrom_core(sysarg_t message, int socket_id, void *data, size_t datalength,
    976976    int flags, struct sockaddr *fromaddr, socklen_t *addrlen)
    977977{
    978978        socket_t *socket;
    979979        aid_t message_id;
    980         ipcarg_t ipc_result;
     980        sysarg_t ipc_result;
    981981        int result;
    982982        size_t fragments;
    … …  
    10311031                // request packet data
    10321032                message_id = async_send_4(socket->phone, message,
    1033                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1034                     (ipcarg_t) flags, &answer);
     1033                    (sysarg_t) socket->socket_id, 0, socket->service,
     1034                    (sysarg_t) flags, &answer);
    10351035
    10361036                // read the address if desired
    … …  
    10601060                // request packet data
    10611061                message_id = async_send_4(socket->phone, message,
    1062                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1063                     (ipcarg_t) flags, &answer);
     1062                    (sysarg_t) socket->socket_id, 0, socket->service,
     1063                    (sysarg_t) flags, &answer);
    10641064
    10651065                // read the address if desired
    … …  
    11601160        socket_t *socket;
    11611161        aid_t message_id;
    1162         ipcarg_t result;
     1162        sysarg_t result;
    11631163
    11641164        if (!value || !optlen)
    … …  
    11791179        // request option value
    11801180        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
    1181             (ipcarg_t) socket->socket_id, (ipcarg_t) optname, socket->service,
     1181            (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
    11821182            NULL);
    11831183
    … …  
    12141214        // send the value
    12151215        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT,
    1216             (ipcarg_t) optname, value, optlen);
     1216            (sysarg_t) optname, value, optlen);
    12171217}
    12181218

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

    r463e734 r87b4baa  
    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
    … …  
    211217int task_wait(task_id_t id, task_exit_t *texit, int *retval)
    212218{
    213         ipcarg_t te, rv;
     219        sysarg_t te, rv;
    214220        int rc;
    215221

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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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/generic_field.h

    r463e734 r87b4baa  
    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/async.h

    r463e734 r87b4baa  
    8484            (arg5), (dataptr))
    8585
    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,
     86extern aid_t async_send_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     87    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr);
     88extern aid_t async_send_slow(int phoneid, sysarg_t method, sysarg_t arg1,
     89    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
    9090    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,
     91extern void async_wait_for(aid_t amsgid, sysarg_t *result);
     92extern int async_wait_timeout(aid_t amsgid, sysarg_t *retval,
    9393    suseconds_t timeout);
    9494
    95 extern fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid,
     95extern fid_t async_new_connection(sysarg_t in_phone_hash, ipc_callid_t callid,
    9696    ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *));
    9797extern void async_usleep(suseconds_t timeout);
    … …  
    242242            (arg5), (rc1), (rc2), (rc3), (rc4), (rc5))
    243243
    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);
     244extern sysarg_t async_req_fast(int phoneid, sysarg_t method, sysarg_t arg1,
     245    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
     246    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5);
     247extern sysarg_t async_req_slow(int phoneid, sysarg_t method, sysarg_t arg1,
     248    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     249    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5);
    250250
    251251static inline void async_serialize_start(void)
    … …  
    259259}
    260260
    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);
     261extern int async_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
     262extern int async_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);
    263263
    264264/*
    … …  
    274274        async_share_in_start((phoneid), (dst), (size), (arg), (flags))
    275275
    276 extern int async_share_in_start(int, void *, size_t, ipcarg_t, int *);
     276extern int async_share_in_start(int, void *, size_t, sysarg_t, int *);
    277277extern int async_share_in_receive(ipc_callid_t *, size_t *);
    278278extern int async_share_in_finalize(ipc_callid_t, void *, int );
    … …  
    314314extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    315315
    316 extern int async_data_read_forward_fast(int, ipcarg_t, ipcarg_t, ipcarg_t,
    317     ipcarg_t, ipcarg_t, ipc_call_t *);
     316extern int async_data_read_forward_fast(int, sysarg_t, sysarg_t, sysarg_t,
     317    sysarg_t, sysarg_t, ipc_call_t *);
    318318
    319319/*
    … …  
    356356extern void async_data_write_void(const int);
    357357
    358 extern int async_data_write_forward_fast(int, ipcarg_t, ipcarg_t, ipcarg_t,
    359     ipcarg_t, ipcarg_t, ipc_call_t *);
     358extern int async_data_write_forward_fast(int, sysarg_t, sysarg_t, sysarg_t,
     359    sysarg_t, sysarg_t, ipc_call_t *);
    360360
    361361#endif

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

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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/io/console.h

    r463e734 r87b4baa  
    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

    r463e734 r87b4baa  
    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/devman.h

    r463e734 r87b4baa  
    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.

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

    r463e734 r87b4baa  
    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/ip.h

    r463e734 r87b4baa  
    9393#define IP_SET_HEADERLEN(answer, value) \
    9494        do { \
    95                 ipcarg_t argument = (ipcarg_t) (value); \
     95                sysarg_t argument = (sysarg_t) (value); \
    9696                IPC_SET_ARG2(*answer, argument); \
    9797        } while (0)

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

    r463e734 r87b4baa  
    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/net.h

    r463e734 r87b4baa  
    192192 */
    193193#define IS_NET_MESSAGE(call) \
    194         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_FIRST, NET_LAST)
     194        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_FIRST, NET_LAST)
    195195
    196196/** Returns a value indicating whether the IPC call is an ARP message.
    … …  
    198198 */
    199199#define IS_NET_ARP_MESSAGE(call) \
    200         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_ARP_FIRST, NET_ARP_LAST)
     200        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_ARP_FIRST, NET_ARP_LAST)
    201201
    202202/** Returns a value indicating whether the IPC call is an Ethernet message.
    … …  
    204204 */
    205205#define IS_NET_ETH_MESSAGE(call) \
    206         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_ETH_FIRST, NET_ETH_LAST)
     206        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_ETH_FIRST, NET_ETH_LAST)
    207207
    208208/** Returns a value indicating whether the IPC call is an ICMP message.
    … …  
    210210 */
    211211#define IS_NET_ICMP_MESSAGE(call) \
    212         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_ICMP_FIRST, NET_ICMP_LAST)
     212        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_ICMP_FIRST, NET_ICMP_LAST)
    213213
    214214/** Returns a value indicating whether the IPC call is an inter-network layer
    … …  
    217217 */
    218218#define IS_NET_IL_MESSAGE(call) \
    219         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_IL_FIRST, NET_IL_LAST)
     219        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_IL_FIRST, NET_IL_LAST)
    220220
    221221/** Returns a value indicating whether the IPC call is an IP message.
    … …  
    223223 */
    224224#define IS_NET_IP_MESSAGE(call) \
    225         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_IP_FIRST, NET_IP_LAST)
     225        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_IP_FIRST, NET_IP_LAST)
    226226
    227227/** Returns a value indicating whether the IPC call is a generic networking
    … …  
    230230 */
    231231#define IS_NET_NET_MESSAGE(call) \
    232         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_NET_FIRST, NET_NET_LAST)
     232        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_NET_FIRST, NET_NET_LAST)
    233233
    234234/** Returns a value indicating whether the IPC call is a network interface layer
    … …  
    237237 */
    238238#define IS_NET_NIL_MESSAGE(call) \
    239         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_NIL_FIRST, NET_NIL_LAST)
     239        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_NIL_FIRST, NET_NIL_LAST)
    240240
    241241/** Returns a value indicating whether the IPC call is a packet manaagement
    … …  
    244244 */
    245245#define IS_NET_PACKET_MESSAGE(call) \
    246         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_PACKET_FIRST, NET_PACKET_LAST)
     246        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_PACKET_FIRST, NET_PACKET_LAST)
    247247
    248248/** Returns a value indicating whether the IPC call is a socket message.
    … …  
    250250 */
    251251#define IS_NET_SOCKET_MESSAGE(call) \
    252         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_SOCKET_FIRST, NET_SOCKET_LAST)
     252        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_SOCKET_FIRST, NET_SOCKET_LAST)
    253253
    254254/** Returns a value indicating whether the IPC call is a TCP message.
    … …  
    256256 */
    257257#define IS_NET_TCP_MESSAGE(call) \
    258         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_TCP_FIRST, NET_TCP_LAST)
     258        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_TCP_FIRST, NET_TCP_LAST)
    259259
    260260/** Returns a value indicating whether the IPC call is a transport layer message.
    … …  
    262262 */
    263263#define IS_NET_TL_MESSAGE(call) \
    264         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_TL_FIRST, NET_TL_LAST)
     264        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_TL_FIRST, NET_TL_LAST)
    265265
    266266/** Returns a value indicating whether the IPC call is a UDP message.
    … …  
    268268 */
    269269#define IS_NET_UDP_MESSAGE(call) \
    270         IS_IN_INTERVAL(IPC_GET_METHOD(*call), NET_UDP_FIRST, NET_UDP_LAST)
     270        IS_IN_INTERVAL(IPC_GET_IMETHOD(*call), NET_UDP_FIRST, NET_UDP_LAST)
    271271
    272272/*@}*/
    … …  
    370370#define IPC_SET_DEVICE(answer, value) \
    371371        do { \
    372                 ipcarg_t argument = (ipcarg_t) (value); \
     372                sysarg_t argument = (sysarg_t) (value); \
    373373                IPC_SET_ARG1(*answer, argument); \
    374374        } while (0)
    … …  
    379379#define IPC_SET_ADDR(answer, value) \
    380380        do { \
    381                 ipcarg_t argument = (ipcarg_t) (value); \
     381                sysarg_t argument = (sysarg_t) (value); \
    382382                IPC_SET_ARG1(*answer, argument); \
    383383        } while (0)
    … …  
    388388#define IPC_SET_PREFIX(answer, value) \
    389389        do { \
    390                 ipcarg_t argument = (ipcarg_t) (value); \
     390                sysarg_t argument = (sysarg_t) (value); \
    391391                IPC_SET_ARG2(*answer, argument); \
    392392        } while (0)
    … …  
    397397#define IPC_SET_CONTENT(answer, value) \
    398398        do { \
    399                 ipcarg_t argument = (ipcarg_t) (value); \
     399                sysarg_t argument = (sysarg_t) (value); \
    400400                IPC_SET_ARG3(*answer, argument); \
    401401        } while (0)
    … …  
    406406#define IPC_SET_SUFFIX(answer, value) \
    407407        do { \
    408                 ipcarg_t argument = (ipcarg_t) (value); \
     408                sysarg_t argument = (sysarg_t) (value); \
    409409                IPC_SET_ARG4(*answer, argument); \
    410410        } while (0)

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

    r463e734 r87b4baa  
    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/ipc/vfs.h

    r463e734 r87b4baa  
    3636#define LIBC_IPC_VFS_H_
    3737
     38#include <ipc/ipc.h>
    3839#include <sys/types.h>
    39 #include <ipc/ipc.h>
     40#include <bool.h>
    4041
    4142#define FS_NAME_MAXLEN  20
    … …  
    5556        /** Unique identifier of the fs. */
    5657        char name[FS_NAME_MAXLEN + 1];
     58        bool concurrent_read_write;
     59        bool write_retains_size;
    5760} vfs_info_t;
    5861

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

    r463e734 r87b4baa  
    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/net/modules.h

    r463e734 r87b4baa  
    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 *
    … …  
    7457
    7558extern void answer_call(ipc_callid_t, int, ipc_call_t *, int);
    76 extern int bind_service(services_t, ipcarg_t, ipcarg_t, ipcarg_t,
     59extern int bind_service(services_t, sysarg_t, sysarg_t, sysarg_t,
    7760    async_client_conn_t);
    78 extern int bind_service_timeout(services_t, ipcarg_t, ipcarg_t, ipcarg_t,
     61extern int bind_service_timeout(services_t, sysarg_t, sysarg_t, sysarg_t,
    7962    async_client_conn_t, suseconds_t);
    8063extern int connect_to_service(services_t);
    8164extern int connect_to_service_timeout(services_t, suseconds_t);
    82 extern int data_receive(void **, size_t *);
    8365extern int data_reply(void *, size_t);
    8466extern void refresh_answer(ipc_call_t *, int *);

  • uspace/lib/clui/tinput.c

    r463e734 r87b4baa  
    140140static void tinput_update_origin(tinput_t *ti)
    141141{
    142         ipcarg_t width = ti->col0 + ti->nc;
    143         ipcarg_t rows = (width / ti->con_cols) + 1;
     142        sysarg_t width = ti->col0 + ti->nc;
     143        sysarg_t rows = (width / ti->con_cols) + 1;
    144144       
    145145        /* Update row0 if the screen scrolled. */
    … …  
    153153                return;
    154154       
    155         ipcarg_t new_width = ti->col0 + ti->nc + 1;
     155        sysarg_t new_width = ti->col0 + ti->nc + 1;
    156156        if (new_width % ti->con_cols == 0) {
    157157                /* Advancing to new line. */
    158                 ipcarg_t new_height = (new_width / ti->con_cols) + 1;
     158                sysarg_t new_height = (new_width / ti->con_cols) + 1;
    159159                if (new_height >= ti->con_rows) {
    160160                        /* Disallow text longer than 1 page for now. */
    … …  
    184184                return;
    185185       
    186         ipcarg_t new_width = ti->col0 + ti->nc + ilen;
    187         ipcarg_t new_height = (new_width / ti->con_cols) + 1;
     186        sysarg_t new_width = ti->col0 + ti->nc + ilen;
     187        sysarg_t new_height = (new_width / ti->con_cols) + 1;
    188188        if (new_height >= ti->con_rows) {
    189189                /* Disallow text longer than 1 page for now. */

  • uspace/lib/clui/tinput.h

    r463e734 r87b4baa  
    5151       
    5252        /** Screen coordinates of the top-left corner of the text field */
    53         ipcarg_t col0;
    54         ipcarg_t row0;
     53        sysarg_t col0;
     54        sysarg_t row0;
    5555       
    5656        /** Screen dimensions */
    57         ipcarg_t con_cols;
    58         ipcarg_t con_rows;
     57        sysarg_t con_cols;
     58        sysarg_t con_rows;
    5959       
    6060        /** Number of characters in @c buffer */

  • uspace/lib/drv/generic/dev_iface.c

    r463e734 r87b4baa  
    5454
    5555remote_iface_func_ptr_t
    56 get_remote_method(remote_iface_t *rem_iface, ipcarg_t iface_method_idx)
     56get_remote_method(remote_iface_t *rem_iface, sysarg_t iface_method_idx)
    5757{
    5858        if (iface_method_idx >= rem_iface->method_count) {

  • uspace/lib/drv/generic/driver.c

    r463e734 r87b4baa  
    8181static void driver_irq_handler(ipc_callid_t iid, ipc_call_t *icall)
    8282{
    83         int id = (int)IPC_GET_METHOD(*icall);
     83        int id = (int)IPC_GET_IMETHOD(*icall);
    8484        interrupt_context_t *ctx;
    8585       
    … …  
    200200                ipc_callid_t callid = async_get_call(&call);
    201201
    202                 switch (IPC_GET_METHOD(call)) {
     202                switch (IPC_GET_IMETHOD(call)) {
    203203                case IPC_M_PHONE_HUNGUP:
    204204                        cont = false;
    … …  
    254254                ipc_call_t call;
    255255                callid = async_get_call(&call);
    256                 ipcarg_t method = IPC_GET_METHOD(call);
     256                sysarg_t method = IPC_GET_IMETHOD(call);
    257257                int iface_idx;
    258258               
    … …  
    308308
    309309                        /* get the method of the remote interface */
    310                         ipcarg_t iface_method_idx = IPC_GET_ARG1(call);
     310                        sysarg_t iface_method_idx = IPC_GET_ARG1(call);
    311311                        remote_iface_func_ptr_t iface_method_ptr =
    312312                            get_remote_method(rem_iface, iface_method_idx);
    … …  
    346346{
    347347        /* Select interface */
    348         switch ((ipcarg_t) (IPC_GET_ARG1(*icall))) {
     348        switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
    349349        case DRIVER_DEVMAN:
    350350                /* handle PnP events from device manager */
    … …  
    418418                goto failure;
    419419
    420         goto leave;
     420        return EOK;
    421421
    422422failure:
    … …  
    431431        }
    432432
    433 leave:
    434433        return rc;
    435434}

  • uspace/lib/drv/include/driver.h

    r463e734 r87b4baa  
    7979
    8080remote_iface_t *get_remote_iface(int);
    81 remote_iface_func_ptr_t get_remote_method(remote_iface_t *, ipcarg_t);
     81remote_iface_func_ptr_t get_remote_method(remote_iface_t *, sysarg_t);
    8282
    8383

  • uspace/lib/fs/libfs.c

    r463e734 r87b4baa  
    155155        devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*request);
    156156        int res;
    157         ipcarg_t rc;
     157        sysarg_t rc;
    158158       
    159159        ipc_call_t call;
    … …  
    163163        callid = async_get_call(&call);
    164164        int mountee_phone = (int) IPC_GET_ARG1(call);
    165         if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) ||
     165        if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) ||
    166166            (mountee_phone < 0)) {
    167167                ipc_answer_0(callid, EINVAL);

  • uspace/lib/fs/libfs.h

    r463e734 r87b4baa  
    8686typedef struct {
    8787        int fs_handle;           /**< File system handle. */
    88         ipcarg_t vfs_phonehash;  /**< Initial VFS phonehash. */
     88        sysarg_t vfs_phonehash;  /**< Initial VFS phonehash. */
    8989        uint8_t *plb_ro;         /**< Read-only PLB view. */
    9090} fs_reg_t;

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

    r463e734 r87b4baa  
    5959    int state, services_t target)
    6060{
    61         async_msg_3(phone, (ipcarg_t) message, (ipcarg_t) device_id,
    62             (ipcarg_t) state, target);
     61        async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     62            (sysarg_t) state, target);
    6363       
    6464        return EOK;
    … …  
    8181    int arg2, services_t service)
    8282{
    83         return (int) async_req_3_0(phone, (ipcarg_t) message,
    84             (ipcarg_t) device_id, (ipcarg_t) arg2, (ipcarg_t) service);
     83        return (int) async_req_3_0(phone, (sysarg_t) message,
     84            (sysarg_t) device_id, (sysarg_t) arg2, (sysarg_t) service);
    8585}
    8686
    … …  
    103103{
    104104        aid_t message_id;
    105         ipcarg_t result;
     105        sysarg_t result;
    106106        int string;
    107107
    … …  
    110110
    111111        // request the address
    112         message_id = async_send_1(phone, (ipcarg_t) message,
    113             (ipcarg_t) device_id, NULL);
     112        message_id = async_send_1(phone, (sysarg_t) message,
     113            (sysarg_t) device_id, NULL);
    114114        string = measured_strings_return(phone, address, data, 1);
    115115        async_wait_for(message_id, &result);
    … …  
    143143                return EBADMEM;
    144144       
    145         ipcarg_t addr_len;
    146         ipcarg_t prefix;
    147         ipcarg_t content;
    148         ipcarg_t suffix;
    149        
    150         ipcarg_t result = async_req_1_4(phone, (ipcarg_t) message,
    151             (ipcarg_t) device_id, &addr_len, &prefix, &content, &suffix);
     145        sysarg_t addr_len;
     146        sysarg_t prefix;
     147        sysarg_t content;
     148        sysarg_t suffix;
     149       
     150        sysarg_t result = async_req_1_4(phone, (sysarg_t) message,
     151            (sysarg_t) device_id, &addr_len, &prefix, &content, &suffix);
    152152       
    153153        packet_dimension->prefix = (size_t) prefix;
    … …  
    175175{
    176176        if (error) {
    177                 async_msg_4(phone, (ipcarg_t) message, (ipcarg_t) device_id,
    178                     (ipcarg_t) packet_id, (ipcarg_t) target, (ipcarg_t) error);
     177                async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     178                    (sysarg_t) packet_id, (sysarg_t) target, (sysarg_t) error);
    179179        } else {
    180                 async_msg_3(phone, (ipcarg_t) message, (ipcarg_t) device_id,
    181                     (ipcarg_t) packet_id, (ipcarg_t) target);
     180                async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     181                    (sysarg_t) packet_id, (sysarg_t) target);
    182182        }
    183183       
    … …  
    201201{
    202202        if (error) {
    203                 async_msg_4(phone, (ipcarg_t) message, (ipcarg_t) device_id,
    204                     (ipcarg_t) packet_id, (ipcarg_t) sender, (ipcarg_t) error);
     203                async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     204                    (sysarg_t) packet_id, (sysarg_t) sender, (sysarg_t) error);
    205205        } else {
    206                 async_msg_3(phone, (ipcarg_t) message, (ipcarg_t) device_id,
    207                     (ipcarg_t) packet_id, (ipcarg_t) sender);
     206                async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     207                    (sysarg_t) packet_id, (sysarg_t) sender);
    208208        }
    209209       
    … …  
    237237{
    238238        aid_t message_id;
    239         ipcarg_t result;
     239        sysarg_t result;
    240240        int string;
    241241
    … …  
    246246
    247247        // request the translation
    248         message_id = async_send_3(phone, (ipcarg_t) message,
    249             (ipcarg_t) device_id, (ipcarg_t) count, (ipcarg_t) service, NULL);
     248        message_id = async_send_3(phone, (sysarg_t) message,
     249            (sysarg_t) device_id, (sysarg_t) count, (sysarg_t) service, NULL);
    250250        measured_strings_send(phone, configuration, count);
    251251        string = measured_strings_return(phone, translation, data, count);

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

    r463e734 r87b4baa  
    8686        }
    8787       
    88         ipcarg_t result;
     88        sysarg_t result;
    8989        async_wait_for(message, &result);
    9090       
    … …  
    116116        *packet = pm_find(packet_id);
    117117        if (!*packet) {
    118                 ipcarg_t size;
     118                sysarg_t size;
    119119               
    120120                rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
    … …  
    151151    size_t max_prefix, size_t max_suffix)
    152152{
    153         ipcarg_t packet_id;
    154         ipcarg_t size;
     153        sysarg_t packet_id;
     154        sysarg_t size;
    155155        int rc;
    156156       
    … …  
    182182packet_t *packet_get_1_remote(int phone, size_t content)
    183183{
    184         ipcarg_t packet_id;
    185         ipcarg_t size;
     184        sysarg_t packet_id;
     185        sysarg_t size;
    186186        int rc;
    187187       

  • uspace/lib/net/il/arp_remote.c

    r463e734 r87b4baa  
    8686{
    8787        aid_t message_id;
    88         ipcarg_t result;
     88        sysarg_t result;
    8989
    9090        message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS,
    91             (ipcarg_t) device_id, protocol, NULL);
     91            (sysarg_t) device_id, protocol, NULL);
    9292        measured_strings_send(arp_phone, address, 1);
    9393        async_wait_for(message_id, &result);
    … …  
    106106{
    107107        return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE,
    108             (ipcarg_t) device_id);
     108            (sysarg_t) device_id);
    109109}
    110110
    … …  
    136136{
    137137        aid_t message_id;
    138         ipcarg_t result;
     138        sysarg_t result;
    139139
    140140        message_id = async_send_3(arp_phone, NET_ARP_DEVICE,
    141             (ipcarg_t) device_id, protocol, netif, NULL);
     141            (sysarg_t) device_id, protocol, netif, NULL);
    142142        measured_strings_send(arp_phone, address, 1);
    143143        async_wait_for(message_id, &result);

  • uspace/lib/net/il/ip_remote.c

    r463e734 r87b4baa  
    6767{
    6868        return (int) async_req_4_0(ip_phone, NET_IP_ADD_ROUTE,
    69             (ipcarg_t) device_id, (ipcarg_t) gateway.s_addr,
    70             (ipcarg_t) address.s_addr, (ipcarg_t) netmask.s_addr);
     69            (sysarg_t) device_id, (sysarg_t) gateway.s_addr,
     70            (sysarg_t) address.s_addr, (sysarg_t) netmask.s_addr);
    7171}
    7272
    … …  
    8686    async_client_conn_t receiver)
    8787{
    88         return (int) bind_service(service, (ipcarg_t) protocol, me, service,
     88        return (int) bind_service(service, (sysarg_t) protocol, me, service,
    8989            receiver);
    9090}
    … …  
    151151        ipc_call_t answer;
    152152        aid_t message_id = async_send_1(ip_phone, NET_IP_GET_ROUTE,
    153             (ipcarg_t) protocol, &answer);
     153            (sysarg_t) protocol, &answer);
    154154       
    155155        if ((async_data_write_start(ip_phone, destination, addrlen) == EOK) &&
    … …  
    164164        }
    165165       
    166         ipcarg_t result;
     166        sysarg_t result;
    167167        async_wait_for(message_id, &result);
    168168       
    … …  
    244244{
    245245        return (int) async_req_2_0(ip_phone, NET_IP_SET_GATEWAY,
    246             (ipcarg_t) device_id, (ipcarg_t) gateway.s_addr);
     246            (sysarg_t) device_id, (sysarg_t) gateway.s_addr);
    247247}
    248248

  • uspace/lib/net/netif/netif_local.c

    r463e734 r87b4baa  
    366366       
    367367        *answer_count = 0;
    368         switch (IPC_GET_METHOD(*call)) {
     368        switch (IPC_GET_IMETHOD(*call)) {
    369369        case IPC_M_PHONE_HUNGUP:
    370370                return EOK;

  • uspace/lib/net/netif/netif_remote.c

    r463e734 r87b4baa  
    144144       
    145145        aid_t message_id = async_send_1(netif_phone, NET_NETIF_STATS,
    146             (ipcarg_t) device_id, NULL);
     146            (sysarg_t) device_id, NULL);
    147147        async_data_read_start(netif_phone, stats, sizeof(*stats));
    148148       
    149         ipcarg_t result;
     149        sysarg_t result;
    150150        async_wait_for(message_id, &result);
    151151       

  • uspace/lib/net/tl/icmp_remote.c

    r463e734 r87b4baa  
    6565    icmp_param_t mtu, packet_t *packet)
    6666{
    67         async_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (ipcarg_t) code,
    68             (ipcarg_t) packet_get_id(packet), (ipcarg_t) mtu);
     67        async_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (sysarg_t) code,
     68            (sysarg_t) packet_get_id(packet), (sysarg_t) mtu);
    6969        return EOK;
    7070}
    … …  
    8585{
    8686        async_msg_2(icmp_phone, NET_ICMP_SOURCE_QUENCH, 0,
    87             (ipcarg_t) packet_get_id(packet));
     87            (sysarg_t) packet_get_id(packet));
    8888        return EOK;
    8989}
    … …  
    104104int icmp_time_exceeded_msg(int icmp_phone, icmp_code_t code, packet_t *packet)
    105105{
    106         async_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (ipcarg_t) code,
    107             (ipcarg_t) packet_get_id(packet));
     106        async_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (sysarg_t) code,
     107            (sysarg_t) packet_get_id(packet));
    108108        return EOK;
    109109}
    … …  
    126126    icmp_param_t pointer, packet_t *packet)
    127127{
    128         async_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (ipcarg_t) code,
    129             (ipcarg_t) packet_get_id(packet), (ipcarg_t) pointer);
     128        async_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (sysarg_t) code,
     129            (sysarg_t) packet_get_id(packet), (sysarg_t) pointer);
    130130        return EOK;
    131131}

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

    r463e734 r87b4baa  
    327327
    328328        *answer_count = 0;
    329         switch (IPC_GET_METHOD(*call)) {
     329        switch (IPC_GET_IMETHOD(*call)) {
    330330        case IPC_M_PHONE_HUNGUP:
    331331                return EOK;
    … …  
    337337                        return ENOMEM;
    338338                *answer_count = 2;
    339                 IPC_SET_ARG1(*answer, (ipcarg_t) packet->packet_id);
    340                 IPC_SET_ARG2(*answer, (ipcarg_t) packet->length);
     339                IPC_SET_ARG1(*answer, (sysarg_t) packet->packet_id);
     340                IPC_SET_ARG2(*answer, (sysarg_t) packet->length);
    341341                return EOK;
    342342       
    … …  
    351351                        return ENOMEM;
    352352                *answer_count = 2;
    353                 IPC_SET_ARG1(*answer, (ipcarg_t) packet->packet_id);
    354                 IPC_SET_ARG2(*answer, (ipcarg_t) packet->length);
     353                IPC_SET_ARG1(*answer, (sysarg_t) packet->packet_id);
     354                IPC_SET_ARG2(*answer, (sysarg_t) packet->length);
    355355                return EOK;
    356356       
    … …  
    365365                if (!packet_is_valid(packet))
    366366                        return ENOENT;
    367                 IPC_SET_ARG1(*answer, (ipcarg_t) packet->length);
     367                IPC_SET_ARG1(*answer, (sysarg_t) packet->length);
    368368                *answer_count = 1;
    369369                return EOK;
Note: See TracChangeset for help on using the changeset viewer.