diff --git a/src/kernel/include/arch_generic/atomic.h b/src/kernel/include/arch_generic/atomic.h index 2b68336..81dc858 100644 --- a/src/kernel/include/arch_generic/atomic.h +++ b/src/kernel/include/arch_generic/atomic.h @@ -31,6 +31,7 @@ * @ingroup kernel */ +//在LiteOS操作系统中，atomic.h头文件通常用于提供原子操作的支持。原子操作是不可中断的操作，它可以确保在多线程环境中对共享资源进行安全的访问和修改。 #ifndef _ARCH_GENERIC_ATOMIC_H #define _ARCH_GENERIC_ATOMIC_H @@ -44,17 +45,26 @@ extern "C" { #endif /* __cplusplus */ #ifndef LOSCFG_KERNEL_SMP - +/*ArchAtomicRead 函数用于原子读取一个整数变量的值。 +它将一个指向原子变量的指针 v 强制转换为 volatile INT32 类型的指针， +并返回该指针所指向的值。*/ STATIC INLINE INT32 ArchAtomicRead(const Atomic *v) { return *(volatile INT32 *)v; } +/*ArchAtomicSet 函数用于原子设置一个整数变量的值。 +它将一个指向原子变量的指针 v 强制转换为 volatile INT32 类型的指针， +并将 setVal 的值赋给该指针所指向的变量。*/ STATIC INLINE VOID ArchAtomicSet(Atomic *v, INT32 setVal) { *(volatile INT32 *)v = setVal; } +/*ArchAtomicAdd 函数用于原子增加一个整数变量的值。 +它先保存当前中断状态，然后在关闭中断的情况下，将 addVal 加到指针 v 所指向的变量上， +并返回增加后的值。 +最后，恢复之前保存的中断状态。*/ STATIC INLINE INT32 ArchAtomicAdd(Atomic *v, INT32 addVal) { UINT32 intSave; @@ -66,6 +76,9 @@ STATIC INLINE INT32 ArchAtomicAdd(Atomic *v, INT32 addVal) return *v; } +/*ArchAtomicSub 函数用于原子减少一个整数变量的值。 +它的实现与 ArchAtomicAdd 类似， +只是将 subVal 减去指针 v 所指向的变量。*/ STATIC INLINE INT32 ArchAtomicSub(Atomic *v, INT32 subVal) { UINT32 intSave; @@ -77,6 +90,10 @@ STATIC INLINE INT32 ArchAtomicSub(Atomic *v, INT32 subVal) return *v; } +/*ArchAtomicInc 函数用于原子增加一个整数变量的值。 +它首先保存当前中断状态 intSave，然后在关闭中断的情况下， +将指针 addr 指向的变量加 1， +最后恢复之前保存的中断状态。*/ STATIC INLINE VOID ArchAtomicInc(Atomic *addr) { UINT32 intSave; @@ -86,6 +103,7 @@ STATIC INLINE VOID ArchAtomicInc(Atomic *addr) LOS_IntRestore(intSave); } +//ArchAtomicIncRet 函数与 ArchAtomicInc 类似，但它还返回增加后的变量值。 STATIC INLINE INT32 ArchAtomicIncRet(Atomic *addr) { UINT32 intSave; @@ -96,6 +114,7 @@ STATIC INLINE INT32 ArchAtomicIncRet(Atomic *addr) return *addr; } +//ArchAtomicDec 函数用于原子减少一个整数变量的值。它的实现类似于 ArchAtomicInc，只是将指针 addr 指向的变量减 1。 STATIC INLINE VOID ArchAtomicDec(Atomic *addr) { UINT32 intSave; @@ -105,6 +124,7 @@ STATIC INLINE VOID ArchAtomicDec(Atomic *addr) LOS_IntRestore(intSave); } +//ArchAtomicDecRet 函数与 ArchAtomicDec 类似，但它还返回减少后的变量值。 STATIC INLINE INT32 ArchAtomicDecRet(Atomic *addr) { UINT32 intSave; @@ -115,6 +135,10 @@ STATIC INLINE INT32 ArchAtomicDecRet(Atomic *addr) return *addr; } +/*ArchAtomic64Read 函数用于原子读取一个 64 位整数变量的值。 +它首先保存当前中断状态 intSave，然后在关闭中断的情况下， +读取指针 v 指向的 64 位整数变量的值， +最后恢复之前保存的中断状态，并返回读取的值。*/ STATIC INLINE INT64 ArchAtomic64Read(const Atomic64 *v) { UINT32 intSave; @@ -127,6 +151,10 @@ STATIC INLINE INT64 ArchAtomic64Read(const Atomic64 *v) return val; } +/*ArchAtomic64Set 函数用于原子设置一个 64 位整数变量的值为 setVal。 +它首先保存当前中断状态 intSave，然后在关闭中断的情况下， +将指针 v 指向的变量设置为 setVal， +最后恢复之前保存的中断状态。*/ STATIC INLINE VOID ArchAtomic64Set(Atomic64 *v, INT64 setVal) { UINT32 intSave; @@ -136,6 +164,10 @@ STATIC INLINE VOID ArchAtomic64Set(Atomic64 *v, INT64 setVal) LOS_IntRestore(intSave); } +/*ArchAtomic64Add 函数用于原子增加一个 64 位整数变量的值。 +它首先保存当前中断状态 intSave，然后在关闭中断的情况下， +将指针 v 指向的变量增加 addVal，然后将增加后的值赋给变量 val， +最后恢复之前保存的中断状态，并返回 val。*/ STATIC INLINE INT64 ArchAtomic64Add(Atomic64 *v, INT64 addVal) { UINT32 intSave; @@ -149,6 +181,9 @@ STATIC INLINE INT64 ArchAtomic64Add(Atomic64 *v, INT64 addVal) return val; } +/*ArchAtomic64Sub 函数用于原子减少一个 64 位整数变量的值。 +它的实现类似于 ArchAtomic64Add， +只是将指针 v 指向的变量减去 subVal。*/ STATIC INLINE INT64 ArchAtomic64Sub(Atomic64 *v, INT64 subVal) { UINT32 intSave; @@ -162,6 +197,8 @@ STATIC INLINE INT64 ArchAtomic64Sub(Atomic64 *v, INT64 subVal) return val; } +/*ArchAtomic64Inc 函数用于原子增加一个 64 位整数变量的值。 +它的实现类似于 ArchAtomic64Add，只是将增加的值固定为 1。*/ STATIC INLINE VOID ArchAtomic64Inc(Atomic64 *v) { UINT32 intSave; @@ -171,6 +208,7 @@ STATIC INLINE VOID ArchAtomic64Inc(Atomic64 *v) LOS_IntRestore(intSave); } +//ArchAtomic64IncRet 函数与 ArchAtomic64Inc 类似，但它还返回增加后的变量值。 STATIC INLINE INT64 ArchAtomic64IncRet(Atomic64 *v) { UINT32 intSave; @@ -184,6 +222,9 @@ STATIC INLINE INT64 ArchAtomic64IncRet(Atomic64 *v) return val; } +/*ArchAtomic64Dec 函数用于原子减少一个 64 位整数变量的值。 +它首先保存当前中断状态 intSave，然后在关闭中断的情况下，将指针 v 指向的变量减去 1， +最后恢复之前保存的中断状态。*/ STATIC INLINE VOID ArchAtomic64Dec(Atomic64 *v) { UINT32 intSave; @@ -193,6 +234,7 @@ STATIC INLINE VOID ArchAtomic64Dec(Atomic64 *v) LOS_IntRestore(intSave); } +//ArchAtomic64DecRet 函数与 ArchAtomic64Dec 类似，但它还返回减少后的变量值。 STATIC INLINE INT64 ArchAtomic64DecRet(Atomic64 *v) { UINT32 intSave; @@ -206,6 +248,10 @@ STATIC INLINE INT64 ArchAtomic64DecRet(Atomic64 *v) return val; } +/*ArchAtomicXchg32bits 函数用于原子交换一个 32 位整数变量的值。 +它首先保存当前中断状态 intSave，然后在关闭中断的情况下， +将指针 v 指向的变量的值赋给 prevVal，再将变量 v 的值设置为 val， +最后恢复之前保存的中断状态，并返回原先的值 prevVal。*/ STATIC INLINE INT32 ArchAtomicXchg32bits(Atomic *v, INT32 val) { UINT32 intSave; @@ -219,6 +265,7 @@ STATIC INLINE INT32 ArchAtomicXchg32bits(Atomic *v, INT32 val) return prevVal; } +//ArchAtomicXchg64bits 函数类似于 ArchAtomicXchg32bits，但它用于原子交换一个 64 位整数变量的值。 STATIC INLINE INT64 ArchAtomicXchg64bits(Atomic64 *v, INT64 val) { UINT32 intSave; @@ -232,6 +279,11 @@ STATIC INLINE INT64 ArchAtomicXchg64bits(Atomic64 *v, INT64 val) return prevVal; } +/*ArchAtomicCmpXchg32bits 函数用于原子比较和交换一个 32 位整数变量的值。 +它首先保存当前中断状态 intSave，然后在关闭中断的情况下， +将指针 v 指向的变量的值赋给 prevVal，接着判断 prevVal 是否等于 oldVal， +如果相等，则将变量 v 的值设置为 val，最后恢复之前保存的中断状态， +并返回是否执行了交换操作的布尔值。*/ STATIC INLINE BOOL ArchAtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal) { UINT32 intSave; @@ -247,6 +299,7 @@ STATIC INLINE BOOL ArchAtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal) return (prevVal != oldVal); } +//ArchAtomicCmpXchg64bits 函数类似于 ArchAtomicCmpXchg32bits，但它用于原子比较和交换一个 64 位整数变量的值。 STATIC INLINE BOOL ArchAtomicCmpXchg64bits(Atomic64 *v, INT64 val, INT64 oldVal) { UINT32 intSave; diff --git a/src/kernel/include/console.h b/src/kernel/include/console.h index a0f102a..e57aba9 100644 --- a/src/kernel/include/console.h +++ b/src/kernel/include/console.h @@ -25,18 +25,18 @@ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * --------------------------------------------------------------------------- */ - +//在LiteOS操作系统中，console头文件通常用于定义与控制台交互相关的函数和数据结构。 #ifndef _CONSOLE_H #define _CONSOLE_H - -#include "los_config.h" -#ifdef LOSCFG_FS_VFS -#include "termios.h" -#ifdef LOSCFG_NET_TELNET -#include "telnet_dev.h" -#endif -#include "virtual_serial.h" -#include "los_ringbuf.h" +//代码中，首先使用了条件编译防护，以确保头文件内容只被包含一次。接着定义了控制台输入输出缓冲区的大小，并声明了控制台初始化、打印和读取等函数。 +#include "los_config.h"//引用了系统配置文件，用于获取操作系统的一些设置和属性。 +#ifdef LOSCFG_FS_VFS//使用条件编译指令判断是否定义了宏LOSCFG_FS_VFS，如果已经定义，则编译下面的代码块，否则跳过。 +#include "termios.h"//包含了 POSIX 终端控制定义的头文件，用于对终端进行控制。 +#ifdef LOSCFG_NET_TELNET//使用条件编译指令判断是否定义了宏,如果已经定义，则编译下面的代码块，否则跳过。 +#include "telnet_dev.h"//包含了 Telnet 设备驱动的头文件，用于实现 Telnet 连接。 +#endif//结束条件编译指令。 +#include "virtual_serial.h"//包含了虚拟串口的头文件，用于实现虚拟串口的功能。 +#include "los_ringbuf.h"//包含了环形缓冲区的头文件，用于实现缓冲区的读写操作。 #endif #ifdef __cplusplus @@ -57,76 +57,76 @@ extern "C" { #define CONSOLE "/dev/console" #define CONSOLE_NAMELEN 16 - -#define CONSOLE_CMD_RD_BLOCK_SERIAL 0x104 -#define CONSOLE_CMD_RD_BLOCK_TELNET 101 -#define CONSOLE_RD_BLOCK 1 -#define CONSOLE_RD_NONBLOCK 0 -#define CONSOLE_SHELL_KEY_EVENT 0x112 -#define CONSOLE_SHELL_EXITED 0x400 -#define CONSOLE_CONTROL_RIGHTS_CAPTURE 201 -#define CONSOLE_CONTROL_RIGHTS_RELEASE 202 -#define CONSOLE_CONTROL_CAPTURE_LINE 203 -#define CONSOLE_CONTROL_CAPTURE_CHAR 204 -#define CONSOLE_FIFO_SIZE 1024 -#define CONSOLE_NUM 2 +//这段代码定义了一些宏和常量，它们的含义如下： +#define CONSOLE_CMD_RD_BLOCK_SERIAL 0x104//表示从串口读取数据的阻塞命令，其值为0x104。 +#define CONSOLE_CMD_RD_BLOCK_TELNET 101//表示从Telnet连接读取数据的阻塞命令，其值为101。 +#define CONSOLE_RD_BLOCK 1//表示阻塞模式，其值为1。 +#define CONSOLE_RD_NONBLOCK 0//表示非阻塞模式，其值为0。 +#define CONSOLE_SHELL_KEY_EVENT 0x112//表示shell键盘事件，其值为0x112。 +#define CONSOLE_SHELL_EXITED 0x400//表示shell已退出，其值为0x400。 +#define CONSOLE_CONTROL_RIGHTS_CAPTURE 201//表示控制权被捕获，其值为201。 +#define CONSOLE_CONTROL_RIGHTS_RELEASE 202//表示控制权被释放，其值为202。 +#define CONSOLE_CONTROL_CAPTURE_LINE 203//表示捕获行命令，其值为203。 +#define CONSOLE_CONTROL_CAPTURE_CHAR 204//表示捕获字符命令，其值为204。 +#define CONSOLE_FIFO_SIZE 1024//表示控制台FIFO（First In First Out）缓冲区大小，其值为1024。 +#define CONSOLE_NUM 2//表示控制台数量，其值为2。 typedef struct { - Ringbuf ringbuf; /* Ring buffer */ - EVENT_CB_S sendEvent; /* Inform telnet send task */ + Ringbuf ringbuf; /* Ring buffer *///表示环形缓冲区，它可能是一个用于缓存数据的循环队列或者环形链表。 + EVENT_CB_S sendEvent; /* Inform telnet send task *///表示向telnet发送任务发送事件的回调函数。 } RingbufSendCB; typedef struct { - UINT32 consoleID; - UINT32 consoleType; - UINT32 consoleSem; - UINT32 shellEntryId; - UINT32 consoleMask; - struct inode *devInode; - CHAR *name; - INT32 fd; - UINT32 refCount; - BOOL isNonBlock; + UINT32 consoleID;//表示控制台的ID。 + UINT32 consoleType;//表示控制台的类型。 + UINT32 consoleSem;//表示用于同步的控制台信号量。 + UINT32 shellEntryId;//表示shell的入口ID。 + UINT32 consoleMask;//表示控制台的掩码。 + struct inode *devInode;//表示设备节点。 + CHAR *name;//表示控制台的名称。 + INT32 fd;//表示文件描述符。 + UINT32 refCount;//表示引用计数。 + BOOL isNonBlock;//表示是否为非阻塞模式。 #ifdef LOSCFG_SHELL - VOID *shellHandle; + VOID *shellHandle;//表示shell的句柄。 #endif - UINT32 sendTaskID; - RingbufSendCB *ringbufSendCB; - UINT8 fifo[CONSOLE_FIFO_SIZE]; - UINT32 fifoOut; - UINT32 fifoIn; - UINT32 currentLen; - struct termios consoleTermios; + UINT32 sendTaskID;//表示发送任务的ID。 + RingbufSendCB *ringbufSendCB;//表示环形缓冲区发送回调。 + UINT8 fifo[CONSOLE_FIFO_SIZE];//表示控制台的FIFO缓冲区。 + UINT32 fifoOut;//表示FIFO缓冲区的输出位置。 + UINT32 fifoIn;//表示FIFO缓冲区的输入位置。 + UINT32 currentLen;//表示当前长度。 + struct termios consoleTermios;//表示控制台的终端属性。 } CONSOLE_CB; -extern INT32 system_console_init(const CHAR *deviceName); -extern INT32 system_console_deinit(const CHAR *deviceName); -extern BOOL SetSerialNonBlock(const CONSOLE_CB *consoleCB); -extern BOOL SetSerialBlock(const CONSOLE_CB *consoleCB); -extern BOOL SetTelnetNonBlock(const CONSOLE_CB *consoleCB); -extern BOOL SetTelnetBlock(const CONSOLE_CB *consoleCB); -extern CONSOLE_CB *OsGetConsoleByID(INT32 consoleId); -extern CONSOLE_CB *OsGetConsoleByTaskID(UINT32 taskId); -extern UINT32 ConsoleTaskReg(INT32 consoleId, UINT32 taskId); -extern INT32 ConsoleUpdateFd(VOID); -extern BOOL ConsoleEnable(VOID); -extern BOOL is_nonblock(const CONSOLE_CB *consoleCB); -extern BOOL IsConsoleOccupied(const CONSOLE_CB *consoleCB); -extern INT32 FilepOpen(struct file *filep, const struct file_operations_vfs *fops); -extern INT32 FilepClose(struct file *filep, const struct file_operations_vfs *fops); -extern INT32 FilepRead(struct file *filep, const struct file_operations_vfs *fops, CHAR *buffer, size_t bufLen); -extern INT32 FilepWrite(struct file *filep, const struct file_operations_vfs *fops, const CHAR *buffer, size_t bufLen); -extern INT32 FilepPoll(struct file *filep, const struct file_operations_vfs *fops, poll_table *fds); -extern INT32 FilepIoctl(struct file *filep, const struct file_operations_vfs *fops, INT32 cmd, unsigned long arg); -extern INT32 GetFilepOps(const struct file *filep, struct file **privFilep, const struct file_operations_vfs **fops); +extern INT32 system_console_init(const CHAR *deviceName);//控制台初始化函数用于初始化控制台相关的资源和状态 +extern INT32 system_console_deinit(const CHAR *deviceName);//控制台反初始化函数，用于释放控制台相关的资源和状态。 +extern BOOL SetSerialNonBlock(const CONSOLE_CB *consoleCB);//设置串口为非阻塞模式。 +extern BOOL SetSerialBlock(const CONSOLE_CB *consoleCB);//设置串口为阻塞模式。 +extern BOOL SetTelnetNonBlock(const CONSOLE_CB *consoleCB);//设置Telnet连接为非阻塞模式。 +extern BOOL SetTelnetBlock(const CONSOLE_CB *consoleCB);//设置Telnet连接为阻塞模式。 +extern CONSOLE_CB *OsGetConsoleByID(INT32 consoleId);//根据控制台ID获取控制台的控制块（Control Block）。 +extern CONSOLE_CB *OsGetConsoleByTaskID(UINT32 taskId);//根据任务ID获取关联的控制台的控制块。 +extern UINT32 ConsoleTaskReg(INT32 consoleId, UINT32 taskId);//将任务与指定的控制台进行关联。 +extern INT32 ConsoleUpdateFd(VOID);//更新控制台的文件描述符（File Descriptor）。 +extern BOOL ConsoleEnable(VOID);//使能控制台功能。 +extern BOOL is_nonblock(const CONSOLE_CB *consoleCB);//判断控制台是否为非阻塞模式。 +extern BOOL IsConsoleOccupied(const CONSOLE_CB *consoleCB);//判断控制台是否已经被占用。 +extern INT32 FilepOpen(struct file *filep, const struct file_operations_vfs *fops);//打开文件。 +extern INT32 FilepClose(struct file *filep, const struct file_operations_vfs *fops);//关闭文件。 +extern INT32 FilepRead(struct file *filep, const struct file_operations_vfs *fops, CHAR *buffer, size_t bufLen);//从文件中读取数据。 +extern INT32 FilepWrite(struct file *filep, const struct file_operations_vfs *fops, const CHAR *buffer, size_t bufLen);//向文件中写入数据。 +extern INT32 FilepPoll(struct file *filep, const struct file_operations_vfs *fops, poll_table *fds);//对文件进行轮询操作。 +extern INT32 FilepIoctl(struct file *filep, const struct file_operations_vfs *fops, INT32 cmd, unsigned long arg);//对文件进行IO控制操作。 +extern INT32 GetFilepOps(const struct file *filep, struct file **privFilep, const struct file_operations_vfs **fops);//获取文件的操作函数。 #else -STATIC INLINE INT32 ConsoleUpdateFd(VOID) +STATIC INLINE INT32 ConsoleUpdateFd(VOID)//这是一个函数声明，声明了一个名为ConsoleUpdateFd的静态内联函数，返回类型为INT32（32位整数），参数为空。根据函数体的实现为return -1;，该函数的作用是更新控制台的文件描述符（File Descriptor），并返回-1。 { return -1; } -#endif +#endif//这个宏表示结束了之前的条件编译指令#if。 -#ifdef __cplusplus +#ifdef __cplusplus//这一组条件编译指令用于判断是否为C++编译环境。如果是C++编译环境，则将后面的代码块用extern "C"包裹起来，以保证C和C++之间的函数调用规则一致。 #if __cplusplus } #endif /* __cplusplus */ diff --git a/src/kernel/include/los_atomic.h b/src/kernel/include/los_atomic.h index 05fff5f..eaf9204 100644 --- a/src/kernel/include/los_atomic.h +++ b/src/kernel/include/los_atomic.h @@ -30,12 +30,12 @@ * @defgroup los_atomic Atomic * @ingroup kernel */ - -#ifndef _LOS_ATOMIC_H -#define _LOS_ATOMIC_H +//los_atomic.h是用于支持原子操作的头文件。 +#ifndef _LOS_ATOMIC_H//表示如果宏变量 _LOS_ATOMIC_H 没有被定义过，则执行以下代码，否则忽略这段代码。 +#define _LOS_ATOMIC_H//是定义一个宏变量，可以用来判断这个头文件是否已经被包含过。 #include "los_typedef.h" -#include "arch/atomic.h" +#include "arch/atomic.h"//是平台相关的原子操作头文件，具体实现依赖于不同的硬件平台。 #ifdef __cplusplus #if __cplusplus @@ -60,7 +60,7 @@ extern "C" { * @see LOS_Atomic64Read * @since Huawei LiteOS V200R003C00 */ -STATIC INLINE INT32 LOS_AtomicRead(const Atomic *v) +STATIC INLINE INT32 LOS_AtomicRead(const Atomic *v)//函数接受一个Atomic类型的指针参数v，并返回一个32位整数。用于读取指定内存位置的原子变量的值。 { return ArchAtomicRead(v); } @@ -84,7 +84,7 @@ STATIC INLINE INT32 LOS_AtomicRead(const Atomic *v) * @see LOS_Atomic64Set * @since Huawei LiteOS V200R003C00 */ -STATIC INLINE VOID LOS_AtomicSet(Atomic *v, INT32 setVal) +STATIC INLINE VOID LOS_AtomicSet(Atomic *v, INT32 setVal)//函数接受一个Atomic类型的指针参数v和一个32位整数setVal，没有返回值（返回类型为VOID）。 { ArchAtomicSet(v, setVal); } @@ -114,7 +114,7 @@ STATIC INLINE VOID LOS_AtomicSet(Atomic *v, INT32 setVal) */ STATIC INLINE INT32 LOS_AtomicAdd(Atomic *v, INT32 addVal) { - return ArchAtomicAdd(v, addVal); + return ArchAtomicAdd(v, addVal);//用于将指定内存位置的原子变量增加指定的值。 } /** @@ -142,7 +142,7 @@ STATIC INLINE INT32 LOS_AtomicAdd(Atomic *v, INT32 addVal) */ STATIC INLINE INT32 LOS_AtomicSub(Atomic *v, INT32 subVal) { - return ArchAtomicSub(v, subVal); + return ArchAtomicSub(v, subVal);//用于将指定内存位置的原子变量减少指定的值。 } /** @@ -168,7 +168,7 @@ STATIC INLINE INT32 LOS_AtomicSub(Atomic *v, INT32 subVal) */ STATIC INLINE VOID LOS_AtomicInc(Atomic *v) { - ArchAtomicInc(v); + ArchAtomicInc(v);//用于将指定内存位置的原子变量增加1。 } /** @@ -222,7 +222,7 @@ STATIC INLINE INT32 LOS_AtomicIncRet(Atomic *v) */ STATIC INLINE VOID LOS_AtomicDec(Atomic *v) { - ArchAtomicDec(v); + ArchAtomicDec(v);//该函数通常是由特定的体系结构提供的原子递减函数的实现。通过使用内联函数和宏定义，可以在编译时将这段代码直接嵌入到调用处，从而提高执行效率和节省函数调用的开销。 } /** @@ -248,7 +248,7 @@ STATIC INLINE VOID LOS_AtomicDec(Atomic *v) */ STATIC INLINE INT32 LOS_AtomicDecRet(Atomic *v) { - return ArchAtomicDecRet(v); + return ArchAtomicDecRet(v);//该函数通常是由特定的体系结构提供的原子递减操作并返回递减后的值的函数。 } /** @@ -270,7 +270,7 @@ STATIC INLINE INT32 LOS_AtomicDecRet(Atomic *v) */ STATIC INLINE INT64 LOS_Atomic64Read(const Atomic64 *v) { - return ArchAtomic64Read(v); + return ArchAtomic64Read(v);//该函数通常是由特定的体系结构提供的原子读取操作的函数。 } /** @@ -294,7 +294,7 @@ STATIC INLINE INT64 LOS_Atomic64Read(const Atomic64 *v) */ STATIC INLINE VOID LOS_Atomic64Set(Atomic64 *v, INT64 setVal) { - ArchAtomic64Set(v, setVal); + ArchAtomic64Set(v, setVal);//该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -322,7 +322,7 @@ STATIC INLINE VOID LOS_Atomic64Set(Atomic64 *v, INT64 setVal) */ STATIC INLINE INT64 LOS_Atomic64Add(Atomic64 *v, INT64 addVal) { - return ArchAtomic64Add(v, addVal); + return ArchAtomic64Add(v, addVal);//函数来完成原子加操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -350,7 +350,7 @@ STATIC INLINE INT64 LOS_Atomic64Add(Atomic64 *v, INT64 addVal) */ STATIC INLINE INT64 LOS_Atomic64Sub(Atomic64 *v, INT64 subVal) { - return ArchAtomic64Sub(v, subVal); + return ArchAtomic64Sub(v, subVal);//函数来完成原子减操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -376,7 +376,7 @@ STATIC INLINE INT64 LOS_Atomic64Sub(Atomic64 *v, INT64 subVal) */ STATIC INLINE VOID LOS_Atomic64Inc(Atomic64 *v) { - ArchAtomic64Inc(v); + ArchAtomic64Inc(v);//函数来完成原子增加操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -403,7 +403,7 @@ STATIC INLINE VOID LOS_Atomic64Inc(Atomic64 *v) */ STATIC INLINE INT64 LOS_Atomic64IncRet(Atomic64 *v) { - return ArchAtomic64IncRet(v); + return ArchAtomic64IncRet(v);//函数来完成原子增加操作并返回增加后的值，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -430,7 +430,7 @@ STATIC INLINE INT64 LOS_Atomic64IncRet(Atomic64 *v) */ STATIC INLINE VOID LOS_Atomic64Dec(Atomic64 *v) { - ArchAtomic64Dec(v); + ArchAtomic64Dec(v);//函数来完成原子减少操作，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -456,7 +456,7 @@ STATIC INLINE VOID LOS_Atomic64Dec(Atomic64 *v) */ STATIC INLINE INT64 LOS_Atomic64DecRet(Atomic64 *v) { - return ArchAtomic64DecRet(v); + return ArchAtomic64DecRet(v);//函数来完成原子减少操作并返回减少后的值，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -480,7 +480,7 @@ STATIC INLINE INT64 LOS_Atomic64DecRet(Atomic64 *v) */ STATIC INLINE INT32 LOS_AtomicXchg32bits(Atomic *v, INT32 val) { - return ArchAtomicXchg32bits(v, val); + return ArchAtomicXchg32bits(v, val);//函数来完成原子交换操作并返回交换前的值，该函数应该是由底层的架构代码提供的，用于实现 32 位整数的原子操作。 } /** @@ -504,7 +504,7 @@ STATIC INLINE INT32 LOS_AtomicXchg32bits(Atomic *v, INT32 val) */ STATIC INLINE INT64 LOS_AtomicXchg64bits(Atomic64 *v, INT64 val) { - return ArchAtomicXchg64bits(v, val); + return ArchAtomicXchg64bits(v, val);//函数来完成原子交换操作并返回交换前的值，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } /** @@ -531,7 +531,7 @@ STATIC INLINE INT64 LOS_AtomicXchg64bits(Atomic64 *v, INT64 val) */ STATIC INLINE BOOL LOS_AtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal) { - return ArchAtomicCmpXchg32bits(v, val, oldVal); + return ArchAtomicCmpXchg32bits(v, val, oldVal);//函数来完成原子比较和交换操作，并返回比较结果，该函数应该是由底层的架构代码提供的，用于实现 32 位整数的原子操作。 } /** @@ -558,7 +558,7 @@ STATIC INLINE BOOL LOS_AtomicCmpXchg32bits(Atomic *v, INT32 val, INT32 oldVal) */ STATIC INLINE BOOL LOS_AtomicCmpXchg64bits(Atomic64 *v, INT64 val, INT64 oldVal) { - return ArchAtomicCmpXchg64bits(v, val, oldVal); + return ArchAtomicCmpXchg64bits(v, val, oldVal);//函数来完成原子比较和交换操作，并返回比较结果，该函数应该是由底层的架构代码提供的，用于实现 64 位整数的原子操作。 } #ifdef __cplusplus diff --git a/src/kernel/include/los_base.h b/src/kernel/include/los_base.h index a4544a5..bf1e570 100644 --- a/src/kernel/include/los_base.h +++ b/src/kernel/include/los_base.h @@ -75,19 +75,19 @@ extern "C" { * @since Huawei LiteOS V100R001C00 */ #define LOS_ASSERT_COND(expression) LOS_ASSERT(expression) - +//这是一个宏函数，它接受一个表达式作为参数，并将该表达式作为参数传递给另一个名为LOS_ASSERT的宏函数。它的作用是在满足给定条件时执行断言。 /** * @ingroup los_base * Define the timeout interval as LOS_NO_WAIT. */ #define LOS_NO_WAIT 0 - +//这是一个常量，被定义为0。它表示一个超时时间间隔，即表示不等待，立即返回。 /** * @ingroup los_base * Define the timeout interval as LOS_WAIT_FOREVER. */ #define LOS_WAIT_FOREVER 0xFFFFFFFF - +//这是另一个常量，被定义为0xFFFFFFFF。它表示一个超时时间间隔，即表示永远等待，直到条件满足或者被中断。 /** * @ingroup los_base * @brief Align the value (addr) by some bytes (boundary). @@ -111,8 +111,8 @@ extern "C" { * @see LOS_Align | TRUNCATE * @since Huawei LiteOS V100R001C00 */ -#ifndef ALIGN -#define ALIGN(addr, boundary) LOS_Align(addr, boundary) +#ifndef ALIGN//判断ALIGN是否已经被定义过，如果没有被定义过，则执行接下来的代码。 +#define ALIGN(addr, boundary) LOS_Align(addr, boundary)//分别表示需要对齐的地址和对齐边界。在函数体内部，它调用了LOS_Align函数进行地址对齐操作，将addr地址向上对齐到最接近的boundary的倍数。 #endif /** @@ -139,10 +139,16 @@ extern "C" { * @since Huawei LiteOS V100R001C00 */ #define TRUNCATE(addr, size) ((UINTPTR)(addr) & ~((size) - 1)) - +//宏接受两个参数 addr 和 size，返回一个截断后的地址。具体而言，该宏将地址 addr 按照 size 的大小进行对齐，并将低位多余的位置为零。例如，如果 addr 是 0x12345678，size 是 4，则截断后的地址是 0x12345670。 /** * Read a UINT8 value from addr and stroed in value. */ +/*READ_UINT8(value, addr)、READ_UINT16(value, addr) 和 READ_UINT32(value, addr) +分别用于从地址 addr 中读取 8 位、16 位和 32 位的数值， +并将结果存储到变量 value 中。这几个宏的实现方式类似， +都是通过指针间接读取内存中的数值，并使用 dsb() 函数进行数据同步操作， +以确保读取的数据正确。其中，dsb() 函数是一个汇编指令， +用于进行数据同步操作，防止出现数据不一致的情况。*/ #define READ_UINT8(value, addr) ({ (value) = *((volatile UINT8 *)((UINTPTR)(addr))); dsb(); }) /** @@ -155,6 +161,9 @@ extern "C" { */ #define READ_UINT32(value, addr) ({ (value) = *((volatile UINT32 *)((UINTPTR)(addr))); dsb(); }) + +//判断编译环境是否为 64 位。如果是 64 位环境，则定义了 READ_UINT64 和 WRITE_UINT64 宏。否则，这两个宏将被忽略。 +//宏用于从地址 addr 中读取一个 64 位的整数值，并将结果存储到变量 value 中。这里使用了和之前类似的操作，通过指针间接读取内存中的值，并使用 dsb() 函数进行数据同步操作。 #ifdef __LP64__ /** * Read a UINT64 value from addr and stroed in value. @@ -162,6 +171,11 @@ extern "C" { #define READ_UINT64(value, addr) ({ (value) = *((volatile UINT64 *)((UINTPTR)(addr))); dsb(); }) #endif + +/*WRITE_UINT8(value, addr)、WRITE_UINT16(value, addr) 和 WRITE_UINT32(value, addr) 宏 +分别用于将 8 位、16 位和 32 位的整数值 value 写入到地址 addr 中。 +这些宏也使用了和之前类似的操作，使用 dsb() 函数进行数据同步操作， +并通过指针间接写入内存中的值。*/ /** * Write a UINT8 value to addr. */ @@ -177,6 +191,8 @@ extern "C" { */ #define WRITE_UINT32(value, addr) ({ dsb(); *((volatile UINT32 *)((UINTPTR)(addr))) = (value); }) + +//在 64 位环境下，还定义了 WRITE_UINT64 宏，用于将 64 位的整数值 value 写入到地址 addr 中。 #ifdef __LP64__ /** * Write a UINT64 addr to addr. @@ -187,11 +203,13 @@ extern "C" { /** * Get a UINT8 value from addr. */ +//宏用于从地址 addr 中读取一个 8 位的无符号整数值，并返回读取到的结果。在读取之后，使用 dsb() 函数进行数据同步操作，以确保读取的数据正确。 #define GET_UINT8(addr) ({ UINT8 r = *((volatile UINT8 *)((UINTPTR)(addr))); dsb(); r; }) /** * Get a UINT16 value from addr. */ +//GET_UINT16(addr) 和 GET_UINT32(addr) 宏分别用于从地址 addr 中读取 16 位和 32 位的无符号整数值，并返回读取到的结果。同样地，在读取之后也进行数据同步操作。 #define GET_UINT16(addr) ({ UINT16 r = *((volatile UINT16 *)((UINTPTR)(addr))); dsb(); r; }) /** @@ -199,6 +217,8 @@ extern "C" { */ #define GET_UINT32(addr) ({ UINT32 r = *((volatile UINT32 *)((UINTPTR)(addr))); dsb(); r; }) + +//在 64 位环境下，还定义了 GET_UINT64(addr) 宏，用于从地址 addr 中读取一个 64 位的无符号整数值，并返回读取到的结果。 #ifdef __LP64__ /** * Get a UINT64 value from addr. @@ -226,7 +246,7 @@ extern "C" { * @see LOS_ASSERT_COND * @since Huawei LiteOS V100R001C00 */ -#ifdef LOSCFG_DEBUG_VERSION +#ifdef LOSCFG_DEBUG_VERSION//首先，通过条件编译指令 #ifdef LOSCFG_DEBUG_VERSION 来判断是否处于调试版本。如果定义了 LOSCFG_DEBUG_VERSION 宏，则表示处于调试版本，代码块 #ifdef 和 #endif 之间的内容将会生效；否则，代码块 #else 和 #endif 之间的内容将会生效。 #define LOS_ASSERT(judge) do { \ if ((UINTPTR)(judge) == 0) { \ (VOID)LOS_IntLock(); \ @@ -234,8 +254,12 @@ extern "C" { while (1) {} \ } \ } while (0) +//在调试版本下，宏定义的代码块中，LOS_ASSERT 宏被定义为一个带有参数 judge 的宏函数。它的作用是进行断言检查，如果 judge 表达式的结果为零（即假），则执行以上操作 +//调用 LOS_IntLock() 函数，该函数可能是一个用于禁止中断的操作，以确保在断言失败时不会中断处理。 +//使用 PRINT_ERR 打印一条错误信息，其中包含了出错的文件名、行号和函数名。 +//进入一个无限循环 while (1)，程序会一直停留在这个循环中。 #else -#define LOS_ASSERT(judge) +#define LOS_ASSERT(judge)//在非调试版本下，宏定义的代码块中，LOS_ASSERT 宏被定义为空，即不进行任何操作。 #endif /** @@ -261,7 +285,8 @@ extern "C" { * @since Huawei LiteOS V100R001C00 */ extern UINTPTR LOS_Align(UINTPTR addr, UINT32 boundary); - +//具体而言，函数的功能是将 addr 按照 boundary 边界进行对齐，并返回对齐后的地址。例如，如果 addr 是 12，boundary 是 8，那么对齐后的地址就是 16。 +//extern 关键字表示该函数是在其他地方定义的，这里只是对其进行声明。这样做的目的是在当前文件中使用该函数时能够正确引用它，而不需要提供函数的具体实现。 /** * @ingroup los_base * @brief Sleep the current task. diff --git a/src/kernel/include/los_bitmap.h b/src/kernel/include/los_bitmap.h index 81bfb8f..b05e472 100644 --- a/src/kernel/include/los_bitmap.h +++ b/src/kernel/include/los_bitmap.h @@ -31,7 +31,7 @@ * @ingroup kernel */ -#ifndef _LOS_BITMAP_H +#ifndef _LOS_BITMAP_H//这段代码是一个条件编译指令块，用于判断是否定义了宏 _LOS_BITMAP_H。如果未定义该宏，则会执行 #ifndef 和 #endif 之间的代码。 #define _LOS_BITMAP_H #include "los_typedef.h" @@ -48,6 +48,7 @@ extern "C" { * * The effective bit index is from 0 to 31. */ +//由于这里宏定义的值为 32，这个宏的含义是使用 0 到 31 的整数表示位索引值，而 32 则表示无效的位索引值。这种处理方式在计算机编程中比较常见，一般用于标识某些特殊的状态或标志。 #define LOS_INVALID_BIT_INDEX 32 /** @@ -69,6 +70,9 @@ extern "C" { * @see LOS_BitmapClr * @since Huawei LiteOS V100R001C00 */ +/*bitmap 是一个指向 UINT32 类型的指针，表示一个位图（或称为位数组）。 +pos 是一个 UINT16 类型的参数，表示要设置的位索引。 +函数的作用是在给定的位图中将指定的位索引位置设为 1，即将相应位置的比特位设置为 1。*/ VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos); /** @@ -90,6 +94,9 @@ VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos); * @see LOS_BitmapSet. * @since Huawei LiteOS V100R001C00 */ +/*bitmap 是一个指向 UINT32 类型的指针，表示一个位图（或称为位数组）。 +pos 是一个 UINT16 类型的参数，表示要清除的位索引。 +函数的作用是在给定的位图中将指定的位索引位置清零，即将相应位置的比特位设置为 0。*/ VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos); /** @@ -108,6 +115,12 @@ VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos); * @see LOS_HighBitGet * @since Huawei LiteOS V100R001C00 */ +/*函数的作用是在给定的位图中找到最低位（也就是数值最小的位）的索引， +并返回该索引。如果位图中不存在任何置位的比特位， +则返回 32，即宏 LOS_INVALID_BIT_INDEX 的值。 +具体实现可能会涉及位运算和掩码操作， +以找到最低位的索引号。由于函数返回类型为 UINT16， +即 unsigned short 类型，因此返回值为 0 到 31 的整数（包括 0 和 31）或 32*/ UINT16 LOS_LowBitGet(UINT32 bitmap); /** @@ -126,6 +139,12 @@ UINT16 LOS_LowBitGet(UINT32 bitmap); * @see LOS_LowBitGet * @since Huawei LiteOS V100R001C00 */ +/*函数的作用是在给定的位图中找到最高位（也就是数值最大的位）的索引， +并返回该索引。如果位图中不存在任何置位的比特位， +则返回 32，即宏 LOS_INVALID_BIT_INDEX 的值。 +具体实现可能会涉及位运算和掩码操作，以找到最高位的索引号。 +由于函数返回类型为 UINT16，即 unsigned short 类型， +因此返回值为 0 到 31 的整数（包括 0 和 31）或 32。*/ UINT16 LOS_HighBitGet(UINT32 bitmap); #ifdef __cplusplus diff --git a/src/kernel/include/los_builddef.h b/src/kernel/include/los_builddef.h index 894fd80..192d90a 100644 --- a/src/kernel/include/los_builddef.h +++ b/src/kernel/include/los_builddef.h @@ -35,79 +35,79 @@ extern "C" { #endif /* __cplusplus */ #endif /* __cplusplus */ -#define OS_LITTLE_ENDIAN 0x1234 /* Little endian */ -#define OS_BIG_ENDIAN 0x4321 /* Big endian */ +#define OS_LITTLE_ENDIAN 0x1234 /* Little endian *///表示小端序，数值为 0x1234 +#define OS_BIG_ENDIAN 0x4321 /* Big endian *///表示大端序，数值为 0x4321 #ifndef OS_BYTE_ORDER -#define OS_BYTE_ORDER OS_LITTLE_ENDIAN +#define OS_BYTE_ORDER OS_LITTLE_ENDIAN//如果未定义 OS_BYTE_ORDER，则将其设置为 OS_LITTLE_ENDIAN #endif /* Define OS code data sections */ /* The indicator function is inline */ #ifndef LITE_OS_SEC_ALW_INLINE -#define LITE_OS_SEC_ALW_INLINE /* __attribute__((always_inline)) */ +#define LITE_OS_SEC_ALW_INLINE /* __attribute__((always_inline)) *///定义了一个宏，用于将函数声明为内联函数 #endif #ifndef LITE_OS_SEC_TEXT -#define LITE_OS_SEC_TEXT /* __attribute__((section(".text.sram"))) */ +#define LITE_OS_SEC_TEXT /* __attribute__((section(".text.sram"))) *///定义了一个宏，用于将代码段放置在 .text.sram 段中 #endif #ifndef LITE_OS_SEC_TEXT_MINOR -#define LITE_OS_SEC_TEXT_MINOR /* __attribute__((section(".text.ddr"))) */ +#define LITE_OS_SEC_TEXT_MINOR /* __attribute__((section(".text.ddr"))) *///定义了一个宏，用于将代码段放置在 .text.ddr 段中 #endif #ifndef LITE_OS_SEC_TEXT_INIT -#define LITE_OS_SEC_TEXT_INIT /* __attribute__((section(".text.init"))) */ +#define LITE_OS_SEC_TEXT_INIT /* __attribute__((section(".text.init"))) *///宏定义了一个代码段，用于放置初始化代码，其位置在 .text.init 段中。 #endif #ifndef LITE_OS_SEC_DATA -#define LITE_OS_SEC_DATA /* __attribute__((section(".data.sram"))) */ +#define LITE_OS_SEC_DATA /* __attribute__((section(".data.sram"))) *///宏定义了一个数据段，用于放置数据，其位置在 .data.sram 段中。 #endif #ifndef LITE_OS_SEC_DATA_MINOR -#define LITE_OS_SEC_DATA_MINOR /* __attribute__((section(".data.ddr"))) */ +#define LITE_OS_SEC_DATA_MINOR /* __attribute__((section(".data.ddr"))) *///定义了一个次要数据段，用于放置次要的数据，其位置在 .data.ddr 段中。 #endif #ifndef LITE_OS_SEC_DATA_INIT -#define LITE_OS_SEC_DATA_INIT /* __attribute__((section(".data.init"))) */ +#define LITE_OS_SEC_DATA_INIT /* __attribute__((section(".data.init"))) *///宏定义了一个数据段，用于放置初始化数据，其位置在 .data.init 段中。 #endif #ifndef LITE_OS_SEC_DATA_VEC -#define LITE_OS_SEC_DATA_VEC __attribute__((section(".data.vector"))) +#define LITE_OS_SEC_DATA_VEC __attribute__((section(".data.vector")))//宏定义了一个数据段，用于放置向量表数据，其位置在 .data.vector 段中。 #endif #ifndef LITE_OS_SEC_BSS -#define LITE_OS_SEC_BSS /* __attribute__((section(".bss.sram"))) */ +#define LITE_OS_SEC_BSS /* __attribute__((section(".bss.sram"))) *///宏定义了一个数据段，用于放置未初始化的数据（BSS段），其位置在 .bss.sram 段中。 #endif #ifndef LITE_OS_SEC_BSS_MINOR -#define LITE_OS_SEC_BSS_MINOR /* __attribute__((section(".bss.ddr"))) */ +#define LITE_OS_SEC_BSS_MINOR /* __attribute__((section(".bss.ddr"))) */// 宏定义了一个数据段，用于放置未初始化的次要数据（BSS段），其位置在 .bss.ddr 段中。 #endif #ifndef LITE_OS_SEC_BSS_INIT -#define LITE_OS_SEC_BSS_INIT /* __attribute__((section(".bss.init"))) */ +#define LITE_OS_SEC_BSS_INIT /* __attribute__((section(".bss.init"))) *///宏定义了一个数据段，用于放置未初始化的初始化数据（BSS段），其位置在 .bss.init 段中。 #endif #ifndef LITE_OS_SEC_ITCM -#define LITE_OS_SEC_ITCM /* __attribute__((section(".itcm "))) */ +#define LITE_OS_SEC_ITCM /* __attribute__((section(".itcm "))) */// 宏定义了一个代码段，用于放置代码（指令）和只读数据，在 ITCM 中运行。 ITCM 与其他内存有所不同，它位于 CPU 内部，具有高速访问和低延迟的优势。 #endif #ifndef LITE_OS_SEC_DTCM -#define LITE_OS_SEC_DTCM /* __attribute__((section(".dtcm"))) */ +#define LITE_OS_SEC_DTCM /* __attribute__((section(".dtcm"))) *///宏定义了一个数据段，用于放置数据，位于 DTCM 中。 DTCM 与其他内存有所不同，它位于 CPU 内部，具有高速访问和低延迟的优势。 #endif -#define PACK1 +#define PACK1//宏定义了一个结构体成员变量的对齐方式，将结构体的成员变量紧密地打包在一起，不使用空间来对齐。 #ifndef LITE_OS_ATTR_SEC -#define LITE_OS_ATTR_SEC(name) __attribute__((section(#name))) +#define LITE_OS_ATTR_SEC(name) __attribute__((section(#name)))//宏定义了一个函数或变量所在的段，通过 #name 将 name 转换为字符串，将函数或变量放置到指定名称的段中。 #endif #ifndef LITE_OS_ATTR_ALIGN -#define LITE_OS_ATTR_ALIGN(x) __attribute__((aligned(x))) +#define LITE_OS_ATTR_ALIGN(x) __attribute__((aligned(x)))//宏定义了数据的对齐方式，即几个字节对齐，x 表示对齐的字节数。 #endif #ifndef LITE_OS_ATTR_SEC_ALIGN -#define LITE_OS_ATTR_SEC_ALIGN(name, x) __attribute__((section(#name), aligned(x))) +#define LITE_OS_ATTR_SEC_ALIGN(name, x) __attribute__((section(#name), aligned(x)))//宏定义了某段数据的对齐方式，即将数据放置到指定名称的段中，并按照指定的对齐方式对齐。 #endif #ifndef OS_EMBED_ASM -#define OS_EMBED_ASM __asm__ __volatile__ +#define OS_EMBED_ASM __asm__ __volatile__//宏定义了嵌入汇编指令的方式，将 asm volatile 作为嵌入汇编指令的前缀，使得编译器可以将其识别为汇编指令。 #endif #ifdef __cplusplus diff --git a/src/kernel/include/los_config.h b/src/kernel/include/los_config.h index 75b9ea0..bd14843 100644 --- a/src/kernel/include/los_config.h +++ b/src/kernel/include/los_config.h @@ -30,6 +30,22 @@ * @defgroup los_config System configuration items * @ingroup kernel */ +/*具体而言，los_config.h 文件通常包含以下内容： + +任务（Task）配置：可以定义任务的数量、优先级范围、堆栈大小等参数，以满足不同应用场景的需求。 + +中断（Interrupt）配置：可以定义中断服务例程的数量、优先级范围，以及中断处理的策略等。 + +内存管理（Memory Management）配置：可以定义动态内存分配算法、内存池的大小和数量等相关参数。 + +定时器（Timer）配置：可以定义定时器的数量、精度、触发方式等。 + +任务调度（Task Scheduling）配置：可以配置任务调度算法、时间片轮转的时间等。 + +系统时钟（System Clock）配置：可以定义系统时钟的频率、定时器的输入时钟源等。 + +通过修改 los_config.h 文件中的宏定义和全局变量，开发人员可以根据应用需求对操作系统进行定制和优化。 +然后，将修改后的 los_config.h 文件编译进入 LiteOS 内核，即可实现对操作系统行为和功能的定制化配置。*/ #ifndef _LOS_CONFIG_H #define _LOS_CONFIG_H @@ -45,53 +61,53 @@ extern "C" { #endif /* __cplusplus */ #endif /* __cplusplus */ -#ifdef LOSCFG_LIB_CONFIGURABLE -extern UINT32 g_osSysClock; -extern UINT32 g_tickPerSecond; -extern UINT32 g_taskLimit; -extern UINT32 g_taskMinStkSize; -extern UINT32 g_taskIdleStkSize; -extern UINT32 g_taskDfltStkSize; -extern UINT32 g_taskSwtmrStkSize; -extern UINT32 g_swtmrLimit; -extern UINT32 g_semLimit; -extern UINT32 g_muxLimit; -extern UINT32 g_queueLimit; -extern UINT32 g_timeSliceTimeOut; - -extern BOOL g_nxEnabled; -extern UINTPTR g_dlNxHeapBase; -extern UINT32 g_dlNxHeapSize; - -#define LOS_GET_NX_CFG() (g_nxEnabled) -#define LOS_SET_NX_CFG(value) (g_nxEnabled = (value)) -#define LOS_GET_DL_NX_HEAP_BASE() (g_dlNxHeapBase) -#define LOS_SET_DL_NX_HEAP_BASE(addr) (g_dlNxHeapBase = (addr)) -#define LOS_GET_DL_NX_HEAP_SIZE() (g_dlNxHeapSize) -#define LOS_SET_DL_NX_HEAP_SIZE(size) (g_dlNxHeapSize = (size)) - -#define OS_SYS_CLOCK g_osSysClock -#define KERNEL_TICK_PER_SECOND g_tickPerSecond -#define KERNEL_TSK_LIMIT g_taskLimit -#define KERNEL_TSK_MIN_STACK_SIZE g_taskMinStkSize -#define KERNEL_TSK_DEFAULT_STACK_SIZE g_taskDfltStkSize -#define KERNEL_TSK_IDLE_STACK_SIZE g_taskIdleStkSize -#define KERNEL_TSK_SWTMR_STACK_SIZE g_taskSwtmrStkSize -#define KERNEL_SWTMR_LIMIT g_swtmrLimit -#define KERNEL_SEM_LIMIT g_semLimit -#define KERNEL_MUX_LIMIT g_muxLimit -#define KERNEL_QUEUE_LIMIT g_queueLimit -#define KERNEL_TIMESLICE_TIMEOUT g_timeSliceTimeOut +#ifdef LOSCFG_LIB_CONFIGURABLE//判断宏定义 LOSCFG_LIB_CONFIGURABLE 是否被定义。如果该宏被定义，那么以下变量声明将会被编译进程序中。 +extern UINT32 g_osSysClock;//系统时钟频率 +extern UINT32 g_tickPerSecond;//系统时钟滴答数 +extern UINT32 g_taskLimit;//最大任务数量 +extern UINT32 g_taskMinStkSize;//任务最小堆栈大小 +extern UINT32 g_taskIdleStkSize;//空闲任务堆栈大小 +extern UINT32 g_taskDfltStkSize;//默认任务堆栈大小 +extern UINT32 g_taskSwtmrStkSize;//软件定时器任务堆栈大小 +extern UINT32 g_swtmrLimit;//最大软件定时器数量 +extern UINT32 g_semLimit;//最大信号量数量 +extern UINT32 g_muxLimit;//最大互斥量数量 +extern UINT32 g_queueLimit;//最大队列数量 +extern UINT32 g_timeSliceTimeOut;//时间片轮转的时间 + +extern BOOL g_nxEnabled;//是否启用内存保护机制 +extern UINTPTR g_dlNxHeapBase;//内存保护机制的起始地址 +extern UINT32 g_dlNxHeapSize;//内存保护机制的大小 + +#define LOS_GET_NX_CFG() (g_nxEnabled)//宏用于获取一个名为g_nxEnabled的变量的值。 +#define LOS_SET_NX_CFG(value) (g_nxEnabled = (value))//宏用于设置一个名为g_nxEnabled的变量的值。 +#define LOS_GET_DL_NX_HEAP_BASE() (g_dlNxHeapBase)//宏用于获取一个名为g_dlNxHeapBase的变量的值。 +#define LOS_SET_DL_NX_HEAP_BASE(addr) (g_dlNxHeapBase = (addr))//宏用于设置一个名为g_dlNxHeapBase的变量的值。 +#define LOS_GET_DL_NX_HEAP_SIZE() (g_dlNxHeapSize)//宏用于获取一个名为g_dlNxHeapSize的变量的值。 +#define LOS_SET_DL_NX_HEAP_SIZE(size) (g_dlNxHeapSize = (size))//宏用于设置一个名为g_dlNxHeapSize的变量的值。 + +#define OS_SYS_CLOCK g_osSysClock//定义系统时间频率 +#define KERNEL_TICK_PER_SECOND g_tickPerSecond//定义系统时针滴答数 +#define KERNEL_TSK_LIMIT g_taskLimit//定义最大任务数量 +#define KERNEL_TSK_MIN_STACK_SIZE g_taskMinStkSize//定义任务最小堆栈大小 +#define KERNEL_TSK_DEFAULT_STACK_SIZE g_taskDfltStkSize//定义默认任务堆栈大小 +#define KERNEL_TSK_IDLE_STACK_SIZE g_taskIdleStkSize//定义默认任务堆栈大小 +#define KERNEL_TSK_SWTMR_STACK_SIZE g_taskSwtmrStkSize//定义软件定时器任务堆栈大小 +#define KERNEL_SWTMR_LIMIT g_swtmrLimit//定义最大软件定时器数量 +#define KERNEL_SEM_LIMIT g_semLimit//定义最大信号量数量 +#define KERNEL_MUX_LIMIT g_muxLimit//定义最大互斥量数量 +#define KERNEL_QUEUE_LIMIT g_queueLimit//定义最大对列数量 +#define KERNEL_TIMESLICE_TIMEOUT g_timeSliceTimeOut//定义时间片轮转的时间 #else /* LOSCFG_LIB_CONFIGURABLE */ #ifdef LOSCFG_KERNEL_NX -#define LOS_GET_NX_CFG() true -#define LOS_SET_NX_CFG(value) -#define LOS_GET_DL_NX_HEAP_BASE() LOS_DL_HEAP_BASE -#define LOS_SET_DL_NX_HEAP_BASE(addr) -#define LOS_GET_DL_NX_HEAP_SIZE() LOS_DL_HEAP_SIZE -#define LOS_SET_DL_NX_HEAP_SIZE(size) +#define LOS_GET_NX_CFG() true//获取内存保护机制是否开启的配置值，当 LOSCFG_KERNEL_NX 宏被定义时，返回 true；否则返回 false。 +#define LOS_SET_NX_CFG(value)//设置内存保护机制的配置值，该宏定义为空白，没有实际操作。 +#define LOS_GET_DL_NX_HEAP_BASE() LOS_DL_HEAP_BASE//获取内存保护机制的起始地址，当 LOSCFG_KERNEL_NX 宏被定义时，返回 LOS_DL_HEAP_BASE；否则返回 NULL。 +#define LOS_SET_DL_NX_HEAP_BASE(addr)//设置内存保护机制的起始地址，该宏定义为空白，没有实际操作。 +#define LOS_GET_DL_NX_HEAP_SIZE() LOS_DL_HEAP_SIZE//获取内存保护机制的大小，当 LOSCFG_KERNEL_NX 宏被定义时，返回 LOS_DL_HEAP_SIZE；否则返回 0。 +#define LOS_SET_DL_NX_HEAP_SIZE(size)//设置内存保护机制的大小，该宏定义为空白，没有实际操作。 #else /* LOSCFG_KERNEL_NX */ #define LOS_GET_NX_CFG() false #define LOS_SET_NX_CFG(value) @@ -101,7 +117,9 @@ extern UINT32 g_dlNxHeapSize; #define LOS_SET_DL_NX_HEAP_SIZE(size) #endif /* LOSCFG_KERNEL_NX */ -#define KERNEL_TICK_PER_SECOND LOSCFG_BASE_CORE_TICK_PER_SECOND +//这段代码是一系列宏定义，用于将一些配置参数映射到对应的宏定义。 +//这样做的目的是将配置参数与代码解耦，使得修改配置参数时只需要修改相应的宏定义，而无需修改引用该参数的代码。这样可以提高代码的可维护性和可移植性。 +#define KERNEL_TICK_PER_SECOND LOSCFG_BASE_CORE_TICK_PER_SECOND//如KERNEL_TICK_PER_SECOND宏定义为LOSCFG_BASE_CORE_TICK_PER_SECOND，意味着在代码中使用KERNEL_TICK_PER_SECOND时，实际上是使用了配置参数 #define KERNEL_TSK_LIMIT LOSCFG_BASE_CORE_TSK_LIMIT #define KERNEL_TSK_MIN_STACK_SIZE LOSCFG_BASE_CORE_TSK_MIN_STACK_SIZE #define KERNEL_TSK_DEFAULT_STACK_SIZE LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE @@ -112,27 +130,27 @@ extern UINT32 g_dlNxHeapSize; #define KERNEL_MUX_LIMIT LOSCFG_BASE_IPC_MUX_LIMIT #define KERNEL_QUEUE_LIMIT LOSCFG_BASE_IPC_QUEUE_LIMIT #define KERNEL_TIMESLICE_TIMEOUT LOSCFG_BASE_CORE_TIMESLICE_TIMEOUT - +//最后的#endif /* LOSCFG_LIB_CONFIGURABLE */表示这组宏定义的结束，在条件LOSCFG_LIB_CONFIGURABLE不成立时，这组宏定义不起作用，因为它们是在这个条件下定义的。 #endif /* LOSCFG_LIB_CONFIGURABLE */ /** * system sections start and end address */ -extern CHAR __int_stack_start; -extern CHAR __int_stack_end; -extern CHAR __rodata_start; -extern CHAR __rodata_end; -extern CHAR __bss_start; -extern CHAR __bss_end; -extern CHAR __text_start; -extern CHAR __text_end; -extern CHAR __ram_data_start; -extern CHAR __ram_data_end; -extern CHAR __exc_heap_start; -extern CHAR __exc_heap_end; -extern CHAR __heap_start; -extern CHAR __init_array_start__; -extern CHAR __init_array_end__; +extern CHAR __int_stack_start;//内部栈的起始地址 +extern CHAR __int_stack_end;//内部栈的结束地址 +extern CHAR __rodata_start;//只读数据段的起始地址。 +extern CHAR __rodata_end;//只读数据段的结束地址。 +extern CHAR __bss_start;//未初始化的全局变量段（BSS Segment）的起始地址。 +extern CHAR __bss_end;//未初始化的全局变量段（BSS Segment）的结束地址。 +extern CHAR __text_start;//可执行代码段（Text Segment）的起始地址。 +extern CHAR __text_end;//可执行代码段（Text Segment）的结束地址。 +extern CHAR __ram_data_start;//RAM 数据段的起始地址。 +extern CHAR __ram_data_end;//RAM 数据段的结束地址。 +extern CHAR __exc_heap_start;//异常堆（Exception Heap）的起始地址。 +extern CHAR __exc_heap_end;//异常堆（Exception Heap）的结束地址。 +extern CHAR __heap_start;//堆（Heap）的起始地址。 +extern CHAR __init_array_start__;//初始化数组的起始地址。 +extern CHAR __init_array_end__; //初始化数组的结束地址。 /****************************** System clock module configuration ****************************/ /** @@ -140,24 +158,24 @@ extern CHAR __init_array_end__; * System clock (unit: HZ) */ #ifndef OS_SYS_CLOCK -#define OS_SYS_CLOCK (get_bus_clk()) +#define OS_SYS_CLOCK (get_bus_clk())//定义系统时钟频率，默认值为get_bus_clk() #endif /** * @ingroup los_config * time timer clock (unit: HZ) */ #ifndef OS_TIME_TIMER_CLOCK -#define OS_TIME_TIMER_CLOCK OS_SYS_CLOCK +#define OS_TIME_TIMER_CLOCK OS_SYS_CLOCK//定义定时器时钟频率，默认值为 OS_SYS_CLOCK #endif /** * limit addr range when search for 'func local(frame pointer)' or 'func name' */ #ifndef OS_SYS_FUNC_ADDR_START -#define OS_SYS_FUNC_ADDR_START ((UINTPTR)&__int_stack_start) +#define OS_SYS_FUNC_ADDR_START ((UINTPTR)&__int_stack_start)//定义函数起始地址，默认值为&__int_stack_start #endif #ifndef OS_SYS_FUNC_ADDR_END -#define OS_SYS_FUNC_ADDR_END g_sys_mem_addr_end +#define OS_SYS_FUNC_ADDR_END g_sys_mem_addr_end//定义函数终止地址，默认值为g_sys_mem_addr_end #endif /** @@ -165,14 +183,14 @@ extern CHAR __init_array_end__; * Microseconds of adjtime in one second */ #ifndef LOSCFG_BASE_CORE_ADJ_PER_SECOND -#define LOSCFG_BASE_CORE_ADJ_PER_SECOND 500 +#define LOSCFG_BASE_CORE_ADJ_PER_SECOND 500//每秒钟的微调时间。如果没有定义过LOSCFG_BASE_CORE_ADJ_PER_SECOND，则将其定义为500。这意味着系统在进行时间微调时，每秒钟可以微调500微秒。 #endif /** * @ingroup los_config * Sched clck interval */ -#define SCHED_CLOCK_INTETRVAL_TICKS 100 +#define SCHED_CLOCK_INTETRVAL_TICKS 100//表示调度时钟的间隔。这个宏定义的值为100，表示调度时钟的间隔为100个时钟节拍。 /****************************** Interrupt module configuration ****************************/ /** @@ -184,7 +202,7 @@ extern CHAR __init_array_end__; */ #ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION #ifndef MAX_BINARY_POINT_VALUE -#define MAX_BINARY_POINT_VALUE 4 +#define MAX_BINARY_POINT_VALUE 4//使用条件编译来检查是否已经定义了MAX_BINARY_POINT_VALUE宏。如果没有定义，则将其定义为4。 #endif #endif @@ -197,6 +215,11 @@ extern CHAR __init_array_end__; * 0xFFFF: max number of all software timers */ #ifndef OS_SWTMR_MAX_TIMERID +/*表示软件定时器ID的最大数量。 +默认值为((0xFFFF / KERNEL_SWTMR_LIMIT) * KERNEL_SWTMR_LIMIT)， +其中KERNEL_SWTMR_LIMIT表示系统中每个任务可以创建的最大软件定时器数。 +这个宏定义的作用是将可用的ID数量限制在一个整数倍的软件定时器数范围内， +这样可以更好地利用ID资源。*/ #define OS_SWTMR_MAX_TIMERID ((0xFFFF / KERNEL_SWTMR_LIMIT) * KERNEL_SWTMR_LIMIT) #endif /** @@ -204,6 +227,11 @@ extern CHAR __init_array_end__; * Maximum size of a software timer queue. The default value of LOSCFG_BASE_CORE_SWTMR_LIMIT is 16. */ #ifndef OS_SWTMR_HANDLE_QUEUE_SIZE +/*示软件定时器队列的最大大小。 +默认值为KERNEL_SWTMR_LIMIT， +也就是系统中每个任务可以同时管理的软件定时器数。 +这个宏定义的作用是限制任务能够管理的软件定时器数量， +以避免资源浪费和性能问题。*/ #define OS_SWTMR_HANDLE_QUEUE_SIZE KERNEL_SWTMR_LIMIT #endif #endif @@ -214,6 +242,10 @@ extern CHAR __init_array_end__; * Starting address of the system memory */ #ifndef OS_SYS_MEM_ADDR +/*__heap_start是在链接脚本中定义的符号， +表示内存池的起始地址。 +因此，OS_SYS_MEM_ADDR的值就是内存池的起始地址的指针， +可以通过该宏来访问系统内存池。*/ #define OS_SYS_MEM_ADDR (&__heap_start) #endif @@ -223,9 +255,11 @@ extern CHAR __init_array_end__; * Starting address of dynload heap */ #if defined (LOSCFG_KERNEL_NX) && defined (LOSCFG_KERNEL_DYNLOAD) -#define LOS_DL_HEAP_SIZE (LOSCFG_KERNLE_DYN_HEAPSIZE * 0x100000) -#define LOS_DL_HEAP_BASE (SYS_MEM_END - LOS_DL_HEAP_SIZE) +//如果这两个宏都被定义了，那么将动态加载模块堆的大小定义为 +#define LOS_DL_HEAP_SIZE (LOSCFG_KERNLE_DYN_HEAPSIZE * 0x100000)//(LOSCFG_KERNLE_DYN_HEAPSIZE * 0x100000) +#define LOS_DL_HEAP_BASE (SYS_MEM_END - LOS_DL_HEAP_SIZE)//SYS_MEM_END - LOS_DL_HEAP_SIZE，其中SYS_MEM_END表示系统内存池的结束地址 #else +//如果没有定义LOSCFG_KERNEL_NX和LOSCFG_KERNEL_DYNLOAD宏，则将动态加载模块堆的大小和起始地址都定义为0。 #define LOS_DL_HEAP_SIZE 0 #define LOS_DL_HEAP_BASE 0 #endif @@ -236,7 +270,7 @@ extern CHAR __init_array_end__; */ #ifndef OS_SYS_MEM_SIZE #define OS_SYS_MEM_SIZE ((g_sys_mem_addr_end) - \ - ((LOS_DL_HEAP_SIZE + ((UINTPTR)&__heap_start) + (64 - 1)) & ~(64 - 1))) + ((LOS_DL_HEAP_SIZE + ((UINTPTR)&__heap_start) + (64 - 1)) & ~(64 - 1)))//定义内存池的大小 #endif /****************************** fw Interface configuration **************************/ @@ -245,11 +279,12 @@ extern CHAR __init_array_end__; * The core number is one in non-SMP architecture. */ #ifdef LOSCFG_KERNEL_SMP +//LOSCFG_KERNEL_CORE_NUM 将被设置为 LOSCFG_KERNEL_SMP_CORE_NUM 的值；否则，LOSCFG_KERNEL_CORE_NUM 将被设置为 1。 #define LOSCFG_KERNEL_CORE_NUM LOSCFG_KERNEL_SMP_CORE_NUM #else #define LOSCFG_KERNEL_CORE_NUM 1 #endif - +//LOSCFG_KERNEL_CPU_MASK 被定义为用于表示 CPU 核心掩码的表达式。它使用了位运算，通过将 1 左移 LOSCFG_KERNEL_CORE_NUM 位，然后减去 1，来生成一个包含 LOSCFG_KERNEL_CORE_NUM 个 1 的二进制数。这个数字通常用于设置 CPU 亲和性，以确定线程可以运行在哪些 CPU 核心上。 #define LOSCFG_KERNEL_CPU_MASK ((1 << LOSCFG_KERNEL_CORE_NUM) - 1) /****************************** trace module configuration **************************/ @@ -259,6 +294,10 @@ extern CHAR __init_array_end__; */ #ifdef LOSCFG_KERNEL_TRACE #ifdef LOSCFG_RECORDER_MODE_OFFLINE +/*LOSCFG_KERNEL_TRACE 被定义的情况下，该代码块会被编译。 +如果同时定义了 LOSCFG_RECORDER_MODE_OFFLINE， +则 LOSTRACE_BUFFER_SIZE 会被设置为 LOSCFG_TRACE_BUFFER_SIZE 的值； +否则，LOSTRACE_BUFFER_SIZE 会被设置为 0。*/ #define LOS_TRACE_BUFFER_SIZE LOSCFG_TRACE_BUFFER_SIZE #else #define LOS_TRACE_BUFFER_SIZE 0 @@ -277,39 +316,44 @@ extern CHAR __init_array_end__; /** * Version number */ -#define _T(x) x -#define HW_LITEOS_SYSNAME "Huawei LiteOS" -#define HW_LITEOS_SEP " " -#define _V(v) _T(HW_LITEOS_SYSNAME)_T(HW_LITEOS_SEP)_T(v) +//这段代码是一组宏定义，用于定义操作系统的版本号和系统名称。 +#define _T(x) x//宏定义将传入的参数 x 原样返回，用于在宏定义中表示字符串。 +#define HW_LITEOS_SYSNAME "Huawei LiteOS"//宏定义为字符串 "Huawei LiteOS"，表示操作系统的名称。 +#define HW_LITEOS_SEP " "//宏定义为字符串 " "，表示名称和版本号之间的分隔符。 +#define _V(v) _T(HW_LITEOS_SYSNAME)_T(HW_LITEOS_SEP)_T(v)//宏定义通过将操作系统名称和版本号连接起来，生成一个完整的版本字符串。 -#define HW_LITEOS_VERSION "V200R005C20B053" -#define HW_LITEOS_VER _V(HW_LITEOS_VERSION"-SMP") +#define HW_LITEOS_VERSION "V200R005C20B053"//宏定义为字符串 "V200R005C20B053"，表示操作系统的具体版本号。 +#define HW_LITEOS_VER _V(HW_LITEOS_VERSION"-SMP")//宏定义使用了 _V 宏，将操作系统名称和版本号连接起来，形成类似 "Huawei LiteOS V200R005C20B053-SMP" 的完整版本号字符串。 /** * The Version number of Public */ -#define MAJ_V 5 -#define MIN_V 1 -#define REL_V 0 +#define MAJ_V 5//宏定义为整数 5，表示操作系统的主要版本号。 +#define MIN_V 1//宏定义为整数 1，表示操作系统的次要版本号。 +#define REL_V 0//宏定义为整数 0，表示操作系统的发布版本号。 /** * The release candidate version number */ -#define EXTRA_V 0 +//这些宏定义和函数声明用于管理操作系统的版本号，并提供了一种将版本号转换为字符串格式的机制。 +#define EXTRA_V 0//宏定义为整数 0，表示操作系统的额外版本号或候选版本号。 -#define VERSION_NUM(a, b, c) (((a) << 16) | ((b) << 8) | (c)) -#define HW_LITEOS_OPEN_VERSION_NUM VERSION_NUM(MAJ_V, MIN_V, REL_V) +#define VERSION_NUM(a, b, c) (((a) << 16) | ((b) << 8) | (c))//宏定义将主版本号 a、次版本号 b 和发布版本号 c 组合成一个无符号整数，通过位运算实现。 +#define HW_LITEOS_OPEN_VERSION_NUM VERSION_NUM(MAJ_V, MIN_V, REL_V)// 宏定义使用了 VERSION_NUM 宏，将主版本号、次版本号和发布版本号组成一个表示版本号的无符号整数。 -#define STRINGIFY_1(x) #x -#define STRINGIFY(x) STRINGIFY_1(x) +#define STRINGIFY_1(x) #x//宏定义将参数 x 转换为字符串。 +#define STRINGIFY(x) STRINGIFY_1(x)//宏定义调用 STRINGIFY_1 宏，将参数转换为字符串。 -#define HW_LITEOS_OPEN_VERSION_STRING STRINGIFY(MAJ_V) "." STRINGIFY(MIN_V) "." STRINGIFY(REL_V) +#define HW_LITEOS_OPEN_VERSION_STRING STRINGIFY(MAJ_V) "." STRINGIFY(MIN_V) "." STRINGIFY(REL_V)//宏定义使用了 STRINGIFY 宏，将主版本号、次版本号和发布版本号转换为形如 "5.1.0" 的字符串格式。 #if (EXTRA_V != 0) +/*不等于 0，则 HW_LITEOS_KERNEL_VERSION_STRING 宏定义为带有候选版本号的版本字符串； +否则，它被定义为不带候选版本号的版本字符串。*/ #define HW_LITEOS_KERNEL_VERSION_STRING HW_LITEOS_OPEN_VERSION_STRING "-rc" STRINGIFY(EXTRA_V) #else #define HW_LITEOS_KERNEL_VERSION_STRING HW_LITEOS_OPEN_VERSION_STRING #endif +//不等于 0，则 HW_LITEOS_KERNEL_VERSION_STRING 宏定义为带有候选版本号的版本字符串；否则，它被定义为不带候选版本号的版本字符串。 extern VOID OsStart(VOID); extern UINT32 OsMain(VOID); extern VOID *OsGetMainTask(VOID); diff --git a/src/kernel/include/los_cppsupport.h b/src/kernel/include/los_cppsupport.h index cdf3fd4..c02d5e4 100644 --- a/src/kernel/include/los_cppsupport.h +++ b/src/kernel/include/los_cppsupport.h @@ -47,6 +47,8 @@ extern "C" { * If LOS_CppSystemInit() is called in the first stage of scatter load, * this flag should be passed as the third parameter. */ +/*如果在散射加载的第一阶段调用 LOS_CppSystemInit（）， +则此标志应作为第三个参数传递。*/ #define BEFORE_SCATTER 0 /** @@ -54,6 +56,8 @@ extern "C" { * If LOS_CppSystemInit() is called in the second stage of scatter load, * this flag should be passed as the third parameter. */ +/*如果在散射加载的第二阶段调用 LOS_CppSystemInit（）， +则此标志应作为第三个参数传递。*/ #define AFTER_SCATTER 1 /** @@ -61,6 +65,8 @@ extern "C" { * If scatter load is disabled, this flag should be passed as the third * parameter when LOS_CppSystemInit() is called. */ +/*如果禁用了分散加载，则在调用 LOS_CppSystemInit（） 时， +应将此标志作为第三个参数传递。*/ #define NO_SCATTER 2 /** @@ -87,6 +93,16 @@ extern "C" { * * @since Huawei LiteOS V100R001C00 */ +//初始化操作系统C++运行环境的函数 +/*具体来说，LOS_CppSystemInit函数的主要工作包括： +调用全局静态对象的构造函数：在C++中， +全局静态对象的构造函数需要在程序开始运行前被调用。 +LOS_CppSystemInit函数会遍历全局静态对象列表， +并依次调用它们的构造函数。 +执行其他C++运行时环境的初始化工作： +除了全局静态对象的构造函数之外， +还可能需要执行其他与C++运行时环境相关的初始化工作。 +例如，可以初始化C++异常处理机制、动态内存分配器等。*/ extern INT32 LOS_CppSystemInit(UINTPTR initArrayStart, UINTPTR initArrayEnd, INT32 flag); #ifdef __cplusplus diff --git a/src/kernel/include/los_cpup.h b/src/kernel/include/los_cpup.h index 3591a26..690cea4 100644 --- a/src/kernel/include/los_cpup.h +++ b/src/kernel/include/los_cpup.h @@ -53,6 +53,9 @@ extern "C" { * * Solution: Decrease the maximum number of tasks. */ +/*在 CPU调度器模块中发生了内存不足的错误， +并且具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x00）生成的。 +这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/ #define LOS_ERRNO_CPUP_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x00) /** @@ -63,6 +66,9 @@ extern "C" { * * Solution: Check whether the pointer to the input parameter is usable. */ +/*在 CPU调度器模块中发生了空指针错误， +并且具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x01）生成的。 +这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/ #define LOS_ERRNO_CPUP_TASK_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x01) /** @@ -73,6 +79,9 @@ extern "C" { * * Solution: Check whether the CPU usage is initialized. */ +/*在 CPU调度器模块中发生了未初始化的错误， +具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x02）生成的。 +这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/ #define LOS_ERRNO_CPUP_NO_INIT LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x02) /** @@ -83,6 +92,9 @@ extern "C" { * * Solution: Check whether the number of threads is applicable for the current operation. */ +/*在 CPU调度器模块中发生了无效的最大数量错误， +具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x03）生成的。 +这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/ #define LOS_ERRNO_CPUP_MAXNUM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x03) /** @@ -93,6 +105,9 @@ extern "C" { * * Solution: Check whether the target thread is created. */ +/*在 CPU调度器模块中发生了线程未创建的错误， +具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x04）生成的。 +这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/ #define LOS_ERRNO_CPUP_THREAD_NO_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x04) /** @@ -103,12 +118,22 @@ extern "C" { * * Solution: Check whether the target task ID is applicable for the current operation. */ +/*在CPU调度器模块中发生了无效的任务ID错误， +具体的错误码是由 LOS_ERRNO_OS_ERROR 宏根据模块ID（LOS_MOD_CPUP）和错误码（0x05）生成的。 +这个错误码可以被用于在程序中标识和处理这个特定的错误情况。*/ #define LOS_ERRNO_CPUP_TSK_ID_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_CPUP, 0x05) /** * @ingroup los_cpup * The structure of the CPU usage information of all tasks. */ +/*用于描述CPU调度器的信息。 +结构体包含两个成员变量： +usStatus：表示任务的状态，是一个 16 位的无符号整数。 +uwUsage：表示所有任务的 CPU 使用率，是一个 32 位的无符号整数，单位为 permillage，即千分之一。 +在操作系统中，CPU 调度器会负责管理系统中各个任务的执行。 +CPUP_INFO_S 结构体则提供了一种方式， +可以帮助了解任务状态和系统 CPU 使用情况的信息。*/ typedef struct tagCpupInfo { UINT16 usStatus; /**< The task status. */ UINT32 uwUsage; /**< CPU usage of all tasks. It is a permillage. And the value range is [0,1000]. */ @@ -118,9 +143,13 @@ typedef struct tagCpupInfo { * @ingroup los_cpup * The time period which the CPU usage collects in. */ +//用于表示 CPU 使用率的时间范围。 enum { + //表示显示最近 10 秒钟的 CPU 使用率，值为0。 CPUP_LAST_TEN_SECONDS = 0, /**< Display CPU usage in the last ten seconds, the value is 0. */ + //表示显示最近 1 秒钟的 CPU 使用率，值为1。 CPUP_LAST_ONE_SECONDS = 1, /**< Display CPU usage in the last one second, the value is 1. */ + //表示显示从系统启动到现在的 CPU 使用率，值为 0xffff。 CPUP_ALL_TIME = 0xffff /**< Display CPU usage from system startup to now, the value is 0xffff. */ }; @@ -149,6 +178,7 @@ enum { * @see LOS_HistoryTaskCpuUsage | LOS_AllCpuUsage * @since Huawei LiteOS V100R001C00 */ +//获取历史系统CPU使用率。参数 mode 是用来指定获取 CPU 使用率的时间范围或者其他相关设置。 extern UINT32 LOS_HistorySysCpuUsage(UINT32 mode); /** @@ -182,6 +212,9 @@ extern UINT32 LOS_HistorySysCpuUsage(UINT32 mode); * @see LOS_HistorySysCpuUsage * @since Huawei LiteOS V100R001C00 */ +/*用于获取历史任务的CPU使用率。 +其中 taskId 参数表示任务的ID或标识符， +mode 参数可能表示获取CPU使用率的模式或配置选项。*/ extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskId, UINT32 mode); /** @@ -224,6 +257,10 @@ extern UINT32 LOS_HistoryTaskCpuUsage(UINT32 taskId, UINT32 mode); * * @since Huawei LiteOS V100R001C00 */ +/*用于获取系统中所有CPU的使用率信息。 +其中 maxNum 参数表示最大的CPU数量，cpupInfo 参数表示用于存储CPU使用率信息的结构体指针， +mode 参数可能表示获取CPU使用率的模式或配置选项， +flag 参数则可能表示其他的控制标志位。*/ extern UINT32 LOS_AllCpuUsage(UINT16 maxNum, CPUP_INFO_S *cpupInfo, UINT32 mode, UINT16 flag); /** @@ -244,6 +281,10 @@ extern UINT32 LOS_AllCpuUsage(UINT16 maxNum, CPUP_INFO_S *cpupInfo, UINT32 mode, * * @since Huawei LiteOS V100R001C00 */ +/*LOS_CpupReset 函数会遍历系统中所有任务和中断， +将它们的 CPU 使用率统计信息清零。 +这样，在下一次任务或中断执行时， +操作系统就会重新开始记录它们的 CPU 使用率。*/ extern VOID LOS_CpupReset(VOID); #ifdef __cplusplus diff --git a/src/kernel/include/los_err.h b/src/kernel/include/los_err.h index ff84c03..ef1f1dc 100644 --- a/src/kernel/include/los_err.h +++ b/src/kernel/include/los_err.h @@ -62,11 +62,12 @@ extern "C" { * * @since Huawei LiteOS V100R001C00 */ -typedef VOID (*LOS_ERRORHANDLE_FUNC)(CHAR *fileName, - UINT32 lineNo, - UINT32 errorNo, - UINT32 paraLen, - VOID *para); +//LOS_ERRORHANDLE_FUNC 是一个函数指针类型，它指向一个函数，该函数具有以下特征： +typedef VOID (*LOS_ERRORHANDLE_FUNC)(CHAR *fileName,//表示发生错误的文件名。 + UINT32 lineNo,//表示发生错误的行号。 + UINT32 errorNo,//表示错误代码或错误号。 + UINT32 paraLen,//表示附加参数的长度。 + VOID *para);//表示附加参数的指针。 /** * @ingroup los_err @@ -88,6 +89,15 @@ typedef VOID (*LOS_ERRORHANDLE_FUNC)(CHAR *fileName, * * @since Huawei LiteOS V100R001C00 */ +/*函数的作用是处理错误。当程序运行过程中发生错误时， +可以调用这个函数来进行错误处理，包括记录错误信息、输出错误日志等操作。 +传入的参数可以用于定位和描述错误的具体信息， +从而更好地进行错误分析和排查。 +CHAR *fileName：表示发生错误的文件名。 +UINT32 lineNo：表示发生错误的行号。 +UINT32 errorNo：表示错误码或错误类型。 +UINT32 paraLen：表示传递的参数长度。 +VOID *para：表示传递的参数。*/ extern UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo, UINT32 errorNo, UINT32 paraLen, VOID *para); diff --git a/src/kernel/include/los_errno.h b/src/kernel/include/los_errno.h index 9d05458..106b7ef 100644 --- a/src/kernel/include/los_errno.h +++ b/src/kernel/include/los_errno.h @@ -46,31 +46,31 @@ extern "C" { * @ingroup los_errno * OS error code flag. It is a 24-bit unsigned integer. Its value is 0x000000U. */ -#define LOS_ERRNO_OS_ID (0x00U << 16) +#define LOS_ERRNO_OS_ID (0x00U << 16)//宏定义为 0x00U << 16，表示操作系统相关的错误码。 /** * @ingroup los_errno * Define the error level as informative. It is a 32-bit unsigned integer. Its value is 0x00000000U. */ -#define LOS_ERRTYPE_NORMAL (0x00U << 24) +#define LOS_ERRTYPE_NORMAL (0x00U << 24)//宏定义表示错误级别为 "informative"（信息级别），其值为 0x00U << 24。 /** * @ingroup los_errno * Define the error level as warning. It is a 32-bit unsigned integer. Its value is 0x01000000U. */ -#define LOS_ERRTYPE_WARN (0x01U << 24) +#define LOS_ERRTYPE_WARN (0x01U << 24)//宏定义表示错误级别为 "warning"（警告级别），其值为 0x01U << 24。 /** * @ingroup los_errno * Define the error level as critical. It is a 32-bit unsigned integer. Its value is 0x02000000U. */ -#define LOS_ERRTYPE_ERROR (0x02U << 24) +#define LOS_ERRTYPE_ERROR (0x02U << 24)//宏定义表示错误级别为 "critical"（严重级别），其值为 0x02U << 24。 /** * @ingroup los_errno * Define the error level as fatal. It is a 32-bit unsigned integer. Its value is 0x03000000U. */ -#define LOS_ERRTYPE_FATAL (0x03U << 24) +#define LOS_ERRTYPE_FATAL (0x03U << 24)//宏定义表示错误级别为 "fatal"（致命级别），其值为 0x03U << 24。 /** * @ingroup los_errno @@ -82,6 +82,14 @@ extern "C" { *
  • 0-7 bits indicate the error code number. It is specified by ERRNO.
    • * */ +/*用于生成操作系统致命错误码。 +LOS_ERRTYPE_FATAL 表示错误级别为 "fatal"（致命级别），其值为 0x03U << 24。 +LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。 +(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。 +(UINT32)(ERRNO) 表示具体的错误码。 +将上述宏和位运算组合起来，LOS_ERRNO_OS_FATAL 宏可以生成一个操作系统致命错误码， +其格式为：错误级别（LOS_ERRTYPE_FATAL）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。 +通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。*/ #define LOS_ERRNO_OS_FATAL(MID, ERRNO) \ (LOS_ERRTYPE_FATAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) @@ -95,6 +103,15 @@ extern "C" { *
  • 0-7 bits indicate the error code number. It is specified by ERRNO.
    • * */ +/*这段代码定义了一个宏 LOS_ERRNO_OS_ERROR，用于生成操作系统严重错误码。 +该宏使用了以下几个宏和位运算操作： +LOS_ERRTYPE_ERROR 表示错误级别为 "critical"（严重级别），其值为 0x02U << 24。 +LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。 +(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。 +(UINT32)(ERRNO) 表示具体的错误码。 +将上述宏和位运算组合起来，LOS_ERRNO_OS_ERROR 宏可以生成一个操作系统严重错误码， +其格式为：错误级别（LOS_ERRTYPE_ERROR）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。 +通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。*/ #define LOS_ERRNO_OS_ERROR(MID, ERRNO) \ (LOS_ERRTYPE_ERROR | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) @@ -108,6 +125,15 @@ extern "C" { *
  • 0-7 bits indicate the error code number. It is specified by ERRNO.
    • * */ +/*这段代码定义了一个宏 LOS_ERRNO_OS_WARN，用于生成操作系统警告错误码。 +该宏使用了以下几个宏和位运算操作： +LOS_ERRTYPE_WARN 表示错误级别为 "warning"（警告级别），其值为 0x01U << 24。 +LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。 +(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。 +(UINT32)(ERRNO) 表示具体的错误码。 +将上述宏和位运算组合起来，LOS_ERRNO_OS_WARN 宏可以生成一个操作系统警告错误码， +其格式为：错误级别（LOS_ERRTYPE_WARN）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。 +通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。在发生警告级别的错误时，可以采取相应的处理措施以避免潜在问题的发生。*/ #define LOS_ERRNO_OS_WARN(MID, ERRNO) \ (LOS_ERRTYPE_WARN | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) @@ -121,13 +147,29 @@ extern "C" { *
  • 0-7 bits indicate the error code number. It is specified by ERRNO.
    • * */ +/*这段代码定义了一个宏 LOS_ERRNO_OS_NORMAL，用于生成操作系统普通错误码。 +该宏使用了以下几个宏和位运算操作： +LOS_ERRTYPE_NORMAL 表示错误级别为 "normal"（普通级别），其值为 0x00U << 24。 +LOS_ERRNO_OS_ID 表示操作系统相关的错误码，其值为 0x00U << 16。 +(UINT32)(MID) << 8 将参数 MID 左移 8 位，用于表示错误码的模块标识。 +(UINT32)(ERRNO) 表示具体的错误码。 +将上述宏和位运算组合起来，LOS_ERRNO_OS_NORMAL 宏可以生成一个操作系统普通错误码， +其格式为：错误级别（LOS_ERRTYPE_NORMAL）+ 错误码来源（LOS_ERRNO_OS_ID）+ 模块标识（MID）+ 具体错误码（ERRNO）。 +通过定义这样的宏，可以方便地生成不同类型的错误码，并根据错误码的不同属性进行分类和处理。在发生普通级别的错误时，可以根据需要进行相应的处理或记录。*/ #define LOS_ERRNO_OS_NORMAL(MID, ERRNO) \ (LOS_ERRTYPE_NORMAL | LOS_ERRNO_OS_ID | ((UINT32)(MID) << 8) | ((UINT32)(ERRNO))) /** * @ingroup los_errno * Define the ID of each module in kernel. The ID is used in error code. + * 在内核中定义每个模块的 ID。该 ID 用于错误代码。 */ +/*这段代码定义了一个枚举类型 LOS_MODULE_ID，它包含了一系列的模块标识符及其对应的数值。 +每个模块都有一个唯一的标识符，用于在代码中进行识别和引用。这些标识符的值是以十六进制表示的，比如 LOS_MOD_SYS 的值是 0x0，LOS_MOD_MEM 的值是 0x1，以此类推。 +在这个枚举类型中，最后一个标识符 LOS_MOD_BUTT 是一个结束标志，表示枚举的结束。 +通过使用这个枚举类型，你可以方便地使用这些模块标识符来表示、操作和传递不同的模块。 +例如，你可以使用 LOS_MOD_SYS 来表示系统模块，在代码中进行相关的操作或者判断。 +总之，这个枚举类型提供了一种简单而有序的方式来管理和使用各个模块的标识符。*/ enum LOS_MOUDLE_ID { LOS_MOD_SYS = 0x0, /**< System ID. Its value is 0x0. */ LOS_MOD_MEM = 0x1, /**< Dynamic memory module ID. Its value is 0x1. */ diff --git a/src/kernel/include/los_event.h b/src/kernel/include/los_event.h index 7f1f653..47abca9 100644 --- a/src/kernel/include/los_event.h +++ b/src/kernel/include/los_event.h @@ -47,19 +47,19 @@ extern "C" { * @ingroup los_event * Event reading mode: The task waits for all its expected events to occur. */ -#define LOS_WAITMODE_AND 4U +#define LOS_WAITMODE_AND 4U//该模式表示任务等待所有期望的事件发生。也就是说，任务只有当所有的事件都发生时才会继续执行。 /** * @ingroup los_event * Event reading mode: The task waits for any of its expected events to occur. */ -#define LOS_WAITMODE_OR 2U +#define LOS_WAITMODE_OR 2U//该模式表示任务等待任何一个期望的事件发生。也就是说，任务只要有任何一个事件发生就会继续执行。 /** * @ingroup los_event * Event reading mode: The event flag is immediately cleared after the event is read. */ -#define LOS_WAITMODE_CLR 1U +#define LOS_WAITMODE_CLR 1U//该模式表示在事件被读取后立即清除事件标志。也就是说，一旦任务读取了事件，事件标志就会被清除。 /** * @ingroup los_event @@ -69,6 +69,14 @@ extern "C" { * Value: 0x02001c00. * * Solution: Set bits excluding bit 25 of the event mask to events. + * 这段代码定义了一个错误码 LOS_ERRNO_EVENT_SETBIT_INVALID， + 表示事件设置位无效。在这个宏定义中使用了 LOS_ERRNO_OS_ERROR 宏， + 该宏通常用于定义操作系统相关的错误码。 + 在这里，LOS_MOD_EVENT 表示错误码所属的模块是事件模块， + 0x00 是该错误码在事件模块内部的具体编号。 + 通过使用这样的宏定义，可以方便地在代码中引用和传播错误码， + 同时也有助于对错误进行分类和定位。当某个操作导致事件设置位无效时， + 可以返回这个错误码，从而让调用者知道发生了什么问题并进行相应的处理。 */ #define LOS_ERRNO_EVENT_SETBIT_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x00) @@ -81,6 +89,13 @@ extern "C" { * Solution: Increase the waiting time for event reading, or make another task write a * mask for the event. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_TIMEOUT，表示事件读取超时。同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏，表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x01。 + +当某个任务等待事件时，如果设定了超时时间， +并且在该时间内没有等到事件发生，那么就会返回这个错误码， +告知调用者事件读取超时。 +这个错误码的定义可以帮助开发人员更好地判断和处理超时情况， +从而提高系统的稳定性和可靠性。*/ #define LOS_ERRNO_EVENT_READ_TIMEOUT LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x01) /** @@ -92,6 +107,13 @@ extern "C" { * * Solution: Pass in a valid EVENTMASK value. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_EVENTMASK_INVALID，表示事件掩码无效。 +同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏， +表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x02。 +事件掩码用于标识期望等待的事件，如果事件掩码无效， +则表示指定的事件掩码不符合规范或不可识别。当发生这种情况时， +可以返回这个错误码，告知调用者事件掩码无效。通过这个错误码的定义， +开发人员可以更好地检测和处理事件掩码相关的错误，从而提高系统的健壮性和可维护性。*/ #define LOS_ERRNO_EVENT_EVENTMASK_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x02) /** @@ -102,6 +124,15 @@ extern "C" { * * Solution: Read the event in a task. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_IN_INTERRUPT，表示在中断中进行事件读取。 +同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏， +表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x03。 +通常情况下，事件读取操作应该在任务上下文中进行，而不是在中断处理程序中执行。 +因为中断处理程序具有高优先级，可能会引起任务调度的竞争和冲突。 +当事件读取操作发生在中断上下文中时，就会返回这个错误码， +告知调用者在中断中进行了事件读取，这是不被支持的。 +通过这个错误码的定义，可以帮助开发人员及时发现并修复在中断上下文中执行事件读取的问题， +确保系统的正确运行和可靠性。*/ #define LOS_ERRNO_EVENT_READ_IN_INTERRUPT LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x03) /** @@ -115,6 +146,15 @@ extern "C" { * * Solution: Pass in a valid flag value. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_FLAGS_INVALID，表示事件标志无效。 +同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏， +表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x04。 +事件标志用于标识特定的事件或状态，在进行事件操作时需要使用有效的事件标志。 +当事件标志无效时，可能是因为传递了错误的标志参数或者标志参数不符合预期。 +当发生这种情况时，可以返回这个错误码，告知调用者事件标志无效。 +通过这个错误码的定义，可以帮助开发人员更好地检测和处理事件标志相关的错误， +从而提高系统的稳定性和可维护性。开发人员可以根据错误码来定位并修复导致事件标志无效的问题， +确保事件操作的准确性和可靠性。*/ #define LOS_ERRNO_EVENT_FLAGS_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x04) /** @@ -125,6 +165,15 @@ extern "C" { * * Solution: Unlock the task and read the event. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_IN_LOCK，表示在锁定状态下进行事件读取。 +同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏， +表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x05。 +通常情况下，事件读取操作应该在非锁定状态下进行， +因为在锁定状态下进行事件读取可能导致资源竞争和死锁等问题。 +当发生在锁定状态下进行事件读取的情况时，可以返回这个错误码， +告知调用者事件读取发生在不合适的锁定状态下。 +通过这个错误码的定义，开发人员可以及时发现并修复在锁定状态下执行事件读取的问题， +确保系统的正确运行和可靠性。这有助于提高系统的并发性和避免潜在的问题。*/ #define LOS_ERRNO_EVENT_READ_IN_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x05) /** @@ -135,6 +184,14 @@ extern "C" { * * Solution: Check whether the input parameter is null. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_PTR_NULL，表示传入的指针为空指针。 +同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏， +表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x06。 +在进行事件操作时，通常需要传递一些参数，如事件掩码、事件标志、事件句柄等。 +如果传递的指针为空指针，可能会导致访问非法内存、程序崩溃等问题。当发生这种情况时， +可以返回这个错误码，告知调用者传入的指针为空指针。 +通过这个错误码的定义，开发人员可以及时发现并修复传入空指针的问题， +确保系统的正确运行和可靠性。这有助于提高系统的稳定性和可维护性。*/ #define LOS_ERRNO_EVENT_PTR_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x06) /** @@ -147,6 +204,15 @@ extern "C" { * Solution: Read the event in a vailid task. * @deprecated This error code is obsolete since LiteOS 5.0.0. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_READ_IN_SYSTEM_TASK， +表示在系统任务中进行了事件读取操作。同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏， +表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x07。 +一般来说，系统任务具有较高的特权级别，并且用于操作系统内部的关键任务， +而不是用于普通的应用程序任务。因此，在系统任务中进行事件读取可能会引起不可预期的行为， +破坏系统的稳定性和可靠性。当发生在系统任务中进行事件读取的情况时， +可以返回这个错误码，告知调用者不应该在系统任务中执行事件读取操作。 +通过这个错误码的定义，可以帮助开发人员避免在系统任务中执行事件读取操作， +从而确保系统的正常运行和安全性。这有助于提高系统的稳定性和可维护性。*/ #define LOS_ERRNO_EVENT_READ_IN_SYSTEM_TASK LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x07) /** @@ -157,12 +223,29 @@ extern "C" { * * Solution: Check whether the event list is not empty. */ +/*这段代码定义了一个错误码 LOS_ERRNO_EVENT_SHOULD_NOT_DESTORY， +表示试图销毁不应该被销毁的事件。同样地，该宏定义中也使用了 LOS_ERRNO_OS_ERROR 宏， +表示该错误码属于操作系统的错误码，并且在事件模块内部的具体编号是 0x08。 +在事件处理过程中，有些事件可能不应该被销毁，因为它们可能仍在被其他任务或线程使用。 +如果试图销毁这些事件，可能会导致错误的行为，如资源泄漏、程序崩溃等问题。当发生这种情况时，可以返回这个错误码，告知调用者不应该销毁这些事件。 +通过这个错误码的定义，可以帮助开发人员避免销毁不应该被销毁的事件， +从而确保系统的正常运行和可靠性。这有助于提高系统的稳定性和可维护性。*/ #define LOS_ERRNO_EVENT_SHOULD_NOT_DESTORY LOS_ERRNO_OS_ERROR(LOS_MOD_EVENT, 0x08) /** * @ingroup los_event * Event control structure */ +/*这段代码定义了一个名为 tagEvent 的结构体，其中包含两个成员变量： +uwEventID：表示事件掩码，在事件控制块中指示已经逻辑处理的事件。 +通常用于标识事件的类型或属性。 +stEventList：是一个链表节点，用于将事件控制块进行链接，以支持对事件的管理操作。 +此外，通过 typedef 关键字将 struct tagEvent 重新定义为 EVENT_CB_S 类型， +同时定义了指向 EVENT_CB_S 结构体的指针类型 PEVENT_CB_S。 +这种结构体的设计通常用于事件管理模块，用于存储和管理事件相关的信息， +包括事件的标识和事件控制块的链表关系。 +开发人员可以使用这样的结构体来实现事件的创建、删除、等待和触发等功能， +从而更好地管理系统中的异步事件，提高系统的并发处理能力。*/ typedef struct tagEvent { UINT32 uwEventID; /**< Event mask in the event control block, indicating the event that has been logically processed. */ @@ -187,6 +270,15 @@ typedef struct tagEvent { * @see LOS_EventClear * @since Huawei LiteOS V100R001C00 */ +/*UINT32 LOS_EventInit(PEVENT_CB_S eventCB) 是 LiteOS 操作系统中的一个函数， +用于初始化事件控制块。 +参数 eventCB 是指向事件控制块结构体 EVENT_CB_S 的指针， +该结构体用于存储和管理事件相关的信息。 +函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。 +通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误，则返回对应的错误码。 +调用 LOS_EventInit 函数可以在使用事件之前对事件控制块进行初始化。 +通过此函数，可以确保事件控制块的初始状态正确， +并且可以安全地使用事件控制块进行事件的等待、触发和处理等操作。*/ extern UINT32 LOS_EventInit(PEVENT_CB_S eventCB); /** @@ -223,6 +315,25 @@ extern UINT32 LOS_EventInit(PEVENT_CB_S eventCB); * @see LOS_EventRead | LOS_EventWrite * @since Huawei LiteOS V100R001C00 */ +/*UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode) 是 LiteOS 操作系统中的一个函数，用于轮询事件。 + +参数说明: + +eventId 是一个指向无符号整数的指针，用于存储轮询到的事件ID。 +eventMask 是一个无符号整数，表示希望轮询的事件掩码。 +mode 是一个无符号整数，表示轮询模式，可以是以下几种值之一： +OS_EVENT_OR：轮询任意一个在事件掩码中设置的事件。 +OS_EVENT_AND：轮询所有在事件掩码中设置的事件。 +函数的返回值 UINT32 是一个无符号整数， +表示函数执行的结果或错误码。通常，如果函数成功执行，则返回 LOS_OK 表示成功； +如果发生错误，则返回对应的错误码。 +调用 LOS_EventPoll 函数可以轮询指定的事件，并根据指定的模式检查事件是否已经触发。 +如果有事件符合条件， +函数会将事件ID写入 eventId 指向的地址，并返回 LOS_OK；如果没有事件符合条件， +函数会根据轮询模式返回相应的错误码（如 LOS_ERRNO_EVENT_UNAVAILABLE）。 +此函数通常与其他事件管理函数配合使用，用于实现任务的等待和事件驱动的机制。 +通过轮询事件，任务可以根据不同的事件状态来决定后续的操作， +实现异步事件处理和任务调度的功能。*/ extern UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode); /** @@ -263,6 +374,24 @@ extern UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode); * @see LOS_EventPoll | LOS_EventWrite * @since Huawei LiteOS V100R001C00 */ +/*UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout) +是 LiteOS 操作系统中的一个函数，用于读取事件。 +参数说明: +eventCB 是一个指向事件控制块结构体 EVENT_CB_S 的指针，表示要读取的事件控制块。 +eventMask 是一个无符号整数，表示希望读取的事件掩码。 +mode 是一个无符号整数，表示读取模式，可以是以下几种值之一： +OS_EVENT_OR：等待任意一个在事件掩码中设置的事件。 +OS_EVENT_AND：等待所有在事件掩码中设置的事件。 +timeout 是一个无符号整数，表示超时时间，单位为系统时钟节拍数。 +如果超过指定时间仍未满足读取条件，则函数返回超时错误码。 +函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。 +通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误或超时，则返回对应的错误码。 +调用 LOS_EventRead 函数可以等待指定的事件触发，并根据指定的模式检查事件是否已经触发。 +如果有事件符合条件，函数会返回 LOS_OK；如果没有事件符合条件， +函数会根据读取模式等待事件的触发，直到满足条件或超时。在等待期间，任务可能会被挂起， +直到事件满足读取条件。 +此函数通常与其他事件管理函数配合使用，用于实现任务的等待和事件驱动的机制。通过读取事件， +任务可以根据不同的事件状态来决定后续的操作，实现异步事件处理和任务调度的功能。*/ extern UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout); /** @@ -311,6 +440,17 @@ extern UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events); * @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite * @since Huawei LiteOS V100R001C00 */ +/*UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events) 是 LiteOS 操作系统中的一个函数，用于写入事件。 +参数说明: +eventCB 是一个指向事件控制块结构体 EVENT_CB_S 的指针，表示要写入事件的事件控制块。 +events 是一个无符号整数，表示要写入的事件掩码。 +函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。 +通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误，则返回对应的错误码。 +调用 LOS_EventWrite 函数可以向指定的事件控制块写入事件。 +事件掩码表示一个或多个事件的状态，通过将相应的事件位设置为 1 来表示事件已经触发。 +当事件写入后，等待该事件的任务可能会被唤醒，根据事件的状态来决定后续的操作。 +此函数通常与其他事件管理函数配合使用，用于实现任务之间的同步与通信。 +通过写入事件，任务可以触发其他任务的执行，实现任务的协调与同步的功能。*/ extern UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events); /** @@ -333,6 +473,22 @@ extern UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events); * @see LOS_EventPoll | LOS_EventRead | LOS_EventWrite * @since Huawei LiteOS V100R001C00 */ +/*UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB) 是 LiteOS 操作系统中的一个函数，用于销毁事件控制块。 +参数说明: + +eventCB 是一个指向事件控制块结构体 EVENT_CB_S 的指针，表示要销毁的事件控制块。 +函数的返回值 UINT32 是一个无符号整数，表示函数执行的结果或错误码。 +通常，如果函数成功执行，则返回 LOS_OK 表示成功；如果发生错误，则返回对应的错误码。 + +调用 LOS_EventDestroy 函数可以销毁一个事件控制块，释放该事件控制块所占用的资源。 +一旦事件控制块被销毁，将不能再使用该事件控制块进行事件管理操作。 + +在实际应用中，当不再需要某个事件控制块时， +可以通过调用 LOS_EventDestroy 函数来释放相关资源，防止资源泄漏和系统资源浪费。 + +需要注意的是，在销毁事件控制块之前， +需要确保没有任务正在等待该事件或者使用该事件进行同步操作， +否则可能会导致系统行为异常。*/ extern UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB); #ifdef __cplusplus diff --git a/src/kernel/include/los_exc.h b/src/kernel/include/los_exc.h index 07c38e9..56ec150 100644 --- a/src/kernel/include/los_exc.h +++ b/src/kernel/include/los_exc.h @@ -61,6 +61,23 @@ extern "C" { * los_exc.h: the header file that contains the API declaration. * @since Huawei LiteOS V100R001C00 */ +/*LOS_Panic(const CHAR *fmt, ...) 是 LiteOS 操作系统中的一个函数，用于触发系统崩溃。 +参数说明: +fmt 是一个格式化字符串，表示崩溃信息的格式。 +... 是可变参数列表，根据格式化字符串 fmt 的要求，传入相应的参数。 +该函数没有返回值。 + +调用 LOS_Panic 函数会导致系统进入崩溃状态，即系统无法正常继续执行下去。 +通常情况下，该函数用于处理严重错误或不可恢复的异常情况， +以防止系统继续执行可能导致更严重问题的代码。 + +该函数允许通过格式化字符串传递一些额外的信息， +从而提供关于崩溃原因、位置或其他相关信息的描述。这 +些信息可能对于调试和排查问题非常有用。 + +需要注意的是，LOS_Panic 函数应该谨慎使用，仅在必要时使用。 +由于该函数触发系统崩溃，会导致系统停止运行并且无法继续恢复， +因此应该避免在正常的业务逻辑中调用该函数，以免造成不必要的系统中断。*/ VOID LOS_Panic(const CHAR *fmt, ...); /** @@ -79,8 +96,22 @@ VOID LOS_Panic(const CHAR *fmt, ...); * los_exc.h: the header file that contains the API declaration. * @since Huawei LiteOS V200R005C10 */ +/*VOID LOS_BackTrace(VOID) 是 LiteOS 操作系统中的函数，用于获取当前线程的函数调用栈信息。 +该函数没有参数，也没有返回值。 +调用 LOS_BackTrace 函数会获取当前线程的函数调用栈信息， +包括每个函数的调用地址以及相应的函数名。这些信息对于调试和排查问题非常有用， +可以帮助开发人员了解程序执行时的函数调用流程，定位问题所在。 + +通常情况下，LOS_BackTrace 函数用于调试目的，在程序出现异常或错误时， +可以通过打印函数调用栈信息来辅助分析问题原因。 +这对于定位崩溃、死锁或其他异常情况非常有帮助。 + +需要注意的是，LOS_BackTrace 函数的实现可能依赖于具体的硬件平台和编译器， +不同的平台和编译器可能会有不同的实现方式和限制。 +因此，在使用该函数时需要了解相关的平台和编译器特性，以确保获取到准确的函数调用栈信息。*/ extern VOID LOS_BackTrace(VOID); #define OsBackTrace LOS_BackTrace +//宏定义将 OsBackTrace 替换为 LOS_BackTrace，意味着在代码中使用 OsBackTrace 时，实际上是调用 LOS_BackTrace 函数。 /** * @ingroup los_exc @@ -99,9 +130,28 @@ extern VOID LOS_BackTrace(VOID); * los_exc.h: the header file that contains the API declaration. * @since Huawei LiteOS V100R001C00 */ +/*VOID LOS_TaskBackTrace(UINT32 taskID) 是 LiteOS 操作系统中的函数，用于获取指定任务的函数调用栈信息。 +参数说明: +taskID 是一个无符号整数，表示要获取函数调用栈信息的目标任务的任务ID。 +该函数没有返回值。 + +调用 LOS_TaskBackTrace 函数可以获取指定任务的函数调用栈信息， +包括每个函数的调用地址以及相应的函数名。这些信息对于调试和排查问题非常有用， +可以帮助开发人员了解指定任务执行时的函数调用流程，定位问题所在。 + +通常情况下，LOS_TaskBackTrace 函数用于调试目的，在特定任务出现异常或错误时， +可以通过打印该任务的函数调用栈信息来辅助分析问题原因。 +这对于定位崩溃、死锁或其他异常情况非常有帮助。 + +需要注意的是，LOS_TaskBackTrace 函数的实现可能依赖于具体的硬件平台和编译器， +不同的平台和编译器可能会有不同的实现方式和限制。 +因此，在使用该函数时需要了解相关的平台和编译器特性，以确保获取到准确的函数调用栈信息。 + +另外，需要确保指定的任务ID是有效的、存在的任务ID， +否则可能导致获取不到正确的函数调用栈信息。*/ extern VOID LOS_TaskBackTrace(UINT32 taskID); #define OsTaskBackTrace LOS_TaskBackTrace - +//宏定义将 OsTaskBackTrace 替换为 LOS_TaskBackTrace，意味着在代码中使用 OsTaskBackTrace 时，实际上是调用 LOS_TaskBackTrace 函数。 #ifdef LOSCFG_SHELL_EXCINFO_DUMP /** * @ingroup los_exc @@ -122,7 +172,14 @@ extern VOID LOS_TaskBackTrace(UINT32 taskID); * * @since Huawei LiteOS V200R005C10 */ +/*这是一个函数指针类型的定义。它定义了一个名为 LogReadWriteFunc 的函数指针类型， +该函数指针指向一个返回类型为 VOID 的函数， +函数参数为 UINTPTR startAddr、UINT32 space、UINT32 rwFlag 和 CHAR *buf。 +这种定义方式可以用来声明符合特定函数签名的函数指针类型，以便在代码中使用。*/ typedef VOID (*LogReadWriteFunc)(UINTPTR startAddr, UINT32 space, UINT32 rwFlag, CHAR *buf); +/*这是一个宏定义，将 log_read_write_fn 替换为 LogReadWriteFunc。 +注释中指出这是一个旧的API，并建议避免使用它。通过这个宏定义， +可以将 log_read_write_fn 在整个代码中替换为 LogReadWriteFunc，以达到简化和统一的目的。*/ #define log_read_write_fn LogReadWriteFunc /* old API since V200R002C00, please avoid use of it */ /** @@ -146,6 +203,22 @@ typedef VOID (*LogReadWriteFunc)(UINTPTR startAddr, UINT32 space, UINT32 rwFlag, * * @since Huawei LiteOS V200R002C00 */ +/*函数 LOS_ExcInfoRegHook 是在 LiteOS 操作系统中的一个函数。它的作用是设置异常信息寄存器的回调钩子函数。 + +该函数有四个参数： + +startAddr：异常信息寄存器的起始地址。 +space：异常信息寄存器的大小（以字节为单位）。 +buf：用于存储异常信息寄存器内容的缓冲区。 +hook：回调钩子函数，类型为 LogReadWriteFunc，即函数指针类型。 +具体来说，当发生异常时，LiteOS 将会调用 LOS_ExcInfoRegHook 函数， +并将异常信息寄存器的起始地址、大小和缓冲区作为参数传递给它。 +然后，在 LOS_ExcInfoRegHook 函数内部， +可以通过回调钩子函数 hook 来处理异常信息寄存器的内容。 + +这个功能可以用于自定义异常处理和异常信息记录。通过设置回调钩子函数， +可以在异常发生时获取并处理异常信息寄存器的内容， +以便进行进一步的分析或记录。*/ VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 space, CHAR *buf, LogReadWriteFunc hook); #endif diff --git a/src/kernel/include/los_hw.h b/src/kernel/include/los_hw.h index db1cf00..2105a21 100644 --- a/src/kernel/include/los_hw.h +++ b/src/kernel/include/los_hw.h @@ -59,9 +59,10 @@ extern "C" { * los_hw.h: the header file that contains the API declaration. * @since Huawei LiteOS V200R003C00 */ +/*这段代码定义了一个静态内联函数 LOS_CpuInfo，该函数返回一个指向常量字符的指针。*/ STATIC INLINE const CHAR *LOS_CpuInfo(VOID) { - return ArchCpuInfo(); + return ArchCpuInfo();//函数会根据当前的硬件平台调用对应的底层函数，以获取关于CPU的信息，例如型号、频率、核心数等等。这个函数的实现通常是与硬件平台紧密相关的，并且可能需要一些底层的寄存器读取或其他特定平台相关的操作。 } #ifdef __cplusplus diff --git a/src/kernel/include/los_hwi.h b/src/kernel/include/los_hwi.h index 95233f2..4603103 100644 --- a/src/kernel/include/los_hwi.h +++ b/src/kernel/include/los_hwi.h @@ -48,12 +48,16 @@ extern "C" { * @ingroup los_hwi * Count of interrupts. */ +/*这行代码声明了一个名为g_intCount的数组，但它的定义并不在当前的源文件中。 +关键字"extern"告诉编译器该数组是在其他地方定义的，这通常意味着它在其他源文件或库中。 +在链接阶段，编译器会去找到实际的g_intCount的定义，然后将其与当前的代码进行链接。*/ extern size_t g_intCount[]; /** * An interrupt is active. */ -extern size_t IntActive(VOID); + +extern size_t IntActive(VOID);//IntActive(VOID)函数是用于获取当前活动的中断数量的函数。该函数没有参数，返回类型为无符号整数类型（size_t）。 /** * @ingroup los_hwi @@ -61,6 +65,16 @@ extern size_t IntActive(VOID); * * @see OS_INT_INACTIVE */ + + /*在LiteOS操作系统中，#define OS_INT_ACTIVE IntActive() 是一个预处理指令，用来定义一个宏。它将OS_INT_ACTIVE 定义为调用 IntActive() 函数的结果。 + + 宏定义是一种在代码中使用的文本替换机制。在这种情况下， + 当代码中出现 OS_INT_ACTIVE 时，预处理器会将其替换为 IntActive() 函数的调用，从 + 而实际上就是将函数调用作为一个宏使用。 + + 这种宏定义的目的可能是为了简化代码书写或提高代码的可读性。 + 通过定义宏，可以通过简单的名称（OS_INT_ACTIVE）来表示复杂的函数调用（IntActive()）， + 从而使代码更加简洁和易于理解。*/ #define OS_INT_ACTIVE IntActive() /** @@ -71,6 +85,21 @@ extern size_t IntActive(VOID); * * @see OS_INT_ACTIVE */ +/*在LiteOS操作系统中，#define OS_INT_INACTIVE (!(OS_INT_ACTIVE)) 是一个预处理指令， +用来定义一个宏。它将OS_INT_INACTIVE 定义为对 OS_INT_ACTIVE 取反的结果。 + +具体来说，OS_INT_ACTIVE 是一个宏，表示调用 IntActive() 函数的结果。 +而 OS_INT_INACTIVE 是另一个宏，表示对 OS_INT_ACTIVE 取反的结果。 +在这种情况下，使用逻辑非运算符 ! 将 OS_INT_ACTIVE 的结果取反。 + +这个宏定义的目的可能是用于表示当前中断是否处于非活动状态。 +如果 OS_INT_ACTIVE 为真（非零），则表示中断处于活动状态； +而 OS_INT_INACTIVE 则为假（零），表示中断处于非活动状态。 + +通过这种方式定义宏，可以方便地在代码中判断中断状态并进行相应的处理。 +代码中使用 OS_INT_INACTIVE 可以更加直观地表示中断是否处于非活动状态， +提高代码的可读性和可维护性。 +*/ #define OS_INT_INACTIVE (!(OS_INT_ACTIVE)) /** @@ -78,6 +107,18 @@ extern size_t IntActive(VOID); * Highest priority of a hardware interrupt.This is an external parameter. * The priority range is [OS_HWI_PRIO_HIGHEST, OS_HWI_PRIO_HIGHEST + LOSCFG_HWI_PRIO_LIMIT - 1]. */ +/*在LiteOS操作系统中，#define OS_HWI_PRIO_HIGHEST 0 是一个预处理指令， +用来定义一个宏。它将 OS_HWI_PRIO_HIGHEST 定义为数字 0。 + +在LiteOS操作系统中，中断（Interrupt）也被称为硬件中断（Hardware Interrupt）， +简称为 HWI。HWI具有不同的优先级（Priority），优先级越高，中断响应的时间越短。 +OS_HWI_PRIO_HIGHEST 是一个表示最高中断优先级的宏，其值为 0。 + +在LiteOS操作系统中，中断的优先级是用数字表示的，数字越小表示优先级越高。 +因此，OS_HWI_PRIO_HIGHEST 表示的是最高中断优先级，也就是数字最小的中断优先级。 +在一些特定场景下，需要使用最高中断优先级， +这时候可以使用 OS_HWI_PRIO_HIGHEST 宏来表示最高中断优先级的数字值 0， +从而方便地进行代码编写。*/ #define OS_HWI_PRIO_HIGHEST 0 /** @@ -85,12 +126,36 @@ extern size_t IntActive(VOID); * This represents the interrupt priority range, the larger number, the lower priority, the interrupt processor is * modified uniformly. */ +/*在LiteOS操作系统中， +#define OS_HWI_PRIO_LOWEST (LOSCFG_HWI_PRIO_LIMIT - 1) 是一个预处理指令， +用来定义一个宏。它将 OS_HWI_PRIO_LOWEST 定义为 LOSCFG_HWI_PRIO_LIMIT 减去 1 的结果。 + +在LiteOS操作系统中，中断（Interrupt）也被称为硬件中断（Hardware Interrupt）， +简称为 HWI。HWI具有不同的优先级（Priority），优先级越高，中断响应的时间越短。OS_HWI_PRIO_LOWEST 是一个表示最低中断优先级的宏，其值为 LOSCFG_HWI_PRIO_LIMIT - 1。 + +LOSCFG_HWI_PRIO_LIMIT 是一个配置参数，用于表示系统支持的最大中断优先级数。 +因此，OS_HWI_PRIO_LOWEST 表示的是最低中断优先级，也就是数字最大的中断优先级， +其值等于最大中断优先级数减去 1。 +在一些特定场景下，需要使用最低中断优先级， +这时候可以使用 OS_HWI_PRIO_LOWEST 宏来表示最低中断优先级的数字值，从而方便地进行代码编写。*/ #define OS_HWI_PRIO_LOWEST (LOSCFG_HWI_PRIO_LIMIT - 1) /** * @ingroup los_hwi * The lower priority number, the higher priority, so OS_HWI_PRIO_LOWEST big than OS_HWI_PRIO_HIGHEST. */ +/*该宏接受一个参数 pri，表示要判断的中断优先级值。 +宏的定义使用了逻辑与运算符 && 和比较运算符 >=、<=。 +具体解释如下： + +((pri) >= OS_HWI_PRIO_HIGHEST) 表示判断 pri 是否大于等于最高中断优先级（OS_HWI_PRIO_HIGHEST）。如果 pri 大于等于最高中断优先级，则该条件结果为真（非零）；否则为假（零）。 +((pri) <= OS_HWI_PRIO_LOWEST) 表示判断 pri 是否小于等于最低中断优先级（OS_HWI_PRIO_LOWEST）。如果 pri 小于等于最低中断优先级，则该条件结果为真（非零）；否则为假（零）。 +整个宏定义将以上两个条件使用逻辑与运算符 && 连接起来， +即 (((pri) >= OS_HWI_PRIO_HIGHEST) && ((pri) <= OS_HWI_PRIO_LOWEST))。 +只有当 pri 同时满足大于等于最高中断优先级和小于等于最低中断优先级时， +该条件结果为真（非零），表示中断优先级有效；否则为假（零），表示中断优先级无效。 +这个宏的作用是在进行中断优先级的判断和设置时， +确保所使用的中断优先级值在有效范围内，避免出现错误的中断优先级设置。*/ #define HWI_PRI_VALID(pri) (((pri) >= OS_HWI_PRIO_HIGHEST) && ((pri) <= OS_HWI_PRIO_LOWEST)) /** @@ -105,6 +170,23 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用来定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。 +它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_NUM_INVALID 是一个表示无效中断号的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成， +它接受两个参数：模块号和错误码值。 +其中，LOS_MOD_HWI 表示HWI模块的模块号，0x00 表示错误码值。 +因此，LOS_ERRNO_HWI_NUM_INVALID 的值就是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_NUM_INVALID 是 LOS_ERRNO_HWI_NUM_INVALID 的别名。 +通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示无效中断号的错误码。 +这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在配置和使用中断时，如果遇到了无效的中断号， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_NUM_INVALID 或 OS_ERRNO_HWI_NUM_INVALID， +来判断中断号是否有效，进而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_NUM_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x00) #define OS_ERRNO_HWI_NUM_INVALID LOS_ERRNO_HWI_NUM_INVALID @@ -120,6 +202,22 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用来定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。 +它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_PROC_FUNC_NULL 是一个表示中断处理函数为空的错误码。该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成， +它接受两个参数：模块号和错误码值。 +其中，LOS_MOD_HWI 表示HWI模块的模块号，0x01 表示错误码值。 +因此，LOS_ERRNO_HWI_PROC_FUNC_NULL 的值就是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_PROC_FUNC_NULL 是 LOS_ERRNO_HWI_PROC_FUNC_NULL 的别名。 +通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断处理函数为空的错误码。 +这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在配置和使用中断时，如果中断处理函数为空， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_PROC_FUNC_NULL 或 OS_ERRNO_HWI_PROC_FUNC_NULL，来判断中断处理函数是否正确设置， +进而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_PROC_FUNC_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x01) #define OS_ERRNO_HWI_PROC_FUNC_NULL LOS_ERRNO_HWI_PROC_FUNC_NULL @@ -132,6 +230,18 @@ extern size_t IntActive(VOID); * Solution: This error code is not in use temporarily. * @deprecated This error code is obsolete since LiteOS 5.0.0. */ +/**/ +/*定义了一个错误码，表示硬件中断（HWI）回调函数不可用的情况。 +具体解释如下： + +OS_ERRNO_HWI_CB_UNAVAILABLE 是用来表示硬件中断（HWI）回调函数不可用的错误码。 +它由 LOS_ERRNO_OS_ERROR 宏生成，该宏接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x02 表示错误码值。 +因此，OS_ERRNO_HWI_CB_UNAVAILABLE 的值是根据模块号和错误码值计算得出的。 +这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在设置和注册中断回调函数时，如果回调函数不可用， +可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_CB_UNAVAILABLE，来判断回调函数的可用性， +从而进行相应的错误处理。*/ #define OS_ERRNO_HWI_CB_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x02) /** @@ -146,6 +256,21 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用来定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_NO_MEMORY 是一个表示无法分配内存的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。 +其中，LOS_MOD_HWI 表示HWI模块的模块号，0x03 表示错误码值。 +因此，LOS_ERRNO_HWI_NO_MEMORY 的值就是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_NO_MEMORY 是 LOS_ERRNO_HWI_NO_MEMORY 的别名。通过将其定义为相同的值， +可以在代码中使用更简洁的名称来表示无法分配内存的错误码。 +这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在设置和注册中断处理函数时，如果出现无法分配内存的情况， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_NO_MEMORY 或 OS_ERRNO_HWI_NO_MEMORY， +来判断内存是否分配成功，进而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_NO_MEMORY LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x03) #define OS_ERRNO_HWI_NO_MEMORY LOS_ERRNO_HWI_NO_MEMORY @@ -162,6 +287,22 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用于定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。 +它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_ALREADY_CREATED 是一个表示中断已经被创建的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x04 表示错误码值。 +因此，LOS_ERRNO_HWI_ALREADY_CREATED 的值是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_ALREADY_CREATED 是 LOS_ERRNO_HWI_ALREADY_CREATED 的别名。 +通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断已经被创建的错误码。 +这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在创建中断时，如果中断已经被创建， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_ALREADY_CREATED 或 OS_ERRNO_HWI_ALREADY_CREATED， +来判断中断是否已经存在，从而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_ALREADY_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x04) #define OS_ERRNO_HWI_ALREADY_CREATED LOS_ERRNO_HWI_ALREADY_CREATED @@ -177,6 +318,22 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用于定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。 +它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_PRIO_INVALID 是一个表示中断优先级无效的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x05 表示错误码值。 +因此，LOS_ERRNO_HWI_PRIO_INVALID 的值是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_PRIO_INVALID 是 LOS_ERRNO_HWI_PRIO_INVALID 的别名。 +通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断优先级无效的错误码。 +这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在设置中断优先级时，如果提供了无效的优先级值， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_PRIO_INVALID 或 OS_ERRNO_HWI_PRIO_INVALID，来判断优先级是否有效， +进而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_PRIO_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x05) #define OS_ERRNO_HWI_PRIO_INVALID LOS_ERRNO_HWI_PRIO_INVALID @@ -189,6 +346,18 @@ extern size_t IntActive(VOID); * Solution: This error code is not in use temporarily. * @deprecated This error code is obsolete since LiteOS 5.0.0. */ +/*是一个预处理指令，用于定义错误码。 + +该错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误， +具体来说是中断模式无效的错误。 +它是通过使用LiteOS提供的错误码宏 LOS_ERRNO_OS_ERROR 来定义的。 +该宏接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x06 表示错误码值。 +因此，OS_ERRNO_HWI_MODE_INVALID 的值是根据模块号和错误码值计算得出的。 +这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在设置中断模式时，如果提供了无效的模式值， +可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_MODE_INVALID ， +来判断模式是否有效，进而进行相应的错误处理。*/ #define OS_ERRNO_HWI_MODE_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x06) /** @@ -200,6 +369,19 @@ extern size_t IntActive(VOID); * Solution: This error code is not in use temporarily. * @deprecated This error code is obsolete since LiteOS 5.0.0. */ +/*是一个预处理指令，用于定义错误码。 + +该错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误， +具体来说是快速中断模式已经被创建的错误。 +它是通过使用LiteOS提供的错误码宏 LOS_ERRNO_OS_ERROR 来定义的。 +该宏接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x07 表示错误码值。 +因此，OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED 的值是根据模块号和错误码值计算得出的。 + +这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在创建快速中断模式时，如果该模式已经被创建， +可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED ， +来判断快速中断模式是否已经存在，从而进行相应的错误处理。*/ #define OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x07) /** @@ -214,6 +396,23 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用于定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断发生错误的错误。 +它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_INTERR 是一个表示硬件中断发生错误的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成， +它接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x08 表示错误码值。 +因此，LOS_ERRNO_HWI_INTERR 的值是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_INTERR 是 LOS_ERRNO_HWI_INTERR 的别名。 +通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示硬件中断发生错误的错误码。 +这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在中断处理函数中，如果硬件中断发生错误， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_INTERR 或 OS_ERRNO_HWI_INTERR， +来判断中断是否发生了错误，进而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_INTERR LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x08) #define OS_ERRNO_HWI_INTERR LOS_ERRNO_HWI_INTERR @@ -230,6 +429,22 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用于定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是共享中断错误的错误。 +它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_SHARED_ERROR 是一个表示共享中断错误的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x09 表示错误码值。 +因此，LOS_ERRNO_HWI_SHARED_ERROR 的值是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_SHARED_ERROR 是 LOS_ERRNO_HWI_SHARED_ERROR 的别名。 +通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示共享中断错误的错误码。 +这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在设置共享中断时，如果发生了错误， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_SHARED_ERROR 或 OS_ERRNO_HWI_SHARED_ERROR， +来判断共享中断是否设置成功，进而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_SHARED_ERROR LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x09) #define OS_ERRNO_HWI_SHARED_ERROR LOS_ERRNO_HWI_SHARED_ERROR @@ -242,6 +457,20 @@ extern size_t IntActive(VOID); * Solution: This error code is not in use temporarily. * @deprecated This error code is obsolete since LiteOS 5.0.0. */ +/*是一个预处理指令，用于定义错误码。 + +这个错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断参数无效的错误。 +它是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +OS_ERRNO_HWI_ARG_INVALID 是一个表示硬件中断参数无效的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x0a 表示错误码值。 +因此，OS_ERRNO_HWI_ARG_INVALID 的值是根据模块号和错误码值计算得出的。 +这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在注册硬件中断处理函数时，如果传递给函数的参数无效， +可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_ARG_INVALID，来判断参数是否有效， +进而进行相应的错误处理。*/ #define OS_ERRNO_HWI_ARG_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x0a) /** @@ -257,6 +486,22 @@ extern size_t IntActive(VOID); *
  • Please use macros starting with LOS, and macros starting with OS will not be supported.
    • * */ +/*是两个预处理指令，用于定义错误码。 + +这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断号未创建的错误。 +它们是通过使用LiteOS提供的错误码宏来定义的。 +具体解释如下： + +LOS_ERRNO_HWI_HWINUM_UNCREATE 是一个表示硬件中断号未创建的错误码。 +该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。 +在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x0b 表示错误码值。 +因此，LOS_ERRNO_HWI_HWINUM_UNCREATE 的值是根据模块号和错误码值计算得出的。 +OS_ERRNO_HWI_HWINUM_UNCREATE 是 LOS_ERRNO_HWI_HWINUM_UNCREATE 的别名。 +通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示硬件中断号未创建的错误码。 +这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。 +例如，在请求处理某个硬件中断时，如果指定的中断号未创建， +可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_HWINUM_UNCREATE 或 OS_ERRNO_HWI_HWINUM_UNCREATE， +来判断中断号是否有效，进而进行相应的错误处理。*/ #define LOS_ERRNO_HWI_HWINUM_UNCREATE LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x0b) #define OS_ERRNO_HWI_HWINUM_UNCREATE LOS_ERRNO_HWI_HWINUM_UNCREATE @@ -264,18 +509,21 @@ extern size_t IntActive(VOID); * @ingroup los_hwi * Define the type HWI_HANDLE_T for a hardware interrupt number, the type is an unsigned int. */ +//这行代码定义了一个新的类型 HWI_HANDLE_T，它被定义为 UINT32，即无符号32位整数。在这里，HWI_HANDLE_T 被用来表示硬件中断的句柄或标识符。 typedef UINT32 HWI_HANDLE_T; /** * @ingroup los_hwi * Define the type HWI_PRIOR_T for a hardware interrupt priority, the type is an unsigned short. */ +//这行代码定义了一个新的类型 HWI_PRIOR_T，它被定义为 UINT16，即无符号16位整数。在这里，HWI_PRIOR_T 被用来表示硬件中断的优先级。 typedef UINT16 HWI_PRIOR_T; /** * @ingroup los_hwi * Define the type HWI_MODE_T for hardware interrupt mode configurations, the type is an unsigned short. */ +//这行代码定义了一个新的类型 HWI_MODE_T，它被定义为 UINT16，即无符号16位整数。在这里，HWI_MODE_T 被用来表示硬件中断的模式配置。 typedef UINT16 HWI_MODE_T; /** @@ -283,6 +531,9 @@ typedef UINT16 HWI_MODE_T; * Define the type HWI_ARG_T for the parameter used for the hardware interrupt creation function. * The function of this parameter varies among platforms. */ +/*这行代码定义了一个新的类型 HWI_ARG_T，它被定义为 UINTPTR， +即一个无符号整数，其大小与指针大小相同。 +在这里，HWI_ARG_T 被用来表示硬件中断创建函数的参数，其具体含义会因平台而异。*/ typedef UINTPTR HWI_ARG_T; /** @@ -303,6 +554,8 @@ typedef UINTPTR HWI_ARG_T; * @see LOS_HwiCreate * @since Huawei LiteOS V100R001C00 */ +/*这行代码定义了一个函数指针类型 HWI_PROC_FUNC，它指向一个没有参数和返回值的函数。 +在这里，HWI_PROC_FUNC 被用来表示硬件中断处理函数的类型。*/ typedef VOID (*HWI_PROC_FUNC)(VOID); /** @@ -311,12 +564,22 @@ typedef VOID (*HWI_PROC_FUNC)(VOID); * * The flag only used by the kernel as part of the IRQ handling routines. */ +/*这个宏定义了一个常量 IRQF_SHARED，其值为 0x8000U。 +在这里，IRQF_SHARED 用于表示一个共享的硬件中断。*/ #define IRQF_SHARED 0x8000U /** * @ingroup los_hwi * The hardware interrupt parameter for #LOS_HwiDelete and interrupt handler in #LOS_HwiCreate. */ +/*这个代码定义了一个名为 HWI_IRQ_PARAM_S 的结构体类型，结构体内包含了以下成员： +int swIrq: 表示中断号的整数变量。 +VOID *pDevId: 表示触发中断的设备ID的指针变量。 +const CHAR *pName: 表示中断名称的指针变量。 + +这个结构体类型 HWI_IRQ_PARAM_S 用作 LOS_HwiDelete 函数和 LOS_HwiCreate 函数中的硬件中断参数。 +通过使用这个结构体， +可以传递中断号、设备ID和中断名称等信息给函数，以进行相应的操作或处理。*/ typedef struct tagIrqParam { int swIrq; /**< The interrupt number */ VOID *pDevId; /**< The pointer to the device ID that launches the interrupt */ @@ -340,6 +603,27 @@ typedef struct tagIrqParam { * @see LOS_IntRestore * @since Huawei LiteOS V100R001C00 */ +/*这段代码定义了一个静态内联函数 LOS_IntLock()，具体解释如下： + +STATIC INLINE： + +STATIC 关键字指示该函数的作用域为当前文件，在其他文件中不可见。 +INLINE 关键字告诉编译器将该函数的代码插入到调用处，而不是生成函数调用。 +UINT32： + +UINT32 表示返回值类型为无符号32位整数。 +LOS_IntLock(VOID)： + +LOS_IntLock 是函数的名称，它接受一个 VOID 参数，表示没有输入参数。 +return ArchIntLock();： + +这行代码调用了 ArchIntLock() 函数，并将其返回值作为 LOS_IntLock() 函数的返回值。 +ArchIntLock() 是一个硬件相关的函数，用于禁用中断，并返回之前的中断状态。 +因为函数声明为内联函数且函数体非常简单， +所以编译器会在调用处直接插入 ArchIntLock() 的代码，提高执行效率。 +总结：LOS_IntLock() 函数是一个内联函数， +它调用底层的 ArchIntLock() 函数来禁用中断，并返回之前的中断状态。 +这个函数的目的是为了保护关键代码区域，防止被中断打断，以确保数据的一致性和可靠性。*/ STATIC INLINE UINT32 LOS_IntLock(VOID) { return ArchIntLock(); @@ -361,6 +645,13 @@ STATIC INLINE UINT32 LOS_IntLock(VOID) * * @see LOS_IntLock */ +/*return ArchIntUnlock();： + +这行代码调用了 ArchIntUnlock() 函数，并将其返回值作为 LOS_IntUnLock() 函数的返回值。 +ArchIntUnlock() 是一个硬件相关的函数，用于恢复之前被禁用的中断状态。 +总结：LOS_IntUnLock() 函数是一个内联函数， +它调用底层的 ArchIntUnlock() 函数来恢复之前被禁用的中断状态。 +这个函数的目的是为了在临界区执行完毕后，恢复中断，允许其他中断事件发生。*/ STATIC INLINE UINT32 LOS_IntUnLock(VOID) { return ArchIntUnlock(); @@ -384,6 +675,14 @@ STATIC INLINE UINT32 LOS_IntUnLock(VOID) * @see LOS_IntLock * @since Huawei LiteOS V100R001C00 */ +/*ArchIntRestore(intSave);： + +这行代码调用了 ArchIntRestore() 函数，将之前保存的中断状态作为参数传递给它。 +ArchIntRestore() 是一个硬件相关的函数，用于根据传入的中断状态值恢复中断。 +总结：LOS_IntRestore() 函数是一个内联函数， +它调用底层的 ArchIntRestore() 函数来根据之前保存的中断状态恢复中断。 +这个函数的目的是在一段被禁用中断的代码执行完毕后，恢复中断状态，允许其他中断事件发生。 +由于函数没有返回值，所以不会返回任何结果。*/ STATIC INLINE VOID LOS_IntRestore(UINT32 intSave) { ArchIntRestore(intSave); @@ -430,11 +729,11 @@ STATIC INLINE VOID LOS_IntRestore(UINT32 intSave) * @see LOS_HwiDelete * @since Huawei LiteOS V100R001C00 */ -extern UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum, - HWI_PRIOR_T hwiPrio, - HWI_MODE_T hwiMode, - HWI_PROC_FUNC hwiHandler, - HWI_IRQ_PARAM_S *irqParam); +extern UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,//表示中断号或中断向量的标识。 + HWI_PRIOR_T hwiPrio,//表示中断的优先级。 + HWI_MODE_T hwiMode,//表示中断的模式（如边沿触发、电平触发等）。 + HWI_PROC_FUNC hwiHandler,//表示中断处理函数的指针。 + HWI_IRQ_PARAM_S *irqParam);//表示中断参数的结构体指针。 /** * @ingroup los_hwi @@ -470,6 +769,9 @@ extern UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum, * @see LOS_HwiCreate * @since Huawei LiteOS V100R001C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中删除一个中断处理程序。 +/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要删除的中断号或中断向量的标识。 +HWI_IRQ_PARAM_S *irqParam 是函数的第二个参数，表示中断参数的结构体指针。*/ extern UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam); /** @@ -492,6 +794,8 @@ extern UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam); * * @since Huawei LiteOS V200R005C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中触发一个指定的中断。 +//HWI_HANDLE_T hwiNum 是函数的参数，表示要触发的中断号或中断向量的标识。 extern UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum); /** @@ -513,6 +817,10 @@ extern UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum); * * @since Huawei LiteOS V200R005C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中清除（复位）一个指定的中断。 +/*HWI_HANDLE_T hwiNum 是函数的参数，表示要清除的中断号或中断向量的标识。 +函数的作用是根据指定的中断号，将相应的中断标志位清除，即将中断状态复位。 +通过调用该函数，可以清除中断触发后的状态，以便重新准备下一次中断处理。*/ extern UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum); /** @@ -536,6 +844,10 @@ extern UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum); * @see LOS_HwiDisable * @since Huawei LiteOS V200R005C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中使能（启用）一个指定的中断。 +/*HWI_HANDLE_T hwiNum 是函数的参数，表示要使能的中断号或中断向量的标识。 +函数的作用是根据指定的中断号，将相应的中断使能位设置为有效，即启用该中断。 +启用中断后，当满足中断触发条件时，系统将会跳转执行对应的中断处理程序。*/ extern UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum); /** @@ -558,6 +870,10 @@ extern UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum); * @see LOS_HwiEnable * @since Huawei LiteOS V200R005C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中禁用（关闭）一个指定的中断。 +/*HWI_HANDLE_T hwiNum 是函数的参数，表示要禁用的中断号或中断向量的标识。 +函数的作用是根据指定的中断号，将相应的中断使能位设置为无效，即禁用该中断。 +禁用中断后，即使满足中断触发条件，系统也不会跳转执行对应的中断处理程序。*/ extern UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum); #ifdef LOSCFG_KERNEL_SMP @@ -582,6 +898,11 @@ extern UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum); * * @since Huawei LiteOS V200R005C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中向指定的处理器发送中断请求。 +/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要发送的中断号或中断向量的标识。 +UINT32 cpuMask 是函数的第二个参数，表示中断发送的目标处理器掩码，用于指定将中断发送到哪些处理器上。 +函数的作用是向指定的处理器发送中断请求， +即通过中断控制器向目标处理器发送中断信号，触发相应的中断处理操作。*/ extern UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask); /** @@ -605,6 +926,12 @@ extern UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask); * * @since Huawei LiteOS V200R005C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中设置指定中断的亲和性（Affinity）。 +/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要设置亲和性的中断号或中断向量的标识。 +UINT32 cpuMask 是函数的第二个参数，表示要设置的中断亲和性掩码，用于指定该中断可以在哪些处理器上执行。 +函数的作用是设置指定中断的亲和性，即将中断与特定的处理器相关联。当中断被触发时， +只有与中断亲和性相关的处理器才会尝试执行中断处理程序， +从而避免了不必要的中断传递和处理开销。*/ extern UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask); #endif /* LOSCFG_KERNEL_SMP */ @@ -632,6 +959,11 @@ extern UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask); * @see None * @since Huawei LiteOS V200R005C00 */ +//是一个函数声明，用于在 LiteOS 操作系统中设置指定中断的优先级（Priority）。 +/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要设置优先级的中断号或中断向量的标识。 +HWI_PRIOR_T priority 是函数的第二个参数，表示要设置的中断优先级。 +函数的作用是设置指定中断的优先级，即确定中断在系统中的相对执行优先级。 +较高优先级的中断将优先获得处理器资源，并在其他中断之前得到响应和执行。*/ extern UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority); #ifdef LOSCFG_KERNEL_LOWPOWER @@ -652,6 +984,10 @@ extern UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority); * @see None. * @since Huawei LiteOS V200R005C10 */ +//是一个函数指针类型的定义。 +/*这部分定义了函数指针所指向的函数的参数列表，其中包含一个名为 hwiNum 的参数，其类型为 HWI_HANDLE_T。 +因此，整体来说，typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum) 定义了一个函数指针类型 WAKEUPFROMINTHOOK， +它指向一个不返回数值的函数，并且该函数接受一个 HWI_HANDLE_T 类型的参数 hwiNum。*/ typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum); /** @@ -671,6 +1007,11 @@ typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum); * @see None. * @since Huawei LiteOS V200R005C10 */ +//是用于注册中断唤醒钩子函数的外部声明。 +/*WAKEUPFROMINTHOOK hook 是函数的参数，它是一个指向中断唤醒钩子函数的指针。 +函数的作用是注册中断唤醒钩子函数， +即将指定的函数指针（指向中断唤醒处理函数的指针）注册到系统中， +以便在特定的中断事件发生时执行相应的处理操作。*/ extern VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook); #endif