diff options
Diffstat (limited to 'kernel/include/kernel_structs.h')
| -rw-r--r-- | kernel/include/kernel_structs.h | 225 |
1 files changed, 225 insertions, 0 deletions
diff --git a/kernel/include/kernel_structs.h b/kernel/include/kernel_structs.h new file mode 100644 index 000000000..c82fc61a5 --- /dev/null +++ b/kernel/include/kernel_structs.h @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2016 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. + */ + +#ifndef _kernel_structs__h_ +#define _kernel_structs__h_ + +#if !defined(_ASMLANGUAGE) +#include <kernel.h> +#include <atomic.h> +#include <misc/dlist.h> +#endif + +/* + * Common bitmask definitions for the struct tcs->flags bit field. + * + * Must be before kerneL_arch_data.h because it might need them to be already + * defined. + */ + +/* thread is defined statically */ +#define K_STATIC (1 << 8) + +/* Thread is waiting on an object */ +#define K_PENDING (1 << 13) + +/* Thread has not yet started */ +#define K_PRESTART (1 << 14) + +/* Thread has terminated */ +#define K_DEAD (1 << 15) + +/* Thread is suspended */ +#define K_SUSPENDED (1 << 16) + +/* Not a real thread */ +#define K_DUMMY (1 << 17) + +#if defined(CONFIG_FP_SHARING) +/* thread uses floating point registers */ +#define K_FP_REGS (1 << 4) +#endif + +/* system thread that must not abort */ +#define K_ESSENTIAL (1 << 9) + +#include <kernel_arch_data.h> + +#if !defined(_ASMLANGUAGE) + +#ifdef CONFIG_THREAD_MONITOR +struct __thread_entry { + _thread_entry_t pEntry; + void *parameter1; + void *parameter2; + void *parameter3; +}; +#endif + +/* can be used for creating 'dummy' threads, e.g. for pending on objects */ +struct _thread_base { + + /* this thread's entry in a ready/wait queue */ + sys_dnode_t k_q_node; + + /* execution flags */ + int flags; + + /* thread priority used to sort linked list */ + int prio; + + /* scheduler lock count */ + atomic_t sched_locked; + + /* data returned by APIs */ + void *swap_data; + +#ifdef CONFIG_NANO_TIMEOUTS + /* this thread's entry in a timeout queue */ + struct _timeout timeout; +#endif + +}; + +typedef struct _thread_base _thread_base_t; + +struct k_thread { + + struct _thread_base base; + + /* defined by the architecture, but all archs need these */ + struct _caller_saved caller_saved; + struct _callee_saved callee_saved; + + /* static thread init data */ + void *init_data; + + /* abort function */ + void (*fn_abort)(void); + +#if defined(CONFIG_THREAD_MONITOR) + /* thread entry and parameters description */ + struct __thread_entry *entry; + + /* next item in list of all threads */ + struct k_thread *next_thread; +#endif + +#ifdef CONFIG_THREAD_CUSTOM_DATA + /* crude thread-local storage */ + void *custom_data; +#endif + +#ifdef CONFIG_ERRNO + /* per-thread errno variable */ + int errno_var; +#endif + + /* arch-specifics: must always be at the end */ + struct _thread_arch arch; +}; + +typedef struct k_thread _thread_t; + +struct _ready_q { + + /* next thread to run if known, NULL otherwise */ + struct k_thread *cache; + + /* bitmap of priorities that contain at least one ready thread */ + uint32_t prio_bmap[K_NUM_PRIO_BITMAPS]; + + /* ready queues, one per priority */ + sys_dlist_t q[K_NUM_PRIORITIES]; +}; + +typedef struct _ready_q _ready_q_t; + +struct _kernel { + + /* nested interrupt count */ + uint32_t nested; + + /* interrupt stack pointer base */ + char *irq_stack; + + /* currently scheduled thread */ + struct k_thread *current; + +#ifdef CONFIG_SYS_CLOCK_EXISTS + /* queue of timeouts */ + sys_dlist_t timeout_q; +#endif + +#ifdef CONFIG_SYS_POWER_MANAGEMENT + int32_t idle; /* Number of ticks for kernel idling */ +#endif + + /* + * ready queue: can be big, keep after small fields, since some + * assembly (e.g. ARC) are limited in the encoding of the offset + */ + struct _ready_q ready_q; + +#ifdef CONFIG_FP_SHARING + /* + * A 'current_sse' field does not exist in addition to the 'current_fp' + * field since it's not possible to divide the IA-32 non-integer + * registers into 2 distinct blocks owned by differing threads. In + * other words, given that the 'fxnsave/fxrstor' instructions + * save/restore both the X87 FPU and XMM registers, it's not possible + * for a thread to only "own" the XMM registers. + */ + + /* thread (fiber or task) that owns the FP regs */ + struct k_thread *current_fp; +#endif + +#if defined(CONFIG_THREAD_MONITOR) + struct k_thread *threads; /* singly linked list of ALL fiber+tasks */ +#endif + + /* arch-specific part of _kernel */ + struct _kernel_arch arch; +}; + +typedef struct _kernel _kernel_t; + +extern struct _kernel _kernel; + +#define _current _kernel.current +#define _ready_q _kernel.ready_q +#define _timeout_q _kernel.timeout_q +#define _threads _kernel.threads + +#include <kernel_arch_func.h> + +static ALWAYS_INLINE void +_set_thread_return_value_with_data(struct k_thread *thread, + unsigned int value, + void *data) +{ + _set_thread_return_value(thread, value); + thread->base.swap_data = data; +} + +extern void _init_thread_base(struct _thread_base *thread_base, + int priority, uint32_t initial_state, + unsigned int options); + +#endif /* _ASMLANGUAGE */ + +#endif /* _kernel_structs__h_ */ |