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)
 
#define K_KERNEL_STACK_DECLARE(sym, size) \
        extern struct z_thread_stack_element \
                sym[K_KERNEL_STACK_LEN(size)]
 
#define K_KERNEL_STACK_ARRAY_DECLARE(sym, nmemb, size) \
        extern struct z_thread_stack_element \
                sym[nmemb][K_KERNEL_STACK_LEN(size)]
 
#define K_KERNEL_PINNED_STACK_ARRAY_DECLARE(sym, nmemb, 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)
 
#if defined(CONFIG_LINKER_USE_PINNED_SECTION)
#define K_KERNEL_PINNED_STACK_DEFINE(sym, size) \
        Z_KERNEL_STACK_DEFINE_IN(sym, size, __pinned_noinit)
#else
#define K_KERNEL_PINNED_STACK_DEFINE(sym, size) \
        Z_KERNEL_STACK_DEFINE_IN(sym, size, __kstackmem)
#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
#define K_KERNEL_STACK_ARRAY_DEFINE(sym, nmemb, size) \
        Z_KERNEL_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, __kstackmem)
 
#if defined(CONFIG_LINKER_USE_PINNED_SECTION)
#define K_KERNEL_PINNED_STACK_ARRAY_DEFINE(sym, nmemb, size) \
        Z_KERNEL_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, __pinned_noinit)
#else
#define K_KERNEL_PINNED_STACK_ARRAY_DEFINE(sym, nmemb, size) \
        Z_KERNEL_STACK_ARRAY_DEFINE_IN(sym, nmemb, size, __kstackmem)
#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
#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_MEMBER           K_KERNEL_STACK_MEMBER
#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
#define K_THREAD_PINNED_STACK_DEFINE    K_KERNEL_PINNED_STACK_DEFINE
#define K_THREAD_PINNED_STACK_ARRAY_DEFINE \
                                        K_KERNEL_PINNED_STACK_ARRAY_DEFINE
#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)
 
#if defined(CONFIG_LINKER_USE_PINNED_SECTION)
#define K_THREAD_PINNED_STACK_DEFINE(sym, size) \
        Z_THREAD_STACK_DEFINE_IN(sym, size, __pinned_noinit)
#else
#define K_THREAD_PINNED_STACK_DEFINE(sym, size) \
        K_THREAD_STACK_DEFINE(sym, size)
#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
#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)
 
#if defined(CONFIG_LINKER_USE_PINNED_SECTION)
#define K_THREAD_PINNED_STACK_ARRAY_DEFINE(sym, nmemb, size) \
        Z_THREAD_PINNED_STACK_DEFINE_IN(sym, nmemb, size, __pinned_noinit)
#else
#define K_THREAD_PINNED_STACK_ARRAY_DEFINE(sym, nmemb, size) \
        K_THREAD_STACK_ARRAY_DEFINE(sym, nmemb, size)
#endif /* CONFIG_LINKER_USE_PINNED_SECTION */
 
#define K_THREAD_STACK_MEMBER(sym, size) __DEPRECATED_MACRO \
        Z_THREAD_STACK_DEFINE_IN(sym, size,)
 
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 */