Changeset 25a179e in mainline for uspace/srv


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/srv
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/vbd/vbd.c

    rd4a829e r25a179e  
    115115        }
    116116
    117         sysarg_t retval = async_data_read_finalize(callid, id_buf, size);
     117        int retval = async_data_read_finalize(callid, id_buf, size);
    118118        free(id_buf);
    119119
    … …  
    172172        ltype = IPC_GET_ARG2(*icall);
    173173        rc = vbds_label_create(disk_sid, ltype);
    174         async_answer_0(iid, (sysarg_t) rc);
     174        async_answer_0(iid, rc);
    175175}
    176176
    … …  
    184184        disk_sid = IPC_GET_ARG1(*icall);
    185185        rc = vbds_label_delete(disk_sid);
    186         async_answer_0(iid, (sysarg_t) rc);
     186        async_answer_0(iid, rc);
    187187}
    188188
    … …  
    219219        }
    220220
    221         sysarg_t retval = async_data_read_finalize(callid, id_buf, size);
     221        int retval = async_data_read_finalize(callid, id_buf, size);
    222222        free(id_buf);
    223223
    … …  
    303303        }
    304304
    305         async_answer_1(iid, (sysarg_t)rc, (sysarg_t)part);
     305        async_answer_1(iid, rc, (sysarg_t)part);
    306306}
    307307
    … …  
    315315        part = IPC_GET_ARG1(*icall);
    316316        rc = vbds_part_delete(part);
    317         async_answer_0(iid, (sysarg_t) rc);
     317        async_answer_0(iid, rc);
    318318}
    319319

  • uspace/srv/clipboard/clipboard.c

    rd4a829e r25a179e  
    121121                }
    122122               
    123                 sysarg_t retval = async_data_read_finalize(callid, clip_data, size);
     123                int retval = async_data_read_finalize(callid, clip_data, size);
    124124                if (retval != EOK) {
    125125                        async_answer_0(rid, retval);

  • uspace/srv/devman/client_conn.c

    rd4a829e r25a179e  
    400400        fibril_rwlock_read_unlock(&device_tree.rwlock);
    401401       
    402         sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
     402        int retval = async_data_read_finalize(callid, hdl_buf, size);
    403403        free(hdl_buf);
    404404       
    … …  
    451451        fun_del_ref(fun);
    452452       
    453         async_answer_0(iid, (sysarg_t) rc);
     453        async_answer_0(iid, rc);
    454454}
    455455
    … …  
    476476        fun_del_ref(fun);
    477477       
    478         async_answer_0(iid, (sysarg_t) rc);
     478        async_answer_0(iid, rc);
    479479}
    480480
    … …  
    532532        }
    533533       
    534         sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
     534        int retval = async_data_read_finalize(callid, hdl_buf, size);
    535535        free(hdl_buf);
    536536       
    … …  
    572572        }
    573573       
    574         sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
     574        int retval = async_data_read_finalize(callid, hdl_buf, size);
    575575        free(hdl_buf);
    576576       

  • uspace/srv/devman/driver.c

    rd4a829e r25a179e  
    309309{
    310310        async_exch_t *exch;
    311         sysarg_t retval;
     311        int retval;
    312312       
    313313        log_msg(LOG_DEFAULT, LVL_DEBUG, "stop_driver(drv=\"%s\")", drv->name);
    … …  
    591591       
    592592        /* Send the device name to the driver. */
    593         sysarg_t rc = async_data_write_start(exch, dev->pfun->name,
     593        int rc = async_data_write_start(exch, dev->pfun->name,
    594594            str_size(dev->pfun->name) + 1);
    595595       
    … …  
    621621{
    622622        async_exch_t *exch;
    623         sysarg_t retval;
     623        int retval;
    624624        driver_t *drv;
    625625        devman_handle_t handle;
    … …  
    644644{
    645645        async_exch_t *exch;
    646         sysarg_t retval;
     646        int retval;
    647647        driver_t *drv;
    648648        devman_handle_t handle;
    … …  
    667667{
    668668        async_exch_t *exch;
    669         sysarg_t retval;
     669        int retval;
    670670        driver_t *drv;
    671671        devman_handle_t handle;
    … …  
    695695{
    696696        async_exch_t *exch;
    697         sysarg_t retval;
     697        int retval;
    698698        driver_t *drv;
    699699        devman_handle_t handle;

  • uspace/srv/devman/drv_conn.c

    rd4a829e r25a179e  
    407407                fun_busy_unlock(fun);
    408408                fun_del_ref(fun);
    409                 async_answer_0(iid, (sysarg_t) rc);
     409                async_answer_0(iid, rc);
    410410                return;
    411411        }
    … …  
    414414        fun_del_ref(fun);
    415415       
    416         async_answer_0(iid, (sysarg_t) EOK);
     416        async_answer_0(iid, EOK);
    417417}
    418418
    … …  
    448448                fun_busy_unlock(fun);
    449449                fun_del_ref(fun);
    450                 async_answer_0(iid, (sysarg_t) rc);
     450                async_answer_0(iid, rc);
    451451                return;
    452452        }
    … …  
    454454        fun_busy_unlock(fun);
    455455        fun_del_ref(fun);
    456         async_answer_0(iid, (sysarg_t) EOK);
     456        async_answer_0(iid, EOK);
    457457}
    458458

  • uspace/srv/fs/locfs/locfs_ops.c

    rd4a829e r25a179e  
    590590               
    591591                /* Wait for reply from the driver. */
    592                 sysarg_t rc;
     592                int rc;
    593593                async_wait_for(msg, &rc);
    594594
    … …  
    654654               
    655655                /* Wait for reply from the driver. */
    656                 sysarg_t rc;
     656                int rc;
    657657                async_wait_for(msg, &rc);
    658658
    … …  
    752752               
    753753                /* Wait for reply from the driver */
    754                 sysarg_t rc;
     754                int rc;
    755755                async_wait_for(msg, &rc);
    756756               

  • uspace/srv/locsrv/locsrv.c

    rd4a829e r25a179e  
    599599        }
    600600       
    601         sysarg_t retval = async_data_read_finalize(callid, cat->name,
     601        int retval = async_data_read_finalize(callid, cat->name,
    602602            min(size, act_size));
    603603       
    … …  
    647647        }
    648648       
    649         sysarg_t retval = async_data_read_finalize(callid, fqn,
     649        int retval = async_data_read_finalize(callid, fqn,
    650650            min(size, act_size));
    651651        free(fqn);
    … …  
    694694        }
    695695       
    696         sysarg_t retval = async_data_read_finalize(callid, svc->server->name,
     696        int retval = async_data_read_finalize(callid, svc->server->name,
    697697            min(size, act_size));
    698698       
    … …  
    10001000        fibril_mutex_unlock(&cdir.mutex);
    10011001       
    1002         sysarg_t retval = async_data_read_finalize(callid, id_buf, size);
     1002        int retval = async_data_read_finalize(callid, id_buf, size);
    10031003        free(id_buf);
    10041004       
    … …  
    10471047        }
    10481048       
    1049         sysarg_t retval = async_data_read_finalize(callid, desc, size);
     1049        int retval = async_data_read_finalize(callid, desc, size);
    10501050       
    10511051        free(desc);
    … …  
    11101110        }
    11111111       
    1112         sysarg_t retval = async_data_read_finalize(callid, desc, size);
     1112        int retval = async_data_read_finalize(callid, desc, size);
    11131113       
    11141114        free(desc);
    … …  
    11631163        fibril_mutex_unlock(&cdir.mutex);
    11641164       
    1165         sysarg_t retval = async_data_read_finalize(callid, id_buf, size);
     1165        int retval = async_data_read_finalize(callid, id_buf, size);
    11661166        free(id_buf);
    11671167       
    … …  
    12781278        catid_t cat_id;
    12791279        service_id_t svc_id;
    1280         sysarg_t retval;
     1280        int retval;
    12811281       
    12821282        svc_id = IPC_GET_ARG1(*icall);

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    rd4a829e r25a179e  
    145145                async_answer_0(callid, rc);
    146146       
    147         async_answer_0(iid, (sysarg_t) rc);
     147        async_answer_0(iid, rc);
    148148       
    149149        dns_hostinfo_destroy(hinfo);
    … …  
    205205        }
    206206       
    207         async_answer_0(iid, (sysarg_t) rc);
     207        async_answer_0(iid, rc);
    208208}
    209209

  • uspace/srv/net/inetsrv/inetcfg.c

    rd4a829e r25a179e  
    364364        }
    365365       
    366         async_answer_1(iid, (sysarg_t) rc, ainfo.ilink);
     366        async_answer_1(iid, rc, ainfo.ilink);
    367367}
    368368
    … …  
    419419        size = min(act_size, max_size);
    420420
    421         sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size);
     421        int retval = async_data_read_finalize(rcallid, id_buf, size);
    422422        free(id_buf);
    423423
    … …  
    453453        size = min(act_size, max_size);
    454454
    455         sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size);
     455        int retval = async_data_read_finalize(rcallid, id_buf, size);
    456456        free(id_buf);
    457457
    … …  
    487487        size = min(act_size, max_size);
    488488
    489         sysarg_t retval = async_data_read_finalize(rcallid, id_buf, size);
     489        int retval = async_data_read_finalize(rcallid, id_buf, size);
    490490        free(id_buf);
    491491
    … …  
    542542        }
    543543
    544         sysarg_t retval = async_data_read_finalize(name_callid, linfo.name,
     544        int retval = async_data_read_finalize(name_callid, linfo.name,
    545545            min(name_max_size, str_size(linfo.name)));
    546546        if (retval != EOK) {
    … …  
    714714        free(srinfo.name);
    715715       
    716         async_answer_0(iid, (sysarg_t) rc);
     716        async_answer_0(iid, rc);
    717717}
    718718

  • uspace/srv/net/inetsrv/inetping.c

    rd4a829e r25a179e  
    130130        }
    131131
    132         sysarg_t retval;
     132        int retval;
    133133        async_wait_for(req, &retval);
    134134
    135         return (int) retval;
     135        return retval;
    136136}
    137137

  • uspace/srv/net/inetsrv/inetsrv.c

    rd4a829e r25a179e  
    480480        }
    481481
    482         sysarg_t retval;
     482        int retval;
    483483        async_wait_for(req, &retval);
    484484
    485         return (int) retval;
     485        return retval;
    486486}
    487487

  • uspace/srv/ns/ns.c

    rd4a829e r25a179e  
    8080               
    8181                task_id_t id;
    82                 sysarg_t retval;
     82                int retval;
    8383               
    8484                service_t service;

  • uspace/srv/ns/service.c

    rd4a829e r25a179e  
    173173        sysarg_t arg3 = IPC_GET_ARG3(*call);
    174174        sysarg_t flags = IPC_GET_ARG4(*call);
    175         sysarg_t retval;
     175        int retval;
    176176       
    177177        ht_link_t *link = hash_table_find(&service_hash_table, &service);

  • uspace/srv/vfs/vfs_file.c

    rd4a829e r25a179e  
    145145        vfs_exchange_release(exch);
    146146       
    147         sysarg_t rc;
     147        int rc;
    148148        async_wait_for(msg, &rc);
    149149       

  • uspace/srv/vfs/vfs_lookup.c

    rd4a829e r25a179e  
    197197       
    198198        rc = async_data_write_start(exch, component, str_size(component) + 1);
    199         sysarg_t orig_rc;
     199        int orig_rc;
    200200        async_wait_for(req, &orig_rc);
    201201        vfs_exchange_release(exch);
    … …  
    213213        assert(result);
    214214       
    215         sysarg_t rc;
     215        int rc;
    216216        ipc_call_t answer;
    217217        async_exch_t *exch = vfs_exchange_grab(base->fs_handle);

  • uspace/srv/vfs/vfs_node.c

    rd4a829e r25a179e  
    275275        vfs_exchange_release(exch);
    276276
    277         sysarg_t rc;
     277        int rc;
    278278        async_wait_for(req, &rc);
    279279       

  • uspace/srv/vfs/vfs_ops.c

    rd4a829e r25a179e  
    152152            &answer);
    153153        /* Send the mount options */
    154         sysarg_t rc = async_data_write_start(exch, options, str_size(options));
     154        int rc = async_data_write_start(exch, options, str_size(options));
    155155        if (rc != EOK) {
    156156                async_forget(msg);
    … …  
    192192{
    193193        fs_handle_t fs_handle = 0;
    194         sysarg_t rc;
     194        int rc;
    195195        int retval;
    196196       
    … …  
    398398        }
    399399       
    400         sysarg_t rc;
     400        int rc;
    401401        async_wait_for(msg, &rc);
    402402       
    … …  
    677677        vfs_exchange_release(fs_exch);
    678678       
    679         sysarg_t rc;
     679        int rc;
    680680        async_wait_for(msg, &rc);
    681681       
    … …  
    689689{
    690690        async_exch_t *exch = vfs_exchange_grab(fs_handle);
    691         sysarg_t rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
     691        int rc = async_req_4_0(exch, VFS_OUT_TRUNCATE,
    692692            (sysarg_t) service_id, (sysarg_t) index, LOWER32(size),
    693693            UPPER32(size));

  • uspace/srv/volsrv/volsrv.c

    rd4a829e r25a179e  
    112112        }
    113113
    114         sysarg_t retval = async_data_read_finalize(callid, id_buf, size);
     114        int retval = async_data_read_finalize(callid, id_buf, size);
    115115        free(id_buf);
    116116
Note: See TracChangeset for help on using the changeset viewer.