Changeset 5a5269d in mainline for kernel/generic/src

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:

• console/console.c (modified) (1 diff)
• ddi/ddi.c (modified) (9 diffs)
• ipc/irq.c (modified) (4 diffs)
• ipc/ops/dataread.c (modified) (3 diffs)
• ipc/ops/datawrite.c (modified) (3 diffs)
• ipc/ops/debug.c (modified) (1 diff)
• ipc/ops/shareout.c (modified) (1 diff)
• ipc/sysipc.c (modified) (8 diffs)
• log/log.c (modified) (1 diff)
• main/uinit.c (modified) (2 diffs)
• mm/as.c (modified) (4 diffs)
• mm/page.c (modified) (1 diff)
• proc/program.c (modified) (4 diffs)
• proc/task.c (modified) (3 diffs)
• proc/thread.c (modified) (3 diffs)
• security/perm.c (modified) (2 diffs)
• synch/syswaitq.c (modified) (1 diff)
• syscall/copy.c (modified) (6 diffs)
• sysinfo/sysinfo.c (modified) (8 diffs)
• udebug/udebug_ipc.c (modified) (1 diff)
• udebug/udebug_ops.c (modified) (2 diffs)

kernel/generic/src/console/console.c

@@ -395 +395 @@
  *
  */
-sys_errno_t sys_kio(int cmd, const void *buf, size_t size)
+sys_errno_t sys_kio(int cmd, uspace_addr_t buf, size_t size)
 {
         char *data;

kernel/generic/src/ddi/ddi.c

@@ -248 +248 @@
  */
 sys_errno_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
-    void *virt_ptr, uintptr_t bound)
+    uspace_ptr_uintptr_t virt_ptr, uintptr_t bound)
 {
         uintptr_t virt;
@@ -262 +262 @@
         rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
         if (rc != EOK) {
-                physmem_unmap((uintptr_t) virt);
+                physmem_unmap(virt);
                 return rc;
         }
@@ -393 +393 @@
  *
  */
-sys_errno_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
+sys_errno_t sys_iospace_enable(uspace_ptr_ddi_ioarg_t uspace_io_arg)
 {
         ddi_ioarg_t arg;
@@ -404 +404 @@
 }
 
-sys_errno_t sys_iospace_disable(ddi_ioarg_t *uspace_io_arg)
+sys_errno_t sys_iospace_disable(uspace_ptr_ddi_ioarg_t uspace_io_arg)
 {
         ddi_ioarg_t arg;
@@ -465 +465 @@
 
 sys_errno_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
-    void *phys_ptr, void *virt_ptr, uintptr_t bound)
+    uspace_ptr_uintptr_t phys_ptr, uspace_ptr_uintptr_t virt_ptr, uintptr_t bound)
 {
         if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0) {
@@ -473 +473 @@
 
                 uintptr_t phys;
-                errno_t rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
+                errno_t rc = dmamem_map(virt_ptr, size, map_flags,
                     flags, &phys);
 
@@ -481 +481 @@
                 rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
                 if (rc != EOK) {
-                        dmamem_unmap((uintptr_t) virt_ptr, size);
+                        dmamem_unmap(virt_ptr, size);
                         return rc;
                 }
@@ -508 +508 @@
                 rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
                 if (rc != EOK) {
-                        dmamem_unmap_anonymous((uintptr_t) virt);
+                        dmamem_unmap_anonymous(virt);
                         return rc;
                 }
@@ -514 +514 @@
                 rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
                 if (rc != EOK) {
-                        dmamem_unmap_anonymous((uintptr_t) virt);
+                        dmamem_unmap_anonymous(virt);
                         return rc;
                 }

kernel/generic/src/ipc/irq.c

@@ -223 +223 @@
  *
  */
-static irq_code_t *code_from_uspace(irq_code_t *ucode)
+static irq_code_t *code_from_uspace(uspace_ptr_irq_code_t ucode)
 {
         irq_pio_range_t *ranges = NULL;
@@ -242 +242 @@
         if (!ranges)
                 goto error;
-        rc = copy_from_uspace(ranges, code->ranges,
+        rc = copy_from_uspace(ranges, (uintptr_t) code->ranges,
             sizeof(code->ranges[0]) * code->rangecount);
         if (rc != EOK)
@@ -250 +250 @@
         if (!cmds)
                 goto error;
-        rc = copy_from_uspace(cmds, code->cmds,
+        rc = copy_from_uspace(cmds, (uintptr_t) code->cmds,
             sizeof(code->cmds[0]) * code->cmdcount);
         if (rc != EOK)
@@ -323 +323 @@
  */
 errno_t ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
-    irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
+    uspace_ptr_irq_code_t ucode, uspace_ptr_cap_irq_handle_t uspace_handle)
 {
         if ((inr < 0) || (inr > last_inr))

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

@@ -63 +63 @@
         if (!ipc_get_retval(&answer->data)) {
                 /* The recipient agreed to send data. */
-                uintptr_t src = ipc_get_arg1(&answer->data);
-                uintptr_t dst = ipc_get_arg1(olddata);
+                uspace_addr_t src = ipc_get_arg1(&answer->data);
+                uspace_addr_t dst = ipc_get_arg1(olddata);
                 size_t max_size = ipc_get_arg2(olddata);
                 size_t size = ipc_get_arg2(&answer->data);
@@ -81 +81 @@
                         }
                         errno_t rc = copy_from_uspace(answer->buffer,
-                            (void *) src, size);
+                            src, size);
                         if (rc) {
                                 ipc_set_retval(&answer->data, rc);
@@ -103 +103 @@
 {
         if (answer->buffer) {
-                uintptr_t dst = ipc_get_arg1(&answer->data);
+                uspace_addr_t dst = ipc_get_arg1(&answer->data);
                 size_t size = ipc_get_arg2(&answer->data);
                 errno_t rc;
 
-                rc = copy_to_uspace((void *) dst, answer->buffer, size);
+                rc = copy_to_uspace(dst, answer->buffer, size);
                 if (rc)
                         ipc_set_retval(&answer->data, rc);

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

@@ -43 +43 @@
 static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
-        uintptr_t src = ipc_get_arg1(&call->data);
+        uspace_addr_t src = ipc_get_arg1(&call->data);
         size_t size = ipc_get_arg2(&call->data);
 
@@ -59 +59 @@
         if (!call->buffer)
                 return ENOMEM;
-        errno_t rc = copy_from_uspace(call->buffer, (void *) src, size);
+        errno_t rc = copy_from_uspace(call->buffer, src, size);
         if (rc != EOK) {
                 /*
@@ -77 +77 @@
         if (!ipc_get_retval(&answer->data)) {
                 /* The recipient agreed to receive data. */
-                uintptr_t dst = (uintptr_t)ipc_get_arg1(&answer->data);
-                size_t size = (size_t)ipc_get_arg2(&answer->data);
-                size_t max_size = (size_t)ipc_get_arg2(olddata);
+                uspace_addr_t dst = ipc_get_arg1(&answer->data);
+                size_t size = ipc_get_arg2(&answer->data);
+                size_t max_size = ipc_get_arg2(olddata);
 
                 if (size <= max_size) {
-                        errno_t rc = copy_to_uspace((void *) dst,
+                        errno_t rc = copy_to_uspace(dst,
                             answer->buffer, size);
                         if (rc)

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

@@ -47 +47 @@
 {
         if (answer->buffer) {
-                uintptr_t dst = ipc_get_arg1(&answer->data);
+                uspace_addr_t dst = ipc_get_arg1(&answer->data);
                 size_t size = ipc_get_arg2(&answer->data);
                 errno_t rc;
 
-                rc = copy_to_uspace((void *) dst, answer->buffer, size);
+                rc = copy_to_uspace(dst, answer->buffer, size);
                 if (rc)
                         ipc_set_retval(&answer->data, rc);

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

@@ -70 +70 @@
 
                 if (rc == EOK) {
-                        rc = copy_to_uspace((void *) ipc_get_arg2(&answer->data),
+                        rc = copy_to_uspace(ipc_get_arg2(&answer->data),
                             &dst_base, sizeof(dst_base));
                 }

kernel/generic/src/ipc/sysipc.c

@@ -419 +419 @@
  *
  */
-sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, ipc_data_t *data,
+sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, uspace_ptr_ipc_data_t data,
     sysarg_t label)
 {
@@ -437 +437 @@
         }
 
-        errno_t rc = copy_from_uspace(&call->data.args, &data->args,
+        errno_t rc = copy_from_uspace(&call->data.args, data + offsetof(ipc_data_t, args),
             sizeof(call->data.args));
         if (rc != EOK) {
@@ -623 +623 @@
  */
 sys_errno_t sys_ipc_forward_slow(cap_call_handle_t chandle,
-    cap_phone_handle_t phandle, ipc_data_t *data, unsigned int mode)
+    cap_phone_handle_t phandle, uspace_ptr_ipc_data_t data, unsigned int mode)
 {
         ipc_data_t newdata;
-        errno_t rc = copy_from_uspace(&newdata.args, &data->args,
+        errno_t rc = copy_from_uspace(&newdata.args, data + offsetof(ipc_data_t, args),
             sizeof(newdata.args));
         if (rc != EOK)
@@ -700 +700 @@
  *
  */
-sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, ipc_data_t *data)
+sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, uspace_ptr_ipc_data_t data)
 {
         kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -718 +718 @@
                 saved = false;
 
-        errno_t rc = copy_from_uspace(&call->data.args, &data->args,
+        errno_t rc = copy_from_uspace(&call->data.args, data + offsetof(ipc_data_t, args),
             sizeof(call->data.args));
         if (rc != EOK) {
@@ -766 +766 @@
  * @return An error code on error.
  */
-sys_errno_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
+sys_errno_t sys_ipc_wait_for_call(uspace_ptr_ipc_data_t calldata, uint32_t usec,
     unsigned int flags)
 {
@@ -888 +888 @@
  */
 sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod,
-    irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
+    uspace_ptr_irq_code_t ucode, uspace_ptr_cap_irq_handle_t uspace_handle)
 {
         if (!(perm_get(TASK) & PERM_IRQ_REG))
@@ -918 +918 @@
  *
  */
-sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid,
-    cap_phone_handle_t *uspace_phone)
+sys_errno_t sys_ipc_connect_kbox(uspace_ptr_task_id_t uspace_taskid,
+    uspace_ptr_cap_phone_handle_t uspace_phone)
 {
 #ifdef CONFIG_UDEBUG

kernel/generic/src/log/log.c

@@ -295 +295 @@
  *
  */
-sys_errno_t sys_klog(sysarg_t operation, void *buf, size_t size,
-    sysarg_t level, size_t *uspace_nread)
+sys_errno_t sys_klog(sysarg_t operation, uspace_addr_t buf, size_t size,
+    sysarg_t level, uspace_ptr_size_t uspace_nread)
 {
         char *data;

kernel/generic/src/main/uinit.c

@@ -70 +70 @@
 #endif
 
-        uspace_arg_t *uarg = (uspace_arg_t *) arg;
+        uspace_arg_t *uarg = arg;
         uspace_arg_t local_uarg;
 
@@ -77 +77 @@
         local_uarg.uspace_stack_size = uarg->uspace_stack_size;
         local_uarg.uspace_uarg = uarg->uspace_uarg;
-        local_uarg.uspace_thread_function = NULL;
-        local_uarg.uspace_thread_arg = NULL;
+        local_uarg.uspace_thread_function = USPACE_NULL;
+        local_uarg.uspace_thread_arg = USPACE_NULL;
 
         free(uarg);

kernel/generic/src/mm/as.c

@@ -2092 +2092 @@
 
 sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
-    uintptr_t bound, as_area_pager_info_t *pager_info)
+    uintptr_t bound, uspace_ptr_as_area_pager_info_t pager_info)
 {
         uintptr_t virt = base;
@@ -2098 +2098 @@
         mem_backend_data_t backend_data;
 
-        if (pager_info == AS_AREA_UNPAGED)
+        if (!pager_info)
                 backend = &anon_backend;
         else {
@@ -2125 +2125 @@
 }
 
-sys_errno_t sys_as_area_get_info(uintptr_t address, as_area_info_t *dest)
+sys_errno_t sys_as_area_get_info(uintptr_t address, uspace_ptr_as_area_info_t dest)
 {
         as_area_t *area;
+        as_area_info_t info;
+
+        /* Prevent leaking stack bytes via structure padding. */
+        memset(&info, 0, sizeof(info));
 
         mutex_lock(&AS->lock);
@@ -2136 +2140 @@
         }
 
-        dest->start_addr = area->base;
-        dest->size = P2SZ(area->pages);
-        dest->flags = area->flags;
+        info.start_addr = area->base;
+        info.size = P2SZ(area->pages);
+        info.flags = area->flags;
 
         mutex_unlock(&area->lock);
         mutex_unlock(&AS->lock);
+
+        copy_to_uspace(dest, &info, sizeof(info));
         return EOK;
 }

kernel/generic/src/mm/page.c

@@ -215 +215 @@
  *
  */
-sys_errno_t sys_page_find_mapping(uintptr_t virt, uintptr_t *phys_ptr)
+sys_errno_t sys_page_find_mapping(uintptr_t virt, uspace_ptr_uintptr_t phys_ptr)
 {
         uintptr_t phys;

kernel/generic/src/proc/program.c

@@ -69 +69 @@
  *
  */
-errno_t program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
+errno_t program_create(as_t *as, uspace_addr_t entry_addr, char *name, program_t *prg)
 {
         uspace_arg_t *kernel_uarg = (uspace_arg_t *)
@@ -86 +86 @@
          * Create the stack address space area.
          */
-        uintptr_t virt = (uintptr_t) -1;
+        uintptr_t virt = (uintptr_t) AS_AREA_ANY;
         uintptr_t bound = USER_ADDRESS_SPACE_END - (STACK_SIZE_USER - 1);
 
@@ -103 +103 @@
         }
 
-        kernel_uarg->uspace_entry = (void *) entry_addr;
-        kernel_uarg->uspace_stack = (void *) virt;
+        kernel_uarg->uspace_entry = entry_addr;
+        kernel_uarg->uspace_stack = virt;
         kernel_uarg->uspace_stack_size = STACK_SIZE_USER;
-        kernel_uarg->uspace_thread_function = NULL;
-        kernel_uarg->uspace_thread_arg = NULL;
-        kernel_uarg->uspace_uarg = NULL;
+        kernel_uarg->uspace_thread_function = USPACE_NULL;
+        kernel_uarg->uspace_thread_arg = USPACE_NULL;
+        kernel_uarg->uspace_uarg = USPACE_NULL;
 
         /*
@@ -218 +218 @@
  *
  */
-sys_errno_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
+sys_errno_t sys_program_spawn_loader(uspace_ptr_char uspace_name, size_t name_len)
 {
         /* Cap length of name and copy it from userspace. */

kernel/generic/src/proc/task.c

@@ -323 +323 @@
  *
  */
-sys_errno_t sys_task_get_id(sysarg64_t *uspace_taskid)
+sys_errno_t sys_task_get_id(uspace_ptr_sysarg64_t uspace_taskid)
 {
         /*
@@ -363 +363 @@
  *
  */
-sys_errno_t sys_task_set_name(const char *uspace_name, size_t name_len)
+sys_errno_t sys_task_set_name(const uspace_ptr_char uspace_name, size_t name_len)
 {
         char namebuf[TASK_NAME_BUFLEN];
@@ -404 +404 @@
  *
  */
-sys_errno_t sys_task_kill(task_id_t *uspace_taskid)
+sys_errno_t sys_task_kill(uspace_ptr_task_id_t uspace_taskid)
 {
         task_id_t taskid;

kernel/generic/src/proc/thread.c

@@ -998 +998 @@
  *
  */
-sys_errno_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
-    size_t name_len, thread_id_t *uspace_thread_id)
+sys_errno_t sys_thread_create(uspace_ptr_uspace_arg_t uspace_uarg, uspace_ptr_char uspace_name,
+    size_t name_len, uspace_ptr_thread_id_t uspace_thread_id)
 {
         if (name_len > THREAD_NAME_BUFLEN - 1)
@@ -1029 +1029 @@
             THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
         if (thread) {
-                if (uspace_thread_id != NULL) {
+                if (uspace_thread_id) {
                         rc = copy_to_uspace(uspace_thread_id, &thread->tid,
                             sizeof(thread->tid));
@@ -1088 +1088 @@
  *
  */
-sys_errno_t sys_thread_get_id(thread_id_t *uspace_thread_id)
+sys_errno_t sys_thread_get_id(uspace_ptr_thread_id_t uspace_thread_id)
 {
         /*

kernel/generic/src/security/perm.c

@@ -158 +158 @@
  *
  */
-sys_errno_t sys_perm_grant(sysarg64_t *uspace_taskid, perm_t perms)
+sys_errno_t sys_perm_grant(uspace_ptr_sysarg64_t uspace_taskid, perm_t perms)
 {
         sysarg64_t taskid;
@@ -179 +179 @@
  *
  */
-sys_errno_t sys_perm_revoke(sysarg64_t *uspace_taskid, perm_t perms)
+sys_errno_t sys_perm_revoke(uspace_ptr_sysarg64_t uspace_taskid, perm_t perms)
 {
         sysarg64_t taskid;

kernel/generic/src/synch/syswaitq.c

@@ -88 +88 @@
  * @return              Error code.
  */
-sys_errno_t sys_waitq_create(cap_waitq_handle_t *whandle)
+sys_errno_t sys_waitq_create(uspace_ptr_cap_waitq_handle_t whandle)
 {
         waitq_t *wq = slab_alloc(waitq_cache, FRAME_ATOMIC);

kernel/generic/src/syscall/copy.c

@@ -59 +59 @@
  * @return EOK on success or an error code from @ref errno.h.
  */
-errno_t copy_from_uspace(void *dst, const void *uspace_src, size_t size)
+errno_t copy_from_uspace(void *dst, uspace_addr_t uspace_src, size_t size)
 {
         ipl_t ipl;
@@ -68 +68 @@
 
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                if (overlaps((uintptr_t) uspace_src, size,
+                if (overlaps(uspace_src, size,
                     KERNEL_ADDRESS_SPACE_START,
                     KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START)) {
@@ -82 +82 @@
          * Check whether the address is outside the address space hole.
          */
-        if (overlaps((uintptr_t) uspace_src, size, ADDRESS_SPACE_HOLE_START,
+        if (overlaps(uspace_src, size, ADDRESS_SPACE_HOLE_START,
             ADDRESS_SPACE_HOLE_END - ADDRESS_SPACE_HOLE_START))
                 return EPERM;
@@ -110 +110 @@
  * @return 0 on success or an error code from @ref errno.h.
  */
-errno_t copy_to_uspace(void *uspace_dst, const void *src, size_t size)
+errno_t copy_to_uspace(uspace_addr_t uspace_dst, const void *src, size_t size)
 {
         ipl_t ipl;
@@ -119 +119 @@
 
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                if (overlaps((uintptr_t) uspace_dst, size,
+                if (overlaps(uspace_dst, size,
                     KERNEL_ADDRESS_SPACE_START,
                     KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START)) {
@@ -133 +133 @@
          * Check whether the address is outside the address space hole.
          */
-        if (overlaps((uintptr_t) uspace_dst, size, ADDRESS_SPACE_HOLE_START,
+        if (overlaps(uspace_dst, size, ADDRESS_SPACE_HOLE_START,
             ADDRESS_SPACE_HOLE_END - ADDRESS_SPACE_HOLE_START))
                 return EPERM;

kernel/generic/src/sysinfo/sysinfo.c

@@ -677 +677 @@
  *
  */
-_NO_TRACE static sysinfo_return_t sysinfo_get_item_uspace(void *ptr, size_t size,
+_NO_TRACE static sysinfo_return_t sysinfo_get_item_uspace(uspace_addr_t ptr, size_t size,
     bool dry_run)
 {
@@ -786 +786 @@
  *
  */
-_NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(void *ptr, size_t size,
+_NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(uspace_addr_t ptr, size_t size,
     bool dry_run)
 {
@@ -831 +831 @@
  *
  */
-sys_errno_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
-    void *size_ptr)
+sys_errno_t sys_sysinfo_get_keys_size(uspace_addr_t path_ptr, size_t path_size,
+    uspace_addr_t size_ptr)
 {
         errno_t rc;
@@ -879 +879 @@
  *
  */
-sys_errno_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
-    void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
+sys_errno_t sys_sysinfo_get_keys(uspace_addr_t path_ptr, size_t path_size,
+    uspace_addr_t buffer_ptr, size_t buffer_size, uspace_ptr_size_t size_ptr)
 {
         errno_t rc;
@@ -914 +914 @@
  *
  */
-sysarg_t sys_sysinfo_get_val_type(void *path_ptr, size_t path_size)
+sysarg_t sys_sysinfo_get_val_type(uspace_addr_t path_ptr, size_t path_size)
 {
         /*
@@ -950 +950 @@
  *
  */
-sys_errno_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
-    void *value_ptr)
+sys_errno_t sys_sysinfo_get_value(uspace_addr_t path_ptr, size_t path_size,
+    uspace_addr_t value_ptr)
 {
         errno_t rc;
@@ -986 +986 @@
  *
  */
-sys_errno_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
-    void *size_ptr)
+sys_errno_t sys_sysinfo_get_data_size(uspace_addr_t path_ptr, size_t path_size,
+    uspace_addr_t size_ptr)
 {
         errno_t rc;
@@ -1036 +1036 @@
  *
  */
-sys_errno_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
-    void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
+sys_errno_t sys_sysinfo_get_data(uspace_addr_t path_ptr, size_t path_size,
+    uspace_addr_t buffer_ptr, size_t buffer_size, uspace_ptr_size_t size_ptr)
 {
         errno_t rc;

kernel/generic/src/udebug/udebug_ipc.c

@@ -398 +398 @@
 static void udebug_receive_mem_read(call_t *call)
 {
-        sysarg_t uspace_dst;
-        sysarg_t uspace_src;
+        uspace_addr_t uspace_dst;
+        uspace_addr_t uspace_src;
         unsigned size;
         void *buffer = NULL;

kernel/generic/src/udebug/udebug_ops.c

@@ -548 +548 @@
  *
  */
-errno_t udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer)
+errno_t udebug_mem_read(uspace_addr_t uspace_addr, size_t n, void **buffer)
 {
         /* Verify task state */
@@ -569 +569 @@
          *
          */
-        errno_t rc = copy_from_uspace(data_buffer, (void *) uspace_addr, n);
+        errno_t rc = copy_from_uspace(data_buffer, uspace_addr, n);
         mutex_unlock(&TASK->udebug.lock);