Changeset 5a5269d in mainline for kernel/generic/src


Ignore:
Timestamp:
2019-07-02T12:03:55Z (6 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
98c4c16
Parents:
aca97582
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-07-02 12:03:55)
git-committer:
GitHub <noreply@…> (2019-07-02 12:03:55)
Message:

Change type of uspace pointers in kernel from pointer type to numeric (#170)

From kernel's perspective, userspace addresses are not valid pointers,
and can only be used in calls to copy_to/from_uspace().
Therefore, we change the type of those arguments and variables to
uspace_addr_t which is an alias for sysarg_t.

This allows the compiler to catch accidental direct accesses to
userspace addresses.

Additionally, to avoid losing the type information in code,
a macro uspace_ptr(type) is used that translates to uspace_addr_t.
I makes no functional difference, but allows keeping the type information
in code in case we implement some sort of static checking for it in the future.

However, ccheck doesn't like that, so instead of using uspace_ptr(char),
we use uspace_ptr_char which is defined as
#define uspace_ptr_char uspace_ptr(char).

Location:
kernel/generic/src
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/console/console.c

    raca97582 r5a5269d  
    395395 *
    396396 */
    397 sys_errno_t sys_kio(int cmd, const void *buf, size_t size)
     397sys_errno_t sys_kio(int cmd, uspace_addr_t buf, size_t size)
    398398{
    399399        char *data;
  • kernel/generic/src/ddi/ddi.c

    raca97582 r5a5269d  
    248248 */
    249249sys_errno_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
    250     void *virt_ptr, uintptr_t bound)
     250    uspace_ptr_uintptr_t virt_ptr, uintptr_t bound)
    251251{
    252252        uintptr_t virt;
     
    262262        rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
    263263        if (rc != EOK) {
    264                 physmem_unmap((uintptr_t) virt);
     264                physmem_unmap(virt);
    265265                return rc;
    266266        }
     
    393393 *
    394394 */
    395 sys_errno_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
     395sys_errno_t sys_iospace_enable(uspace_ptr_ddi_ioarg_t uspace_io_arg)
    396396{
    397397        ddi_ioarg_t arg;
     
    404404}
    405405
    406 sys_errno_t sys_iospace_disable(ddi_ioarg_t *uspace_io_arg)
     406sys_errno_t sys_iospace_disable(uspace_ptr_ddi_ioarg_t uspace_io_arg)
    407407{
    408408        ddi_ioarg_t arg;
     
    465465
    466466sys_errno_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
    467     void *phys_ptr, void *virt_ptr, uintptr_t bound)
     467    uspace_ptr_uintptr_t phys_ptr, uspace_ptr_uintptr_t virt_ptr, uintptr_t bound)
    468468{
    469469        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0) {
     
    473473
    474474                uintptr_t phys;
    475                 errno_t rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
     475                errno_t rc = dmamem_map(virt_ptr, size, map_flags,
    476476                    flags, &phys);
    477477
     
    481481                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
    482482                if (rc != EOK) {
    483                         dmamem_unmap((uintptr_t) virt_ptr, size);
     483                        dmamem_unmap(virt_ptr, size);
    484484                        return rc;
    485485                }
     
    508508                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
    509509                if (rc != EOK) {
    510                         dmamem_unmap_anonymous((uintptr_t) virt);
     510                        dmamem_unmap_anonymous(virt);
    511511                        return rc;
    512512                }
     
    514514                rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
    515515                if (rc != EOK) {
    516                         dmamem_unmap_anonymous((uintptr_t) virt);
     516                        dmamem_unmap_anonymous(virt);
    517517                        return rc;
    518518                }
  • kernel/generic/src/ipc/irq.c

    raca97582 r5a5269d  
    223223 *
    224224 */
    225 static irq_code_t *code_from_uspace(irq_code_t *ucode)
     225static irq_code_t *code_from_uspace(uspace_ptr_irq_code_t ucode)
    226226{
    227227        irq_pio_range_t *ranges = NULL;
     
    242242        if (!ranges)
    243243                goto error;
    244         rc = copy_from_uspace(ranges, code->ranges,
     244        rc = copy_from_uspace(ranges, (uintptr_t) code->ranges,
    245245            sizeof(code->ranges[0]) * code->rangecount);
    246246        if (rc != EOK)
     
    250250        if (!cmds)
    251251                goto error;
    252         rc = copy_from_uspace(cmds, code->cmds,
     252        rc = copy_from_uspace(cmds, (uintptr_t) code->cmds,
    253253            sizeof(code->cmds[0]) * code->cmdcount);
    254254        if (rc != EOK)
     
    323323 */
    324324errno_t ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
    325     irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
     325    uspace_ptr_irq_code_t ucode, uspace_ptr_cap_irq_handle_t uspace_handle)
    326326{
    327327        if ((inr < 0) || (inr > last_inr))
  • kernel/generic/src/ipc/ops/dataread.c

    raca97582 r5a5269d  
    6363        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);
     65                uspace_addr_t src = ipc_get_arg1(&answer->data);
     66                uspace_addr_t dst = ipc_get_arg1(olddata);
    6767                size_t max_size = ipc_get_arg2(olddata);
    6868                size_t size = ipc_get_arg2(&answer->data);
     
    8181                        }
    8282                        errno_t rc = copy_from_uspace(answer->buffer,
    83                             (void *) src, size);
     83                            src, size);
    8484                        if (rc) {
    8585                                ipc_set_retval(&answer->data, rc);
     
    103103{
    104104        if (answer->buffer) {
    105                 uintptr_t dst = ipc_get_arg1(&answer->data);
     105                uspace_addr_t dst = ipc_get_arg1(&answer->data);
    106106                size_t size = ipc_get_arg2(&answer->data);
    107107                errno_t rc;
    108108
    109                 rc = copy_to_uspace((void *) dst, answer->buffer, size);
     109                rc = copy_to_uspace(dst, answer->buffer, size);
    110110                if (rc)
    111111                        ipc_set_retval(&answer->data, rc);
  • kernel/generic/src/ipc/ops/datawrite.c

    raca97582 r5a5269d  
    4343static errno_t request_preprocess(call_t *call, phone_t *phone)
    4444{
    45         uintptr_t src = ipc_get_arg1(&call->data);
     45        uspace_addr_t src = ipc_get_arg1(&call->data);
    4646        size_t size = ipc_get_arg2(&call->data);
    4747
     
    5959        if (!call->buffer)
    6060                return ENOMEM;
    61         errno_t rc = copy_from_uspace(call->buffer, (void *) src, size);
     61        errno_t rc = copy_from_uspace(call->buffer, src, size);
    6262        if (rc != EOK) {
    6363                /*
     
    7777        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                uspace_addr_t dst = ipc_get_arg1(&answer->data);
     80                size_t size = ipc_get_arg2(&answer->data);
     81                size_t max_size = ipc_get_arg2(olddata);
    8282
    8383                if (size <= max_size) {
    84                         errno_t rc = copy_to_uspace((void *) dst,
     84                        errno_t rc = copy_to_uspace(dst,
    8585                            answer->buffer, size);
    8686                        if (rc)
  • kernel/generic/src/ipc/ops/debug.c

    raca97582 r5a5269d  
    4747{
    4848        if (answer->buffer) {
    49                 uintptr_t dst = ipc_get_arg1(&answer->data);
     49                uspace_addr_t dst = ipc_get_arg1(&answer->data);
    5050                size_t size = ipc_get_arg2(&answer->data);
    5151                errno_t rc;
    5252
    53                 rc = copy_to_uspace((void *) dst, answer->buffer, size);
     53                rc = copy_to_uspace(dst, answer->buffer, size);
    5454                if (rc)
    5555                        ipc_set_retval(&answer->data, rc);
  • kernel/generic/src/ipc/ops/shareout.c

    raca97582 r5a5269d  
    7070
    7171                if (rc == EOK) {
    72                         rc = copy_to_uspace((void *) ipc_get_arg2(&answer->data),
     72                        rc = copy_to_uspace(ipc_get_arg2(&answer->data),
    7373                            &dst_base, sizeof(dst_base));
    7474                }
  • kernel/generic/src/ipc/sysipc.c

    raca97582 r5a5269d  
    419419 *
    420420 */
    421 sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, ipc_data_t *data,
     421sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, uspace_ptr_ipc_data_t data,
    422422    sysarg_t label)
    423423{
     
    437437        }
    438438
    439         errno_t rc = copy_from_uspace(&call->data.args, &data->args,
     439        errno_t rc = copy_from_uspace(&call->data.args, data + offsetof(ipc_data_t, args),
    440440            sizeof(call->data.args));
    441441        if (rc != EOK) {
     
    623623 */
    624624sys_errno_t sys_ipc_forward_slow(cap_call_handle_t chandle,
    625     cap_phone_handle_t phandle, ipc_data_t *data, unsigned int mode)
     625    cap_phone_handle_t phandle, uspace_ptr_ipc_data_t data, unsigned int mode)
    626626{
    627627        ipc_data_t newdata;
    628         errno_t rc = copy_from_uspace(&newdata.args, &data->args,
     628        errno_t rc = copy_from_uspace(&newdata.args, data + offsetof(ipc_data_t, args),
    629629            sizeof(newdata.args));
    630630        if (rc != EOK)
     
    700700 *
    701701 */
    702 sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, ipc_data_t *data)
     702sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, uspace_ptr_ipc_data_t data)
    703703{
    704704        kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
     
    718718                saved = false;
    719719
    720         errno_t rc = copy_from_uspace(&call->data.args, &data->args,
     720        errno_t rc = copy_from_uspace(&call->data.args, data + offsetof(ipc_data_t, args),
    721721            sizeof(call->data.args));
    722722        if (rc != EOK) {
     
    766766 * @return An error code on error.
    767767 */
    768 sys_errno_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     768sys_errno_t sys_ipc_wait_for_call(uspace_ptr_ipc_data_t calldata, uint32_t usec,
    769769    unsigned int flags)
    770770{
     
    888888 */
    889889sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod,
    890     irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
     890    uspace_ptr_irq_code_t ucode, uspace_ptr_cap_irq_handle_t uspace_handle)
    891891{
    892892        if (!(perm_get(TASK) & PERM_IRQ_REG))
     
    918918 *
    919919 */
    920 sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid,
    921     cap_phone_handle_t *uspace_phone)
     920sys_errno_t sys_ipc_connect_kbox(uspace_ptr_task_id_t uspace_taskid,
     921    uspace_ptr_cap_phone_handle_t uspace_phone)
    922922{
    923923#ifdef CONFIG_UDEBUG
  • kernel/generic/src/log/log.c

    raca97582 r5a5269d  
    295295 *
    296296 */
    297 sys_errno_t sys_klog(sysarg_t operation, void *buf, size_t size,
    298     sysarg_t level, size_t *uspace_nread)
     297sys_errno_t sys_klog(sysarg_t operation, uspace_addr_t buf, size_t size,
     298    sysarg_t level, uspace_ptr_size_t uspace_nread)
    299299{
    300300        char *data;
  • kernel/generic/src/main/uinit.c

    raca97582 r5a5269d  
    7070#endif
    7171
    72         uspace_arg_t *uarg = (uspace_arg_t *) arg;
     72        uspace_arg_t *uarg = arg;
    7373        uspace_arg_t local_uarg;
    7474
     
    7777        local_uarg.uspace_stack_size = uarg->uspace_stack_size;
    7878        local_uarg.uspace_uarg = uarg->uspace_uarg;
    79         local_uarg.uspace_thread_function = NULL;
    80         local_uarg.uspace_thread_arg = NULL;
     79        local_uarg.uspace_thread_function = USPACE_NULL;
     80        local_uarg.uspace_thread_arg = USPACE_NULL;
    8181
    8282        free(uarg);
  • kernel/generic/src/mm/as.c

    raca97582 r5a5269d  
    20922092
    20932093sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
    2094     uintptr_t bound, as_area_pager_info_t *pager_info)
     2094    uintptr_t bound, uspace_ptr_as_area_pager_info_t pager_info)
    20952095{
    20962096        uintptr_t virt = base;
     
    20982098        mem_backend_data_t backend_data;
    20992099
    2100         if (pager_info == AS_AREA_UNPAGED)
     2100        if (!pager_info)
    21012101                backend = &anon_backend;
    21022102        else {
     
    21252125}
    21262126
    2127 sys_errno_t sys_as_area_get_info(uintptr_t address, as_area_info_t *dest)
     2127sys_errno_t sys_as_area_get_info(uintptr_t address, uspace_ptr_as_area_info_t dest)
    21282128{
    21292129        as_area_t *area;
     2130        as_area_info_t info;
     2131
     2132        /* Prevent leaking stack bytes via structure padding. */
     2133        memset(&info, 0, sizeof(info));
    21302134
    21312135        mutex_lock(&AS->lock);
     
    21362140        }
    21372141
    2138         dest->start_addr = area->base;
    2139         dest->size = P2SZ(area->pages);
    2140         dest->flags = area->flags;
     2142        info.start_addr = area->base;
     2143        info.size = P2SZ(area->pages);
     2144        info.flags = area->flags;
    21412145
    21422146        mutex_unlock(&area->lock);
    21432147        mutex_unlock(&AS->lock);
     2148
     2149        copy_to_uspace(dest, &info, sizeof(info));
    21442150        return EOK;
    21452151}
  • kernel/generic/src/mm/page.c

    raca97582 r5a5269d  
    215215 *
    216216 */
    217 sys_errno_t sys_page_find_mapping(uintptr_t virt, uintptr_t *phys_ptr)
     217sys_errno_t sys_page_find_mapping(uintptr_t virt, uspace_ptr_uintptr_t phys_ptr)
    218218{
    219219        uintptr_t phys;
  • kernel/generic/src/proc/program.c

    raca97582 r5a5269d  
    6969 *
    7070 */
    71 errno_t program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
     71errno_t program_create(as_t *as, uspace_addr_t entry_addr, char *name, program_t *prg)
    7272{
    7373        uspace_arg_t *kernel_uarg = (uspace_arg_t *)
     
    8686         * Create the stack address space area.
    8787         */
    88         uintptr_t virt = (uintptr_t) -1;
     88        uintptr_t virt = (uintptr_t) AS_AREA_ANY;
    8989        uintptr_t bound = USER_ADDRESS_SPACE_END - (STACK_SIZE_USER - 1);
    9090
     
    103103        }
    104104
    105         kernel_uarg->uspace_entry = (void *) entry_addr;
    106         kernel_uarg->uspace_stack = (void *) virt;
     105        kernel_uarg->uspace_entry = entry_addr;
     106        kernel_uarg->uspace_stack = virt;
    107107        kernel_uarg->uspace_stack_size = STACK_SIZE_USER;
    108         kernel_uarg->uspace_thread_function = NULL;
    109         kernel_uarg->uspace_thread_arg = NULL;
    110         kernel_uarg->uspace_uarg = NULL;
     108        kernel_uarg->uspace_thread_function = USPACE_NULL;
     109        kernel_uarg->uspace_thread_arg = USPACE_NULL;
     110        kernel_uarg->uspace_uarg = USPACE_NULL;
    111111
    112112        /*
     
    218218 *
    219219 */
    220 sys_errno_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
     220sys_errno_t sys_program_spawn_loader(uspace_ptr_char uspace_name, size_t name_len)
    221221{
    222222        /* Cap length of name and copy it from userspace. */
  • kernel/generic/src/proc/task.c

    raca97582 r5a5269d  
    323323 *
    324324 */
    325 sys_errno_t sys_task_get_id(sysarg64_t *uspace_taskid)
     325sys_errno_t sys_task_get_id(uspace_ptr_sysarg64_t uspace_taskid)
    326326{
    327327        /*
     
    363363 *
    364364 */
    365 sys_errno_t sys_task_set_name(const char *uspace_name, size_t name_len)
     365sys_errno_t sys_task_set_name(const uspace_ptr_char uspace_name, size_t name_len)
    366366{
    367367        char namebuf[TASK_NAME_BUFLEN];
     
    404404 *
    405405 */
    406 sys_errno_t sys_task_kill(task_id_t *uspace_taskid)
     406sys_errno_t sys_task_kill(uspace_ptr_task_id_t uspace_taskid)
    407407{
    408408        task_id_t taskid;
  • kernel/generic/src/proc/thread.c

    raca97582 r5a5269d  
    998998 *
    999999 */
    1000 sys_errno_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
    1001     size_t name_len, thread_id_t *uspace_thread_id)
     1000sys_errno_t sys_thread_create(uspace_ptr_uspace_arg_t uspace_uarg, uspace_ptr_char uspace_name,
     1001    size_t name_len, uspace_ptr_thread_id_t uspace_thread_id)
    10021002{
    10031003        if (name_len > THREAD_NAME_BUFLEN - 1)
     
    10291029            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
    10301030        if (thread) {
    1031                 if (uspace_thread_id != NULL) {
     1031                if (uspace_thread_id) {
    10321032                        rc = copy_to_uspace(uspace_thread_id, &thread->tid,
    10331033                            sizeof(thread->tid));
     
    10881088 *
    10891089 */
    1090 sys_errno_t sys_thread_get_id(thread_id_t *uspace_thread_id)
     1090sys_errno_t sys_thread_get_id(uspace_ptr_thread_id_t uspace_thread_id)
    10911091{
    10921092        /*
  • kernel/generic/src/security/perm.c

    raca97582 r5a5269d  
    158158 *
    159159 */
    160 sys_errno_t sys_perm_grant(sysarg64_t *uspace_taskid, perm_t perms)
     160sys_errno_t sys_perm_grant(uspace_ptr_sysarg64_t uspace_taskid, perm_t perms)
    161161{
    162162        sysarg64_t taskid;
     
    179179 *
    180180 */
    181 sys_errno_t sys_perm_revoke(sysarg64_t *uspace_taskid, perm_t perms)
     181sys_errno_t sys_perm_revoke(uspace_ptr_sysarg64_t uspace_taskid, perm_t perms)
    182182{
    183183        sysarg64_t taskid;
  • kernel/generic/src/synch/syswaitq.c

    raca97582 r5a5269d  
    8888 * @return              Error code.
    8989 */
    90 sys_errno_t sys_waitq_create(cap_waitq_handle_t *whandle)
     90sys_errno_t sys_waitq_create(uspace_ptr_cap_waitq_handle_t whandle)
    9191{
    9292        waitq_t *wq = slab_alloc(waitq_cache, FRAME_ATOMIC);
  • kernel/generic/src/syscall/copy.c

    raca97582 r5a5269d  
    5959 * @return EOK on success or an error code from @ref errno.h.
    6060 */
    61 errno_t copy_from_uspace(void *dst, const void *uspace_src, size_t size)
     61errno_t copy_from_uspace(void *dst, uspace_addr_t uspace_src, size_t size)
    6262{
    6363        ipl_t ipl;
     
    6868
    6969        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    70                 if (overlaps((uintptr_t) uspace_src, size,
     70                if (overlaps(uspace_src, size,
    7171                    KERNEL_ADDRESS_SPACE_START,
    7272                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START)) {
     
    8282         * Check whether the address is outside the address space hole.
    8383         */
    84         if (overlaps((uintptr_t) uspace_src, size, ADDRESS_SPACE_HOLE_START,
     84        if (overlaps(uspace_src, size, ADDRESS_SPACE_HOLE_START,
    8585            ADDRESS_SPACE_HOLE_END - ADDRESS_SPACE_HOLE_START))
    8686                return EPERM;
     
    110110 * @return 0 on success or an error code from @ref errno.h.
    111111 */
    112 errno_t copy_to_uspace(void *uspace_dst, const void *src, size_t size)
     112errno_t copy_to_uspace(uspace_addr_t uspace_dst, const void *src, size_t size)
    113113{
    114114        ipl_t ipl;
     
    119119
    120120        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    121                 if (overlaps((uintptr_t) uspace_dst, size,
     121                if (overlaps(uspace_dst, size,
    122122                    KERNEL_ADDRESS_SPACE_START,
    123123                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START)) {
     
    133133         * Check whether the address is outside the address space hole.
    134134         */
    135         if (overlaps((uintptr_t) uspace_dst, size, ADDRESS_SPACE_HOLE_START,
     135        if (overlaps(uspace_dst, size, ADDRESS_SPACE_HOLE_START,
    136136            ADDRESS_SPACE_HOLE_END - ADDRESS_SPACE_HOLE_START))
    137137                return EPERM;
  • kernel/generic/src/sysinfo/sysinfo.c

    raca97582 r5a5269d  
    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(uspace_addr_t ptr, size_t size,
    680680    bool dry_run)
    681681{
     
    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(uspace_addr_t ptr, size_t size,
    789789    bool dry_run)
    790790{
     
    831831 *
    832832 */
    833 sys_errno_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
    834     void *size_ptr)
     833sys_errno_t sys_sysinfo_get_keys_size(uspace_addr_t path_ptr, size_t path_size,
     834    uspace_addr_t size_ptr)
    835835{
    836836        errno_t rc;
     
    879879 *
    880880 */
    881 sys_errno_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
    882     void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
     881sys_errno_t sys_sysinfo_get_keys(uspace_addr_t path_ptr, size_t path_size,
     882    uspace_addr_t buffer_ptr, size_t buffer_size, uspace_ptr_size_t size_ptr)
    883883{
    884884        errno_t rc;
     
    914914 *
    915915 */
    916 sysarg_t sys_sysinfo_get_val_type(void *path_ptr, size_t path_size)
     916sysarg_t sys_sysinfo_get_val_type(uspace_addr_t path_ptr, size_t path_size)
    917917{
    918918        /*
     
    950950 *
    951951 */
    952 sys_errno_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
    953     void *value_ptr)
     952sys_errno_t sys_sysinfo_get_value(uspace_addr_t path_ptr, size_t path_size,
     953    uspace_addr_t value_ptr)
    954954{
    955955        errno_t rc;
     
    986986 *
    987987 */
    988 sys_errno_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
    989     void *size_ptr)
     988sys_errno_t sys_sysinfo_get_data_size(uspace_addr_t path_ptr, size_t path_size,
     989    uspace_addr_t size_ptr)
    990990{
    991991        errno_t rc;
     
    10361036 *
    10371037 */
    1038 sys_errno_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
    1039     void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
     1038sys_errno_t sys_sysinfo_get_data(uspace_addr_t path_ptr, size_t path_size,
     1039    uspace_addr_t buffer_ptr, size_t buffer_size, uspace_ptr_size_t size_ptr)
    10401040{
    10411041        errno_t rc;
  • kernel/generic/src/udebug/udebug_ipc.c

    raca97582 r5a5269d  
    398398static void udebug_receive_mem_read(call_t *call)
    399399{
    400         sysarg_t uspace_dst;
    401         sysarg_t uspace_src;
     400        uspace_addr_t uspace_dst;
     401        uspace_addr_t uspace_src;
    402402        unsigned size;
    403403        void *buffer = NULL;
  • kernel/generic/src/udebug/udebug_ops.c

    raca97582 r5a5269d  
    548548 *
    549549 */
    550 errno_t udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer)
     550errno_t udebug_mem_read(uspace_addr_t uspace_addr, size_t n, void **buffer)
    551551{
    552552        /* Verify task state */
     
    569569         *
    570570         */
    571         errno_t rc = copy_from_uspace(data_buffer, (void *) uspace_addr, n);
     571        errno_t rc = copy_from_uspace(data_buffer, uspace_addr, n);
    572572        mutex_unlock(&TASK->udebug.lock);
    573573
Note: See TracChangeset for help on using the changeset viewer.