Line data    Source code

       1           0 : /*
       2             :  * Copyright (c) 2017, Intel Corporation
       3             :  *
       4             :  * SPDX-License-Identifier: Apache-2.0
       5             :  */
       6             : 
       7             : 
       8             : #ifndef ZEPHYR_INCLUDE_SYSCALL_H_
       9             : #define ZEPHYR_INCLUDE_SYSCALL_H_
      10             : 
      11             : #include <zephyr/syscall_list.h>
      12             : #include <zephyr/arch/syscall.h>
      13             : #include <stdbool.h>
      14             : 
      15             : #ifndef _ASMLANGUAGE
      16             : #include <zephyr/types.h>
      17             : #include <zephyr/linker/sections.h>
      18             : 
      19             : #ifdef __cplusplus
      20             : extern "C" {
      21             : #endif
      22             : 
      23             : /*
      24             :  * System Call Declaration macros
      25             :  *
      26             :  * These macros are used in public header files to declare system calls.
      27             :  * They generate inline functions which have different implementations
      28             :  * depending on the current compilation context:
      29             :  *
      30             :  * - Kernel-only code, or CONFIG_USERSPACE disabled, these inlines will
      31             :  *   directly call the implementation
      32             :  * - User-only code, these inlines will marshal parameters and elevate
      33             :  *   privileges
      34             :  * - Mixed or indeterminate code, these inlines will do a runtime check
      35             :  *   to determine what course of action is needed.
      36             :  *
      37             :  * All system calls require a verifier function and an implementation
      38             :  * function.  These must follow a naming convention. For a system call
      39             :  * named k_foo():
      40             :  *
      41             :  * - The handler function will be named z_vrfy_k_foo(). Handler
      42             :  *   functions have the same type signature as the wrapped call,
      43             :  *   verify arguments passed up from userspace, and call the
      44             :  *   implementation function. See documentation for that typedef for
      45             :  *   more information.  - The implementation function will be named
      46             :  *   z_impl_k_foo(). This is the actual implementation of the system
      47             :  *   call.
      48             :  */
      49             : 
      50             : /**
      51             :  * @typedef _k_syscall_handler_t
      52             :  * @brief System call handler function type
      53             :  *
      54             :  * These are kernel-side skeleton functions for system calls. They are
      55             :  * necessary to sanitize the arguments passed into the system call:
      56             :  *
      57             :  * - Any kernel object or device pointers are validated with _SYSCALL_IS_OBJ()
      58             :  * - Any memory buffers passed in are checked to ensure that the calling thread
      59             :  *   actually has access to them
      60             :  * - Many kernel calls do no sanity checking of parameters other than
      61             :  *   assertions. The handler must check all of these conditions using
      62             :  *   _SYSCALL_ASSERT()
      63             :  * - If the system call has more than 6 arguments, then arg6 will be a pointer
      64             :  *   to some struct containing arguments 6+. The struct itself needs to be
      65             :  *   validated like any other buffer passed in from userspace, and its members
      66             :  *   individually validated (if necessary) and then passed to the real
      67             :  *   implementation like normal arguments
      68             :  *
      69             :  * Even if the system call implementation has no return value, these always
      70             :  * return something, even 0, to prevent register leakage to userspace.
      71             :  *
      72             :  * Once everything has been validated, the real implementation will be executed.
      73             :  *
      74             :  * @param arg1 system call argument 1
      75             :  * @param arg2 system call argument 2
      76             :  * @param arg3 system call argument 3
      77             :  * @param arg4 system call argument 4
      78             :  * @param arg5 system call argument 5
      79             :  * @param arg6 system call argument 6
      80             :  * @param ssf System call stack frame pointer. Used to generate kernel oops
      81             :  *            via _arch_syscall_oops_at(). Contents are arch-specific.
      82             :  * @return system call return value, or 0 if the system call implementation
      83             :  *         return void
      84             :  *
      85             :  */
      86             : typedef uintptr_t (*_k_syscall_handler_t)(uintptr_t arg1, uintptr_t arg2,
      87             :                                           uintptr_t arg3, uintptr_t arg4,
      88             :                                           uintptr_t arg5, uintptr_t arg6,
      89             :                                           void *ssf);
      90             : 
      91             : /* True if a syscall function must trap to the kernel, usually a
      92             :  * compile-time decision.
      93             :  */
      94             : static ALWAYS_INLINE bool z_syscall_trap(void)
      95             : {
      96             :         bool ret = false;
      97             : #ifdef CONFIG_USERSPACE
      98             : #if defined(__ZEPHYR_SUPERVISOR__)
      99             :         ret = false;
     100             : #elif defined(__ZEPHYR_USER__)
     101             :         ret = true;
     102             : #else
     103             :         ret = arch_is_user_context();
     104             : #endif
     105             : #endif
     106             :         return ret;
     107             : }
     108             : 
     109             : /**
     110             :  * Indicate whether the CPU is currently in user mode
     111             :  *
     112             :  * @return true if the CPU is currently running with user permissions
     113             :  */
     114             : __pinned_func
     115           1 : static inline bool k_is_user_context(void)
     116             : {
     117             : #ifdef CONFIG_USERSPACE
     118             :         return arch_is_user_context();
     119             : #else
     120             :         return false;
     121             : #endif
     122             : }
     123             : 
     124             : #ifdef __cplusplus
     125             : }
     126             : #endif
     127             : 
     128             : #endif /* _ASMLANGUAGE */
     129             : 
     130             : #endif