syscall_handler.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017, Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
 
#ifndef ZEPHYR_INCLUDE_SYSCALL_HANDLER_H_
#define ZEPHYR_INCLUDE_SYSCALL_HANDLER_H_
 
#ifdef CONFIG_USERSPACE
 
#ifndef _ASMLANGUAGE
#include <zephyr/kernel.h>
#include <zephyr/sys/arch_interface.h>
#include <zephyr/sys/math_extras.h>
#include <stdbool.h>
#include <zephyr/logging/log.h>
 
extern const _k_syscall_handler_t _k_syscall_table[K_SYSCALL_LIMIT];
 
enum _obj_init_check {
        _OBJ_INIT_TRUE = 0,
        _OBJ_INIT_FALSE = -1,
        _OBJ_INIT_ANY = 1
};
 
static inline bool z_is_in_user_syscall(void)
{
        /* This gets set on entry to the syscall's generasted z_mrsh
         * function and then cleared on exit. This code path is only
         * encountered when a syscall is made from user mode, system
         * calls from supervisor mode bypass everything directly to
         * the implementation function.
         */
        return !k_is_in_isr() && _current->syscall_frame != NULL;
}
 
int z_object_validate(struct z_object *ko, enum k_objects otype,
                      enum _obj_init_check init);
 
extern void z_dump_object_error(int retval, const void *obj,
                                struct z_object *ko, enum k_objects otype);
 
extern struct z_object *z_object_find(const void *obj);
 
typedef void (*_wordlist_cb_func_t)(struct z_object *ko, void *context);
 
extern void z_object_wordlist_foreach(_wordlist_cb_func_t func, void *context);
 
extern void z_thread_perms_inherit(struct k_thread *parent,
                                  struct k_thread *child);
 
extern void z_thread_perms_set(struct z_object *ko, struct k_thread *thread);
 
extern void z_thread_perms_clear(struct z_object *ko, struct k_thread *thread);
 
/*
 * Revoke access to all objects for the provided thread
 *
 * NOTE: Unlike z_thread_perms_clear(), this function will not clear
 * permissions on public objects.
 *
 * @param thread Thread object to revoke access
 */
extern void z_thread_perms_all_clear(struct k_thread *thread);
 
void z_object_uninit(const void *obj);
 
void z_object_recycle(const void *obj);
 
static inline size_t z_user_string_nlen(const char *src, size_t maxlen,
                                        int *err)
{
        return arch_user_string_nlen(src, maxlen, err);
}
 
extern void *z_user_alloc_from_copy(const void *src, size_t size);
 
extern int z_user_from_copy(void *dst, const void *src, size_t size);
 
extern int z_user_to_copy(void *dst, const void *src, size_t size);
 
extern char *z_user_string_alloc_copy(const char *src, size_t maxlen);
 
extern int z_user_string_copy(char *dst, const char *src, size_t maxlen);
 
#define Z_OOPS(expr) \
        do { \
                if (expr) { \
                        arch_syscall_oops(_current->syscall_frame); \
                } \
        } while (false)
 
#define Z_SYSCALL_VERIFY_MSG(expr, fmt, ...) ({ \
        bool expr_copy = !(expr); \
        if (expr_copy) { \
                TOOLCHAIN_IGNORE_WSHADOW_BEGIN \
                LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL); \
                TOOLCHAIN_IGNORE_WSHADOW_END \
                LOG_ERR("syscall %s failed check: " fmt, \
                        __func__, ##__VA_ARGS__); \
        } \
        expr_copy; })
 
#define Z_SYSCALL_VERIFY(expr) Z_SYSCALL_VERIFY_MSG(expr, #expr)
 
#define Z_SYSCALL_MEMORY(ptr, size, write) \
        Z_SYSCALL_VERIFY_MSG(arch_buffer_validate((void *)ptr, size, write) \
                             == 0, \
                             "Memory region %p (size %zu) %s access denied", \
                             (void *)(ptr), (size_t)(size), \
                             write ? "write" : "read")
 
#define Z_SYSCALL_MEMORY_READ(ptr, size) \
        Z_SYSCALL_MEMORY(ptr, size, 0)
 
#define Z_SYSCALL_MEMORY_WRITE(ptr, size) \
        Z_SYSCALL_MEMORY(ptr, size, 1)
 
#define Z_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, write) \
        ({ \
                size_t product; \
                Z_SYSCALL_VERIFY_MSG(!size_mul_overflow((size_t)(nmemb), \
                                                        (size_t)(size), \
                                                        &product), \
                                     "%zux%zu array is too large", \
                                     (size_t)(nmemb), (size_t)(size)) ||  \
                        Z_SYSCALL_MEMORY(ptr, product, write); \
        })
 
#define Z_SYSCALL_MEMORY_ARRAY_READ(ptr, nmemb, size) \
        Z_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 0)
 
#define Z_SYSCALL_MEMORY_ARRAY_WRITE(ptr, nmemb, size) \
        Z_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 1)
 
static inline int z_obj_validation_check(struct z_object *ko,
                                         const void *obj,
                                         enum k_objects otype,
                                         enum _obj_init_check init)
{
        int ret;
 
        ret = z_object_validate(ko, otype, init);
 
#ifdef CONFIG_LOG
        if (ret != 0) {
                z_dump_object_error(ret, obj, ko, otype);
        }
#else
        ARG_UNUSED(obj);
#endif
 
        return ret;
}
 
#define Z_SYSCALL_IS_OBJ(ptr, type, init) \
        Z_SYSCALL_VERIFY_MSG(z_obj_validation_check(                    \
                                     z_object_find((const void *)ptr),  \
                                     (const void *)ptr,                 \
                                     type, init) == 0, "access denied")
 
#define Z_SYSCALL_DRIVER_OP(ptr, api_name, op) \
        ({ \
                struct api_name *__device__ = (struct api_name *) \
                        ((const struct device *)ptr)->api; \
                Z_SYSCALL_VERIFY_MSG(__device__->op != NULL, \
                                    "Operation %s not defined for driver " \
                                    "instance %p", \
                                    # op, __device__); \
        })
 
#define Z_SYSCALL_SPECIFIC_DRIVER(_device, _dtype, _api) \
        ({ \
                const struct device *_dev = (const struct device *)_device; \
                Z_SYSCALL_OBJ(_dev, _dtype) || \
                        Z_SYSCALL_VERIFY_MSG(_dev->api == _api, \
                                             "API structure mismatch"); \
        })
 
#define Z_SYSCALL_OBJ(ptr, type) \
        Z_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_TRUE)
 
#define Z_SYSCALL_OBJ_INIT(ptr, type) \
        Z_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_ANY)
 
#define Z_SYSCALL_OBJ_NEVER_INIT(ptr, type) \
        Z_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_FALSE)
 
#include <driver-validation.h>
 
#endif /* _ASMLANGUAGE */
 
#endif /* CONFIG_USERSPACE */
 
#endif /* ZEPHYR_INCLUDE_SYSCALL_HANDLER_H_ */