Changeset d5c1051 in mainline for uspace/lib


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
Files:
37 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 */

  • uspace/lib/clui/nchoice.c

    r8610c2c rd5c1051  
    131131        int i;
    132132        int rc;
     133        int ret;
    133134        char *str;
    134135        unsigned long c;
    … …  
    151152
    152153        if (def_i > 0) {
    153                 rc = asprintf(&istr, "%d", def_i);
    154                 if (rc < 0)
     154                ret = asprintf(&istr, "%d", def_i);
     155                if (ret < 0)
    155156                        return ENOMEM;
    156157        } else {

  • uspace/lib/compress/inflate.c

    r8610c2c rd5c1051  
    637637       
    638638        uint16_t last;
    639         int ret = 0;
     639        int ret = EOK;
    640640       
    641641        do {

  • uspace/lib/draw/font/pcf.c

    r8610c2c rd5c1051  
    268268            (glyph_id * sizeof(uint32_t));
    269269       
    270         rc = fseek(data->file, offset, SEEK_SET);
    271         if (rc != 0)
     270        if (fseek(data->file, offset, SEEK_SET) < 0)
    272271                return errno;
    273272       
    … …  
    284283            + bitmap_offset;
    285284       
    286         rc = fseek(data->file, offset, SEEK_SET);
    287         if (rc != 0)
     285        if (fseek(data->file, offset, SEEK_SET) < 0)
    288286                return errno;
    289287       

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

    r8610c2c rd5c1051  
    5151}
    5252
    53 int unregister_interrupt_handler(ddf_dev_t *dev, int cap)
     53int unregister_interrupt_handler(ddf_dev_t *dev, cap_handle_t cap)
    5454{
    5555        return async_irq_unsubscribe(cap);

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

    r8610c2c rd5c1051  
    216216                return rc;
    217217       
    218         return (int) res;
     218        return res;
    219219}
    220220
    … …  
    243243                return rc;
    244244       
    245         return (int) res;
     245        return res;
    246246}
    247247
    … …  
    301301                return rc;
    302302       
    303         return (int) res;
     303        return res;
    304304}
    305305
    … …  
    635635                return rc;
    636636       
    637         return (int) res;
     637        return res;
    638638}
    639639
    … …  
    723723                return rc;
    724724       
    725         return (int) res;
     725        return res;
    726726}
    727727
    … …  
    884884                return rc;
    885885       
    886         return (int) res;
     886        return res;
    887887}
    888888
    … …  
    944944                return rc;
    945945       
    946         return (int) res;
     946        return res;
    947947}
    948948
    … …  
    10111011       
    10121012        *id = IPC_GET_ARG1(result);
    1013         return (int) res;
     1013        return res;
    10141014}
    10151015
    … …  
    13171317                return rc;
    13181318       
    1319         return (int) res;
     1319        return res;
    13201320}
    13211321

  • uspace/lib/drv/include/ddf/interrupt.h

    r8610c2c rd5c1051  
    5252extern int register_interrupt_handler(ddf_dev_t *, int, interrupt_handler_t *,
    5353    const irq_code_t *, cap_handle_t *);
    54 extern int unregister_interrupt_handler(ddf_dev_t *, int);
     54extern int unregister_interrupt_handler(ddf_dev_t *, cap_handle_t);
    5555
    5656#endif

  • uspace/lib/http/src/response.c

    r8610c2c rd5c1051  
    5454        recv_mark(rb, &start);
    5555        int rc = recv_while(rb, is_digit);
    56         if (rc < 0) {
     56        if (rc != EOK) {
    5757                recv_unmark(rb, &start);
    5858                return rc;
    … …  
    149149       
    150150        rc = recv_while(rb, is_not_newline);
    151         if (rc < 0) {
     151        if (rc != EOK) {
    152152                recv_unmark(rb, &msg_start);
    153153                return rc;

  • uspace/lib/nic/include/nic_addr_db.h

    r8610c2c rd5c1051  
    6060extern int nic_addr_db_insert(nic_addr_db_t *db, const uint8_t *addr);
    6161extern int nic_addr_db_remove(nic_addr_db_t *db, const uint8_t *addr);
    62 extern int nic_addr_db_contains(const nic_addr_db_t *db, const uint8_t *addr);
     62extern bool nic_addr_db_contains(const nic_addr_db_t *db, const uint8_t *addr);
    6363extern void nic_addr_db_foreach(const nic_addr_db_t *db,
    6464        void (*func)(const uint8_t *, void *), void *arg);

  • uspace/lib/nic/include/nic_rx_control.h

    r8610c2c rd5c1051  
    118118extern int nic_rxc_set_addr(nic_rxc_t *rxc,
    119119        const nic_address_t *prev_addr, const nic_address_t *curr_addr);
    120 extern int nic_rxc_check(const nic_rxc_t *rxc,
     120extern bool nic_rxc_check(const nic_rxc_t *rxc,
    121121        const void *data, size_t size, nic_frame_type_t *frame_type);
    122122extern void nic_rxc_hw_filtering(nic_rxc_t *rxc,

  • uspace/lib/nic/src/nic_addr_db.c

    r8610c2c rd5c1051  
    223223 * @return true if the address is in the db, false otherwise
    224224 */
    225 int nic_addr_db_contains(const nic_addr_db_t *db, const uint8_t *addr)
     225bool nic_addr_db_contains(const nic_addr_db_t *db, const uint8_t *addr)
    226226{
    227227        assert(db && addr);

  • uspace/lib/nic/src/nic_driver.c

    r8610c2c rd5c1051  
    521521        fibril_rwlock_read_lock(&nic_data->rxc_lock);
    522522        nic_frame_type_t frame_type;
    523         int check = nic_rxc_check(&nic_data->rx_control, frame->data,
     523        bool check = nic_rxc_check(&nic_data->rx_control, frame->data,
    524524            frame->size, &frame_type);
    525525        fibril_rwlock_read_unlock(&nic_data->rxc_lock);
    … …  
    10921092                fibril_rwlock_read_unlock(&nic->main_lock);
    10931093        }
    1094         return 0;
     1094        return EOK;
    10951095}
    10961096

  • uspace/lib/nic/src/nic_rx_control.c

    r8610c2c rd5c1051  
    394394 * @return True if the frame passes, false if it does not
    395395 */
    396 int nic_rxc_check(const nic_rxc_t *rxc, const void *data, size_t size,
     396bool nic_rxc_check(const nic_rxc_t *rxc, const void *data, size_t size,
    397397        nic_frame_type_t *frame_type)
    398398{

  • uspace/lib/trackmod/protracker.c

    r8610c2c rd5c1051  
    302302                memcpy(&mod15, &mod31, sizeof(protracker_15smp_t));
    303303
    304                 rc = fseek(f, sizeof(protracker_15smp_t), SEEK_SET);
    305                 if (rc != 0) {
     304                if (fseek(f, sizeof(protracker_15smp_t), SEEK_SET) < 0) {
    306305                        printf("Error seeking.\n");
    307306                        rc = EIO;

  • uspace/lib/trackmod/xm.c

    r8610c2c rd5c1051  
    174174        long seek_amount;
    175175        int rc;
     176        int ret;
    176177
    177178        module->pattern = calloc(sizeof(trackmod_pattern_t), module->patterns);
    … …  
    182183
    183184        for (i = 0; i < module->patterns; i++) {
    184                 rc = fread(&pattern, 1, sizeof(xm_pattern_t), f);
    185                 if (rc != sizeof(xm_pattern_t)) {
     185                ret = fread(&pattern, 1, sizeof(xm_pattern_t), f);
     186                if (ret != sizeof(xm_pattern_t)) {
    186187                        rc = EIO;
    187188                        goto error;
    … …  
    297298        long pos;
    298299        int rc;
     300        int ret;
    299301
    300302        module->instrs = uint16_t_le2host(xm_hdr->instruments);
    … …  
    305307        for (i = 0; i < module->instrs; i++) {
    306308                pos = ftell(f);
    307                 rc = fread(&instr, 1, sizeof(xm_instr_t), f);
    308                 if (rc != sizeof(xm_instr_t)) {
     309                ret = fread(&instr, 1, sizeof(xm_instr_t), f);
     310                if (ret != sizeof(xm_instr_t)) {
    309311                        rc = EIO;
    310312                        goto error;
    … …  
    315317
    316318                if (samples > 0) {
    317                         rc = fread(&instrx, 1, sizeof(xm_instr_ext_t), f);
    318                         if (rc != sizeof(xm_instr_ext_t)) {
     319                        ret = fread(&instrx, 1, sizeof(xm_instr_ext_t), f);
     320                        if (ret != sizeof(xm_instr_ext_t)) {
    319321                                rc = EIO;
    320322                                goto error;
    … …  
    346348                        pos = ftell(f);
    347349
    348                         rc = fread(&smp, 1, sizeof(xm_smp_t), f);
    349                         if (rc != sizeof(xm_smp_t)) {
     350                        ret = fread(&smp, 1, sizeof(xm_smp_t), f);
     351                        if (ret != sizeof(xm_smp_t)) {
    350352                                rc = EIO;
    351353                                goto error;
Note: See TracChangeset for help on using the changeset viewer.