rtdef.h

浏览该文件的文档.

/*
 * Copyright (c) 2006-2024, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2007-01-10     Bernard      the first version
 * 2008-07-12     Bernard      remove all rt_int8, rt_uint32_t etc typedef
 * 2010-10-26     yi.qiu       add module support
 * 2010-11-10     Bernard      add cleanup callback function in thread exit.
 * 2011-05-09     Bernard      use builtin va_arg in GCC 4.x
 * 2012-11-16     Bernard      change RT_NULL from ((void*)0) to 0.
 * 2012-12-29     Bernard      change the RT_USING_MEMPOOL location and add
 *                             RT_USING_MEMHEAP condition.
 * 2012-12-30     Bernard      add more control command for graphic.
 * 2013-01-09     Bernard      change version number.
 * 2015-02-01     Bernard      change version number to v2.1.0
 * 2017-08-31     Bernard      change version number to v3.0.0
 * 2017-11-30     Bernard      change version number to v3.0.1
 * 2017-12-27     Bernard      change version number to v3.0.2
 * 2018-02-24     Bernard      change version number to v3.0.3
 * 2018-04-25     Bernard      change version number to v3.0.4
 * 2018-05-31     Bernard      change version number to v3.1.0
 * 2018-09-04     Bernard      change version number to v3.1.1
 * 2018-09-14     Bernard      apply Apache License v2.0 to RT-Thread Kernel
 * 2018-10-13     Bernard      change version number to v4.0.0
 * 2018-10-02     Bernard      add 64bit arch support
 * 2018-11-22     Jesven       add smp member to struct rt_thread
 *                             add struct rt_cpu
 *                             add smp relevant macros
 * 2019-01-27     Bernard      change version number to v4.0.1
 * 2019-05-17     Bernard      change version number to v4.0.2
 * 2019-12-20     Bernard      change version number to v4.0.3
 * 2020-08-10     Meco Man     add macro for struct rt_device_ops
 * 2020-10-23     Meco Man     define maximum value of ipc type
 * 2021-03-19     Meco Man     add security devices
 * 2021-05-10     armink       change version number to v4.0.4
 * 2021-11-19     Meco Man     change version number to v4.1.0
 * 2021-12-21     Meco Man     re-implement RT_UNUSED
 * 2022-01-01     Gabriel      improve hooking method
 * 2022-01-07     Gabriel      move some __on_rt_xxxxx_hook to dedicated c source files
 * 2022-01-12     Meco Man     remove RT_THREAD_BLOCK
 * 2022-04-20     Meco Man     change version number to v4.1.1
 * 2022-04-21     THEWON       add macro RT_VERSION_CHECK
 * 2022-06-29     Meco Man     add RT_USING_LIBC and standard libc headers
 * 2022-08-16     Meco Man     change version number to v5.0.0
 * 2022-09-12     Meco Man     define rt_ssize_t
 * 2022-12-20     Meco Man     add const name for rt_object
 * 2023-04-01     Chushicheng  change version number to v5.0.1
 * 2023-05-20     Bernard      add stdc atomic detection.
 * 2023-09-15     xqyjlj       perf rt_hw_interrupt_disable/enable
 * 2023-10-10     Chushicheng  change version number to v5.1.0
 * 2023-10-11     zmshahaha    move specific devices related and driver to components/drivers
 * 2023-11-21     Meco Man     add RT_USING_NANO macro
 * 2023-11-17     xqyjlj       add process group and session support
 * 2023-12-01     Shell        Support of dynamic device
 * 2023-12-18     xqyjlj       add rt_always_inline
 * 2023-12-22     Shell        Support hook list
 * 2024-01-18     Shell        Seperate basical types to a rttypes.h
 *                             Seperate the compiler portings to rtcompiler.h
 * 2024-03-30     Meco Man     update version number to v5.2.0
 */
 
#ifndef __RT_DEF_H__
#define __RT_DEF_H__
 
#include "rtsched.h"
#include "rttypes.h"
 
#include "klibc/kerrno.h"
 
#ifdef __cplusplus
extern "C" {
#endif


 
/* RT-Thread version information */
#define RT_VERSION_MAJOR                5               
#define RT_VERSION_MINOR                2               
#define RT_VERSION_PATCH                0               
 
/* e.g. #if (RTTHREAD_VERSION >= RT_VERSION_CHECK(4, 1, 0) */
#define RT_VERSION_CHECK(major, minor, revise)          ((major * 10000U) + (minor * 100U) + revise)
 
/* RT-Thread version */
#define RTTHREAD_VERSION                RT_VERSION_CHECK(RT_VERSION_MAJOR, RT_VERSION_MINOR, RT_VERSION_PATCH)

 
/* maximum value of base type */
#ifdef RT_USING_LIBC
#define RT_UINT8_MAX                    UINT8_MAX       
#define RT_UINT16_MAX                   UINT16_MAX      
#define RT_UINT32_MAX                   UINT32_MAX      
#define RT_UINT64_MAX                   UINT64_MAX      
#else
#define RT_UINT8_MAX                    0xFFU                 
#define RT_UINT16_MAX                   0xFFFFU               
#define RT_UINT32_MAX                   0xFFFFFFFFUL          
#define RT_UINT64_MAX                   0xFFFFFFFFFFFFFFFFULL 
#endif /* RT_USING_LIBC */
 
#define RT_TICK_MAX                     RT_UINT32_MAX   
 
/* maximum value of ipc type */
#define RT_SEM_VALUE_MAX                RT_UINT16_MAX   
#define RT_MUTEX_VALUE_MAX              RT_UINT16_MAX   
#define RT_MUTEX_HOLD_MAX               RT_UINT8_MAX    
#define RT_MB_ENTRY_MAX                 RT_UINT16_MAX   
#define RT_MQ_ENTRY_MAX                 RT_UINT16_MAX   
 
/* Common Utilities */
 
#define RT_UNUSED(x)                   ((void)(x))
 
/* compile time assertion */
#define RT_STATIC_ASSERT(name, expn) typedef char _static_assert_##name[(expn)?1:-1]
 
/* Compiler Related Definitions */
#include "rtcompiler.h"
 
/* initialization export */
#ifdef RT_USING_COMPONENTS_INIT
typedef int (*init_fn_t)(void);
#ifdef _MSC_VER
#pragma section("rti_fn$f",read)
    #ifdef RT_DEBUGING_AUTO_INIT
        struct rt_init_desc
        {
            const char* level;
            const init_fn_t fn;
            const char* fn_name;
        };
        #define INIT_EXPORT(fn, level)                                  \
                                const char __rti_level_##fn[] = ".rti_fn." level;       \
                                const char __rti_##fn##_name[] = #fn;                   \
                                __declspec(allocate("rti_fn$f"))                        \
                                rt_used const struct rt_init_desc __rt_init_msc_##fn =  \
                                {__rti_level_##fn, fn, __rti_##fn##_name};
    #else
        struct rt_init_desc
        {
            const char* level;
            const init_fn_t fn;
        };
        #define INIT_EXPORT(fn, level)                                  \
                                const char __rti_level_##fn[] = ".rti_fn." level;       \
                                __declspec(allocate("rti_fn$f"))                        \
                                rt_used const struct rt_init_desc __rt_init_msc_##fn =  \
                                {__rti_level_##fn, fn };
    #endif /* RT_DEBUGING_AUTO_INIT */
#else
    #ifdef RT_DEBUGING_AUTO_INIT
        struct rt_init_desc
        {
            const char* fn_name;
            const init_fn_t fn;
        };
        #define INIT_EXPORT(fn, level)                                                       \
            const char __rti_##fn##_name[] = #fn;                                            \
            rt_used const struct rt_init_desc __rt_init_desc_##fn rt_section(".rti_fn." level) = \
            { __rti_##fn##_name, fn};
    #else
        #define INIT_EXPORT(fn, level)                                                       \
            rt_used const init_fn_t __rt_init_##fn rt_section(".rti_fn." level) = fn
    #endif /* RT_DEBUGING_AUTO_INIT */
#endif /* _MSC_VER */
#else
#define INIT_EXPORT(fn, level)
#endif /* RT_USING_COMPONENTS_INIT */
 
/* board init routines will be called in board_init() function */
#define INIT_BOARD_EXPORT(fn)           INIT_EXPORT(fn, "1")
 
/* init cpu, memory, interrupt-controller, bus... */
#define INIT_CORE_EXPORT(fn)            INIT_EXPORT(fn, "1.0")
/* init sys-timer, clk, pinctrl... */
#define INIT_SUBSYS_EXPORT(fn)          INIT_EXPORT(fn, "1.1")
/* init platform, user code... */
#define INIT_PLATFORM_EXPORT(fn)        INIT_EXPORT(fn, "1.2")
 
/* pre/device/component/env/app init routines will be called in init_thread */
/* components pre-initialization (pure software initialization) */
#define INIT_PREV_EXPORT(fn)            INIT_EXPORT(fn, "2")
/* device initialization */
#define INIT_DEVICE_EXPORT(fn)          INIT_EXPORT(fn, "3")
/* components initialization (dfs, lwip, ...) */
#define INIT_COMPONENT_EXPORT(fn)       INIT_EXPORT(fn, "4")
/* environment initialization (mount disk, ...) */
#define INIT_ENV_EXPORT(fn)             INIT_EXPORT(fn, "5")
/* application initialization (rtgui application etc ...) */
#define INIT_APP_EXPORT(fn)             INIT_EXPORT(fn, "6")
 
/* init after mount fs */
#define INIT_FS_EXPORT(fn)              INIT_EXPORT(fn, "6.0")
/* init in secondary_cpu_c_start */
#define INIT_SECONDARY_CPU_EXPORT(fn)   INIT_EXPORT(fn, "7")
 
#if !defined(RT_USING_FINSH)
/* define these to empty, even if not include finsh.h file */
#define FINSH_FUNCTION_EXPORT(name, desc)
#define FINSH_FUNCTION_EXPORT_ALIAS(name, alias, desc)
 
#define MSH_CMD_EXPORT(command, desc)
#define MSH_CMD_EXPORT_ALIAS(command, alias, desc)
#elif !defined(FINSH_USING_SYMTAB)
#define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc)
#endif
 
/* event length */
#define RT_EVENT_LENGTH                 32
 
/* memory management option */
#define RT_MM_PAGE_SIZE                 4096
#define RT_MM_PAGE_MASK                 (RT_MM_PAGE_SIZE - 1)
#define RT_MM_PAGE_BITS                 12
 
/* kernel malloc definitions */
#ifndef RT_KERNEL_MALLOC
#define RT_KERNEL_MALLOC(sz)            rt_malloc(sz)
#endif /* RT_KERNEL_MALLOC */
 
#ifndef RT_KERNEL_FREE
#define RT_KERNEL_FREE(ptr)             rt_free(ptr)
#endif /* RT_KERNEL_FREE */
 
#ifndef RT_KERNEL_REALLOC
#define RT_KERNEL_REALLOC(ptr, size)    rt_realloc(ptr, size)
#endif /* RT_KERNEL_REALLOC */

#define RT_IS_ALIGN(addr, align) ((!(addr & (align - 1))) && (addr != RT_NULL))

#define RT_ALIGN(size, align)           (((size) + (align) - 1) & ~((align) - 1))

#define RT_ALIGN_DOWN(size, align)      ((size) & ~((align) - 1))


 
/*
 * kernel object macros
 */
#define RT_OBJECT_FLAG_MODULE           0x80            

struct rt_object
{
#if RT_NAME_MAX > 0
    char        name[RT_NAME_MAX];                       
#else
    const char *name;                                    
#endif /* RT_NAME_MAX > 0 */
    rt_uint8_t  type;                                    
    rt_uint8_t  flag;                                    
 
#ifdef RT_USING_MODULE
    void      * module_id;                               
#endif /* RT_USING_MODULE */
 
#ifdef RT_USING_SMART
    rt_atomic_t lwp_ref_count;                           
#endif /* RT_USING_SMART */
 
    rt_list_t   list;                                    
};
typedef struct rt_object *rt_object_t;                   

typedef rt_err_t (*rt_object_iter_t)(rt_object_t object, void *data);

enum rt_object_class_type
{
    RT_Object_Class_Null          = 0x00,      
    RT_Object_Class_Thread        = 0x01,      
    RT_Object_Class_Semaphore     = 0x02,      
    RT_Object_Class_Mutex         = 0x03,      
    RT_Object_Class_Event         = 0x04,      
    RT_Object_Class_MailBox       = 0x05,      
    RT_Object_Class_MessageQueue  = 0x06,      
    RT_Object_Class_MemHeap       = 0x07,      
    RT_Object_Class_MemPool       = 0x08,      
    RT_Object_Class_Device        = 0x09,      
    RT_Object_Class_Timer         = 0x0a,      
    RT_Object_Class_Module        = 0x0b,      
    RT_Object_Class_Memory        = 0x0c,      
    RT_Object_Class_Channel       = 0x0d,      
    RT_Object_Class_ProcessGroup  = 0x0e,      
    RT_Object_Class_Session       = 0x0f,      
    RT_Object_Class_Custom        = 0x10,      
    RT_Object_Class_Unknown       = 0x11,      
    RT_Object_Class_Static        = 0x80       
};

struct rt_object_information
{
    enum rt_object_class_type type;                     
    rt_list_t                 object_list;              
    rt_size_t                 object_size;              
    struct rt_spinlock        spinlock;
};

#ifndef RT_USING_HOOK
#define RT_OBJECT_HOOK_CALL(func, argv)
 
#else

#define _RT_OBJECT_HOOK_CALL(func, argv) __ON_HOOK_ARGS(func, argv)
#define RT_OBJECT_HOOK_CALL(func, argv)  _RT_OBJECT_HOOK_CALL(func, argv)
 
    #ifdef RT_HOOK_USING_FUNC_PTR
        #define __ON_HOOK_ARGS(__hook, argv)        do {if ((__hook) != RT_NULL) __hook argv; } while (0)
    #else
        #define __ON_HOOK_ARGS(__hook, argv)
    #endif /* RT_HOOK_USING_FUNC_PTR */
#endif /* RT_USING_HOOK */
 
#ifdef RT_USING_HOOKLIST

#define RT_OBJECT_HOOKLIST_DECLARE(handler_type, name) \
    typedef struct name##_hooklistnode                 \
    {                                                  \
        handler_type handler;                          \
        rt_list_t list_node;                           \
    } *name##_hooklistnode_t;                          \
    extern volatile rt_ubase_t name##_nested;          \
    void name##_sethook(name##_hooklistnode_t node);   \
    void name##_rmhook(name##_hooklistnode_t node)

#define RT_OBJECT_HOOKLIST_DEFINE_NODE(hookname, nodename, hooker_handler) \
    struct hookname##_hooklistnode nodename = {                            \
        .handler = hooker_handler,                                         \
        .list_node = RT_LIST_OBJECT_INIT(nodename.list_node),              \
    };

#define RT_OBJECT_HOOKLIST_DEFINE(name)                                      \
    static rt_list_t name##_hooklist = RT_LIST_OBJECT_INIT(name##_hooklist); \
    static struct rt_spinlock name##lock = RT_SPINLOCK_INIT;                 \
    volatile rt_ubase_t name##_nested = 0;                                   \
    void name##_sethook(name##_hooklistnode_t node)                          \
    {                                                                        \
        rt_ubase_t level = rt_spin_lock_irqsave(&name##lock);                \
        while (name##_nested)                                                \
        {                                                                    \
            rt_spin_unlock_irqrestore(&name##lock, level);                   \
            level = rt_spin_lock_irqsave(&name##lock);                       \
        }                                                                    \
        rt_list_insert_before(&name##_hooklist, &node->list_node);           \
        rt_spin_unlock_irqrestore(&name##lock, level);                       \
    }                                                                        \
    void name##_rmhook(name##_hooklistnode_t node)                           \
    {                                                                        \
        rt_ubase_t level = rt_spin_lock_irqsave(&name##lock);                \
        while (name##_nested)                                                \
        {                                                                    \
            rt_spin_unlock_irqrestore(&name##lock, level);                   \
            level = rt_spin_lock_irqsave(&name##lock);                       \
        }                                                                    \
        rt_list_remove(&node->list_node);                                    \
        rt_spin_unlock_irqrestore(&name##lock, level);                       \
    }

#define _RT_OBJECT_HOOKLIST_CALL(nodetype, nested, list, lock, argv)  \
    do                                                                \
    {                                                                 \
        nodetype iter, next;                                          \
        rt_ubase_t level = rt_spin_lock_irqsave(&lock);               \
        nested += 1;                                                  \
        rt_spin_unlock_irqrestore(&lock, level);                      \
        if (!rt_list_isempty(&list))                                  \
        {                                                             \
            rt_list_for_each_entry_safe(iter, next, &list, list_node) \
            {                                                         \
                iter->handler argv;                                   \
            }                                                         \
        }                                                             \
        level = rt_spin_lock_irqsave(&lock);                          \
        nested -= 1;                                                  \
        rt_spin_unlock_irqrestore(&lock, level);                      \
    } while (0)
#define RT_OBJECT_HOOKLIST_CALL(name, argv)                        \
    _RT_OBJECT_HOOKLIST_CALL(name##_hooklistnode_t, name##_nested, \
                             name##_hooklist, name##lock, argv)
 
#else
 
#define RT_OBJECT_HOOKLIST_DECLARE(handler_type, name)
#define RT_OBJECT_HOOKLIST_DEFINE_NODE(hookname, nodename, hooker_handler)
#define RT_OBJECT_HOOKLIST_DEFINE(name)
#define RT_OBJECT_HOOKLIST_CALL(name, argv)
#endif /* RT_USING_HOOKLIST */




#define RT_TIMER_FLAG_DEACTIVATED       0x0             
#define RT_TIMER_FLAG_ACTIVATED         0x1             
#define RT_TIMER_FLAG_ONE_SHOT          0x0             
#define RT_TIMER_FLAG_PERIODIC          0x2             
 
#define RT_TIMER_FLAG_HARD_TIMER        0x0             
#define RT_TIMER_FLAG_SOFT_TIMER        0x4             
#define RT_TIMER_FLAG_THREAD_TIMER \
    (0x8 | RT_TIMER_FLAG_HARD_TIMER)                    
 
#define RT_TIMER_CTRL_SET_TIME          0x0             
#define RT_TIMER_CTRL_GET_TIME          0x1             
#define RT_TIMER_CTRL_SET_ONESHOT       0x2             
#define RT_TIMER_CTRL_SET_PERIODIC      0x3             
#define RT_TIMER_CTRL_GET_STATE         0x4             
#define RT_TIMER_CTRL_GET_REMAIN_TIME   0x5             
#define RT_TIMER_CTRL_GET_FUNC          0x6             
#define RT_TIMER_CTRL_SET_FUNC          0x7             
#define RT_TIMER_CTRL_GET_PARM          0x8             
#define RT_TIMER_CTRL_SET_PARM          0x9             
 
#ifndef RT_TIMER_SKIP_LIST_LEVEL
#define RT_TIMER_SKIP_LIST_LEVEL          1
#endif
 
/* 1 or 3 */
#ifndef RT_TIMER_SKIP_LIST_MASK
#define RT_TIMER_SKIP_LIST_MASK         0x3             
#endif

typedef void (*rt_timer_func_t)(void *parameter);

struct rt_timer
{
    struct rt_object parent;                            
 
    rt_list_t        row[RT_TIMER_SKIP_LIST_LEVEL];
 
    rt_timer_func_t  timeout_func;                      
    void             *parameter;                        
 
    rt_tick_t        init_tick;                         
    rt_tick_t        timeout_tick;                      
};
typedef struct rt_timer *rt_timer_t;


 
#ifdef RT_USING_SIGNALS
#define RT_SIG_MAX          32
typedef unsigned long rt_sigset_t;
typedef siginfo_t rt_siginfo_t;
typedef void (*rt_sighandler_t)(int signo);
#endif /* RT_USING_SIGNALS */


 
/*
 * Thread
 */
 
/*
 * thread state definitions
 */
#define RT_THREAD_INIT                       0x00                
#define RT_THREAD_CLOSE                      0x01                
#define RT_THREAD_READY                      0x02                
#define RT_THREAD_RUNNING                    0x03                
 
/*
 * for rt_thread_suspend_with_flag()
 */
enum
{
    RT_INTERRUPTIBLE = 0,
    RT_KILLABLE,
    RT_UNINTERRUPTIBLE,
};
 
#define RT_THREAD_SUSPEND_MASK               0x04
#define RT_SIGNAL_COMMON_WAKEUP_MASK         0x02
#define RT_SIGNAL_KILL_WAKEUP_MASK           0x01
 
#define RT_THREAD_SUSPEND_INTERRUPTIBLE      (RT_THREAD_SUSPEND_MASK)                                                             
#define RT_THREAD_SUSPEND                    RT_THREAD_SUSPEND_INTERRUPTIBLE
#define RT_THREAD_SUSPEND_KILLABLE           (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK)                              
#define RT_THREAD_SUSPEND_UNINTERRUPTIBLE    (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK | RT_SIGNAL_KILL_WAKEUP_MASK) 
#define RT_THREAD_STAT_MASK                  0x07
 
#define RT_THREAD_STAT_YIELD            0x08                
#define RT_THREAD_STAT_YIELD_MASK       RT_THREAD_STAT_YIELD
 
#define RT_THREAD_STAT_SIGNAL           0x10                
#define RT_THREAD_STAT_SIGNAL_READY     (RT_THREAD_STAT_SIGNAL | RT_THREAD_READY)
#define RT_THREAD_STAT_SIGNAL_WAIT      0x20                
#define RT_THREAD_STAT_SIGNAL_PENDING   0x40                
#define RT_THREAD_STAT_SIGNAL_MASK      0xf0

#define RT_THREAD_CTRL_STARTUP          0x00                
#define RT_THREAD_CTRL_CLOSE            0x01                
#define RT_THREAD_CTRL_CHANGE_PRIORITY  0x02                
#define RT_THREAD_CTRL_INFO             0x03                
#define RT_THREAD_CTRL_BIND_CPU         0x04                

struct rt_cpu_usage_stats
{
    rt_ubase_t user;
    rt_ubase_t system;
    rt_ubase_t irq;
    rt_ubase_t idle;
};
typedef struct rt_cpu_usage_stats *rt_cpu_usage_stats_t;
 
#ifdef RT_USING_SMP
 
#define RT_CPU_DETACHED                 RT_CPUS_NR          
#define RT_CPU_MASK                     ((1 << RT_CPUS_NR) - 1) 
 
#ifndef RT_SCHEDULE_IPI
#define RT_SCHEDULE_IPI                 0
#endif /* RT_SCHEDULE_IPI */
 
#ifndef RT_STOP_IPI
#define RT_STOP_IPI                     1
#endif /* RT_STOP_IPI */
 
#ifndef RT_SMP_CALL_IPI
#define RT_SMP_CALL_IPI                 2
#endif
 
#define RT_MAX_IPI                      3
 
#define _SCHEDULER_CONTEXT(fileds) fileds

struct rt_cpu
{
    _SCHEDULER_CONTEXT(
        struct rt_thread        *current_thread;
 
        rt_uint8_t              irq_switch_flag:1;
        rt_uint8_t              sched_lock_flag:1;
#ifndef ARCH_USING_HW_THREAD_SELF
        rt_uint8_t              critical_switch_flag:1;
#endif /* ARCH_USING_HW_THREAD_SELF */
 
        rt_uint8_t              current_priority;
        rt_list_t               priority_table[RT_THREAD_PRIORITY_MAX];
    #if RT_THREAD_PRIORITY_MAX > 32
        rt_uint32_t             priority_group;
        rt_uint8_t              ready_table[32];
    #else
        rt_uint32_t             priority_group;
    #endif /* RT_THREAD_PRIORITY_MAX > 32 */
 
        rt_atomic_t             tick;   
    );
 
    struct rt_thread            *idle_thread;
    rt_atomic_t                 irq_nest;
 
#ifdef RT_USING_SMART
    struct rt_spinlock          spinlock;
#endif /* RT_USING_SMART */
#ifdef RT_USING_CPU_USAGE_TRACER
    struct rt_cpu_usage_stats   cpu_stat;
#endif /* RT_USING_CPU_USAGE_TRACER */
#ifdef ARCH_USING_IRQ_CTX_LIST
    rt_slist_t                  irq_ctx_head;
#endif /* ARCH_USING_IRQ_CTX_LIST */
};
 
#else /* !RT_USING_SMP */
struct rt_cpu
{
    struct rt_thread            *current_thread;
    struct rt_thread            *idle_thread;
 
#ifdef RT_USING_CPU_USAGE_TRACER
    struct rt_cpu_usage_stats   cpu_stat;
#endif /* RT_USING_CPU_USAGE_TRACER */
#ifdef ARCH_USING_IRQ_CTX_LIST
    rt_slist_t                  irq_ctx_head;
#endif /* ARCH_USING_IRQ_CTX_LIST */
};
 
#endif /* RT_USING_SMP */
 
typedef struct rt_cpu *rt_cpu_t;
/* Noted: As API to reject writing to this variable from application codes */
#define rt_current_thread rt_thread_self()
 
struct rt_thread;

 
typedef struct rt_interrupt_context {
    void *context;      
    rt_slist_t node;    
} *rt_interrupt_context_t;
 
#ifdef RT_USING_SMART
typedef rt_err_t (*rt_wakeup_func_t)(void *object, struct rt_thread *thread);
 
struct rt_wakeup
{
    rt_wakeup_func_t func;
    void *user_data;
};
 
#define _LWP_NSIG       64
 
#ifdef ARCH_CPU_64BIT
#define _LWP_NSIG_BPW   64
#else
#define _LWP_NSIG_BPW   32
#endif
 
#define _LWP_NSIG_WORDS (RT_ALIGN(_LWP_NSIG, _LWP_NSIG_BPW) / _LWP_NSIG_BPW)
 
typedef void (*lwp_sighandler_t)(int);
typedef void (*lwp_sigaction_t)(int signo, siginfo_t *info, void *context);
 
typedef struct {
    unsigned long sig[_LWP_NSIG_WORDS];
} lwp_sigset_t;
 
#if _LWP_NSIG <= 64
#define lwp_sigmask(signo)      ((lwp_sigset_t){.sig = {[0] = ((long)(1u << ((signo)-1)))}})
#define lwp_sigset_init(mask)   ((lwp_sigset_t){.sig = {[0] = (long)(mask)}})
#endif /* _LWP_NSIG <= 64 */
 
struct lwp_sigaction {
    union {
        void (*_sa_handler)(int);
        void (*_sa_sigaction)(int, siginfo_t *, void *);
    } __sa_handler;
    lwp_sigset_t sa_mask;
    int sa_flags;
    void (*sa_restorer)(void);
};
 
typedef struct lwp_siginfo_ext {
    union {
        /* for SIGCHLD */
        struct {
            int status;
            clock_t utime;
            clock_t stime;
        } sigchld;
    };
} *lwp_siginfo_ext_t;
 
typedef struct lwp_siginfo {
    rt_list_t node;
 
    struct {
        int signo;
        int code;
 
        int from_tid;
        pid_t from_pid;
    } ksiginfo;
 
    /* the signal specified extension field */
    struct lwp_siginfo_ext *ext;
} *lwp_siginfo_t;
 
typedef struct lwp_sigqueue {
    rt_list_t siginfo_list;
    lwp_sigset_t sigset_pending;
} *lwp_sigqueue_t;
 
struct lwp_thread_signal {
    lwp_sigset_t sigset_mask;
    struct lwp_sigqueue sig_queue;
};
 
struct rt_user_context
{
    void *sp;
    void *pc;
    void *flag;
 
    void *ctx;
};
#endif /* RT_USING_SMART */
 
typedef void (*rt_thread_cleanup_t)(struct rt_thread *tid);

 
struct rt_thread
{
    struct rt_object            parent;
 
    /* stack point and entry */
    void                        *sp;                    
    void                        *entry;                 
    void                        *parameter;             
    void                        *stack_addr;            
    rt_uint32_t                 stack_size;             
 
    /* error code */
    rt_err_t                    error;                  
 
#ifdef RT_USING_SMP
    rt_atomic_t                 cpus_lock_nest;         
#endif
 
    RT_SCHED_THREAD_CTX
    struct rt_timer             thread_timer;           
    rt_thread_cleanup_t         cleanup;                
 
#ifdef RT_USING_MUTEX
    /* object for IPC */
    rt_list_t                   taken_object_list;
    rt_object_t                 pending_object;
#endif /* RT_USING_MUTEX */
 
#ifdef RT_USING_EVENT
    /* thread event */
    rt_uint32_t                 event_set;
    rt_uint8_t                  event_info;
#endif /* RT_USING_EVENT */
 
#ifdef RT_USING_SIGNALS
    rt_sigset_t                 sig_pending;            
    rt_sigset_t                 sig_mask;               
 
#ifndef RT_USING_SMP
    void                        *sig_ret;               
#endif /* RT_USING_SMP */
    rt_sighandler_t             *sig_vectors;           
    void                        *si_list;               
#endif /* RT_USING_SIGNALS */
 
#ifdef RT_USING_CPU_USAGE
    rt_uint64_t                 duration_tick;          
#endif /* RT_USING_CPU_USAGE */
 
#ifdef RT_USING_PTHREADS
    void                        *pthread_data;          
#endif /* RT_USING_PTHREADS */
 
    /* light weight process if present */
#ifdef RT_USING_SMART
    void                        *msg_ret;               
 
    void                        *lwp;                   
    /* for user create */
    void                        *user_entry;
    void                        *user_stack;
    rt_uint32_t                 user_stack_size;
    rt_uint32_t                 *kernel_sp;             
    rt_list_t                   sibling;                
 
    struct lwp_thread_signal    signal;                 
    struct rt_user_context      user_ctx;               
    struct rt_wakeup            wakeup_handle;          
    rt_atomic_t                 exit_request;           
    int                         tid;                    
    int                         tid_ref_count;          
    void                        *susp_recycler;         
    void                        *robust_list;           
 
#ifndef ARCH_MM_MMU
    lwp_sighandler_t            signal_handler[32];
#else
    int                         step_exec;
    int                         debug_attach_req;
    int                         debug_ret_user;
    int                         debug_suspend;
    struct rt_hw_exp_stack      *regs;
    void                        *thread_idr;            
    int                         *clear_child_tid;
#endif /* ARCH_MM_MMU */
#endif /* RT_USING_SMART */
 
#ifdef RT_USING_CPU_USAGE_TRACER
    rt_ubase_t                  user_time;              
    rt_ubase_t                  system_time;            
#endif /* RT_USING_CPU_USAGE_TRACER */
 
#ifdef RT_USING_MEM_PROTECTION
    void *mem_regions;
#ifdef RT_USING_HW_STACK_GUARD
    void *stack_buf;
#endif /* RT_USING_HW_STACK_GUARD */
#endif /* RT_USING_MEM_PROTECTION */
 
    struct rt_spinlock          spinlock;
    rt_ubase_t                  user_data;              
};
typedef struct rt_thread *rt_thread_t;
 
#ifdef RT_USING_SMART
#define LWP_IS_USER_MODE(t) ((t)->user_ctx.ctx == RT_NULL)
#else
#define LWP_IS_USER_MODE(t) (0)
#endif /* RT_USING_SMART */




#define RT_IPC_FLAG_FIFO                0x00            
#define RT_IPC_FLAG_PRIO                0x01            
 
#define RT_IPC_CMD_UNKNOWN              0x00            
#define RT_IPC_CMD_RESET                0x01            
#define RT_IPC_CMD_GET_STATE            0x02            
#define RT_IPC_CMD_SET_VLIMIT           0x03            
 
#define RT_WAITING_FOREVER              -1              
#define RT_WAITING_NO                   0               

struct rt_ipc_object
{
    struct rt_object parent;                            
 
    rt_list_t suspend_thread;                 
};

 
#ifdef RT_USING_SEMAPHORE
struct rt_semaphore
{
    struct rt_ipc_object parent;                        
 
    rt_uint16_t          value;                         
    rt_uint16_t          max_value;
    struct rt_spinlock   spinlock;
};
typedef struct rt_semaphore *rt_sem_t;
#endif /* RT_USING_SEMAPHORE */


 
#ifdef RT_USING_MUTEX
struct rt_mutex
{
    struct rt_ipc_object parent;                        
 
    rt_uint8_t           ceiling_priority;              
    rt_uint8_t           priority;                      
    rt_uint8_t           hold;                          
    rt_uint8_t           reserved;                      
 
    struct rt_thread    *owner;                         
    rt_list_t            taken_list;                    
    struct rt_spinlock   spinlock;
};
typedef struct rt_mutex *rt_mutex_t;
#endif /* RT_USING_MUTEX */


 
#ifdef RT_USING_EVENT
#define RT_EVENT_FLAG_AND               0x01            
#define RT_EVENT_FLAG_OR                0x02            
#define RT_EVENT_FLAG_CLEAR             0x04            
 
/*
 * event structure
 */
struct rt_event
{
    struct rt_ipc_object parent;                        
 
    rt_uint32_t          set;                           
    struct rt_spinlock   spinlock;
};
typedef struct rt_event *rt_event_t;
#endif /* RT_USING_EVENT */


 
#ifdef RT_USING_MAILBOX
struct rt_mailbox
{
    struct rt_ipc_object parent;                        
 
    rt_ubase_t          *msg_pool;                      
 
    rt_uint16_t          size;                          
 
    rt_uint16_t          entry;                         
    rt_uint16_t          in_offset;                     
    rt_uint16_t          out_offset;                    
 
    rt_list_t            suspend_sender_thread;         
    struct rt_spinlock   spinlock;
};
typedef struct rt_mailbox *rt_mailbox_t;
#endif /* RT_USING_MAILBOX */


 
#ifdef RT_USING_MESSAGEQUEUE
struct rt_messagequeue
{
    struct rt_ipc_object parent;                        
 
    void                *msg_pool;                      
 
    rt_uint16_t          msg_size;                      
    rt_uint16_t          max_msgs;                      
 
    rt_uint16_t          entry;                         
 
    void                *msg_queue_head;                
    void                *msg_queue_tail;                
    void                *msg_queue_free;                
 
    rt_list_t            suspend_sender_thread;         
    struct rt_spinlock   spinlock;
};
typedef struct rt_messagequeue *rt_mq_t;
#endif /* RT_USING_MESSAGEQUEUE */




 
#ifdef RT_USING_HEAP
/*
 * memory structure
 */
struct rt_memory
{
    struct rt_object        parent;                 
    const char *            algorithm;              
    rt_ubase_t              address;                
    rt_size_t               total;                  
    rt_size_t               used;                   
    rt_size_t               max;                    
};
typedef struct rt_memory *rt_mem_t;
#endif /* RT_USING_HEAP */
 
/*
 * memory management
 * heap & partition
 */
 
#ifdef RT_USING_SMALL_MEM
typedef rt_mem_t rt_smem_t;
#endif /* RT_USING_SMALL_MEM */
 
#ifdef RT_USING_SLAB
typedef rt_mem_t rt_slab_t;
#endif /* RT_USING_SLAB */
 
#ifdef RT_USING_MEMHEAP
struct rt_memheap_item
{
    rt_uint32_t             magic;                      
    struct rt_memheap      *pool_ptr;                   
 
    struct rt_memheap_item *next;                       
    struct rt_memheap_item *prev;                       
 
    struct rt_memheap_item *next_free;                  
    struct rt_memheap_item *prev_free;                  
#ifdef RT_USING_MEMTRACE
    rt_uint8_t              owner_thread_name[4];       
#endif /* RT_USING_MEMTRACE */
};

struct rt_memheap
{
    struct rt_object        parent;                     
 
    void                   *start_addr;                 
 
    rt_size_t               pool_size;                  
    rt_size_t               available_size;             
    rt_size_t               max_used_size;              
 
    struct rt_memheap_item *block_list;                 
 
    struct rt_memheap_item *free_list;                  
    struct rt_memheap_item  free_header;                
 
    struct rt_semaphore     lock;                       
    rt_bool_t               locked;                     
};
#endif /* RT_USING_MEMHEAP */
 
#ifdef RT_USING_MEMPOOL
struct rt_mempool
{
    struct rt_object    parent;                            
 
    void                *start_address;                     
    rt_size_t           size;                              
 
    rt_size_t           block_size;                        
    rt_uint8_t          *block_list;                        
 
    rt_size_t           block_total_count;                 
    rt_size_t           block_free_count;                  
 
    rt_list_t           suspend_thread;                    
    struct rt_spinlock  spinlock;
};
typedef struct rt_mempool *rt_mp_t;
#endif /* RT_USING_MEMPOOL */

 
#ifdef RT_USING_DEVICE


enum rt_device_class_type
{
    RT_Device_Class_Char = 0,                           
    RT_Device_Class_Block,                              
    RT_Device_Class_NetIf,                              
    RT_Device_Class_MTD,                                
    RT_Device_Class_CAN,                                
    RT_Device_Class_RTC,                                
    RT_Device_Class_Sound,                              
    RT_Device_Class_Graphic,                            
    RT_Device_Class_I2CBUS,                             
    RT_Device_Class_USBDevice,                          
    RT_Device_Class_USBHost,                            
    RT_Device_Class_USBOTG,                             
    RT_Device_Class_SPIBUS,                             
    RT_Device_Class_SPIDevice,                          
    RT_Device_Class_SDIO,                               
    RT_Device_Class_PM,                                 
    RT_Device_Class_Pipe,                               
    RT_Device_Class_Portal,                             
    RT_Device_Class_Timer,                              
    RT_Device_Class_Miscellaneous,                      
    RT_Device_Class_Sensor,                             
    RT_Device_Class_Touch,                              
    RT_Device_Class_PHY,                                
    RT_Device_Class_Security,                           
    RT_Device_Class_WLAN,                               
    RT_Device_Class_Pin,                                
    RT_Device_Class_ADC,                                
    RT_Device_Class_DAC,                                
    RT_Device_Class_WDT,                                
    RT_Device_Class_PWM,                                
    RT_Device_Class_Bus,                                
    RT_Device_Class_Unknown                             
};

#define RT_DEVICE_FLAG_DEACTIVATE       0x000           
 
#define RT_DEVICE_FLAG_RDONLY           0x001           
#define RT_DEVICE_FLAG_WRONLY           0x002           
#define RT_DEVICE_FLAG_RDWR             0x003           
 
#define RT_DEVICE_FLAG_REMOVABLE        0x004           
#define RT_DEVICE_FLAG_STANDALONE       0x008           
#define RT_DEVICE_FLAG_ACTIVATED        0x010           
#define RT_DEVICE_FLAG_SUSPENDED        0x020           
#define RT_DEVICE_FLAG_STREAM           0x040           
#define RT_DEVICE_FLAG_DYNAMIC          0x080           
 
#define RT_DEVICE_FLAG_INT_RX           0x100           
#define RT_DEVICE_FLAG_DMA_RX           0x200           
#define RT_DEVICE_FLAG_INT_TX           0x400           
#define RT_DEVICE_FLAG_DMA_TX           0x800           
 
#define RT_DEVICE_OFLAG_CLOSE           0x000           
#define RT_DEVICE_OFLAG_RDONLY          0x001           
#define RT_DEVICE_OFLAG_WRONLY          0x002           
#define RT_DEVICE_OFLAG_RDWR            0x003           
#define RT_DEVICE_OFLAG_OPEN            0x008           
#define RT_DEVICE_OFLAG_MASK            0xf0f           

#define RT_DEVICE_CTRL_RESUME           0x01            
#define RT_DEVICE_CTRL_SUSPEND          0x02            
#define RT_DEVICE_CTRL_CONFIG           0x03            
#define RT_DEVICE_CTRL_CLOSE            0x04            
#define RT_DEVICE_CTRL_NOTIFY_SET       0x05            
#define RT_DEVICE_CTRL_SET_INT          0x06            
#define RT_DEVICE_CTRL_CLR_INT          0x07            
#define RT_DEVICE_CTRL_GET_INT          0x08            
#define RT_DEVICE_CTRL_CONSOLE_OFLAG    0x09            
#define RT_DEVICE_CTRL_MASK             0x1f            

#define RT_DEVICE_CTRL_BASE(Type)        ((RT_Device_Class_##Type + 1) * 0x100)
 
typedef struct rt_driver *rt_driver_t;
typedef struct rt_device *rt_device_t;
 
#ifdef RT_USING_DEVICE_OPS
struct rt_device_ops
{
    /* common device interface */
    rt_err_t  (*init)   (rt_device_t dev);
    rt_err_t  (*open)   (rt_device_t dev, rt_uint16_t oflag);
    rt_err_t  (*close)  (rt_device_t dev);
    rt_ssize_t (*read)  (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
    rt_ssize_t (*write) (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
    rt_err_t  (*control)(rt_device_t dev, int cmd, void *args);
};
#endif /* RT_USING_DEVICE_OPS */

struct rt_wqueue
{
    rt_uint32_t flag;
    rt_list_t waiting_list;
    struct rt_spinlock spinlock;
};
typedef struct rt_wqueue rt_wqueue_t;
 
#ifdef RT_USING_DM
struct rt_driver;
struct rt_bus;
#endif /* RT_USING_DM */

struct rt_device
{
    struct rt_object          parent;                   
 
#ifdef RT_USING_DM
    struct rt_bus *bus;                                 
    rt_list_t node;                                     
    struct rt_driver *drv;                              
#ifdef RT_USING_OFW
    void *ofw_node;                                     
#endif /* RT_USING_OFW */
    void *power_domain_unit;
#ifdef RT_USING_DMA
    const void *dma_ops;
#endif
#endif /* RT_USING_DM */
 
    enum rt_device_class_type type;                     
    rt_uint16_t               flag;                     
    rt_uint16_t               open_flag;                
 
    rt_uint8_t                ref_count;                
#ifdef RT_USING_DM
    rt_uint8_t                master_id;                
#endif
    rt_uint8_t                device_id;                
 
    /* device call back */
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);
 
#ifdef RT_USING_DEVICE_OPS
    const struct rt_device_ops *ops;
#else
    /* common device interface */
    rt_err_t  (*init)   (rt_device_t dev);
    rt_err_t  (*open)   (rt_device_t dev, rt_uint16_t oflag);
    rt_err_t  (*close)  (rt_device_t dev);
    rt_ssize_t (*read)  (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
    rt_ssize_t (*write) (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
    rt_err_t  (*control)(rt_device_t dev, int cmd, void *args);
#endif /* RT_USING_DEVICE_OPS */
 
#ifdef RT_USING_POSIX_DEVIO
    const struct dfs_file_ops *fops;
    struct rt_wqueue wait_queue;
#endif /* RT_USING_POSIX_DEVIO */
 
    rt_err_t (*readlink)
        (rt_device_t dev, char *buf, int len);          
 
    void                     *user_data;                
};

struct rt_device_notify
{
    void (*notify)(rt_device_t dev);
    struct rt_device *dev;
};
 
#ifdef RT_USING_SMART
struct rt_channel
{
    struct rt_ipc_object parent;                        
    struct rt_thread *reply;                            
    struct rt_spinlock slock;                           
    rt_list_t wait_msg;                                 
    rt_list_t wait_thread;                              
    rt_wqueue_t reader_queue;                           
    rt_uint8_t  stat;                                   
    rt_ubase_t  ref;
};
typedef struct rt_channel *rt_channel_t;
#endif /* RT_USING_SMART */

#endif /* RT_USING_DEVICE */
 
#ifdef __cplusplus
}
#endif
 
#ifdef __cplusplus
/* RT-Thread definitions for C++ */
namespace rtthread {
 
enum TICK_WAIT {
    WAIT_NONE = 0,
    WAIT_FOREVER = -1,
};
 
}
 
#endif /* __cplusplus */
 
#endif /* __RT_DEF_H__ */