Changeset 25a179e in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2017-12-20T19:51:45Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f96b6c8
Parents:
d4a829e
Message:

IPC return values are always errno constants. Adjust types to reflect that.

In principle, IPC server is not allowed to return non-errno values via
the "main" return value, because kernel interprets it (e.g. EHANGUP).
It's still possible to return arbitrary additional return values alongside EOK,
which are not interpreted in normal communication.

Location:
uspace/lib/c/generic
Files:
29 edited

Legend:

Unmodified
Added
Removed

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

    rd4a829e r25a179e  
    205205        ipc_call_t *dataptr;
    206206       
    207         sysarg_t retval;
     207        int retval;
    208208} amsg_t;
    209209
    … …  
    332332                msg->destroyed = false;
    333333                msg->dataptr = NULL;
    334                 msg->retval = (sysarg_t) EINVAL;
     334                msg->retval = EINVAL;
    335335                awaiter_initialize(&msg->wdata);
    336336        }
    … …  
    860860            &answer);
    861861       
    862         sysarg_t ret;
     862        int ret;
    863863        async_wait_for(req, &ret);
    864864        if (ret != EOK)
    … …  
    17081708 *
    17091709 */
    1710 void async_wait_for(aid_t amsgid, sysarg_t *retval)
     1710void async_wait_for(aid_t amsgid, int *retval)
    17111711{
    17121712        assert(amsgid);
    … …  
    17541754 *
    17551755 */
    1756 int async_wait_timeout(aid_t amsgid, sysarg_t *retval, suseconds_t timeout)
     1756int async_wait_timeout(aid_t amsgid, int *retval, suseconds_t timeout)
    17571757{
    17581758        assert(amsgid);
    … …  
    19171917 *
    19181918 */
    1919 sysarg_t async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     1919int async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
    19201920    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
    19211921    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    … …  
    19281928            &result);
    19291929       
    1930         sysarg_t rc;
     1930        int rc;
    19311931        async_wait_for(aid, &rc);
    19321932       
    … …  
    19691969 *
    19701970 */
    1971 sysarg_t async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     1971int async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
    19721972    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
    19731973    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    … …  
    19801980            &result);
    19811981       
    1982         sysarg_t rc;
     1982        int rc;
    19831983        async_wait_for(aid, &rc);
    19841984       
    … …  
    20442044}
    20452045
    2046 sysarg_t async_answer_0(cap_handle_t chandle, sysarg_t retval)
     2046int async_answer_0(cap_handle_t chandle, int retval)
    20472047{
    20482048        return ipc_answer_0(chandle, retval);
    20492049}
    20502050
    2051 sysarg_t async_answer_1(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1)
     2051int async_answer_1(cap_handle_t chandle, int retval, sysarg_t arg1)
    20522052{
    20532053        return ipc_answer_1(chandle, retval, arg1);
    20542054}
    20552055
    2056 sysarg_t async_answer_2(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2056int async_answer_2(cap_handle_t chandle, int retval, sysarg_t arg1,
    20572057    sysarg_t arg2)
    20582058{
    … …  
    20602060}
    20612061
    2062 sysarg_t async_answer_3(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2062int async_answer_3(cap_handle_t chandle, int retval, sysarg_t arg1,
    20632063    sysarg_t arg2, sysarg_t arg3)
    20642064{
    … …  
    20662066}
    20672067
    2068 sysarg_t async_answer_4(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2068int async_answer_4(cap_handle_t chandle, int retval, sysarg_t arg1,
    20692069    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    20702070{
    … …  
    20722072}
    20732073
    2074 sysarg_t async_answer_5(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2074int async_answer_5(cap_handle_t chandle, int retval, sysarg_t arg1,
    20752075    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
    20762076{
    … …  
    21202120            &answer);
    21212121       
    2122         sysarg_t rc;
     2122        int rc;
    21232123        async_wait_for(req, &rc);
    21242124        if (rc != EOK)
    … …  
    21472147            msg, reply_received);
    21482148       
    2149         sysarg_t rc;
     2149        int rc;
    21502150        async_wait_for((aid_t) msg, &rc);
    21512151       
    … …  
    28862886        }
    28872887       
    2888         sysarg_t rc;
     2888        int rc;
    28892889        async_wait_for(msg, &rc);
    28902890       
    … …  
    30643064 *
    30653065 */
    3066 void async_data_write_void(sysarg_t retval)
     3066void async_data_write_void(int retval)
    30673067{
    30683068        cap_handle_t chandle;
    … …  
    31023102        }
    31033103       
    3104         sysarg_t rc;
     3104        int rc;
    31053105        async_wait_for(msg, &rc);
    31063106       

  • uspace/lib/c/generic/bd.c

    rd4a829e r25a179e  
    9898        }
    9999
    100         sysarg_t retval;
     100        int retval;
    101101        async_wait_for(req, &retval);
    102102
    … …  
    121121        }
    122122
    123         sysarg_t retval;
     123        int retval;
    124124        async_wait_for(req, &retval);
    125125
    … …  
    146146        }
    147147
    148         sysarg_t retval;
     148        int retval;
    149149        async_wait_for(req, &retval);
    150150        if (retval != EOK)

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

    rd4a829e r25a179e  
    104104        if (size == 0) {
    105105                async_exch_t *exch = clip_exchange_begin();
    106                 sysarg_t rc = async_req_1_0(exch, CLIPBOARD_PUT_DATA,
     106                int rc = async_req_1_0(exch, CLIPBOARD_PUT_DATA,
    107107                    CLIPBOARD_TAG_NONE);
    108108                clip_exchange_end(exch);
    … …  
    113113                aid_t req = async_send_1(exch, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA,
    114114                    NULL);
    115                 sysarg_t rc = async_data_write_start(exch, (void *) str, size);
     115                int rc = async_data_write_start(exch, (void *) str, size);
    116116                clip_exchange_end(exch);
    117117               
    118118                if (rc != EOK) {
    119                         sysarg_t rc_orig;
     119                        int rc_orig;
    120120                        async_wait_for(req, &rc_orig);
    121121                        if (rc_orig == EOK)
    … …  
    148148                sysarg_t size;
    149149                sysarg_t tag;
    150                 sysarg_t rc = async_req_0_2(exch, CLIPBOARD_CONTENT, &size, &tag);
     150                int rc = async_req_0_2(exch, CLIPBOARD_CONTENT, &size, &tag);
    151151               
    152152                clip_exchange_end(exch);
    … …  
    185185                       
    186186                        if (rc != EOK) {
    187                                 sysarg_t rc_orig;
     187                                int rc_orig;
    188188                                async_wait_for(req, &rc_orig);
    189189                                if (rc_orig == EOK)

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

    rd4a829e r25a179e  
    6060        async_exchange_end(exch);
    6161
    62         sysarg_t rc;
     62        int rc;
    6363        if (ret != EOK) {
    6464                async_forget(req);
    … …  
    9191        async_exchange_end(exch);
    9292
    93         sysarg_t rc;
     93        int rc;
    9494        if (ret != EOK) {
    9595                async_forget(req);

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

    rd4a829e r25a179e  
    4848        async_exchange_end(exch);
    4949       
    50         sysarg_t rc;
     50        int rc;
    5151        async_wait_for(req, &rc);
    5252       

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

    rd4a829e r25a179e  
    182182        ipc_call_t answer;
    183183        aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
    184         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     184        int retval = async_data_write_start(exch, name, str_size(name));
    185185       
    186186        devman_exchange_end(exch);
    … …  
    222222        aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
    223223            devh, match_count, &answer);
    224         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     224        int retval = async_data_write_start(exch, name, str_size(name));
    225225        if (retval != EOK) {
    226226                devman_exchange_end(exch);
    … …  
    272272        aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY,
    273273            devman_handle, &answer);
    274         sysarg_t retval = async_data_write_start(exch, cat_name,
     274        int retval = async_data_write_start(exch, cat_name,
    275275            str_size(cat_name));
    276276       
    … …  
    310310{
    311311        async_exch_t *exch;
    312         sysarg_t retval;
     312        int retval;
    313313       
    314314        exch = devman_exchange_begin_blocking(INTERFACE_DDF_DRIVER);
    … …  
    316316        devman_exchange_end(exch);
    317317       
    318         return (int) retval;
     318        return retval;
    319319}
    320320
    … …  
    325325                return ENOMEM;
    326326       
    327         sysarg_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_ONLINE, funh);
    328        
    329         devman_exchange_end(exch);
    330         return (int) retval;
     327        int retval = async_req_1_0(exch, DEVMAN_DRV_FUN_ONLINE, funh);
     328       
     329        devman_exchange_end(exch);
     330        return retval;
    331331}
    332332
    … …  
    337337                return ENOMEM;
    338338       
    339         sysarg_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_OFFLINE, funh);
    340        
    341         devman_exchange_end(exch);
    342         return (int) retval;
     339        int retval = async_req_1_0(exch, DEVMAN_DRV_FUN_OFFLINE, funh);
     340       
     341        devman_exchange_end(exch);
     342        return retval;
    343343}
    344344
    … …  
    374374        aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
    375375            &answer);
    376         sysarg_t retval = async_data_write_start(exch, pathname,
     376        int retval = async_data_write_start(exch, pathname,
    377377            str_size(pathname));
    378378       
    … …  
    405405        ipc_call_t dreply;
    406406        size_t act_size;
    407         sysarg_t dretval;
     407        int dretval;
    408408       
    409409        exch = devman_exchange_begin_blocking(INTERFACE_DDF_CLIENT);
    … …  
    421421        }
    422422       
    423         sysarg_t retval;
     423        int retval;
    424424        async_wait_for(req, &retval);
    425425       
    … …  
    476476                return ENOMEM;
    477477       
    478         sysarg_t retval = async_req_1_0(exch, DEVMAN_FUN_ONLINE, funh);
    479        
    480         devman_exchange_end(exch);
    481         return (int) retval;
     478        int retval = async_req_1_0(exch, DEVMAN_FUN_ONLINE, funh);
     479       
     480        devman_exchange_end(exch);
     481        return retval;
    482482}
    483483
    … …  
    488488                return ENOMEM;
    489489       
    490         sysarg_t retval = async_req_1_0(exch, DEVMAN_FUN_OFFLINE, funh);
    491        
    492         devman_exchange_end(exch);
    493         return (int) retval;
     490        int retval = async_req_1_0(exch, DEVMAN_FUN_OFFLINE, funh);
     491       
     492        devman_exchange_end(exch);
     493        return retval;
    494494}
    495495
    … …  
    510510        }
    511511       
    512         sysarg_t retval;
     512        int retval;
    513513        async_wait_for(req, &retval);
    514514       
    … …  
    580580                return ENOMEM;
    581581       
    582         sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
     582        int retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
    583583            funh, devh);
    584584       
    585585        devman_exchange_end(exch);
    586         return (int) retval;
     586        return retval;
    587587}
    588588
    … …  
    600600                return ENOMEM;
    601601       
    602         sysarg_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
     602        int retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
    603603            devh, funh);
    604604       
    605605        devman_exchange_end(exch);
    606         return (int) retval;
     606        return retval;
    607607}
    608608
    … …  
    613613                return ENOMEM;
    614614       
    615         sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
     615        int retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
    616616            sid, handle);
    617617       
    618618        devman_exchange_end(exch);
    619         return (int) retval;
     619        return retval;
    620620}
    621621
    … …  
    643643        ipc_call_t answer;
    644644        aid_t req = async_send_0(exch, DEVMAN_DRIVER_GET_HANDLE, &answer);
    645         sysarg_t retval = async_data_write_start(exch, drvname,
     645        int retval = async_data_write_start(exch, drvname,
    646646            str_size(drvname));
    647647       

  • uspace/lib/c/generic/dnsr.c

    rd4a829e r25a179e  
    9090            sizeof(inet_addr_t), &answer_addr);
    9191       
    92         sysarg_t retval_addr;
     92        int retval_addr;
    9393        async_wait_for(req_addr, &retval_addr);
    9494       
    … …  
    9797                async_forget(req);
    9898                free(info);
    99                 return (int) retval_addr;
     99                return retval_addr;
    100100        }
    101101       
    … …  
    107107        dnsr_exchange_end(exch);
    108108       
    109         sysarg_t retval_cname;
     109        int retval_cname;
    110110        async_wait_for(req_cname, &retval_cname);
    111111       
    … …  
    113113                async_forget(req);
    114114                free(info);
    115                 return (int) retval_cname;
     115                return retval_cname;
    116116        }
    117117       
    118         sysarg_t retval;
     118        int retval;
    119119        async_wait_for(req, &retval);
    120120       
    … …  
    122122                async_forget(req);
    123123                free(info);
    124                 return (int) retval;
     124                return retval;
    125125        }
    126126       
    … …  
    165165        }
    166166       
    167         sysarg_t retval;
     167        int retval;
    168168        async_wait_for(req, &retval);
    169169       
    170         return (int) retval;
     170        return retval;
    171171}
    172172
    … …  
    186186        }
    187187       
    188         sysarg_t retval;
     188        int retval;
    189189        async_wait_for(req, &retval);
    190190       
    191         return (int) retval;
     191        return retval;
    192192}
    193193

  • uspace/lib/c/generic/inet.c

    rd4a829e r25a179e  
    5858                return rc;
    5959       
    60         sysarg_t retval;
     60        int retval;
    6161        async_wait_for(req, &retval);
    6262       
    … …  
    141141        }
    142142       
    143         sysarg_t retval;
     143        int retval;
    144144        async_wait_for(req, &retval);
    145145       
    146         return (int) retval;
     146        return retval;
    147147}
    148148
    … …  
    170170        }
    171171       
    172         sysarg_t retval;
     172        int retval;
    173173        async_wait_for(req, &retval);
    174174       
    175         return (int) retval;
     175        return retval;
    176176}
    177177

  • uspace/lib/c/generic/inet/tcp.c

    rd4a829e r25a179e  
    7676                return rc;
    7777
    78         sysarg_t retval;
     78        int retval;
    7979        async_wait_for(req, &retval);
    8080
    … …  
    216216        exch = async_exchange_begin(tcp->sess);
    217217        aid_t req = async_send_0(exch, TCP_CONN_CREATE, &answer);
    218         sysarg_t rc = async_data_write_start(exch, (void *)epp,
     218        int rc = async_data_write_start(exch, (void *)epp,
    219219            sizeof(inet_ep2_t));
    220220        async_exchange_end(exch);
    221221
    222222        if (rc != EOK) {
    223                 sysarg_t rc_orig;
     223                int rc_orig;
    224224                async_wait_for(req, &rc_orig);
    225225                if (rc_orig != EOK)
    … …  
    260260
    261261        exch = async_exchange_begin(conn->tcp->sess);
    262         sysarg_t rc = async_req_1_0(exch, TCP_CONN_DESTROY, conn->id);
     262        int rc = async_req_1_0(exch, TCP_CONN_DESTROY, conn->id);
    263263        async_exchange_end(exch);
    264264
    … …  
    331331        exch = async_exchange_begin(tcp->sess);
    332332        aid_t req = async_send_0(exch, TCP_LISTENER_CREATE, &answer);
    333         sysarg_t rc = async_data_write_start(exch, (void *)ep,
     333        int rc = async_data_write_start(exch, (void *)ep,
    334334            sizeof(inet_ep_t));
    335335        async_exchange_end(exch);
    336336
    337337        if (rc != EOK) {
    338                 sysarg_t rc_orig;
     338                int rc_orig;
    339339                async_wait_for(req, &rc_orig);
    340340                if (rc_orig != EOK)
    … …  
    377377
    378378        exch = async_exchange_begin(lst->tcp->sess);
    379         sysarg_t rc = async_req_1_0(exch, TCP_LISTENER_DESTROY, lst->id);
     379        int rc = async_req_1_0(exch, TCP_LISTENER_DESTROY, lst->id);
    380380        async_exchange_end(exch);
    381381
    … …  
    451451{
    452452        async_exch_t *exch;
    453         sysarg_t rc;
     453        int rc;
    454454
    455455        exch = async_exchange_begin(conn->tcp->sess);
    … …  
    485485
    486486        exch = async_exchange_begin(conn->tcp->sess);
    487         sysarg_t rc = async_req_1_0(exch, TCP_CONN_SEND_FIN, conn->id);
     487        int rc = async_req_1_0(exch, TCP_CONN_SEND_FIN, conn->id);
    488488        async_exchange_end(exch);
    489489
    … …  
    501501
    502502        exch = async_exchange_begin(conn->tcp->sess);
    503         sysarg_t rc = async_req_1_0(exch, TCP_CONN_PUSH, conn->id);
     503        int rc = async_req_1_0(exch, TCP_CONN_PUSH, conn->id);
    504504        async_exchange_end(exch);
    505505
    … …  
    517517
    518518        exch = async_exchange_begin(conn->tcp->sess);
    519         sysarg_t rc = async_req_1_0(exch, TCP_CONN_RESET, conn->id);
     519        int rc = async_req_1_0(exch, TCP_CONN_RESET, conn->id);
    520520        async_exchange_end(exch);
    521521
    … …  
    562562        }
    563563
    564         sysarg_t retval;
     564        int retval;
    565565        async_wait_for(req, &retval);
    566566        if (retval != EOK) {
    … …  
    616616        }
    617617
    618         sysarg_t retval;
     618        int retval;
    619619        async_wait_for(req, &retval);
    620620        if (retval != EOK) {

  • uspace/lib/c/generic/inet/udp.c

    rd4a829e r25a179e  
    6363                return rc;
    6464
    65         sysarg_t retval;
     65        int retval;
    6666        async_wait_for(req, &retval);
    6767
    … …  
    173173        exch = async_exchange_begin(udp->sess);
    174174        aid_t req = async_send_0(exch, UDP_ASSOC_CREATE, &answer);
    175         sysarg_t rc = async_data_write_start(exch, (void *)epp,
     175        int rc = async_data_write_start(exch, (void *)epp,
    176176            sizeof(inet_ep2_t));
    177177        async_exchange_end(exch);
    178178
    179179        if (rc != EOK) {
    180                 sysarg_t rc_orig;
     180                int rc_orig;
    181181                async_wait_for(req, &rc_orig);
    182182                if (rc_orig != EOK)
    … …  
    220220
    221221        exch = async_exchange_begin(assoc->udp->sess);
    222         sysarg_t rc = async_req_1_0(exch, UDP_ASSOC_DESTROY, assoc->id);
     222        int rc = async_req_1_0(exch, UDP_ASSOC_DESTROY, assoc->id);
    223223        async_exchange_end(exch);
    224224
    … …  
    237237
    238238        exch = async_exchange_begin(assoc->udp->sess);
    239         sysarg_t rc = async_req_1_0(exch, UDP_ASSOC_SET_NOLOCAL, assoc->id);
     239        int rc = async_req_1_0(exch, UDP_ASSOC_SET_NOLOCAL, assoc->id);
    240240        async_exchange_end(exch);
    241241
    … …  
    260260        aid_t req = async_send_1(exch, UDP_ASSOC_SEND_MSG, assoc->id, NULL);
    261261
    262         sysarg_t rc = async_data_write_start(exch, (void *)dest,
     262        int rc = async_data_write_start(exch, (void *)dest,
    263263            sizeof(inet_ep_t));
    264264        if (rc != EOK) {
    … …  
    333333        }
    334334
    335         sysarg_t retval;
     335        int retval;
    336336        async_wait_for(req, &retval);
    337337        if (retval != EOK) {
    … …  
    398398        }
    399399
    400         sysarg_t retval;
     400        int retval;
    401401        async_wait_for(req, &retval);
    402402        if (retval != EOK)
    … …  
    420420
    421421        exch = async_exchange_begin(udp->sess);
    422         sysarg_t rc = async_req_0_0(exch, UDP_RMSG_DISCARD);
     422        int rc = async_req_0_0(exch, UDP_RMSG_DISCARD);
    423423        async_exchange_end(exch);
    424424

  • uspace/lib/c/generic/inetcfg.c

    rd4a829e r25a179e  
    5555        }
    5656
    57         sysarg_t retval;
     57        int retval;
    5858        async_wait_for(req, &retval);
    5959
    … …  
    158158        }
    159159       
    160         sysarg_t retval;
     160        int retval;
    161161        async_wait_for(req, &retval);
    162162       
    163163        *addr_id = IPC_GET_ARG1(answer);
    164164       
    165         return (int) retval;
     165        return retval;
    166166}
    167167
    … …  
    187187            sizeof(inet_naddr_t), &answer_naddr);
    188188       
    189         sysarg_t retval_naddr;
     189        int retval_naddr;
    190190        async_wait_for(req_naddr, &retval_naddr);
    191191       
    … …  
    193193                async_exchange_end(exch);
    194194                async_forget(req);
    195                 return (int) retval_naddr;
     195                return retval_naddr;
    196196        }
    197197       
    … …  
    203203        async_exchange_end(exch);
    204204       
    205         sysarg_t retval_name;
     205        int retval_name;
    206206        async_wait_for(req_name, &retval_name);
    207207       
    208208        if (retval_name != EOK) {
    209209                async_forget(req);
    210                 return (int) retval_name;
    211         }
    212        
    213         sysarg_t retval;
     210                return retval_name;
     211        }
     212       
     213        int retval;
    214214        async_wait_for(req, &retval);
    215215       
    216216        if (retval != EOK)
    217                 return (int) retval;
     217                return retval;
    218218       
    219219        size_t act_size = IPC_GET_ARG2(answer_name);
    … …  
    234234        ipc_call_t answer;
    235235        aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
    236         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     236        int retval = async_data_write_start(exch, name, str_size(name));
    237237
    238238        async_exchange_end(exch);
    … …  
    280280{
    281281        ipc_call_t dreply;
    282         sysarg_t dretval;
     282        int dretval;
    283283        size_t act_size;
    284284        char name_buf[LOC_NAME_MAXLEN + 1];
    … …  
    299299        }
    300300
    301         sysarg_t retval;
     301        int retval;
    302302        async_wait_for(req, &retval);
    303303
    … …  
    356356        }
    357357       
    358         sysarg_t retval;
     358        int retval;
    359359        async_wait_for(req, &retval);
    360360       
    361361        *sroute_id = IPC_GET_ARG1(answer);
    362362       
    363         return (int) retval;
     363        return retval;
    364364}
    365365
    … …  
    385385            sizeof(inet_naddr_t), &answer_dest);
    386386       
    387         sysarg_t retval_dest;
     387        int retval_dest;
    388388        async_wait_for(req_dest, &retval_dest);
    389389       
    … …  
    391391                async_exchange_end(exch);
    392392                async_forget(req);
    393                 return (int) retval_dest;
     393                return retval_dest;
    394394        }
    395395       
    … …  
    398398            sizeof(inet_addr_t), &answer_router);
    399399       
    400         sysarg_t retval_router;
     400        int retval_router;
    401401        async_wait_for(req_router, &retval_router);
    402402       
    … …  
    404404                async_exchange_end(exch);
    405405                async_forget(req);
    406                 return (int) retval_router;
     406                return retval_router;
    407407        }
    408408       
    … …  
    414414        async_exchange_end(exch);
    415415       
    416         sysarg_t retval_name;
     416        int retval_name;
    417417        async_wait_for(req_name, &retval_name);
    418418       
    419419        if (retval_name != EOK) {
    420420                async_forget(req);
    421                 return (int) retval_name;
    422         }
    423        
    424         sysarg_t retval;
     421                return retval_name;
     422        }
     423       
     424        int retval;
    425425        async_wait_for(req, &retval);
    426426       
    427427        if (retval != EOK)
    428                 return (int) retval;
     428                return retval;
    429429       
    430430        size_t act_size = IPC_GET_ARG2(answer_name);
    … …  
    444444        ipc_call_t answer;
    445445        aid_t req = async_send_0(exch, INETCFG_SROUTE_GET_ID, &answer);
    446         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     446        int retval = async_data_write_start(exch, name, str_size(name));
    447447
    448448        async_exchange_end(exch);

  • uspace/lib/c/generic/inetping.c

    rd4a829e r25a179e  
    110110        }
    111111
    112         sysarg_t retval;
     112        int retval;
    113113        async_wait_for(req, &retval);
    114114
    115         return (int) retval;
     115        return retval;
    116116}
    117117
    … …  
    136136        async_exchange_end(exch);
    137137
    138         sysarg_t retval_local;
     138        int retval_local;
    139139        async_wait_for(req_local, &retval_local);
    140140
    141141        if (retval_local != EOK) {
    142142                async_forget(req);
    143                 return (int) retval_local;
    144         }
    145 
    146         sysarg_t retval;
     143                return retval_local;
     144        }
     145
     146        int retval;
    147147        async_wait_for(req, &retval);
    148148
    149         return (int) retval;
     149        return retval;
    150150}
    151151

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

    rd4a829e r25a179e  
    114114        }
    115115
    116         sysarg_t retval;
     116        int retval;
    117117        async_wait_for(req, &retval);
    118118
    … …  
    166166        }
    167167
    168         sysarg_t retval;
     168        int retval;
    169169        async_wait_for(req, &retval);
    170170        if (retval != EOK) {

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

    rd4a829e r25a179e  
    188188                async_exchange_end(exch);
    189189               
    190                 sysarg_t rc;
     190                int rc;
    191191                async_wait_for(aid, &rc);
    192192               
    … …  
    202202                }
    203203        } else {
    204                 sysarg_t retval;
     204                int retval;
    205205                async_wait_for(ctrl->input_aid, &retval);
    206206               
    … …  
    208208               
    209209                if (retval != EOK) {
    210                         errno = (int) retval;
     210                        errno = retval;
    211211                        return false;
    212212                }
    … …  
    235235        }
    236236       
    237         sysarg_t retval;
     237        int retval;
    238238        int rc = async_wait_timeout(ctrl->input_aid, &retval, *timeout);
    239239        if (rc != EOK) {
    … …  
    246246       
    247247        if (retval != EOK) {
    248                 errno = (int) retval;
     248                errno = retval;
    249249                return false;
    250250        }

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

    rd4a829e r25a179e  
    8989            log, level, NULL);
    9090        int rc = async_data_write_start(exchange, message, str_size(message));
    91         sysarg_t reg_msg_rc;
     91        int reg_msg_rc;
    9292        async_wait_for(reg_msg, &reg_msg_rc);
    9393
    … …  
    199199            parent, &answer);
    200200        int rc = async_data_write_start(exchange, name, str_size(name));
    201         sysarg_t reg_msg_rc;
     201        int reg_msg_rc;
    202202        async_wait_for(reg_msg, &reg_msg_rc);
    203203

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

    rd4a829e r25a179e  
    111111            new_level, NULL);
    112112        rc = async_data_write_start(exchange, logname, str_size(logname));
    113         sysarg_t reg_msg_rc;
     113        int reg_msg_rc;
    114114        async_wait_for(reg_msg, &reg_msg_rc);
    115115
    … …  
    137137        rc = vfs_pass_handle(vfs_exch, vfs_root(), exchange);
    138138        vfs_exchange_end(vfs_exch);
    139         sysarg_t reg_msg_rc;
     139        int reg_msg_rc;
    140140        async_wait_for(reg_msg, &reg_msg_rc);
    141141

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

    rd4a829e r25a179e  
    9494        async_exchange_end(exch);
    9595       
    96         sysarg_t ret;
     96        int ret;
    9797        async_wait_for(req, &ret);
    9898       

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

    rd4a829e r25a179e  
    6868        async_exchange_end(exch);
    6969
    70         sysarg_t ret;
     70        int ret;
    7171        async_wait_for(req, &ret);
    7272
    … …  
    9191        async_exchange_end(exch);
    9292
    93         sysarg_t ret;
     93        int ret;
    9494        async_wait_for(req, &ret);
    9595
    … …  
    114114        async_exchange_end(exch);
    115115
    116         sysarg_t ret;
     116        int ret;
    117117        async_wait_for(req, &ret);
    118118
    … …  
    137137        async_exchange_end(exch);
    138138
    139         sysarg_t ret;
     139        int ret;
    140140        async_wait_for(req, &ret);
    141141
    … …  
    160160        async_exchange_end(exch);
    161161
    162         sysarg_t ret;
     162        int ret;
    163163        async_wait_for(req, &ret);
    164164

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

    rd4a829e r25a179e  
    6161        async_exchange_end(exch);
    6262
    63         sysarg_t ret;
     63        int ret;
    6464        async_wait_for(req, &ret);
    6565
    … …  
    105105        async_exchange_end(exch);
    106106       
    107         sysarg_t ret;
     107        int ret;
    108108        async_wait_for(req, &ret);
    109109       

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

    rd4a829e r25a179e  
    197197 *
    198198 */
    199 sysarg_t ipc_answer_fast(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     199int ipc_answer_fast(cap_handle_t chandle, int retval, sysarg_t arg1,
    200200    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    201201{
    … …  
    218218 *
    219219 */
    220 sysarg_t ipc_answer_slow(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     220int ipc_answer_slow(cap_handle_t chandle, int retval, sysarg_t arg1,
    221221    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
    222222{

  • uspace/lib/c/generic/iplink.c

    rd4a829e r25a179e  
    102102        }
    103103       
    104         sysarg_t retval;
    105         async_wait_for(req, &retval);
    106        
    107         return (int) retval;
     104        int retval;
     105        async_wait_for(req, &retval);
     106       
     107        return retval;
    108108}
    109109
    … …  
    131131        }
    132132       
    133         sysarg_t retval;
    134         async_wait_for(req, &retval);
    135        
    136         return (int) retval;
     133        int retval;
     134        async_wait_for(req, &retval);
     135       
     136        return retval;
    137137}
    138138
    … …  
    169169        }
    170170       
    171         sysarg_t retval;
    172         async_wait_for(req, &retval);
    173        
    174         return (int) retval;
     171        int retval;
     172        async_wait_for(req, &retval);
     173       
     174        return retval;
    175175}
    176176
    … …  
    191191        }
    192192       
    193         sysarg_t retval;
    194         async_wait_for(req, &retval);
    195        
    196         return (int) retval;
     193        int retval;
     194        async_wait_for(req, &retval);
     195       
     196        return retval;
    197197}
    198198
    … …  
    213213        }
    214214       
    215         sysarg_t retval;
    216         async_wait_for(req, &retval);
    217        
    218         return (int) retval;
     215        int retval;
     216        async_wait_for(req, &retval);
     217       
     218        return retval;
    219219}
    220220
    … …  
    234234        }
    235235       
    236         sysarg_t retval;
    237         async_wait_for(req, &retval);
    238        
    239         return (int) retval;
     236        int retval;
     237        async_wait_for(req, &retval);
     238       
     239        return retval;
    240240}
    241241

  • uspace/lib/c/generic/iplink_srv.c

    rd4a829e r25a179e  
    7878                async_answer_0(callid, rc);
    7979       
    80         async_answer_0(iid, (sysarg_t) rc);
     80        async_answer_0(iid, rc);
    8181}
    8282
    … …  
    9090
    9191        if (!async_data_write_receive(&callid, &size)) {
    92                 async_answer_0(callid, (sysarg_t) EREFUSED);
    93                 async_answer_0(iid, (sysarg_t) EREFUSED);
     92                async_answer_0(callid, EREFUSED);
     93                async_answer_0(iid, EREFUSED);
    9494        }
    9595
    … …  
    104104                async_answer_0(callid, rc);
    105105       
    106         async_answer_0(iid, (sysarg_t) rc);
     106        async_answer_0(iid, rc);
    107107}
    108108
    … …  
    127127        int rc = async_data_write_finalize(callid, &addr, size);
    128128        if (rc != EOK) {
    129                 async_answer_0(callid, (sysarg_t) rc);
    130                 async_answer_0(iid, (sysarg_t) rc);
     129                async_answer_0(callid, rc);
     130                async_answer_0(iid, rc);
    131131        }
    132132       
    133133        rc = srv->ops->addr_add(srv, &addr);
    134         async_answer_0(iid, (sysarg_t) rc);
     134        async_answer_0(iid, rc);
    135135}
    136136
    … …  
    155155        int rc = async_data_write_finalize(callid, &addr, size);
    156156        if (rc != EOK) {
    157                 async_answer_0(callid, (sysarg_t) rc);
    158                 async_answer_0(iid, (sysarg_t) rc);
     157                async_answer_0(callid, rc);
     158                async_answer_0(iid, rc);
    159159        }
    160160       
    161161        rc = srv->ops->addr_remove(srv, &addr);
    162         async_answer_0(iid, (sysarg_t) rc);
     162        async_answer_0(iid, rc);
    163163}
    164164
    … …  
    204204        int rc = async_data_write_finalize(callid, &sdu.dest, size);
    205205        if (rc != EOK) {
    206                 async_answer_0(callid, (sysarg_t) rc);
    207                 async_answer_0(iid, (sysarg_t) rc);
     206                async_answer_0(callid, rc);
     207                async_answer_0(iid, rc);
    208208        }
    209209       
    … …  
    321321        }
    322322       
    323         sysarg_t retval;
     323        int retval;
    324324        async_wait_for(req, &retval);
    325325        if (retval != EOK)
    … …  
    347347        }
    348348       
    349         sysarg_t retval;
     349        int retval;
    350350        async_wait_for(req, &retval);
    351351        if (retval != EOK)

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

    rd4a829e r25a179e  
    9494        ipc_call_t answer;
    9595        aid_t req = async_send_0(exch, LOADER_GET_TASKID, &answer);
    96         sysarg_t rc = async_data_read_start(exch, task_id, sizeof(task_id_t));
     96        int rc = async_data_read_start(exch, task_id, sizeof(task_id_t));
    9797       
    9898        async_exchange_end(exch);
    … …  
    131131        ipc_call_t answer;
    132132        aid_t req = async_send_0(exch, LOADER_SET_CWD, &answer);
    133         sysarg_t rc = async_data_write_start(exch, cwd, len);
     133        int rc = async_data_write_start(exch, cwd, len);
    134134       
    135135        async_exchange_end(exch);
    … …  
    161161        aid_t req = async_send_0(exch, LOADER_SET_PROGRAM, &answer);
    162162
    163         sysarg_t rc = async_data_write_start(exch, name, str_size(name) + 1);
     163        int rc = async_data_write_start(exch, name, str_size(name) + 1);
    164164        if (rc == EOK) {
    165165                async_exch_t *vfs_exch = vfs_exchange_begin();
    … …  
    252252        ipc_call_t answer;
    253253        aid_t req = async_send_0(exch, LOADER_SET_ARGS, &answer);
    254         sysarg_t rc = async_data_write_start(exch, (void *) arg_buf,
     254        int rc = async_data_write_start(exch, (void *) arg_buf,
    255255            buffer_size);
    256256       
    … …  
    283283        aid_t req = async_send_0(exch, LOADER_ADD_INBOX, NULL);
    284284       
    285         sysarg_t rc = async_data_write_start(exch, name, str_size(name) + 1);
     285        int rc = async_data_write_start(exch, name, str_size(name) + 1);
    286286        if (rc == EOK) {
    287287                rc = vfs_pass_handle(vfs_exch, file, exch);

  • uspace/lib/c/generic/loc.c

    rd4a829e r25a179e  
    121121                        return rc;
    122122               
    123                 sysarg_t retval;
     123                int retval;
    124124                async_wait_for(req, &retval);
    125125                if (retval != EOK)
    … …  
    245245        ipc_call_t answer;
    246246        aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer);
    247         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     247        int retval = async_data_write_start(exch, name, str_size(name));
    248248       
    249249        if (retval != EOK) {
    … …  
    278278        ipc_call_t answer;
    279279        aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
    280         sysarg_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
     280        int retval = async_data_write_start(exch, fqsn, str_size(fqsn));
    281281       
    282282        if (retval != EOK) {
    … …  
    314314{
    315315        async_exch_t *exch;
    316         sysarg_t retval;
     316        int retval;
    317317       
    318318        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    … …  
    339339        aid_t req = async_send_2(exch, LOC_SERVICE_GET_ID, flags, 0,
    340340            &answer);
    341         sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
     341        int retval = async_data_write_start(exch, fqdn, str_size(fqdn));
    342342       
    343343        loc_exchange_end(exch);
    … …  
    379379        ipc_call_t dreply;
    380380        size_t act_size;
    381         sysarg_t dretval;
     381        int dretval;
    382382       
    383383        *name = NULL;
    … …  
    397397        }
    398398       
    399         sysarg_t retval;
     399        int retval;
    400400        async_wait_for(req, &retval);
    401401       
    … …  
    472472        aid_t req = async_send_2(exch, LOC_NAMESPACE_GET_ID, flags, 0,
    473473            &answer);
    474         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     474        int retval = async_data_write_start(exch, name, str_size(name));
    475475       
    476476        loc_exchange_end(exch);
    … …  
    521521        aid_t req = async_send_0(exch, LOC_CATEGORY_GET_ID,
    522522            &answer);
    523         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     523        int retval = async_data_write_start(exch, name, str_size(name));
    524524       
    525525        loc_exchange_end(exch);
    … …  
    615615{
    616616        async_exch_t *exch;
    617         sysarg_t retval;
     617        int retval;
    618618       
    619619        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    … …  
    692692                }
    693693               
    694                 sysarg_t retval;
     694                int retval;
    695695                async_wait_for(req, &retval);
    696696               
    … …  
    741741                }
    742742               
    743                 sysarg_t retval;
     743                int retval;
    744744                async_wait_for(req, &retval);
    745745               
    … …  
    768768        }
    769769       
    770         sysarg_t retval;
     770        int retval;
    771771        async_wait_for(req, &retval);
    772772       

  • uspace/lib/c/generic/ns.c

    rd4a829e r25a179e  
    4848int service_register(service_t service)
    4949{
    50         sysarg_t retval;
     50        int retval;
    5151        ipc_call_t answer;
    5252       

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

    rd4a829e r25a179e  
    369369        assert(retval);
    370370
    371         sysarg_t rc;
     371        int rc;
    372372        async_wait_for(wait->aid, &rc);
    373373

  • uspace/lib/c/generic/vbd.c

    rd4a829e r25a179e  
    106106{
    107107        async_exch_t *exch;
    108         sysarg_t retval;
     108        int retval;
    109109        ipc_call_t answer;
    110110
    … …  
    183183        }
    184184
    185         sysarg_t retval;
     185        int retval;
    186186        async_wait_for(req, &retval);
    187187
    … …  
    259259{
    260260        async_exch_t *exch;
    261         sysarg_t retval;
     261        int retval;
    262262        ipc_call_t answer;
    263263
    … …  
    283283{
    284284        async_exch_t *exch;
    285         sysarg_t retval;
     285        int retval;
    286286        ipc_call_t answer;
    287287
    … …  
    338338{
    339339        async_exch_t *exch;
    340         sysarg_t retval;
     340        int retval;
    341341        ipc_call_t answer;
    342342

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

    rd4a829e r25a179e  
    375375    vfs_fs_probe_info_t *info)
    376376{
    377         sysarg_t rc;
     377        int rc;
    378378       
    379379        ipc_call_t answer;
    … …  
    616616    unsigned int flags, unsigned int instance, int *mountedfd)
    617617{
    618         sysarg_t rc, rc1;
     618        int rc, rc1;
    619619       
    620620        if (!mountedfd)
    … …  
    810810
    811811        sysarg_t ret;
    812         sysarg_t rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE, high, &ret);
     812        int rc = async_req_1_1(vfs_exch, VFS_IN_WAIT_HANDLE, high, &ret);
    813813
    814814        async_exchange_end(vfs_exch);
    … …  
    879879    ssize_t *nread)
    880880{
    881         sysarg_t rc;
     881        int rc;
    882882        ipc_call_t answer;
    883883        aid_t req;
    … …  
    920920int vfs_rename_path(const char *old, const char *new)
    921921{
    922         sysarg_t rc;
    923         sysarg_t rc_orig;
     922        int rc;
     923        int rc_orig;
    924924        aid_t req;
    925925       
    … …  
    10511051int vfs_stat(int file, struct stat *stat)
    10521052{
    1053         sysarg_t rc;
     1053        int rc;
    10541054        aid_t req;
    10551055       
    … …  
    10611061                vfs_exchange_end(exch);
    10621062               
    1063                 sysarg_t rc_orig;
     1063                int rc_orig;
    10641064                async_wait_for(req, &rc_orig);
    10651065               
    … …  
    11061106int vfs_statfs(int file, struct statfs *st)
    11071107{
    1108         sysarg_t rc, ret;
     1108        int rc, ret;
    11091109        aid_t req;
    11101110
    … …  
    11731173int vfs_unlink(int parent, const char *child, int expect)
    11741174{
    1175         sysarg_t rc;
     1175        int rc;
    11761176        aid_t req;
    11771177       
    … …  
    11831183        vfs_exchange_end(exch);
    11841184       
    1185         sysarg_t rc_orig;
     1185        int rc_orig;
    11861186        async_wait_for(req, &rc_orig);
    11871187       
    … …  
    12701270        ipc_call_t answer;
    12711271        aid_t req = async_send_2(exch, VFS_IN_WALK, parent, flags, &answer);
    1272         sysarg_t rc = async_data_write_start(exch, path, str_size(path));
     1272        int rc = async_data_write_start(exch, path, str_size(path));
    12731273        vfs_exchange_end(exch);
    12741274               
    1275         sysarg_t rc_orig;
     1275        int rc_orig;
    12761276        async_wait_for(req, &rc_orig);
    12771277
    … …  
    13431343    ssize_t *nwritten)
    13441344{
    1345         sysarg_t rc;
     1345        int rc;
    13461346        ipc_call_t answer;
    13471347        aid_t req;

  • uspace/lib/c/generic/vol.c

    rd4a829e r25a179e  
    119119        }
    120120
    121         sysarg_t retval;
     121        int retval;
    122122        async_wait_for(req, &retval);
    123123
    … …  
    215215{
    216216        async_exch_t *exch;
    217         sysarg_t retval;
     217        int retval;
    218218        ipc_call_t answer;
    219219
    … …  
    257257{
    258258        async_exch_t *exch;
    259         sysarg_t retval;
     259        int retval;
    260260        ipc_call_t answer;
    261261
    … …  
    283283        async_exch_t *exch;
    284284        ipc_call_t answer;
    285         sysarg_t retval;
     285        int retval;
    286286
    287287        exch = async_exchange_begin(vol->sess);
Note: See TracChangeset for help on using the changeset viewer.