Changeset fafb8e5 in mainline for kernel


Ignore:
Timestamp:
2019-02-06T13:25:12Z (6 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:
95a47b0
Parents:
eb13ef8
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-02 14:10:59)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-06 13:25:12)
Message:

Mechanically lowercase IPC_SET_*/IPC_GET_*

Location:
kernel/generic/src
Files:
18 edited

Legend:

Unmodified
Added
Removed

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

    reb13ef8 rfafb8e5  
    153153                                call->priv = ++event->counter;
    154154
    155                                 IPC_SET_IMETHOD(&call->data, event->imethod);
    156                                 IPC_SET_ARG1(&call->data, a1);
    157                                 IPC_SET_ARG2(&call->data, a2);
    158                                 IPC_SET_ARG3(&call->data, a3);
    159                                 IPC_SET_ARG4(&call->data, a4);
    160                                 IPC_SET_ARG5(&call->data, a5);
     155                                ipc_set_imethod(&call->data, event->imethod);
     156                                ipc_set_arg1(&call->data, a1);
     157                                ipc_set_arg2(&call->data, a2);
     158                                ipc_set_arg3(&call->data, a3);
     159                                ipc_set_arg4(&call->data, a4);
     160                                ipc_set_arg5(&call->data, a5);
    161161
    162162                                call->data.task_id = TASK ? TASK->taskid : 0;

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

    reb13ef8 rfafb8e5  
    387387{
    388388        _ipc_call_actions_internal(phone, call, false);
    389         IPC_SET_RETVAL(&call->data, err);
     389        ipc_set_retval(&call->data, err);
    390390        _ipc_answer_free_call(call, false);
    391391}
    … …  
    485485                assert(call);
    486486
    487                 IPC_SET_IMETHOD(&call->data, IPC_M_PHONE_HUNGUP);
     487                ipc_set_imethod(&call->data, IPC_M_PHONE_HUNGUP);
    488488                call->request_method = IPC_M_PHONE_HUNGUP;
    489489                call->flags |= IPC_CALL_DISCARD_ANSWER;
    … …  
    634634
    635635                ipc_data_t old = call->data;
    636                 IPC_SET_RETVAL(&call->data, EHANGUP);
     636                ipc_set_retval(&call->data, EHANGUP);
    637637                answer_preprocess(call, &old);
    638638                _ipc_answer_free_call(call, true);
    … …  
    690690                        assert(call);
    691691
    692                         IPC_SET_IMETHOD(&call->data, IPC_M_PHONE_HUNGUP);
     692                        ipc_set_imethod(&call->data, IPC_M_PHONE_HUNGUP);
    693693                        call->request_method = IPC_M_PHONE_HUNGUP;
    694694                        call->flags |= IPC_CALL_DISCARD_ANSWER;
    … …  
    909909                printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun
    910910                    " %-6" PRIun " %-6" PRIun " %-7x",
    911                     IPC_GET_IMETHOD(&call->data), IPC_GET_ARG1(&call->data),
    912                     IPC_GET_ARG2(&call->data), IPC_GET_ARG3(&call->data),
    913                     IPC_GET_ARG4(&call->data), IPC_GET_ARG5(&call->data),
     911                    ipc_get_imethod(&call->data), ipc_get_arg1(&call->data),
     912                    ipc_get_arg2(&call->data), ipc_get_arg3(&call->data),
     913                    ipc_get_arg4(&call->data), ipc_get_arg5(&call->data),
    914914                    call->flags);
    915915

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

    reb13ef8 rfafb8e5  
    539539
    540540                /* Set up args */
    541                 IPC_SET_IMETHOD(&call->data, irq->notif_cfg.imethod);
    542                 IPC_SET_ARG1(&call->data, irq->notif_cfg.scratch[1]);
    543                 IPC_SET_ARG2(&call->data, irq->notif_cfg.scratch[2]);
    544                 IPC_SET_ARG3(&call->data, irq->notif_cfg.scratch[3]);
    545                 IPC_SET_ARG4(&call->data, irq->notif_cfg.scratch[4]);
    546                 IPC_SET_ARG5(&call->data, irq->notif_cfg.scratch[5]);
     541                ipc_set_imethod(&call->data, irq->notif_cfg.imethod);
     542                ipc_set_arg1(&call->data, irq->notif_cfg.scratch[1]);
     543                ipc_set_arg2(&call->data, irq->notif_cfg.scratch[2]);
     544                ipc_set_arg3(&call->data, irq->notif_cfg.scratch[3]);
     545                ipc_set_arg4(&call->data, irq->notif_cfg.scratch[4]);
     546                ipc_set_arg5(&call->data, irq->notif_cfg.scratch[5]);
    547547
    548548                send_call(irq, call);
    … …  
    576576                call->priv = ++irq->notif_cfg.counter;
    577577
    578                 IPC_SET_IMETHOD(&call->data, irq->notif_cfg.imethod);
    579                 IPC_SET_ARG1(&call->data, a1);
    580                 IPC_SET_ARG2(&call->data, a2);
    581                 IPC_SET_ARG3(&call->data, a3);
    582                 IPC_SET_ARG4(&call->data, a4);
    583                 IPC_SET_ARG5(&call->data, a5);
     578                ipc_set_imethod(&call->data, irq->notif_cfg.imethod);
     579                ipc_set_arg1(&call->data, a1);
     580                ipc_set_arg2(&call->data, a2);
     581                ipc_set_arg3(&call->data, a3);
     582                ipc_set_arg4(&call->data, a4);
     583                ipc_set_arg5(&call->data, a5);
    584584
    585585                send_call(irq, call);

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

    reb13ef8 rfafb8e5  
    121121
    122122        LOG("Continue with hangup message.");
    123         IPC_SET_RETVAL(&call->data, 0);
     123        ipc_set_retval(&call->data, 0);
    124124        ipc_answer(&TASK->kb.box, call);
    125125
    … …  
    174174                        continue;  /* Try again. */
    175175
    176                 switch (IPC_GET_IMETHOD(&call->data)) {
     176                switch (ipc_get_imethod(&call->data)) {
    177177
    178178                case IPC_M_DEBUG:

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

    reb13ef8 rfafb8e5  
    5959
    6060        /* Remember the handle */
    61         IPC_SET_ARG5(&call->data, (sysarg_t) phandle);
     61        ipc_set_arg5(&call->data, (sysarg_t) phandle);
    6262
    6363        return EOK;
    … …  
    6666static errno_t request_forget(call_t *call)
    6767{
    68         cap_phone_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(&call->data);
     68        cap_phone_handle_t phandle = (cap_handle_t) ipc_get_arg5(&call->data);
    6969
    7070        if (cap_handle_raw(phandle) < 0)
    … …  
    8888
    8989        /* Set the recipient-assigned label */
    90         pobj->phone->label = IPC_GET_ARG5(&answer->data);
     90        pobj->phone->label = ipc_get_arg5(&answer->data);
    9191
    9292        /* Restore phone handle in answer's ARG5 */
    93         IPC_SET_ARG5(&answer->data, IPC_GET_ARG5(olddata));
     93        ipc_set_arg5(&answer->data, ipc_get_arg5(olddata));
    9494
    9595        /* If the user accepted the call, connect */
    96         if (IPC_GET_RETVAL(&answer->data) == EOK) {
     96        if (ipc_get_retval(&answer->data) == EOK) {
    9797                /* Hand over reference from pobj to the answerbox */
    9898                (void) ipc_phone_connect(pobj->phone, &TASK->answerbox);
    … …  
    107107static errno_t answer_process(call_t *answer)
    108108{
    109         cap_phone_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(&answer->data);
     109        cap_phone_handle_t phandle = (cap_handle_t) ipc_get_arg5(&answer->data);
    110110        /* Move the reference from answer->priv to pobj */
    111111        kobject_t *pobj = (kobject_t *) answer->priv;
    112112        answer->priv = 0;
    113113
    114         if (IPC_GET_RETVAL(&answer->data)) {
     114        if (ipc_get_retval(&answer->data)) {
    115115                if (cap_handle_raw(phandle) >= 0) {
    116116                        /*

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

    reb13ef8 rfafb8e5  
    4949                 * Set the sender-assigned label to the new phone.
    5050                 */
    51                 pobj->phone->label = IPC_GET_ARG5(&call->data);
     51                pobj->phone->label = ipc_get_arg5(&call->data);
    5252        }
    5353        call->priv = (sysarg_t) pobj;
    54         IPC_SET_ARG5(&call->data, cap_handle_raw(phandle));
     54        ipc_set_arg5(&call->data, cap_handle_raw(phandle));
    5555        return 0;
    5656}
    … …  
    5858static errno_t answer_cleanup(call_t *answer, ipc_data_t *olddata)
    5959{
    60         cap_phone_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(olddata);
     60        cap_phone_handle_t phandle = (cap_handle_t) ipc_get_arg5(olddata);
    6161        kobject_t *pobj = (kobject_t *) answer->priv;
    6262
    … …  
    7171static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    7272{
    73         cap_phone_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(olddata);
     73        cap_phone_handle_t phandle = (cap_handle_t) ipc_get_arg5(olddata);
    7474        kobject_t *pobj = (kobject_t *) answer->priv;
    7575
    76         if (IPC_GET_RETVAL(&answer->data) != EOK) {
     76        if (ipc_get_retval(&answer->data) != EOK) {
    7777                /* The connection was not accepted */
    7878                answer_cleanup(answer, olddata);
    … …  
    9494                } else {
    9595                        /* The answerbox is shutting down. */
    96                         IPC_SET_RETVAL(&answer->data, ENOENT);
     96                        ipc_set_retval(&answer->data, ENOENT);
    9797                        answer_cleanup(answer, olddata);
    9898                }
    9999        } else {
    100                 IPC_SET_RETVAL(&answer->data, ELIMIT);
     100                ipc_set_retval(&answer->data, ELIMIT);
    101101        }
    102102

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

    reb13ef8 rfafb8e5  
    4343static errno_t request_preprocess(call_t *call, phone_t *phone)
    4444{
    45         size_t size = IPC_GET_ARG2(&call->data);
     45        size_t size = ipc_get_arg2(&call->data);
    4646
    4747        if (size > DATA_XFER_LIMIT) {
    48                 int flags = IPC_GET_ARG3(&call->data);
     48                int flags = ipc_get_arg3(&call->data);
    4949
    5050                if (flags & IPC_XF_RESTRICT)
    51                         IPC_SET_ARG2(&call->data, DATA_XFER_LIMIT);
     51                        ipc_set_arg2(&call->data, DATA_XFER_LIMIT);
    5252                else
    5353                        return ELIMIT;
    … …  
    6161        assert(!answer->buffer);
    6262
    63         if (!IPC_GET_RETVAL(&answer->data)) {
     63        if (!ipc_get_retval(&answer->data)) {
    6464                /* The recipient agreed to send data. */
    65                 uintptr_t src = IPC_GET_ARG1(&answer->data);
    66                 uintptr_t dst = IPC_GET_ARG1(olddata);
    67                 size_t max_size = IPC_GET_ARG2(olddata);
    68                 size_t size = IPC_GET_ARG2(&answer->data);
     65                uintptr_t src = ipc_get_arg1(&answer->data);
     66                uintptr_t dst = ipc_get_arg1(olddata);
     67                size_t max_size = ipc_get_arg2(olddata);
     68                size_t size = ipc_get_arg2(&answer->data);
    6969
    7070                if (size && size <= max_size) {
    … …  
    7373                         * information is not lost.
    7474                         */
    75                         IPC_SET_ARG1(&answer->data, dst);
     75                        ipc_set_arg1(&answer->data, dst);
    7676
    7777                        answer->buffer = malloc(size);
    7878                        if (!answer->buffer) {
    79                                 IPC_SET_RETVAL(&answer->data, ENOMEM);
     79                                ipc_set_retval(&answer->data, ENOMEM);
    8080                                return EOK;
    8181                        }
    … …  
    8383                            (void *) src, size);
    8484                        if (rc) {
    85                                 IPC_SET_RETVAL(&answer->data, rc);
     85                                ipc_set_retval(&answer->data, rc);
    8686                                /*
    8787                                 * answer->buffer will be cleaned up in
    … …  
    9191                        }
    9292                } else if (!size) {
    93                         IPC_SET_RETVAL(&answer->data, EOK);
     93                        ipc_set_retval(&answer->data, EOK);
    9494                } else {
    95                         IPC_SET_RETVAL(&answer->data, ELIMIT);
     95                        ipc_set_retval(&answer->data, ELIMIT);
    9696                }
    9797        }
    … …  
    103103{
    104104        if (answer->buffer) {
    105                 uintptr_t dst = IPC_GET_ARG1(&answer->data);
    106                 size_t size = IPC_GET_ARG2(&answer->data);
     105                uintptr_t dst = ipc_get_arg1(&answer->data);
     106                size_t size = ipc_get_arg2(&answer->data);
    107107                errno_t rc;
    108108
    109109                rc = copy_to_uspace((void *) dst, answer->buffer, size);
    110110                if (rc)
    111                         IPC_SET_RETVAL(&answer->data, rc);
     111                        ipc_set_retval(&answer->data, rc);
    112112        }
    113113

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

    reb13ef8 rfafb8e5  
    4343static errno_t request_preprocess(call_t *call, phone_t *phone)
    4444{
    45         uintptr_t src = IPC_GET_ARG1(&call->data);
    46         size_t size = IPC_GET_ARG2(&call->data);
     45        uintptr_t src = ipc_get_arg1(&call->data);
     46        size_t size = ipc_get_arg2(&call->data);
    4747
    4848        if (size > DATA_XFER_LIMIT) {
    49                 int flags = IPC_GET_ARG3(&call->data);
     49                int flags = ipc_get_arg3(&call->data);
    5050
    5151                if (flags & IPC_XF_RESTRICT) {
    5252                        size = DATA_XFER_LIMIT;
    53                         IPC_SET_ARG2(&call->data, size);
     53                        ipc_set_arg2(&call->data, size);
    5454                } else
    5555                        return ELIMIT;
    … …  
    7575        assert(answer->buffer);
    7676
    77         if (!IPC_GET_RETVAL(&answer->data)) {
     77        if (!ipc_get_retval(&answer->data)) {
    7878                /* The recipient agreed to receive data. */
    79                 uintptr_t dst = (uintptr_t)IPC_GET_ARG1(&answer->data);
    80                 size_t size = (size_t)IPC_GET_ARG2(&answer->data);
    81                 size_t max_size = (size_t)IPC_GET_ARG2(olddata);
     79                uintptr_t dst = (uintptr_t)ipc_get_arg1(&answer->data);
     80                size_t size = (size_t)ipc_get_arg2(&answer->data);
     81                size_t max_size = (size_t)ipc_get_arg2(olddata);
    8282
    8383                if (size <= max_size) {
    … …  
    8585                            answer->buffer, size);
    8686                        if (rc)
    87                                 IPC_SET_RETVAL(&answer->data, rc);
     87                                ipc_set_retval(&answer->data, rc);
    8888                } else {
    89                         IPC_SET_RETVAL(&answer->data, ELIMIT);
     89                        ipc_set_retval(&answer->data, ELIMIT);
    9090                }
    9191        }

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

    reb13ef8 rfafb8e5  
    4747{
    4848        if (answer->buffer) {
    49                 uintptr_t dst = IPC_GET_ARG1(&answer->data);
    50                 size_t size = IPC_GET_ARG2(&answer->data);
     49                uintptr_t dst = ipc_get_arg1(&answer->data);
     50                size_t size = ipc_get_arg2(&answer->data);
    5151                errno_t rc;
    5252
    5353                rc = copy_to_uspace((void *) dst, answer->buffer, size);
    5454                if (rc)
    55                         IPC_SET_RETVAL(&answer->data, rc);
     55                        ipc_set_retval(&answer->data, rc);
    5656        }
    5757

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

    reb13ef8 rfafb8e5  
    6868                return EOK;
    6969
    70         if (!IPC_GET_RETVAL(&answer->data)) {
     70        if (!ipc_get_retval(&answer->data)) {
    7171
    7272                pte_t pte;
    … …  
    7474
    7575                page_table_lock(AS, true);
    76                 bool found = page_mapping_find(AS, IPC_GET_ARG1(&answer->data),
     76                bool found = page_mapping_find(AS, ipc_get_arg1(&answer->data),
    7777                    false, &pte);
    7878                if (found & PTE_PRESENT(&pte)) {
    … …  
    8686                                frame_reference_add(ADDR2PFN(frame));
    8787                        }
    88                         IPC_SET_ARG1(&answer->data, frame);
     88                        ipc_set_arg1(&answer->data, frame);
    8989                } else {
    90                         IPC_SET_RETVAL(&answer->data, ENOENT);
     90                        ipc_set_retval(&answer->data, ENOENT);
    9191                }
    9292                page_table_unlock(AS, true);

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

    reb13ef8 rfafb8e5  
    4343static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
    4444{
    45         if (!IPC_GET_RETVAL(&answer->data)) {
     45        if (!ipc_get_retval(&answer->data)) {
    4646                irq_spinlock_lock(&answer->sender->lock, true);
    4747                as_t *as = answer->sender->as;
    … …  
    4949
    5050                uintptr_t dst_base = (uintptr_t) -1;
    51                 errno_t rc = as_area_share(AS, IPC_GET_ARG1(&answer->data),
    52                     IPC_GET_ARG1(olddata), as, IPC_GET_ARG2(&answer->data),
    53                     &dst_base, IPC_GET_ARG2(olddata));
    54                 IPC_SET_ARG5(&answer->data, dst_base);
    55                 IPC_SET_RETVAL(&answer->data, rc);
     51                errno_t rc = as_area_share(AS, ipc_get_arg1(&answer->data),
     52                    ipc_get_arg1(olddata), as, ipc_get_arg2(&answer->data),
     53                    &dst_base, ipc_get_arg2(olddata));
     54                ipc_set_arg5(&answer->data, dst_base);
     55                ipc_set_retval(&answer->data, rc);
    5656        }
    5757

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

    reb13ef8 rfafb8e5  
    4444static errno_t request_preprocess(call_t *call, phone_t *phone)
    4545{
    46         size_t size = as_area_get_size(IPC_GET_ARG1(&call->data));
     46        size_t size = as_area_get_size(ipc_get_arg1(&call->data));
    4747
    4848        if (!size)
    4949                return EPERM;
    50         IPC_SET_ARG2(&call->data, size);
     50        ipc_set_arg2(&call->data, size);
    5151
    5252        return EOK;
    … …  
    5757        errno_t rc = EOK;
    5858
    59         if (!IPC_GET_RETVAL(&answer->data)) {
     59        if (!ipc_get_retval(&answer->data)) {
    6060                /* Accepted, handle as_area receipt */
    6161
    … …  
    6565
    6666                uintptr_t dst_base = (uintptr_t) -1;
    67                 rc = as_area_share(as, IPC_GET_ARG1(olddata),
    68                     IPC_GET_ARG2(olddata), AS, IPC_GET_ARG3(olddata),
    69                     &dst_base, IPC_GET_ARG1(&answer->data));
     67                rc = as_area_share(as, ipc_get_arg1(olddata),
     68                    ipc_get_arg2(olddata), AS, ipc_get_arg3(olddata),
     69                    &dst_base, ipc_get_arg1(&answer->data));
    7070
    7171                if (rc == EOK) {
    72                         rc = copy_to_uspace((void *) IPC_GET_ARG2(&answer->data),
     72                        rc = copy_to_uspace((void *) ipc_get_arg2(&answer->data),
    7373                            &dst_base, sizeof(dst_base));
    7474                }
    7575
    76                 IPC_SET_RETVAL(&answer->data, rc);
     76                ipc_set_retval(&answer->data, rc);
    7777        }
    7878

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

    reb13ef8 rfafb8e5  
    4646
    4747        kobject_t *sender_obj = kobject_get(TASK,
    48             (cap_handle_t) IPC_GET_ARG5(&call->data), KOBJECT_TYPE_PHONE);
     48            (cap_handle_t) ipc_get_arg5(&call->data), KOBJECT_TYPE_PHONE);
    4949        if (!sender_obj)
    5050                return ENOENT;
    … …  
    6262
    6363        /* Remember the third party task hash. */
    64         IPC_SET_ARG5(&call->data, (sysarg_t) other_task_s);
     64        ipc_set_arg5(&call->data, (sysarg_t) other_task_s);
    6565
    6666        kobject_put(sender_obj);
    … …  
    7272        errno_t rc = EOK;
    7373
    74         if (!IPC_GET_RETVAL(&answer->data)) {
     74        if (!ipc_get_retval(&answer->data)) {
    7575                /* The recipient authorized the change of state. */
    7676                task_t *other_task_s;
    … …  
    7878
    7979                kobject_t *recipient_obj = kobject_get(TASK,
    80                     (cap_handle_t) IPC_GET_ARG1(&answer->data),
     80                    (cap_handle_t) ipc_get_arg1(&answer->data),
    8181                    KOBJECT_TYPE_PHONE);
    8282                if (!recipient_obj) {
    83                         IPC_SET_RETVAL(&answer->data, ENOENT);
     83                        ipc_set_retval(&answer->data, ENOENT);
    8484                        return ENOENT;
    8585                }
    … …  
    8888                if (recipient_obj->phone->state != IPC_PHONE_CONNECTED) {
    8989                        mutex_unlock(&recipient_obj->phone->lock);
    90                         IPC_SET_RETVAL(&answer->data, EINVAL);
     90                        ipc_set_retval(&answer->data, EINVAL);
    9191                        kobject_put(recipient_obj);
    9292                        return EINVAL;
    … …  
    9494
    9595                other_task_r = recipient_obj->phone->callee->task;
    96                 other_task_s = (task_t *) IPC_GET_ARG5(olddata);
     96                other_task_s = (task_t *) ipc_get_arg5(olddata);
    9797
    9898                /*
    … …  
    101101                 */
    102102                if (other_task_r != other_task_s) {
    103                         IPC_SET_RETVAL(&answer->data, EINVAL);
     103                        ipc_set_retval(&answer->data, EINVAL);
    104104                        rc = EINVAL;
    105105                } else {
    106106                        rc = event_task_notify_5(other_task_r,
    107107                            EVENT_TASK_STATE_CHANGE, false,
    108                             IPC_GET_ARG1(olddata),
    109                             IPC_GET_ARG2(olddata),
    110                             IPC_GET_ARG3(olddata),
     108                            ipc_get_arg1(olddata),
     109                            ipc_get_arg2(olddata),
     110                            ipc_get_arg3(olddata),
    111111                            LOWER32(olddata->task_id),
    112112                            UPPER32(olddata->task_id));
    113                         IPC_SET_RETVAL(&answer->data, rc);
     113                        ipc_set_retval(&answer->data, rc);
    114114                }
    115115

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

    reb13ef8 rfafb8e5  
    131131static inline bool answer_need_old(call_t *call)
    132132{
    133         switch (IPC_GET_IMETHOD(&call->data)) {
     133        switch (ipc_get_imethod(&call->data)) {
    134134        case IPC_M_CONNECT_TO_ME:
    135135        case IPC_M_CONNECT_ME_TO:
    … …  
    192192        spinlock_unlock(&answer->forget_lock);
    193193
    194         if ((errno_t) IPC_GET_RETVAL(&answer->data) == EHANGUP) {
     194        if ((errno_t) ipc_get_retval(&answer->data) == EHANGUP) {
    195195                phone_t *phone = answer->caller_phone;
    196196                mutex_lock(&phone->lock);
    … …  
    223223static errno_t request_preprocess(call_t *call, phone_t *phone)
    224224{
    225         call->request_method = IPC_GET_IMETHOD(&call->data);
     225        call->request_method = ipc_get_imethod(&call->data);
    226226        return SYSIPC_OP(request_preprocess, call, phone);
    227227}
    … …  
    238238static void process_answer(call_t *call)
    239239{
    240         if (((errno_t) IPC_GET_RETVAL(&call->data) == EHANGUP) &&
     240        if (((errno_t) ipc_get_retval(&call->data) == EHANGUP) &&
    241241            (call->flags & IPC_CALL_FORWARDED))
    242                 IPC_SET_RETVAL(&call->data, EFORWARD);
     242                ipc_set_retval(&call->data, EFORWARD);
    243243
    244244        SYSIPC_OP(answer_process, call);
    … …  
    326326                process_answer(call);
    327327        } else
    328                 IPC_SET_RETVAL(&call->data, rc);
     328                ipc_set_retval(&call->data, rc);
    329329
    330330        memcpy(data->args, call->data.args, sizeof(data->args));
    … …  
    385385        }
    386386
    387         IPC_SET_IMETHOD(&call->data, imethod);
    388         IPC_SET_ARG1(&call->data, arg1);
    389         IPC_SET_ARG2(&call->data, arg2);
    390         IPC_SET_ARG3(&call->data, arg3);
     387        ipc_set_imethod(&call->data, imethod);
     388        ipc_set_arg1(&call->data, arg1);
     389        ipc_set_arg2(&call->data, arg2);
     390        ipc_set_arg3(&call->data, arg3);
    391391
    392392        /*
    … …  
    394394         * the limits of the fast version.
    395395         */
    396         IPC_SET_ARG5(&call->data, 0);
     396        ipc_set_arg5(&call->data, 0);
    397397
    398398        /* Set the user-defined label */
    … …  
    505505        }
    506506
    507         if (!method_is_forwardable(IPC_GET_IMETHOD(&call->data))) {
     507        if (!method_is_forwardable(ipc_get_imethod(&call->data))) {
    508508                rc = EPERM;
    509509                goto error;
    … …  
    518518         * If the interface and method is immutable, don't change anything.
    519519         */
    520         if (!method_is_immutable(IPC_GET_IMETHOD(&call->data))) {
    521                 if (method_is_system(IPC_GET_IMETHOD(&call->data))) {
    522                         if (IPC_GET_IMETHOD(&call->data) ==
     520        if (!method_is_immutable(ipc_get_imethod(&call->data))) {
     521                if (method_is_system(ipc_get_imethod(&call->data))) {
     522                        if (ipc_get_imethod(&call->data) ==
    523523                            IPC_M_CONNECT_TO_ME) {
    524524                                kobject_put((kobject_t *) call->priv);
    525525                                call->priv = 0;
    526526                                cap_free(TASK,
    527                                     (cap_handle_t) IPC_GET_ARG5(&call->data));
     527                                    (cap_handle_t) ipc_get_arg5(&call->data));
    528528                        }
    529529
    530                         IPC_SET_ARG1(&call->data, imethod);
    531                         IPC_SET_ARG2(&call->data, arg1);
    532                         IPC_SET_ARG3(&call->data, arg2);
     530                        ipc_set_arg1(&call->data, imethod);
     531                        ipc_set_arg2(&call->data, arg1);
     532                        ipc_set_arg3(&call->data, arg2);
    533533
    534534                        if (slow)
    535                                 IPC_SET_ARG4(&call->data, arg3);
     535                                ipc_set_arg4(&call->data, arg3);
    536536
    537537                        /*
    … …  
    540540                         */
    541541                } else {
    542                         IPC_SET_IMETHOD(&call->data, imethod);
    543                         IPC_SET_ARG1(&call->data, arg1);
    544                         IPC_SET_ARG2(&call->data, arg2);
     542                        ipc_set_imethod(&call->data, imethod);
     543                        ipc_set_arg1(&call->data, arg1);
     544                        ipc_set_arg2(&call->data, arg2);
    545545                        if (slow) {
    546                                 IPC_SET_ARG3(&call->data, arg3);
    547                                 IPC_SET_ARG4(&call->data, arg4);
    548                                 IPC_SET_ARG5(&call->data, arg5);
     546                                ipc_set_arg3(&call->data, arg3);
     547                                ipc_set_arg4(&call->data, arg4);
     548                                ipc_set_arg5(&call->data, arg5);
    549549                        }
    550550                }
    … …  
    563563
    564564error:
    565         IPC_SET_RETVAL(&call->data, EFORWARD);
     565        ipc_set_retval(&call->data, EFORWARD);
    566566        (void) answer_preprocess(call, need_old ? &old : NULL);
    567567        if (after_forward)
    … …  
    632632
    633633        return sys_ipc_forward_common(chandle, phandle,
    634             IPC_GET_IMETHOD(&newdata), IPC_GET_ARG1(&newdata),
    635             IPC_GET_ARG2(&newdata), IPC_GET_ARG3(&newdata),
    636             IPC_GET_ARG4(&newdata), IPC_GET_ARG5(&newdata), mode, true);
     634            ipc_get_imethod(&newdata), ipc_get_arg1(&newdata),
     635            ipc_get_arg2(&newdata), ipc_get_arg3(&newdata),
     636            ipc_get_arg4(&newdata), ipc_get_arg5(&newdata), mode, true);
    637637}
    638638
    … …  
    671671                saved = false;
    672672
    673         IPC_SET_RETVAL(&call->data, retval);
    674         IPC_SET_ARG1(&call->data, arg1);
    675         IPC_SET_ARG2(&call->data, arg2);
    676         IPC_SET_ARG3(&call->data, arg3);
    677         IPC_SET_ARG4(&call->data, arg4);
     673        ipc_set_retval(&call->data, retval);
     674        ipc_set_arg1(&call->data, arg1);
     675        ipc_set_arg2(&call->data, arg2);
     676        ipc_set_arg3(&call->data, arg3);
     677        ipc_set_arg4(&call->data, arg4);
    678678
    679679        /*
    … …  
    681681         * the limits of the fast version.
    682682         */
    683         IPC_SET_ARG5(&call->data, 0);
     683        ipc_set_arg5(&call->data, 0);
    684684        errno_t rc = answer_preprocess(call, saved ? &saved_data : NULL);
    685685
    … …  
    858858                saved = false;
    859859
    860         IPC_SET_RETVAL(&call->data, EPARTY);
     860        ipc_set_retval(&call->data, EPARTY);
    861861        (void) answer_preprocess(call, saved ? &saved_data : NULL);
    862862        call->flags |= IPC_CALL_AUTO_REPLY;

  • kernel/generic/src/mm/backend_user.c

    reb13ef8 rfafb8e5  
    119119
    120120        ipc_data_t data = { };
    121         IPC_SET_IMETHOD(&data, IPC_M_PAGE_IN);
    122         IPC_SET_ARG1(&data, upage - area->base);
    123         IPC_SET_ARG2(&data, PAGE_SIZE);
    124         IPC_SET_ARG3(&data, pager_info->id1);
    125         IPC_SET_ARG4(&data, pager_info->id2);
    126         IPC_SET_ARG5(&data, pager_info->id3);
     121        ipc_set_imethod(&data, IPC_M_PAGE_IN);
     122        ipc_set_arg1(&data, upage - area->base);
     123        ipc_set_arg2(&data, PAGE_SIZE);
     124        ipc_set_arg3(&data, pager_info->id1);
     125        ipc_set_arg4(&data, pager_info->id2);
     126        ipc_set_arg5(&data, pager_info->id3);
    127127
    128128        errno_t rc = ipc_req_internal(pager_info->pager, &data, (sysarg_t) true);
    … …  
    136136        }
    137137
    138         if (IPC_GET_RETVAL(&data) != EOK)
     138        if (ipc_get_retval(&data) != EOK)
    139139                return AS_PF_FAULT;
    140140
    … …  
    145145         */
    146146
    147         uintptr_t frame = IPC_GET_ARG1(&data);
     147        uintptr_t frame = ipc_get_arg1(&data);
    148148        page_mapping_insert(AS, upage, frame, as_area_get_flags(area));
    149149        if (!used_space_insert(&area->used_space, upage, 1))

  • kernel/generic/src/udebug/udebug.c

    reb13ef8 rfafb8e5  
    141141                TASK->udebug.begin_call = NULL;
    142142
    143                 IPC_SET_RETVAL(&db_call->data, 0);
     143                ipc_set_retval(&db_call->data, 0);
    144144                ipc_answer(&TASK->answerbox, db_call);
    145145        } else if (TASK->udebug.dt_state == UDEBUG_TS_ACTIVE) {
    … …  
    160160                        assert(go_call);
    161161
    162                         IPC_SET_RETVAL(&go_call->data, 0);
    163                         IPC_SET_ARG1(&go_call->data, UDEBUG_EVENT_STOP);
     162                        ipc_set_retval(&go_call->data, 0);
     163                        ipc_set_arg1(&go_call->data, UDEBUG_EVENT_STOP);
    164164
    165165                        THREAD->udebug.cur_event = UDEBUG_EVENT_STOP;
    … …  
    243243        THREAD->udebug.go_call = NULL;
    244244
    245         IPC_SET_RETVAL(&call->data, 0);
    246         IPC_SET_ARG1(&call->data, etype);
    247         IPC_SET_ARG2(&call->data, id);
    248         IPC_SET_ARG3(&call->data, rc);
     245        ipc_set_retval(&call->data, 0);
     246        ipc_set_arg1(&call->data, etype);
     247        ipc_set_arg2(&call->data, id);
     248        ipc_set_arg3(&call->data, rc);
    249249
    250250        THREAD->udebug.syscall_args[0] = a1;
    … …  
    314314
    315315        THREAD->udebug.go_call = NULL;
    316         IPC_SET_RETVAL(&call->data, 0);
    317         IPC_SET_ARG1(&call->data, UDEBUG_EVENT_THREAD_B);
    318         IPC_SET_ARG2(&call->data, (sysarg_t) thread);
     316        ipc_set_retval(&call->data, 0);
     317        ipc_set_arg1(&call->data, UDEBUG_EVENT_THREAD_B);
     318        ipc_set_arg2(&call->data, (sysarg_t) thread);
    319319
    320320        /*
    … …  
    365365
    366366        THREAD->udebug.go_call = NULL;
    367         IPC_SET_RETVAL(&call->data, 0);
    368         IPC_SET_ARG1(&call->data, UDEBUG_EVENT_THREAD_E);
     367        ipc_set_retval(&call->data, 0);
     368        ipc_set_arg1(&call->data, UDEBUG_EVENT_THREAD_E);
    369369
    370370        /* Prevent any further debug activity in thread. */
    … …  
    428428                                LOG("Answer GO call with EVENT_FINISHED.");
    429429
    430                                 IPC_SET_RETVAL(&thread->udebug.go_call->data, 0);
    431                                 IPC_SET_ARG1(&thread->udebug.go_call->data,
     430                                ipc_set_retval(&thread->udebug.go_call->data, 0);
     431                                ipc_set_arg1(&thread->udebug.go_call->data,
    432432                                    UDEBUG_EVENT_FINISHED);
    433433

  • kernel/generic/src/udebug/udebug_ipc.c

    reb13ef8 rfafb8e5  
    5353errno_t udebug_request_preprocess(call_t *call, phone_t *phone)
    5454{
    55         switch (IPC_GET_ARG1(&call->data)) {
     55        switch (ipc_get_arg1(&call->data)) {
    5656                /* future UDEBUG_M_REGS_WRITE, UDEBUG_M_MEM_WRITE: */
    5757        default:
    … …  
    7676        rc = udebug_begin(call, &active);
    7777        if (rc != EOK) {
    78                 IPC_SET_RETVAL(&call->data, rc);
     78                ipc_set_retval(&call->data, rc);
    7979                ipc_answer(&TASK->kb.box, call);
    8080                return;
    … …  
    8686         */
    8787        if (active) {
    88                 IPC_SET_RETVAL(&call->data, EOK);
     88                ipc_set_retval(&call->data, EOK);
    8989                ipc_answer(&TASK->kb.box, call);
    9090        }
    … …  
    102102        rc = udebug_end();
    103103
    104         IPC_SET_RETVAL(&call->data, rc);
     104        ipc_set_retval(&call->data, rc);
    105105        ipc_answer(&TASK->kb.box, call);
    106106}
    … …  
    116116        udebug_evmask_t mask;
    117117
    118         mask = IPC_GET_ARG2(&call->data);
     118        mask = ipc_get_arg2(&call->data);
    119119        rc = udebug_set_evmask(mask);
    120120
    121         IPC_SET_RETVAL(&call->data, rc);
     121        ipc_set_retval(&call->data, rc);
    122122        ipc_answer(&TASK->kb.box, call);
    123123}
    … …  
    133133        errno_t rc;
    134134
    135         t = (thread_t *)IPC_GET_ARG2(&call->data);
     135        t = (thread_t *)ipc_get_arg2(&call->data);
    136136
    137137        rc = udebug_go(t, call);
    138138        if (rc != EOK) {
    139                 IPC_SET_RETVAL(&call->data, rc);
     139                ipc_set_retval(&call->data, rc);
    140140                ipc_answer(&TASK->kb.box, call);
    141141                return;
    … …  
    153153        errno_t rc;
    154154
    155         t = (thread_t *)IPC_GET_ARG2(&call->data);
     155        t = (thread_t *)ipc_get_arg2(&call->data);
    156156
    157157        rc = udebug_stop(t, call);
    158         IPC_SET_RETVAL(&call->data, rc);
     158        ipc_set_retval(&call->data, rc);
    159159        ipc_answer(&TASK->kb.box, call);
    160160}
    … …  
    173173        errno_t rc;
    174174
    175         uspace_addr = IPC_GET_ARG2(&call->data);        /* Destination address */
    176         buf_size = IPC_GET_ARG3(&call->data);   /* Dest. buffer size */
     175        uspace_addr = ipc_get_arg2(&call->data);        /* Destination address */
     176        buf_size = ipc_get_arg3(&call->data);   /* Dest. buffer size */
    177177
    178178        /*
    … …  
    182182        rc = udebug_thread_read(&buffer, buf_size, &copied, &needed);
    183183        if (rc != EOK) {
    184                 IPC_SET_RETVAL(&call->data, rc);
     184                ipc_set_retval(&call->data, rc);
    185185                ipc_answer(&TASK->kb.box, call);
    186186                return;
    … …  
    191191         */
    192192
    193         IPC_SET_RETVAL(&call->data, 0);
    194         /*
    195          * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    196          * same code in process_answer() can be used
    197          * (no way to distinguish method in answer)
    198          */
    199         IPC_SET_ARG1(&call->data, uspace_addr);
    200         IPC_SET_ARG2(&call->data, copied);
    201         IPC_SET_ARG3(&call->data, needed);
     193        ipc_set_retval(&call->data, 0);
     194        /*
     195         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
     196         * same code in process_answer() can be used
     197         * (no way to distinguish method in answer)
     198         */
     199        ipc_set_arg1(&call->data, uspace_addr);
     200        ipc_set_arg2(&call->data, copied);
     201        ipc_set_arg3(&call->data, needed);
    202202        call->buffer = buffer;
    203203
    … …  
    219219        void *data;
    220220
    221         uspace_addr = IPC_GET_ARG2(&call->data);        /* Destination address */
    222         buf_size = IPC_GET_ARG3(&call->data);   /* Dest. buffer size */
     221        uspace_addr = ipc_get_arg2(&call->data);        /* Destination address */
     222        buf_size = ipc_get_arg3(&call->data);   /* Dest. buffer size */
    223223
    224224        /*
    … …  
    238238         */
    239239
    240         IPC_SET_RETVAL(&call->data, 0);
    241         /*
    242          * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    243          * same code in process_answer() can be used
    244          * (no way to distinguish method in answer)
    245          */
    246         IPC_SET_ARG1(&call->data, uspace_addr);
    247         IPC_SET_ARG2(&call->data, to_copy);
    248 
    249         IPC_SET_ARG3(&call->data, data_size);
     240        ipc_set_retval(&call->data, 0);
     241        /*
     242         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
     243         * same code in process_answer() can be used
     244         * (no way to distinguish method in answer)
     245         */
     246        ipc_set_arg1(&call->data, uspace_addr);
     247        ipc_set_arg2(&call->data, to_copy);
     248
     249        ipc_set_arg3(&call->data, data_size);
    250250        call->buffer = data;
    251251
    … …  
    268268        as_area_info_t *data;
    269269
    270         uspace_addr = IPC_GET_ARG2(&call->data);        /* Destination address */
    271         buf_size = IPC_GET_ARG3(&call->data);   /* Dest. buffer size */
     270        uspace_addr = ipc_get_arg2(&call->data);        /* Destination address */
     271        buf_size = ipc_get_arg3(&call->data);   /* Dest. buffer size */
    272272
    273273        /*
    … …  
    276276        data = as_get_area_info(AS, &data_size);
    277277        if (!data) {
    278                 IPC_SET_RETVAL(&call->data, ENOMEM);
     278                ipc_set_retval(&call->data, ENOMEM);
    279279                ipc_answer(&TASK->kb.box, call);
    280280                return;
    … …  
    292292         */
    293293
    294         IPC_SET_RETVAL(&call->data, 0);
    295         /*
    296          * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    297          * same code in process_answer() can be used
    298          * (no way to distinguish method in answer)
    299          */
    300         IPC_SET_ARG1(&call->data, uspace_addr);
    301         IPC_SET_ARG2(&call->data, to_copy);
    302 
    303         IPC_SET_ARG3(&call->data, data_size);
     294        ipc_set_retval(&call->data, 0);
     295        /*
     296         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
     297         * same code in process_answer() can be used
     298         * (no way to distinguish method in answer)
     299         */
     300        ipc_set_arg1(&call->data, uspace_addr);
     301        ipc_set_arg2(&call->data, to_copy);
     302
     303        ipc_set_arg3(&call->data, data_size);
    304304        call->buffer = (uint8_t *) data;
    305305
    … …  
    319319        void *buffer;
    320320
    321         t = (thread_t *)IPC_GET_ARG2(&call->data);
     321        t = (thread_t *)ipc_get_arg2(&call->data);
    322322
    323323        rc = udebug_args_read(t, &buffer);
    324324        if (rc != EOK) {
    325                 IPC_SET_RETVAL(&call->data, rc);
     325                ipc_set_retval(&call->data, rc);
    326326                ipc_answer(&TASK->kb.box, call);
    327327                return;
    … …  
    332332         */
    333333
    334         uspace_addr = IPC_GET_ARG3(&call->data);
    335 
    336         IPC_SET_RETVAL(&call->data, 0);
    337         /*
    338          * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    339          * same code in process_answer() can be used
    340          * (no way to distinguish method in answer)
    341          */
    342         IPC_SET_ARG1(&call->data, uspace_addr);
    343         IPC_SET_ARG2(&call->data, 6 * sizeof(sysarg_t));
     334        uspace_addr = ipc_get_arg3(&call->data);
     335
     336        ipc_set_retval(&call->data, 0);
     337        /*
     338         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
     339         * same code in process_answer() can be used
     340         * (no way to distinguish method in answer)
     341         */
     342        ipc_set_arg1(&call->data, uspace_addr);
     343        ipc_set_arg2(&call->data, 6 * sizeof(sysarg_t));
    344344        call->buffer = buffer;
    345345
    … …  
    359359        errno_t rc;
    360360
    361         t = (thread_t *) IPC_GET_ARG2(&call->data);
     361        t = (thread_t *) ipc_get_arg2(&call->data);
    362362
    363363        rc = udebug_regs_read(t, &buffer);
    364364        if (rc != EOK) {
    365                 IPC_SET_RETVAL(&call->data, rc);
     365                ipc_set_retval(&call->data, rc);
    366366                ipc_answer(&TASK->kb.box, call);
    367367                return;
    … …  
    374374         */
    375375
    376         uspace_addr = IPC_GET_ARG3(&call->data);
     376        uspace_addr = ipc_get_arg3(&call->data);
    377377        to_copy = sizeof(istate_t);
    378378
    379         IPC_SET_RETVAL(&call->data, 0);
    380         /*
    381          * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    382          * same code in process_answer() can be used
    383          * (no way to distinguish method in answer)
    384          */
    385         IPC_SET_ARG1(&call->data, uspace_addr);
    386         IPC_SET_ARG2(&call->data, to_copy);
     379        ipc_set_retval(&call->data, 0);
     380        /*
     381         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
     382         * same code in process_answer() can be used
     383         * (no way to distinguish method in answer)
     384         */
     385        ipc_set_arg1(&call->data, uspace_addr);
     386        ipc_set_arg2(&call->data, to_copy);
    387387
    388388        call->buffer = buffer;
    … …  
    404404        errno_t rc;
    405405
    406         uspace_dst = IPC_GET_ARG2(&call->data);
    407         uspace_src = IPC_GET_ARG3(&call->data);
    408         size = IPC_GET_ARG4(&call->data);
     406        uspace_dst = ipc_get_arg2(&call->data);
     407        uspace_src = ipc_get_arg3(&call->data);
     408        size = ipc_get_arg4(&call->data);
    409409
    410410        rc = udebug_mem_read(uspace_src, size, &buffer);
    411411        if (rc != EOK) {
    412                 IPC_SET_RETVAL(&call->data, rc);
     412                ipc_set_retval(&call->data, rc);
    413413                ipc_answer(&TASK->kb.box, call);
    414414                return;
    … …  
    417417        assert(buffer != NULL);
    418418
    419         IPC_SET_RETVAL(&call->data, 0);
    420         /*
    421          * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    422          * same code in process_answer() can be used
    423          * (no way to distinguish method in answer)
    424          */
    425         IPC_SET_ARG1(&call->data, uspace_dst);
    426         IPC_SET_ARG2(&call->data, size);
     419        ipc_set_retval(&call->data, 0);
     420        /*
     421         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
     422         * same code in process_answer() can be used
     423         * (no way to distinguish method in answer)
     424         */
     425        ipc_set_arg1(&call->data, uspace_dst);
     426        ipc_set_arg2(&call->data, size);
    427427        call->buffer = buffer;
    428428
    … …  
    439439        int debug_method;
    440440
    441         debug_method = IPC_GET_ARG1(&call->data);
     441        debug_method = ipc_get_arg1(&call->data);
    442442
    443443        if (debug_method != UDEBUG_M_BEGIN) {
    … …  
    450450                 */
    451451                if (TASK->udebug.debugger != call->sender) {
    452                         IPC_SET_RETVAL(&call->data, EINVAL);
     452                        ipc_set_retval(&call->data, EINVAL);
    453453                        ipc_answer(&TASK->kb.box, call);
    454454                        return;

  • kernel/generic/src/udebug/udebug_ops.c

    reb13ef8 rfafb8e5  
    328328        thread->udebug.go_call = NULL;
    329329
    330         IPC_SET_RETVAL(&call->data, 0);
    331         IPC_SET_ARG1(&call->data, UDEBUG_EVENT_STOP);
     330        ipc_set_retval(&call->data, 0);
     331        ipc_set_arg1(&call->data, UDEBUG_EVENT_STOP);
    332332
    333333        THREAD->udebug.cur_event = UDEBUG_EVENT_STOP;
Note: See TracChangeset for help on using the changeset viewer.