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.
 */
 
#ifndef THREAD_H
#define THREAD_H
 
#include "clist.h"
#include "cib.h"
#include "msg.h"
#include "cpu_conf.h"
#include "sched.h"
 
#ifdef MODULE_CORE_THREAD_FLAGS
#include "thread_flags.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#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
 
    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) || defined(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
#ifdef HAVE_THREAD_ARCH_T
    thread_arch_t arch;             
#endif
};
 
#ifndef THREAD_STACKSIZE_DEFAULT
#error THREAD_STACKSIZE_DEFAULT must be defined per CPU
#endif
#ifdef DOXYGEN
#define THREAD_STACKSIZE_DEFAULT
#endif
 
#ifndef THREAD_STACKSIZE_IDLE
#error THREAD_STACKSIZE_IDLE must be defined per CPU
#endif
#ifdef DOXYGEN
#define THREAD_STACKSIZE_IDLE
#endif
 
#ifndef THREAD_EXTRA_STACKSIZE_PRINTF
#error THREAD_EXTRA_STACKSIZE_PRINTF must be defined per CPU
#endif
#ifdef DOXYGEN
#define THREAD_EXTRA_STACKSIZE_PRINTF
#endif
 
#ifndef THREAD_STACKSIZE_MAIN
#define THREAD_STACKSIZE_MAIN      (THREAD_STACKSIZE_DEFAULT + \
                                    THREAD_EXTRA_STACKSIZE_PRINTF)
#endif
 
#ifndef THREAD_STACKSIZE_LARGE
#define THREAD_STACKSIZE_LARGE (THREAD_STACKSIZE_MEDIUM * 2)
#endif
 
#ifndef THREAD_STACKSIZE_MEDIUM
#define THREAD_STACKSIZE_MEDIUM THREAD_STACKSIZE_DEFAULT
#endif
 
#ifndef THREAD_STACKSIZE_SMALL
#define THREAD_STACKSIZE_SMALL (THREAD_STACKSIZE_MEDIUM / 2)
#endif
 
#ifndef THREAD_STACKSIZE_TINY
#define THREAD_STACKSIZE_TINY (THREAD_STACKSIZE_MEDIUM / 4)
#endif
 
#ifndef THREAD_STACKSIZE_MINIMUM
#define THREAD_STACKSIZE_MINIMUM  (sizeof(thread_t))
#endif
 
#define THREAD_PRIORITY_MIN            (SCHED_PRIO_LEVELS - 1)
 
#define THREAD_PRIORITY_IDLE           (THREAD_PRIORITY_MIN)
 
#ifndef THREAD_PRIORITY_MAIN
#define THREAD_PRIORITY_MAIN           (THREAD_PRIORITY_MIN - \
                                        (SCHED_PRIO_LEVELS / 2))
#endif
 
#define THREAD_CREATE_SLEEPING          (1)
 
#define THREAD_AUTO_FREE                (2)
 
#define THREAD_CREATE_WOUT_YIELD        (4)
 
#define THREAD_CREATE_STACKTEST         (8)
 
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);
 
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);
 
void thread_yield(void);
 
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);
 
const char *thread_getname(kernel_pid_t pid);
 
#ifdef DEVELHELP
 
uintptr_t thread_measure_stack_free(const char *stack);
#endif /* DEVELHELP */
 
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 int thread_has_msg_queue(const volatile struct _thread *thread)
{
#if defined(MODULE_CORE_MSG) || defined(DOXYGEN)
    return (thread->msg_array != NULL);
#else
    (void)thread;
    return 0;
#endif
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* THREAD_H */