mirror of
https://github.com/zephyrproject-rtos/zephyr
synced 2025-09-09 15:14:00 +00:00
507852a4ad
Historically, stacks were just character buffers and could be treated as such if the user wanted to look inside the stack data, and also declared as an array of the desired stack size. This is no longer the case. Certain architectures will create a memory region much larger to account for MPU/MMU guard pages. Unfortunately, the kernel interfaces treat both the declared stack, and the valid stack buffer within it as the same char * data type, even though these absolutely cannot be used interchangeably. We introduce an opaque k_thread_stack_t which gets instantiated by K_THREAD_STACK_DECLARE(), this is no longer treated by the compiler as a character pointer, even though it really is. To access the real stack buffer within, the result of K_THREAD_STACK_BUFFER() can be used, which will return a char * type. This should catch a bunch of programming mistakes at build time: - Declaring a character array outside of K_THREAD_STACK_DECLARE() and passing it to K_THREAD_CREATE - Directly examining the stack created by K_THREAD_STACK_DECLARE() which is not actually the memory desired and may trigger a CPU exception Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
70 lines
2.4 KiB
C
70 lines
2.4 KiB
C
/*
|
|
* Copyright (c) 2016 Jean-Paul Etienne <fractalclone@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include <kernel.h>
|
|
#include <arch/cpu.h>
|
|
#include <kernel_structs.h>
|
|
#include <wait_q.h>
|
|
#include <string.h>
|
|
|
|
void _thread_entry_wrapper(_thread_entry_t thread,
|
|
void *arg1,
|
|
void *arg2,
|
|
void *arg3);
|
|
|
|
void _new_thread(struct k_thread *thread, k_thread_stack_t stack,
|
|
size_t stack_size, _thread_entry_t thread_func,
|
|
void *arg1, void *arg2, void *arg3,
|
|
int priority, unsigned int options)
|
|
{
|
|
char *stack_memory = K_THREAD_STACK_BUFFER(stack);
|
|
_ASSERT_VALID_PRIO(priority, thread_func);
|
|
|
|
struct __esf *stack_init;
|
|
|
|
_new_thread_init(thread, stack_memory, stack_size, priority, options);
|
|
|
|
/* Initial stack frame for thread */
|
|
stack_init = (struct __esf *)
|
|
STACK_ROUND_DOWN(stack_memory +
|
|
stack_size - sizeof(struct __esf));
|
|
|
|
/* Setup the initial stack frame */
|
|
stack_init->a0 = (u32_t)thread_func;
|
|
stack_init->a1 = (u32_t)arg1;
|
|
stack_init->a2 = (u32_t)arg2;
|
|
stack_init->a3 = (u32_t)arg3;
|
|
/*
|
|
* Following the RISC-V architecture,
|
|
* the MSTATUS register (used to globally enable/disable interrupt),
|
|
* as well as the MEPC register (used to by the core to save the
|
|
* value of the program counter at which an interrupt/exception occcurs)
|
|
* need to be saved on the stack, upon an interrupt/exception
|
|
* and restored prior to returning from the interrupt/exception.
|
|
* This shall allow to handle nested interrupts.
|
|
*
|
|
* Given that context switching is performed via a system call exception
|
|
* within the RISCV32 architecture implementation, initially set:
|
|
* 1) MSTATUS to SOC_MSTATUS_DEF_RESTORE in the thread stack to enable
|
|
* interrupts when the newly created thread will be scheduled;
|
|
* 2) MEPC to the address of the _thread_entry_wrapper in the thread
|
|
* stack.
|
|
* Hence, when going out of an interrupt/exception/context-switch,
|
|
* after scheduling the newly created thread:
|
|
* 1) interrupts will be enabled, as the MSTATUS register will be
|
|
* restored following the MSTATUS value set within the thread stack;
|
|
* 2) the core will jump to _thread_entry_wrapper, as the program
|
|
* counter will be restored following the MEPC value set within the
|
|
* thread stack.
|
|
*/
|
|
stack_init->mstatus = SOC_MSTATUS_DEF_RESTORE;
|
|
stack_init->mepc = (u32_t)_thread_entry_wrapper;
|
|
|
|
thread->callee_saved.sp = (u32_t)stack_init;
|
|
|
|
thread_monitor_init(thread);
|
|
}
|