p2gpamesw
/
LiteOS-Reading
2
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

11.27

Browse Source
pull/1/head
tree 1 year ago
parent 99c01f46b7
commit a5ed7a0caa
11 changed files with 170 additions and 124 deletions
Show Stats Download Patch File Download Diff File

12
src/kernel/base/los_bitmap.c
Unescape View File

@ -26,6 +26,10 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这是一个位图（bitmap）的实现，用于对位图进行设置、清除和获取最高/最低位的操作。
该位图使用一个32位无符号整数（UINT32）来表示，每一位都代表一个标记
函数通过位运算来实现对位图的操作，其中包括左移、按位与、按位或、按位取反等操作。*/
#include "los_bitmap.h" #include "los_bitmap.h"
#include "los_toolchain.h" #include "los_toolchain.h"
@ -36,7 +40,7 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#define OS_BITMAP_MASK 0x1FU #define OS_BITMAP_MASK 0x1FU
//LOS_BitmapSet：将指定位置的位设置为1
VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos) VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos)
{ {
if (bitmap == NULL) { if (bitmap == NULL) {
@ -45,7 +49,7 @@ VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos)
*bitmap |= 1U << (pos & OS_BITMAP_MASK); *bitmap |= 1U << (pos & OS_BITMAP_MASK);
} }
//LOS_BitmapClr：将指定位置的位清除为0
VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos) VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos)
{ {
if (bitmap == NULL) { if (bitmap == NULL) {
@ -54,7 +58,7 @@ VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos)
*bitmap &= ~(1U << (pos & OS_BITMAP_MASK)); *bitmap &= ~(1U << (pos & OS_BITMAP_MASK));
} }
//LOS_HighBitGet：获取位图中最高位（值为1的位置）的索引
UINT16 LOS_HighBitGet(UINT32 bitmap) UINT16 LOS_HighBitGet(UINT32 bitmap)
{ {
if (bitmap == 0) { if (bitmap == 0) {
@ -63,7 +67,7 @@ UINT16 LOS_HighBitGet(UINT32 bitmap)
return (OS_BITMAP_MASK - CLZ(bitmap)); return (OS_BITMAP_MASK - CLZ(bitmap));
} }
//LOS_LowBitGet：获取位图中最低位（值为1的位置）的索引
UINT16 LOS_LowBitGet(UINT32 bitmap) UINT16 LOS_LowBitGet(UINT32 bitmap)
{ {
if (bitmap == 0) { if (bitmap == 0) {

8
src/kernel/base/los_err.c
Unescape View File

@ -25,7 +25,8 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这段代码是关于错误处理的相关功能，包括注册错误处理函数和执行错误处理的函数。
通过以下接口，用户可以自定义错误处理函数，并在发生错误时进行相应的处理操作。这样可以增强系统的健壮性和容错性，更好地应对各种错误情况。*/
#include "los_err.h" #include "los_err.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -35,8 +36,9 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* Hook function for error handling. */ /* Hook function for error handling. */
//g_usrErrFunc：全局变量，用于保存用户注册的错误处理函数
LITE_OS_SEC_BSS LOS_ERRORHANDLE_FUNC g_usrErrFunc; LITE_OS_SEC_BSS LOS_ERRORHANDLE_FUNC g_usrErrFunc;
//LOS_ErrHandle：用于执行错误处理的函数，当系统出现错误时会调用该函数来处理错误信息
LITE_OS_SEC_TEXT_INIT UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo, UINT32 errorNo, LITE_OS_SEC_TEXT_INIT UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo, UINT32 errorNo,
UINT32 paraLen, VOID *para) UINT32 paraLen, VOID *para)
{ {
@ -46,7 +48,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_ErrHandle(CHAR *fileName, UINT32 lineNo, UINT32
return LOS_OK; return LOS_OK;
} }
//LOS_RegErrHandle：用于注册错误处理函数的接口，用户可以通过该函数注册自定义的错误处理函数
LITE_OS_SEC_TEXT_INIT VOID LOS_RegErrHandle(LOS_ERRORHANDLE_FUNC func) LITE_OS_SEC_TEXT_INIT VOID LOS_RegErrHandle(LOS_ERRORHANDLE_FUNC func)
{ {
g_usrErrFunc = func; g_usrErrFunc = func;

34
src/kernel/base/los_event.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这段代码是关于事件管理的实现，包括事件的初始化、读取、写入、清除等操作。*/
#include "los_event_pri.h" #include "los_event_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
#include "los_spinlock.h" #include "los_spinlock.h"
@ -38,7 +38,7 @@
extern "C" { extern "C" {
#endif #endif
#endif /* __cplusplus */ #endif /* __cplusplus */
//LOS_EventInit()函数用于初始化事件控制块（eventCB），并将事件ID、事件列表等属性设置为初始值
LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB) LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB)
{ {
UINT32 intSave; UINT32 intSave;
@ -55,7 +55,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB)
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
return LOS_OK; return LOS_OK;
} }
//OsEventParamCheck()函数用于检查参数的有效性，包括事件掩码（eventMask）、模式（mode）等
LITE_OS_SEC_TEXT STATIC UINT32 OsEventParamCheck(const VOID *ptr, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT STATIC UINT32 OsEventParamCheck(const VOID *ptr, UINT32 eventMask, UINT32 mode)
{ {
if (ptr == NULL) { if (ptr == NULL) {
@ -75,16 +75,17 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventParamCheck(const VOID *ptr, UINT32 eventMa
!(mode & (LOS_WAITMODE_OR | LOS_WAITMODE_AND))) { !(mode & (LOS_WAITMODE_OR | LOS_WAITMODE_AND))) {
return LOS_ERRNO_EVENT_FLAGS_INVALID; return LOS_ERRNO_EVENT_FLAGS_INVALID;
} }
//指针非空，事件掩码非0，事件掩码不包含LOS_ERRTYPE_ERROR标志位，模式合法
return LOS_OK; return LOS_OK;
} }
//OsEventPoll()函数用于轮询事件，根据指定的事件掩码和模式判断是否满足条件
LITE_OS_SEC_TEXT STATIC UINT32 OsEventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT STATIC UINT32 OsEventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode)
{ {
UINT32 ret = 0; UINT32 ret = 0;
LOS_ASSERT(ArchIntLocked()); LOS_ASSERT(ArchIntLocked());
LOS_ASSERT(LOS_SpinHeld(&g_taskSpin)); LOS_ASSERT(LOS_SpinHeld(&g_taskSpin));
if (mode & LOS_WAITMODE_OR) { if (mode & LOS_WAITMODE_OR) {
if ((*eventId & eventMask) != 0) { if ((*eventId & eventMask) != 0) {
ret = *eventId & eventMask; ret = *eventId & eventMask;
@ -101,7 +102,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventPoll(UINT32 *eventId, UINT32 eventMask, UI
return ret; return ret;
} }
//OsEventReadCheck()函数用于检查事件读取操作的参数有效性，包括事件控制块（eventCB）、事件掩码（eventMask）、模式（mode）等
LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadCheck(const PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadCheck(const PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode)
{ {
UINT32 ret; UINT32 ret;
@ -122,7 +123,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadCheck(const PEVENT_CB_S eventCB, UINT3
} }
return LOS_OK; return LOS_OK;
} }
//OsEventReadImp()函数是事件读取的实现，根据指定的事件掩码和模式进行轮询，并根据超时时间和是否只读取一次进行相应的操作
LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode,
UINT32 timeout, BOOL once, UINT32 *intSave) UINT32 timeout, BOOL once, UINT32 *intSave)
{ {
@ -165,7 +166,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventReadImp(PEVENT_CB_S eventCB, UINT32 eventM
} }
return ret; return ret;
} }
//OsEventRead()函数是对外提供的事件读取接口，调用OsEventReadCheck()和OsEventReadImp()实现事件的读取操作
LITE_OS_SEC_TEXT STATIC UINT32 OsEventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, LITE_OS_SEC_TEXT STATIC UINT32 OsEventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode,
UINT32 timeout, BOOL once) UINT32 timeout, BOOL once)
{ {
@ -184,7 +185,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventRead(PEVENT_CB_S eventCB, UINT32 eventMask
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return ret; return ret;
} }
//OsEventWrite()函数用于向事件控制块中写入指定的事件
LITE_OS_SEC_TEXT STATIC UINT32 OsEventWrite(PEVENT_CB_S eventCB, UINT32 events, BOOL once) LITE_OS_SEC_TEXT STATIC UINT32 OsEventWrite(PEVENT_CB_S eventCB, UINT32 events, BOOL once)
{ {
LosTaskCB *resumedTask = NULL; LosTaskCB *resumedTask = NULL;
@ -230,7 +231,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsEventWrite(PEVENT_CB_S eventCB, UINT32 events,
} }
return LOS_OK; return LOS_OK;
} }
//LOS_EventPoll()函数是对外提供的事件轮询接口，调用OsEventParamCheck()和OsEventPoll()实现事件的轮询操作
LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode) LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32 mode)
{ {
UINT32 ret; UINT32 ret;
@ -246,17 +247,17 @@ LITE_OS_SEC_TEXT UINT32 LOS_EventPoll(UINT32 *eventId, UINT32 eventMask, UINT32
SCHEDULER_UNLOCK(intSave); SCHEDULER_UNLOCK(intSave);
return ret; return ret;
} }
//LOS_EventRead()函数是对外提供的事件读取接口，调用OsEventRead()实现事件的读取操作
LITE_OS_SEC_TEXT UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout) LITE_OS_SEC_TEXT UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout)
{ {
return OsEventRead(eventCB, eventMask, mode, timeout, FALSE); return OsEventRead(eventCB, eventMask, mode, timeout, FALSE);
} }
//LOS_EventWrite()函数是对外提供的事件写入接口，调用OsEventWrite()实现事件的写入操作
LITE_OS_SEC_TEXT UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events) LITE_OS_SEC_TEXT UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events)
{ {
return OsEventWrite(eventCB, events, FALSE); return OsEventWrite(eventCB, events, FALSE);
} }
//LOS_EventDestroy()函数用于销毁事件控制块，将事件ID设置为0
LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB) LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB)
{ {
UINT32 intSave; UINT32 intSave;
@ -279,7 +280,7 @@ OUT:
LOS_TRACE(EVENT_DELETE, (UINTPTR)eventCB, ret); LOS_TRACE(EVENT_DELETE, (UINTPTR)eventCB, ret);
return ret; return ret;
} }
//LOS_EventClear()函数用于清除指定的事件
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events) LITE_OS_SEC_TEXT_MINOR UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events)
{ {
UINT32 intSave; UINT32 intSave;
@ -296,18 +297,19 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_EventClear(PEVENT_CB_S eventCB, UINT32 events)
return LOS_OK; return LOS_OK;
} }
//OsEventWriteOnce()函数是事件写入的实现，与OsEventWrite()类似，但只写入一次
LITE_OS_SEC_TEXT_MINOR UINT32 OsEventWriteOnce(PEVENT_CB_S eventCB, UINT32 events) LITE_OS_SEC_TEXT_MINOR UINT32 OsEventWriteOnce(PEVENT_CB_S eventCB, UINT32 events)
{ {
return OsEventWrite(eventCB, events, TRUE); return OsEventWrite(eventCB, events, TRUE);
} }
#ifdef LOSCFG_COMPAT_POSIX #ifdef LOSCFG_COMPAT_POSIX
//OsEventReadOnce()函数是事件读取的实现，与OsEventRead()类似，但只读取一次
LITE_OS_SEC_TEXT_MINOR UINT32 OsEventReadOnce(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout) LITE_OS_SEC_TEXT_MINOR UINT32 OsEventReadOnce(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout)
{ {
return OsEventRead(eventCB, eventMask, mode, timeout, TRUE); return OsEventRead(eventCB, eventMask, mode, timeout, TRUE);
} }
// /OsEventReadWithCond()函数用于根据条件读取事件，只有当条件满足时才进行事件读取操作
LITE_OS_SEC_TEXT UINT32 OsEventReadWithCond(const EventCond *cond, PEVENT_CB_S eventCB, LITE_OS_SEC_TEXT UINT32 OsEventReadWithCond(const EventCond *cond, PEVENT_CB_S eventCB,
UINT32 eventMask, UINT32 mode, UINT32 timeout) UINT32 eventMask, UINT32 mode, UINT32 timeout)
{ {

51
src/kernel/base/los_exc.c
Unescape View File

@ -25,7 +25,8 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这是关于LiteOS中异常处理的代码，其中包括记录异常信息、异常信息保存和读取等功能。
同时还包括了一些与异常相关的函数，如打印异常信息、任务回溯等*/
#include "los_exc.h" #include "los_exc.h"
#include "los_printf_pri.h" #include "los_printf_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
@ -48,7 +49,7 @@
extern "C" { extern "C" {
#endif #endif
#endif /* __cplusplus */ #endif /* __cplusplus */
//ExcInfoDumpFormat的结构体类型，包含了用于存储异常信息的缓冲区指针、偏移量、长度和存储地址等信息
#ifdef LOSCFG_SHELL_EXCINFO_DUMP #ifdef LOSCFG_SHELL_EXCINFO_DUMP
typedef struct { typedef struct {
CHAR *buf; /* pointer to the buffer for storing the exception information */ CHAR *buf; /* pointer to the buffer for storing the exception information */
@ -56,11 +57,13 @@ typedef struct {
UINT32 len; /* the size of storing the exception information */ UINT32 len; /* the size of storing the exception information */
UINTPTR dumpAddr; /* the address of storing the exception information */ UINTPTR dumpAddr; /* the address of storing the exception information */
} ExcInfoDumpFormat; } ExcInfoDumpFormat;
//全局变量g_excInfoPool，用于存储异常信息的缓冲区和相关的信息
STATIC ExcInfoDumpFormat g_excInfoPool = {0}; STATIC ExcInfoDumpFormat g_excInfoPool = {0};
/* the hook of read-writing exception information */ /* the hook of read-writing exception information */
STATIC __attribute__((section(".data"))) LogReadWriteFunc g_dumpHook = NULL; STATIC __attribute__((section(".data"))) LogReadWriteFunc g_dumpHook = NULL;
//LOS_ExcInfoRegHook：注册异常信息读写钩子函数，用于设置异常信息的存储地址、长度以及缓冲区等信息
//"钩子函数"是指在特定事件发生时会被调用的函数
//通过使用钩子函数，可以在异常发生时灵活地执行特定的操作，例如记录异常信息、进行特定的处理或通知其他模块进行相应的操作
VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 len, CHAR *buf, LogReadWriteFunc hook) VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 len, CHAR *buf, LogReadWriteFunc hook)
{ {
if ((hook == NULL) || (buf == NULL)) { if ((hook == NULL) || (buf == NULL)) {
@ -78,57 +81,57 @@ VOID LOS_ExcInfoRegHook(UINTPTR startAddr, UINT32 len, CHAR *buf, LogReadWriteFu
g_excInfoPool.buf = buf; g_excInfoPool.buf = buf;
g_dumpHook = hook; g_dumpHook = hook;
} }
//OsSetExcInfoRW：设置异常信息读写钩子函数
VOID OsSetExcInfoRW(LogReadWriteFunc func) VOID OsSetExcInfoRW(LogReadWriteFunc func)
{ {
g_dumpHook = func; g_dumpHook = func;
} }
//OsGetExcInfoRW：获取异常信息读写钩子函数
LogReadWriteFunc OsGetExcInfoRW(VOID) LogReadWriteFunc OsGetExcInfoRW(VOID)
{ {
return g_dumpHook; return g_dumpHook;
} }
//OsSetExcInfoBuf：设置异常信息的缓冲区
VOID OsSetExcInfoBuf(CHAR *buf) VOID OsSetExcInfoBuf(CHAR *buf)
{ {
g_excInfoPool.buf = buf; g_excInfoPool.buf = buf;
} }
//OsGetExcInfoBuf：获取异常信息的缓冲区
CHAR *OsGetExcInfoBuf(VOID) CHAR *OsGetExcInfoBuf(VOID)
{ {
return g_excInfoPool.buf; return g_excInfoPool.buf;
} }
//OsSetExcInfoOffset：设置异常信息的偏移量
VOID OsSetExcInfoOffset(UINT32 Offset) VOID OsSetExcInfoOffset(UINT32 Offset)
{ {
g_excInfoPool.offset = Offset; g_excInfoPool.offset = Offset;
} }
//OsGetExcInfoOffset：获取异常信息的偏移量
UINT32 OsGetExcInfoOffset(VOID) UINT32 OsGetExcInfoOffset(VOID)
{ {
return g_excInfoPool.offset; return g_excInfoPool.offset;
} }
//OsSetExcInfoDumpAddr：设置异常信息的存储地址
VOID OsSetExcInfoDumpAddr(UINTPTR addr) VOID OsSetExcInfoDumpAddr(UINTPTR addr)
{ {
g_excInfoPool.dumpAddr = addr; g_excInfoPool.dumpAddr = addr;
} }
//OsGetExcInfoDumpAddr：获取异常信息的存储地址
UINTPTR OsGetExcInfoDumpAddr(VOID) UINTPTR OsGetExcInfoDumpAddr(VOID)
{ {
return g_excInfoPool.dumpAddr; return g_excInfoPool.dumpAddr;
} }
//OsSetExcInfoLen：设置异常信息的长度
VOID OsSetExcInfoLen(UINT32 len) VOID OsSetExcInfoLen(UINT32 len)
{ {
g_excInfoPool.len = len; g_excInfoPool.len = len;
} }
//OsGetExcInfoLen：获取异常信息的长度
UINT32 OsGetExcInfoLen(VOID) UINT32 OsGetExcInfoLen(VOID)
{ {
return g_excInfoPool.len; return g_excInfoPool.len;
} }
//WriteExcBufVa：将格式化的字符串写入异常信息缓冲区
VOID WriteExcBufVa(const CHAR *format, va_list arglist) VOID WriteExcBufVa(const CHAR *format, va_list arglist)
{ {
errno_t ret; errno_t ret;
@ -143,7 +146,7 @@ VOID WriteExcBufVa(const CHAR *format, va_list arglist)
g_excInfoPool.offset += ret; g_excInfoPool.offset += ret;
} }
} }
//WriteExcInfoToBuf：将格式化的字符串写入异常信息缓冲区
VOID WriteExcInfoToBuf(const CHAR *format, ...) VOID WriteExcInfoToBuf(const CHAR *format, ...)
{ {
va_list arglist; va_list arglist;
@ -152,7 +155,7 @@ VOID WriteExcInfoToBuf(const CHAR *format, ...)
WriteExcBufVa(format, arglist); WriteExcBufVa(format, arglist);
va_end(arglist); va_end(arglist);
} }
//OsRecordExcInfoTime：记录异常信息的时间
VOID OsRecordExcInfoTime(VOID) VOID OsRecordExcInfoTime(VOID)
{ {
#define NOW_TIME_LENGTH 24 #define NOW_TIME_LENGTH 24
@ -169,7 +172,7 @@ VOID OsRecordExcInfoTime(VOID)
#undef NOW_TIME_LENGTH #undef NOW_TIME_LENGTH
PrintExcInfo("%s \n", nowTime); PrintExcInfo("%s \n", nowTime);
} }
//OsShellCmdReadExcInfo：读取并打印异常信息的Shell命令
#ifdef LOSCFG_SHELL #ifdef LOSCFG_SHELL
INT32 OsShellCmdReadExcInfo(INT32 argc, const CHAR **argv) INT32 OsShellCmdReadExcInfo(INT32 argc, const CHAR **argv)
{ {
@ -200,6 +203,9 @@ SHELLCMD_ENTRY(readExcInfo_shellcmd, CMD_TYPE_EX, "excInfo", 0, (CmdCallBackFunc
#endif #endif
#ifdef LOSCFG_EXC_INTERACTION #ifdef LOSCFG_EXC_INTERACTION
//OsCheckExcInteractionTask：检查任务是否为异常交互任务
//异常交互任务通常指的是用于处理异常情况的特殊任务或线程
//当系统发生严重的错误或异常时，需要立即采取相应的措施来处理异常情况，这就需要使用异常交互任务来处理
UINT32 OsCheckExcInteractionTask(const TSK_INIT_PARAM_S *initParam) UINT32 OsCheckExcInteractionTask(const TSK_INIT_PARAM_S *initParam)
{ {
if ((initParam->pfnTaskEntry == (TSK_ENTRY_FUNC)ShellTask) || if ((initParam->pfnTaskEntry == (TSK_ENTRY_FUNC)ShellTask) ||
@ -209,7 +215,7 @@ UINT32 OsCheckExcInteractionTask(const TSK_INIT_PARAM_S *initParam)
} }
return LOS_NOK; return LOS_NOK;
} }
//OsKeepExcInteractionTask：保留异常交互任务，删除其他任务
VOID OsKeepExcInteractionTask(VOID) VOID OsKeepExcInteractionTask(VOID)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
@ -243,7 +249,7 @@ VOID OsKeepExcInteractionTask(VOID)
} }
#endif #endif
//LOS_Panic：打印异常信息并停止CPU执行
VOID LOS_Panic(const CHAR *fmt, ...) VOID LOS_Panic(const CHAR *fmt, ...)
{ {
va_list ap; va_list ap;
@ -252,7 +258,7 @@ VOID LOS_Panic(const CHAR *fmt, ...)
va_end(ap); va_end(ap);
ArchHaltCpu(); ArchHaltCpu();
} }
//LOS_BackTrace：打印当前任务的运行信息和回溯堆栈
VOID LOS_BackTrace(VOID) VOID LOS_BackTrace(VOID)
{ {
#ifdef LOSCFG_BACKTRACE #ifdef LOSCFG_BACKTRACE
@ -262,7 +268,7 @@ VOID LOS_BackTrace(VOID)
ArchBackTrace(); ArchBackTrace();
#endif #endif
} }
//LOS_TaskBackTrace：打印指定任务的运行信息和回溯堆栈
VOID LOS_TaskBackTrace(UINT32 taskID) VOID LOS_TaskBackTrace(UINT32 taskID)
{ {
#ifdef LOSCFG_BACKTRACE #ifdef LOSCFG_BACKTRACE
@ -289,6 +295,7 @@ VOID LOS_TaskBackTrace(UINT32 taskID)
#ifdef __GNUC__ #ifdef __GNUC__
/* stack protector */ /* stack protector */
//__stack_chk_fail：用于栈保护机制，当发现栈被破坏时触发异常处理
VOID __stack_chk_fail(VOID) VOID __stack_chk_fail(VOID)
{ {
/* __builtin_return_address is a builtin function, building in gcc */ /* __builtin_return_address is a builtin function, building in gcc */

61
src/kernel/base/los_hwi.c
Unescape View File

@ -25,7 +25,9 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*
关于LiteOS中硬件中断处理的部分，涉及了中断的注册、删除、触发、使能、禁止等操作
*/
#include "los_hwi_pri.h" #include "los_hwi_pri.h"
#include "los_hwi.h" #include "los_hwi.h"
#include "los_memory.h" #include "los_memory.h"
@ -61,7 +63,7 @@ const HwiControllerOps *g_hwiOps = NULL;
typedef VOID (*HWI_PROC_FUNC0)(VOID); typedef VOID (*HWI_PROC_FUNC0)(VOID);
typedef VOID (*HWI_PROC_FUNC2)(INT32, VOID *); typedef VOID (*HWI_PROC_FUNC2)(INT32, VOID *);
//OsIrqNestingActive：用于在处理中断期间激活中断嵌套计数器，避免在处理时钟中断时进行抢占
STATIC INLINE VOID OsIrqNestingActive(UINT32 hwiNum) STATIC INLINE VOID OsIrqNestingActive(UINT32 hwiNum)
{ {
#ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION #ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION
@ -71,7 +73,7 @@ STATIC INLINE VOID OsIrqNestingActive(UINT32 hwiNum)
} }
#endif #endif
} }
//OsIrqNestingInactive：用于在处理中断结束后禁用中断嵌套计数器
STATIC INLINE VOID OsIrqNestingInactive(UINT32 hwiNum) STATIC INLINE VOID OsIrqNestingInactive(UINT32 hwiNum)
{ {
#ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION #ifdef LOSCFG_ARCH_INTERRUPT_PREEMPTION
@ -80,17 +82,17 @@ STATIC INLINE VOID OsIrqNestingInactive(UINT32 hwiNum)
} }
#endif #endif
} }
//OsIrqNestingCntGet：获取当前CPU的中断嵌套计数值
size_t OsIrqNestingCntGet(VOID) size_t OsIrqNestingCntGet(VOID)
{ {
return g_intCount[ArchCurrCpuid()]; return g_intCount[ArchCurrCpuid()];
} }
//OsIrqNestingCntSet：设置当前CPU的中断嵌套计数值
VOID OsIrqNestingCntSet(size_t val) VOID OsIrqNestingCntSet(size_t val)
{ {
g_intCount[ArchCurrCpuid()] = val; g_intCount[ArchCurrCpuid()] = val;
} }
//InterruptHandle：处理中断的实际函数，根据中断号调用对应的中断处理函数
STATIC INLINE VOID InterruptHandle(HwiHandleInfo *hwiForm) STATIC INLINE VOID InterruptHandle(HwiHandleInfo *hwiForm)
{ {
hwiForm->respCount++; hwiForm->respCount++;
@ -114,7 +116,7 @@ STATIC INLINE VOID InterruptHandle(HwiHandleInfo *hwiForm)
} }
#endif #endif
} }
//OsIntHandle：中断处理入口函数，负责处理中断前的一些准备工作，如调用中断处理前的钩子函数等
VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *hwiForm) VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *hwiForm)
{ {
size_t *intCnt = NULL; size_t *intCnt = NULL;
@ -148,7 +150,7 @@ VOID OsIntHandle(UINT32 hwiNum, HwiHandleInfo *hwiForm)
OsCpupIrqEnd(hwiNum); OsCpupIrqEnd(hwiNum);
#endif #endif
} }
//OsIntEntry：中断向量入口函数，根据中断号调用对应的中断处理函数
VOID OsIntEntry(VOID) VOID OsIntEntry(VOID)
{ {
if ((g_hwiOps != NULL) && (g_hwiOps->handleIrq != NULL)) { if ((g_hwiOps != NULL) && (g_hwiOps->handleIrq != NULL)) {
@ -156,7 +158,7 @@ VOID OsIntEntry(VOID)
} }
return; return;
} }
//OsHwiCpIrqParam：根据传入的中断参数结构体分配内存，并将参数信息拷贝到新分配的内存中
STATIC HWI_ARG_T OsHwiCpIrqParam(const HWI_IRQ_PARAM_S *irqParam) STATIC HWI_ARG_T OsHwiCpIrqParam(const HWI_IRQ_PARAM_S *irqParam)
{ {
HWI_IRQ_PARAM_S *paramByAlloc = NULL; HWI_IRQ_PARAM_S *paramByAlloc = NULL;
@ -169,6 +171,7 @@ STATIC HWI_ARG_T OsHwiCpIrqParam(const HWI_IRQ_PARAM_S *irqParam)
return (HWI_ARG_T)paramByAlloc; return (HWI_ARG_T)paramByAlloc;
} }
#ifndef LOSCFG_SHARED_IRQ #ifndef LOSCFG_SHARED_IRQ
//OsHwiDel：删除指定的中断处理函数
STATIC UINT32 OsHwiDel(HwiHandleInfo *hwiForm, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId) STATIC UINT32 OsHwiDel(HwiHandleInfo *hwiForm, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId)
{ {
UINT32 intSave; UINT32 intSave;
@ -190,7 +193,7 @@ STATIC UINT32 OsHwiDel(HwiHandleInfo *hwiForm, const HWI_IRQ_PARAM_S *irqParam,
HWI_UNLOCK(intSave); HWI_UNLOCK(intSave);
return LOS_OK; return LOS_OK;
} }
//OsHwiCreate：创建中断处理函数，并将其添加到中断处理链表中
STATIC UINT32 OsHwiCreate(HwiHandleInfo *hwiForm, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler, STATIC UINT32 OsHwiCreate(HwiHandleInfo *hwiForm, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler,
const HWI_IRQ_PARAM_S *irqParam) const HWI_IRQ_PARAM_S *irqParam)
{ {
@ -218,6 +221,7 @@ STATIC UINT32 OsHwiCreate(HwiHandleInfo *hwiForm, HWI_MODE_T hwiMode, HWI_PROC_F
return LOS_OK; return LOS_OK;
} }
#else /* LOSCFG_SHARED_IRQ */ #else /* LOSCFG_SHARED_IRQ */
//函数OsFreeHwiNode:用于释放中断处理函数节点，并在需要时禁止该中断
STATIC INLINE UINT32 OsFreeHwiNode(HwiHandleInfo *head, HwiHandleInfo *hwiForm, UINT32 irqId) STATIC INLINE UINT32 OsFreeHwiNode(HwiHandleInfo *head, HwiHandleInfo *hwiForm, UINT32 irqId)
{ {
UINT32 ret = LOS_OK; UINT32 ret = LOS_OK;
@ -240,7 +244,8 @@ STATIC INLINE UINT32 OsFreeHwiNode(HwiHandleInfo *head, HwiHandleInfo *hwiForm,
return ret; return ret;
} }
//OsHwiDel:用于删除硬件中断处理函数，它首先判断中断是否是共享中断
//如果不是，则直接释放该中断的处理函数节点;如果是共享中断，则遍历链表找到对应的设备ID，然后释放该中断的处理函数节点
STATIC UINT32 OsHwiDel(HwiHandleInfo *head, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId) STATIC UINT32 OsHwiDel(HwiHandleInfo *head, const HWI_IRQ_PARAM_S *irqParam, UINT32 irqId)
{ {
HwiHandleInfo *hwiFormPrev = NULL; HwiHandleInfo *hwiFormPrev = NULL;
@ -290,7 +295,8 @@ STATIC UINT32 OsHwiDel(HwiHandleInfo *head, const HWI_IRQ_PARAM_S *irqParam, UIN
HWI_UNLOCK(intSave); HWI_UNLOCK(intSave);
return ret; return ret;
} }
//OsHwiCreate:用于创建硬件中断处理函数，它首先判断中断是否是共享中断，并检查是否已经存在具有相同设备ID的中断处理函数节点，如果存在则返回错误
//然后申请内存并初始化新的中断处理函数节点，将其添加到链表中
STATIC UINT32 OsHwiCreate(HwiHandleInfo *head, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler, STATIC UINT32 OsHwiCreate(HwiHandleInfo *head, HWI_MODE_T hwiMode, HWI_PROC_FUNC hwiHandler,
const HWI_IRQ_PARAM_S *irqParam) const HWI_IRQ_PARAM_S *irqParam)
{ {
@ -359,7 +365,9 @@ size_t IntActive()
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
return intCount; return intCount;
} }
//LOS_HwiCreate 函数：用于创建硬件中断处理函数
//它会注册一个中断处理函数，并将其与指定的硬件中断号相关联
//可以设置中断的优先级、硬件中断模式和处理函数
LITE_OS_SEC_TEXT UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum, LITE_OS_SEC_TEXT UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,
HWI_PRIOR_T hwiPrio, HWI_PRIOR_T hwiPrio,
HWI_MODE_T hwiMode, HWI_MODE_T hwiMode,
@ -396,7 +404,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,
} }
return ret; return ret;
} }
//LOS_HwiDelete 函数：用于删除已经创建的硬件中断处理函数
//通过指定硬件中断号，可以将之前注册的中断处理函数从系统中删除
LITE_OS_SEC_TEXT UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam) LITE_OS_SEC_TEXT UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam)
{ {
UINT32 ret; UINT32 ret;
@ -417,7 +426,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqP
return ret; return ret;
} }
//LOS_HwiTrigger 函数：用于手动触发指定的硬件中断
//调用该函数后，会立即触发对应的硬件中断，使得系统执行相应的中断处理函数
LITE_OS_SEC_TEXT UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->triggerIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->triggerIrq == NULL)) {
@ -427,7 +437,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum)
return g_hwiOps->triggerIrq(hwiNum); return g_hwiOps->triggerIrq(hwiNum);
} }
//LOS_HwiEnable 函数：用于使能指定的硬件中断
//调用该函数后，系统将允许对应的硬件中断产生，并执行相应的中断处理函数
LITE_OS_SEC_TEXT UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->enableIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->enableIrq == NULL)) {
@ -437,7 +448,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum)
return g_hwiOps->enableIrq(hwiNum); return g_hwiOps->enableIrq(hwiNum);
} }
//LOS_HwiDisable 函数：用于禁止指定的硬件中断
//调用该函数后，系统将阻止对应的硬件中断产生，屏蔽其影响
LITE_OS_SEC_TEXT UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->disableIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->disableIrq == NULL)) {
@ -447,7 +459,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum)
return g_hwiOps->disableIrq(hwiNum); return g_hwiOps->disableIrq(hwiNum);
} }
//LOS_HwiClear 函数：用于清除指定的硬件中断
//在某些平台上，硬件中断发生后可能需要手动清除中断标志位，以便正确处理后续的中断
LITE_OS_SEC_TEXT UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum) LITE_OS_SEC_TEXT UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->clearIrq == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->clearIrq == NULL)) {
@ -457,7 +470,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum)
return g_hwiOps->clearIrq(hwiNum); return g_hwiOps->clearIrq(hwiNum);
} }
//LOS_HwiSetPriority 函数：用于设置硬件中断的优先级
//通过指定硬件中断号和优先级，可以调整硬件中断的触发顺序
LITE_OS_SEC_TEXT UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority) LITE_OS_SEC_TEXT UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->setIrqPriority == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->setIrqPriority == NULL)) {
@ -468,6 +482,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T prio
return g_hwiOps->setIrqPriority(hwiNum, priority); return g_hwiOps->setIrqPriority(hwiNum, priority);
} }
#ifdef LOSCFG_KERNEL_SMP #ifdef LOSCFG_KERNEL_SMP
//LOS_HwiSetAffinity函数：用于设置硬件中断的处理CPU亲和性
//它首先检查硬件中断操作函数指针是否为空，然后调用具体的操作函数来设置中断的处理CPU亲和性
LITE_OS_SEC_TEXT UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask) LITE_OS_SEC_TEXT UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->setIrqCpuAffinity == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->setIrqCpuAffinity == NULL)) {
@ -477,7 +493,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
return g_hwiOps->setIrqCpuAffinity(hwiNum, cpuMask); return g_hwiOps->setIrqCpuAffinity(hwiNum, cpuMask);
} }
//LOS_HwiSendIpi函数：用于发送硬件中断处理请求给指定的CPU
//它首先检查硬件中断操作函数指针是否为空，然后调用具体的操作函数来发送中断处理请求
LITE_OS_SEC_TEXT UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask) LITE_OS_SEC_TEXT UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
{ {
if ((g_hwiOps == NULL) || (g_hwiOps->sendIpi == NULL)) { if ((g_hwiOps == NULL) || (g_hwiOps->sendIpi == NULL)) {
@ -490,6 +507,8 @@ LITE_OS_SEC_TEXT UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask)
#endif #endif
#ifdef LOSCFG_KERNEL_LOWPOWER #ifdef LOSCFG_KERNEL_LOWPOWER
//LOS_IntWakeupHookReg函数：用于注册中断唤醒回调函数
//它将传入的回调函数赋值给全局变量g_intWakeupHook，以便在中断唤醒时调用该回调函数
LITE_OS_SEC_TEXT_MINOR VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook) LITE_OS_SEC_TEXT_MINOR VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook)
{ {
g_intWakeupHook = hook; g_intWakeupHook = hook;
@ -497,6 +516,8 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook)
#endif #endif
/* Initialization of the hardware interrupt */ /* Initialization of the hardware interrupt */
//OsHwiInit函数：用于初始化硬件中断
//它会调用具体的平台相关函数来进行硬件中断的初始化操作
LITE_OS_SEC_TEXT_INIT VOID OsHwiInit(VOID) LITE_OS_SEC_TEXT_INIT VOID OsHwiInit(VOID)
{ {
ArchIrqInit(); ArchIrqInit();

25
src/kernel/base/los_lockdep.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*这段代码是关于锁依赖检查的实现。包含了一些头文件和函数的定义，用于在多核系统中检测锁的使用情况*/
#include "los_base.h" #include "los_base.h"
#include "los_spinlock.h" #include "los_spinlock.h"
#include "los_task_pri.h" #include "los_task_pri.h"
@ -47,6 +47,8 @@ extern "C" {
STATIC Atomic g_lockdepAvailable = 1; STATIC Atomic g_lockdepAvailable = 1;
/* atomic insurance for lockdep check */ /* atomic insurance for lockdep check */
//OsLockDepRequire：该函数用于获取锁依赖检查的原子操作，确保在进行锁依赖检查时不会被中断
//原子操作是指在计算机科学中，不会被中断的操作
STATIC INLINE VOID OsLockDepRequire(UINT32 *intSave) STATIC INLINE VOID OsLockDepRequire(UINT32 *intSave)
{ {
*intSave = LOS_IntLock(); *intSave = LOS_IntLock();
@ -54,13 +56,13 @@ STATIC INLINE VOID OsLockDepRequire(UINT32 *intSave)
/* busy waiting */ /* busy waiting */
} }
} }
//OsLockDepRelease：释放锁依赖检查的原子操作，用于在完成锁依赖检查后恢复正常的中断状态
STATIC INLINE VOID OsLockDepRelease(UINT32 intSave) STATIC INLINE VOID OsLockDepRelease(UINT32 intSave)
{ {
LOS_AtomicSet(&g_lockdepAvailable, 1); LOS_AtomicSet(&g_lockdepAvailable, 1);
LOS_IntRestore(intSave); LOS_IntRestore(intSave);
} }
//OsLockDepGetCycles：获取当前 CPU 的周期计数器的值，用于记录锁请求和释放时的时间戳
STATIC INLINE UINT64 OsLockDepGetCycles(VOID) STATIC INLINE UINT64 OsLockDepGetCycles(VOID)
{ {
UINT32 high, low; UINT32 high, low;
@ -69,7 +71,7 @@ STATIC INLINE UINT64 OsLockDepGetCycles(VOID)
/* combine cycleHi and cycleLo into 8 bytes cycles */ /* combine cycleHi and cycleLo into 8 bytes cycles */
return (((UINT64)high << 32) + low); return (((UINT64)high << 32) + low);
} }
//OsLockDepErrorStringGet：根据错误类型返回对应的错误字符串，用于打印错误信息
STATIC INLINE CHAR *OsLockDepErrorStringGet(enum LockDepErrType type) STATIC INLINE CHAR *OsLockDepErrorStringGet(enum LockDepErrType type)
{ {
CHAR *errorString = NULL; CHAR *errorString = NULL;
@ -94,7 +96,7 @@ STATIC INLINE CHAR *OsLockDepErrorStringGet(enum LockDepErrType type)
return errorString; return errorString;
} }
//OsLockDepPanic：当发生严重错误时触发系统的崩溃，通常在检测到死锁等无法修复的情况下调用
WEAK VOID OsLockDepPanic(enum LockDepErrType errType) WEAK VOID OsLockDepPanic(enum LockDepErrType errType)
{ {
/* halt here */ /* halt here */
@ -103,7 +105,7 @@ WEAK VOID OsLockDepPanic(enum LockDepErrType errType)
OsBackTrace(); OsBackTrace();
while (1) {} while (1) {}
} }
//OsLockDepDumpLock：输出锁依赖检查失败时的调试信息，包括任务名、任务 ID、CPU 号等，并最终触发崩溃
STATIC VOID OsLockDepDumpLock(const LosTaskCB *task, const SPIN_LOCK_S *lock, STATIC VOID OsLockDepDumpLock(const LosTaskCB *task, const SPIN_LOCK_S *lock,
const VOID *requestAddr, enum LockDepErrType errType) const VOID *requestAddr, enum LockDepErrType errType)
{ {
@ -143,7 +145,7 @@ STATIC VOID OsLockDepDumpLock(const LosTaskCB *task, const SPIN_LOCK_S *lock,
OsLockDepPanic(errType); OsLockDepPanic(errType);
} }
//OsLockDepCheckDependancy：检查当前任务与锁的所有者之间是否存在依赖关系，以避免死锁
STATIC BOOL OsLockDepCheckDependancy(const LosTaskCB *current, const LosTaskCB *lockOwner) STATIC BOOL OsLockDepCheckDependancy(const LosTaskCB *current, const LosTaskCB *lockOwner)
{ {
BOOL checkResult = TRUE; BOOL checkResult = TRUE;
@ -164,7 +166,7 @@ STATIC BOOL OsLockDepCheckDependancy(const LosTaskCB *current, const LosTaskCB *
return checkResult; return checkResult;
} }
//OsLockDepCheckIn：在请求锁时进行依赖检查，记录锁的请求地址和等待时间，如检查失败则触发崩溃
VOID OsLockDepCheckIn(const SPIN_LOCK_S *lock) VOID OsLockDepCheckIn(const SPIN_LOCK_S *lock)
{ {
UINT32 intSave; UINT32 intSave;
@ -217,7 +219,7 @@ OUT:
OsLockDepRelease(intSave); OsLockDepRelease(intSave);
} }
//OsLockDepRecord：记录成功获取锁的时间戳和持有者信息，并更新锁的所有者和 CPU 号等信息
VOID OsLockDepRecord(SPIN_LOCK_S *lock) VOID OsLockDepRecord(SPIN_LOCK_S *lock)
{ {
UINT32 intSave; UINT32 intSave;
@ -250,7 +252,7 @@ VOID OsLockDepRecord(SPIN_LOCK_S *lock)
OsLockDepRelease(intSave); OsLockDepRelease(intSave);
} }
//OsLockDepCheckOut：在释放锁时进行依赖检查，记录持有时间并清除相关信息，如检查失败则触发崩溃
VOID OsLockDepCheckOut(SPIN_LOCK_S *lock) VOID OsLockDepCheckOut(SPIN_LOCK_S *lock)
{ {
UINT32 intSave; UINT32 intSave;
@ -302,7 +304,8 @@ VOID OsLockDepCheckOut(SPIN_LOCK_S *lock)
OUT: OUT:
OsLockDepRelease(intSave); OsLockDepRelease(intSave);
} }
//OsLockdepClearSpinlocks：清除当前任务持有的所有自旋锁，通常在系统处于异常状态下调用以确保解锁
//自旋锁是一种用于多线程同步的机制。在使用自旋锁时，线程会反复检查锁是否被释放，如果锁已经被占用，线程就会一直循环等待，直到锁被释放为止
VOID OsLockdepClearSpinlocks(VOID) VOID OsLockdepClearSpinlocks(VOID)
{ {
LosTaskCB *task = OsCurrTaskGet(); LosTaskCB *task = OsCurrTaskGet();

42
src/kernel/base/los_misc.c
Unescape View File

@ -25,7 +25,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
//操作系统的基础函数
#include "los_task_pri.h" #include "los_task_pri.h"
#include "los_misc_pri.h" #include "los_misc_pri.h"
#include "los_memory_pri.h" #include "los_memory_pri.h"
@ -48,23 +48,23 @@ extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#ifdef LOSCFG_LIB_CONFIGURABLE #ifdef LOSCFG_LIB_CONFIGURABLE
LITE_OS_SEC_BSS UINT32 g_osSysClock; LITE_OS_SEC_BSS UINT32 g_osSysClock; //操作系统的系统时钟频率
LITE_OS_SEC_BSS UINT32 g_semLimit; LITE_OS_SEC_BSS UINT32 g_semLimit; //信号量的最大数量限制
LITE_OS_SEC_BSS UINT32 g_muxLimit; LITE_OS_SEC_BSS UINT32 g_muxLimit; //互斥锁的最大数量限制
LITE_OS_SEC_BSS UINT32 g_queueLimit; LITE_OS_SEC_BSS UINT32 g_queueLimit; //队列最大数量限制
LITE_OS_SEC_BSS UINT32 g_swtmrLimit; LITE_OS_SEC_BSS UINT32 g_swtmrLimit; //软件定时器的最大数量限制
LITE_OS_SEC_BSS UINT32 g_taskLimit; LITE_OS_SEC_BSS UINT32 g_taskLimit; //任务的最大数量限制
LITE_OS_SEC_BSS UINT32 g_minusOneTickPerSecond; LITE_OS_SEC_BSS UINT32 g_minusOneTickPerSecond; //每秒减去的滴答数，用于时间戳计算
LITE_OS_SEC_BSS UINT32 g_taskMinStkSize; LITE_OS_SEC_BSS UINT32 g_taskMinStkSize;//任务的最小堆栈大小
LITE_OS_SEC_BSS UINT32 g_taskIdleStkSize; LITE_OS_SEC_BSS UINT32 g_taskIdleStkSize; //空闲任务的堆栈大小
LITE_OS_SEC_BSS UINT32 g_taskSwtmrStkSize; LITE_OS_SEC_BSS UINT32 g_taskSwtmrStkSize; //软件定时器任务的堆栈大小
LITE_OS_SEC_BSS UINT32 g_taskDfltStkSize; LITE_OS_SEC_BSS UINT32 g_taskDfltStkSize; //默认任务的堆栈大小
LITE_OS_SEC_BSS UINT32 g_timeSliceTimeOut; LITE_OS_SEC_BSS UINT32 g_timeSliceTimeOut; //时间片的超时时间
LITE_OS_SEC_DATA BOOL g_nxEnabled = FALSE; LITE_OS_SEC_DATA BOOL g_nxEnabled = FALSE; //是否启用了内存保护机制
LITE_OS_SEC_BSS UINTPTR g_dlNxHeapBase; LITE_OS_SEC_BSS UINTPTR g_dlNxHeapBase; //动态加载库的内存堆起始地址
LITE_OS_SEC_BSS UINT32 g_dlNxHeapSize; LITE_OS_SEC_BSS UINT32 g_dlNxHeapSize; //动态加载库的内存堆大小
#endif #endif
#ifdef LOSCFG_KERNEL_TRACE #ifdef LOSCFG_KERNEL_TRACE
@ -77,11 +77,12 @@ LMS_INIT_HOOK g_lmsMemInitHook = NULL;
LMS_FUNC_HOOK g_lmsMallocHook = NULL; LMS_FUNC_HOOK g_lmsMallocHook = NULL;
LMS_FUNC_HOOK g_lmsFreeHook = NULL; LMS_FUNC_HOOK g_lmsFreeHook = NULL;
#endif #endif
//LOS_Align：用于将给定的地址按指定的边界对齐，返回对齐后的地址
LITE_OS_SEC_TEXT UINTPTR LOS_Align(UINTPTR addr, UINT32 boundary) LITE_OS_SEC_TEXT UINTPTR LOS_Align(UINTPTR addr, UINT32 boundary)
{ {
return (addr + boundary - 1) & ~((UINTPTR)(boundary - 1)); return (addr + boundary - 1) & ~((UINTPTR)(boundary - 1));
} }
//OsDumpMemByte：用于以字节为单位打印内存中的数据
LITE_OS_SEC_TEXT_MINOR VOID LOS_Msleep(UINT32 msecs) LITE_OS_SEC_TEXT_MINOR VOID LOS_Msleep(UINT32 msecs)
{ {
UINT32 interval; UINT32 interval;
@ -97,7 +98,7 @@ LITE_OS_SEC_TEXT_MINOR VOID LOS_Msleep(UINT32 msecs)
(VOID)LOS_TaskDelay(interval); (VOID)LOS_TaskDelay(interval);
} }
//OsDumpMemByte：用于以字节为单位打印内存中的数据
VOID OsDumpMemByte(size_t length, UINTPTR addr) VOID OsDumpMemByte(size_t length, UINTPTR addr)
{ {
size_t dataLen; size_t dataLen;
@ -141,6 +142,7 @@ VOID OsDumpMemByte(size_t length, UINTPTR addr)
} }
#if defined(LOSCFG_DEBUG_SEMAPHORE) || defined(LOSCFG_DEBUG_MUTEX) || defined(LOSCFG_DEBUG_QUEUE) #if defined(LOSCFG_DEBUG_SEMAPHORE) || defined(LOSCFG_DEBUG_MUTEX) || defined(LOSCFG_DEBUG_QUEUE)
//OsArraySort：快速排序
VOID OsArraySort(UINT32 *sortArray, UINT32 start, UINT32 end, VOID OsArraySort(UINT32 *sortArray, UINT32 start, UINT32 end,
const SortParam *sortParam, OsCompareFunc compareFunc) const SortParam *sortParam, OsCompareFunc compareFunc)
{ {

20
src/kernel/base/los_mp.c
Unescape View File

@ -25,7 +25,8 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*针对多处理器（SMP）系统的操作系统内核部分的实现
主要包括了多处理器调度、任务管理和中断处理等功能*/
#include "los_mp_pri.h" #include "los_mp_pri.h"
#include "los_task_pri.h" #include "los_task_pri.h"
#include "los_percpu_pri.h" #include "los_percpu_pri.h"
@ -45,7 +46,7 @@ LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_mpCallSpin);
#define MP_CALL_LOCK(state) LOS_SpinLockSave(&g_mpCallSpin, &(state)) #define MP_CALL_LOCK(state) LOS_SpinLockSave(&g_mpCallSpin, &(state))
#define MP_CALL_UNLOCK(state) LOS_SpinUnlockRestore(&g_mpCallSpin, (state)) #define MP_CALL_UNLOCK(state) LOS_SpinUnlockRestore(&g_mpCallSpin, (state))
#endif #endif
//LOS_MpSchedule：多处理器调度函数，用于向指定的处理器发送调度中断
VOID LOS_MpSchedule(UINT32 target) VOID LOS_MpSchedule(UINT32 target)
{ {
UINT32 ret; UINT32 ret;
@ -57,12 +58,12 @@ VOID LOS_MpSchedule(UINT32 target)
} }
return; return;
} }
//OsMpWakeHandler：多处理器唤醒处理函数，目前为空实现，无特定操作
VOID OsMpWakeHandler(VOID) VOID OsMpWakeHandler(VOID)
{ {
/* generic wakeup ipi, do nothing */ /* generic wakeup ipi, do nothing */
} }
//OsMpScheduleHandler：多处理器调度处理函数，设置调度标志以触发调度器在中断结束时执行调度
VOID OsMpScheduleHandler(VOID) VOID OsMpScheduleHandler(VOID)
{ {
/* /*
@ -71,7 +72,7 @@ VOID OsMpScheduleHandler(VOID)
*/ */
OsPercpuGet()->schedFlag = INT_PEND_RESCH; OsPercpuGet()->schedFlag = INT_PEND_RESCH;
} }
//OsMpHaltHandler：多处理器停机处理函数，将当前处理器标记为已停机状态，并进入死循环
VOID OsMpHaltHandler(VOID) VOID OsMpHaltHandler(VOID)
{ {
(VOID)LOS_IntLock(); (VOID)LOS_IntLock();
@ -79,7 +80,7 @@ VOID OsMpHaltHandler(VOID)
while (1) {} while (1) {}
} }
//OsMpCollectTasks：多处理器任务回收函数，用于递归检查所有可用任务，并删除标记为需要销毁的任务
VOID OsMpCollectTasks(VOID) VOID OsMpCollectTasks(VOID)
{ {
LosTaskCB *taskCB = NULL; LosTaskCB *taskCB = NULL;
@ -109,6 +110,7 @@ VOID OsMpCollectTasks(VOID)
} }
#ifdef LOSCFG_KERNEL_SMP_CALL #ifdef LOSCFG_KERNEL_SMP_CALL
//OsMpFuncCall：多处理器函数调用函数，用于向指定的处理器发送函数调用请求
VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args) VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args)
{ {
UINT32 index; UINT32 index;
@ -144,7 +146,7 @@ VOID OsMpFuncCall(UINT32 target, SMP_FUNC_CALL func, VOID *args)
} }
return; return;
} }
//OsMpFuncCallHandler：多处理器函数调用处理函数，从本处理器的函数调用队列中取出并执行函数调用请求
VOID OsMpFuncCallHandler(VOID) VOID OsMpFuncCallHandler(VOID)
{ {
UINT32 intSave; UINT32 intSave;
@ -166,7 +168,7 @@ VOID OsMpFuncCallHandler(VOID)
} }
MP_CALL_UNLOCK(intSave); MP_CALL_UNLOCK(intSave);
} }
//OsMpFuncCallInit：多处理器函数调用初始化函数，用于初始化每个核心的函数调用队列
VOID OsMpFuncCallInit(VOID) VOID OsMpFuncCallInit(VOID)
{ {
UINT32 index; UINT32 index;
@ -176,7 +178,7 @@ VOID OsMpFuncCallInit(VOID)
} }
} }
#endif /* LOSCFG_KERNEL_SMP_CALL */ #endif /* LOSCFG_KERNEL_SMP_CALL */
//OsMpInit：多处理器初始化函数，包括创建周期性软件定时器和初始化函数调用队列等
UINT32 OsMpInit(VOID) UINT32 OsMpInit(VOID)
{ {
UINT16 swtmrId; UINT16 swtmrId;

25
src/kernel/base/los_mux.c
Unescape View File

@ -25,7 +25,8 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* --------------------------------------------------------------------------- */ * --------------------------------------------------------------------------- */
/*代码实现了一个简单的互斥锁（Mutex），用于保护共享资源的访问
互斥锁的主要功能是确保在同一时间只有一个线程可以访问被保护的代码块或共享资源，从而避免并发访问引发的数据竞争和不一致性*/
#include "los_mux_pri.h" #include "los_mux_pri.h"
#include "los_mux_debug_pri.h" #include "los_mux_debug_pri.h"
#include "los_bitmap.h" #include "los_bitmap.h"
@ -49,6 +50,7 @@ LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_unusedMuxList;
* Description : Initializes the mutex * Description : Initializes the mutex
* Return : LOS_OK on success, or error code on failure * Return : LOS_OK on success, or error code on failure
*/ */
//OsMuxInit：Mutex初始化函数，用于初始化Mutex数据结构并设置初始状态
LITE_OS_SEC_TEXT UINT32 OsMuxInit(VOID) LITE_OS_SEC_TEXT UINT32 OsMuxInit(VOID)
{ {
LosMuxCB *muxNode = NULL; LosMuxCB *muxNode = NULL;
@ -74,7 +76,7 @@ LITE_OS_SEC_TEXT UINT32 OsMuxInit(VOID)
} }
return LOS_OK; return LOS_OK;
} }
//LOS_MuxCreate：创建Mutex函数，用于创建一个新的Mutex对象，并返回其句柄
LITE_OS_SEC_TEXT UINT32 LOS_MuxCreate(UINT32 *muxHandle) LITE_OS_SEC_TEXT UINT32 LOS_MuxCreate(UINT32 *muxHandle)
{ {
UINT32 intSave; UINT32 intSave;
@ -113,7 +115,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_MuxCreate(UINT32 *muxHandle)
ERR_HANDLER: ERR_HANDLER:
OS_RETURN_ERROR_P2(errLine, errNo); OS_RETURN_ERROR_P2(errLine, errNo);
} }
//LOS_MuxDelete：删除Mutex函数，用于删除指定的Mutex对象及其相关资源
LITE_OS_SEC_TEXT UINT32 LOS_MuxDelete(UINT32 muxHandle) LITE_OS_SEC_TEXT UINT32 LOS_MuxDelete(UINT32 muxHandle)
{ {
UINT32 intSave; UINT32 intSave;
@ -154,7 +156,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_MuxDelete(UINT32 muxHandle)
ERR_HANDLER: ERR_HANDLER:
OS_RETURN_ERROR_P2(errLine, errNo); OS_RETURN_ERROR_P2(errLine, errNo);
} }
//OsMuxParaCheck 函数主要用于验证互斥量操作的参数是否有效，包括互斥量是否被正确创建和传入的句柄是否有效，以及当前是否处于中断上下文
LITE_OS_SEC_TEXT STATIC UINT32 OsMuxParaCheck(const LosMuxCB *muxCB, UINT32 muxHandle) LITE_OS_SEC_TEXT STATIC UINT32 OsMuxParaCheck(const LosMuxCB *muxCB, UINT32 muxHandle)
{ {
if ((muxCB->muxStat == LOS_UNUSED) || (muxCB->muxId != muxHandle)) { if ((muxCB->muxStat == LOS_UNUSED) || (muxCB->muxId != muxHandle)) {
@ -168,7 +170,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 OsMuxParaCheck(const LosMuxCB *muxCB, UINT32 muxH
} }
return LOS_OK; return LOS_OK;
} }
//OsMuxBitmapSet 函数用于在互斥量等待队列中设置任务的优先级位图，并根据需要调整任务的优先级，以确保任务在等待互斥量时能够正确反映其优先级关系
LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapSet(const LosTaskCB *runTask, const MuxBaseCB *muxPended) LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapSet(const LosTaskCB *runTask, const MuxBaseCB *muxPended)
{ {
if (muxPended->owner->priority > runTask->priority) { if (muxPended->owner->priority > runTask->priority) {
@ -176,7 +178,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapSet(const LosTaskCB *runTask, const MuxB
OsTaskPriModify(muxPended->owner, runTask->priority); OsTaskPriModify(muxPended->owner, runTask->priority);
} }
} }
//OsMuxBitmapRestore 函数用于恢复任务的优先级位图，并根据需要更新拥有者任务的优先级
LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapRestore(const LosTaskCB *runTask, LosTaskCB *owner) LITE_OS_SEC_TEXT STATIC VOID OsMuxBitmapRestore(const LosTaskCB *runTask, LosTaskCB *owner)
{ {
UINT16 bitMapPri; UINT16 bitMapPri;
@ -244,7 +246,8 @@ LITE_OS_SEC_TEXT STATIC LOS_DL_LIST *OsMuxPendFindPos(const LosTaskCB *runTask,
return node; return node;
} }
#endif #endif
//总体来说，OsMuxPostOp 函数用于处理 Mutex 的释放操作，包括唤醒等待任务、更新 Mutex 状态和持有者等
//确保 Mutex 能够按照预期的方式被正确释放和传递给下一个任务
LITE_OS_SEC_TEXT UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UINT32 timeout, LITE_OS_SEC_TEXT UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UINT32 timeout,
UINT32 *intSave) UINT32 *intSave)
{ {
@ -270,7 +273,7 @@ LITE_OS_SEC_TEXT UINT32 OsMuxPendOp(LosTaskCB *runTask, MuxBaseCB *muxPended, UI
return ret; return ret;
} }
//LOS_MuxPend：等待Mutex函数，用于尝试获取指定Mutex的访问权限。如果Mutex已被其他任务持有，则当前任务会被挂起，直到Mutex可用
LITE_OS_SEC_TEXT UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout) LITE_OS_SEC_TEXT UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout)
{ {
UINT32 ret; UINT32 ret;
@ -332,7 +335,7 @@ OUT_UNLOCK:
} }
return ret; return ret;
} }
//OsMuxPostOpSub:通过比较当前任务和 Mutex 等待队列中的任务的优先级，来调整当前任务的优先级位图，并将 Mutex 持有者的优先级提升
LITE_OS_SEC_TEXT STATIC VOID OsMuxPostOpSub(LosTaskCB *runTask, MuxBaseCB *muxPosted) LITE_OS_SEC_TEXT STATIC VOID OsMuxPostOpSub(LosTaskCB *runTask, MuxBaseCB *muxPosted)
{ {
LosTaskCB *pendedTask = NULL; LosTaskCB *pendedTask = NULL;
@ -350,7 +353,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsMuxPostOpSub(LosTaskCB *runTask, MuxBaseCB *muxPo
LOS_BitmapClr(&runTask->priBitMap, bitMapPri); LOS_BitmapClr(&runTask->priBitMap, bitMapPri);
OsTaskPriModify(muxPosted->owner, bitMapPri); OsTaskPriModify(muxPosted->owner, bitMapPri);
} }
//
LITE_OS_SEC_TEXT UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted) LITE_OS_SEC_TEXT UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted)
{ {
LosTaskCB *resumedTask = NULL; LosTaskCB *resumedTask = NULL;
@ -386,7 +389,7 @@ LITE_OS_SEC_TEXT UINT32 OsMuxPostOp(LosTaskCB *runTask, MuxBaseCB *muxPosted)
return MUX_SCHEDULE; return MUX_SCHEDULE;
} }
//LOS_MuxPost：释放Mutex函数，用于释放当前任务对指定Mutex的访问权限，以便其他任务可以获取该Mutex
LITE_OS_SEC_TEXT UINT32 LOS_MuxPost(UINT32 muxHandle) LITE_OS_SEC_TEXT UINT32 LOS_MuxPost(UINT32 muxHandle)
{ {
UINT32 ret; UINT32 ret;

2
src/kernel/base/los_percpu.c
Unescape View File

@ -33,7 +33,7 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* __cplusplus */ #endif /* __cplusplus */
//定义全局变量数组，用于存储每个CPU核心的私有数据
Percpu g_percpu[LOSCFG_KERNEL_CORE_NUM]; Percpu g_percpu[LOSCFG_KERNEL_CORE_NUM];
#ifdef __cplusplus #ifdef __cplusplus

14
src/kernel/base/los_printf.c
Unescape View File

@ -32,7 +32,7 @@
* It should not add OS inner invocation, which is not allowed to be accessed in user space. * It should not add OS inner invocation, which is not allowed to be accessed in user space.
* But it's allowed to invoke syscall interface. * But it's allowed to invoke syscall interface.
*---------------------------------------------------------------------------- */ *---------------------------------------------------------------------------- */
/*这段代码是一个输出控制模块，根据不同的输出类型将字符串输出到不同的设备上*/
#ifdef LOSCFG_LIB_LIBC #ifdef LOSCFG_LIB_LIBC
#include "unistd.h" #include "unistd.h"
#endif #endif
@ -62,13 +62,13 @@ typedef enum {
CONSOLE_OUTPUT = 2, CONSOLE_OUTPUT = 2,
EXC_OUTPUT = 3 EXC_OUTPUT = 3
} OutputType; } OutputType;
//ErrorMsg：用于输出错误信息，当字符串输出非法或者vsnprintf_s函数失败时调用
STATIC VOID ErrorMsg(VOID) STATIC VOID ErrorMsg(VOID)
{ {
const CHAR *p = "Output illegal string! vsnprintf_s failed!\n"; const CHAR *p = "Output illegal string! vsnprintf_s failed!\n";
UartPuts(p, (UINT32)strlen(p), UART_WITH_LOCK); UartPuts(p, (UINT32)strlen(p), UART_WITH_LOCK);
} }
//UartOutput：实际将字符串输出到串口的函数，根据配置可能会进行一些额外的处理
STATIC VOID UartOutput(const CHAR *str, UINT32 len, BOOL isLock) STATIC VOID UartOutput(const CHAR *str, UINT32 len, BOOL isLock)
{ {
#ifdef LOSCFG_SHELL_DMESG #ifdef LOSCFG_SHELL_DMESG
@ -82,7 +82,7 @@ STATIC VOID UartOutput(const CHAR *str, UINT32 len, BOOL isLock)
UartPuts(str, len, isLock); UartPuts(str, len, isLock);
#endif #endif
} }
//OutputControl：根据输出类型选择相应的输出设备，并调用对应的输出函数
STATIC VOID OutputControl(const CHAR *str, UINT32 len, OutputType type) STATIC VOID OutputControl(const CHAR *str, UINT32 len, OutputType type)
{ {
switch (type) { switch (type) {
@ -105,14 +105,14 @@ STATIC VOID OutputControl(const CHAR *str, UINT32 len, OutputType type)
} }
return; return;
} }
//OsVprintfFree：释放动态分配的缓冲区内存
STATIC VOID OsVprintfFree(CHAR *buf, UINT32 bufLen) STATIC VOID OsVprintfFree(CHAR *buf, UINT32 bufLen)
{ {
if (bufLen != SIZEBUF) { if (bufLen != SIZEBUF) {
(VOID)LOS_MemFree(m_aucSysMem0, buf); (VOID)LOS_MemFree(m_aucSysMem0, buf);
} }
} }
//OsVprintf：核心函数，根据给定的格式化字符串和可变参数，进行字符串格式化并输出到相应的设备
STATIC VOID OsVprintf(const CHAR *fmt, va_list ap, OutputType type) STATIC VOID OsVprintf(const CHAR *fmt, va_list ap, OutputType type)
{ {
INT32 len; INT32 len;
@ -156,7 +156,7 @@ STATIC VOID OsVprintf(const CHAR *fmt, va_list ap, OutputType type)
OutputControl(bBuf, len, type); OutputControl(bBuf, len, type);
OsVprintfFree(bBuf, bufLen); OsVprintfFree(bBuf, bufLen);
} }
//UartVprintf、ConsoleVprintf、UartPrintf、dprintf、LkDprintf、DmesgPrintf、ExcPrintf、PrintExcInfo：这些函数都是对OsVprintf的封装，提供了不同的输出接口，在不同的场景下调用OsVprintf来完成字符串的格式化和输出
VOID UartVprintf(const CHAR *fmt, va_list ap) VOID UartVprintf(const CHAR *fmt, va_list ap)
{ {
OsVprintf(fmt, ap, UART_OUTPUT); OsVprintf(fmt, ap, UART_OUTPUT);

Write Preview
Loading…
Cancel
Save