thread_stack.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */


 
#ifndef ZEPHYR_INCLUDE_KERNEL_THREAD_STACK_H
#define ZEPHYR_INCLUDE_KERNEL_THREAD_STACK_H
 
#if !defined(_ASMLANGUAGE)
#include <zephyr/arch/cpu.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Using typedef deliberately here, this is quite intended to be an opaque
 * type.
 *
 * The purpose of this data type is to clearly distinguish between the
 * declared symbol for a stack (of type k_thread_stack_t) and the underlying
 * buffer which composes the stack data actually used by the underlying
 * thread; they cannot be used interchangeably as some arches precede the
 * stack buffer region with guard areas that trigger a MPU or MMU fault
 * if written to.
 *
 * APIs that want to work with the buffer inside should continue to use
 * char *.
 *
 * Stacks should always be created with K_THREAD_STACK_DEFINE().
 */
struct __packed z_thread_stack_element {
        char data;
};

 

static inline char *z_stack_ptr_align(char *ptr)
{
        return (char *)ROUND_DOWN(ptr, ARCH_STACK_PTR_ALIGN);
}
#define Z_STACK_PTR_ALIGN(ptr) ((uintptr_t)z_stack_ptr_align((char *)(ptr)))

#define Z_STACK_PTR_TO_FRAME(type, ptr) \
        (type *)((ptr) - sizeof(type))
 
#ifdef ARCH_KERNEL_STACK_RESERVED
#define K_KERNEL_STACK_RESERVED ((size_t)ARCH_KERNEL_STACK_RESERVED)
#else
#define K_KERNEL_STACK_RESERVED ((size_t)0)
#endif /* ARCH_KERNEL_STACK_RESERVED */
 
#define Z_KERNEL_STACK_SIZE_ADJUST(size) (ROUND_UP(size, \
                                                   ARCH_STACK_PTR_ALIGN) + \
                                          K_KERNEL_STACK_RESERVED)
 
#ifdef ARCH_KERNEL_STACK_OBJ_ALIGN
#define Z_KERNEL_STACK_OBJ_ALIGN        ARCH_KERNEL_STACK_OBJ_ALIGN
#else
#define Z_KERNEL_STACK_OBJ_ALIGN        ARCH_STACK_PTR_ALIGN
#endif /* ARCH_KERNEL_STACK_OBJ_ALIGN */
 
#define K_KERNEL_STACK_LEN(size) \
        ROUND_UP(Z_KERNEL_STACK_SIZE_ADJUST(size), Z_KERNEL_STACK_OBJ_ALIGN)

 
#ifdef CONFIG_HW_SHADOW_STACK
#define k_thread_hw_shadow_stack_t arch_thread_hw_shadow_stack_t

#define K_THREAD_HW_SHADOW_STACK_SIZE(size_) \
        ARCH_THREAD_HW_SHADOW_STACK_SIZE(size_)

#define K_KERNEL_HW_SHADOW_STACK_DECLARE(sym, size) \
        ARCH_THREAD_HW_SHADOW_STACK_DECLARE(__ ## sym ## _shstk, size)

#define K_KERNEL_HW_SHADOW_STACK_ARRAY_DECLARE(sym, nmemb, size) \
        ARCH_THREAD_HW_SHADOW_STACK_ARRAY_DECLARE(__ ## sym ## _shstk_arr, \
                                                  nmemb, size)
 
struct _stack_to_hw_shadow_stack {
        k_thread_stack_t *stack;
        k_thread_hw_shadow_stack_t *shstk_addr;
        size_t size;
};
 

#define K_THREAD_HW_SHADOW_STACK_DEFINE(sym, size_) \
        ARCH_THREAD_HW_SHADOW_STACK_DEFINE(__ ## sym ## _shstk, size_); \
        static const STRUCT_SECTION_ITERABLE(_stack_to_hw_shadow_stack, \
                sym ## _stack_to_shstk_attach) = { \
                .stack = sym, \
                .shstk_addr = __ ## sym ## _shstk, \
                .size = size_, \
        }
 
struct _stack_to_hw_shadow_stack_arr {
        uintptr_t stack_addr;
        uintptr_t shstk_addr;
        size_t stack_size;
        size_t shstk_size;
        size_t nmemb;
};

#define K_THREAD_HW_SHADOW_STACK_ARRAY_DEFINE(sym, nmemb_, size_) \
        ARCH_THREAD_HW_SHADOW_STACK_ARRAY_DEFINE(__ ## sym ## _shstk_arr, nmemb_, \
                        K_THREAD_HW_SHADOW_STACK_SIZE(size_)); \
        static const STRUCT_SECTION_ITERABLE(_stack_to_hw_shadow_stack_arr, \
                sym ## _stack_to_shstk_attach) = { \
                .stack_addr = (uintptr_t)sym, \
                .stack_size = K_KERNEL_STACK_LEN(size_), \
                .nmemb = nmemb_, \
                .shstk_addr = (uintptr_t)__ ## sym ## _shstk_arr, \
                .shstk_size = K_THREAD_HW_SHADOW_STACK_SIZE(size_), \
        }

#define k_thread_hw_shadow_stack_attach arch_thread_hw_shadow_stack_attach
 
struct _thread_hw_shadow_stack_static {
        struct k_thread *thread;
        k_thread_hw_shadow_stack_t *shstk_addr;
        size_t size;
};

#define K_THREAD_HW_SHADOW_STACK_ATTACH(thread_, shstk_addr_, size_) \
        static const STRUCT_SECTION_ITERABLE(_thread_hw_shadow_stack_static, \
                thread ## _shstk_attach_static) = { \
                .thread = thread_, \
                .shstk_addr = shstk_addr_, \
                .size = size_, \
        }
 
#else
#define K_KERNEL_HW_SHADOW_STACK_DECLARE(sym, size)
#define K_KERNEL_HW_SHADOW_STACK_ARRAY_DECLARE(sym, nmemb, size)
#define K_THREAD_HW_SHADOW_STACK_DEFINE(sym, size)
#define K_THREAD_HW_SHADOW_STACK_ARRAY_DEFINE(sym, nmemb, size_)
#endif

#define K_KERNEL_STACK_DECLARE(sym, size) \
        K_KERNEL_HW_SHADOW_STACK_DECLARE(sym, K_THREAD_HW_SHADOW_STACK_SIZE(size)); \
        extern struct z_thread_stack_element \
                sym[K_KERNEL_STACK_LEN(size)]

#define K_KERNEL_STACK_ARRAY_DECLARE(sym, nmemb, size) \
        K_KERNEL_HW_SHADOW_STACK_ARRAY_DECLARE(sym, nmemb, K_THREAD_HW_SHADOW_STACK_SIZE(size)); \
        extern struct z_thread_stack_element \
                sym[nmemb][K_KERNEL_STACK_LEN(size)]

#define Z_KERNEL_STACK_DEFINE_IN(sym, size, lsect) \
        struct z_thread_stack_element lsect \
                __aligned(Z_KERNEL_STACK_OBJ_ALIGN) \
                sym[K_KERNEL_STACK_LEN(size)]

#define Z_KERNEL_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, lsect) \
        struct z_thread_stack_element lsect \
                __aligned(Z_KERNEL_STACK_OBJ_ALIGN) \
                sym[nmemb][K_KERNEL_STACK_LEN(size)]

#define K_KERNEL_STACK_DEFINE(sym, size) \
        Z_KERNEL_STACK_DEFINE_IN(sym, size, __kstackmem); \
        K_THREAD_HW_SHADOW_STACK_DEFINE(sym, \
                                        K_THREAD_HW_SHADOW_STACK_SIZE(size))

#define K_KERNEL_STACK_ARRAY_DEFINE(sym, nmemb, size) \
        Z_KERNEL_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, __kstackmem); \
        K_THREAD_HW_SHADOW_STACK_ARRAY_DEFINE(sym, nmemb, size)

#define K_KERNEL_STACK_MEMBER(sym, size) \
        Z_KERNEL_STACK_DEFINE_IN(sym, size,)
 
#define K_KERNEL_STACK_SIZEOF(sym) (sizeof(sym) - K_KERNEL_STACK_RESERVED)

 
static inline char *K_KERNEL_STACK_BUFFER(k_thread_stack_t *sym)
{
        return (char *)sym + K_KERNEL_STACK_RESERVED;
}
#ifndef CONFIG_USERSPACE
#define K_THREAD_STACK_RESERVED         K_KERNEL_STACK_RESERVED
#define K_THREAD_STACK_SIZEOF           K_KERNEL_STACK_SIZEOF
#define K_THREAD_STACK_LEN              K_KERNEL_STACK_LEN
#define K_THREAD_STACK_DEFINE           K_KERNEL_STACK_DEFINE
#define K_THREAD_STACK_ARRAY_DEFINE     K_KERNEL_STACK_ARRAY_DEFINE
#define K_THREAD_STACK_BUFFER           K_KERNEL_STACK_BUFFER
#define K_THREAD_STACK_DECLARE          K_KERNEL_STACK_DECLARE
#define K_THREAD_STACK_ARRAY_DECLARE    K_KERNEL_STACK_ARRAY_DECLARE
#else
#ifdef ARCH_THREAD_STACK_RESERVED
#define K_THREAD_STACK_RESERVED         ((size_t)(ARCH_THREAD_STACK_RESERVED))
#else
#define K_THREAD_STACK_RESERVED         ((size_t)0U)
#endif /* ARCH_THREAD_STACK_RESERVED */

#if defined(ARCH_THREAD_STACK_OBJ_ALIGN)
#define Z_THREAD_STACK_OBJ_ALIGN(size)  \
        ARCH_THREAD_STACK_OBJ_ALIGN(Z_THREAD_STACK_SIZE_ADJUST(size))
#else
#define Z_THREAD_STACK_OBJ_ALIGN(size)  ARCH_STACK_PTR_ALIGN
#endif /* ARCH_THREAD_STACK_OBJ_ALIGN */

#if defined(ARCH_THREAD_STACK_SIZE_ADJUST)
#define Z_THREAD_STACK_SIZE_ADJUST(size) \
        ARCH_THREAD_STACK_SIZE_ADJUST((size) + K_THREAD_STACK_RESERVED)
#else
#define Z_THREAD_STACK_SIZE_ADJUST(size) \
        (ROUND_UP((size), ARCH_STACK_PTR_ALIGN) + K_THREAD_STACK_RESERVED)
#endif /* ARCH_THREAD_STACK_SIZE_ADJUST */


#define K_THREAD_STACK_DECLARE(sym, size) \
        extern struct z_thread_stack_element \
                sym[K_THREAD_STACK_LEN(size)]

#define K_THREAD_STACK_ARRAY_DECLARE(sym, nmemb, size) \
        extern struct z_thread_stack_element \
                sym[nmemb][K_THREAD_STACK_LEN(size)]

#define K_THREAD_STACK_SIZEOF(sym)      (sizeof(sym) - K_THREAD_STACK_RESERVED)

#define Z_THREAD_STACK_DEFINE_IN(sym, size, lsect) \
        struct z_thread_stack_element lsect \
                __aligned(Z_THREAD_STACK_OBJ_ALIGN(size)) \
                sym[K_THREAD_STACK_LEN(size)]

#define Z_THREAD_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, lsect) \
        struct z_thread_stack_element lsect \
                __aligned(Z_THREAD_STACK_OBJ_ALIGN(size)) \
                sym[nmemb][K_THREAD_STACK_LEN(size)]

#define K_THREAD_STACK_DEFINE(sym, size) \
        Z_THREAD_STACK_DEFINE_IN(sym, size, __stackmem)

#define K_THREAD_STACK_LEN(size) \
        ROUND_UP(Z_THREAD_STACK_SIZE_ADJUST(size), \
                 Z_THREAD_STACK_OBJ_ALIGN(size))

#define K_THREAD_STACK_ARRAY_DEFINE(sym, nmemb, size) \
        Z_THREAD_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, __stackmem)


static inline char *K_THREAD_STACK_BUFFER(k_thread_stack_t *sym)
{
        return (char *)sym + K_THREAD_STACK_RESERVED;
}
 
#endif /* CONFIG_USERSPACE */
 
#ifdef __cplusplus
}
#endif
 
#endif /* _ASMLANGUAGE */
#endif /* ZEPHYR_INCLUDE_KERNEL_THREAD_STACK_H */