From 076941612a5105acd51a42e5c0d36eb632f5dffa Mon Sep 17 00:00:00 2001
From: Meco Man <920369182@qq.com>
Date: Fri, 4 Jun 2021 00:34:27 +0800
Subject: [PATCH 1/3] =?UTF-8?q?[kernel]=20=E8=A7=84=E8=8C=83=E5=86=85?=
 =?UTF-8?q?=E6=A0=B8=E5=86=85=E9=83=A8=E5=87=BD=E6=95=B0=E5=91=BD=E5=90=8D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/idle.c      |   4 +-
 src/ipc.c       | 102 ++++++++++++++++++++++++------------------------
 src/scheduler.c |  14 +++----
 3 files changed, 60 insertions(+), 60 deletions(-)

diff --git a/src/idle.c b/src/idle.c
index 59868352d8..317ee76926 100644
--- a/src/idle.c
+++ b/src/idle.c
@@ -129,7 +129,7 @@ rt_err_t rt_thread_idle_delhook(void (*hook)(void))
 
 #ifdef RT_USING_HEAP
 /* Return whether there is defunctional thread to be deleted. */
-rt_inline int _has_defunct_thread(void)
+rt_inline int _rt_has_defunct_thread(void)
 {
     /* The rt_list_isempty has prototype of "int rt_list_isempty(const rt_list_t *l)".
      * So the compiler has a good reason that the rt_thread_defunct list does
@@ -165,7 +165,7 @@ void rt_thread_idle_excute(void)
         lock = rt_hw_interrupt_disable();
 
         /* check whether list is empty */
-        if (!_has_defunct_thread())
+        if (!_rt_has_defunct_thread())
         {
             rt_hw_interrupt_enable(lock);
             break;
diff --git a/src/ipc.c b/src/ipc.c
index 6cd38b74ab..311724f0a6 100755
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -64,7 +64,7 @@ extern void (*rt_object_put_hook)(struct rt_object *object);
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t rt_ipc_object_init(struct rt_ipc_object *ipc)
+rt_inline rt_err_t _rt_ipc_object_init(struct rt_ipc_object *ipc)
 {
     /* initialize ipc object */
     rt_list_init(&(ipc->suspend_thread));
@@ -83,7 +83,7 @@ rt_inline rt_err_t rt_ipc_object_init(struct rt_ipc_object *ipc)
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t        *list,
+rt_inline rt_err_t _rt_ipc_list_suspend(rt_list_t        *list,
                                        struct rt_thread *thread,
                                        rt_uint8_t        flag)
 {
@@ -141,7 +141,7 @@ rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t        *list,
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list)
+rt_inline rt_err_t _rt_ipc_list_resume(rt_list_t *list)
 {
     struct rt_thread *thread;
 
@@ -164,7 +164,7 @@ rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list)
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t rt_ipc_list_resume_all(rt_list_t *list)
+rt_inline rt_err_t _rt_ipc_list_resume_all(rt_list_t *list)
 {
     struct rt_thread *thread;
     register rt_ubase_t temp;
@@ -202,7 +202,7 @@ rt_inline rt_err_t rt_ipc_list_resume_all(rt_list_t *list)
  *
  * @return the highest priority
  */
-rt_uint8_t rt_ipc_get_highest_priority(rt_list_t *list)
+rt_uint8_t _rt_ipc_get_highest_priority(rt_list_t *list)
 {
     struct rt_list_node *n;
     struct rt_thread *sthread;
@@ -243,7 +243,7 @@ rt_err_t rt_sem_init(rt_sem_t    sem,
     rt_object_init(&(sem->parent.parent), RT_Object_Class_Semaphore, name);
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(sem->parent));
+    _rt_ipc_object_init(&(sem->parent));
 
     /* set initial value */
     sem->value = (rt_uint16_t)value;
@@ -272,7 +272,7 @@ rt_err_t rt_sem_detach(rt_sem_t sem)
     RT_ASSERT(rt_object_is_systemobject(&sem->parent.parent));
 
     /* wakeup all suspended threads */
-    rt_ipc_list_resume_all(&(sem->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(sem->parent.suspend_thread));
 
     /* detach semaphore object */
     rt_object_detach(&(sem->parent.parent));
@@ -306,7 +306,7 @@ rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag)
         return sem;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(sem->parent));
+    _rt_ipc_object_init(&(sem->parent));
 
     /* set initial value */
     sem->value = value;
@@ -337,7 +337,7 @@ rt_err_t rt_sem_delete(rt_sem_t sem)
     RT_ASSERT(rt_object_is_systemobject(&sem->parent.parent) == RT_FALSE);
 
     /* wakeup all suspended threads */
-    rt_ipc_list_resume_all(&(sem->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(sem->parent.suspend_thread));
 
     /* delete semaphore object */
     rt_object_delete(&(sem->parent.parent));
@@ -408,7 +408,7 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time)
                                         thread->name));
 
             /* suspend thread */
-            rt_ipc_list_suspend(&(sem->parent.suspend_thread),
+            _rt_ipc_list_suspend(&(sem->parent.suspend_thread),
                                 thread,
                                 sem->parent.parent.flag);
 
@@ -489,7 +489,7 @@ rt_err_t rt_sem_release(rt_sem_t sem)
     if (!rt_list_isempty(&sem->parent.suspend_thread))
     {
         /* resume the suspended thread */
-        rt_ipc_list_resume(&(sem->parent.suspend_thread));
+        _rt_ipc_list_resume(&(sem->parent.suspend_thread));
         need_schedule = RT_TRUE;
     }
     else
@@ -543,7 +543,7 @@ rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        rt_ipc_list_resume_all(&sem->parent.suspend_thread);
+        _rt_ipc_list_resume_all(&sem->parent.suspend_thread);
 
         /* set new value */
         sem->value = (rt_uint16_t)value;
@@ -581,7 +581,7 @@ rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag)
     rt_object_init(&(mutex->parent.parent), RT_Object_Class_Mutex, name);
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(mutex->parent));
+    _rt_ipc_object_init(&(mutex->parent));
 
     mutex->value = 1;
     mutex->owner = RT_NULL;
@@ -612,7 +612,7 @@ rt_err_t rt_mutex_detach(rt_mutex_t mutex)
     RT_ASSERT(rt_object_is_systemobject(&mutex->parent.parent));
 
     /* wakeup all suspended threads */
-    rt_ipc_list_resume_all(&(mutex->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(mutex->parent.suspend_thread));
 
     /* detach semaphore object */
     rt_object_detach(&(mutex->parent.parent));
@@ -644,7 +644,7 @@ rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag)
         return mutex;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(mutex->parent));
+    _rt_ipc_object_init(&(mutex->parent));
 
     mutex->value              = 1;
     mutex->owner              = RT_NULL;
@@ -677,7 +677,7 @@ rt_err_t rt_mutex_delete(rt_mutex_t mutex)
     RT_ASSERT(rt_object_is_systemobject(&mutex->parent.parent) == RT_FALSE);
 
     /* wakeup all suspended threads */
-    rt_ipc_list_resume_all(&(mutex->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(mutex->parent.suspend_thread));
 
     /* delete mutex object */
     rt_object_delete(&(mutex->parent.parent));
@@ -791,7 +791,7 @@ __again:
                 }
 
                 /* suspend current thread */
-                rt_ipc_list_suspend(&(mutex->parent.suspend_thread),
+                _rt_ipc_list_suspend(&(mutex->parent.suspend_thread),
                                     thread,
                                     mutex->parent.parent.flag);
 
@@ -938,7 +938,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
              * 2.The priority of the thread to be resumed is not equal to the
              *   highest priority in the queue;
              */
-            max_priority_in_queue = rt_ipc_get_highest_priority(&mutex->parent.suspend_thread);
+            max_priority_in_queue = _rt_ipc_get_highest_priority(&mutex->parent.suspend_thread);
             if (mutex->parent.parent.flag == RT_IPC_FLAG_FIFO &&
                 thread->current_priority != max_priority_in_queue)
             {
@@ -958,7 +958,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
             }
 
             /* resume thread */
-            rt_ipc_list_resume(&(mutex->parent.suspend_thread));
+            _rt_ipc_list_resume(&(mutex->parent.suspend_thread));
 
             need_schedule = RT_TRUE;
         }
@@ -1035,7 +1035,7 @@ rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag)
     event->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(event->parent));
+    _rt_ipc_object_init(&(event->parent));
 
     /* initialize event */
     event->set = 0;
@@ -1059,7 +1059,7 @@ rt_err_t rt_event_detach(rt_event_t event)
     RT_ASSERT(rt_object_is_systemobject(&event->parent.parent));
 
     /* resume all suspended thread */
-    rt_ipc_list_resume_all(&(event->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(event->parent.suspend_thread));
 
     /* detach event object */
     rt_object_detach(&(event->parent.parent));
@@ -1092,7 +1092,7 @@ rt_event_t rt_event_create(const char *name, rt_uint8_t flag)
     event->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(event->parent));
+    _rt_ipc_object_init(&(event->parent));
 
     /* initialize event */
     event->set = 0;
@@ -1118,7 +1118,7 @@ rt_err_t rt_event_delete(rt_event_t event)
     RT_DEBUG_NOT_IN_INTERRUPT;
 
     /* resume all suspended thread */
-    rt_ipc_list_resume_all(&(event->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(event->parent.suspend_thread));
 
     /* delete event object */
     rt_object_delete(&(event->parent.parent));
@@ -1321,7 +1321,7 @@ rt_err_t rt_event_recv(rt_event_t   event,
         thread->event_info = option;
 
         /* put thread to suspended thread list */
-        rt_ipc_list_suspend(&(event->parent.suspend_thread),
+        _rt_ipc_list_suspend(&(event->parent.suspend_thread),
                             thread,
                             event->parent.parent.flag);
 
@@ -1387,7 +1387,7 @@ rt_err_t rt_event_control(rt_event_t event, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        rt_ipc_list_resume_all(&event->parent.suspend_thread);
+        _rt_ipc_list_resume_all(&event->parent.suspend_thread);
 
         /* initialize event set */
         event->set = 0;
@@ -1433,7 +1433,7 @@ rt_err_t rt_mb_init(rt_mailbox_t mb,
     mb->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(mb->parent));
+    _rt_ipc_object_init(&(mb->parent));
 
     /* initialize mailbox */
     mb->msg_pool   = (rt_ubase_t *)msgpool;
@@ -1464,9 +1464,9 @@ rt_err_t rt_mb_detach(rt_mailbox_t mb)
     RT_ASSERT(rt_object_is_systemobject(&mb->parent.parent));
 
     /* resume all suspended thread */
-    rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
     /* also resume all mailbox private suspended thread */
-    rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
+    _rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
 
     /* detach mailbox object */
     rt_object_detach(&(mb->parent.parent));
@@ -1500,7 +1500,7 @@ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag)
     mb->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(mb->parent));
+    _rt_ipc_object_init(&(mb->parent));
 
     /* initialize mailbox */
     mb->size     = size;
@@ -1540,10 +1540,10 @@ rt_err_t rt_mb_delete(rt_mailbox_t mb)
     RT_ASSERT(rt_object_is_systemobject(&mb->parent.parent) == RT_FALSE);
 
     /* resume all suspended thread */
-    rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
 
     /* also resume all mailbox private suspended thread */
-    rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
+    _rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
 
     /* free mailbox pool */
     RT_KERNEL_FREE(mb->msg_pool);
@@ -1612,7 +1612,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
 
         RT_DEBUG_IN_THREAD_CONTEXT;
         /* suspend current thread */
-        rt_ipc_list_suspend(&(mb->suspend_sender_thread),
+        _rt_ipc_list_suspend(&(mb->suspend_sender_thread),
                             thread,
                             mb->parent.parent.flag);
 
@@ -1679,7 +1679,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
     /* resume suspended thread */
     if (!rt_list_isempty(&mb->parent.suspend_thread))
     {
-        rt_ipc_list_resume(&(mb->parent.suspend_thread));
+        _rt_ipc_list_resume(&(mb->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -1760,7 +1760,7 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value)
     /* resume suspended thread */
     if (!rt_list_isempty(&mb->parent.suspend_thread))
     {
-        rt_ipc_list_resume(&(mb->parent.suspend_thread));
+        _rt_ipc_list_resume(&(mb->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -1834,7 +1834,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
 
         RT_DEBUG_IN_THREAD_CONTEXT;
         /* suspend current thread */
-        rt_ipc_list_suspend(&(mb->parent.suspend_thread),
+        _rt_ipc_list_suspend(&(mb->parent.suspend_thread),
                             thread,
                             mb->parent.parent.flag);
 
@@ -1897,7 +1897,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
     /* resume suspended thread */
     if (!rt_list_isempty(&(mb->suspend_sender_thread)))
     {
-        rt_ipc_list_resume(&(mb->suspend_sender_thread));
+        _rt_ipc_list_resume(&(mb->suspend_sender_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -1941,9 +1941,9 @@ rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
+        _rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
         /* also resume all mailbox private suspended thread */
-        rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
+        _rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
 
         /* re-init mailbox */
         mb->entry      = 0;
@@ -2002,7 +2002,7 @@ rt_err_t rt_mq_init(rt_mq_t     mq,
     mq->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(mq->parent));
+    _rt_ipc_object_init(&(mq->parent));
 
     /* set message pool */
     mq->msg_pool = msgpool;
@@ -2050,9 +2050,9 @@ rt_err_t rt_mq_detach(rt_mq_t mq)
     RT_ASSERT(rt_object_is_systemobject(&mq->parent.parent));
 
     /* resume all suspended thread */
-    rt_ipc_list_resume_all(&mq->parent.suspend_thread);
+    _rt_ipc_list_resume_all(&mq->parent.suspend_thread);
     /* also resume all message queue private suspended thread */
-    rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
+    _rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
 
     /* detach message queue object */
     rt_object_detach(&(mq->parent.parent));
@@ -2092,7 +2092,7 @@ rt_mq_t rt_mq_create(const char *name,
     mq->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    rt_ipc_object_init(&(mq->parent));
+    _rt_ipc_object_init(&(mq->parent));
 
     /* initialize message queue */
 
@@ -2150,9 +2150,9 @@ rt_err_t rt_mq_delete(rt_mq_t mq)
     RT_ASSERT(rt_object_is_systemobject(&mq->parent.parent) == RT_FALSE);
 
     /* resume all suspended thread */
-    rt_ipc_list_resume_all(&(mq->parent.suspend_thread));
+    _rt_ipc_list_resume_all(&(mq->parent.suspend_thread));
     /* also resume all message queue private suspended thread */
-    rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
+    _rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
 
     /* free message queue pool */
     RT_KERNEL_FREE(mq->msg_pool);
@@ -2234,7 +2234,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
 
         RT_DEBUG_IN_THREAD_CONTEXT;
         /* suspend current thread */
-        rt_ipc_list_suspend(&(mq->suspend_sender_thread),
+        _rt_ipc_list_suspend(&(mq->suspend_sender_thread),
                             thread,
                             mq->parent.parent.flag);
 
@@ -2320,7 +2320,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     /* resume suspended thread */
     if (!rt_list_isempty(&mq->parent.suspend_thread))
     {
-        rt_ipc_list_resume(&(mq->parent.suspend_thread));
+        _rt_ipc_list_resume(&(mq->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -2428,7 +2428,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
     /* resume suspended thread */
     if (!rt_list_isempty(&mq->parent.suspend_thread))
     {
-        rt_ipc_list_resume(&(mq->parent.suspend_thread));
+        _rt_ipc_list_resume(&(mq->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -2510,7 +2510,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
         }
 
         /* suspend current thread */
-        rt_ipc_list_suspend(&(mq->parent.suspend_thread),
+        _rt_ipc_list_suspend(&(mq->parent.suspend_thread),
                             thread,
                             mq->parent.parent.flag);
 
@@ -2586,7 +2586,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
     /* resume suspended thread */
     if (!rt_list_isempty(&(mq->suspend_sender_thread)))
     {
-        rt_ipc_list_resume(&(mq->suspend_sender_thread));
+        _rt_ipc_list_resume(&(mq->suspend_sender_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -2632,9 +2632,9 @@ rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        rt_ipc_list_resume_all(&mq->parent.suspend_thread);
+        _rt_ipc_list_resume_all(&mq->parent.suspend_thread);
         /* also resume all message queue private suspended thread */
-        rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
+        _rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
 
         /* release all message in the queue */
         while (mq->msg_queue_head != RT_NULL)
diff --git a/src/scheduler.c b/src/scheduler.c
index ed0f30fc81..179ad85e07 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -23,7 +23,7 @@
  * 2013-12-21     Grissiom     add rt_critical_level
  * 2018-11-22     Jesven       remove the current task from ready queue
  *                             add per cpu ready queue
- *                             add _get_highest_priority_thread to find highest priority task
+ *                             add _rt_get_highest_priority_thread to find highest priority task
  *                             rt_schedule_insert_thread won't insert current task to ready queue
  *                             in smp version, rt_hw_context_switch_interrupt maybe switch to
  *                               new task directly
@@ -114,7 +114,7 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread)
  * get the highest priority thread in ready queue
  */
 #ifdef RT_USING_SMP
-static struct rt_thread* _get_highest_priority_thread(rt_ubase_t *highest_prio)
+static struct rt_thread* _rt_get_highest_priority_thread(rt_ubase_t *highest_prio)
 {
     register struct rt_thread *highest_priority_thread;
     register rt_ubase_t highest_ready_priority, local_highest_ready_priority;
@@ -150,7 +150,7 @@ static struct rt_thread* _get_highest_priority_thread(rt_ubase_t *highest_prio)
     return highest_priority_thread;
 }
 #else
-static struct rt_thread* _get_highest_priority_thread(rt_ubase_t *highest_prio)
+static struct rt_thread* _rt_get_highest_priority_thread(rt_ubase_t *highest_prio)
 {
     register struct rt_thread *highest_priority_thread;
     register rt_ubase_t highest_ready_priority;
@@ -239,7 +239,7 @@ void rt_system_scheduler_start(void)
     register struct rt_thread *to_thread;
     rt_ubase_t highest_ready_priority;
 
-    to_thread = _get_highest_priority_thread(&highest_ready_priority);
+    to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
 
 #ifdef RT_USING_SMP
     to_thread->oncpu = rt_hw_cpu_id();
@@ -327,7 +327,7 @@ void rt_schedule(void)
 
         if (rt_thread_ready_priority_group != 0 || pcpu->priority_group != 0)
         {
-            to_thread = _get_highest_priority_thread(&highest_ready_priority);
+            to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
             current_thread->oncpu = RT_CPU_DETACHED;
             if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
             {
@@ -425,7 +425,7 @@ void rt_schedule(void)
             /* need_insert_from_thread: need to insert from_thread to ready queue */
             int need_insert_from_thread = 0;
 
-            to_thread = _get_highest_priority_thread(&highest_ready_priority);
+            to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
 
             if ((rt_current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
             {
@@ -576,7 +576,7 @@ void rt_scheduler_do_irq_switch(void *context)
 
         if (rt_thread_ready_priority_group != 0 || pcpu->priority_group != 0)
         {
-            to_thread = _get_highest_priority_thread(&highest_ready_priority);
+            to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
             current_thread->oncpu = RT_CPU_DETACHED;
             if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
             {

From bb848db2a40fd02ffaf059367a2e21603e47866c Mon Sep 17 00:00:00 2001
From: Meco Man <920369182@qq.com>
Date: Tue, 8 Jun 2021 10:49:20 +0800
Subject: [PATCH 2/3] =?UTF-8?q?=E8=A7=A3=E5=86=B3=E5=86=B2=E7=AA=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/ipc.c | 41 -----------------------------------------
 1 file changed, 41 deletions(-)

diff --git a/src/ipc.c b/src/ipc.c
index 311724f0a6..b586a44181 100755
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -194,31 +194,6 @@ rt_inline rt_err_t _rt_ipc_list_resume_all(rt_list_t *list)
     return RT_EOK;
 }
 
-/**
- * This function will get the highest priority from the specified
- * list of threads
- *
- * @param list of the threads
- *
- * @return the highest priority
- */
-rt_uint8_t _rt_ipc_get_highest_priority(rt_list_t *list)
-{
-    struct rt_list_node *n;
-    struct rt_thread *sthread;
-    rt_uint8_t priority = RT_THREAD_PRIORITY_MAX - 1;
-
-    for (n = list->next; n != list; n = n->next)
-    {
-        sthread = rt_list_entry(n, struct rt_thread, tlist);
-
-        priority = priority < sthread->current_priority ?
-                    priority :
-                    sthread->current_priority;
-    }
-    return priority;
-}
-
 #ifdef RT_USING_SEMAPHORE
 /**
  * This function will initialize a semaphore and put it under control of
@@ -870,7 +845,6 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
     register rt_base_t temp;
     struct rt_thread *thread;
     rt_bool_t need_schedule;
-    rt_uint8_t max_priority_in_queue = RT_THREAD_PRIORITY_MAX - 1;
 
     /* parameter check */
     RT_ASSERT(mutex != RT_NULL);
@@ -932,21 +906,6 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
             mutex->owner             = thread;
             mutex->original_priority = thread->current_priority;
 
-            /* Priority adjustment occurs only when the following conditions
-             * are met simultaneously:
-             * 1.The type of mutex is RT_IPC_FLAG_FIFO;
-             * 2.The priority of the thread to be resumed is not equal to the
-             *   highest priority in the queue;
-             */
-            max_priority_in_queue = _rt_ipc_get_highest_priority(&mutex->parent.suspend_thread);
-            if (mutex->parent.parent.flag == RT_IPC_FLAG_FIFO &&
-                thread->current_priority != max_priority_in_queue)
-            {
-                rt_thread_control(thread,
-                        RT_THREAD_CTRL_CHANGE_PRIORITY,
-                        &(max_priority_in_queue));
-            }
-
             if(mutex->hold < RT_MUTEX_HOLD_MAX)
             {
                 mutex->hold ++;

From c10678c1f0968a1ce9f5af1eb051b39f3bb2c1d6 Mon Sep 17 00:00:00 2001
From: Meco Man <920369182@qq.com>
Date: Tue, 13 Jul 2021 13:20:36 +0800
Subject: [PATCH 3/3] =?UTF-8?q?=E5=86=85=E9=83=A8=E5=87=BD=E6=95=B0?=
 =?UTF-8?q?=E4=BB=A5=5F=E5=BC=80=E5=A4=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/idle.c      |   4 +-
 src/ipc.c       | 102 ++++++++++++++++++++++++------------------------
 src/scheduler.c |  14 +++----
 3 files changed, 60 insertions(+), 60 deletions(-)

diff --git a/src/idle.c b/src/idle.c
index a6efad5628..81ac7e30dd 100644
--- a/src/idle.c
+++ b/src/idle.c
@@ -129,7 +129,7 @@ rt_err_t rt_thread_idle_delhook(void (*hook)(void))
 
 #ifdef RT_USING_HEAP
 /* Return whether there is defunctional thread to be deleted. */
-rt_inline int _rt_has_defunct_thread(void)
+rt_inline int _idle_has_defunct_thread(void)
 {
     /* The rt_list_isempty has prototype of "int rt_list_isempty(const rt_list_t *l)".
      * So the compiler has a good reason that the rt_thread_defunct list does
@@ -165,7 +165,7 @@ void rt_thread_idle_excute(void)
         lock = rt_hw_interrupt_disable();
 
         /* check whether list is empty */
-        if (!_rt_has_defunct_thread())
+        if (!_idle_has_defunct_thread())
         {
             rt_hw_interrupt_enable(lock);
             break;
diff --git a/src/ipc.c b/src/ipc.c
index d57aa64d59..30ed44de56 100755
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -63,7 +63,7 @@ extern void (*rt_object_put_hook)(struct rt_object *object);
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t _rt_ipc_object_init(struct rt_ipc_object *ipc)
+rt_inline rt_err_t _ipc_object_init(struct rt_ipc_object *ipc)
 {
     /* initialize ipc object */
     rt_list_init(&(ipc->suspend_thread));
@@ -82,9 +82,9 @@ rt_inline rt_err_t _rt_ipc_object_init(struct rt_ipc_object *ipc)
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t _rt_ipc_list_suspend(rt_list_t        *list,
-                                       struct rt_thread *thread,
-                                       rt_uint8_t        flag)
+rt_inline rt_err_t _ipc_list_suspend(rt_list_t        *list,
+                                     struct rt_thread *thread,
+                                     rt_uint8_t        flag)
 {
     /* suspend thread */
     rt_thread_suspend(thread);
@@ -140,7 +140,7 @@ rt_inline rt_err_t _rt_ipc_list_suspend(rt_list_t        *list,
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t _rt_ipc_list_resume(rt_list_t *list)
+rt_inline rt_err_t _ipc_list_resume(rt_list_t *list)
 {
     struct rt_thread *thread;
 
@@ -163,7 +163,7 @@ rt_inline rt_err_t _rt_ipc_list_resume(rt_list_t *list)
  *
  * @return the operation status, RT_EOK on successful
  */
-rt_inline rt_err_t _rt_ipc_list_resume_all(rt_list_t *list)
+rt_inline rt_err_t _ipc_list_resume_all(rt_list_t *list)
 {
     struct rt_thread *thread;
     register rt_ubase_t temp;
@@ -217,7 +217,7 @@ rt_err_t rt_sem_init(rt_sem_t    sem,
     rt_object_init(&(sem->parent.parent), RT_Object_Class_Semaphore, name);
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(sem->parent));
+    _ipc_object_init(&(sem->parent));
 
     /* set initial value */
     sem->value = (rt_uint16_t)value;
@@ -246,7 +246,7 @@ rt_err_t rt_sem_detach(rt_sem_t sem)
     RT_ASSERT(rt_object_is_systemobject(&sem->parent.parent));
 
     /* wakeup all suspended threads */
-    _rt_ipc_list_resume_all(&(sem->parent.suspend_thread));
+    _ipc_list_resume_all(&(sem->parent.suspend_thread));
 
     /* detach semaphore object */
     rt_object_detach(&(sem->parent.parent));
@@ -280,7 +280,7 @@ rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag)
         return sem;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(sem->parent));
+    _ipc_object_init(&(sem->parent));
 
     /* set initial value */
     sem->value = value;
@@ -311,7 +311,7 @@ rt_err_t rt_sem_delete(rt_sem_t sem)
     RT_ASSERT(rt_object_is_systemobject(&sem->parent.parent) == RT_FALSE);
 
     /* wakeup all suspended threads */
-    _rt_ipc_list_resume_all(&(sem->parent.suspend_thread));
+    _ipc_list_resume_all(&(sem->parent.suspend_thread));
 
     /* delete semaphore object */
     rt_object_delete(&(sem->parent.parent));
@@ -382,7 +382,7 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time)
                                         thread->name));
 
             /* suspend thread */
-            _rt_ipc_list_suspend(&(sem->parent.suspend_thread),
+            _ipc_list_suspend(&(sem->parent.suspend_thread),
                                 thread,
                                 sem->parent.parent.flag);
 
@@ -463,7 +463,7 @@ rt_err_t rt_sem_release(rt_sem_t sem)
     if (!rt_list_isempty(&sem->parent.suspend_thread))
     {
         /* resume the suspended thread */
-        _rt_ipc_list_resume(&(sem->parent.suspend_thread));
+        _ipc_list_resume(&(sem->parent.suspend_thread));
         need_schedule = RT_TRUE;
     }
     else
@@ -517,7 +517,7 @@ rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        _rt_ipc_list_resume_all(&sem->parent.suspend_thread);
+        _ipc_list_resume_all(&sem->parent.suspend_thread);
 
         /* set new value */
         sem->value = (rt_uint16_t)value;
@@ -555,7 +555,7 @@ rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag)
     rt_object_init(&(mutex->parent.parent), RT_Object_Class_Mutex, name);
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(mutex->parent));
+    _ipc_object_init(&(mutex->parent));
 
     mutex->value = 1;
     mutex->owner = RT_NULL;
@@ -586,7 +586,7 @@ rt_err_t rt_mutex_detach(rt_mutex_t mutex)
     RT_ASSERT(rt_object_is_systemobject(&mutex->parent.parent));
 
     /* wakeup all suspended threads */
-    _rt_ipc_list_resume_all(&(mutex->parent.suspend_thread));
+    _ipc_list_resume_all(&(mutex->parent.suspend_thread));
 
     /* detach semaphore object */
     rt_object_detach(&(mutex->parent.parent));
@@ -618,7 +618,7 @@ rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag)
         return mutex;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(mutex->parent));
+    _ipc_object_init(&(mutex->parent));
 
     mutex->value              = 1;
     mutex->owner              = RT_NULL;
@@ -651,7 +651,7 @@ rt_err_t rt_mutex_delete(rt_mutex_t mutex)
     RT_ASSERT(rt_object_is_systemobject(&mutex->parent.parent) == RT_FALSE);
 
     /* wakeup all suspended threads */
-    _rt_ipc_list_resume_all(&(mutex->parent.suspend_thread));
+    _ipc_list_resume_all(&(mutex->parent.suspend_thread));
 
     /* delete mutex object */
     rt_object_delete(&(mutex->parent.parent));
@@ -765,7 +765,7 @@ __again:
                 }
 
                 /* suspend current thread */
-                _rt_ipc_list_suspend(&(mutex->parent.suspend_thread),
+                _ipc_list_suspend(&(mutex->parent.suspend_thread),
                                     thread,
                                     mutex->parent.parent.flag);
 
@@ -916,7 +916,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
             }
 
             /* resume thread */
-            _rt_ipc_list_resume(&(mutex->parent.suspend_thread));
+            _ipc_list_resume(&(mutex->parent.suspend_thread));
 
             need_schedule = RT_TRUE;
         }
@@ -993,7 +993,7 @@ rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag)
     event->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(event->parent));
+    _ipc_object_init(&(event->parent));
 
     /* initialize event */
     event->set = 0;
@@ -1017,7 +1017,7 @@ rt_err_t rt_event_detach(rt_event_t event)
     RT_ASSERT(rt_object_is_systemobject(&event->parent.parent));
 
     /* resume all suspended thread */
-    _rt_ipc_list_resume_all(&(event->parent.suspend_thread));
+    _ipc_list_resume_all(&(event->parent.suspend_thread));
 
     /* detach event object */
     rt_object_detach(&(event->parent.parent));
@@ -1050,7 +1050,7 @@ rt_event_t rt_event_create(const char *name, rt_uint8_t flag)
     event->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(event->parent));
+    _ipc_object_init(&(event->parent));
 
     /* initialize event */
     event->set = 0;
@@ -1076,7 +1076,7 @@ rt_err_t rt_event_delete(rt_event_t event)
     RT_DEBUG_NOT_IN_INTERRUPT;
 
     /* resume all suspended thread */
-    _rt_ipc_list_resume_all(&(event->parent.suspend_thread));
+    _ipc_list_resume_all(&(event->parent.suspend_thread));
 
     /* delete event object */
     rt_object_delete(&(event->parent.parent));
@@ -1279,7 +1279,7 @@ rt_err_t rt_event_recv(rt_event_t   event,
         thread->event_info = option;
 
         /* put thread to suspended thread list */
-        _rt_ipc_list_suspend(&(event->parent.suspend_thread),
+        _ipc_list_suspend(&(event->parent.suspend_thread),
                             thread,
                             event->parent.parent.flag);
 
@@ -1345,7 +1345,7 @@ rt_err_t rt_event_control(rt_event_t event, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        _rt_ipc_list_resume_all(&event->parent.suspend_thread);
+        _ipc_list_resume_all(&event->parent.suspend_thread);
 
         /* initialize event set */
         event->set = 0;
@@ -1391,7 +1391,7 @@ rt_err_t rt_mb_init(rt_mailbox_t mb,
     mb->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(mb->parent));
+    _ipc_object_init(&(mb->parent));
 
     /* initialize mailbox */
     mb->msg_pool   = (rt_ubase_t *)msgpool;
@@ -1422,9 +1422,9 @@ rt_err_t rt_mb_detach(rt_mailbox_t mb)
     RT_ASSERT(rt_object_is_systemobject(&mb->parent.parent));
 
     /* resume all suspended thread */
-    _rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
+    _ipc_list_resume_all(&(mb->parent.suspend_thread));
     /* also resume all mailbox private suspended thread */
-    _rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
+    _ipc_list_resume_all(&(mb->suspend_sender_thread));
 
     /* detach mailbox object */
     rt_object_detach(&(mb->parent.parent));
@@ -1458,7 +1458,7 @@ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag)
     mb->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(mb->parent));
+    _ipc_object_init(&(mb->parent));
 
     /* initialize mailbox */
     mb->size     = size;
@@ -1498,10 +1498,10 @@ rt_err_t rt_mb_delete(rt_mailbox_t mb)
     RT_ASSERT(rt_object_is_systemobject(&mb->parent.parent) == RT_FALSE);
 
     /* resume all suspended thread */
-    _rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
+    _ipc_list_resume_all(&(mb->parent.suspend_thread));
 
     /* also resume all mailbox private suspended thread */
-    _rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
+    _ipc_list_resume_all(&(mb->suspend_sender_thread));
 
     /* free mailbox pool */
     RT_KERNEL_FREE(mb->msg_pool);
@@ -1570,7 +1570,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
 
         RT_DEBUG_IN_THREAD_CONTEXT;
         /* suspend current thread */
-        _rt_ipc_list_suspend(&(mb->suspend_sender_thread),
+        _ipc_list_suspend(&(mb->suspend_sender_thread),
                             thread,
                             mb->parent.parent.flag);
 
@@ -1637,7 +1637,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
     /* resume suspended thread */
     if (!rt_list_isempty(&mb->parent.suspend_thread))
     {
-        _rt_ipc_list_resume(&(mb->parent.suspend_thread));
+        _ipc_list_resume(&(mb->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -1718,7 +1718,7 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value)
     /* resume suspended thread */
     if (!rt_list_isempty(&mb->parent.suspend_thread))
     {
-        _rt_ipc_list_resume(&(mb->parent.suspend_thread));
+        _ipc_list_resume(&(mb->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -1792,7 +1792,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
 
         RT_DEBUG_IN_THREAD_CONTEXT;
         /* suspend current thread */
-        _rt_ipc_list_suspend(&(mb->parent.suspend_thread),
+        _ipc_list_suspend(&(mb->parent.suspend_thread),
                             thread,
                             mb->parent.parent.flag);
 
@@ -1855,7 +1855,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
     /* resume suspended thread */
     if (!rt_list_isempty(&(mb->suspend_sender_thread)))
     {
-        _rt_ipc_list_resume(&(mb->suspend_sender_thread));
+        _ipc_list_resume(&(mb->suspend_sender_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -1899,9 +1899,9 @@ rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        _rt_ipc_list_resume_all(&(mb->parent.suspend_thread));
+        _ipc_list_resume_all(&(mb->parent.suspend_thread));
         /* also resume all mailbox private suspended thread */
-        _rt_ipc_list_resume_all(&(mb->suspend_sender_thread));
+        _ipc_list_resume_all(&(mb->suspend_sender_thread));
 
         /* re-init mailbox */
         mb->entry      = 0;
@@ -1960,7 +1960,7 @@ rt_err_t rt_mq_init(rt_mq_t     mq,
     mq->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(mq->parent));
+    _ipc_object_init(&(mq->parent));
 
     /* set message pool */
     mq->msg_pool = msgpool;
@@ -2008,9 +2008,9 @@ rt_err_t rt_mq_detach(rt_mq_t mq)
     RT_ASSERT(rt_object_is_systemobject(&mq->parent.parent));
 
     /* resume all suspended thread */
-    _rt_ipc_list_resume_all(&mq->parent.suspend_thread);
+    _ipc_list_resume_all(&mq->parent.suspend_thread);
     /* also resume all message queue private suspended thread */
-    _rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
+    _ipc_list_resume_all(&(mq->suspend_sender_thread));
 
     /* detach message queue object */
     rt_object_detach(&(mq->parent.parent));
@@ -2050,7 +2050,7 @@ rt_mq_t rt_mq_create(const char *name,
     mq->parent.parent.flag = flag;
 
     /* initialize ipc object */
-    _rt_ipc_object_init(&(mq->parent));
+    _ipc_object_init(&(mq->parent));
 
     /* initialize message queue */
 
@@ -2108,9 +2108,9 @@ rt_err_t rt_mq_delete(rt_mq_t mq)
     RT_ASSERT(rt_object_is_systemobject(&mq->parent.parent) == RT_FALSE);
 
     /* resume all suspended thread */
-    _rt_ipc_list_resume_all(&(mq->parent.suspend_thread));
+    _ipc_list_resume_all(&(mq->parent.suspend_thread));
     /* also resume all message queue private suspended thread */
-    _rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
+    _ipc_list_resume_all(&(mq->suspend_sender_thread));
 
     /* free message queue pool */
     RT_KERNEL_FREE(mq->msg_pool);
@@ -2192,7 +2192,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
 
         RT_DEBUG_IN_THREAD_CONTEXT;
         /* suspend current thread */
-        _rt_ipc_list_suspend(&(mq->suspend_sender_thread),
+        _ipc_list_suspend(&(mq->suspend_sender_thread),
                             thread,
                             mq->parent.parent.flag);
 
@@ -2278,7 +2278,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     /* resume suspended thread */
     if (!rt_list_isempty(&mq->parent.suspend_thread))
     {
-        _rt_ipc_list_resume(&(mq->parent.suspend_thread));
+        _ipc_list_resume(&(mq->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -2386,7 +2386,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
     /* resume suspended thread */
     if (!rt_list_isempty(&mq->parent.suspend_thread))
     {
-        _rt_ipc_list_resume(&(mq->parent.suspend_thread));
+        _ipc_list_resume(&(mq->parent.suspend_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -2468,7 +2468,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
         }
 
         /* suspend current thread */
-        _rt_ipc_list_suspend(&(mq->parent.suspend_thread),
+        _ipc_list_suspend(&(mq->parent.suspend_thread),
                             thread,
                             mq->parent.parent.flag);
 
@@ -2544,7 +2544,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
     /* resume suspended thread */
     if (!rt_list_isempty(&(mq->suspend_sender_thread)))
     {
-        _rt_ipc_list_resume(&(mq->suspend_sender_thread));
+        _ipc_list_resume(&(mq->suspend_sender_thread));
 
         /* enable interrupt */
         rt_hw_interrupt_enable(temp);
@@ -2590,9 +2590,9 @@ rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg)
         level = rt_hw_interrupt_disable();
 
         /* resume all waiting thread */
-        _rt_ipc_list_resume_all(&mq->parent.suspend_thread);
+        _ipc_list_resume_all(&mq->parent.suspend_thread);
         /* also resume all message queue private suspended thread */
-        _rt_ipc_list_resume_all(&(mq->suspend_sender_thread));
+        _ipc_list_resume_all(&(mq->suspend_sender_thread));
 
         /* release all message in the queue */
         while (mq->msg_queue_head != RT_NULL)
diff --git a/src/scheduler.c b/src/scheduler.c
index 179ad85e07..8849d7f3ec 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -23,7 +23,7 @@
  * 2013-12-21     Grissiom     add rt_critical_level
  * 2018-11-22     Jesven       remove the current task from ready queue
  *                             add per cpu ready queue
- *                             add _rt_get_highest_priority_thread to find highest priority task
+ *                             add _scheduler_get_highest_priority_thread to find highest priority task
  *                             rt_schedule_insert_thread won't insert current task to ready queue
  *                             in smp version, rt_hw_context_switch_interrupt maybe switch to
  *                               new task directly
@@ -114,7 +114,7 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread)
  * get the highest priority thread in ready queue
  */
 #ifdef RT_USING_SMP
-static struct rt_thread* _rt_get_highest_priority_thread(rt_ubase_t *highest_prio)
+static struct rt_thread* _scheduler_get_highest_priority_thread(rt_ubase_t *highest_prio)
 {
     register struct rt_thread *highest_priority_thread;
     register rt_ubase_t highest_ready_priority, local_highest_ready_priority;
@@ -150,7 +150,7 @@ static struct rt_thread* _rt_get_highest_priority_thread(rt_ubase_t *highest_pri
     return highest_priority_thread;
 }
 #else
-static struct rt_thread* _rt_get_highest_priority_thread(rt_ubase_t *highest_prio)
+static struct rt_thread* _scheduler_get_highest_priority_thread(rt_ubase_t *highest_prio)
 {
     register struct rt_thread *highest_priority_thread;
     register rt_ubase_t highest_ready_priority;
@@ -239,7 +239,7 @@ void rt_system_scheduler_start(void)
     register struct rt_thread *to_thread;
     rt_ubase_t highest_ready_priority;
 
-    to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
+    to_thread = _scheduler_get_highest_priority_thread(&highest_ready_priority);
 
 #ifdef RT_USING_SMP
     to_thread->oncpu = rt_hw_cpu_id();
@@ -327,7 +327,7 @@ void rt_schedule(void)
 
         if (rt_thread_ready_priority_group != 0 || pcpu->priority_group != 0)
         {
-            to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
+            to_thread = _scheduler_get_highest_priority_thread(&highest_ready_priority);
             current_thread->oncpu = RT_CPU_DETACHED;
             if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
             {
@@ -425,7 +425,7 @@ void rt_schedule(void)
             /* need_insert_from_thread: need to insert from_thread to ready queue */
             int need_insert_from_thread = 0;
 
-            to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
+            to_thread = _scheduler_get_highest_priority_thread(&highest_ready_priority);
 
             if ((rt_current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
             {
@@ -576,7 +576,7 @@ void rt_scheduler_do_irq_switch(void *context)
 
         if (rt_thread_ready_priority_group != 0 || pcpu->priority_group != 0)
         {
-            to_thread = _rt_get_highest_priority_thread(&highest_ready_priority);
+            to_thread = _scheduler_get_highest_priority_thread(&highest_ready_priority);
             current_thread->oncpu = RT_CPU_DETACHED;
             if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_RUNNING)
             {