thread.h

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once
 
#include <stdbool.h>
 
#include "cib.h"
#include "clist.h"
#include "compiler_hints.h"
#include "msg.h"
#include "sched.h"
#include "thread_config.h"
 
#ifdef MODULE_CORE_THREAD_FLAGS
#include "thread_flags.h"
#endif
 
#include "thread_arch.h" /* IWYU pragma: export */
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifdef THREAD_API_INLINED
#define THREAD_MAYBE_INLINE static inline __attribute__((always_inline))
#else
#define THREAD_MAYBE_INLINE
#endif /* THREAD_API_INLINED */
 
#if defined(DEVELHELP) && !defined(CONFIG_THREAD_NAMES)
#define CONFIG_THREAD_NAMES
#endif
 
typedef void *(*thread_task_func_t)(void *arg);
 
struct _thread {
    char *sp;                       
    thread_status_t status;         
    uint8_t priority;               
    kernel_pid_t pid;               
#if defined(MODULE_CORE_THREAD_FLAGS) || defined(DOXYGEN)
    thread_flags_t flags;           
#endif
    void *exit_val;
 
    clist_node_t rq_entry;          
#if defined(MODULE_CORE_MSG) || defined(MODULE_CORE_THREAD_FLAGS) \
    || defined(MODULE_CORE_MBOX) || defined(DOXYGEN)
    void *wait_data;                
#endif
#if defined(MODULE_CORE_MSG) || defined(DOXYGEN)
    list_node_t msg_waiters;        
    cib_t msg_queue;                
    msg_t *msg_array;               
#endif
#if defined(DEVELHELP) || IS_ACTIVE(SCHED_TEST_STACK) \
    || defined(MODULE_MPU_STACK_GUARD) || defined(DOXYGEN)
    char *stack_start;              
#endif
#if defined(CONFIG_THREAD_NAMES) || defined(DOXYGEN)
    const char *name;               
#endif
#if defined(DEVELHELP) || defined(DOXYGEN)
    int stack_size;                 
#endif
/* enable TLS only when Picolibc is compiled with TLS enabled */
#ifdef PICOLIBC_TLS
    void *tls;                      
#endif
};
 
#define THREAD_CREATE_SLEEPING          (1)
 
#define THREAD_AUTO_FREE                (2)
 
#define THREAD_CREATE_WOUT_YIELD        (4)
 
#define THREAD_CREATE_NO_STACKTEST      (8)
 
#define THREAD_CREATE_JOINABLE          (16)
 
#define THREAD_CREATE_STACKTEST         (0)
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);
 
int thread_join(kernel_pid_t pid, void **exit_value);
 
static inline thread_t *thread_get_unchecked(kernel_pid_t pid)
{
    return (thread_t *)sched_threads[pid];
}
 
static inline thread_t *thread_get(kernel_pid_t pid)
{
    if (pid_is_valid(pid)) {
        return thread_get_unchecked(pid);
    }
    return NULL;
}
 
thread_status_t thread_getstatus(kernel_pid_t pid);
 
void thread_sleep(void);
 
#if defined(MODULE_CORE_THREAD) || DOXYGEN
void thread_yield(void);
#else
static inline void thread_yield(void)
{
    /* NO-OP */
}
#endif
 
THREAD_MAYBE_INLINE void thread_yield_higher(void);
 
void thread_zombify(void);
 
int thread_kill_zombie(kernel_pid_t pid);
 
int thread_wakeup(kernel_pid_t pid);
 
static inline kernel_pid_t thread_getpid(void)
{
    extern volatile kernel_pid_t sched_active_pid;
 
    return sched_active_pid;
}
 
static inline thread_t *thread_get_active(void)
{
    extern volatile thread_t *sched_active_thread;
 
    return (thread_t *)sched_active_thread;
}
 
char *thread_stack_init(thread_task_func_t task_func, void *arg,
                        void *stack_start, int stack_size);
 
void thread_add_to_list(list_node_t *list, thread_t *thread);
 
#if defined(MODULE_CORE_THREAD) || DOXYGEN
const char *thread_getname(kernel_pid_t pid);
#else
static inline const char *thread_getname(kernel_pid_t pid)
{
    (void)pid;
    return "(none)";
}
#endif
 
uintptr_t measure_stack_free_internal(const char *stack, size_t size);
 
int thread_isr_stack_usage(void);
 
void *thread_isr_stack_pointer(void);
 
void *thread_isr_stack_start(void);
 
void thread_stack_print(void);
 
void thread_print_stack(void);
 
static inline bool thread_has_msg_queue(const thread_t *thread)
{
    assume(thread != NULL);
#if defined(MODULE_CORE_MSG) || defined(DOXYGEN)
    return (thread->msg_array != NULL);
#else
    (void)thread;
    return 0;
#endif
}
 
static inline thread_status_t thread_get_status(const thread_t *thread)
{
    return thread->status;
}
 
static inline uint8_t thread_get_priority(const thread_t *thread)
{
    return thread->priority;
}
 
static inline bool thread_is_active(const thread_t *thread)
{
    return thread->status >= STATUS_ON_RUNQUEUE;
}
 
const char *thread_state_to_string(thread_status_t state);
 
static inline void *thread_get_stackstart(const thread_t *thread)
{
#if defined(DEVELHELP) || IS_ACTIVE(SCHED_TEST_STACK) \
    || defined(MODULE_MPU_STACK_GUARD)
    return thread->stack_start;
#else
    (void)thread;
    return NULL;
#endif
}
 
static inline void *thread_get_sp(const thread_t *thread)
{
    return thread->sp;
}
 
static inline size_t thread_get_stacksize(const thread_t *thread)
{
#if defined(DEVELHELP)
    return thread->stack_size;
#else
    (void)thread;
    return 0;
#endif
}
 
static inline kernel_pid_t thread_getpid_of(const thread_t *thread)
{
    return thread->pid;
}
 
static inline const char *thread_get_name(const thread_t *thread)
{
#if defined(CONFIG_THREAD_NAMES)
    return thread->name;
#else
    (void)thread;
    return NULL;
#endif
}
 
static inline uintptr_t thread_measure_stack_free(const thread_t *thread)
{
    /* explicitly casting void pointers is bad code style, but needed for C++
     * compatibility */
    return measure_stack_free_internal((const char *)thread_get_stackstart(thread),
                                       thread_get_stacksize(thread));
}
 
#ifdef __cplusplus
}
#endif