Changeset b7fd2a0 in mainline for uspace/lib/c/generic/loc.c


Ignore:
Timestamp:
2018-01-13T03:10:29Z (7 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:
a53ed3a
Parents:
36f0738
Message:

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r36f0738 rb7fd2a0  
    103103 *
    104104 */
    105 static int loc_callback_create(void)
     105static errno_t loc_callback_create(void)
    106106{
    107107        if (!loc_callback_created) {
    … …  
    113113               
    114114                port_id_t port;
    115                 int rc = async_create_callback_port(exch, INTERFACE_LOC_CB, 0, 0,
     115                errno_t rc = async_create_callback_port(exch, INTERFACE_LOC_CB, 0, 0,
    116116                    loc_cb_conn, NULL, &port);
    117117               
    … …  
    121121                        return rc;
    122122               
    123                 int retval;
     123                errno_t retval;
    124124                async_wait_for(req, &retval);
    125125                if (retval != EOK)
    … …  
    239239
    240240/** Register new driver with loc. */
    241 int loc_server_register(const char *name)
     241errno_t loc_server_register(const char *name)
    242242{
    243243        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    … …  
    245245        ipc_call_t answer;
    246246        aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer);
    247         int retval = async_data_write_start(exch, name, str_size(name));
     247        errno_t retval = async_data_write_start(exch, name, str_size(name));
    248248       
    249249        if (retval != EOK) {
    … …  
    272272 *
    273273 */
    274 int loc_service_register(const char *fqsn, service_id_t *sid)
     274errno_t loc_service_register(const char *fqsn, service_id_t *sid)
    275275{
    276276        async_exch_t *exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    … …  
    278278        ipc_call_t answer;
    279279        aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
    280         int retval = async_data_write_start(exch, fqsn, str_size(fqsn));
     280        errno_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
    281281       
    282282        if (retval != EOK) {
    … …  
    311311 * @param sid   Service ID
    312312 */
    313 int loc_service_unregister(service_id_t sid)
     313errno_t loc_service_unregister(service_id_t sid)
    314314{
    315315        async_exch_t *exch;
    316         int retval;
     316        errno_t retval;
    317317       
    318318        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    … …  
    320320        loc_exchange_end(exch);
    321321       
    322         return (int)retval;
    323 }
    324 
    325 int loc_service_get_id(const char *fqdn, service_id_t *handle,
     322        return (errno_t)retval;
     323}
     324
     325errno_t loc_service_get_id(const char *fqdn, service_id_t *handle,
    326326    unsigned int flags)
    327327{
    … …  
    339339        aid_t req = async_send_2(exch, LOC_SERVICE_GET_ID, flags, 0,
    340340            &answer);
    341         int retval = async_data_write_start(exch, fqdn, str_size(fqdn));
     341        errno_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
    342342       
    343343        loc_exchange_end(exch);
    … …  
    373373 * @return              EOK on success or an error code
    374374 */
    375 static int loc_get_name_internal(sysarg_t method, sysarg_t id, char **name)
     375static errno_t loc_get_name_internal(sysarg_t method, sysarg_t id, char **name)
    376376{
    377377        async_exch_t *exch;
    … …  
    379379        ipc_call_t dreply;
    380380        size_t act_size;
    381         int dretval;
     381        errno_t dretval;
    382382       
    383383        *name = NULL;
    … …  
    397397        }
    398398       
    399         int retval;
     399        errno_t retval;
    400400        async_wait_for(req, &retval);
    401401       
    … …  
    423423 * @return              EOK on success or an error code
    424424 */
    425 int loc_category_get_name(category_id_t cat_id, char **name)
     425errno_t loc_category_get_name(category_id_t cat_id, char **name)
    426426{
    427427        return loc_get_name_internal(LOC_CATEGORY_GET_NAME, cat_id, name);
    … …  
    437437 * @return              EOK on success or an error code
    438438 */
    439 int loc_service_get_name(service_id_t svc_id, char **name)
     439errno_t loc_service_get_name(service_id_t svc_id, char **name)
    440440{
    441441        return loc_get_name_internal(LOC_SERVICE_GET_NAME, svc_id, name);
    … …  
    451451 * @return              EOK on success or an error code
    452452 */
    453 int loc_service_get_server_name(service_id_t svc_id, char **name)
     453errno_t loc_service_get_server_name(service_id_t svc_id, char **name)
    454454{
    455455        return loc_get_name_internal(LOC_SERVICE_GET_SERVER_NAME, svc_id, name);
    456456}
    457457
    458 int loc_namespace_get_id(const char *name, service_id_t *handle,
     458errno_t loc_namespace_get_id(const char *name, service_id_t *handle,
    459459    unsigned int flags)
    460460{
    … …  
    472472        aid_t req = async_send_2(exch, LOC_NAMESPACE_GET_ID, flags, 0,
    473473            &answer);
    474         int retval = async_data_write_start(exch, name, str_size(name));
     474        errno_t retval = async_data_write_start(exch, name, str_size(name));
    475475       
    476476        loc_exchange_end(exch);
    … …  
    505505 * @return              EOK on success or an error code
    506506 */
    507 int loc_category_get_id(const char *name, category_id_t *cat_id,
     507errno_t loc_category_get_id(const char *name, category_id_t *cat_id,
    508508    unsigned int flags)
    509509{
    … …  
    521521        aid_t req = async_send_0(exch, LOC_CATEGORY_GET_ID,
    522522            &answer);
    523         int retval = async_data_write_start(exch, name, str_size(name));
     523        errno_t retval = async_data_write_start(exch, name, str_size(name));
    524524       
    525525        loc_exchange_end(exch);
    … …  
    551551       
    552552        sysarg_t type;
    553         int retval = async_req_1_1(exch, LOC_ID_PROBE, handle, &type);
     553        errno_t retval = async_req_1_1(exch, LOC_ID_PROBE, handle, &type);
    554554       
    555555        loc_exchange_end(exch);
    … …  
    582582       
    583583        sysarg_t null_id;
    584         int retval = async_req_0_1(exch, LOC_NULL_CREATE, &null_id);
     584        errno_t retval = async_req_0_1(exch, LOC_NULL_CREATE, &null_id);
    585585       
    586586        loc_exchange_end(exch);
    … …  
    602602{
    603603        sysarg_t count;
    604         int retval = async_req_0_1(exch, LOC_GET_NAMESPACE_COUNT, &count);
     604        errno_t retval = async_req_0_1(exch, LOC_GET_NAMESPACE_COUNT, &count);
    605605        if (retval != EOK)
    606606                return 0;
    … …  
    615615 * @return              EOK on success or an error code
    616616 */
    617 int loc_service_add_to_cat(service_id_t svc_id, service_id_t cat_id)
     617errno_t loc_service_add_to_cat(service_id_t svc_id, service_id_t cat_id)
    618618{
    619619        async_exch_t *exch;
    620         int retval;
     620        errno_t retval;
    621621       
    622622        exch = loc_exchange_begin_blocking(INTERFACE_LOC_SUPPLIER);
    … …  
    631631{
    632632        sysarg_t count;
    633         int retval = async_req_1_1(exch, LOC_GET_SERVICE_COUNT, ns_handle,
     633        errno_t retval = async_req_1_1(exch, LOC_GET_SERVICE_COUNT, ns_handle,
    634634            &count);
    635635        if (retval != EOK)
    … …  
    676676                ipc_call_t answer;
    677677                aid_t req = async_send_0(exch, LOC_GET_NAMESPACES, &answer);
    678                 int rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
     678                errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
    679679               
    680680                loc_exchange_end(exch);
    … …  
    695695                }
    696696               
    697                 int retval;
     697                errno_t retval;
    698698                async_wait_for(req, &retval);
    699699               
    … …  
    725725                ipc_call_t answer;
    726726                aid_t req = async_send_1(exch, LOC_GET_SERVICES, ns_handle, &answer);
    727                 int rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
     727                errno_t rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
    728728               
    729729                loc_exchange_end(exch);
    … …  
    744744                }
    745745               
    746                 int retval;
     746                errno_t retval;
    747747                async_wait_for(req, &retval);
    748748               
    … …  
    755755}
    756756
    757 static int loc_category_get_ids_once(sysarg_t method, sysarg_t arg1,
     757static errno_t loc_category_get_ids_once(sysarg_t method, sysarg_t arg1,
    758758    sysarg_t *id_buf, size_t buf_size, size_t *act_size)
    759759{
    … …  
    762762        ipc_call_t answer;
    763763        aid_t req = async_send_1(exch, method, arg1, &answer);
    764         int rc = async_data_read_start(exch, id_buf, buf_size);
     764        errno_t rc = async_data_read_start(exch, id_buf, buf_size);
    765765       
    766766        loc_exchange_end(exch);
    … …  
    771771        }
    772772       
    773         int retval;
     773        errno_t retval;
    774774        async_wait_for(req, &retval);
    775775       
    … …  
    792792 * @return              EOK on success or an error code
    793793 */
    794 static int loc_get_ids_internal(sysarg_t method, sysarg_t arg1,
     794static errno_t loc_get_ids_internal(sysarg_t method, sysarg_t arg1,
    795795    sysarg_t **data, size_t *count)
    796796{
    … …  
    799799       
    800800        size_t act_size = 0;
    801         int rc = loc_category_get_ids_once(method, arg1, NULL, 0,
     801        errno_t rc = loc_category_get_ids_once(method, arg1, NULL, 0,
    802802            &act_size);
    803803        if (rc != EOK)
    … …  
    838838 * @return              EOK on success or an error code
    839839 */
    840 int loc_category_get_svcs(category_id_t cat_id, service_id_t **data,
     840errno_t loc_category_get_svcs(category_id_t cat_id, service_id_t **data,
    841841    size_t *count)
    842842{
    … …  
    853853 * @return              EOK on success or an error code
    854854 */
    855 int loc_get_categories(category_id_t **data, size_t *count)
     855errno_t loc_get_categories(category_id_t **data, size_t *count)
    856856{
    857857        return loc_get_ids_internal(LOC_GET_CATEGORIES, 0,
    … …  
    859859}
    860860
    861 int loc_register_cat_change_cb(loc_cat_change_cb_t cb_fun)
     861errno_t loc_register_cat_change_cb(loc_cat_change_cb_t cb_fun)
    862862{
    863863        fibril_mutex_lock(&loc_callback_mutex);
Note: See TracChangeset for help on using the changeset viewer.