Changeset bc73be3 in mainline for kernel/generic/src


Ignore:
Timestamp:
2019-06-27T08:51:20Z (7 years ago)
Author:
Jaroslav Jindrak <dzejrou@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8add15e0
Parents:
ad40b74b (diff), aeba767 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

cpp: merge and resolve conflicts

Location:
kernel/generic/src
Files:
1 added
36 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/adt/hash_table.c

    rad40b74b rbc73be3  
    5151#include <adt/hash_table.h>
    5252#include <adt/list.h>
     53#include <assert.h>
    5354#include <stdlib.h>
    54 #include <assert.h>
    5555#include <str.h>
    5656
    … …  
    245245 *
    246246 */
    247 ht_link_t *hash_table_find(const hash_table_t *h, void *key)
     247ht_link_t *hash_table_find(const hash_table_t *h, const void *key)
    248248{
    249249        assert(h && h->bucket);
    … …  
    306306 * @return Returns the number of removed items.
    307307 */
    308 size_t hash_table_remove(hash_table_t *h, void *key)
     308size_t hash_table_remove(hash_table_t *h, const void *key)
    309309{
    310310        assert(h && h->bucket);

  • kernel/generic/src/cap/cap.c

    rad40b74b rbc73be3  
    9898{
    9999        cap_t *cap = hash_table_get_inst(item, cap_t, caps_link);
    100         return hash_mix(CAP_HANDLE_RAW(cap->handle));
    101 }
    102 
    103 static size_t caps_key_hash(void *key)
    104 {
    105         cap_handle_t *handle = (cap_handle_t *) key;
    106         return hash_mix(CAP_HANDLE_RAW(*handle));
    107 }
    108 
    109 static bool caps_key_equal(void *key, const ht_link_t *item)
    110 {
    111         cap_handle_t *handle = (cap_handle_t *) key;
     100        return hash_mix(cap_handle_raw(cap->handle));
     101}
     102
     103static size_t caps_key_hash(const void *key)
     104{
     105        const cap_handle_t *handle = key;
     106        return hash_mix(cap_handle_raw(*handle));
     107}
     108
     109static bool caps_key_equal(const void *key, const ht_link_t *item)
     110{
     111        const cap_handle_t *handle = key;
    112112        cap_t *cap = hash_table_get_inst(item, cap_t, caps_link);
    113113        return *handle == cap->handle;
    … …  
    232232        assert(mutex_locked(&task->cap_info->lock));
    233233
    234         if ((CAP_HANDLE_RAW(handle) < CAPS_START) ||
    235             (CAP_HANDLE_RAW(handle) > CAPS_LAST))
     234        if ((cap_handle_raw(handle) < CAPS_START) ||
     235            (cap_handle_raw(handle) > CAPS_LAST))
    236236                return NULL;
    237237        ht_link_t *link = hash_table_find(&task->cap_info->caps, &handle);
    … …  
    383383void cap_free(task_t *task, cap_handle_t handle)
    384384{
    385         assert(CAP_HANDLE_RAW(handle) >= CAPS_START);
    386         assert(CAP_HANDLE_RAW(handle) <= CAPS_LAST);
     385        assert(cap_handle_raw(handle) >= CAPS_START);
     386        assert(cap_handle_raw(handle) <= CAPS_LAST);
    387387
    388388        mutex_lock(&task->cap_info->lock);
    … …  
    392392
    393393        hash_table_remove_item(&task->cap_info->caps, &cap->caps_link);
    394         ra_free(task->cap_info->handles, CAP_HANDLE_RAW(handle), 1);
     394        ra_free(task->cap_info->handles, cap_handle_raw(handle), 1);
    395395        slab_free(cap_cache, cap);
    396396        mutex_unlock(&task->cap_info->lock);

  • kernel/generic/src/console/kconsole.c

    rad40b74b rbc73be3  
    156156
    157157/** Print count times a character */
    158 NO_TRACE static void print_cc(wchar_t ch, size_t count)
     158_NO_TRACE static void print_cc(wchar_t ch, size_t count)
    159159{
    160160        size_t i;
    … …  
    203203 *
    204204 */
    205 NO_TRACE static int cmdtab_compl(char *input, size_t size, indev_t *indev,
     205_NO_TRACE static int cmdtab_compl(char *input, size_t size, indev_t *indev,
    206206    hints_enum_func_t hints_enum)
    207207{
    … …  
    290290}
    291291
    292 NO_TRACE static cmd_info_t *parse_cmd(const wchar_t *cmdline)
     292_NO_TRACE static cmd_info_t *parse_cmd(const wchar_t *cmdline)
    293293{
    294294        size_t start = 0;
    … …  
    331331}
    332332
    333 NO_TRACE static wchar_t *clever_readline(const char *prompt, indev_t *indev,
     333_NO_TRACE static wchar_t *clever_readline(const char *prompt, indev_t *indev,
    334334    char *tmp)
    335335{
    … …  
    548548}
    549549
    550 NO_TRACE static bool parse_int_arg(const char *text, size_t len,
     550_NO_TRACE static bool parse_int_arg(const char *text, size_t len,
    551551    sysarg_t *result)
    552552{
    … …  
    637637 *
    638638 */
    639 NO_TRACE static bool parse_argument(const char *cmdline, size_t size,
     639_NO_TRACE static bool parse_argument(const char *cmdline, size_t size,
    640640    size_t *start, size_t *end)
    641641{
    … …  
    674674 *
    675675 */
    676 NO_TRACE static cmd_info_t *parse_cmdline(const char *cmdline, size_t size)
     676_NO_TRACE static cmd_info_t *parse_cmdline(const char *cmdline, size_t size)
    677677{
    678678        size_t start = 0;

  • kernel/generic/src/ddi/ddi.c

    rad40b74b rbc73be3  
    4646#include <mm/frame.h>
    4747#include <mm/as.h>
     48#include <mm/km.h>
    4849#include <mm/page.h>
    4950#include <synch/mutex.h>
    … …  
    5657#include <trace.h>
    5758#include <bitops.h>
     59#include <arch/asm.h>
    5860
    5961/** This lock protects the @c pareas ordered dictionary. */
    … …  
    121123 *
    122124 */
    123 NO_TRACE static errno_t physmem_map(uintptr_t phys, size_t pages,
     125_NO_TRACE static errno_t physmem_map(uintptr_t phys, size_t pages,
    124126    unsigned int flags, uintptr_t *virt, uintptr_t bound)
    125127{
    … …  
    227229}
    228230
    229 NO_TRACE static errno_t physmem_unmap(uintptr_t virt)
     231_NO_TRACE static errno_t physmem_unmap(uintptr_t virt)
    230232{
    231233        assert(TASK);
    … …  
    312314 *
    313315 */
    314 NO_TRACE static errno_t iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
     316_NO_TRACE static errno_t iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
    315317{
    316318        /*
    … …  
    353355 *
    354356 */
    355 NO_TRACE static errno_t iospace_disable(task_id_t id, uintptr_t ioaddr, size_t size)
     357_NO_TRACE static errno_t iospace_disable(task_id_t id, uintptr_t ioaddr, size_t size)
    356358{
    357359        /*
    … …  
    413415}
    414416
    415 NO_TRACE static errno_t dmamem_map(uintptr_t virt, size_t size, unsigned int map_flags,
     417_NO_TRACE static errno_t dmamem_map(uintptr_t virt, size_t size, unsigned int map_flags,
    416418    unsigned int flags, uintptr_t *phys)
    417419{
    … …  
    422424}
    423425
    424 NO_TRACE static errno_t dmamem_map_anonymous(size_t size, uintptr_t constraint,
     426_NO_TRACE static errno_t dmamem_map_anonymous(size_t size, uintptr_t constraint,
    425427    unsigned int map_flags, unsigned int flags, uintptr_t *phys,
    426428    uintptr_t *virt, uintptr_t bound)
    … …  
    451453}
    452454
    453 NO_TRACE static errno_t dmamem_unmap(uintptr_t virt, size_t size)
     455_NO_TRACE static errno_t dmamem_unmap(uintptr_t virt, size_t size)
    454456{
    455457        // TODO: implement unlocking & unmap
    … …  
    457459}
    458460
    459 NO_TRACE static errno_t dmamem_unmap_anonymous(uintptr_t virt)
     461_NO_TRACE static errno_t dmamem_unmap_anonymous(uintptr_t virt)
    460462{
    461463        return as_area_destroy(TASK->as, virt);
    … …  
    527529                return dmamem_unmap_anonymous(virt);
    528530}
     531void *pio_map(void *phys, size_t size)
     532{
     533#ifdef IO_SPACE_BOUNDARY
     534        if (phys < IO_SPACE_BOUNDARY)
     535                return phys;
     536#endif
     537        return (void *) km_map((uintptr_t) phys, size, KM_NATURAL_ALIGNMENT,
     538            PAGE_READ | PAGE_WRITE | PAGE_NOT_CACHEABLE);
     539}
     540
     541void pio_unmap(void *phys, void *virt, size_t size)
     542{
     543#ifdef IO_SPACE_BOUNDARY
     544        if (phys < IO_SPACE_BOUNDARY)
     545                return;
     546#endif
     547        km_unmap((uintptr_t) virt, size);
     548}
    529549
    530550/** @}

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

    rad40b74b rbc73be3  
    7373
    7474static size_t irq_ht_hash(const ht_link_t *);
    75 static size_t irq_ht_key_hash(void *);
     75static size_t irq_ht_key_hash(const void *);
    7676static bool irq_ht_equal(const ht_link_t *, const ht_link_t *);
    77 static bool irq_ht_key_equal(void *, const ht_link_t *);
     77static bool irq_ht_key_equal(const void *, const ht_link_t *);
    7878
    7979static hash_table_ops_t irq_ht_ops = {
    … …  
    208208
    209209/** Return the hash of the key. */
    210 size_t irq_ht_key_hash(void *key)
    211 {
    212         inr_t *inr = (inr_t *) key;
     210size_t irq_ht_key_hash(const void *key)
     211{
     212        const inr_t *inr = key;
    213213        return hash_mix(*inr);
    214214}
    … …  
    223223
    224224/** Return true if the key is equal to the item's lookup key. */
    225 bool irq_ht_key_equal(void *key, const ht_link_t *item)
    226 {
    227         inr_t *inr = (inr_t *) key;
     225bool irq_ht_key_equal(const void *key, const ht_link_t *item)
     226{
     227        const inr_t *inr = key;
    228228        irq_t *irq = hash_table_get_inst(item, irq_t, link);
    229229        return irq->inr == *inr;

  • kernel/generic/src/interrupt/interrupt.c

    rad40b74b rbc73be3  
    9999 *
    100100 */
    101 NO_TRACE void exc_dispatch(unsigned int n, istate_t *istate)
     101_NO_TRACE void exc_dispatch(unsigned int n, istate_t *istate)
    102102{
    103103#if (IVT_ITEMS > 0)
    … …  
    159159 *
    160160 */
    161 NO_TRACE static void exc_undef(unsigned int n, istate_t *istate)
     161_NO_TRACE static void exc_undef(unsigned int n, istate_t *istate)
    162162{
    163163        fault_if_from_uspace(istate, "Unhandled exception %u.", n);
    … …  
    165165}
    166166
    167 static NO_TRACE void
     167static _NO_TRACE void
    168168fault_from_uspace_core(istate_t *istate, const char *fmt, va_list args)
    169169{
    … …  
    185185 *
    186186 */
    187 NO_TRACE void fault_from_uspace(istate_t *istate, const char *fmt, ...)
     187_NO_TRACE void fault_from_uspace(istate_t *istate, const char *fmt, ...)
    188188{
    189189        va_list args;
    … …  
    197197 *
    198198 */
    199 NO_TRACE void fault_if_from_uspace(istate_t *istate, const char *fmt, ...)
     199_NO_TRACE void fault_if_from_uspace(istate_t *istate, const char *fmt, ...)
    200200{
    201201        if (!istate_from_uspace(istate))
    … …  
    233233 *
    234234 */
    235 NO_TRACE static int cmd_exc_print(cmd_arg_t *argv)
     235_NO_TRACE static int cmd_exc_print(cmd_arg_t *argv)
    236236{
    237237        bool excs_all;

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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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
    … …  
    931931        mutex_lock(&phone->lock);
    932932        if (phone->state != IPC_PHONE_FREE) {
    933                 printf("%-11d %7" PRIun " ", (int) CAP_HANDLE_RAW(cap->handle),
     933                printf("%-11d %7" PRIun " ", (int) cap_handle_raw(cap->handle),
    934934                    atomic_load(&phone->active_calls));
    935935

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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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
    70         if (CAP_HANDLE_RAW(phandle) < 0)
     70        if (cap_handle_raw(phandle) < 0)
    7171                return EOK;
    7272
    … …  
    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)) {
    115                 if (CAP_HANDLE_RAW(phandle) >= 0) {
     114        if (ipc_get_retval(&answer->data)) {
     115                if (cap_handle_raw(phandle) >= 0) {
    116116                        /*
    117117                         * Cleanup the unpublished capability and drop

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

    rad40b74b rbc73be3  
    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
    63         if (CAP_HANDLE_VALID(phandle)) {
     63        if (cap_handle_valid(phandle)) {
    6464                kobject_put(pobj);
    6565                cap_free(TASK, phandle);
    … …  
    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);
    79         } else if (CAP_HANDLE_VALID(phandle)) {
     79        } else if (cap_handle_valid(phandle)) {
    8080                /*
    8181                 * The connection was accepted
    … …  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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
    … …  
    841841
    842842error:
    843         if (CAP_HANDLE_VALID(handle))
     843        if (cap_handle_valid(handle))
    844844                cap_free(TASK, handle);
    845845
    … …  
    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/lib/elf.c

    rad40b74b rbc73be3  
    5050#include <lib/elf_load.h>
    5151
    52 static const char *error_codes[] = {
    53         "no error",
    54         "invalid image",
    55         "address space error",
    56         "incompatible image",
    57         "unsupported image type",
    58         "irrecoverable error"
    59 };
    60 
    61 static int load_segment(elf_segment_header_t *, elf_header_t *, as_t *);
     52static errno_t load_segment(elf_segment_header_t *, elf_header_t *, as_t *);
    6253
    6354/** ELF loader
    … …  
    6758 * @param flags  A combination of ELD_F_*
    6859 *
    69  * @return EE_OK on success
     60 * @return EOK on success
    7061 *
    7162 */
    72 unsigned int elf_load(elf_header_t *header, as_t *as)
     63errno_t elf_load(elf_header_t *header, as_t *as)
    7364{
    7465        /* Identify ELF */
    … …  
    7768            (header->e_ident[EI_MAG2] != ELFMAG2) ||
    7869            (header->e_ident[EI_MAG3] != ELFMAG3))
    79                 return EE_INVALID;
     70                return EINVAL;
    8071
    8172        /* Identify ELF compatibility */
    … …  
    8576            (header->e_version != EV_CURRENT) ||
    8677            (header->e_ident[EI_CLASS] != ELF_CLASS))
    87                 return EE_INCOMPATIBLE;
     78                return EINVAL;
    8879
    8980        if (header->e_phentsize != sizeof(elf_segment_header_t))
    90                 return EE_INCOMPATIBLE;
     81                return EINVAL;
    9182
    9283        /* Check if the object type is supported. */
    9384        if (header->e_type != ET_EXEC)
    94                 return EE_UNSUPPORTED;
     85                return ENOTSUP;
    9586
    9687        /* Check if the ELF image starts on a page boundary */
    9788        if (ALIGN_UP((uintptr_t) header, PAGE_SIZE) != (uintptr_t) header)
    98                 return EE_UNSUPPORTED;
     89                return ENOTSUP;
    9990
    10091        /* Walk through all segment headers and process them. */
    … …  
    10899                        continue;
    109100
    110                 int rc = load_segment(seghdr, header, as);
    111                 if (rc != EE_OK)
     101                errno_t rc = load_segment(seghdr, header, as);
     102                if (rc != EOK)
    112103                        return rc;
    113104        }
    114105
    115         return EE_OK;
    116 }
    117 
    118 /** Print error message according to error code.
    119  *
    120  * @param rc Return code returned by elf_load().
    121  *
    122  * @return NULL terminated description of error.
    123  *
    124  */
    125 const char *elf_error(unsigned int rc)
    126 {
    127         assert(rc < sizeof(error_codes) / sizeof(char *));
    128 
    129         return error_codes[rc];
     106        return EOK;
    130107}
    131108
    … …  
    136113 * @param as    Address space into wich the ELF is being loaded.
    137114 *
    138  * @return EE_OK on success, error code otherwise.
     115 * @return EOK on success, error code otherwise.
    139116 *
    140117 */
    141 int load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
     118errno_t load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
    142119{
    143120        mem_backend_data_t backend_data;
    … …  
    146123                if ((entry->p_offset % entry->p_align) !=
    147124                    (entry->p_vaddr % entry->p_align))
    148                         return EE_INVALID;
     125                        return EINVAL;
    149126        }
    150127
    … …  
    177154            AS_AREA_ATTR_NONE, &elf_backend, &backend_data, &base, 0);
    178155        if (!area)
    179                 return EE_MEMORY;
     156                return ENOMEM;
    180157
    181158        /*
    … …  
    184161         */
    185162
    186         return EE_OK;
     163        return EOK;
    187164}
    188165

  • kernel/generic/src/lib/ra.c

    rad40b74b rbc73be3  
    6767
    6868/** Return the hash of the key */
    69 static size_t used_key_hash(void *key)
    70 {
    71         uintptr_t *base = (uintptr_t *) key;
     69static size_t used_key_hash(const void *key)
     70{
     71        const uintptr_t *base = key;
    7272        return hash_mix(*base);
    7373}
    7474
    7575/** Return true if the key is equal to the item's lookup key */
    76 static bool used_key_equal(void *key, const ht_link_t *item)
    77 {
    78         uintptr_t *base = (uintptr_t *) key;
     76static bool used_key_equal(const void *key, const ht_link_t *item)
     77{
     78        const uintptr_t *base = key;
    7979        ra_segment_t *seg = hash_table_get_inst(item, ra_segment_t, uh_link);
    8080        return seg->base == *base;

  • kernel/generic/src/lib/str.c

    rad40b74b rbc73be3  
    11/*
    22 * Copyright (c) 2001-2004 Jakub Jermar
     3 * Copyright (c) 2005 Martin Decky
     4 * Copyright (c) 2008 Jiri Svoboda
     5 * Copyright (c) 2011 Martin Sucha
     6 * Copyright (c) 2011 Oleg Romanenko
    37 * All rights reserved.
    48 *
    … …  
    103107
    104108#include <str.h>
    105 #include <cpu.h>
    106 #include <arch/asm.h>
    107 #include <arch.h>
     109
     110#include <assert.h>
    108111#include <errno.h>
     112#include <stdbool.h>
     113#include <stddef.h>
     114#include <stdint.h>
     115#include <stdlib.h>
     116
    109117#include <align.h>
    110 #include <assert.h>
    111118#include <macros.h>
    112 #include <stdlib.h>
    113119
    114120/** Check the condition if wchar_t is signed */
    … …  
    616622}
    617623
     624/** Convert wide string to string.
     625 *
     626 * Convert wide string @a src to string. The output is written to the buffer
     627 * specified by @a dest and @a size. @a size must be non-zero and the string
     628 * written will always be well-formed.
     629 *
     630 * @param dest  Destination buffer.
     631 * @param size  Size of the destination buffer.
     632 * @param src   Source wide string.
     633 */
     634void wstr_to_str(char *dest, size_t size, const wchar_t *src)
     635{
     636        wchar_t ch;
     637        size_t src_idx;
     638        size_t dest_off;
     639
     640        /* There must be space for a null terminator in the buffer. */
     641        assert(size > 0);
     642
     643        src_idx = 0;
     644        dest_off = 0;
     645
     646        while ((ch = src[src_idx++]) != 0) {
     647                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
     648                        break;
     649        }
     650
     651        dest[dest_off] = '\0';
     652}
     653
     654/** Find first occurence of character in string.
     655 *
     656 * @param str String to search.
     657 * @param ch  Character to look for.
     658 *
     659 * @return Pointer to character in @a str or NULL if not found.
     660 */
     661char *str_chr(const char *str, wchar_t ch)
     662{
     663        wchar_t acc;
     664        size_t off = 0;
     665        size_t last = 0;
     666
     667        while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
     668                if (acc == ch)
     669                        return (char *) (str + last);
     670                last = off;
     671        }
     672
     673        return NULL;
     674}
     675
     676/** Insert a wide character into a wide string.
     677 *
     678 * Insert a wide character into a wide string at position
     679 * @a pos. The characters after the position are shifted.
     680 *
     681 * @param str     String to insert to.
     682 * @param ch      Character to insert to.
     683 * @param pos     Character index where to insert.
     684 * @param max_pos Characters in the buffer.
     685 *
     686 * @return True if the insertion was sucessful, false if the position
     687 *         is out of bounds.
     688 *
     689 */
     690bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
     691{
     692        size_t len = wstr_length(str);
     693
     694        if ((pos > len) || (pos + 1 > max_pos))
     695                return false;
     696
     697        size_t i;
     698        for (i = len; i + 1 > pos; i--)
     699                str[i + 1] = str[i];
     700
     701        str[pos] = ch;
     702
     703        return true;
     704}
     705
     706/** Remove a wide character from a wide string.
     707 *
     708 * Remove a wide character from a wide string at position
     709 * @a pos. The characters after the position are shifted.
     710 *
     711 * @param str String to remove from.
     712 * @param pos Character index to remove.
     713 *
     714 * @return True if the removal was sucessful, false if the position
     715 *         is out of bounds.
     716 *
     717 */
     718bool wstr_remove(wchar_t *str, size_t pos)
     719{
     720        size_t len = wstr_length(str);
     721
     722        if (pos >= len)
     723                return false;
     724
     725        size_t i;
     726        for (i = pos + 1; i <= len; i++)
     727                str[i - 1] = str[i];
     728
     729        return true;
     730}
     731
    618732/** Duplicate string.
    619733 *
    … …  
    675789        str_ncpy(dest, size + 1, src, size);
    676790        return dest;
    677 }
    678 
    679 /** Convert wide string to string.
    680  *
    681  * Convert wide string @a src to string. The output is written to the buffer
    682  * specified by @a dest and @a size. @a size must be non-zero and the string
    683  * written will always be well-formed.
    684  *
    685  * @param dest  Destination buffer.
    686  * @param size  Size of the destination buffer.
    687  * @param src   Source wide string.
    688  */
    689 void wstr_to_str(char *dest, size_t size, const wchar_t *src)
    690 {
    691         wchar_t ch;
    692         size_t src_idx;
    693         size_t dest_off;
    694 
    695         /* There must be space for a null terminator in the buffer. */
    696         assert(size > 0);
    697 
    698         src_idx = 0;
    699         dest_off = 0;
    700 
    701         while ((ch = src[src_idx++]) != 0) {
    702                 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    703                         break;
    704         }
    705 
    706         dest[dest_off] = '\0';
    707 }
    708 
    709 /** Find first occurence of character in string.
    710  *
    711  * @param str String to search.
    712  * @param ch  Character to look for.
    713  *
    714  * @return Pointer to character in @a str or NULL if not found.
    715  *
    716  */
    717 char *str_chr(const char *str, wchar_t ch)
    718 {
    719         wchar_t acc;
    720         size_t off = 0;
    721         size_t last = 0;
    722 
    723         while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
    724                 if (acc == ch)
    725                         return (char *) (str + last);
    726                 last = off;
    727         }
    728 
    729         return NULL;
    730 }
    731 
    732 /** Insert a wide character into a wide string.
    733  *
    734  * Insert a wide character into a wide string at position
    735  * @a pos. The characters after the position are shifted.
    736  *
    737  * @param str     String to insert to.
    738  * @param ch      Character to insert to.
    739  * @param pos     Character index where to insert.
    740  * @param max_pos Characters in the buffer.
    741  *
    742  * @return True if the insertion was sucessful, false if the position
    743  *         is out of bounds.
    744  *
    745  */
    746 bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
    747 {
    748         size_t len = wstr_length(str);
    749 
    750         if ((pos > len) || (pos + 1 > max_pos))
    751                 return false;
    752 
    753         size_t i;
    754         for (i = len; i + 1 > pos; i--)
    755                 str[i + 1] = str[i];
    756 
    757         str[pos] = ch;
    758 
    759         return true;
    760 }
    761 
    762 /** Remove a wide character from a wide string.
    763  *
    764  * Remove a wide character from a wide string at position
    765  * @a pos. The characters after the position are shifted.
    766  *
    767  * @param str String to remove from.
    768  * @param pos Character index to remove.
    769  *
    770  * @return True if the removal was sucessful, false if the position
    771  *         is out of bounds.
    772  *
    773  */
    774 bool wstr_remove(wchar_t *str, size_t pos)
    775 {
    776         size_t len = wstr_length(str);
    777 
    778         if (pos >= len)
    779                 return false;
    780 
    781         size_t i;
    782         for (i = pos + 1; i <= len; i++)
    783                 str[i - 1] = str[i];
    784 
    785         return true;
    786 }
    787 
    788 /** Convert string to uint64_t (internal variant).
    789  *
    790  * @param nptr   Pointer to string.
    791  * @param endptr Pointer to the first invalid character is stored here.
    792  * @param base   Zero or number between 2 and 36 inclusive.
    793  * @param neg    Indication of unary minus is stored here.
    794  * @apram result Result of the conversion.
    795  *
    796  * @return EOK if conversion was successful.
    797  *
    798  */
    799 static errno_t str_uint(const char *nptr, char **endptr, unsigned int base,
    800     bool *neg, uint64_t *result)
    801 {
    802         assert(endptr != NULL);
    803         assert(neg != NULL);
    804         assert(result != NULL);
    805 
    806         *neg = false;
    807         const char *str = nptr;
    808 
    809         /* Ignore leading whitespace */
    810         while (isspace(*str))
    811                 str++;
    812 
    813         if (*str == '-') {
    814                 *neg = true;
    815                 str++;
    816         } else if (*str == '+')
    817                 str++;
    818 
    819         if (base == 0) {
    820                 /* Decode base if not specified */
    821                 base = 10;
    822 
    823                 if (*str == '0') {
    824                         base = 8;
    825                         str++;
    826 
    827                         switch (*str) {
    828                         case 'b':
    829                         case 'B':
    830                                 base = 2;
    831                                 str++;
    832                                 break;
    833                         case 'o':
    834                         case 'O':
    835                                 base = 8;
    836                                 str++;
    837                                 break;
    838                         case 'd':
    839                         case 'D':
    840                         case 't':
    841                         case 'T':
    842                                 base = 10;
    843                                 str++;
    844                                 break;
    845                         case 'x':
    846                         case 'X':
    847                                 base = 16;
    848                                 str++;
    849                                 break;
    850                         default:
    851                                 str--;
    852                         }
    853                 }
    854         } else {
    855                 /* Check base range */
    856                 if ((base < 2) || (base > 36)) {
    857                         *endptr = (char *) str;
    858                         return EINVAL;
    859                 }
    860         }
    861 
    862         *result = 0;
    863         const char *startstr = str;
    864 
    865         while (*str != 0) {
    866                 unsigned int digit;
    867 
    868                 if ((*str >= 'a') && (*str <= 'z'))
    869                         digit = *str - 'a' + 10;
    870                 else if ((*str >= 'A') && (*str <= 'Z'))
    871                         digit = *str - 'A' + 10;
    872                 else if ((*str >= '0') && (*str <= '9'))
    873                         digit = *str - '0';
    874                 else
    875                         break;
    876 
    877                 if (digit >= base)
    878                         break;
    879 
    880                 uint64_t prev = *result;
    881                 *result = (*result) * base + digit;
    882 
    883                 if (*result < prev) {
    884                         /* Overflow */
    885                         *endptr = (char *) str;
    886                         return EOVERFLOW;
    887                 }
    888 
    889                 str++;
    890         }
    891 
    892         if (str == startstr) {
    893                 /*
    894                  * No digits were decoded => first invalid character is
    895                  * the first character of the string.
    896                  */
    897                 str = nptr;
    898         }
    899 
    900         *endptr = (char *) str;
    901 
    902         if (str == nptr)
    903                 return EINVAL;
    904 
    905         return EOK;
    906 }
    907 
    908 /** Convert string to uint64_t.
    909  *
    910  * @param nptr   Pointer to string.
    911  * @param endptr If not NULL, pointer to the first invalid character
    912  *               is stored here.
    913  * @param base   Zero or number between 2 and 36 inclusive.
    914  * @param strict Do not allow any trailing characters.
    915  * @param result Result of the conversion.
    916  *
    917  * @return EOK if conversion was successful.
    918  *
    919  */
    920 errno_t str_uint64_t(const char *nptr, char **endptr, unsigned int base,
    921     bool strict, uint64_t *result)
    922 {
    923         assert(result != NULL);
    924 
    925         bool neg;
    926         char *lendptr;
    927         errno_t ret = str_uint(nptr, &lendptr, base, &neg, result);
    928 
    929         if (endptr != NULL)
    930                 *endptr = (char *) lendptr;
    931 
    932         if (ret != EOK)
    933                 return ret;
    934 
    935         /* Do not allow negative values */
    936         if (neg)
    937                 return EINVAL;
    938 
    939         /*
    940          * Check whether we are at the end of
    941          * the string in strict mode
    942          */
    943         if ((strict) && (*lendptr != 0))
    944                 return EINVAL;
    945 
    946         return EOK;
    947791}
    948792

  • kernel/generic/src/main/kinit.c

    rad40b74b rbc73be3  
    291291                        log(LF_OTHER, LVL_ERROR,
    292292                            "init[%zu]: Init binary load failed "
    293                             "(error %s, loader status %u)", i,
    294                             str_error_name(rc), programs[i].loader_status);
     293                            "(error %s, loader status %s)", i,
     294                            str_error_name(rc), str_error_name(programs[i].loader_status));
    295295                }
    296296        }

  • kernel/generic/src/main/main.c

    rad40b74b rbc73be3  
    160160 *
    161161 */
    162 NO_TRACE void main_bsp(void)
     162_NO_TRACE void main_bsp(void)
    163163{
    164164        config.cpu_count = 1;

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

    rad40b74b rbc73be3  
    127127static void used_space_shorten_ival(used_space_ival_t *, size_t);
    128128
    129 NO_TRACE static errno_t as_constructor(void *obj, unsigned int flags)
     129_NO_TRACE static errno_t as_constructor(void *obj, unsigned int flags)
    130130{
    131131        as_t *as = (as_t *) obj;
    … …  
    137137}
    138138
    139 NO_TRACE static size_t as_destructor(void *obj)
     139_NO_TRACE static size_t as_destructor(void *obj)
    140140{
    141141        return as_destructor_arch((as_t *) obj);
    … …  
    281281 *
    282282 */
    283 NO_TRACE void as_hold(as_t *as)
     283_NO_TRACE void as_hold(as_t *as)
    284284{
    285285        refcount_up(&as->refcount);
    … …  
    294294 *
    295295 */
    296 NO_TRACE void as_release(as_t *as)
     296_NO_TRACE void as_release(as_t *as)
    297297{
    298298        if (refcount_down(&as->refcount))
    … …  
    340340 * @return True if the two areas conflict, false otherwise.
    341341 */
    342 NO_TRACE static bool area_is_conflicting(uintptr_t addr,
     342_NO_TRACE static bool area_is_conflicting(uintptr_t addr,
    343343    size_t count, bool guarded, as_area_t *area)
    344344{
    … …  
    380380 *
    381381 */
    382 NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t addr,
     382_NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t addr,
    383383    size_t count, bool guarded, as_area_t *avoid)
    384384{
    … …  
    474474 *
    475475 */
    476 NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound,
     476_NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound,
    477477    size_t size, bool guarded)
    478478{
    … …  
    580580 * @param pagemap Pagemap
    581581 */
    582 NO_TRACE void as_pagemap_initialize(as_pagemap_t *pagemap)
     582_NO_TRACE void as_pagemap_initialize(as_pagemap_t *pagemap)
    583583{
    584584        odict_initialize(&pagemap->map, as_pagemap_getkey, as_pagemap_cmp);
    … …  
    591591 * @param pagemap Pagemap
    592592 */
    593 NO_TRACE void as_pagemap_finalize(as_pagemap_t *pagemap)
     593_NO_TRACE void as_pagemap_finalize(as_pagemap_t *pagemap)
    594594{
    595595        as_page_mapping_t *mapping = as_pagemap_first(pagemap);
    … …  
    606606 * @return First mapping or @c NULL if there is none
    607607 */
    608 NO_TRACE as_page_mapping_t *as_pagemap_first(as_pagemap_t *pagemap)
     608_NO_TRACE as_page_mapping_t *as_pagemap_first(as_pagemap_t *pagemap)
    609609{
    610610        odlink_t *odlink;
    … …  
    622622 * @return Next mapping or @c NULL if @a cur is the last one
    623623 */
    624 NO_TRACE as_page_mapping_t *as_pagemap_next(as_page_mapping_t *cur)
     624_NO_TRACE as_page_mapping_t *as_pagemap_next(as_page_mapping_t *cur)
    625625{
    626626        odlink_t *odlink;
    … …  
    640640 * @return EOK on succcess or ENOENT if no mapping found
    641641 */
    642 NO_TRACE errno_t as_pagemap_find(as_pagemap_t *pagemap, uintptr_t vaddr,
     642_NO_TRACE errno_t as_pagemap_find(as_pagemap_t *pagemap, uintptr_t vaddr,
    643643    uintptr_t *rframe)
    644644{
    … …  
    663663 * @param frame Physical frame address
    664664 */
    665 NO_TRACE void as_pagemap_insert(as_pagemap_t *pagemap, uintptr_t vaddr,
     665_NO_TRACE void as_pagemap_insert(as_pagemap_t *pagemap, uintptr_t vaddr,
    666666    uintptr_t frame)
    667667{
    … …  
    680680 * @param mapping Mapping
    681681 */
    682 NO_TRACE void as_pagemap_remove(as_page_mapping_t *mapping)
     682_NO_TRACE void as_pagemap_remove(as_page_mapping_t *mapping)
    683683{
    684684        odict_remove(&mapping->lpagemap);
    … …  
    693693 *
    694694 */
    695 NO_TRACE static void sh_info_remove_reference(share_info_t *sh_info)
     695_NO_TRACE static void sh_info_remove_reference(share_info_t *sh_info)
    696696{
    697697        bool dealloc = false;
    … …  
    861861 *
    862862 */
    863 NO_TRACE static as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
     863_NO_TRACE static as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
    864864{
    865865        assert(mutex_locked(&as->lock));
    … …  
    13051305 *
    13061306 */
    1307 NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
     1307_NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
    13081308{
    13091309        assert(mutex_locked(&area->lock));
    … …  
    13281328 *
    13291329 */
    1330 NO_TRACE static unsigned int area_flags_to_page_flags(unsigned int aflags)
     1330_NO_TRACE static unsigned int area_flags_to_page_flags(unsigned int aflags)
    13311331{
    13321332        unsigned int flags = PAGE_USER | PAGE_PRESENT;
    … …  
    16981698 *
    16991699 */
    1700 NO_TRACE unsigned int as_area_get_flags(as_area_t *area)
     1700_NO_TRACE unsigned int as_area_get_flags(as_area_t *area)
    17011701{
    17021702        assert(mutex_locked(&area->lock));
    … …  
    17461746 *
    17471747 */
    1748 NO_TRACE pte_t *page_table_create(unsigned int flags)
     1748_NO_TRACE pte_t *page_table_create(unsigned int flags)
    17491749{
    17501750        assert(as_operations);
    … …  
    17611761 *
    17621762 */
    1763 NO_TRACE void page_table_destroy(pte_t *page_table)
     1763_NO_TRACE void page_table_destroy(pte_t *page_table)
    17641764{
    17651765        assert(as_operations);
    … …  
    17821782 *
    17831783 */
    1784 NO_TRACE void page_table_lock(as_t *as, bool lock)
     1784_NO_TRACE void page_table_lock(as_t *as, bool lock)
    17851785{
    17861786        assert(as_operations);
    … …  
    17961796 *
    17971797 */
    1798 NO_TRACE void page_table_unlock(as_t *as, bool unlock)
     1798_NO_TRACE void page_table_unlock(as_t *as, bool unlock)
    17991799{
    18001800        assert(as_operations);
    … …  
    18111811 *         are locked, otherwise false.
    18121812 */
    1813 NO_TRACE bool page_table_locked(as_t *as)
     1813_NO_TRACE bool page_table_locked(as_t *as)
    18141814{
    18151815        assert(as_operations);

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

    rad40b74b rbc73be3  
    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/mm/frame.c

    rad40b74b rbc73be3  
    7979 *
    8080 */
    81 NO_TRACE static void frame_initialize(frame_t *frame)
     81_NO_TRACE static void frame_initialize(frame_t *frame)
    8282{
    8383        frame->refcount = 0;
    … …  
    100100 *
    101101 */
    102 NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count,
     102_NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count,
    103103    zone_flags_t flags)
    104104{
    … …  
    156156 *
    157157 */
    158 NO_TRACE static size_t frame_total_free_get_internal(void)
     158_NO_TRACE static size_t frame_total_free_get_internal(void)
    159159{
    160160        size_t total = 0;
    … …  
    167167}
    168168
    169 NO_TRACE size_t frame_total_free_get(void)
     169_NO_TRACE size_t frame_total_free_get(void)
    170170{
    171171        size_t total;
    … …  
    190190 *
    191191 */
    192 NO_TRACE size_t find_zone(pfn_t frame, size_t count, size_t hint)
     192_NO_TRACE size_t find_zone(pfn_t frame, size_t count, size_t hint)
    193193{
    194194        if (hint >= zones.count)
    … …  
    211211
    212212/** @return True if zone can allocate specified number of frames */
    213 NO_TRACE static bool zone_can_alloc(zone_t *zone, size_t count,
     213_NO_TRACE static bool zone_can_alloc(zone_t *zone, size_t count,
    214214    pfn_t constraint)
    215215{
    … …  
    239239 *
    240240 */
    241 NO_TRACE static size_t find_free_zone_all(size_t count, zone_flags_t flags,
     241_NO_TRACE static size_t find_free_zone_all(size_t count, zone_flags_t flags,
    242242    pfn_t constraint, size_t hint)
    243243{
    … …  
    265265 *
    266266 */
    267 NO_TRACE static bool is_high_priority(pfn_t base, size_t count)
     267_NO_TRACE static bool is_high_priority(pfn_t base, size_t count)
    268268{
    269269        return (base + count <= FRAME_LOWPRIO);
    … …  
    285285 *
    286286 */
    287 NO_TRACE static size_t find_free_zone_lowprio(size_t count, zone_flags_t flags,
     287_NO_TRACE static size_t find_free_zone_lowprio(size_t count, zone_flags_t flags,
    288288    pfn_t constraint, size_t hint)
    289289{
    … …  
    322322 *
    323323 */
    324 NO_TRACE static size_t find_free_zone(size_t count, zone_flags_t flags,
     324_NO_TRACE static size_t find_free_zone(size_t count, zone_flags_t flags,
    325325    pfn_t constraint, size_t hint)
    326326{
    … …  
    346346
    347347/** Return frame from zone. */
    348 NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t index)
     348_NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t index)
    349349{
    350350        assert(index < zone->count);
    … …  
    366366 *
    367367 */
    368 NO_TRACE static size_t zone_frame_alloc(zone_t *zone, size_t count,
     368_NO_TRACE static size_t zone_frame_alloc(zone_t *zone, size_t count,
    369369    pfn_t constraint)
    370370{
    … …  
    405405 *
    406406 */
    407 NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t index)
     407_NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t index)
    408408{
    409409        assert(zone->flags & ZONE_AVAILABLE);
    … …  
    427427
    428428/** Mark frame in zone unavailable to allocation. */
    429 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t index)
     429_NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t index)
    430430{
    431431        assert(zone->flags & ZONE_AVAILABLE);
    … …  
    453453 *
    454454 */
    455 NO_TRACE static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1,
     455_NO_TRACE static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1,
    456456    void *confdata)
    457457{
    … …  
    507507 *
    508508 */
    509 NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
     509_NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
    510510{
    511511        assert(zones.info[znum].flags & ZONE_AVAILABLE);
    … …  
    623623 *
    624624 */
    625 NO_TRACE static void zone_construct(zone_t *zone, pfn_t start, size_t count,
     625_NO_TRACE static void zone_construct(zone_t *zone, pfn_t start, size_t count,
    626626    zone_flags_t flags, void *confdata)
    627627{
    … …  
    10371037 *
    10381038 */
    1039 NO_TRACE void frame_reference_add(pfn_t pfn)
     1039_NO_TRACE void frame_reference_add(pfn_t pfn)
    10401040{
    10411041        irq_spinlock_lock(&zones.lock, true);
    … …  
    10561056 *
    10571057 */
    1058 NO_TRACE void frame_mark_unavailable(pfn_t start, size_t count)
     1058_NO_TRACE void frame_mark_unavailable(pfn_t start, size_t count)
    10591059{
    10601060        irq_spinlock_lock(&zones.lock, true);

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

    rad40b74b rbc73be3  
    9595 *
    9696 */
    97 NO_TRACE void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
     97_NO_TRACE void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
    9898    unsigned int flags)
    9999{
    … …  
    120120 *
    121121 */
    122 NO_TRACE void page_mapping_remove(as_t *as, uintptr_t page)
     122_NO_TRACE void page_mapping_remove(as_t *as, uintptr_t page)
    123123{
    124124        assert(page_table_locked(as));
    … …  
    144144 *         the PTE is not guaranteed to be present.
    145145 */
    146 NO_TRACE bool page_mapping_find(as_t *as, uintptr_t page, bool nolock,
     146_NO_TRACE bool page_mapping_find(as_t *as, uintptr_t page, bool nolock,
    147147    pte_t *pte)
    148148{
    … …  
    165165 * @param pte      New PTE.
    166166 */
    167 NO_TRACE void page_mapping_update(as_t *as, uintptr_t page, bool nolock,
     167_NO_TRACE void page_mapping_update(as_t *as, uintptr_t page, bool nolock,
    168168    pte_t *pte)
    169169{

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

    rad40b74b rbc73be3  
    158158 *
    159159 */
    160 NO_TRACE static slab_t *slab_space_alloc(slab_cache_t *cache,
     160_NO_TRACE static slab_t *slab_space_alloc(slab_cache_t *cache,
    161161    unsigned int flags)
    162162{
    … …  
    206206 *
    207207 */
    208 NO_TRACE static size_t slab_space_free(slab_cache_t *cache, slab_t *slab)
     208_NO_TRACE static size_t slab_space_free(slab_cache_t *cache, slab_t *slab)
    209209{
    210210        frame_free(KA2PA(slab->start), slab->cache->frames);
    … …  
    218218
    219219/** Map object to slab structure */
    220 NO_TRACE static slab_t *obj2slab(void *obj)
     220_NO_TRACE static slab_t *obj2slab(void *obj)
    221221{
    222222        return (slab_t *) frame_get_parent(ADDR2PFN(KA2PA(obj)), 0);
    … …  
    234234 *
    235235 */
    236 NO_TRACE static size_t slab_obj_destroy(slab_cache_t *cache, void *obj,
     236_NO_TRACE static size_t slab_obj_destroy(slab_cache_t *cache, void *obj,
    237237    slab_t *slab)
    238238{
    … …  
    276276 *
    277277 */
    278 NO_TRACE static void *slab_obj_create(slab_cache_t *cache, unsigned int flags)
     278_NO_TRACE static void *slab_obj_create(slab_cache_t *cache, unsigned int flags)
    279279{
    280280        irq_spinlock_lock(&cache->slablock, true);
    … …  
    332332 *
    333333 */
    334 NO_TRACE static slab_magazine_t *get_mag_from_cache(slab_cache_t *cache,
     334_NO_TRACE static slab_magazine_t *get_mag_from_cache(slab_cache_t *cache,
    335335    bool first)
    336336{
    … …  
    357357 *
    358358 */
    359 NO_TRACE static void put_mag_to_cache(slab_cache_t *cache,
     359_NO_TRACE static void put_mag_to_cache(slab_cache_t *cache,
    360360    slab_magazine_t *mag)
    361361{
    … …  
    373373 *
    374374 */
    375 NO_TRACE static size_t magazine_destroy(slab_cache_t *cache,
     375_NO_TRACE static size_t magazine_destroy(slab_cache_t *cache,
    376376    slab_magazine_t *mag)
    377377{
    … …  
    392392 *
    393393 */
    394 NO_TRACE static slab_magazine_t *get_full_current_mag(slab_cache_t *cache)
     394_NO_TRACE static slab_magazine_t *get_full_current_mag(slab_cache_t *cache)
    395395{
    396396        slab_magazine_t *cmag = cache->mag_cache[CPU->id].current;
    … …  
    429429 *
    430430 */
    431 NO_TRACE static void *magazine_obj_get(slab_cache_t *cache)
     431_NO_TRACE static void *magazine_obj_get(slab_cache_t *cache)
    432432{
    433433        if (!CPU)
    … …  
    459459 *
    460460 */
    461 NO_TRACE static slab_magazine_t *make_empty_current_mag(slab_cache_t *cache)
     461_NO_TRACE static slab_magazine_t *make_empty_current_mag(slab_cache_t *cache)
    462462{
    463463        slab_magazine_t *cmag = cache->mag_cache[CPU->id].current;
    … …  
    509509 *
    510510 */
    511 NO_TRACE static int magazine_obj_put(slab_cache_t *cache, void *obj)
     511_NO_TRACE static int magazine_obj_put(slab_cache_t *cache, void *obj)
    512512{
    513513        if (!CPU)
    … …  
    538538 *
    539539 */
    540 NO_TRACE static size_t comp_objects(slab_cache_t *cache)
     540_NO_TRACE static size_t comp_objects(slab_cache_t *cache)
    541541{
    542542        if (cache->flags & SLAB_CACHE_SLINSIDE)
    … …  
    550550 *
    551551 */
    552 NO_TRACE static size_t badness(slab_cache_t *cache)
     552_NO_TRACE static size_t badness(slab_cache_t *cache)
    553553{
    554554        size_t objects = comp_objects(cache);
    … …  
    564564 *
    565565 */
    566 NO_TRACE static bool make_magcache(slab_cache_t *cache)
     566_NO_TRACE static bool make_magcache(slab_cache_t *cache)
    567567{
    568568        assert(_slab_initialized >= 2);
    … …  
    585585 *
    586586 */
    587 NO_TRACE static void _slab_cache_create(slab_cache_t *cache, const char *name,
     587_NO_TRACE static void _slab_cache_create(slab_cache_t *cache, const char *name,
    588588    size_t size, size_t align, errno_t (*constructor)(void *obj,
    589589    unsigned int kmflag), size_t (*destructor)(void *obj), unsigned int flags)
    … …  
    660660 *
    661661 */
    662 NO_TRACE static size_t _slab_reclaim(slab_cache_t *cache, unsigned int flags)
     662_NO_TRACE static size_t _slab_reclaim(slab_cache_t *cache, unsigned int flags)
    663663{
    664664        if (cache->flags & SLAB_CACHE_NOMAGAZINE)
    … …  
    707707 *
    708708 */
    709 NO_TRACE static void _slab_free(slab_cache_t *cache, void *obj, slab_t *slab)
     709_NO_TRACE static void _slab_free(slab_cache_t *cache, void *obj, slab_t *slab)
    710710{
    711711        if (!obj)

  • kernel/generic/src/proc/current.c

    rad40b74b rbc73be3  
    7070 *
    7171 */
    72 NO_TRACE void current_copy(current_t *src, current_t *dst)
     72_NO_TRACE void current_copy(current_t *src, current_t *dst)
    7373{
    7474        assert(src->magic == MAGIC);

  • kernel/generic/src/proc/program.c

    rad40b74b rbc73be3  
    4848#include <security/perm.h>
    4949#include <lib/elf_load.h>
    50 #include <errno.h>
     50#include <str.h>
    5151#include <log.h>
    5252#include <syscall/copy.h>
    … …  
    7676                return ENOMEM;
    7777
    78         prg->loader_status = EE_OK;
     78        prg->loader_status = EOK;
    7979        prg->task = task_create(as, name);
    8080        if (!prg->task) {
    … …  
    149149
    150150        prg->loader_status = elf_load((elf_header_t *) image_addr, as);
    151         if (prg->loader_status != EE_OK) {
     151        if (prg->loader_status != EOK) {
    152152                as_release(as);
    153153                prg->task = NULL;
    … …  
    183183
    184184        prg->loader_status = elf_load((elf_header_t *) program_loader, as);
    185         if (prg->loader_status != EE_OK) {
     185        if (prg->loader_status != EOK) {
    186186                as_release(as);
    187187                log(LF_OTHER, LVL_ERROR, "Cannot spawn loader (%s)",
    188                     elf_error(prg->loader_status));
     188                    str_error(prg->loader_status));
    189189                return ENOENT;
    190190        }

  • kernel/generic/src/sysinfo/sysinfo.c

    rad40b74b rbc73be3  
    6262 *
    6363 */
    64 NO_TRACE static errno_t sysinfo_item_constructor(void *obj, unsigned int kmflag)
     64_NO_TRACE static errno_t sysinfo_item_constructor(void *obj, unsigned int kmflag)
    6565{
    6666        sysinfo_item_t *item = (sysinfo_item_t *) obj;
    … …  
    8282 *
    8383 */
    84 NO_TRACE static size_t sysinfo_item_destructor(void *obj)
     84_NO_TRACE static size_t sysinfo_item_destructor(void *obj)
    8585{
    8686        sysinfo_item_t *item = (sysinfo_item_t *) obj;
    … …  
    124124 *
    125125 */
    126 NO_TRACE static sysinfo_item_t *sysinfo_find_item(const char *name,
     126_NO_TRACE static sysinfo_item_t *sysinfo_find_item(const char *name,
    127127    sysinfo_item_t *subtree, sysinfo_return_t **ret, bool dry_run)
    128128{
    … …  
    190190 *
    191191 */
    192 NO_TRACE static sysinfo_item_t *sysinfo_create_path(const char *name,
     192_NO_TRACE static sysinfo_item_t *sysinfo_create_path(const char *name,
    193193    sysinfo_item_t **psubtree)
    194194{
    … …  
    508508 *
    509509 */
    510 NO_TRACE static void sysinfo_indent(size_t spaces)
     510_NO_TRACE static void sysinfo_indent(size_t spaces)
    511511{
    512512        for (size_t i = 0; i < spaces; i++)
    … …  
    522522 *
    523523 */
    524 NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, size_t spaces)
     524_NO_TRACE static void sysinfo_dump_internal(sysinfo_item_t *root, size_t spaces)
    525525{
    526526        /* Walk all siblings */
    … …  
    622622 *
    623623 */
    624 NO_TRACE static sysinfo_return_t sysinfo_get_item(const char *name,
     624_NO_TRACE static sysinfo_return_t sysinfo_get_item(const char *name,
    625625    sysinfo_item_t **root, bool dry_run)
    626626{
    … …  
    677677 *
    678678 */
    679 NO_TRACE static sysinfo_return_t sysinfo_get_item_uspace(void *ptr, size_t size,
     679_NO_TRACE static sysinfo_return_t sysinfo_get_item_uspace(void *ptr, size_t size,
    680680    bool dry_run)
    681681{
    … …  
    720720 *
    721721 */
    722 NO_TRACE static sysinfo_return_t sysinfo_get_keys(const char *name,
     722_NO_TRACE static sysinfo_return_t sysinfo_get_keys(const char *name,
    723723    sysinfo_item_t **root, bool dry_run)
    724724{
    … …  
    786786 *
    787787 */
    788 NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(void *ptr, size_t size,
     788_NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(void *ptr, size_t size,
    789789    bool dry_run)
    790790{

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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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

    rad40b74b rbc73be3  
    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.