/* * @brief Initialize a new thread from its stack space * * The thread control structure is put at the lower address of the stack. An * initial context, to be "restored" by __return_from_coop(), is put at * the other end of the stack, and thus reusable by the stack when not * needed anymore. * * The initial context is a basic stack frame that contains arguments for * _thread_entry() return address, that points at _thread_entry() * and status register. * * <options> is currently unused. * * @param pStackmem the pointer to aligned stack memory * @param stackSize the stack size in bytes * @param pEntry thread entry point routine * @param parameter1 first param to entry point * @param parameter2 second param to entry point * @param parameter3 third param to entry point * @param priority thread priority * @param options thread options: K_ESSENTIAL * * @return N/A */ void _new_thread(struct k_thread *thread, k_thread_stack_t stack, size_t stackSize, _thread_entry_t pEntry, void *parameter1, void *parameter2, void *parameter3, int priority, unsigned int options) { char *pStackMem = K_THREAD_STACK_BUFFER(stack); _ASSERT_VALID_PRIO(priority, pEntry); char *stackEnd = pStackMem + stackSize; struct init_stack_frame *pInitCtx; _new_thread_init(thread, pStackMem, stackSize, priority, options); /* carve the thread entry struct from the "base" of the stack */ pInitCtx = (struct init_stack_frame *)(STACK_ROUND_DOWN(stackEnd) - sizeof(struct init_stack_frame)); pInitCtx->pc = ((u32_t)_thread_entry_wrapper); pInitCtx->r0 = (u32_t)pEntry; pInitCtx->r1 = (u32_t)parameter1; pInitCtx->r2 = (u32_t)parameter2; pInitCtx->r3 = (u32_t)parameter3; /* * For now set the interrupt priority to 15 * we can leave interrupt enable flag set to 0 as * seti instruction in the end of the _Swap() will * enable the interrupts based on intlock_key * value. */ #ifdef CONFIG_ARC_STACK_CHECKING pInitCtx->status32 = _ARC_V2_STATUS32_SC | _ARC_V2_STATUS32_E(_ARC_V2_DEF_IRQ_LEVEL); thread->arch.stack_base = (u32_t) stackEnd; #else pInitCtx->status32 = _ARC_V2_STATUS32_E(_ARC_V2_DEF_IRQ_LEVEL); #endif #ifdef CONFIG_THREAD_MONITOR /* * In debug mode thread->entry give direct access to the thread entry * and the corresponding parameters. */ thread->entry = (struct __thread_entry *)(pInitCtx); #endif /* * intlock_key is constructed based on ARCv2 ISA Programmer's * Reference Manual CLRI instruction description: * dst[31:6] dst[5] dst[4] dst[3:0] * 26'd0 1 STATUS32.IE STATUS32.E[3:0] */ thread->arch.intlock_key = 0x3F; thread->arch.relinquish_cause = _CAUSE_COOP; thread->callee_saved.sp = (u32_t)pInitCtx - ___callee_saved_stack_t_SIZEOF; /* initial values in all other regs/k_thread entries are irrelevant */ thread_monitor_init(thread); }
void _new_thread(struct k_thread *thread, k_thread_stack_t *stack, size_t stack_size, k_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); }
void _new_thread(char *pStackMem, size_t stackSize, _thread_entry_t pEntry, void *parameter1, void *parameter2, void *parameter3, int priority, unsigned int options) { _ASSERT_VALID_PRIO(priority, pEntry); __ASSERT(!((u32_t)pStackMem & (STACK_ALIGN - 1)), "stack is not aligned properly\n" "%d-byte alignment required\n", STACK_ALIGN); char *stackEnd = pStackMem + stackSize; struct __esf *pInitCtx; struct k_thread *thread = (struct k_thread *) pStackMem; thread = _new_thread_init(pStackMem, stackSize, priority, options); /* carve the thread entry struct from the "base" of the stack */ pInitCtx = (struct __esf *)(STACK_ROUND_DOWN(stackEnd) - sizeof(struct __esf)); pInitCtx->pc = ((u32_t)_thread_entry) & 0xfffffffe; pInitCtx->a1 = (u32_t)pEntry; pInitCtx->a2 = (u32_t)parameter1; pInitCtx->a3 = (u32_t)parameter2; pInitCtx->a4 = (u32_t)parameter3; pInitCtx->xpsr = 0x01000000UL; /* clear all, thumb bit is 1, even if RO */ #ifdef CONFIG_THREAD_MONITOR /* * In debug mode thread->entry give direct access to the thread entry * and the corresponding parameters. */ thread->entry = (struct __thread_entry *)(pInitCtx); #endif thread->callee_saved.psp = (u32_t)pInitCtx; thread->arch.basepri = 0; /* swap_return_value can contain garbage */ /* * initial values in all other registers/thread entries are * irrelevant. */ thread_monitor_init(thread); }
/** * @brief Create a new kernel execution thread * * Initializes the k_thread object and sets up initial stack frame. * * @param thread pointer to thread struct memory, including any space needed * for extra coprocessor context * @param stack the pointer to aligned stack memory * @param stack_size the stack size in bytes * @param entry thread entry point routine * @param arg1 first param to entry point * @param arg2 second param to entry point * @param arg3 third param to entry point * @param priority thread priority * @param options thread options: K_ESSENTIAL, K_FP_REGS, K_SSE_REGS * * Note that in this arch we cheat quite a bit: we use as stack a normal * pthreads stack and therefore we ignore the stack size * */ void _new_thread(struct k_thread *thread, k_thread_stack_t *stack, size_t stack_size, k_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); posix_thread_status_t *thread_status; _new_thread_init(thread, stack_memory, stack_size, priority, options); /* We store it in the same place where normal archs store the * "initial stack frame" */ thread_status = (posix_thread_status_t *) STACK_ROUND_DOWN(stack_memory + stack_size - sizeof(*thread_status)); /* _thread_entry() arguments */ thread_status->entry_point = thread_func; thread_status->arg1 = arg1; thread_status->arg2 = arg2; thread_status->arg3 = arg3; #if defined(CONFIG_ARCH_HAS_THREAD_ABORT) thread_status->aborted = 0; #endif thread->callee_saved.thread_status = (u32_t)thread_status; posix_new_thread(thread_status); thread_monitor_init(thread); }
void _new_thread(char *pStackMem, size_t stackSize, _thread_entry_t pEntry, void *parameter1, void *parameter2, void *parameter3, int priority, unsigned options) { _ASSERT_VALID_PRIO(priority, pEntry); __ASSERT(!((uint32_t)pStackMem & (STACK_ALIGN - 1)), "stack is not aligned properly\n" "%d-byte alignment required\n", STACK_ALIGN); char *stackEnd = pStackMem + stackSize; struct __esf *pInitCtx; struct tcs *tcs = (struct tcs *) pStackMem; #ifdef CONFIG_INIT_STACKS memset(pStackMem, 0xaa, stackSize); #endif /* carve the thread entry struct from the "base" of the stack */ pInitCtx = (struct __esf *)(STACK_ROUND_DOWN(stackEnd) - sizeof(struct __esf)); pInitCtx->pc = ((uint32_t)_thread_entry) & 0xfffffffe; pInitCtx->a1 = (uint32_t)pEntry; pInitCtx->a2 = (uint32_t)parameter1; pInitCtx->a3 = (uint32_t)parameter2; pInitCtx->a4 = (uint32_t)parameter3; pInitCtx->xpsr = 0x01000000UL; /* clear all, thumb bit is 1, even if RO */ _init_thread_base(&tcs->base, priority, K_PRESTART, options); /* static threads overwrite it afterwards with real value */ tcs->init_data = NULL; tcs->fn_abort = NULL; #ifdef CONFIG_THREAD_CUSTOM_DATA /* Initialize custom data field (value is opaque to kernel) */ tcs->custom_data = NULL; #endif #ifdef CONFIG_THREAD_MONITOR /* * In debug mode tcs->entry give direct access to the thread entry * and the corresponding parameters. */ tcs->entry = (struct __thread_entry *)(pInitCtx); #endif tcs->callee_saved.psp = (uint32_t)pInitCtx; tcs->arch.basepri = 0; /* swap_return_value can contain garbage */ /* initial values in all other registers/TCS entries are irrelevant */ thread_monitor_init(tcs); }