syscall_handler.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017, Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_INTERNAL_SYSCALL_HANDLER_H_
#define ZEPHYR_INCLUDE_INTERNAL_SYSCALL_HANDLER_H_

 
#if defined(CONFIG_USERSPACE) || defined(__DOXYGEN__)
 
#ifndef _ASMLANGUAGE
#include <zephyr/kernel.h>
#include <zephyr/arch/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 k_is_in_user_syscall(void)
{
        /* This gets set on entry to the syscall's generated 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 k_object_validate(struct k_object *ko, enum k_objects otype,
                      enum _obj_init_check init);

void k_object_dump_error(int retval, const void *obj,
                         struct k_object *ko, enum k_objects otype);

struct k_object *k_object_find(const void *obj);

static inline bool k_object_is_dynamic(const void *obj)
{
        struct k_object *ko = k_object_find(obj);
 
        return (ko != NULL) && ((ko->flags & K_OBJ_FLAG_ALLOC) != 0U);
}
 
typedef void (*_wordlist_cb_func_t)(struct k_object *ko, void *context);

void k_object_wordlist_foreach(_wordlist_cb_func_t func, void *context);

void k_thread_perms_inherit(struct k_thread *parent, struct k_thread *child);

void k_thread_perms_set(struct k_object *ko, struct k_thread *thread);

void k_thread_perms_clear(struct k_object *ko, struct k_thread *thread);

void k_thread_perms_all_clear(struct k_thread *thread);

void k_object_uninit(const void *obj);

void k_object_recycle(const void *obj);

static inline size_t k_usermode_string_nlen(const char *src, size_t maxlen,
                                        int *err)
{
        return arch_user_string_nlen(src, maxlen, err);
}

void *k_usermode_alloc_from_copy(const void *src, size_t size);

int k_usermode_from_copy(void *dst, const void *src, size_t size);

int k_usermode_to_copy(void *dst, const void *src, size_t size);

char *k_usermode_string_alloc_copy(const char *src, size_t maxlen);

int k_usermode_string_copy(char *dst, const char *src, size_t maxlen);

#define K_OOPS(expr) \
        do { \
                if (expr) { \
                        arch_syscall_oops(_current->syscall_frame); \
                } \
        } while (false)

#define K_SYSCALL_VERIFY_MSG(expr, fmt, ...) ({ \
        bool expr_copy = !(expr); \
        if (expr_copy) { \
                TOOLCHAIN_DISABLE_WARNING(TOOLCHAIN_WARNING_SHADOW) \
                LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL); \
                TOOLCHAIN_ENABLE_WARNING(TOOLCHAIN_WARNING_SHADOW) \
                LOG_ERR("syscall %s failed check: " fmt, \
                        __func__, ##__VA_ARGS__); \
        } \
        expr_copy; })

#define K_SYSCALL_VERIFY(expr) K_SYSCALL_VERIFY_MSG(expr, #expr)

#define K_SYSCALL_MEMORY_SIZE_CHECK(ptr, size) \
        (((uintptr_t)(ptr) + (size)) >= (uintptr_t)(ptr))

#define K_SYSCALL_MEMORY(ptr, size, write) \
        K_SYSCALL_VERIFY_MSG(K_SYSCALL_MEMORY_SIZE_CHECK(ptr, size) \
                             && !Z_DETECT_POINTER_OVERFLOW(ptr, size) \
                             && (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 K_SYSCALL_MEMORY_READ(ptr, size) \
        K_SYSCALL_MEMORY(ptr, size, 0)

#define K_SYSCALL_MEMORY_WRITE(ptr, size) \
        K_SYSCALL_MEMORY(ptr, size, 1)

#define K_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, write) \
        ({ \
                size_t product; \
                K_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)) ||  \
                        K_SYSCALL_MEMORY(ptr, product, write); \
        })

#define K_SYSCALL_MEMORY_ARRAY_READ(ptr, nmemb, size) \
        K_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 0)

#define K_SYSCALL_MEMORY_ARRAY_WRITE(ptr, nmemb, size) \
        K_SYSCALL_MEMORY_ARRAY(ptr, nmemb, size, 1)
 
static inline int k_object_validation_check(struct k_object *ko,
                                         const void *obj,
                                         enum k_objects otype,
                                         enum _obj_init_check init)
{
        int ret;
 
        ret = k_object_validate(ko, otype, init);
 
#ifdef CONFIG_LOG
        if (ret != 0) {
                k_object_dump_error(ret, obj, ko, otype);
        }
#else
        ARG_UNUSED(obj);
#endif
 
        return ret;
}
 
#define K_SYSCALL_IS_OBJ(ptr, type, init) \
        K_SYSCALL_VERIFY_MSG(k_object_validation_check(                 \
                                     k_object_find((const void *)(ptr)),        \
                                     (const void *)(ptr),               \
                                     (type), (init)) == 0, "access denied")

#define K_SYSCALL_DRIVER_OP(ptr, api_name, op) \
        ({ \
                struct api_name *__device__ = (struct api_name *) \
                        ((const struct device *)(ptr))->api; \
                K_SYSCALL_VERIFY_MSG(__device__->op != NULL, \
                                    "Operation %s not defined for driver " \
                                    "instance %p", \
                                    # op, __device__); \
        })

#define K_SYSCALL_SPECIFIC_DRIVER(_device, _dtype, _api) \
        ({ \
                const struct device *_dev = (const struct device *)_device; \
                K_SYSCALL_OBJ(_dev, _dtype) || \
                        K_SYSCALL_VERIFY_MSG(_dev->api == _api, \
                                             "API structure mismatch"); \
        })

#define K_SYSCALL_OBJ(ptr, type) \
        K_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_TRUE)

 
#define K_SYSCALL_OBJ_INIT(ptr, type) \
        K_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_ANY)

 
#define K_SYSCALL_OBJ_NEVER_INIT(ptr, type) \
        K_SYSCALL_IS_OBJ(ptr, type, _OBJ_INIT_FALSE)

 
#define K_SYSCALL_OBJ_STATIC(ptr, type) \
        (K_SYSCALL_OBJ(ptr, type) || \
         K_SYSCALL_VERIFY_MSG(!k_object_is_dynamic((const void *)(ptr)), \
                              "dynamically allocated kernel object %p may not " \
                              "be used here, it can be freed while still in use", \
                              (const void *)(ptr)))
 
#include <zephyr/driver-validation.h>
 
#endif /* _ASMLANGUAGE */
 
#endif /* CONFIG_USERSPACE */
 
#endif /* ZEPHYR_INCLUDE_INTERNAL_SYSCALL_HANDLER_H_ */