rttypes.h

浏览该文件的文档.

/*
 * Copyright (c) 2006-2024, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-01-18     Shell        Separate the basic types from rtdef.h
 */
 
#ifndef __RT_TYPES_H__
#define __RT_TYPES_H__
 
#include <rtconfig.h>
 
#include <stdint.h>
#include <stddef.h>
#include <stdarg.h>
#ifndef RT_USING_NANO
#include <sys/types.h>
#include <sys/errno.h>
#if defined(RT_USING_SIGNALS) || defined(RT_USING_SMART)
#include <sys/signal.h>
#endif /* defined(RT_USING_SIGNALS) || defined(RT_USING_SMART) */
#endif /* RT_USING_NANO */
 
#ifdef __cplusplus
extern "C" {
#endif

 
typedef int                             rt_bool_t;      
 
#ifndef RT_USING_ARCH_DATA_TYPE
#ifdef RT_USING_LIBC
typedef int8_t                          rt_int8_t;      
typedef int16_t                         rt_int16_t;     
typedef int32_t                         rt_int32_t;     
typedef uint8_t                         rt_uint8_t;     
typedef uint16_t                        rt_uint16_t;    
typedef uint32_t                        rt_uint32_t;    
typedef int64_t                         rt_int64_t;     
typedef uint64_t                        rt_uint64_t;    
#else
typedef signed   char                   rt_int8_t;      
typedef signed   short                  rt_int16_t;     
typedef signed   int                    rt_int32_t;     
typedef unsigned char                   rt_uint8_t;     
typedef unsigned short                  rt_uint16_t;    
typedef unsigned int                    rt_uint32_t;    
#ifdef ARCH_CPU_64BIT
typedef signed long                     rt_int64_t;     
typedef unsigned long                   rt_uint64_t;    
#else
typedef signed long long                rt_int64_t;     
typedef unsigned long long              rt_uint64_t;    
#endif /* ARCH_CPU_64BIT */
#endif /* RT_USING_LIBC */
#endif /* RT_USING_ARCH_DATA_TYPE */
 
#ifdef ARCH_CPU_64BIT
typedef rt_int64_t                      rt_base_t;      
typedef rt_uint64_t                     rt_ubase_t;     
#else
typedef rt_int32_t                      rt_base_t;      
typedef rt_uint32_t                     rt_ubase_t;     
#endif
 
#if defined(RT_USING_LIBC) && !defined(RT_USING_NANO)
typedef size_t                          rt_size_t;      
typedef ssize_t                         rt_ssize_t;     
typedef intptr_t                        rt_intptr_t;    
typedef uintptr_t                       rt_uintptr_t;   
#else
typedef rt_ubase_t                      rt_size_t;      
typedef rt_base_t                       rt_ssize_t;     
typedef rt_ubase_t                      rt_intptr_t;    
typedef rt_base_t                       rt_uintptr_t;   
#endif /* defined(RT_USING_LIBC) && !defined(RT_USING_NANO) */
 
typedef rt_base_t                       rt_err_t;       
typedef rt_uint32_t                     rt_time_t;      
typedef rt_uint32_t                     rt_tick_t;      
typedef rt_base_t                       rt_flag_t;      
typedef rt_ubase_t                      rt_dev_t;       
typedef rt_base_t                       rt_off_t;       
 
#if defined(RT_USING_STDC_ATOMIC) && __STDC_VERSION__ < 201112L
#undef RT_USING_STDC_ATOMIC
#warning Not using C11 or beyond! Maybe you should change the -std option on your compiler
#endif
 
#ifdef __cplusplus
    typedef rt_base_t rt_atomic_t;
#else
    #if defined(RT_USING_STDC_ATOMIC)
        #include <stdatomic.h>
        typedef _Atomic(rt_base_t) rt_atomic_t;
    #elif defined(RT_USING_HW_ATOMIC)
        typedef rt_base_t rt_atomic_t;
    #else
        typedef rt_base_t rt_atomic_t;
    #endif /* RT_USING_STDC_ATOMIC */
#endif /* __cplusplus */
 
/* boolean type definitions */
#define RT_TRUE                         1               
#define RT_FALSE                        0               
 
/* null pointer definition */
#define RT_NULL                         0

struct rt_list_node
{
    struct rt_list_node *next;                          
    struct rt_list_node *prev;                          
};
typedef struct rt_list_node rt_list_t;                  

struct rt_slist_node
{
    struct rt_slist_node *next;                         
};
typedef struct rt_slist_node rt_slist_t;                

struct rt_lockless_slist_node
{
    rt_atomic_t next;                                   
};
typedef struct rt_lockless_slist_node rt_ll_slist_t;    

#ifdef RT_USING_SMP
#include <cpuport.h> /* for spinlock from arch */
 
struct rt_spinlock
{
    rt_hw_spinlock_t lock;
#ifdef RT_USING_DEBUG
    rt_uint32_t critical_level;
#endif /* RT_USING_DEBUG */
#if defined(RT_DEBUGING_SPINLOCK)
    void *owner;
    void *pc;
#endif /* RT_DEBUGING_SPINLOCK */
};
 
#ifndef RT_SPINLOCK_INIT
#define RT_SPINLOCK_INIT {{0}} /* can be overridden by cpuport.h */
#endif /* RT_SPINLOCK_INIT */
 
#else /* !RT_USING_SMP */
 
struct rt_spinlock
{
#ifdef RT_USING_DEBUG
    rt_uint32_t critical_level;
#endif /* RT_USING_DEBUG */
    rt_ubase_t lock;
};
#define RT_SPINLOCK_INIT {0}
#endif /* RT_USING_SMP */
#if defined(RT_DEBUGING_SPINLOCK) && defined(RT_USING_SMP)
 
    #define __OWNER_MAGIC ((void *)0xdeadbeaf)
 
    #if defined(__GNUC__)
    #define __GET_RETURN_ADDRESS __builtin_return_address(0)
    #else /* !__GNUC__ */
    #define __GET_RETURN_ADDRESS RT_NULL
    #endif /* __GNUC__ */
 
    #define _SPIN_LOCK_DEBUG_OWNER(lock)                  \
        do                                                \
        {                                                 \
            struct rt_thread *_curthr = rt_thread_self(); \
            if (_curthr != RT_NULL)                       \
            {                                             \
                (lock)->owner = _curthr;                  \
                (lock)->pc = __GET_RETURN_ADDRESS;        \
            }                                             \
        } while (0)
 
    #define _SPIN_UNLOCK_DEBUG_OWNER(lock) \
        do                                 \
        {                                  \
            (lock)->owner = __OWNER_MAGIC; \
            (lock)->pc = RT_NULL;          \
        } while (0)
 
#else /* !RT_DEBUGING_SPINLOCK */
 
    #define _SPIN_LOCK_DEBUG_OWNER(lock)    RT_UNUSED(lock)
    #define _SPIN_UNLOCK_DEBUG_OWNER(lock)  RT_UNUSED(lock)
#endif /* RT_DEBUGING_SPINLOCK */
 
#ifdef RT_DEBUGING_CRITICAL
    #define _SPIN_LOCK_DEBUG_CRITICAL(lock)               \
        do                                                \
        {                                                 \
            (lock)->critical_level = rt_critical_level(); \
        } while (0)
 
    #define _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical) \
        do                                              \
        {                                               \
            (critical) = (lock)->critical_level;        \
        } while (0)
 
#else /* !RT_DEBUGING_CRITICAL */
    #define _SPIN_LOCK_DEBUG_CRITICAL(lock)             RT_UNUSED(lock)
    #define _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical) do {critical = 0; RT_UNUSED(lock);} while (0)
 
#endif /* RT_DEBUGING_CRITICAL */
 
#define RT_SPIN_LOCK_DEBUG(lock)         \
    do                                   \
    {                                    \
        _SPIN_LOCK_DEBUG_OWNER(lock);    \
        _SPIN_LOCK_DEBUG_CRITICAL(lock); \
    } while (0)
 
#define RT_SPIN_UNLOCK_DEBUG(lock, critical)         \
    do                                               \
    {                                                \
        _SPIN_UNLOCK_DEBUG_OWNER(lock);              \
        _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical); \
    } while (0)
 
typedef struct rt_spinlock rt_spinlock_t;
 
#define RT_DEFINE_SPINLOCK(x)  struct rt_spinlock x = RT_SPINLOCK_INIT
 
#ifdef __cplusplus
}
#endif
 
#endif /* __RT_TYPES_H__ */