Zephyr API Documentation 4.2.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
kernel_structs.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016 Wind River Systems, Inc.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7/*
8 * The purpose of this file is to provide essential/minimal kernel structure
9 * definitions, so that they can be used without including kernel.h.
10 *
11 * The following rules must be observed:
12 * 1. kernel_structs.h shall not depend on kernel.h both directly and
13 * indirectly (i.e. it shall not include any header files that include
14 * kernel.h in their dependency chain).
15 * 2. kernel.h shall imply kernel_structs.h, such that it shall not be
16 * necessary to include kernel_structs.h explicitly when kernel.h is
17 * included.
18 */
19
20#ifndef ZEPHYR_KERNEL_INCLUDE_KERNEL_STRUCTS_H_
21#define ZEPHYR_KERNEL_INCLUDE_KERNEL_STRUCTS_H_
22
23#if !defined(_ASMLANGUAGE)
24#include <zephyr/sys/atomic.h>
25#include <zephyr/types.h>
26#include <zephyr/sys/dlist.h>
27#include <zephyr/sys/util.h>
28#include <zephyr/sys/sys_heap.h>
29#include <zephyr/arch/structs.h>
30#include <zephyr/kernel/stats.h>
32#include <zephyr/sys/rb.h>
33#endif
34
35#define K_NUM_THREAD_PRIO (CONFIG_NUM_PREEMPT_PRIORITIES + CONFIG_NUM_COOP_PRIORITIES + 1)
36#define PRIQ_BITMAP_SIZE (DIV_ROUND_UP(K_NUM_THREAD_PRIO, BITS_PER_LONG))
37
38#ifdef __cplusplus
39extern "C" {
40#endif
41
42/*
43 * Bitmask definitions for the struct k_thread.thread_state field.
44 *
45 * Must be before kernel_arch_data.h because it might need them to be already
46 * defined.
47 */
48
49/* states: common uses low bits, arch-specific use high bits */
50
51/* Not a real thread */
52#define _THREAD_DUMMY (BIT(0))
53
54/* Thread is waiting on an object */
55#define _THREAD_PENDING (BIT(1))
56
57/* Thread is sleeping */
58#define _THREAD_SLEEPING (BIT(2))
59
60/* Thread has terminated */
61#define _THREAD_DEAD (BIT(3))
62
63/* Thread is suspended */
64#define _THREAD_SUSPENDED (BIT(4))
65
66/* Thread is in the process of aborting */
67#define _THREAD_ABORTING (BIT(5))
68
69/* Thread is in the process of suspending */
70#define _THREAD_SUSPENDING (BIT(6))
71
72/* Thread is present in the ready queue */
73#define _THREAD_QUEUED (BIT(7))
74
75/* end - states */
76
77#ifdef CONFIG_STACK_SENTINEL
78/* Magic value in lowest bytes of the stack */
79#define STACK_SENTINEL 0xF0F0F0F0
80#endif
81
82/* lowest value of _thread_base.preempt at which a thread is non-preemptible */
83#define _NON_PREEMPT_THRESHOLD 0x0080U
84
85/* highest value of _thread_base.preempt at which a thread is preemptible */
86#define _PREEMPT_THRESHOLD (_NON_PREEMPT_THRESHOLD - 1U)
87
88#if !defined(_ASMLANGUAGE)
89
90/* Two abstractions are defined here for "thread priority queues".
91 *
92 * One is a "dumb" list implementation appropriate for systems with
93 * small numbers of threads and sensitive to code size. It is stored
94 * in sorted order, taking an O(N) cost every time a thread is added
95 * to the list. This corresponds to the way the original _wait_q_t
96 * abstraction worked and is very fast as long as the number of
97 * threads is small.
98 *
99 * The other is a balanced tree "fast" implementation with rather
100 * larger code size (due to the data structure itself, the code here
101 * is just stubs) and higher constant-factor performance overhead, but
102 * much better O(logN) scaling in the presence of large number of
103 * threads.
104 *
105 * Each can be used for either the wait_q or system ready queue,
106 * configurable at build time.
107 */
108
109struct _priq_rb {
110 struct rbtree tree;
111 int next_order_key;
112};
113
114
115/* Traditional/textbook "multi-queue" structure. Separate lists for a
116 * small number (max 32 here) of fixed priorities. This corresponds
117 * to the original Zephyr scheduler. RAM requirements are
118 * comparatively high, but performance is very fast. Won't work with
119 * features like deadline scheduling which need large priority spaces
120 * to represent their requirements.
121 */
122struct _priq_mq {
124 unsigned long bitmask[PRIQ_BITMAP_SIZE];
125#ifndef CONFIG_SMP
126 unsigned int cached_queue_index;
127#endif
128};
129
130struct _ready_q {
131#ifndef CONFIG_SMP
132 /* always contains next thread to run: cannot be NULL */
133 struct k_thread *cache;
134#endif
135
136#if defined(CONFIG_SCHED_SIMPLE)
137 sys_dlist_t runq;
138#elif defined(CONFIG_SCHED_SCALABLE)
139 struct _priq_rb runq;
140#elif defined(CONFIG_SCHED_MULTIQ)
141 struct _priq_mq runq;
142#endif
143};
144
145typedef struct _ready_q _ready_q_t;
146
147struct _cpu {
148 /* nested interrupt count */
149 uint32_t nested;
150
151 /* interrupt stack pointer base */
152 char *irq_stack;
153
154 /* currently scheduled thread */
155 struct k_thread *current;
156
157 /* one assigned idle thread per CPU */
158 struct k_thread *idle_thread;
159
160#ifdef CONFIG_SCHED_CPU_MASK_PIN_ONLY
161 struct _ready_q ready_q;
162#endif
163
164#if (CONFIG_NUM_METAIRQ_PRIORITIES > 0) && \
165 (CONFIG_NUM_COOP_PRIORITIES > CONFIG_NUM_METAIRQ_PRIORITIES)
166 /* Coop thread preempted by current metairq, or NULL */
167 struct k_thread *metairq_preempted;
168#endif
169
170 uint8_t id;
171
172#if defined(CONFIG_FPU_SHARING)
173 void *fp_ctx;
174#endif
175
176#ifdef CONFIG_SMP
177 /* True when _current is allowed to context switch */
178 uint8_t swap_ok;
179#endif
180
181#ifdef CONFIG_SCHED_THREAD_USAGE
182 /*
183 * [usage0] is used as a timestamp to mark the beginning of an
184 * execution window. [0] is a special value indicating that it
185 * has been stopped (but not disabled).
186 */
187
188 uint32_t usage0;
189
190#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
191 struct k_cycle_stats *usage;
192#endif
193#endif
194
195#ifdef CONFIG_OBJ_CORE_SYSTEM
196 struct k_obj_core obj_core;
197#endif
198
199#ifdef CONFIG_SCHED_IPI_SUPPORTED
200 sys_dlist_t ipi_workq;
201#endif
202
203 /* Per CPU architecture specifics */
204 struct _cpu_arch arch;
205};
206
207typedef struct _cpu _cpu_t;
208
209struct z_kernel {
210 struct _cpu cpus[CONFIG_MP_MAX_NUM_CPUS];
211
212#ifdef CONFIG_PM
213 int32_t idle; /* Number of ticks for kernel idling */
214#endif
215
216 /*
217 * ready queue: can be big, keep after small fields, since some
218 * assembly (e.g. ARC) are limited in the encoding of the offset
219 */
220#ifndef CONFIG_SCHED_CPU_MASK_PIN_ONLY
221 struct _ready_q ready_q;
222#endif
223
224#if defined(CONFIG_THREAD_MONITOR)
225 struct k_thread *threads; /* singly linked list of ALL threads */
226#endif
227#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
228 struct k_cycle_stats usage[CONFIG_MP_MAX_NUM_CPUS];
229#endif
230
231#ifdef CONFIG_OBJ_CORE_SYSTEM
232 struct k_obj_core obj_core;
233#endif
234
235#if defined(CONFIG_SMP) && defined(CONFIG_SCHED_IPI_SUPPORTED)
236 /* Identify CPUs to send IPIs to at the next scheduling point */
237 atomic_t pending_ipi;
238#endif
239};
240
241typedef struct z_kernel _kernel_t;
242
243extern struct z_kernel _kernel;
244
245extern atomic_t _cpus_active;
246
247#ifdef CONFIG_SMP
248
249/* True if the current context can be preempted and migrated to
250 * another SMP CPU.
251 */
252bool z_smp_cpu_mobile(void);
253#define _current_cpu ({ __ASSERT_NO_MSG(!z_smp_cpu_mobile()); \
254 arch_curr_cpu(); })
255
256__attribute_const__ struct k_thread *z_smp_current_get(void);
257#define _current z_smp_current_get()
258
259#else
260#define _current_cpu (&_kernel.cpus[0])
261#define _current _kernel.cpus[0].current
262#endif
263
264#define CPU_ID ((CONFIG_MP_MAX_NUM_CPUS == 1) ? 0 : _current_cpu->id)
265
266/* This is always invoked from a context where preemption is disabled */
267#define z_current_thread_set(thread) ({ _current_cpu->current = (thread); })
268
269#ifdef CONFIG_ARCH_HAS_CUSTOM_CURRENT_IMPL
270#undef _current
271#define _current arch_current_thread()
272#undef z_current_thread_set
273#define z_current_thread_set(thread) \
274 arch_current_thread_set(({ _current_cpu->current = (thread); }))
275#endif
276
277/* kernel wait queue record */
278#ifdef CONFIG_WAITQ_SCALABLE
279
280typedef struct {
281 struct _priq_rb waitq;
282} _wait_q_t;
283
284/* defined in kernel/priority_queues.c */
285bool z_priq_rb_lessthan(struct rbnode *a, struct rbnode *b);
286
287#define Z_WAIT_Q_INIT(wait_q) { { { .lessthan_fn = z_priq_rb_lessthan } } }
288
289#else
290
291typedef struct {
292 sys_dlist_t waitq;
293} _wait_q_t;
294
295#define Z_WAIT_Q_INIT(wait_q) { SYS_DLIST_STATIC_INIT(&(wait_q)->waitq) }
296
297#endif /* CONFIG_WAITQ_SCALABLE */
298
299/* kernel timeout record */
300struct _timeout;
301typedef void (*_timeout_func_t)(struct _timeout *t);
302
303struct _timeout {
304 sys_dnode_t node;
305 _timeout_func_t fn;
306#ifdef CONFIG_TIMEOUT_64BIT
307 /* Can't use k_ticks_t for header dependency reasons */
308 int64_t dticks;
309#else
310 int32_t dticks;
311#endif
312};
313
314typedef void (*k_thread_timeslice_fn_t)(struct k_thread *thread, void *data);
315
316#ifdef __cplusplus
317}
318#endif
319
320#endif /* _ASMLANGUAGE */
321
322#endif /* ZEPHYR_KERNEL_INCLUDE_KERNEL_STRUCTS_H_ */
long atomic_t
Definition atomic_types.h:15
struct _dnode sys_dnode_t
Doubly-linked list node structure.
Definition dlist.h:54
struct _dnode sys_dlist_t
Doubly-linked list structure.
Definition dlist.h:50
#define PRIQ_BITMAP_SIZE
Definition kernel_structs.h:36
void(* k_thread_timeslice_fn_t)(struct k_thread *thread, void *data)
Definition kernel_structs.h:314
#define K_NUM_THREAD_PRIO
Definition kernel_structs.h:35
__UINT32_TYPE__ uint32_t
Definition stdint.h:90
__INT32_TYPE__ int32_t
Definition stdint.h:74
__UINT8_TYPE__ uint8_t
Definition stdint.h:88
__INT64_TYPE__ int64_t
Definition stdint.h:75
Structure used to track internal statistics about both thread and CPU usage.
Definition stats.h:18
Object core structure.
Definition obj_core.h:121
Thread Structure.
Definition thread.h:262
Balanced red/black tree node structure.
Definition rb.h:58
Balanced red/black tree structure.
Definition rb.h:91
Misc utilities.