Changeset d5c1051 in mainline for uspace/lib/c


Ignore:
Timestamp:
2017-12-20T22:25:34Z (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:
39b54fe
Parents:
8610c2c
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2017-12-20 22:22:29)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2017-12-20 22:25:34)
Message:

"Obviously harmless" error handling tweaks.

Location:
uspace/lib/c
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/as.c

    r8610c2c rd5c1051  
    7676int as_area_resize(void *address, size_t size, unsigned int flags)
    7777{
    78         return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t) address,
     78        return (int) __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t) address,
    7979            (sysarg_t) size, (sysarg_t) flags);
    8080}
    … …  
    9090int as_area_destroy(void *address)
    9191{
    92         return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t) address);
     92        return (int) __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t) address);
    9393}
    9494
    … …  
    104104int as_area_change_flags(void *address, unsigned int flags)
    105105{
    106         return __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address,
     106        return (int) __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address,
    107107            (sysarg_t) flags);
    108108}

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

    r8610c2c rd5c1051  
    763763       
    764764        free(fibril_connection);
    765         return 0;
     765        return EOK;
    766766}
    767767

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

    r8610c2c rd5c1051  
    178178{
    179179        int rc;
     180        int ret;
    180181        const char *sunit;
    181182        uint64_t ipart;
    … …  
    196197        sunit = cu_str[cap->cunit];
    197198        if (cap->dp > 0) {
    198                 rc = asprintf(rstr, "%" PRIu64 ".%0*" PRIu64 " %s", ipart,
     199                ret = asprintf(rstr, "%" PRIu64 ".%0*" PRIu64 " %s", ipart,
    199200                    (int)cap->dp, fpart, sunit);
    200201        } else {
    201                 rc = asprintf(rstr, "%" PRIu64 " %s", ipart, sunit);
    202         }
    203         if (rc < 0)
     202                ret = asprintf(rstr, "%" PRIu64 " %s", ipart, sunit);
     203        }
     204        if (ret < 0)
    204205                return ENOMEM;
    205206

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

    r8610c2c rd5c1051  
    7171int physmem_map(uintptr_t phys, size_t pages, unsigned int flags, void **virt)
    7272{
    73         return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
     73        return (int) __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
    7474            pages, flags, (sysarg_t) virt, (sysarg_t) __entry);
    7575}
    … …  
    8787int physmem_unmap(void *virt)
    8888{
    89         return __SYSCALL1(SYS_PHYSMEM_UNMAP, (sysarg_t) virt);
     89        return (int) __SYSCALL1(SYS_PHYSMEM_UNMAP, (sysarg_t) virt);
    9090}
    9191
    … …  
    150150int dmamem_unmap(void *virt, size_t size)
    151151{
    152         return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, (sysarg_t) size, 0);
     152        return (int) __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, (sysarg_t) size, 0);
    153153}
    154154
    155155int dmamem_unmap_anonymous(void *virt)
    156156{
    157         return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, 0,
     157        return (int) __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, 0,
    158158            DMAMEM_FLAGS_ANONYMOUS);
    159159}
    … …  
    181181        };
    182182       
    183         return __SYSCALL1(SYS_IOSPACE_ENABLE, (sysarg_t) &arg);
     183        return (int) __SYSCALL1(SYS_IOSPACE_ENABLE, (sysarg_t) &arg);
    184184}
    185185
    … …  
    205205        };
    206206       
    207         return __SYSCALL1(SYS_IOSPACE_DISABLE, (sysarg_t) &arg);
     207        return (int) __SYSCALL1(SYS_IOSPACE_DISABLE, (sysarg_t) &arg);
    208208}
    209209

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

    r8610c2c rd5c1051  
    4545 * @param imethod Use this interface and method for notifying me.
    4646 *
    47  * @return Value returned by the kernel.
     47 * @return Error code returned by the kernel.
    4848 *
    4949 */
    5050int ipc_event_subscribe(event_type_t evno, sysarg_t imethod)
    5151{
    52         return __SYSCALL2(SYS_IPC_EVENT_SUBSCRIBE, (sysarg_t) evno,
     52        return (int) __SYSCALL2(SYS_IPC_EVENT_SUBSCRIBE, (sysarg_t) evno,
    5353            (sysarg_t) imethod);
    5454}
    … …  
    5959 * @param imethod Use this interface and method for notifying me.
    6060 *
    61  * @return Value returned by the kernel.
     61 * @return Error code returned by the kernel.
    6262 *
    6363 */
    6464int ipc_event_task_subscribe(event_task_type_t evno, sysarg_t imethod)
    6565{
    66         return __SYSCALL2(SYS_IPC_EVENT_SUBSCRIBE, (sysarg_t) evno,
     66        return (int) __SYSCALL2(SYS_IPC_EVENT_SUBSCRIBE, (sysarg_t) evno,
    6767            (sysarg_t) imethod);
    6868}
    … …  
    7272 * @param evno    Event type to unsubscribe.
    7373 *
    74  * @return Value returned by the kernel.
     74 * @return Error code returned by the kernel.
    7575 *
    7676 */
    7777int ipc_event_unsubscribe(event_type_t evno)
    7878{
    79         return __SYSCALL1(SYS_IPC_EVENT_UNSUBSCRIBE, (sysarg_t) evno);
     79        return (int) __SYSCALL1(SYS_IPC_EVENT_UNSUBSCRIBE, (sysarg_t) evno);
    8080}
    8181
    … …  
    8484 * @param evno    Event type to unsubscribe.
    8585 *
    86  * @return Value returned by the kernel.
     86 * @return Error code returned by the kernel.
    8787 *
    8888 */
    8989int ipc_event_task_unsubscribe(event_task_type_t evno)
    9090{
    91         return __SYSCALL1(SYS_IPC_EVENT_UNSUBSCRIBE, (sysarg_t) evno);
     91        return (int) __SYSCALL1(SYS_IPC_EVENT_UNSUBSCRIBE, (sysarg_t) evno);
    9292}
    9393
    … …  
    9696 * @param evno Event type to unmask.
    9797 *
    98  * @return Value returned by the kernel.
     98 * @return Error code returned by the kernel.
    9999 *
    100100 */
    101101int ipc_event_unmask(event_type_t evno)
    102102{
    103         return __SYSCALL1(SYS_IPC_EVENT_UNMASK, (sysarg_t) evno);
     103        return (int) __SYSCALL1(SYS_IPC_EVENT_UNMASK, (sysarg_t) evno);
    104104}
    105105
    … …  
    108108 * @param evno Event type to unmask.
    109109 *
    110  * @return Value returned by the kernel.
     110 * @return Error code returned by the kernel.
    111111 *
    112112 */
    113113int ipc_event_task_unmask(event_task_type_t evno)
    114114{
    115         return __SYSCALL1(SYS_IPC_EVENT_UNMASK, (sysarg_t) evno);
     115        return (int) __SYSCALL1(SYS_IPC_EVENT_UNMASK, (sysarg_t) evno);
    116116}
    117117

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

    r8610c2c rd5c1051  
    584584{
    585585        int rc;
     586        int ret;
    586587
    587588        rc = ENOTSUP;
    … …  
    589590        switch (addr->version) {
    590591        case ip_any:
    591                 rc = asprintf(bufp, "none");
    592                 if (rc < 0)
     592                ret = asprintf(bufp, "none");
     593                if (ret < 0)
    593594                        return ENOMEM;
    594595                rc = EOK;
    … …  
    618619{
    619620        int rc;
     621        int ret;
    620622        char *astr;
    621623
    … …  
    624626        switch (naddr->version) {
    625627        case ip_any:
    626                 rc = asprintf(bufp, "none");
    627                 if (rc < 0)
     628                ret = asprintf(bufp, "none");
     629                if (ret < 0)
    628630                        return ENOMEM;
    629631                rc = EOK;
    … …  
    634636                        return ENOMEM;
    635637
    636                 rc = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
    637                 if (rc < 0) {
     638                ret = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
     639                if (ret < 0) {
    638640                        free(astr);
    639641                        return ENOMEM;
    … …  
    647649                        return ENOMEM;
    648650
    649                 rc = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
    650                 if (rc < 0) {
     651                ret = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
     652                if (ret < 0) {
    651653                        free(astr);
    652654                        return ENOMEM;

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

    r8610c2c rd5c1051  
    140140{
    141141        int rc;
     142        int ret;
    142143        char *astr, *str;
    143144        char *hstr = NULL;
    … …  
    154155                        hstr = astr;
    155156                } else {
    156                         rc = asprintf(&hstr, "[%s]", astr);
    157                         if (rc < 0) {
     157                        ret = asprintf(&hstr, "[%s]", astr);
     158                        if (ret < 0) {
    158159                                free(astr);
    159160                                return ENOMEM;
    … …  
    171172        }
    172173
    173         rc = asprintf(&str, "%s:%u", hstr, hp->port);
    174         if (rc < 0)
     174        ret = asprintf(&str, "%s:%u", hstr, hp->port);
     175        if (ret < 0)
    175176                return ENOMEM;
    176177

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

    r8610c2c rd5c1051  
    124124        *nread = IPC_GET_ARG2(answer);
    125125        /* In case of partial success, ARG1 contains the error code */
    126         return IPC_GET_ARG1(answer);
     126        return (int) IPC_GET_ARG1(answer);
    127127
    128128}
    … …  
    175175        *nwritten = IPC_GET_ARG2(answer);
    176176        /* In case of partial success, ARG1 contains the error code */
    177         return IPC_GET_ARG1(answer);
     177        return (int) IPC_GET_ARG1(answer);
    178178}
    179179

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

    r8610c2c rd5c1051  
    8282
    8383        free(buf);
    84         async_answer_2(callid, EOK, rc, nread);
     84        async_answer_2(callid, EOK, (sysarg_t) rc, nread);
    8585}
    8686
    … …  
    111111        }
    112112
    113         async_answer_2(callid, EOK, rc, nwr);
     113        async_answer_2(callid, EOK, (sysarg_t) rc, nwr);
    114114}
    115115

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

    r8610c2c rd5c1051  
    478478        va_list args;
    479479        int rc;
     480        int ret;
    480481        char *str;
    481482        char *sp, *ep;
    … …  
    486487
    487488        va_start(args, fmt);
    488         rc = vasprintf(&str, fmt, args);
     489        ret = vasprintf(&str, fmt, args);
    489490        va_end(args);
    490491
    491         if (rc < 0) {
     492        if (ret < 0) {
    492493                table->error = ENOMEM;
    493494                return table->error;

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

    r8610c2c rd5c1051  
    136136                return;
    137137       
    138         int rc = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phandle, imethod, arg1,
     138        int rc = (int) __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phandle, imethod, arg1,
    139139            arg2, arg3, (sysarg_t) call);
    140140       
    … …  
    175175        IPC_SET_ARG5(call->msg.data, arg5);
    176176       
    177         int rc = __SYSCALL3(SYS_IPC_CALL_ASYNC_SLOW, phandle,
     177        int rc = (int) __SYSCALL3(SYS_IPC_CALL_ASYNC_SLOW, phandle,
    178178            (sysarg_t) &call->msg.data, (sysarg_t) call);
    179179       
    … …  
    200200    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    201201{
    202         return __SYSCALL6(SYS_IPC_ANSWER_FAST, chandle, retval, arg1, arg2,
     202        return (int) __SYSCALL6(SYS_IPC_ANSWER_FAST, chandle, (sysarg_t) retval, arg1, arg2,
    203203            arg3, arg4);
    204204}
    … …  
    230230        IPC_SET_ARG5(data, arg5);
    231231       
    232         return __SYSCALL2(SYS_IPC_ANSWER_SLOW, chandle, (sysarg_t) &data);
     232        return (int) __SYSCALL2(SYS_IPC_ANSWER_SLOW, chandle, (sysarg_t) &data);
    233233}
    234234
    … …  
    260260int ipc_wait_cycle(ipc_call_t *call, sysarg_t usec, unsigned int flags)
    261261{
    262         int rc = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
     262        int rc = (int) __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
    263263       
    264264        /* Handle received answers */
    … …  
    330330int ipc_hangup(cap_handle_t phandle)
    331331{
    332         return __SYSCALL1(SYS_IPC_HANGUP, phandle);
     332        return (int) __SYSCALL1(SYS_IPC_HANGUP, phandle);
    333333}
    334334
    … …  
    353353    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    354354{
    355         return __SYSCALL6(SYS_IPC_FORWARD_FAST, chandle, phandle, imethod, arg1,
     355        return (int) __SYSCALL6(SYS_IPC_FORWARD_FAST, chandle, phandle, imethod, arg1,
    356356            arg2, mode);
    357357}
    … …  
    370370        IPC_SET_ARG5(data, arg5);
    371371       
    372         return __SYSCALL4(SYS_IPC_FORWARD_SLOW, chandle, phandle,
     372        return (int) __SYSCALL4(SYS_IPC_FORWARD_SLOW, chandle, phandle,
    373373            (sysarg_t) &data, mode);
    374374}
    … …  
    379379int ipc_connect_kbox(task_id_t id, cap_handle_t *phone)
    380380{
    381         return __SYSCALL2(SYS_IPC_CONNECT_KBOX, (sysarg_t) &id, (sysarg_t) phone);
     381        return (int) __SYSCALL2(SYS_IPC_CONNECT_KBOX, (sysarg_t) &id, (sysarg_t) phone);
    382382}
    383383

  • uspace/lib/c/generic/irq.c

    r8610c2c rd5c1051  
    6969                ucode = &default_ucode;
    7070       
    71         return __SYSCALL4(SYS_IPC_IRQ_SUBSCRIBE, inr, method, (sysarg_t) ucode,
     71        return (int) __SYSCALL4(SYS_IPC_IRQ_SUBSCRIBE, inr, method, (sysarg_t) ucode,
    7272            (sysarg_t) out_handle);
    7373}
    … …  
    8282int ipc_irq_unsubscribe(cap_handle_t cap)
    8383{
    84         return __SYSCALL1(SYS_IPC_IRQ_UNSUBSCRIBE, cap);
     84        return (int) __SYSCALL1(SYS_IPC_IRQ_UNSUBSCRIBE, cap);
    8585}
    8686

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

    r8610c2c rd5c1051  
    5656int loader_spawn(const char *name)
    5757{
    58         return __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER,
     58        return (int) __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER,
    5959            (sysarg_t) name, str_size(name));
    6060}

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

    r8610c2c rd5c1051  
    574574}
    575575
     576/**
     577 * @return ID of a new NULL device, or -1 if failed.
     578 */
    576579int loc_null_create(void)
    577580{

  • uspace/lib/c/generic/perm.c

    r8610c2c rd5c1051  
    5252#ifdef __32_BITS__
    5353        sysarg64_t arg = (sysarg64_t) id;
    54         return __SYSCALL2(SYS_PERM_GRANT, (sysarg_t) &arg, (sysarg_t) perms);
     54        return (int) __SYSCALL2(SYS_PERM_GRANT, (sysarg_t) &arg, (sysarg_t) perms);
    5555#endif
    5656       
    5757#ifdef __64_BITS__
    58         return __SYSCALL2(SYS_PERM_GRANT, (sysarg_t) id, (sysarg_t) perms);
     58        return (int) __SYSCALL2(SYS_PERM_GRANT, (sysarg_t) id, (sysarg_t) perms);
    5959#endif
    6060}
    … …  
    7272#ifdef __32_BITS__
    7373        sysarg64_t arg = (sysarg64_t) id;
    74         return __SYSCALL2(SYS_PERM_REVOKE, (sysarg_t) &arg, (sysarg_t) perms);
     74        return (int) __SYSCALL2(SYS_PERM_REVOKE, (sysarg_t) &arg, (sysarg_t) perms);
    7575#endif
    7676       
    7777#ifdef __64_BITS__
    78         return __SYSCALL2(SYS_PERM_REVOKE, (sysarg_t) id, (sysarg_t) perms);
     78        return (int) __SYSCALL2(SYS_PERM_REVOKE, (sysarg_t) id, (sysarg_t) perms);
    7979#endif
    8080}

  • uspace/lib/c/generic/smc.c

    r8610c2c rd5c1051  
    3939int smc_coherence(void *address, size_t size)
    4040{
    41         return __SYSCALL2(SYS_SMC_COHERENCE, (sysarg_t) address,
     41        return (int) __SYSCALL2(SYS_SMC_COHERENCE, (sysarg_t) address,
    4242            (sysarg_t) size);
    4343}

  • uspace/lib/c/generic/sysinfo.c

    r8610c2c rd5c1051  
    9292        /* Get the data */
    9393        size_t sz;
    94         ret = __SYSCALL5(SYS_SYSINFO_GET_KEYS, (sysarg_t) path,
     94        ret = (int) __SYSCALL5(SYS_SYSINFO_GET_KEYS, (sysarg_t) path,
    9595            (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
    9696            (sysarg_t) &sz);
    … …  
    186186        /* Get the data */
    187187        size_t sz;
    188         ret = __SYSCALL5(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
     188        ret = (int) __SYSCALL5(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
    189189            (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
    190190            (sysarg_t) &sz);

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

    r8610c2c rd5c1051  
    7575        assert(name);
    7676       
    77         return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name));
     77        return (int) __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name));
    7878}
    7979

  • uspace/lib/c/generic/thread.c

    r8610c2c rd5c1051  
    132132        uarg->uspace_uarg = uarg;
    133133       
    134         int rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
     134        int rc = (int) __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
    135135            (sysarg_t) name, (sysarg_t) str_size(name), (sysarg_t) tid);
    136136       

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

    r8610c2c rd5c1051  
    7676                struct stat st;
    7777                int rc;
     78                int ret;
    7879
    79                 rc = asprintf(&child, "%s/%s", path, dirent->d_name);
    80                 if (rc < 0) {
     80                ret = asprintf(&child, "%s/%s", path, dirent->d_name);
     81                if (ret < 0) {
    8182                        closedir(dir);
    82                         return rc;
     83                        return ENOMEM;
    8384                }
    8485

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

    r8610c2c rd5c1051  
    170170extern int async_irq_subscribe(int, async_notification_handler_t, void *,
    171171    const irq_code_t *, cap_handle_t *);
    172 extern int async_irq_unsubscribe(int);
     172extern int async_irq_unsubscribe(cap_handle_t);
    173173
    174174extern int async_event_subscribe(event_type_t, async_notification_handler_t,

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

    r8610c2c rd5c1051  
    108108 * @param futex Futex.
    109109 *
    110  * @return Non-zero if the futex was acquired.
    111  * @return Zero if the futex was not acquired.
     110 * @return true if the futex was acquired.
     111 * @return false if the futex was not acquired.
    112112 *
    113113 */
    114 static inline int futex_trydown(futex_t *futex)
     114static inline bool futex_trydown(futex_t *futex)
    115115{
    116116        return cas(&futex->val, 1, 0);
    … …  
    129129{
    130130        if ((atomic_signed_t) atomic_predec(&futex->val) < 0)
    131                 return __SYSCALL1(SYS_FUTEX_SLEEP, (sysarg_t) &futex->val.count);
     131                return (int) __SYSCALL1(SYS_FUTEX_SLEEP, (sysarg_t) &futex->val.count);
    132132       
    133133        return EOK;
    … …  
    146146{
    147147        if ((atomic_signed_t) atomic_postinc(&futex->val) < 0)
    148                 return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) &futex->val.count);
     148                return (int) __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) &futex->val.count);
    149149       
    150150        return EOK;

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

    r8610c2c rd5c1051  
    4040#include <stddef.h>
    4141#include <stdio.h>
     42#include <errno.h>
    4243
    4344/** Table metrics */
Note: See TracChangeset for help on using the changeset viewer.