Add thread entry function argument.

At-EC · At-EC · commit 5216a3b29221 · 2025-02-04T16:26:59.000+08:00
diff --git a/build_version.h b/build_version.h
@@ -12,11 +12,11 @@
 extern "C" {
 #endif
 
-#define ATOS_BUILD_TIME           "2025-02-04,15:10"
-#define ATOS_COMMIT_HEAD_ID       "a0b28787448a43985e85829c0426dfec46eb8f0f"
+#define ATOS_BUILD_TIME           "2025-02-04,16:26"
+#define ATOS_COMMIT_HEAD_ID       "d85c041e0b12e7bc1bfd22e05f570788e579dc7f"
 #define ATOS_VERSION_MAJOR_NUMBER (2u)
 #define ATOS_VERSION_MINOR_NUMBER (0u)
-#define ATOS_VERSION_PATCH_NUMBER (12u)
+#define ATOS_VERSION_PATCH_NUMBER (13u)
 
 #define ATOS_VERSION_MAJOR_NUMBER_MASK (0x03FFu)
 #define ATOS_VERSION_MAJOR_NUMBER_POS  (22u)
diff --git a/include/at_rtos.h b/include/at_rtos.h
@@ -100,17 +100,19 @@ struct foreach_item {
  * @param pStackAddr The pointer of the thread stack address. The stack memory must be predefined and allocated in your system.
  * @param stackSize The size of the the stack is base on your specified variable.
  * @param priority The thread priority specified the thread's priority when the AtOS do kernel schedule.
+ * @param pArg The thread entry function argument.
  * @param pName The thread name.
  *
  * @return The value of thread unique id.
  */
-static inline os_thread_id_t os_thread_init(u32_t *pStackAddr, u32_t size, i16_t priority, pThread_entryFunc_t pEntryFun,
+static inline os_thread_id_t os_thread_init(u32_t *pStackAddr, u32_t size, i16_t priority, pThread_entryFunc_t pEntryFun, void *pArg,
                                             const char_t *pName)
 {
-    extern u32_t _impl_thread_init(pThread_entryFunc_t pEntryFun, u32_t * pAddress, u32_t size, i16_t priority, const char_t *pName);
+    extern _u32_t _impl_thread_init(pThread_entryFunc_t pEntryFun, _u32_t * pAddress, _u32_t size, _i16_t priority, void *pArg,
+                                    const _char_t *pName);
 
     os_thread_id_t id = {0u};
-    id.u32_val = _impl_thread_init(pEntryFun, pStackAddr, size, priority, pName);
+    id.u32_val = _impl_thread_init(pEntryFun, pStackAddr, size, priority, pArg, pName);
     id.pName = pName;
 
     return id;
@@ -898,7 +900,7 @@ static inline void os_object_free_force(struct os_id id)
 /* It defined the AtOS extern symbol for convenience use, but it has extra memory consumption */
 #ifdef OS_API_ENABLED
 typedef struct {
-    os_thread_id_t (*thread_init)(u32_t *, u32_t, i16_t, pThread_entryFunc_t, const char_t *);
+    os_thread_id_t (*thread_init)(u32_t *, u32_t, i16_t, pThread_entryFunc_t, void *, const char_t *);
     i32p_t (*thread_sleep)(u32_t);
     i32p_t (*thread_resume)(os_thread_id_t);
     i32p_t (*thread_suspend)(os_thread_id_t);
diff --git a/include/kernel.h b/include/kernel.h
@@ -46,15 +46,15 @@ void schedule_setPend(struct schedule_task *pTask);
 list_t *schedule_waitList(void);
 _b_t schedule_hasTwoPendingItem(void);
 _i32p_t kernel_schedule_result_take(void);
-_u32_t kernel_stack_frame_init(void (*pEntryFunction)(void), _u32_t *pAddress, _u32_t size);
+_u32_t kernel_stack_frame_init(void (*pEntryFn)(void *), _u32_t *pAddress, _u32_t size, void *p_arg);
 _b_t kernel_isInThreadMode(void);
 _i32p_t kernel_thread_schedule_request(void);
 void kernel_message_notification(void);
 void kernel_scheduler_inPendSV_c(_u32_t **ppCurPsp, _u32_t **ppNextPSP);
 void kernel_privilege_call_inSVC_c(_u32_t *svc_args);
 _i32p_t kernel_privilege_invoke(const void *pCallFun, arguments_t *pArgs);
-void kernel_schedule_thread(void);
-void kernel_idle_thread(void);
+void kernel_schedule_thread(void *p_arg);
+void kernel_idle_thread(void *p_arg);
 void kthread_message_notification(void);
 _i32p_t kthread_message_arrived(void);
 void kthread_message_idle_loop_fn(void);
diff --git a/include/kstruct.h b/include/kstruct.h
@@ -25,7 +25,7 @@
 typedef void (*pCallbackFunc_t)(void);
 typedef void (*pTimer_callbackFunc_t)(void *);
 typedef void (*pTask_callbackFunc_t)(void *);
-typedef void (*pThread_entryFunc_t)(void);
+typedef void (*pThread_entryFunc_t)(void *);
 typedef void (*pEvent_callbackFunc_t)(void);
 typedef void (*pSubscribe_callbackFunc_t)(const void *, _u16_t);
 typedef void (*pTimeout_callbackFunc_t)(void *);
@@ -269,7 +269,8 @@ struct thread_context {
 typedef struct thread_context thread_context_t;
 
 typedef struct {
-    struct thread_context *pThread;
+    struct thread_context *p_thread;
+    void *p_arg;
 } thread_context_init_t;
 
 /** @brief The rtos kernel structure. */
diff --git a/include/port/port.h b/include/port/port.h
@@ -312,7 +312,7 @@ _u32_t port_irq_disable(void);
 void port_irq_enable(_u32_t value);
 void port_setPendSV(void);
 void port_interrupt_init(void);
-_u32_t port_stack_frame_init(void (*pEntryFunction)(void), _u32_t *pAddress, _u32_t size);
+_u32_t port_stack_frame_init(void (*pEntryFn)(void*), _u32_t *pAddress, _u32_t size, void *pArg);
 _u32_t port_stack_free_size_get(_u32_t stack_addr);
 
 #endif /* _PORT_H_ */
diff --git a/include/static_init.h b/include/static_init.h
@@ -73,7 +73,7 @@
 #define INIT_OS_THREAD_RUNTIME_NUM_DEFINE(num)                                                                                             \
     INIT_USED thread_context_t _init_runtime_thread[num] INIT_SECTION(_INIT_OS_THREAD_LIST) = {0}
 
-#define INIT_OS_THREAD_DEFINE(id_name, priority, stack_size, pEntryFn)                                                                     \
+#define INIT_OS_THREAD_DEFINE(id_name, priority, stack_size, pEntryFn, pArg)                                                               \
     STACK_STATIC_VALUE_DEFINE(id_name##_stack, stack_size);                                                                                \
     INIT_USED thread_context_t _init_##id_name##_thread INIT_SECTION(_INIT_OS_THREAD_LIST) =                                               \
         {.head = {.cs = CS_INITED, .pName = #id_name},                                                                                     \
@@ -82,7 +82,7 @@
          .pEntryFunc = pEntryFn,                                                                                                           \
          .task = {.prior = priority, .psp = 0u}};                                                                                          \
     INIT_USED thread_context_init_t _init_##id_name##_thread_init INIT_SECTION(_INIT_OS_THREAD_STATIC) =                                   \
-        {.pThread = &_init_##id_name##_thread};                                                                                            \
+        {.p_thread = &_init_##id_name##_thread, .p_arg = pArg};                                                                            \
     os_thread_id_t id_name = {.p_val = (void*)&_init_##id_name##_thread, .pName = #id_name}
 
 #define INIT_OS_TIMER_RUNTIME_NUM_DEFINE(num)                                                                                              \
@@ -188,7 +188,7 @@ extern void subscribe_notification(void *pLinker);
 #define INIT_OS_THREAD_RUNTIME_NUM_DEFINE(num)                                                                                             \
     static __root thread_context_t _init_runtime_thread[num] @ "_INIT_OS_THREAD_LIST" = {0}
 
-#define INIT_OS_THREAD_DEFINE(id_name, priority, stack_size, pEntryFn)                                                                     \
+#define INIT_OS_THREAD_DEFINE(id_name, priority, stack_size, pEntryFn, pArg)                                                               \
     STACK_STATIC_VALUE_DEFINE(id_name##_stack, stack_size);                                                                                \
     static __root thread_context_t _init_##id_name##_thread @ "_INIT_OS_THREAD_LIST" =                                                     \
         {.head = {.cs = CS_INITED, .pName = #id_name},                                                                                     \
@@ -197,7 +197,7 @@ extern void subscribe_notification(void *pLinker);
          .pEntryFunc = pEntryFn,                                                                                                           \
          .task = {.prior = priority, .psp = 0u}};                                                                                          \
     static __root thread_context_init_t _init_##id_name##_thread_init @ "_INIT_OS_THREAD_STATIC" =                                         \
-        {.pThread = &_init_##id_name##_thread};                                                                                            \
+        {.p_thread = &_init_##id_name##_thread, .p_arg = pArg};                                                                            \
     os_thread_id_t id_name = {.p_val = (void*)&_init_##id_name##_thread, .pName = #id_name}
 
 #define INIT_OS_TIMER_RUNTIME_NUM_DEFINE(num)                                                                                              \
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
     "name":  "At-RTOS",
     "homepage":  "https://github.com/At-EC/At-RTOS",
-    "version":  "2.0.12",
-    "timestamp":  "2025-02-04,15:10",
-    "commit_id":  "e67d6b6d5955a438a676872675d7cbc0cbb5df19"
+    "version":  "2.0.13",
+    "timestamp":  "2025-02-04,16:26",
+    "commit_id":  "a0b28787448a43985e85829c0426dfec46eb8f0f"
 }
diff --git a/source/kernel.c b/source/kernel.c
@@ -374,9 +374,9 @@ static _i32p_t _kernel_message_arrived(void)
  *
  * @return The PSP stack address.
  */
-_u32_t kernel_stack_frame_init(void (*pEntryFunction)(void), _u32_t *pAddress, _u32_t size)
+_u32_t kernel_stack_frame_init(void (*pEntryFn)(void*), _u32_t *pAddress, _u32_t size, void *p_arg)
 {
-    return (_u32_t)port_stack_frame_init(pEntryFunction, pAddress, size);
+    return (_u32_t)port_stack_frame_init(pEntryFn, pAddress, size, p_arg);
 }
 
 /**
@@ -442,7 +442,7 @@ void kernel_message_notification(void)
 /**
  * @brief The kernel thread only serve for RTOS with highest priority.
  */
-void kernel_schedule_thread(void)
+void kernel_schedule_thread(void* p_arg)
 {
     while (1) {
         PC_IF(_kernel_message_arrived(), PC_PASS)
@@ -458,7 +458,7 @@ void kernel_schedule_thread(void)
 /**
  * @brief The idle thread entry function.
  */
-void kernel_idle_thread(void)
+void kernel_idle_thread(void* p_arg)
 {
     while (1) {
         kthread_message_idle_loop_fn();
diff --git a/source/kthread.c b/source/kthread.c
@@ -19,8 +19,8 @@ INIT_OS_POOL_RUNTIME_NUM_DEFINE(POOL_RUNTIME_NUMBER_SUPPORTED);
 INIT_OS_PUBLISH_RUNTIME_NUM_DEFINE(PUBLISH_RUNTIME_NUMBER_SUPPORTED);
 INIT_OS_SUBSCRIBE_RUNTIME_NUM_DEFINE(SUBSCRIBE_RUNTIME_NUMBER_SUPPORTED);
 
-INIT_OS_THREAD_DEFINE(kernel_th, OS_PRIORITY_KERNEL_SCHEDULE_LEVEL, KERNEL_SCHEDULE_THREAD_STACK_SIZE, kernel_schedule_thread);
-INIT_OS_THREAD_DEFINE(idle_th, OS_PRIORITY_KERNEL_IDLE_LEVEL, KERNEL_IDLE_THREAD_STACK_SIZE, kernel_idle_thread);
+INIT_OS_THREAD_DEFINE(kernel_th, OS_PRIORITY_KERNEL_SCHEDULE_LEVEL, KERNEL_SCHEDULE_THREAD_STACK_SIZE, kernel_schedule_thread, NULL);
+INIT_OS_THREAD_DEFINE(idle_th, OS_PRIORITY_KERNEL_IDLE_LEVEL, KERNEL_IDLE_THREAD_STACK_SIZE, kernel_idle_thread, NULL);
 INIT_OS_SEMAPHORE_DEFINE(kernel_sem, 0u, OS_SEM_LIMIT_BINARY);
 
 static pThread_entryFunc_t g_idle_thread_user_entry_fn = NULL;
@@ -121,7 +121,7 @@ _i32p_t kthread_message_arrived(void)
 void kthread_message_idle_loop_fn(void)
 {
     if (g_idle_thread_user_entry_fn) {
-        g_idle_thread_user_entry_fn();
+        g_idle_thread_user_entry_fn(NULL);
     }
 }
 
diff --git a/source/port/port_common.c b/source/port/port_common.c
@@ -84,29 +84,32 @@ void port_interrupt_init(void)
 /**
  * @brief Initialize a thread stack frame.
  *
- * @param pEntryFunction The entry function pointer.
+ * @param pEntryFn The entry function pointer.
  * @param pAddress The stack address.
  * @param size The stack size.
  *
  * @return The PSP stack address.
  */
-_u32_t port_stack_frame_init(void (*pEntryFunction)(void), _u32_t *pAddress, _u32_t size)
+_u32_t port_stack_frame_init(void (*pEntryFn)(void *), _u32_t *pAddress, _u32_t size, void *pArg)
 {
+    extern void _impl_thread_entry(void (*pEntryFn)(void *), void *pArg);
+
     os_memset((_uchar_t *)pAddress, STACT_UNUSED_DATA, size);
 
     _u32_t psp_frame = (_u32_t)pAddress + size - sizeof(stack_snapshot_t);
 
     psp_frame = STACK_ADDRESS_DOWN(psp_frame);
 
-    ((stack_snapshot_t *)psp_frame)->xPSR = B(24);                    /* xPSR */
-    ((stack_snapshot_t *)psp_frame)->R15_PC = (_u32_t)pEntryFunction; /* PC   */
-    ((stack_snapshot_t *)psp_frame)->R14_LR = 0xFFFFFFFDu;            /* LR   */
+    ((stack_snapshot_t *)psp_frame)->xPSR = B(24);                        /* xPSR */
+    ((stack_snapshot_t *)psp_frame)->R15_PC = (_u32_t)_impl_thread_entry; /* PC   */
+    ((stack_snapshot_t *)psp_frame)->R15_PC &= 0xFFFFFFFEu;               /* ARM mode: Clear LSB of address */
+    ((stack_snapshot_t *)psp_frame)->R14_LR = 0xFFFFFFFDu;                /* LR   */
 
-    ((stack_snapshot_t *)psp_frame)->R12 = 0x12121212u; /* R12  */
-    ((stack_snapshot_t *)psp_frame)->R3 = 0x03030303u;  /* R3   */
-    ((stack_snapshot_t *)psp_frame)->R2 = 0x02020202u;  /* R2   */
-    ((stack_snapshot_t *)psp_frame)->R1 = 0x01010101u;  /* R1   */
-    ((stack_snapshot_t *)psp_frame)->R0 = 0x0B0B0B0Bu;  /* R0   */
+    ((stack_snapshot_t *)psp_frame)->R12 = 0x12121212u;     /* R12  */
+    ((stack_snapshot_t *)psp_frame)->R3 = 0x03030303u;      /* R3   */
+    ((stack_snapshot_t *)psp_frame)->R2 = 0x02020202u;      /* R2   */
+    ((stack_snapshot_t *)psp_frame)->R1 = (_u32_t)pArg;     /* R1   */
+    ((stack_snapshot_t *)psp_frame)->R0 = (_u32_t)pEntryFn; /* R0   */
 
 #if defined(ARCH_ARM_CORTEX_CM0)
     ((stack_snapshot_t *)psp_frame)->cm0.R11 = 0x11111111u; /* R11  */
@@ -154,7 +157,7 @@ _u32_t port_stack_free_size_get(_u32_t stack_addr)
         return 0u;
     }
 
-    uint8_t *ptr = (uint8_t *)stack_addr;
+    _u8_t *ptr = (_u8_t *)stack_addr;
     while (*ptr == STACT_UNUSED_DATA) {
         ptr++;
     }
diff --git a/source/static_init.c b/source/static_init.c
@@ -25,12 +25,12 @@ void init_func_list(void)
 
 void init_static_thread_list(void)
 {
-    extern void _impl_thread_static_init(thread_context_t * pCurThread);
+    extern void _impl_thread_static_init(thread_context_t *pCurThread, void *p_arg);
 
     INIT_SECTION_FOREACH(INIT_SECTION_OS_THREAD_STATIC, thread_context_init_t, pInit)
     {
-        if (pInit->pThread) {
-            _impl_thread_static_init(pInit->pThread);
+        if (pInit->p_thread) {
+            _impl_thread_static_init(pInit->p_thread, pInit->p_arg);
         }
     }
 }
diff --git a/source/thread.c b/source/thread.c
@@ -8,7 +8,6 @@
 #include "timer.h"
 #include "postcode.h"
 #include "trace.h"
-#include "init.h"
 
 /**
  * Local unique postcode.
@@ -58,7 +57,8 @@ static _u32_t _thread_init_privilege_routine(arguments_t *pArgs)
     _u32_t *pAddress = (_u32_t *)pArgs[1].u32_val;
     _u32_t size = (_u32_t)pArgs[2].u32_val;
     _i16_t priority = (_i16_t)pArgs[3].u16_val;
-    const _char_t *pName = (const _char_t *)pArgs[4].pch_val;
+    void *p_arg = (void *)pArgs[4].pv_val;
+    const _char_t *pName = (const _char_t *)pArgs[5].pch_val;
 
     INIT_SECTION_FOREACH(INIT_SECTION_OS_THREAD_LIST, thread_context_t, pCurThread)
     {
@@ -79,7 +79,7 @@ static _u32_t _thread_init_privilege_routine(arguments_t *pArgs)
         pCurThread->stackSize = size;
 
         pCurThread->task.prior = priority;
-        pCurThread->task.psp = (_u32_t)kernel_stack_frame_init(pEntryFun, pAddress, size);
+        pCurThread->task.psp = (_u32_t)kernel_stack_frame_init(pEntryFun, pAddress, size, p_arg);
         timeout_init(&pCurThread->task.expire, schedule_callback_fromTimeOut);
         schedule_setPend(&pCurThread->task);
 
@@ -279,17 +279,23 @@ const _char_t *_impl_thread_name_get(_u32_t ctx)
     return (const _char_t *)((pCtx) ? (pCtx->head.pName) : (NULL));
 }
 
-void _impl_thread_static_init(thread_context_t *pCurThread)
+void _impl_thread_static_init(thread_context_t *pCurThread, void *p_arg)
 {
     ENTER_CRITICAL_SECTION();
 
-    pCurThread->task.psp = (_u32_t)kernel_stack_frame_init(pCurThread->pEntryFunc, pCurThread->pStackAddr, pCurThread->stackSize);
+    pCurThread->task.psp = (_u32_t)kernel_stack_frame_init(pCurThread->pEntryFunc, pCurThread->pStackAddr, pCurThread->stackSize, p_arg);
     timeout_init(&pCurThread->task.expire, schedule_callback_fromTimeOut);
     schedule_setPend(&pCurThread->task);
 
     EXIT_CRITICAL_SECTION();
 }
 
+void _impl_thread_entry(pThread_entryFunc_t pEntryFn, void *pArg)
+{
+    pEntryFn(pArg);
+    RUN_UNREACHABLE();
+}
+
 /**
  * @brief Initialize a new thread.
  *
@@ -301,7 +307,7 @@ void _impl_thread_static_init(thread_context_t *pCurThread)
  *
  * @return The value of thread unique id.
  */
-_u32_t _impl_thread_init(pThread_entryFunc_t pEntryFun, _u32_t *pAddress, _u32_t size, _i16_t priority, const _char_t *pName)
+_u32_t _impl_thread_init(pThread_entryFunc_t pEntryFun, _u32_t *pAddress, _u32_t size, _i16_t priority, void *pArg, const _char_t *pName)
 {
     if (!pEntryFun) {
         return OS_INVALID_ID_VAL;
@@ -324,8 +330,8 @@ _u32_t _impl_thread_init(pThread_entryFunc_t pEntryFun, _u32_t *pAddress, _u32_t
     }
 
     arguments_t arguments[] = {
-        [0] = {.ptr_val = (void *)pEntryFun}, [1] = {.u32_val = (_u32_t)pAddress},    [2] = {.u32_val = (_u32_t)size},
-        [3] = {.u16_val = (_i16_t)priority},  [4] = {.pch_val = (const void *)pName},
+        [0] = {.ptr_val = (void *)pEntryFun}, [1] = {.u32_val = (_u32_t)pAddress}, [2] = {.u32_val = (_u32_t)size},
+        [3] = {.u16_val = (_i16_t)priority},  [4] = {.pv_val = (void *)pArg},      [5] = {.pch_val = (const void *)pName},
     };
 
     return kernel_privilege_invoke((const void *)_thread_init_privilege_routine, arguments);

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "At-RTOS",`
`3`	`3`	`"homepage": "https://github.com/At-EC/At-RTOS",`
`4`		`- "version": "2.0.12",`
`5`		`- "timestamp": "2025-02-04,15:10",`
`6`		`- "commit_id": "e67d6b6d5955a438a676872675d7cbc0cbb5df19"`
	`4`	`+ "version": "2.0.13",`
	`5`	`+ "timestamp": "2025-02-04,16:26",`
	`6`	`+ "commit_id": "a0b28787448a43985e85829c0426dfec46eb8f0f"`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -374,9 +374,9 @@ static _i32p_t _kernel_message_arrived(void)`
`374`	`374`	`*`
`375`	`375`	`* @return The PSP stack address.`
`376`	`376`	`*/`
`377`		`-_u32_t kernel_stack_frame_init(void (pEntryFunction)(void), _u32_t pAddress, _u32_t size)`
	`377`	`+_u32_t kernel_stack_frame_init(void (pEntryFn)(void), _u32_t pAddress, _u32_t size, void p_arg)`
`378`	`378`	`{`
`379`		`- return (_u32_t)port_stack_frame_init(pEntryFunction, pAddress, size);`
	`379`	`+ return (_u32_t)port_stack_frame_init(pEntryFn, pAddress, size, p_arg);`
`380`	`380`	`}`
`381`	`381`
`382`	`382`	`/**`
`@@ -442,7 +442,7 @@ void kernel_message_notification(void)`
`442`	`442`	`/**`
`443`	`443`	`* @brief The kernel thread only serve for RTOS with highest priority.`
`444`	`444`	`*/`
`445`		`-void kernel_schedule_thread(void)`
	`445`	`+void kernel_schedule_thread(void* p_arg)`
`446`	`446`	`{`
`447`	`447`	`while (1) {`
`448`	`448`	`PC_IF(_kernel_message_arrived(), PC_PASS)`
`@@ -458,7 +458,7 @@ void kernel_schedule_thread(void)`
`458`	`458`	`/**`
`459`	`459`	`* @brief The idle thread entry function.`
`460`	`460`	`*/`
`461`		`-void kernel_idle_thread(void)`
	`461`	`+void kernel_idle_thread(void* p_arg)`
`462`	`462`	`{`
`463`	`463`	`while (1) {`
`464`	`464`	`kthread_message_idle_loop_fn();`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@ INIT_OS_POOL_RUNTIME_NUM_DEFINE(POOL_RUNTIME_NUMBER_SUPPORTED);`
`19`	`19`	`INIT_OS_PUBLISH_RUNTIME_NUM_DEFINE(PUBLISH_RUNTIME_NUMBER_SUPPORTED);`
`20`	`20`	`INIT_OS_SUBSCRIBE_RUNTIME_NUM_DEFINE(SUBSCRIBE_RUNTIME_NUMBER_SUPPORTED);`
`21`	`21`
`22`		`-INIT_OS_THREAD_DEFINE(kernel_th, OS_PRIORITY_KERNEL_SCHEDULE_LEVEL, KERNEL_SCHEDULE_THREAD_STACK_SIZE, kernel_schedule_thread);`
`23`		`-INIT_OS_THREAD_DEFINE(idle_th, OS_PRIORITY_KERNEL_IDLE_LEVEL, KERNEL_IDLE_THREAD_STACK_SIZE, kernel_idle_thread);`
	`22`	`+INIT_OS_THREAD_DEFINE(kernel_th, OS_PRIORITY_KERNEL_SCHEDULE_LEVEL, KERNEL_SCHEDULE_THREAD_STACK_SIZE, kernel_schedule_thread, NULL);`
	`23`	`+INIT_OS_THREAD_DEFINE(idle_th, OS_PRIORITY_KERNEL_IDLE_LEVEL, KERNEL_IDLE_THREAD_STACK_SIZE, kernel_idle_thread, NULL);`
`24`	`24`	`INIT_OS_SEMAPHORE_DEFINE(kernel_sem, 0u, OS_SEM_LIMIT_BINARY);`
`25`	`25`
`26`	`26`	`static pThread_entryFunc_t g_idle_thread_user_entry_fn = NULL;`
`@@ -121,7 +121,7 @@ _i32p_t kthread_message_arrived(void)`
`121`	`121`	`void kthread_message_idle_loop_fn(void)`
`122`	`122`	`{`
`123`	`123`	`if (g_idle_thread_user_entry_fn) {`
`124`		`- g_idle_thread_user_entry_fn();`
	`124`	`+ g_idle_thread_user_entry_fn(NULL);`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`