Changeset b7fd2a0 in mainline for kernel/generic/src/ipc


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.

Location:
kernel/generic/src/ipc
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/ipc/event.c

    r36f0738 rb7fd2a0  
    138138}
    139139
    140 static int event_enqueue(event_t *event, bool mask, sysarg_t a1, sysarg_t a2,
     140static errno_t event_enqueue(event_t *event, bool mask, sysarg_t a1, sysarg_t a2,
    141141    sysarg_t a3, sysarg_t a4, sysarg_t a5)
    142142{
    143         int res;
     143        errno_t res;
    144144
    145145        spinlock_lock(&event->lock);
    … …  
    206206 *
    207207 */
    208 int event_notify(event_type_t evno, bool mask, sysarg_t a1, sysarg_t a2,
     208errno_t event_notify(event_type_t evno, bool mask, sysarg_t a1, sysarg_t a2,
    209209    sysarg_t a3, sysarg_t a4, sysarg_t a5)
    210210{
    … …  
    234234 *
    235235 */
    236 int event_task_notify(task_t *task, event_task_type_t evno, bool mask,
     236errno_t event_task_notify(task_t *task, event_task_type_t evno, bool mask,
    237237    sysarg_t a1, sysarg_t a2, sysarg_t a3, sysarg_t a4, sysarg_t a5)
    238238{
    … …  
    255255 *
    256256 */
    257 static int event_subscribe(event_t *event, sysarg_t imethod,
     257static errno_t event_subscribe(event_t *event, sysarg_t imethod,
    258258    answerbox_t *answerbox)
    259259{
    260         int res;
     260        errno_t res;
    261261       
    262262        spinlock_lock(&event->lock);
    … …  
    286286 *
    287287 */
    288 static int event_unsubscribe(event_t *event, answerbox_t *answerbox)
    289 {
    290         int res;
     288static errno_t event_unsubscribe(event_t *event, answerbox_t *answerbox)
     289{
     290        errno_t res;
    291291       
    292292        spinlock_lock(&event->lock);
    … …  
    338338 *
    339339 */
    340 sysarg_t sys_ipc_event_subscribe(sysarg_t evno, sysarg_t imethod)
     340sys_errno_t sys_ipc_event_subscribe(sysarg_t evno, sysarg_t imethod)
    341341{
    342342        if (evno >= EVENT_TASK_END)
    343343                return ELIMIT;
    344344       
    345         return (sysarg_t) event_subscribe(evno2event(evno, TASK),
     345        return (sys_errno_t) event_subscribe(evno2event(evno, TASK),
    346346            (sysarg_t) imethod, &TASK->answerbox);
    347347}
    … …  
    357357 *
    358358 */
    359 sysarg_t sys_ipc_event_unsubscribe(sysarg_t evno)
     359sys_errno_t sys_ipc_event_unsubscribe(sysarg_t evno)
    360360{
    361361        if (evno >= EVENT_TASK_END)
    362362                return ELIMIT;
    363363       
    364         return (sysarg_t) event_unsubscribe(evno2event(evno, TASK),
     364        return (sys_errno_t) event_unsubscribe(evno2event(evno, TASK),
    365365            &TASK->answerbox);
    366366}
    … …  
    379379 *
    380380 */
    381 sysarg_t sys_ipc_event_unmask(sysarg_t evno)
     381sys_errno_t sys_ipc_event_unmask(sysarg_t evno)
    382382{
    383383        if (evno >= EVENT_TASK_END)

  • kernel/generic/src/ipc/ipc.c

    r36f0738 rb7fd2a0  
    208208 *
    209209 */
    210 int ipc_call_sync(phone_t *phone, call_t *request)
     210errno_t ipc_call_sync(phone_t *phone, call_t *request)
    211211{
    212212        answerbox_t *mybox = slab_alloc(answerbox_cache, 0);
    … …  
    216216        request->callerbox = mybox;
    217217       
    218         int rc = ipc_call(phone, request);
     218        errno_t rc = ipc_call(phone, request);
    219219        if (rc != EOK) {
    220220                slab_free(answerbox_cache, mybox);
    … …  
    371371 *
    372372 */
    373 void ipc_backsend_err(phone_t *phone, call_t *call, int err)
     373void ipc_backsend_err(phone_t *phone, call_t *call, errno_t err)
    374374{
    375375        _ipc_call_actions_internal(phone, call, false);
    … …  
    415415 *
    416416 */
    417 int ipc_call(phone_t *phone, call_t *call)
     417errno_t ipc_call(phone_t *phone, call_t *call)
    418418{
    419419        mutex_lock(&phone->lock);
    … …  
    448448 *
    449449 */
    450 int ipc_phone_hangup(phone_t *phone)
     450errno_t ipc_phone_hangup(phone_t *phone)
    451451{
    452452        mutex_lock(&phone->lock);
    … …  
    495495 *
    496496 */
    497 int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox,
     497errno_t ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox,
    498498    unsigned int mode)
    499499{
    … …  
    535535        uint64_t answer_cnt = 0;
    536536        uint64_t call_cnt = 0;
    537         int rc;
     537        errno_t rc;
    538538       
    539539restart:

  • kernel/generic/src/ipc/ipcrsc.c

    r36f0738 rb7fd2a0  
    170170 * @return  An error code if a new capability cannot be allocated.
    171171 */
    172 int phone_alloc(task_t *task, cap_handle_t *out_handle)
     172errno_t phone_alloc(task_t *task, cap_handle_t *out_handle)
    173173{
    174174        cap_handle_t handle;
    175         int rc = cap_alloc(task, &handle);
     175        errno_t rc = cap_alloc(task, &handle);
    176176        if (rc == EOK) {
    177177                phone_t *phone = slab_alloc(phone_cache, FRAME_ATOMIC);

  • kernel/generic/src/ipc/irq.c

    r36f0738 rb7fd2a0  
    7878}
    7979
    80 static int ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
     80static errno_t ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
    8181    irq_cmd_t *cmds, size_t cmdcount)
    8282{
    … …  
    164164 *
    165165 */
    166 static int code_check(irq_cmd_t *cmds, size_t cmdcount)
     166static errno_t code_check(irq_cmd_t *cmds, size_t cmdcount)
    167167{
    168168        for (size_t i = 0; i < cmdcount; i++) {
    … …  
    226226       
    227227        irq_code_t *code = malloc(sizeof(*code), 0);
    228         int rc = copy_from_uspace(code, ucode, sizeof(*code));
     228        errno_t rc = copy_from_uspace(code, ucode, sizeof(*code));
    229229        if (rc != EOK)
    230230                goto error;
    … …  
    313313 *
    314314 */
    315 int ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
     315errno_t ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
    316316    irq_code_t *ucode, cap_handle_t *uspace_handle)
    317317{
    … …  
    331331         */
    332332        cap_handle_t handle;
    333         int rc = cap_alloc(TASK, &handle);
     333        errno_t rc = cap_alloc(TASK, &handle);
    334334        if (rc != EOK)
    335335                return rc;
    … …  
    390390 *
    391391 */
    392 int ipc_irq_unsubscribe(answerbox_t *box, int handle)
     392errno_t ipc_irq_unsubscribe(answerbox_t *box, int handle)
    393393{
    394394        kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_IRQ);

  • kernel/generic/src/ipc/kbox.c

    r36f0738 rb7fd2a0  
    210210 *
    211211 */
    212 int ipc_connect_kbox(task_id_t taskid, cap_handle_t *out_phone)
     212errno_t ipc_connect_kbox(task_id_t taskid, cap_handle_t *out_phone)
    213213{
    214214        irq_spinlock_lock(&tasks_lock, true);
    … …  
    253253        /* Allocate a new phone. */
    254254        cap_handle_t phone_handle;
    255         int rc = phone_alloc(TASK, &phone_handle);
     255        errno_t rc = phone_alloc(TASK, &phone_handle);
    256256        if (rc != EOK) {
    257257                mutex_unlock(&task->kb.cleanup_lock);

  • kernel/generic/src/ipc/ops/conctmeto.c

    r36f0738 rb7fd2a0  
    4040#include <arch.h>
    4141
    42 static int request_preprocess(call_t *call, phone_t *phone)
     42static errno_t request_preprocess(call_t *call, phone_t *phone)
    4343{
    4444        cap_handle_t phone_handle;
    45         int rc = phone_alloc(TASK, &phone_handle);
     45        errno_t rc = phone_alloc(TASK, &phone_handle);
    4646
    4747        /* Remember the phone capability or that an error occured. */
    … …  
    6161}
    6262
    63 static int request_forget(call_t *call)
     63static errno_t request_forget(call_t *call)
    6464{
    6565        cap_handle_t phone_handle = (cap_handle_t) call->priv;
    … …  
    7777}
    7878
    79 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     79static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    8080{
    8181        /* Hand over reference from ARG5 to phone */
    … …  
    9393}
    9494
    95 static int answer_process(call_t *answer)
     95static errno_t answer_process(call_t *answer)
    9696{
    9797        cap_handle_t phone_handle = (cap_handle_t) answer->priv;

  • kernel/generic/src/ipc/ops/concttome.c

    r36f0738 rb7fd2a0  
    4343{
    4444        cap_handle_t phone_handle;
    45         int rc = phone_alloc(TASK, &phone_handle);
     45        errno_t rc = phone_alloc(TASK, &phone_handle);
    4646        IPC_SET_ARG5(call->data, (rc == EOK) ? phone_handle : -1);
    4747        return 0;
    4848}
    4949
    50 static int answer_cleanup(call_t *answer, ipc_data_t *olddata)
     50static errno_t answer_cleanup(call_t *answer, ipc_data_t *olddata)
    5151{
    5252        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
    … …  
    5858}
    5959
    60 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     60static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    6161{
    6262        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);

  • kernel/generic/src/ipc/ops/dataread.c

    r36f0738 rb7fd2a0  
    4141#include <config.h>
    4242
    43 static int request_preprocess(call_t *call, phone_t *phone)
     43static errno_t request_preprocess(call_t *call, phone_t *phone)
    4444{
    4545        size_t size = IPC_GET_ARG2(call->data);
    … …  
    5757}
    5858
    59 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     59static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    6060{
    6161        assert(!answer->buffer);
    … …  
    7676                               
    7777                        answer->buffer = malloc(size, 0);
    78                         int rc = copy_from_uspace(answer->buffer,
     78                        errno_t rc = copy_from_uspace(answer->buffer,
    7979                            (void *) src, size);
    8080                        if (rc) {
    … …  
    9595}
    9696
    97 static int answer_process(call_t *answer)
     97static errno_t answer_process(call_t *answer)
    9898{
    9999        if (answer->buffer) {
    100100                uintptr_t dst = IPC_GET_ARG1(answer->data);
    101101                size_t size = IPC_GET_ARG2(answer->data);
    102                 int rc;
     102                errno_t rc;
    103103
    104104                rc = copy_to_uspace((void *) dst, answer->buffer, size);

  • kernel/generic/src/ipc/ops/datawrite.c

    r36f0738 rb7fd2a0  
    4141#include <config.h>
    4242
    43 static int request_preprocess(call_t *call, phone_t *phone)
     43static errno_t request_preprocess(call_t *call, phone_t *phone)
    4444{
    4545        uintptr_t src = IPC_GET_ARG1(call->data);
    … …  
    5757
    5858        call->buffer = (uint8_t *) malloc(size, 0);
    59         int rc = copy_from_uspace(call->buffer, (void *) src, size);
     59        errno_t rc = copy_from_uspace(call->buffer, (void *) src, size);
    6060        if (rc != 0) {
    6161                /*
    … …  
    6969}
    7070
    71 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     71static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    7272{
    7373        assert(answer->buffer);
    … …  
    8080                       
    8181                if (size <= max_size) {
    82                         int rc = copy_to_uspace((void *) dst,
     82                        errno_t rc = copy_to_uspace((void *) dst,
    8383                            answer->buffer, size);
    8484                        if (rc)

  • kernel/generic/src/ipc/ops/debug.c

    r36f0738 rb7fd2a0  
    4444}
    4545
    46 static int answer_process(call_t *answer)
     46static errno_t answer_process(call_t *answer)
    4747{
    4848        if (answer->buffer) {
    4949                uintptr_t dst = IPC_GET_ARG1(answer->data);
    5050                size_t size = IPC_GET_ARG2(answer->data);
    51                 int rc;
     51                errno_t rc;
    5252
    5353                rc = copy_to_uspace((void *) dst, answer->buffer, size);

  • kernel/generic/src/ipc/ops/pagein.c

    r36f0738 rb7fd2a0  
    4444#include <arch.h>
    4545
    46 static int pagein_request_preprocess(call_t *call, phone_t *phone)
     46static errno_t pagein_request_preprocess(call_t *call, phone_t *phone)
    4747{
    4848        /*
    … …  
    5858}
    5959
    60 static int pagein_answer_preprocess(call_t *answer, ipc_data_t *olddata)
     60static errno_t pagein_answer_preprocess(call_t *answer, ipc_data_t *olddata)
    6161{
    6262        /*

  • kernel/generic/src/ipc/ops/sharein.c

    r36f0738 rb7fd2a0  
    4141#include <arch.h>
    4242
    43 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     43static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    4444{
    4545        if (!IPC_GET_RETVAL(answer->data)) {
    … …  
    4949                       
    5050                uintptr_t dst_base = (uintptr_t) -1;
    51                 int rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
     51                errno_t rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
    5252                    IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data),
    5353                    &dst_base, IPC_GET_ARG3(answer->data));

  • kernel/generic/src/ipc/ops/shareout.c

    r36f0738 rb7fd2a0  
    4242#include <arch.h>
    4343
    44 static int request_preprocess(call_t *call, phone_t *phone)
     44static errno_t request_preprocess(call_t *call, phone_t *phone)
    4545{
    4646        size_t size = as_area_get_size(IPC_GET_ARG1(call->data));
    … …  
    5353}
    5454
    55 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     55static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    5656{
    57         int rc = EOK;
     57        errno_t rc = EOK;
    5858
    5959        if (!IPC_GET_RETVAL(answer->data)) {

  • kernel/generic/src/ipc/ops/stchngath.c

    r36f0738 rb7fd2a0  
    4141#include <macros.h>
    4242
    43 static int request_preprocess(call_t *call, phone_t *phone)
     43static errno_t request_preprocess(call_t *call, phone_t *phone)
    4444{
    4545        task_t *other_task_s;
    … …  
    6868}
    6969
    70 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
     70static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    7171{
    72         int rc = EOK;
     72        errno_t rc = EOK;
    7373
    7474        if (!IPC_GET_RETVAL(answer->data)) {

  • kernel/generic/src/ipc/sysipc.c

    r36f0738 rb7fd2a0  
    158158 *
    159159 */
    160 int answer_preprocess(call_t *answer, ipc_data_t *olddata)
    161 {
    162         int rc = EOK;
     160errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
     161{
     162        errno_t rc = EOK;
    163163
    164164        spinlock_lock(&answer->forget_lock);
    … …  
    194194        spinlock_unlock(&answer->forget_lock);
    195195
    196         if ((int) IPC_GET_RETVAL(answer->data) == EHANGUP) {
     196        if ((errno_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
    197197                phone_t *phone = answer->caller_phone;
    198198                mutex_lock(&phone->lock);
    … …  
    222222 *
    223223 */
    224 static int request_preprocess(call_t *call, phone_t *phone)
     224static errno_t request_preprocess(call_t *call, phone_t *phone)
    225225{
    226226        call->request_method = IPC_GET_IMETHOD(call->data);
    … …  
    239239static void process_answer(call_t *call)
    240240{
    241         if (((int) IPC_GET_RETVAL(call->data) == EHANGUP) &&
     241        if (((errno_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
    242242            (call->flags & IPC_CALL_FORWARDED))
    243243                IPC_SET_RETVAL(call->data, EFORWARD);
    … …  
    271271 *
    272272 */
    273 int ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
     273errno_t ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
    274274{
    275275        kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
    … …  
    281281        memcpy(call->data.args, data->args, sizeof(data->args));
    282282       
    283         int rc = request_preprocess(call, kobj->phone);
     283        errno_t rc = request_preprocess(call, kobj->phone);
    284284        if (!rc) {
    285285#ifdef CONFIG_UDEBUG
    … …  
    362362 *
    363363 */
    364 sysarg_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
     364sys_errno_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
    365365    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t label)
    366366{
    … …  
    389389        call->data.label = label;
    390390       
    391         int res = request_preprocess(call, kobj->phone);
     391        errno_t res = request_preprocess(call, kobj->phone);
    392392       
    393393        if (!res)
    … …  
    409409 *
    410410 */
    411 sysarg_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
     411sys_errno_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
    412412    sysarg_t label)
    413413{
    … …  
    422422
    423423        call_t *call = ipc_call_alloc(0);
    424         int rc = copy_from_uspace(&call->data.args, &data->args,
     424        errno_t rc = copy_from_uspace(&call->data.args, &data->args,
    425425            sizeof(call->data.args));
    426426        if (rc != 0) {
    427427                kobject_put(call->kobject);
    428428                kobject_put(kobj);
    429                 return (sysarg_t) rc;
     429                return (sys_errno_t) rc;
    430430        }
    431431
    … …  
    433433        call->data.label = label;
    434434       
    435         int res = request_preprocess(call, kobj->phone);
     435        errno_t res = request_preprocess(call, kobj->phone);
    436436       
    437437        if (!res)
    … …  
    466466 *
    467467 */
    468 static sysarg_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
     468static sys_errno_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
    469469    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
    470470    sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
    … …  
    482482       
    483483        bool after_forward = false;
    484         int rc;
     484        errno_t rc;
    485485
    486486        kobject_t *pkobj = kobject_get(TASK, phandle, KOBJECT_TYPE_PHONE);
    … …  
    577577 *
    578578 */
    579 sysarg_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
     579sys_errno_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
    580580    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    581581{
    … …  
    601601 *
    602602 */
    603 sysarg_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
     603sys_errno_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
    604604    ipc_data_t *data, unsigned int mode)
    605605{
    606606        ipc_data_t newdata;
    607         int rc = copy_from_uspace(&newdata.args, &data->args,
     607        errno_t rc = copy_from_uspace(&newdata.args, &data->args,
    608608            sizeof(newdata.args));
    609609        if (rc != 0)
    610                 return (sysarg_t) rc;
     610                return (sys_errno_t) rc;
    611611       
    612612        return sys_ipc_forward_common(chandle, phandle,
    … …  
    631631 *
    632632 */
    633 sysarg_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
     633sys_errno_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
    634634    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    635635{
    … …  
    660660         */
    661661        IPC_SET_ARG5(call->data, 0);
    662         int rc = answer_preprocess(call, saved ? &saved_data : NULL);
     662        errno_t rc = answer_preprocess(call, saved ? &saved_data : NULL);
    663663       
    664664        ipc_answer(&TASK->answerbox, call);
    … …  
    678678 *
    679679 */
    680 sysarg_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
     680sys_errno_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
    681681{
    682682        kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
    … …  
    695695                saved = false;
    696696       
    697         int rc = copy_from_uspace(&call->data.args, &data->args,
     697        errno_t rc = copy_from_uspace(&call->data.args, &data->args,
    698698            sizeof(call->data.args));
    699699        if (rc != 0) {
    … …  
    722722 *
    723723 */
    724 sysarg_t sys_ipc_hangup(sysarg_t handle)
     724sys_errno_t sys_ipc_hangup(sysarg_t handle)
    725725{
    726726        kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
    … …  
    728728                return ENOENT;
    729729       
    730         int rc = ipc_phone_hangup(kobj->phone);
     730        errno_t rc = ipc_phone_hangup(kobj->phone);
    731731        kobject_put(kobj);
    732732        return rc;
    … …  
    742742 * @return An error code on error.
    743743 */
    744 sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     744sys_errno_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
    745745    unsigned int flags)
    746746{
    … …  
    800800       
    801801        cap_handle_t handle;
    802         int rc = cap_alloc(TASK, &handle);
     802        errno_t rc = cap_alloc(TASK, &handle);
    803803        if (rc != EOK) {
    804804                goto error;
    … …  
    848848 *
    849849 */
    850 sysarg_t sys_ipc_poke(void)
     850sys_errno_t sys_ipc_poke(void)
    851851{
    852852        waitq_unsleep(&TASK->answerbox.wq);
    … …  
    866866 *
    867867 */
    868 sysarg_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode,
     868sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode,
    869869        cap_handle_t *uspace_handle)
    870870{
    … …  
    883883 *
    884884 */
    885 sysarg_t sys_ipc_irq_unsubscribe(sysarg_t cap)
     885sys_errno_t sys_ipc_irq_unsubscribe(sysarg_t cap)
    886886{
    887887        if (!(perm_get(TASK) & PERM_IRQ_REG))
    … …  
    898898 *
    899899 */
    900 sysarg_t sys_ipc_connect_kbox(task_id_t *uspace_taskid, cap_handle_t *uspace_phone)
     900sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid, cap_handle_t *uspace_phone)
    901901{
    902902#ifdef CONFIG_UDEBUG
    … …  
    904904        cap_handle_t phone;
    905905       
    906         int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(task_id_t));
     906        errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(task_id_t));
    907907        if (rc == EOK) {
    908908                rc = ipc_connect_kbox((task_id_t) taskid, &phone);
    … …  
    917917        }
    918918       
    919         return (sysarg_t) rc;
     919        return (sys_errno_t) rc;
    920920#else
    921         return (sysarg_t) ENOTSUP;
     921        return (sys_errno_t) ENOTSUP;
    922922#endif
    923923}

  • kernel/generic/src/ipc/sysipc_ops.c

    r36f0738 rb7fd2a0  
    6969};
    7070
    71 int null_request_preprocess(call_t *call, phone_t *phone)
     71errno_t null_request_preprocess(call_t *call, phone_t *phone)
    7272{
    7373        return EOK;
    7474}
    7575
    76 int null_request_forget(call_t *call)
     76errno_t null_request_forget(call_t *call)
    7777{
    7878        return EOK;
    … …  
    8484}
    8585
    86 int null_answer_cleanup(call_t *call, ipc_data_t *data)
     86errno_t null_answer_cleanup(call_t *call, ipc_data_t *data)
    8787{
    8888        return EOK;
    8989}
    9090
    91 int null_answer_preprocess(call_t *call, ipc_data_t *data)
     91errno_t null_answer_preprocess(call_t *call, ipc_data_t *data)
    9292{
    9393        return EOK;
    9494}
    9595
    96 int null_answer_process(call_t *call)
     96errno_t null_answer_process(call_t *call)
    9797{
    9898        return EOK;
Note: See TracChangeset for help on using the changeset viewer.