All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Loading...
Searching...
No Matches
thread.h
Go to the documentation of this file.
1/*
2 * Copyright (C) 2014 Freie Universität Berlin
3 *
4 * This file is subject to the terms and conditions of the GNU Lesser
5 * General Public License v2.1. See the file LICENSE in the top level
6 * directory for more details.
7 */
8
9#pragma once
10
121#include <stdbool.h>
122
123#include "cib.h"
124#include "clist.h"
125#include "compiler_hints.h"
126#include "msg.h"
127#include "sched.h"
128#include "thread_config.h"
129
130#ifdef MODULE_CORE_THREAD_FLAGS
131#include "thread_flags.h"
132#endif
133
134#include "thread_arch.h" /* IWYU pragma: export */
135
136#ifdef __cplusplus
137extern "C" {
138#endif
139
146#ifdef THREAD_API_INLINED
147#define THREAD_MAYBE_INLINE static inline __attribute__((always_inline))
148#else
149#define THREAD_MAYBE_INLINE
150#endif /* THREAD_API_INLINED */
151
152#if defined(DEVELHELP) && !defined(CONFIG_THREAD_NAMES)
159#define CONFIG_THREAD_NAMES
160#endif
161
165typedef void *(*thread_task_func_t)(void *arg);
166
170struct _thread {
171 char *sp;
173 uint8_t priority;
177#if defined(MODULE_CORE_THREAD_FLAGS) || defined(DOXYGEN)
179#endif
180
183#if defined(MODULE_CORE_MSG) || defined(MODULE_CORE_THREAD_FLAGS) \
184 || defined(MODULE_CORE_MBOX) || defined(DOXYGEN)
185 void *wait_data;
187#endif
188#if defined(MODULE_CORE_MSG) || defined(DOXYGEN)
196#endif
197#if defined(DEVELHELP) || IS_ACTIVE(SCHED_TEST_STACK) \
198 || defined(MODULE_MPU_STACK_GUARD) || defined(DOXYGEN)
200#endif
201#if defined(CONFIG_THREAD_NAMES) || defined(DOXYGEN)
202 const char *name;
203#endif
204#if defined(DEVELHELP) || defined(DOXYGEN)
206#endif
207/* enable TLS only when Picolibc is compiled with TLS enabled */
208#ifdef PICOLIBC_TLS
209 void *tls;
210#endif
211};
212
220#define THREAD_CREATE_SLEEPING (1)
221
225#define THREAD_AUTO_FREE (2)
226
233#define THREAD_CREATE_WOUT_YIELD (4)
234
240#define THREAD_CREATE_NO_STACKTEST (8)
241
249#define THREAD_CREATE_STACKTEST (0)
277 int stacksize,
278 uint8_t priority,
279 int flags,
280 thread_task_func_t task_func,
281 void *arg,
282 const char *name);
283
292{
293 return (thread_t *)sched_threads[pid];
294}
295
304{
305 if (pid_is_valid(pid)) {
306 return thread_get_unchecked(pid);
307 }
308 return NULL;
309}
310
320
324void thread_sleep(void);
325
337#if defined(MODULE_CORE_THREAD) || DOXYGEN
338void thread_yield(void);
339#else
340static inline void thread_yield(void)
341{
342 /* NO-OP */
343}
344#endif
345
359
369void thread_zombify(void);
370
380
390
396static inline kernel_pid_t thread_getpid(void)
397{
398 extern volatile kernel_pid_t sched_active_pid;
399
400 return sched_active_pid;
401}
402
410static inline thread_t *thread_get_active(void)
411{
412 extern volatile thread_t *sched_active_thread;
413
414 return (thread_t *)sched_active_thread;
415}
416
427char *thread_stack_init(thread_task_func_t task_func, void *arg,
428 void *stack_start, int stack_size);
429
444
455#if defined(MODULE_CORE_THREAD) || DOXYGEN
457#else
458static inline const char *thread_getname(kernel_pid_t pid)
459{
460 (void)pid;
461 return "(none)";
462}
463#endif
464
480uintptr_t measure_stack_free_internal(const char *stack, size_t size);
481
486
491
496
501
506
520static inline bool thread_has_msg_queue(const thread_t *thread)
521{
522 assume(thread != NULL);
523#if defined(MODULE_CORE_MSG) || defined(DOXYGEN)
524 return (thread->msg_array != NULL);
525#else
526 (void)thread;
527 return 0;
528#endif
529}
530
537static inline thread_status_t thread_get_status(const thread_t *thread)
538{
539 return thread->status;
540}
541
548static inline uint8_t thread_get_priority(const thread_t *thread)
549{
550 return thread->priority;
551}
552
559static inline bool thread_is_active(const thread_t *thread)
560{
561 return thread->status >= STATUS_ON_RUNQUEUE;
562}
563
571
578static inline void *thread_get_stackstart(const thread_t *thread)
579{
580#if defined(DEVELHELP) || IS_ACTIVE(SCHED_TEST_STACK) \
581 || defined(MODULE_MPU_STACK_GUARD)
582 return thread->stack_start;
583#else
584 (void)thread;
585 return NULL;
586#endif
587}
588
597static inline void *thread_get_sp(const thread_t *thread)
598{
599 return thread->sp;
600}
601
608static inline size_t thread_get_stacksize(const thread_t *thread)
609{
610#if defined(DEVELHELP)
611 return thread->stack_size;
612#else
613 (void)thread;
614 return 0;
615#endif
616}
617
626static inline kernel_pid_t thread_getpid_of(const thread_t *thread)
627{
628 return thread->pid;
629}
630
637static inline const char *thread_get_name(const thread_t *thread)
638{
639#if defined(CONFIG_THREAD_NAMES)
640 return thread->name;
641#else
642 (void)thread;
643 return NULL;
644#endif
645}
646
657static inline uintptr_t thread_measure_stack_free(const thread_t *thread)
658{
659 /* explicitly casting void pointers is bad code style, but needed for C++
660 * compatibility */
661 return measure_stack_free_internal((const char *)thread_get_stackstart(thread),
662 thread_get_stacksize(thread));
663}
664
665#ifdef __cplusplus
666}
667#endif
668
Circular integer buffer interface.
Circular linked list.
Common macros and compiler attributes/pragmas configuration.
#define assume(cond)
Behaves like an assert(), but tells the compiler that cond can never be false.
Messaging API for inter process communication.
static int pid_is_valid(kernel_pid_t pid)
Determine if the given pid is valid.
Definition sched.h:147
int16_t kernel_pid_t
Unique process identifier.
Definition sched.h:138
volatile thread_t * sched_threads[KERNEL_PID_LAST+1]
Thread table.
thread_status_t
Definition sched.h:162
#define STATUS_ON_RUNQUEUE
to check if on run queue: st >= STATUS_ON_RUNQUEUE
Definition sched.h:184
uint16_t thread_flags_t
Type definition of thread_flags_t.
void thread_stack_print(void)
Print the current stack to stdout.
uintptr_t measure_stack_free_internal(const char *stack, size_t size)
Measures the stack usage of a stack.
thread_status_t thread_getstatus(kernel_pid_t pid)
Returns the status of a process.
const char * thread_state_to_string(thread_status_t state)
Convert a thread state code to a human readable string.
static uint8_t thread_get_priority(const thread_t *thread)
Get a thread's priority.
Definition thread.h:548
static size_t thread_get_stacksize(const thread_t *thread)
Get size of a thread's stack.
Definition thread.h:608
void *(* thread_task_func_t)(void *arg)
Prototype for a thread entry function.
Definition thread.h:165
static const char * thread_get_name(const thread_t *thread)
Get name of thread.
Definition thread.h:637
static thread_t * thread_get_active(void)
Returns a pointer to the Thread Control Block of the currently running thread.
Definition thread.h:410
void thread_add_to_list(list_node_t *list, thread_t *thread)
Add thread to list, sorted by priority (internal)
static uintptr_t thread_measure_stack_free(const thread_t *thread)
Measures the stack usage of a stack.
Definition thread.h:657
void thread_zombify(void)
Puts the current thread into zombie state.
kernel_pid_t thread_create(char *stack, int stacksize, uint8_t priority, int flags, thread_task_func_t task_func, void *arg, const char *name)
Creates a new thread.
THREAD_MAYBE_INLINE void thread_yield_higher(void)
Lets current thread yield in favor of a higher prioritized thread.
void * thread_isr_stack_pointer(void)
Get the current ISR stack pointer.
int thread_kill_zombie(kernel_pid_t pid)
Terminates zombie thread.
void thread_sleep(void)
Puts the current thread into sleep mode.
static void * thread_get_stackstart(const thread_t *thread)
Get start address (lowest) of a thread's stack.
Definition thread.h:578
static thread_t * thread_get_unchecked(kernel_pid_t pid)
Retrieve a thread control block by PID.
Definition thread.h:291
const char * thread_getname(kernel_pid_t pid)
Returns the name of a process.
void thread_yield(void)
Lets current thread yield.
int thread_wakeup(kernel_pid_t pid)
Wakes up a sleeping thread.
static kernel_pid_t thread_getpid(void)
Returns the process ID of the currently running thread.
Definition thread.h:396
char * thread_stack_init(thread_task_func_t task_func, void *arg, void *stack_start, int stack_size)
Gets called upon thread creation to set CPU registers.
static bool thread_is_active(const thread_t *thread)
Returns if a thread is active (currently running or waiting to be scheduled)
Definition thread.h:559
int thread_isr_stack_usage(void)
Get the number of bytes used on the ISR stack.
static thread_status_t thread_get_status(const thread_t *thread)
Get a thread's status.
Definition thread.h:537
static thread_t * thread_get(kernel_pid_t pid)
Retrieve a thread control block by PID.
Definition thread.h:303
static void * thread_get_sp(const thread_t *thread)
Get stored Stack Pointer of thread.
Definition thread.h:597
void thread_print_stack(void)
Prints human readable, ps-like thread information for debugging purposes.
void * thread_isr_stack_start(void)
Get the start of the ISR stack.
#define THREAD_MAYBE_INLINE
Macro definition to inline some of the platform specific implementations.
Definition thread.h:149
static bool thread_has_msg_queue(const thread_t *thread)
Checks if a thread has an initialized message queue.
Definition thread.h:520
static kernel_pid_t thread_getpid_of(const thread_t *thread)
Get PID of thread.
Definition thread.h:626
Scheduler API definition.
thread_t holds thread's context data.
Definition thread.h:170
char * sp
thread's stack pointer
Definition thread.h:171
char * stack_start
thread's stack start address
Definition thread.h:199
cib_t msg_queue
index of this [thread's message queue] (thread_t::msg_array), if any
Definition thread.h:192
thread_flags_t flags
currently set flags
Definition thread.h:178
list_node_t msg_waiters
threads waiting for their message to be delivered to this thread (i.e.
Definition thread.h:189
thread_status_t status
thread's status
Definition thread.h:172
msg_t * msg_array
memory holding messages sent to this thread's message queue
Definition thread.h:194
uint8_t priority
thread's priority
Definition thread.h:173
int stack_size
thread's stack size
Definition thread.h:205
const char * name
thread's name
Definition thread.h:202
clist_node_t rq_entry
run queue entry
Definition thread.h:181
void * wait_data
used by msg, mbox and thread flags
Definition thread.h:185
kernel_pid_t pid
thread's process id
Definition thread.h:175
circular integer buffer structure
Definition cib.h:44
List node structure.
Definition list.h:39
Describes a message object which can be sent between threads.
Definition msg.h:195
Thread configuration defines.
Thread Flags API.