| /* |
| * Copyright (c) 2010-2014 Wind River Systems, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file |
| * @brief Nanokernel thread support |
| * |
| * This module provides general purpose thread support, with applies to both |
| * tasks or fibers. |
| */ |
| |
| #include <toolchain.h> |
| #include <sections.h> |
| |
| #include <nano_private.h> |
| #include <misc/printk.h> |
| #include <sys_clock.h> |
| #include <drivers/system_timer.h> |
| |
| |
| nano_thread_id_t sys_thread_self_get(void) |
| { |
| return _nanokernel.current; |
| } |
| |
| nano_context_type_t sys_execution_context_type_get(void) |
| { |
| if (_IS_IN_ISR()) |
| return NANO_CTX_ISR; |
| |
| if ((_nanokernel.current->flags & TASK) == TASK) |
| return NANO_CTX_TASK; |
| |
| return NANO_CTX_FIBER; |
| } |
| |
| /** |
| * |
| * @brief Mark thread as essential to system |
| * |
| * This function tags the running fiber or task as essential to system |
| * operation; exceptions raised by this thread will be treated as a fatal |
| * system error. |
| * |
| * @return N/A |
| */ |
| void _thread_essential_set(void) |
| { |
| _nanokernel.current->flags |= ESSENTIAL; |
| } |
| |
| /** |
| * |
| * @brief Mark thread as not essential to system |
| * |
| * This function tags the running fiber or task as not essential to system |
| * operation; exceptions raised by this thread may be recoverable. |
| * (This is the default tag for a thread.) |
| * |
| * @return N/A |
| */ |
| void _thread_essential_clear(void) |
| { |
| _nanokernel.current->flags &= ~ESSENTIAL; |
| } |
| |
| /** |
| * |
| * @brief Is the specified thread essential? |
| * |
| * This routine indicates if the running fiber or task is an essential system |
| * thread. |
| * |
| * @return Non-zero if current thread is essential, zero if it is not |
| */ |
| int _is_thread_essential(void) |
| { |
| return _nanokernel.current->flags & ESSENTIAL; |
| } |
| |
| void sys_thread_busy_wait(uint32_t usec_to_wait) |
| { |
| /* use 64-bit math to prevent overflow when multiplying */ |
| uint32_t cycles_to_wait = (uint32_t)( |
| (uint64_t)usec_to_wait * |
| (uint64_t)sys_clock_hw_cycles_per_sec / |
| (uint64_t)USEC_PER_SEC |
| ); |
| uint32_t start_cycles = sys_cycle_get_32(); |
| |
| for (;;) { |
| uint32_t current_cycles = sys_cycle_get_32(); |
| |
| /* this handles the rollover on an unsigned 32-bit value */ |
| if ((current_cycles - start_cycles) >= cycles_to_wait) { |
| break; |
| } |
| } |
| } |
| |
| #ifdef CONFIG_THREAD_CUSTOM_DATA |
| |
| /** |
| * |
| * @brief Set thread's custom data |
| * |
| * This routine sets the custom data value for the current task or fiber. |
| * Custom data is not used by the kernel itself, and is freely available |
| * for the thread to use as it sees fit. |
| * |
| * @param value New to set the thread's custom data to. |
| * |
| * @return N/A |
| */ |
| void sys_thread_custom_data_set(void *value) |
| { |
| _nanokernel.current->custom_data = value; |
| } |
| |
| /** |
| * |
| * @brief Get thread's custom data |
| * |
| * This function returns the custom data value for the current task or fiber. |
| * |
| * @return current handle value |
| */ |
| void *sys_thread_custom_data_get(void) |
| { |
| return _nanokernel.current->custom_data; |
| } |
| |
| #endif /* CONFIG_THREAD_CUSTOM_DATA */ |
| |
| #if defined(CONFIG_THREAD_MONITOR) |
| /** |
| * |
| * @brief Thread exit routine |
| * |
| * This function is invoked when the specified thread is aborted, either |
| * normally or abnormally. It is called for the termination of any thread, |
| * (fibers and tasks). |
| * |
| * This routine must be invoked either from a fiber or from a task with |
| * interrupts locked to guarantee that the list of threads does not change in |
| * mid-operation. It cannot be called from ISR context. |
| * |
| * @return N/A |
| */ |
| void _thread_exit(struct tcs *thread) |
| { |
| /* |
| * Remove thread from the list of threads. This singly linked list of |
| * threads maintains ALL the threads in the system: both tasks and |
| * fibers regardless of whether they are runnable. |
| */ |
| |
| if (thread == _nanokernel.threads) { |
| _nanokernel.threads = _nanokernel.threads->next_thread; |
| } else { |
| struct tcs *prev_thread; |
| |
| prev_thread = _nanokernel.threads; |
| while (thread != prev_thread->next_thread) { |
| prev_thread = prev_thread->next_thread; |
| } |
| prev_thread->next_thread = thread->next_thread; |
| } |
| } |
| #endif /* CONFIG_THREAD_MONITOR */ |
| |
| /** |
| * |
| * @brief Common thread entry point function |
| * |
| * This function serves as the entry point for _all_ threads, i.e. both |
| * task and fibers are instantiated such that initial execution starts |
| * here. |
| * |
| * This routine invokes the actual task or fiber entry point function and |
| * passes it three arguments. It also handles graceful termination of the |
| * task or fiber if the entry point function ever returns. |
| * |
| * @param pEntry address of the app entry point function |
| * @param parameter1 1st arg to the app entry point function |
| * @param parameter2 2nd arg to the app entry point function |
| * @param parameter3 3rd arg to the app entry point function |
| * |
| * @internal |
| * The 'noreturn' attribute is applied to this function so that the compiler |
| * can dispense with generating the usual preamble that is only required for |
| * functions that actually return. |
| * |
| * @return Does not return |
| * |
| */ |
| FUNC_NORETURN void _thread_entry(_thread_entry_t pEntry, |
| _thread_arg_t parameter1, |
| _thread_arg_t parameter2, |
| _thread_arg_t parameter3) |
| { |
| /* Execute the "application" entry point function */ |
| |
| pEntry(parameter1, parameter2, parameter3); |
| |
| /* Determine if thread can legally terminate itself via "return" */ |
| |
| if (_is_thread_essential()) { |
| #ifdef CONFIG_NANOKERNEL |
| /* |
| * Nanokernel's background task must always be present, |
| * so if it has nothing left to do just let it idle forever |
| */ |
| |
| while (((_nanokernel.current)->flags & TASK) == TASK) { |
| nano_cpu_idle(); |
| } |
| #endif /* CONFIG_NANOKERNEL */ |
| |
| /* Loss of essential thread is a system fatal error */ |
| |
| _NanoFatalErrorHandler(_NANO_ERR_INVALID_TASK_EXIT, |
| &_default_esf); |
| } |
| |
| /* Gracefully terminate the currently executing thread */ |
| |
| #ifdef CONFIG_MICROKERNEL |
| if (((_nanokernel.current)->flags & TASK) == TASK) { |
| extern FUNC_NORETURN void _TaskAbort(void); |
| _TaskAbort(); |
| } else |
| #endif /* CONFIG_MICROKERNEL */ |
| { |
| fiber_abort(); |
| } |
| |
| /* |
| * Compiler can't tell that fiber_abort() won't return and issues |
| * a warning unless we explicitly tell it that control never gets this |
| * far. |
| */ |
| |
| CODE_UNREACHABLE; |
| } |