f955476559
Some thread fields were 32-bit wide, when they are not even close to using that full range of values. They are instead changed to 8-bit fields. - prio can fit in one byte, limiting the priorities range to -128 to 127 - recursive scheduler locking can be limited to 255; a rollover results most probably from a logic error - flags are split into execution flags and thread states; 8 bits is enough for each of them currently, with at worst two states and four flags to spare (on x86, on other archs, there are six flags to spare) Doing this saves 8 bytes per stack. It also sets up an incoming enhancement when checking if the current thread is preemptible on interrupt exit. Change-Id: Ieb5321a5b99f99173b0605dd4a193c3bc7ddabf4 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
239 lines
5.3 KiB
C
239 lines
5.3 KiB
C
/*
|
|
* 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
|
|
|
|
/*
|
|
* bitmask definitions for the execution_flags and state
|
|
*
|
|
* Must be before kerneL_arch_data.h because it might need them to be already
|
|
* defined.
|
|
*/
|
|
|
|
|
|
/* states: common uses low bits, arch-specific use high bits */
|
|
|
|
/* system thread that must not abort */
|
|
#define K_ESSENTIAL (1 << 0)
|
|
|
|
/* Thread is waiting on an object */
|
|
#define K_PENDING (1 << 1)
|
|
|
|
/* Thread has not yet started */
|
|
#define K_PRESTART (1 << 2)
|
|
|
|
/* Thread has terminated */
|
|
#define K_DEAD (1 << 3)
|
|
|
|
/* Thread is suspended */
|
|
#define K_SUSPENDED (1 << 4)
|
|
|
|
/* Not a real thread */
|
|
#define K_DUMMY (1 << 5)
|
|
|
|
/* end - states */
|
|
|
|
|
|
/* execution flags: common uses low bits, arch-specific use high bits */
|
|
|
|
/* thread is defined statically */
|
|
#define K_STATIC (1 << 0)
|
|
|
|
#if defined(CONFIG_FP_SHARING)
|
|
/* thread uses floating point registers */
|
|
#define K_FP_REGS (1 << 1)
|
|
#endif
|
|
/* end - execution flags */
|
|
|
|
|
|
#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 */
|
|
uint8_t execution_flags;
|
|
|
|
/* thread state */
|
|
uint8_t thread_state;
|
|
|
|
/* scheduler lock count */
|
|
volatile uint8_t sched_locked;
|
|
|
|
/* thread priority used to sort linked list */
|
|
int8_t prio;
|
|
|
|
/* data returned by APIs */
|
|
void *swap_data;
|
|
|
|
#ifdef CONFIG_SYS_CLOCK_EXISTS
|
|
/* 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 {
|
|
|
|
/* always contains next thread to run: cannot be NULL */
|
|
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_ */
|