原rt_thread_suspend改名为rt_thread_suspend_with_flag

新rt_thread_suspend函数为suspend_flag为RT_UNITERRUPTIBLE的rt_thread_suspend_with_flag调用
lwp_user_access_ok函数改名为lwp_user_accessable

bsp/gkipc/armv6/rtos_lib.c

@@ -663,7 +663,7 @@ U32 msleep( U32 msecs )
 
 U32 RTOS_SuspendThread( RTOS_ThreadT threadHandle )
 {
-    return rt_thread_suspend((rt_thread_t)threadHandle, RT_UNINTERRUPTIBLE);
+    return rt_thread_suspend_witch_flag((rt_thread_t)threadHandle, RT_UNINTERRUPTIBLE);
 }
 
 U32 RTOS_WakeupThread( RTOS_ThreadT threadHandle )

components/dfs/src/poll.c

@@ -95,7 +95,7 @@ static int poll_wait_timeout(struct rt_poll_table *pt, int msec)
 
     if (timeout != 0 && !pt->triggered)
     {
-        if (rt_thread_suspend(thread, RT_INTERRUPTIBLE) == RT_EOK)
+        if (rt_thread_suspend_with_flag(thread, RT_INTERRUPTIBLE) == RT_EOK)
         {
             if (timeout > 0)
             {

components/drivers/audio/audio_pipe.c

@@ -72,7 +72,7 @@ static rt_size_t rt_pipe_read(rt_device_t dev,
         read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), (rt_uint8_t *)buffer, size);
         if (read_nbytes == 0)
         {
-            rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+            rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
             /* waiting on suspended read list */
             rt_list_insert_before(&(pipe->suspended_read_list),
                                   &(thread->tlist));
@@ -160,7 +160,7 @@ static rt_size_t rt_pipe_write(rt_device_t dev,
         if (write_nbytes == 0)
         {
             /* pipe full, waiting on suspended write list */
-            rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+            rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
             /* waiting on suspended read list */
             rt_list_insert_before(&(pipe->suspended_write_list),
                                   &(thread->tlist));

components/drivers/src/completion.c

@@ -55,7 +55,7 @@ rt_err_t rt_completion_wait(struct rt_completion *completion,
             thread->error = RT_EOK;
 
             /* suspend thread */
-            rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+            rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
             /* add to suspended list */
             rt_list_insert_before(&(completion->suspended_list),
                                   &(thread->tlist));

components/drivers/src/dataqueue.c

@@ -87,7 +87,7 @@ rt_err_t rt_data_queue_push(struct rt_data_queue *queue,
         thread->error = RT_EOK;
 
         /* suspend thread on the push list */
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
         rt_list_insert_before(&(queue->suspended_push_list), &(thread->tlist));
         /* start timer */
         if (timeout > 0)
@@ -187,7 +187,7 @@ rt_err_t rt_data_queue_pop(struct rt_data_queue *queue,
         thread->error = RT_EOK;
 
         /* suspend thread on the pop list */
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
         rt_list_insert_before(&(queue->suspended_pop_list), &(thread->tlist));
         /* start timer */
         if (timeout > 0)

components/drivers/src/waitqueue.c

@@ -103,7 +103,7 @@ static int _rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec, int susp
         goto __exit_wakeup;
     }
 
-    ret = rt_thread_suspend(tid, RT_INTERRUPTIBLE);
+    ret = rt_thread_suspend_with_flag(tid, RT_INTERRUPTIBLE);
     if (ret != RT_EOK)
     {
         rt_hw_interrupt_enable(level);

components/drivers/src/workqueue.c

@@ -61,7 +61,7 @@ static void _workqueue_thread_entry(void *parameter)
         if (rt_list_isempty(&(queue->work_list)))
         {
             /* no software timer exist, suspend self. */
-            rt_thread_suspend(rt_thread_self(), RT_UNINTERRUPTIBLE);
+            rt_thread_suspend_with_flag(rt_thread_self(), RT_UNINTERRUPTIBLE);
             rt_schedule();
         }
 

components/libc/compilers/newlib/syscalls.c

@@ -431,7 +431,7 @@ void abort(void)
         rt_thread_t self = rt_thread_self();
 
         rt_kprintf("thread:%-8.*s abort!\n", RT_NAME_MAX, self->name);
-        rt_thread_suspend(self, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(self, RT_UNINTERRUPTIBLE);
 
         rt_schedule();
     }

components/libc/libdl/dlmodule.c

@@ -128,7 +128,7 @@ static void _dlmodule_exit(void)
                     (thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT)
                 {
                     rt_timer_stop(&(thread->thread_timer));
-                    rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+                    rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
                 }
             }
         }

components/lwp/arch/arm/cortex-a/arch_user_stack.c

@@ -29,7 +29,7 @@ int arch_expand_user_stack(void *addr)
     {
         void *map = lwp_map_user(lwp_self(), (void*)stack_addr, ARCH_PAGE_SIZE);
 
-        if (map || lwp_user_access_ok(addr, 1))
+        if (map || lwp_user_accessable(addr, 1))
         {
             ret = 1;
         }

components/lwp/lwp_ipc.c

@@ -138,7 +138,7 @@ rt_inline rt_err_t rt_channel_list_resume_all(rt_list_t *list)
 rt_inline rt_err_t rt_channel_list_suspend(rt_list_t *list, struct rt_thread *thread)
 {
     /* suspend thread */
-    rt_err_t ret = rt_thread_suspend(thread, RT_INTERRUPTIBLE);
+    rt_err_t ret = rt_thread_suspend_with_flag(thread, RT_INTERRUPTIBLE);
 
     if (ret == RT_EOK)
     {

components/lwp/lwp_pid.c

@@ -410,7 +410,7 @@ pid_t waitpid(pid_t pid, int *status, int options)
             goto quit;
         }
         thread = rt_thread_self();
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
         rt_list_insert_before(&lwp->wait_list, &(thread->tlist));
         rt_schedule();
         if (thread->error == RT_EOK)

components/lwp/lwp_syscall.c

@@ -275,7 +275,7 @@ ssize_t sys_read(int fd, void *buf, size_t nbyte)
     if (!nbyte)
         return 0;
 
-    if (!lwp_user_access_ok((void*)buf, nbyte))
+    if (!lwp_user_accessable((void*)buf, nbyte))
         return 0;
 
     kmem = kmem_get(nbyte);
@@ -303,7 +303,7 @@ ssize_t sys_write(int fd, const void *buf, size_t nbyte)
     if (!nbyte)
         return 0;
 
-    if (!lwp_user_access_ok((void*)buf, nbyte))
+    if (!lwp_user_accessable((void*)buf, nbyte))
         return 0;
 
     kmem = kmem_get(nbyte);
@@ -334,7 +334,7 @@ int sys_open(const char *name, int flag, ...)
     rt_size_t len;
     char *kname;
 
-    if (!lwp_user_access_ok((void*)name, 1))
+    if (!lwp_user_accessable((void*)name, 1))
         return -1;
 
     len = rt_strlen(name);
@@ -391,7 +391,7 @@ int sys_poll(struct pollfd *fds, nfds_t nfds, int timeout)
     int ret;
     struct pollfd *kfds;
 
-    if (!lwp_user_access_ok((void*)fds, nfds * sizeof *fds))
+    if (!lwp_user_accessable((void*)fds, nfds * sizeof *fds))
         return -1;
 
     kfds = (struct pollfd *)kmem_get(nfds * sizeof *kfds);
@@ -417,7 +417,7 @@ int sys_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, s
 
     if (readfds)
     {
-        if (!lwp_user_access_ok((void*)readfds, sizeof *readfds))
+        if (!lwp_user_accessable((void*)readfds, sizeof *readfds))
         {
             return -1;
         }
@@ -430,7 +430,7 @@ int sys_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, s
     }
     if (writefds)
     {
-        if (!lwp_user_access_ok((void*)writefds, sizeof *writefds))
+        if (!lwp_user_accessable((void*)writefds, sizeof *writefds))
         {
             return -1;
         }
@@ -443,7 +443,7 @@ int sys_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, s
     }
     if (exceptfds)
     {
-        if (!lwp_user_access_ok((void*)exceptfds, sizeof *exceptfds))
+        if (!lwp_user_accessable((void*)exceptfds, sizeof *exceptfds))
         {
             return -1;
         }
@@ -494,7 +494,7 @@ int sys_unlink(const char *pathname)
     rt_size_t len;
     char *kname;
 
-    if (!lwp_user_access_ok((void*)pathname, 1))
+    if (!lwp_user_accessable((void*)pathname, 1))
         return -1;
 
     len = rt_strlen(pathname);
@@ -525,7 +525,7 @@ int sys_nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
 
     dbg_log(DBG_LOG, "sys_nanosleep\n");
 
-    if (!lwp_user_access_ok((void*)rqtp, sizeof *rqtp))
+    if (!lwp_user_accessable((void*)rqtp, sizeof *rqtp))
         return -1;
 
     lwp_get_from_user(&rqtp_k, (void *)rqtp, sizeof rqtp_k);
@@ -535,7 +535,7 @@ int sys_nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
 
     if (rmtp)
     {
-        if (!lwp_user_access_ok((void*)rmtp, sizeof *rmtp))
+        if (!lwp_user_accessable((void*)rmtp, sizeof *rmtp))
             return -1;
 
         tick = rt_tick_get() - tick;
@@ -571,7 +571,7 @@ int sys_gettimeofday(struct timeval *tp, struct timezone *tzp)
 #ifdef RT_USING_USERSPACE
     if (tp)
     {
-        if (!lwp_user_access_ok((void*)tp, sizeof *tp))
+        if (!lwp_user_accessable((void*)tp, sizeof *tp))
             return -1;
 
         t_k.tv_sec = rt_tick_get() / RT_TICK_PER_SECOND;
@@ -1075,7 +1075,7 @@ int sys_accept(int socket, struct musl_sockaddr *addr, socklen_t *addrlen)
     socklen_t uaddrlen;
     socklen_t kaddrlen;
 
-    if (!lwp_user_access_ok(addrlen, sizeof (socklen_t *)))
+    if (!lwp_user_accessable(addrlen, sizeof (socklen_t *)))
     {
         return -1;
     }
@@ -1085,7 +1085,7 @@ int sys_accept(int socket, struct musl_sockaddr *addr, socklen_t *addrlen)
         return -1;
     }
 
-    if (!lwp_user_access_ok(addr, uaddrlen))
+    if (!lwp_user_accessable(addr, uaddrlen))
     {
         return -1;
     }
@@ -1110,7 +1110,7 @@ int sys_bind(int socket, const struct musl_sockaddr *name, socklen_t namelen)
     struct sockaddr sa;
     struct musl_sockaddr kname;
 
-    if (!lwp_user_access_ok((void*)name, namelen))
+    if (!lwp_user_accessable((void*)name, namelen))
     {
         return -1;
     }
@@ -1134,7 +1134,7 @@ int sys_getpeername (int socket, struct musl_sockaddr *name, socklen_t *namelen)
     socklen_t unamelen;
     socklen_t knamelen;
 
-    if (!lwp_user_access_ok(namelen, sizeof (socklen_t *)))
+    if (!lwp_user_accessable(namelen, sizeof (socklen_t *)))
     {
         return -1;
     }
@@ -1144,7 +1144,7 @@ int sys_getpeername (int socket, struct musl_sockaddr *name, socklen_t *namelen)
         return -1;
     }
 
-    if (!lwp_user_access_ok(name, unamelen))
+    if (!lwp_user_accessable(name, unamelen))
     {
         return -1;
     }
@@ -1174,7 +1174,7 @@ int sys_getsockname (int socket, struct musl_sockaddr *name, socklen_t *namelen)
     socklen_t unamelen;
     socklen_t knamelen;
 
-    if (!lwp_user_access_ok(namelen, sizeof (socklen_t *)))
+    if (!lwp_user_accessable(namelen, sizeof (socklen_t *)))
     {
         return -1;
     }
@@ -1184,7 +1184,7 @@ int sys_getsockname (int socket, struct musl_sockaddr *name, socklen_t *namelen)
         return -1;
     }
 
-    if (!lwp_user_access_ok(name, unamelen))
+    if (!lwp_user_accessable(name, unamelen))
     {
         return -1;
     }
@@ -1225,7 +1225,7 @@ int sys_connect(int socket, const struct musl_sockaddr *name, socklen_t namelen)
     struct sockaddr sa;
     struct musl_sockaddr kname;
 
-    if (!lwp_user_access_ok((void*)name, namelen))
+    if (!lwp_user_accessable((void*)name, namelen))
     {
         return -1;
     }
@@ -1278,7 +1278,7 @@ int sys_recvfrom(int socket, void *mem, size_t len, int flags,
     if (!len)
         return -1;
 
-    if (!lwp_user_access_ok((void*)mem, len))
+    if (!lwp_user_accessable((void*)mem, len))
         return -1;
 
     kmem = kmem_get(len);
@@ -1340,7 +1340,7 @@ int sys_sendto(int socket, const void *dataptr, size_t size, int flags,
     if (!size)
         return -1;
 
-    if (!lwp_user_access_ok((void*)dataptr, size))
+    if (!lwp_user_accessable((void*)dataptr, size))
         return -1;
 
     kmem = kmem_get(size);
@@ -1722,7 +1722,7 @@ int sys_access(const char *filename, int mode)
     rt_size_t len;
     char *kname;
 
-    if (!lwp_user_access_ok((void*)filename, 1))
+    if (!lwp_user_accessable((void*)filename, 1))
         return -1;
 
     len = rt_strlen(filename);

components/lwp/lwp_user_mm.c

@@ -385,7 +385,7 @@ size_t lwp_put_to_user(void *dst, void *src, size_t size)
     return lwp_data_put(m_info, dst, src, size);
 }
 
-int lwp_user_access_ok(void *addr, size_t size)
+int lwp_user_accessable(void *addr, size_t size)
 {
     void *addr_start, *addr_end, *next_page;
     void *tmp_addr;

components/lwp/lwp_user_mm.h

@@ -36,7 +36,7 @@ int lwp_munmap(void *addr, size_t length);
 
 size_t lwp_get_from_user(void *dst, void *src, size_t size);
 size_t lwp_put_to_user(void *dst, void *src, size_t size);
-int lwp_user_access_ok(void *addr, size_t size);
+int lwp_user_accessable(void *addr, size_t size);
 
 size_t lwp_data_get(rt_mmu_info *mmu_info, void *dst, void *src, size_t size);
 size_t lwp_data_put(rt_mmu_info *mmu_info, void *dst, void *src, size_t size);

components/vbus/prio_queue.c

@@ -205,7 +205,7 @@ rt_err_t rt_prio_queue_pop(struct rt_prio_queue *que,
 
         thread = rt_thread_self();
         thread->error = RT_EOK;
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
 
         rt_list_insert_before(&(que->suspended_pop_list), &(thread->tlist));
 

components/vbus/vbus.c

@@ -230,7 +230,7 @@ static void _bus_out_entry(void *param)
             /* kick the guest, hoping this could force it do the work */
             rt_vbus_tick(0, RT_VBUS_GUEST_VIRQ);
 
-            rt_thread_suspend(rt_thread_self(), RT_UNINTERRUPTIBLE);
+            rt_thread_suspend_with_flag(rt_thread_self(), RT_UNINTERRUPTIBLE);
             rt_schedule();
 
             RT_VBUS_OUT_RING->blocked = 0;
@@ -334,7 +334,7 @@ rt_err_t rt_vbus_post(rt_uint8_t id,
         /* We only touch the _chn_suspended_threads in thread, so lock the
          * scheduler is enough. */
         rt_enter_critical();
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
 
         rt_list_insert_after(&_chn_suspended_threads[id], &thread->tlist);
         if (timeout > 0)

components/vbus/watermark_queue.h

@@ -63,7 +63,7 @@ rt_inline rt_err_t rt_wm_que_inc(struct rt_watermark_queue *wg,
 
         thread = rt_thread_self();
         thread->error = RT_EOK;
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
         rt_list_insert_after(&wg->suspended_threads, &thread->tlist);
         if (timeout > 0)
         {

examples/kernel/thread_resume.c

@@ -18,7 +18,7 @@ static void thread1_entry(void* parameter)
 
     /* 挂起自身 */
     rt_kprintf("suspend thread self\n");
-    rt_thread_suspend(tid1, RT_UNINTERRUPTIBLE);
+    rt_thread_suspend_witch_flag(tid1, RT_UNINTERRUPTIBLE);
     /* 主动执行线程调度 */
     rt_schedule();
 

examples/kernel/thread_suspend.c

@@ -28,7 +28,7 @@ static void thread2_entry(void* parameter)
     rt_thread_delay(10);
 
     /* 挂起线程1 */
-    rt_thread_suspend(tid1, RT_UNINTERRUPTIBLE);
+    rt_thread_suspend_witch_flag(tid1, RT_UNINTERRUPTIBLE);
 
     /* 延时10个OS Tick */
     rt_thread_delay(10);

include/rtthread.h

@@ -148,7 +148,8 @@ rt_err_t rt_thread_delay_until(rt_tick_t *tick, rt_tick_t inc_tick);
 rt_err_t rt_thread_mdelay(rt_int32_t ms);
 rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg);
 void rt_thread_set_suspend_state(struct rt_thread *thread, int suspend_flag);
-rt_err_t rt_thread_suspend(rt_thread_t thread, int suspend_flag);
+rt_err_t rt_thread_suspend(rt_thread_t thread);
+rt_err_t rt_thread_suspend_with_flag(rt_thread_t thread, int suspend_flag);
 rt_err_t rt_thread_resume(rt_thread_t thread);
 #ifdef RT_USING_LWP
 rt_err_t rt_thread_wakeup(rt_thread_t thread);

libcpu/arm/AT91SAM7X/trap.c

@@ -42,7 +42,7 @@ extern struct rt_thread* rt_current_thread;
 void rt_hw_trap_abort(void)
 {
 	rt_kprintf("Abort occured!!! Thread [%s] suspended.\n",rt_current_thread->name);
-	rt_thread_suspend(rt_current_thread, RT_UNINTERRUPTIBLE);
+	rt_thread_suspend_witch_flag(rt_current_thread, RT_UNINTERRUPTIBLE);
 	rt_schedule();
 
 }

libcpu/arm/cortex-a/trap.c

@@ -103,12 +103,12 @@ static int check_debug_event(struct rt_hw_exp_stack *regs, uint32_t pc_adj)
             dmb();
             thread_info.thread->debug_suspend = 1;
             dsb();
-            rt_thread_suspend(thread_info.thread, RT_UNINTERRUPTIBLE);
+            rt_thread_suspend_witch_flag(thread_info.thread, RT_UNINTERRUPTIBLE);
             rt_raw_channel_send(gdb_get_server_channel(), &msg);
             rt_schedule();
             while (thread_info.thread->debug_suspend)
             {
-                rt_thread_suspend(thread_info.thread, RT_UNINTERRUPTIBLE);
+                rt_thread_suspend_witch_flag(thread_info.thread, RT_UNINTERRUPTIBLE);
                 rt_schedule();
             }
             return ret;

src/ipc.c

@@ -85,7 +85,7 @@ rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t        *list,
                                        rt_uint8_t        flag,
                                        int suspend_flag)
 {
-    rt_err_t ret = rt_thread_suspend(thread, suspend_flag);
+    rt_err_t ret = rt_thread_suspend_with_flag(thread, suspend_flag);
 
     /* suspend thread */
     if (ret != RT_EOK)

src/mempool.c

@@ -334,7 +334,7 @@ void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time)
         thread->error = RT_EOK;
 
         /* need suspend thread */
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
         rt_list_insert_after(&(mp->suspend_thread), &(thread->tlist));
 
         if (time > 0)

src/signal.c

@@ -302,7 +302,7 @@ int rt_signal_wait(const rt_sigset_t *set, rt_siginfo_t *si, rt_int32_t timeout)
     }
 
     /* suspend self thread */
-    rt_thread_suspend(tid, RT_UNINTERRUPTIBLE);
+    rt_thread_suspend_with_flag(tid, RT_UNINTERRUPTIBLE);
     /* set thread stat as waiting for signal */
     tid->stat |= RT_THREAD_STAT_SIGNAL_WAIT;
 

src/thread.c

@@ -556,7 +556,7 @@ rt_err_t rt_thread_sleep(rt_tick_t tick)
     temp = rt_hw_interrupt_disable();
 
     /* suspend thread */
-    rt_thread_suspend(thread, RT_INTERRUPTIBLE);
+    rt_thread_suspend_with_flag(thread, RT_INTERRUPTIBLE);
 
     /* reset the timeout of thread timer and start it */
     rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);
@@ -615,7 +615,7 @@ rt_err_t rt_thread_delay_until(rt_tick_t *tick, rt_tick_t inc_tick)
         *tick = *tick + inc_tick - rt_tick_get();
 
         /* suspend thread */
-        rt_thread_suspend(thread, RT_UNINTERRUPTIBLE);
+        rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
 
         /* reset the timeout of thread timer and start it */
         rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, tick);
@@ -781,7 +781,7 @@ int lwp_suspend_sigcheck(rt_thread_t thread, int suspend_flag);
  * @note if suspend self thread, after this function call, the
  * rt_schedule() must be invoked.
  */
-rt_err_t rt_thread_suspend(rt_thread_t thread, int suspend_flag)
+rt_err_t rt_thread_suspend_with_flag(rt_thread_t thread, int suspend_flag)
 {
     register rt_base_t stat;
     register rt_base_t temp;
@@ -829,8 +829,15 @@ rt_err_t rt_thread_suspend(rt_thread_t thread, int suspend_flag)
     RT_OBJECT_HOOK_CALL(rt_thread_suspend_hook, (thread));
     return RT_EOK;
 }
+RTM_EXPORT(rt_thread_suspend_with_flag);
+
+rt_err_t rt_thread_suspend(rt_thread_t thread)
+{
+    return rt_thread_suspend_with_flag(thread, RT_UNINTERRUPTIBLE);
+}
 RTM_EXPORT(rt_thread_suspend);
 
+
 /**
  * This function will resume a thread and put it to system ready queue.
  *

src/timer.c

@@ -710,7 +710,7 @@ static void rt_thread_timer_entry(void *parameter)
         if (next_timeout == RT_TICK_MAX)
         {
             /* no software timer exist, suspend self. */
-            rt_thread_suspend(rt_thread_self(), RT_UNINTERRUPTIBLE);
+            rt_thread_suspend_with_flag(rt_thread_self(), RT_UNINTERRUPTIBLE);
             rt_schedule();
         }
         else