patrick/zephyr
1
0
Fork 0
Code Issues Pull requests Actions 8 Packages Projects Releases Wiki Activity

syscall: rename z_user_ to k_usermode_

Browse source 
Rename internal API to not use z_/Z_.

Signed-off-by: Anas Nashif <anas.nashif@intel.com>
This commit is contained in:
Anas Nashif 2023-09-27 10:56:59 +00:00 committed by Carles Cufí
parent 56fddd805a
commit 9c1aeb5fd3
23 changed files with 65 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
doc/kernel/usermode/syscalls.rst
View file

@ -377,7 +377,7 @@ The proper procedure to mitigate these attacks is to make a copies in the
verification function, and only perform parameter checks on the copies, which
user threads will never have access to. The implementation functions get passed
the copy and not the original data sent by the user. The
:c:func:`z_user_to_copy()` and :c:func:`k_usermode_from_copy()` APIs exist for
:c:func:`k_usermode_to_copy()` and :c:func:`k_usermode_from_copy()` APIs exist for
this purpose.
There is one exception in place, with respect to large data buffers which are
@ -397,12 +397,12 @@ for some integral value:
int ret;
ret = z_impl_some_syscall(&local_out_param);
Z_OOPS(z_user_to_copy(out_param, &local_out_param, sizeof(*out_param)));
Z_OOPS(k_usermode_to_copy(out_param, &local_out_param, sizeof(*out_param)));
return ret;
}
Here we have allocated ``local_out_param`` on the stack, passed its address to
the implementation function, and then used :c:func:`z_user_to_copy()` to fill
the implementation function, and then used :c:func:`k_usermode_to_copy()` to fill
in the memory passed in by the caller.
It might be tempting to do something more concise:
@ -435,7 +435,7 @@ bytes processed. This too should use a stack copy:
Z_OOPS(k_usermode_from_copy(&size, size_ptr, sizeof(size));
ret = z_impl_in_out_syscall(&size);
Z_OOPS(z_user_to_copy(size_ptr, &size, sizeof(size)));
Z_OOPS(k_usermode_to_copy(size_ptr, &size, sizeof(size)));
return ret;
}
@ -566,7 +566,7 @@ conventions are as follows:
invokes :c:macro:`Z_OOPS()`.
#. Any invalid access to memory found by the set of ``Z_SYSCALL_MEMORY`` APIs,
:c:func:`k_usermode_from_copy()`, :c:func:`z_user_to_copy()`
:c:func:`k_usermode_from_copy()`, :c:func:`k_usermode_to_copy()`
should trigger a :c:macro:`Z_OOPS`. This happens when the caller doesn't have
appropriate permissions on the memory buffer or some size calculation
overflowed.

4
drivers/can/can_handlers.c
View file

@ -17,7 +17,7 @@ static int z_vrfy_can_calc_timing(const struct device *dev, struct can_timing *r
Z_OOPS(k_usermode_from_copy(&res_copy, res, sizeof(res_copy)));
err = z_impl_can_calc_timing(dev, &res_copy, bitrate, sample_pnt);
Z_OOPS(z_user_to_copy(res, &res_copy, sizeof(*res)));
Z_OOPS(k_usermode_to_copy(res, &res_copy, sizeof(*res)));
return err;
}
@ -84,7 +84,7 @@ static int z_vrfy_can_calc_timing_data(const struct device *dev, struct can_timi
Z_OOPS(k_usermode_from_copy(&res_copy, res, sizeof(res_copy)));
err = z_impl_can_calc_timing_data(dev, &res_copy, bitrate, sample_pnt);
Z_OOPS(z_user_to_copy(res, &res_copy, sizeof(*res)));
Z_OOPS(k_usermode_to_copy(res, &res_copy, sizeof(*res)));
return err;
}

2
drivers/charger/charger_handlers.c
View file

@ -16,7 +16,7 @@ static inline int z_vrfy_charger_get_prop(const struct device *dev, const charge
int ret = z_impl_charger_get_prop(dev, prop, &k_val);
Z_OOPS(z_user_to_copy(val, &k_val, sizeof(union charger_propval)));
Z_OOPS(k_usermode_to_copy(val, &k_val, sizeof(union charger_propval)));
return ret;
}

2
drivers/counter/maxim_ds3231.c
View file

@ -1314,7 +1314,7 @@ int z_vrfy_maxim_ds3231_get_syncpoint(const struct device *dev,
rv = z_impl_maxim_ds3231_get_syncpoint(dev, &value);
if (rv >= 0) {
Z_OOPS(z_user_to_copy(syncpoint, &value, sizeof(*syncpoint)));
Z_OOPS(k_usermode_to_copy(syncpoint, &value, sizeof(*syncpoint)));
}
return rv;

10
drivers/espi/espi_handlers.c
View file

@ -40,7 +40,7 @@ static inline int z_vrfy_espi_read_lpc_request(const struct device *dev,
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, read_lpc_request));
ret = z_impl_espi_read_lpc_request(dev, op, &data_copy);
Z_OOPS(z_user_to_copy(data, &data_copy, sizeof(uint8_t)));
Z_OOPS(k_usermode_to_copy(data, &data_copy, sizeof(uint8_t)));
return ret;
}
@ -79,7 +79,7 @@ static inline int z_vrfy_espi_receive_vwire(const struct device *dev,
Z_OOPS(Z_SYSCALL_DRIVER_ESPI(dev, receive_vwire));
ret = z_impl_espi_receive_vwire(dev, signal, &level_copy);
Z_OOPS(z_user_to_copy(level, &level_copy, sizeof(uint8_t)));
Z_OOPS(k_usermode_to_copy(level, &level_copy, sizeof(uint8_t)));
return ret;
}
@ -98,7 +98,7 @@ static inline int z_vrfy_espi_read_request(const struct device *dev,
ret = z_impl_espi_read_request(dev, &req_copy);
Z_OOPS(z_user_to_copy(req, &req_copy,
Z_OOPS(k_usermode_to_copy(req, &req_copy,
sizeof(struct espi_request_packet)));
return ret;
@ -151,7 +151,7 @@ static inline int z_vrfy_espi_receive_oob(const struct device *dev,
Z_OOPS(Z_SYSCALL_MEMORY_WRITE(pckt->buf, pckt->len));
ret = z_impl_espi_receive_oob(dev, &pckt_copy);
Z_OOPS(z_user_to_copy(pckt, &pckt_copy,
Z_OOPS(k_usermode_to_copy(pckt, &pckt_copy,
sizeof(struct espi_oob_packet)));
return ret;
@ -170,7 +170,7 @@ static inline int z_vrfy_espi_read_flash(const struct device *dev,
Z_OOPS(Z_SYSCALL_MEMORY_WRITE(pckt->buf, pckt->len));
ret = z_impl_espi_read_flash(dev, pckt);
Z_OOPS(z_user_to_copy(pckt, &pckt_copy,
Z_OOPS(k_usermode_to_copy(pckt, &pckt_copy,
sizeof(struct espi_flash_packet)));
return ret;

4
drivers/flash/flash_npcx_fiu_nor.c
View file

@ -462,7 +462,7 @@ static int flash_npcx_nor_ex_op(const struct device *dev, uint16_t code,
ret = flash_npcx_nor_ex_exec_uma(dev, op_in, op_out);
#ifdef CONFIG_USERSPACE
if (ret == 0 && syscall_trap) {
Z_OOPS(z_user_to_copy(out, op_out, sizeof(out_copy)));
Z_OOPS(k_usermode_to_copy(out, op_out, sizeof(out_copy)));
}
#endif
break;
@ -495,7 +495,7 @@ static int flash_npcx_nor_ex_op(const struct device *dev, uint16_t code,
ret = flash_npcx_nor_ex_get_spi_spec(dev, op_out);
#ifdef CONFIG_USERSPACE
if (ret == 0 && syscall_trap) {
Z_OOPS(z_user_to_copy(out, op_out, sizeof(out_copy)));
Z_OOPS(k_usermode_to_copy(out, op_out, sizeof(out_copy)));
}
#endif
break;

4
drivers/flash/flash_stm32_ex_op.c
View file

@ -75,7 +75,7 @@ int flash_stm32_ex_op_sector_wp(const struct device *dev, const uintptr_t in,
#ifdef CONFIG_USERSPACE
if (syscall_trap) {
Z_OOPS(z_user_to_copy(out, result, sizeof(out_copy)));
Z_OOPS(k_usermode_to_copy(out, result, sizeof(out_copy)));
}
#endif
}
@ -132,7 +132,7 @@ int flash_stm32_ex_op_rdp(const struct device *dev, const uintptr_t in,
#ifdef CONFIG_USERSPACE
if (syscall_trap) {
Z_OOPS(z_user_to_copy(out, result, sizeof(copy)));
Z_OOPS(k_usermode_to_copy(out, result, sizeof(copy)));
}
#endif
}

6
drivers/fuel_gauge/fuel_gauge_syscall_handlers.c
View file

@ -19,7 +19,7 @@ static inline int z_vrfy_fuel_gauge_get_prop(const struct device *dev, fuel_gaug
int ret = z_impl_fuel_gauge_get_prop(dev, prop, &k_val);
Z_OOPS(z_user_to_copy(val, &k_val, sizeof(union fuel_gauge_prop_val)));
Z_OOPS(k_usermode_to_copy(val, &k_val, sizeof(union fuel_gauge_prop_val)));
return ret;
}
@ -39,7 +39,7 @@ static inline int z_vrfy_fuel_gauge_get_props(const struct device *dev, fuel_gau
int ret = z_impl_fuel_gauge_get_props(dev, k_props, k_vals, len);
Z_OOPS(z_user_to_copy(vals, k_vals, len * sizeof(union fuel_gauge_prop_val)));
Z_OOPS(k_usermode_to_copy(vals, k_vals, len * sizeof(union fuel_gauge_prop_val)));
return ret;
}
@ -72,7 +72,7 @@ static inline int z_vrfy_fuel_gauge_set_props(const struct device *dev, fuel_gau
int ret = z_impl_fuel_gauge_set_props(dev, k_props, k_vals, len);
/* We only copy back vals because props will never be modified */
Z_OOPS(z_user_to_copy(vals, k_vals, len * sizeof(union fuel_gauge_prop_val)));
Z_OOPS(k_usermode_to_copy(vals, k_vals, len * sizeof(union fuel_gauge_prop_val)));
return ret;
}

4
drivers/hwinfo/hwinfo_handlers.c
View file

@ -21,7 +21,7 @@ int z_vrfy_hwinfo_get_reset_cause(uint32_t *cause)
uint32_t cause_copy;
ret = z_impl_hwinfo_get_reset_cause(&cause_copy);
Z_OOPS(z_user_to_copy(cause, &cause_copy, sizeof(uint32_t)));
Z_OOPS(k_usermode_to_copy(cause, &cause_copy, sizeof(uint32_t)));
return ret;
}
@ -40,7 +40,7 @@ int z_vrfy_hwinfo_get_supported_reset_cause(uint32_t *supported)
uint32_t supported_copy;
ret = z_impl_hwinfo_get_supported_reset_cause(&supported_copy);
Z_OOPS(z_user_to_copy(supported, &supported_copy, sizeof(uint32_t)));
Z_OOPS(k_usermode_to_copy(supported, &supported_copy, sizeof(uint32_t)));
return ret;
}

4
drivers/i2s/i2s_handlers.c
View file

@ -63,12 +63,12 @@ static inline int z_vrfy_i2s_buf_read(const struct device *dev,
*/
rx_cfg = i2s_config_get((const struct device *)dev, I2S_DIR_RX);
copy_success = z_user_to_copy((void *)buf, mem_block,
copy_success = k_usermode_to_copy((void *)buf, mem_block,
data_size);
k_mem_slab_free(rx_cfg->mem_slab, mem_block);
Z_OOPS(copy_success);
Z_OOPS(z_user_to_copy((void *)size, &data_size,
Z_OOPS(k_usermode_to_copy((void *)size, &data_size,
sizeof(data_size)));
}

2
drivers/ptp_clock/ptp_clock.c
View file

@ -22,7 +22,7 @@ int z_vrfy_ptp_clock_get(const struct device *dev,
return 0;
}
if (z_user_to_copy((void *)tm, &ptp_time, sizeof(ptp_time)) != 0) {
if (k_usermode_to_copy((void *)tm, &ptp_time, sizeof(ptp_time)) != 0) {
return 0;
}

4
drivers/pwm/pwm_handlers.c
View file

@ -64,12 +64,12 @@ static inline int z_vrfy_pwm_capture_cycles(const struct device *dev,
err = z_impl_pwm_capture_cycles((const struct device *)dev, channel,
flags, &period, &pulse, timeout);
if (period_cycles != NULL) {
Z_OOPS(z_user_to_copy(period_cycles, &period,
Z_OOPS(k_usermode_to_copy(period_cycles, &period,
sizeof(*period_cycles)));
}
if (pulse_cycles != NULL) {
Z_OOPS(z_user_to_copy(pulse_cycles, &pulse,
Z_OOPS(k_usermode_to_copy(pulse_cycles, &pulse,
sizeof(*pulse_cycles)));
}

6
include/zephyr/internal/syscall_handler.h
View file

@ -251,7 +251,7 @@ int k_usermode_from_copy(void *dst, const void *src, size_t size);
* @retval 0 On success
* @retval EFAULT On memory access error
*/
int z_user_to_copy(void *dst, const void *src, size_t size);
int k_usermode_to_copy(void *dst, const void *src, size_t size);
/**
* @brief Copy a C string from userspace into a resource pool allocation
@ -267,7 +267,7 @@ int z_user_to_copy(void *dst, const void *src, size_t size);
* @param maxlen Maximum size of the string including trailing NULL
* @return The duplicated string, or NULL if an error occurred.
*/
char *z_user_string_alloc_copy(const char *src, size_t maxlen);
char *k_usermode_string_alloc_copy(const char *src, size_t maxlen);
/**
* @brief Copy a C string from userspace into a provided buffer
@ -285,7 +285,7 @@ char *z_user_string_alloc_copy(const char *src, size_t maxlen);
* to maxlen
* @retval EFAULT On memory access error
*/
int z_user_string_copy(char *dst, const char *src, size_t maxlen);
int k_usermode_string_copy(char *dst, const char *src, size_t maxlen);
#define Z_OOPS(expr) \
do { \

2
kernel/device.c
View file

@ -59,7 +59,7 @@ static inline const struct device *z_vrfy_device_get_binding(const char *name)
{
char name_copy[Z_DEVICE_MAX_NAME_LEN];
if (z_user_string_copy(name_copy, (char *)name, sizeof(name_copy))
if (k_usermode_string_copy(name_copy, (char *)name, sizeof(name_copy))
!= 0) {
return NULL;
}

6
kernel/thread.c
View file

@ -266,7 +266,7 @@ static inline int z_vrfy_k_thread_name_set(struct k_thread *thread, const char *
* the current z_vrfy / z_impl split does not provide a
* means of doing so.
*/
if (z_user_string_copy(name, (char *)str, sizeof(name)) != 0) {
if (k_usermode_string_copy(name, (char *)str, sizeof(name)) != 0) {
return -EFAULT;
}
@ -377,7 +377,7 @@ static inline int z_vrfy_k_thread_name_copy(k_tid_t thread,
return -ENOSPC;
}
return z_user_to_copy((void *)buf, thread->name, len + 1);
return k_usermode_to_copy((void *)buf, thread->name, len + 1);
#else
ARG_UNUSED(thread);
ARG_UNUSED(buf);
@ -1070,7 +1070,7 @@ int z_vrfy_k_thread_stack_space_get(const struct k_thread *thread,
return ret;
}
ret = z_user_to_copy(unused_ptr, &unused, sizeof(size_t));
ret = k_usermode_to_copy(unused_ptr, &unused, sizeof(size_t));
CHECKIF(ret != 0) {
return ret;
}

8
kernel/userspace.c
View file

@ -847,12 +847,12 @@ int k_usermode_from_copy(void *dst, const void *src, size_t size)
return user_copy(dst, src, size, false);
}
int z_user_to_copy(void *dst, const void *src, size_t size)
int k_usermode_to_copy(void *dst, const void *src, size_t size)
{
return user_copy(dst, src, size, true);
}
char *z_user_string_alloc_copy(const char *src, size_t maxlen)
char *k_usermode_string_alloc_copy(const char *src, size_t maxlen)
{
size_t actual_len;
int err;
@ -885,7 +885,7 @@ out:
return ret;
}
int z_user_string_copy(char *dst, const char *src, size_t maxlen)
int k_usermode_string_copy(char *dst, const char *src, size_t maxlen)
{
size_t actual_len;
int ret, err;
@ -909,7 +909,7 @@ int z_user_string_copy(char *dst, const char *src, size_t maxlen)
ret = k_usermode_from_copy(dst, src, actual_len);
/* See comment above in z_user_string_alloc_copy() */
/* See comment above in k_usermode_string_alloc_copy() */
dst[actual_len - 1] = '\0';
out:
return ret;

2
samples/userspace/prod_consumer/src/app_syscall.c
View file

@ -47,7 +47,7 @@ static int z_vrfy_magic_syscall(unsigned int *cookie)
ret = z_impl_magic_syscall(&cookie_copy);
if (ret == 0 &&
z_user_to_copy(cookie, &cookie_copy, sizeof(*cookie)) != 0) {
k_usermode_to_copy(cookie, &cookie_copy, sizeof(*cookie)) != 0) {
return -EPERM;
}

6
subsys/net/ip/utils.c
View file

@ -323,7 +323,7 @@ char *z_vrfy_net_addr_ntop(sa_family_t family, const void *src,
return 0;
}
Z_OOPS(z_user_to_copy((void *)dst, str, MIN(size, sizeof(str))));
Z_OOPS(k_usermode_to_copy((void *)dst, str, MIN(size, sizeof(str))));
return dst;
}
@ -484,7 +484,7 @@ int z_vrfy_net_addr_pton(sa_family_t family, const char *src,
return -EINVAL;
}
if (z_user_string_copy(str, (char *)src, sizeof(str)) != 0) {
if (k_usermode_string_copy(str, (char *)src, sizeof(str)) != 0) {
return -EINVAL;
}
@ -495,7 +495,7 @@ int z_vrfy_net_addr_pton(sa_family_t family, const char *src,
return err;
}
Z_OOPS(z_user_to_copy((void *)dst, addr, size));
Z_OOPS(k_usermode_to_copy((void *)dst, addr, size));
return 0;
}

4
subsys/net/lib/sockets/getaddrinfo.c
View file

@ -287,7 +287,7 @@ static inline int z_vrfy_z_zsock_getaddrinfo_internal(const char *host,
Z_OOPS(K_SYSCALL_MEMORY_ARRAY_WRITE(res, AI_ARR_MAX, sizeof(struct zsock_addrinfo)));
if (service) {
service_copy = z_user_string_alloc_copy((char *)service, 64);
service_copy = k_usermode_string_alloc_copy((char *)service, 64);
if (!service_copy) {
ret = DNS_EAI_MEMORY;
goto out;
@ -295,7 +295,7 @@ static inline int z_vrfy_z_zsock_getaddrinfo_internal(const char *host,
}
if (host) {
host_copy = z_user_string_alloc_copy((char *)host, 64);
host_copy = k_usermode_string_alloc_copy((char *)host, 64);
if (!host_copy) {
ret = DNS_EAI_MEMORY;
goto out;

2
subsys/net/lib/sockets/socketpair.c
View file

@ -350,7 +350,7 @@ int z_vrfy_zsock_socketpair(int family, int type, int proto, int *sv)
ret = z_impl_zsock_socketpair(family, type, proto, tmp);
if (ret == 0) {
Z_OOPS(z_user_to_copy(sv, tmp, sizeof(tmp)));
Z_OOPS(k_usermode_to_copy(sv, tmp, sizeof(tmp)));
}
out:

18
subsys/net/lib/sockets/sockets.c
View file

@ -700,7 +700,7 @@ static inline int z_vrfy_zsock_accept(int sock, struct sockaddr *addr,
ret = z_impl_zsock_accept(sock, (struct sockaddr *)addr,
addrlen ? &addrlen_copy : NULL);
Z_OOPS(ret >= 0 && addrlen && z_user_to_copy(addrlen, &addrlen_copy,
Z_OOPS(ret >= 0 && addrlen && k_usermode_to_copy(addrlen, &addrlen_copy,
sizeof(socklen_t)));
return ret;
@ -1530,7 +1530,7 @@ ssize_t z_vrfy_zsock_recvfrom(int sock, void *buf, size_t max_len, int flags,
addrlen ? &addrlen_copy : NULL);
if (addrlen) {
Z_OOPS(z_user_to_copy(addrlen, &addrlen_copy,
Z_OOPS(k_usermode_to_copy(addrlen, &addrlen_copy,
sizeof(socklen_t)));
}
@ -1915,7 +1915,7 @@ static inline int z_vrfy_zsock_poll(struct zsock_pollfd *fds,
ret = z_impl_zsock_poll(fds_copy, nfds, timeout);
if (ret >= 0) {
z_user_to_copy((void *)fds, fds_copy, fds_size);
k_usermode_to_copy((void *)fds, fds_copy, fds_size);
}
k_free(fds_copy);
@ -1954,9 +1954,9 @@ static inline int z_vrfy_zsock_inet_pton(sa_family_t family,
return -1;
}
Z_OOPS(z_user_string_copy(src_copy, (char *)src, sizeof(src_copy)));
Z_OOPS(k_usermode_string_copy(src_copy, (char *)src, sizeof(src_copy)));
ret = z_impl_zsock_inet_pton(family, src_copy, dst_copy);
Z_OOPS(z_user_to_copy(dst, dst_copy, dst_size));
Z_OOPS(k_usermode_to_copy(dst, dst_copy, dst_size));
return ret;
}
@ -2180,8 +2180,8 @@ int z_vrfy_zsock_getsockopt(int sock, int level, int optname,
ret = z_impl_zsock_getsockopt(sock, level, optname,
kernel_optval, &kernel_optlen);
Z_OOPS(z_user_to_copy((void *)optval, kernel_optval, kernel_optlen));
Z_OOPS(z_user_to_copy((void *)optlen, &kernel_optlen,
Z_OOPS(k_usermode_to_copy((void *)optval, kernel_optval, kernel_optlen));
Z_OOPS(k_usermode_to_copy((void *)optlen, &kernel_optlen,
sizeof(socklen_t)));
k_free(kernel_optval);
@ -2603,7 +2603,7 @@ static inline int z_vrfy_zsock_getpeername(int sock, struct sockaddr *addr,
&addrlen_copy);
if (ret == 0 &&
z_user_to_copy((void *)addrlen, &addrlen_copy,
k_usermode_to_copy((void *)addrlen, &addrlen_copy,
sizeof(socklen_t))) {
errno = EINVAL;
return -1;
@ -2682,7 +2682,7 @@ static inline int z_vrfy_zsock_getsockname(int sock, struct sockaddr *addr,
&addrlen_copy);
if (ret == 0 &&
z_user_to_copy((void *)addrlen, &addrlen_copy,
k_usermode_to_copy((void *)addrlen, &addrlen_copy,
sizeof(socklen_t))) {
errno = EINVAL;
return -1;

6
subsys/net/lib/sockets/sockets_select.c
View file

@ -261,17 +261,17 @@ static int z_vrfy_zsock_select(int nfds, zsock_fd_set *readfds,
if (ret >= 0) {
if (readfds_copy) {
z_user_to_copy((void *)readfds, readfds_copy,
k_usermode_to_copy((void *)readfds, readfds_copy,
sizeof(zsock_fd_set));
}
if (writefds_copy) {
z_user_to_copy((void *)writefds, writefds_copy,
k_usermode_to_copy((void *)writefds, writefds_copy,
sizeof(zsock_fd_set));
}
if (exceptfds_copy) {
z_user_to_copy((void *)exceptfds, exceptfds_copy,
k_usermode_to_copy((void *)exceptfds, exceptfds_copy,
sizeof(zsock_fd_set));
}
}

14
tests/kernel/mem_protect/syscalls/src/main.c
View file

@ -59,7 +59,7 @@ static inline size_t z_vrfy_string_nlen(char *src, size_t maxlen, int *err)
err_copy = -1;
}
Z_OOPS(z_user_to_copy((int *)err, &err_copy, sizeof(err_copy)));
Z_OOPS(k_usermode_to_copy((int *)err, &err_copy, sizeof(err_copy)));
return ret;
}
@ -79,7 +79,7 @@ static inline int z_vrfy_string_alloc_copy(char *src)
char *src_copy;
int ret;
src_copy = z_user_string_alloc_copy((char *)src, BUF_SIZE);
src_copy = k_usermode_string_alloc_copy((char *)src, BUF_SIZE);
if (!src_copy) {
return -1;
}
@ -102,7 +102,7 @@ int z_impl_string_copy(char *src)
static inline int z_vrfy_string_copy(char *src)
{
int ret = z_user_string_copy(kernel_buf, (char *)src, BUF_SIZE);
int ret = k_usermode_string_copy(kernel_buf, (char *)src, BUF_SIZE);
if (ret) {
return ret;
@ -123,7 +123,7 @@ int z_impl_to_copy(char *dest)
static inline int z_vrfy_to_copy(char *dest)
{
return z_user_to_copy((char *)dest, user_string, BUF_SIZE);
return k_usermode_to_copy((char *)dest, user_string, BUF_SIZE);
}
#include <syscalls/to_copy_mrsh.c>
@ -248,7 +248,7 @@ ZTEST_USER(syscalls, test_string_nlen)
*
* @ingroup kernel_memprotect_tests
*
* @see z_user_string_alloc_copy(), strcmp()
* @see k_usermode_string_alloc_copy(), strcmp()
*/
ZTEST_USER(syscalls, test_user_string_alloc_copy)
{
@ -273,7 +273,7 @@ ZTEST_USER(syscalls, test_user_string_alloc_copy)
*
* @ingroup kernel_memprotect_tests
*
* @see z_user_string_copy(), strcmp()
* @see k_usermode_string_copy(), strcmp()
*/
ZTEST_USER(syscalls, test_user_string_copy)
{
@ -297,7 +297,7 @@ ZTEST_USER(syscalls, test_user_string_copy)
*
* @ingroup kernel_memprotect_tests
*
* @see memcpy(), z_user_to_copy()
* @see memcpy(), k_usermode_to_copy()
*/
ZTEST_USER(syscalls, test_to_copy)
{