From d4f77ee8c20e992142207a84b592a96fd99e4a48 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Tue, 8 Dec 2020 16:19:20 +0800 Subject: [PATCH 01/16] fix ipc default return value --- src/ipc.c | 39 +++++++++++++++++---------------------- 1 file changed, 17 insertions(+), 22 deletions(-) diff --git a/src/ipc.c b/src/ipc.c index 454fcb5439..30071e3e89 100644 --- a/src/ipc.c +++ b/src/ipc.c @@ -144,6 +144,8 @@ rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list) /* get thread entry */ thread = rt_list_entry(list->next, struct rt_thread, tlist); + thread->error = RT_EOK; + RT_DEBUG_LOG(RT_DEBUG_IPC, ("resume thread:%s\n", thread->name)); /* resume it */ @@ -373,7 +375,7 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time) thread = rt_thread_self(); /* reset thread error number */ - thread->error = RT_EOK; + thread->error = -RT_EINTR; RT_DEBUG_LOG(RT_DEBUG_IPC, ("sem take: suspend thread - %s\n", thread->name)); @@ -692,7 +694,7 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time) thread->name, mutex->value, mutex->hold)); /* reset thread error */ - thread->error = RT_EOK; + thread->error = -RT_EINTR; if (mutex->owner == thread) { @@ -709,9 +711,6 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time) } else { -#ifdef RT_USING_SIGNALS -__again: -#endif /* end of RT_USING_SIGNALS */ /* The value of mutex is 1 in initial status. Therefore, if the * value is great than 0, it indicates the mutex is avaible. */ @@ -788,11 +787,6 @@ __again: if (thread->error != RT_EOK) { -#ifdef RT_USING_SIGNALS - /* interrupt by signal, try it again */ - if (thread->error == -RT_EINTR) goto __again; -#endif /* end of RT_USING_SIGNALS */ - /* return error */ return thread->error; } @@ -915,7 +909,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex) rt_hw_interrupt_enable(temp); /* enable interrupt */ return -RT_EFULL; /* value overflowed */ } - + /* clear owner */ mutex->owner = RT_NULL; mutex->original_priority = 0xff; @@ -1152,6 +1146,7 @@ rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set) /* resume thread, and thread list breaks out */ rt_thread_resume(thread); + thread->error = RT_EOK; /* need do a scheduling */ need_schedule = RT_TRUE; @@ -1207,7 +1202,7 @@ rt_err_t rt_event_recv(rt_event_t event, /* get current thread */ thread = rt_thread_self(); /* reset thread error */ - thread->error = RT_EOK; + thread->error = -RT_EINTR; RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(event->parent.parent))); @@ -1236,11 +1231,11 @@ rt_err_t rt_event_recv(rt_event_t event, /* set received event */ if (recved) *recved = (event->set & set); - - /* fill thread event info */ + + /* fill thread event info */ thread->event_set = (event->set & set); thread->event_info = option; - + /* received event */ if (option & RT_EVENT_FLAG_CLEAR) event->set &= ~set; @@ -1541,7 +1536,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb, while (mb->entry == mb->size) { /* reset error number in thread */ - thread->error = RT_EOK; + thread->error = -RT_EINTR; /* no waiting, return timeout */ if (timeout == 0) @@ -1606,7 +1601,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb, ++ mb->in_offset; if (mb->in_offset >= mb->size) mb->in_offset = 0; - + if(mb->entry < RT_MB_ENTRY_MAX) { /* increase message entry */ @@ -1617,7 +1612,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb, rt_hw_interrupt_enable(temp); /* enable interrupt */ return -RT_EFULL; /* value overflowed */ } - + /* resume suspended thread */ if (!rt_list_isempty(&mb->parent.suspend_thread)) { @@ -1696,7 +1691,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout) while (mb->entry == 0) { /* reset error number in thread */ - thread->error = RT_EOK; + thread->error = -RT_EINTR; /* no waiting, return timeout */ if (timeout == 0) @@ -2094,7 +2089,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t mq, while ((msg = mq->msg_queue_free) == RT_NULL) { /* reset error number in thread */ - thread->error = RT_EOK; + thread->error = -RT_EINTR; /* no waiting, return timeout */ if (timeout == 0) @@ -2297,7 +2292,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size) rt_hw_interrupt_enable(temp); /* enable interrupt */ return -RT_EFULL; /* value overflowed */ } - + /* resume suspended thread */ if (!rt_list_isempty(&mq->parent.suspend_thread)) { @@ -2369,7 +2364,7 @@ rt_err_t rt_mq_recv(rt_mq_t mq, RT_DEBUG_IN_THREAD_CONTEXT; /* reset error number in thread */ - thread->error = RT_EOK; + thread->error = -RT_EINTR; /* no waiting, return timeout */ if (timeout == 0) -- Gitee From 5318d57587822a03fe2041b216b43deade62b507 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 11 Dec 2020 09:20:24 +0800 Subject: [PATCH 02/16] =?UTF-8?q?=E8=B0=83=E6=95=B4thread=20suspend?= =?UTF-8?q?=E7=8A=B6=E6=80=81=EF=BC=8C=E5=88=86=E6=88=90interruptible=20ki?= =?UTF-8?q?llable=20uninterruptible=E4=B8=89=E4=B8=AA=E6=83=85=E5=86=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bsp/gkipc/armv6/rtos_lib.c | 2 +- bsp/gkipc/armv6/trap.c | 2 +- components/finsh/cmd.c | 2 +- components/lwp/lwp_pid.c | 6 +++--- components/lwp/lwp_signal.c | 4 ++-- include/rtdef.h | 21 ++++++++++++++------- src/scheduler.c | 4 ++-- src/signal.c | 2 +- src/thread.c | 4 ++-- src/timer.c | 2 +- 10 files changed, 28 insertions(+), 21 deletions(-) diff --git a/bsp/gkipc/armv6/rtos_lib.c b/bsp/gkipc/armv6/rtos_lib.c index 7d7aec5c51..2f8b0b1e43 100644 --- a/bsp/gkipc/armv6/rtos_lib.c +++ b/bsp/gkipc/armv6/rtos_lib.c @@ -720,7 +720,7 @@ void thread_statistics() rt_kprintf("%-32.*s %3d", RT_NAME_MAX, thread->name, priority); #endif if (thread->stat == RT_THREAD_READY) rt_kprintf(" ready"); - else if (thread->stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend"); + else if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) rt_kprintf(" suspend"); else if (thread->stat == RT_THREAD_INIT) rt_kprintf(" init"); else if (thread->stat == RT_THREAD_CLOSE) rt_kprintf(" close"); diff --git a/bsp/gkipc/armv6/trap.c b/bsp/gkipc/armv6/trap.c index 602badff39..f3ed43ab13 100644 --- a/bsp/gkipc/armv6/trap.c +++ b/bsp/gkipc/armv6/trap.c @@ -88,7 +88,7 @@ static void _rtt_statistics() rt_kprintf("%-32.*s %03d", RT_NAME_MAX, thread->name, priority); #endif if (thread->stat == RT_THREAD_READY) rt_kprintf(" ready "); - else if (thread->stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend"); + else if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) rt_kprintf(" suspend"); else if (thread->stat == RT_THREAD_INIT) rt_kprintf(" init "); else if (thread->stat == RT_THREAD_CLOSE) rt_kprintf(" close "); diff --git a/components/finsh/cmd.c b/components/finsh/cmd.c index d53e30ceaa..3c2a0b74c8 100644 --- a/components/finsh/cmd.c +++ b/components/finsh/cmd.c @@ -221,7 +221,7 @@ long list_thread(void) #endif /*RT_USING_SMP*/ stat = (thread->stat & RT_THREAD_STAT_MASK); if (stat == RT_THREAD_READY) rt_kprintf(" ready "); - else if (stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend"); + else if ((stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) rt_kprintf(" suspend"); else if (stat == RT_THREAD_INIT) rt_kprintf(" init "); else if (stat == RT_THREAD_CLOSE) rt_kprintf(" close "); else if (stat == RT_THREAD_RUNNING) rt_kprintf(" running"); diff --git a/components/lwp/lwp_pid.c b/components/lwp/lwp_pid.c index 700f347007..1ca9b3ce04 100644 --- a/components/lwp/lwp_pid.c +++ b/components/lwp/lwp_pid.c @@ -464,7 +464,7 @@ static void print_thread_info(struct rt_thread* thread, int maxlen) stat = (thread->stat & RT_THREAD_STAT_MASK); if (stat == RT_THREAD_READY) rt_kprintf(" ready "); - else if (stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend"); + else if ((stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) rt_kprintf(" suspend"); else if (stat == RT_THREAD_INIT) rt_kprintf(" init "); else if (stat == RT_THREAD_CLOSE) rt_kprintf(" close "); else if (stat == RT_THREAD_RUNNING) rt_kprintf(" running"); @@ -694,7 +694,7 @@ void lwp_request_thread_exit(rt_thread_t thread_to_exit) { thread->exit_request = LWP_EXIT_REQUEST_TRIGGERED; } - if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND) + if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) { thread->error = RT_EINTR; dsb(); @@ -734,7 +734,7 @@ void lwp_terminate(struct rt_lwp *lwp) { thread->exit_request = LWP_EXIT_REQUEST_TRIGGERED; } - if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND) + if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) { thread->error = RT_EINTR; dsb(); diff --git a/components/lwp/lwp_signal.c b/components/lwp/lwp_signal.c index e0e0c24ff1..22ca341a37 100644 --- a/components/lwp/lwp_signal.c +++ b/components/lwp/lwp_signal.c @@ -255,7 +255,7 @@ int lwp_kill(pid_t pid, int sig) signal = (1 << sig); signal &= ~lwp->signal_mask; lwp->signal |= signal; - if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND) + if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) { rt_thread_wakeup(thread); @@ -285,7 +285,7 @@ int lwp_thread_kill(rt_thread_t thread, int sig) signal = (1 << sig); signal &= ~thread->signal_mask; thread->signal |= signal; - if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND) + if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) { rt_thread_wakeup(thread); diff --git a/include/rtdef.h b/include/rtdef.h index 7f39ec35c3..8a73716d60 100644 --- a/include/rtdef.h +++ b/include/rtdef.h @@ -511,13 +511,20 @@ typedef siginfo_t rt_siginfo_t; /* * thread state definitions */ -#define RT_THREAD_INIT 0x00 /**< Initialized status */ -#define RT_THREAD_READY 0x01 /**< Ready status */ -#define RT_THREAD_SUSPEND 0x02 /**< Suspend status */ -#define RT_THREAD_RUNNING 0x03 /**< Running status */ -#define RT_THREAD_BLOCK RT_THREAD_SUSPEND /**< Blocked status */ -#define RT_THREAD_CLOSE 0x04 /**< Closed status */ -#define RT_THREAD_STAT_MASK 0x07 +#define RT_THREAD_INIT 0x00 /**< Initialized status */ +#define RT_THREAD_CLOSE 0x01 /**< Closed status */ +#define RT_THREAD_READY 0x02 /**< Ready status */ +#define RT_THREAD_RUNNING 0x03 /**< Running status */ + +#define RT_THREAD_SUSPEND_MASK 0x04 +#define RT_SIGNAL_COMMON_WAKEUP_MASK 0x02 +#define RT_SIGNAL_KILL_WAKEUP_MASK 0x01 + +#define RT_THREAD_SUSPEND_INTERRUPTIBLE (RT_THREAD_SUSPEND_MASK) /**< Suspend interruptable 0x4 */ +#define RT_THREAD_SUSPEND RT_THREAD_SUSPEND_INTERRUPTIBLE +#define RT_THREAD_SUSPEND_KILLABLE (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK) /**< Suspend with killable 0x6 */ +#define RT_THREAD_SUSPEND_UNINTERRUPTIBLE (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK | RT_SIGNAL_KILL_WAKEUP_MASK) /**< Suspend with uninterruptable 0x7 */ +#define RT_THREAD_STAT_MASK 0x07 #define RT_THREAD_STAT_YIELD 0x08 /**< indicate whether remaining_tick has been reloaded since last schedule */ #define RT_THREAD_STAT_YIELD_MASK RT_THREAD_STAT_YIELD diff --git a/src/scheduler.c b/src/scheduler.c index 2daf9aae9e..385d800b48 100644 --- a/src/scheduler.c +++ b/src/scheduler.c @@ -315,7 +315,7 @@ void rt_schedule(void) } #ifdef RT_USING_SIGNALS - if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND) + if ((current_thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) { /* if current_thread signal is in pending */ @@ -559,7 +559,7 @@ void rt_scheduler_do_irq_switch(void *context) current_thread = pcpu->current_thread; #ifdef RT_USING_SIGNALS - if ((current_thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND) + if ((current_thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) { /* if current_thread signal is in pending */ diff --git a/src/signal.c b/src/signal.c index 8745c18e47..59ecc40b48 100644 --- a/src/signal.c +++ b/src/signal.c @@ -102,7 +102,7 @@ static void _signal_deliver(rt_thread_t tid) return; } - if ((tid->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND) + if ((tid->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) { /* resume thread to handle signal */ #ifdef RT_USING_LWP diff --git a/src/thread.c b/src/thread.c index 0290f330f8..bf549f52ee 100644 --- a/src/thread.c +++ b/src/thread.c @@ -807,7 +807,7 @@ rt_err_t rt_thread_resume(rt_thread_t thread) RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: %s\n", thread->name)); - if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_SUSPEND) + if ((thread->stat & RT_THREAD_SUSPEND_MASK) != RT_THREAD_SUSPEND_MASK) { RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: thread disorder, %d\n", thread->stat)); @@ -899,7 +899,7 @@ void rt_thread_timeout(void *parameter) /* thread check */ RT_ASSERT(thread != RT_NULL); - RT_ASSERT((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND); + RT_ASSERT((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK); RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread); /* set error number */ diff --git a/src/timer.c b/src/timer.c index b5c978991c..41d419dc90 100644 --- a/src/timer.c +++ b/src/timer.c @@ -415,7 +415,7 @@ rt_err_t rt_timer_start(rt_timer_t timer) { /* check whether timer thread is ready */ if ((soft_timer_status == RT_SOFT_TIMER_IDLE) && - ((timer_thread.stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND)) + ((timer_thread.stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK)) { /* resume timer thread to check soft timer */ rt_thread_resume(&timer_thread); -- Gitee From b3404e990180bbce222364ecaaf0e8bdd313ca12 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 11 Dec 2020 09:23:31 +0800 Subject: [PATCH 03/16] =?UTF-8?q?=E8=A7=84=E8=8C=83signal=E5=8F=B7?= =?UTF-8?q?=EF=BC=8C=E5=85=88=E6=8A=8A=E6=89=80=E6=9C=89suspend=E7=BD=AE?= =?UTF-8?q?=E4=BA=8Euninterruptible=E7=8A=B6=E6=80=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bsp/gkipc/armv6/rtos_lib.c | 2 +- components/dfs/src/poll.c | 2 +- components/drivers/audio/audio_pipe.c | 4 +- components/drivers/src/completion.c | 2 +- components/drivers/src/dataqueue.c | 30 +-- components/drivers/src/waitqueue.c | 2 +- components/drivers/src/workqueue.c | 2 +- components/libc/compilers/newlib/syscalls.c | 2 +- components/libc/libdl/dlmodule.c | 2 +- components/lwp/arch/arm/cortex-a/lwp_arch.h | 5 + components/lwp/lwp.h | 6 +- components/lwp/lwp_ipc.c | 2 +- components/lwp/lwp_pid.c | 2 +- components/lwp/lwp_signal.c | 264 +++++++++++++++----- components/lwp/lwp_signal.h | 2 +- components/vbus/prio_queue.c | 2 +- components/vbus/vbus.c | 4 +- components/vbus/watermark_queue.h | 2 +- examples/kernel/thread_resume.c | 2 +- examples/kernel/thread_suspend.c | 2 +- include/rtdef.h | 26 +- include/rtthread.h | 3 +- libcpu/arm/AT91SAM7X/trap.c | 2 +- libcpu/arm/cortex-a/trap.c | 4 +- src/ipc.c | 2 +- src/mempool.c | 2 +- src/signal.c | 2 +- src/thread.c | 42 +++- src/timer.c | 2 +- 29 files changed, 306 insertions(+), 120 deletions(-) diff --git a/bsp/gkipc/armv6/rtos_lib.c b/bsp/gkipc/armv6/rtos_lib.c index 2f8b0b1e43..78e7e1ccfa 100644 --- a/bsp/gkipc/armv6/rtos_lib.c +++ b/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); + return rt_thread_suspend((rt_thread_t)threadHandle, RT_UNINTERRUPTIBLE); } U32 RTOS_WakeupThread( RTOS_ThreadT threadHandle ) diff --git a/components/dfs/src/poll.c b/components/dfs/src/poll.c index fc48eca758..7a1f22c5cd 100644 --- a/components/dfs/src/poll.c +++ b/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) { - rt_thread_suspend(thread); + rt_thread_suspend(thread, RT_UNINTERRUPTIBLE); if (timeout > 0) { rt_timer_control(&(thread->thread_timer), diff --git a/components/drivers/audio/audio_pipe.c b/components/drivers/audio/audio_pipe.c index d7c37009b6..dca9c72be7 100644 --- a/components/drivers/audio/audio_pipe.c +++ b/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_thread_suspend(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_thread_suspend(thread, RT_UNINTERRUPTIBLE); /* waiting on suspended read list */ rt_list_insert_before(&(pipe->suspended_write_list), &(thread->tlist)); diff --git a/components/drivers/src/completion.c b/components/drivers/src/completion.c index 9e461e49ce..cdb6bd8fab 100644 --- a/components/drivers/src/completion.c +++ b/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_thread_suspend(thread, RT_UNINTERRUPTIBLE); /* add to suspended list */ rt_list_insert_before(&(completion->suspended_list), &(thread->tlist)); diff --git a/components/drivers/src/dataqueue.c b/components/drivers/src/dataqueue.c index bfe8e12573..196b81598a 100644 --- a/components/drivers/src/dataqueue.c +++ b/components/drivers/src/dataqueue.c @@ -62,7 +62,7 @@ rt_err_t rt_data_queue_push(struct rt_data_queue *queue, rt_ubase_t level; rt_thread_t thread; rt_err_t result; - + RT_ASSERT(queue != RT_NULL); RT_ASSERT(queue->magic == DATAQUEUE_MAGIC); @@ -85,9 +85,9 @@ rt_err_t rt_data_queue_push(struct rt_data_queue *queue, /* reset thread error number */ thread->error = RT_EOK; - + /* suspend thread on the push list */ - rt_thread_suspend(thread); + rt_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_before(&(queue->suspended_push_list), &(thread->tlist)); /* start timer */ if (timeout > 0) @@ -155,13 +155,13 @@ RTM_EXPORT(rt_data_queue_push); rt_err_t rt_data_queue_pop(struct rt_data_queue *queue, const void** data_ptr, - rt_size_t *size, + rt_size_t *size, rt_int32_t timeout) { rt_ubase_t level; rt_thread_t thread; rt_err_t result; - + RT_ASSERT(queue != RT_NULL); RT_ASSERT(queue->magic == DATAQUEUE_MAGIC); RT_ASSERT(data_ptr != RT_NULL); @@ -185,9 +185,9 @@ rt_err_t rt_data_queue_pop(struct rt_data_queue *queue, /* reset thread error number */ thread->error = RT_EOK; - + /* suspend thread on the pop list */ - rt_thread_suspend(thread); + rt_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_before(&(queue->suspended_pop_list), &(thread->tlist)); /* start timer */ if (timeout > 0) @@ -269,11 +269,11 @@ rt_err_t rt_data_queue_peak(struct rt_data_queue *queue, rt_size_t *size) { rt_ubase_t level; - + RT_ASSERT(queue != RT_NULL); RT_ASSERT(queue->magic == DATAQUEUE_MAGIC); - if (queue->is_empty) + if (queue->is_empty) { return -RT_EEMPTY; } @@ -293,7 +293,7 @@ void rt_data_queue_reset(struct rt_data_queue *queue) { rt_ubase_t level; struct rt_thread *thread; - + RT_ASSERT(queue != RT_NULL); RT_ASSERT(queue->magic == DATAQUEUE_MAGIC); @@ -303,9 +303,9 @@ void rt_data_queue_reset(struct rt_data_queue *queue) queue->put_index = 0; queue->is_empty = 1; queue->is_full = 0; - + rt_hw_interrupt_enable(level); - + rt_enter_critical(); /* wakeup all suspend threads */ @@ -375,7 +375,7 @@ rt_err_t rt_data_queue_deinit(struct rt_data_queue *queue) level = rt_hw_interrupt_disable(); queue->magic = 0; rt_hw_interrupt_enable(level); - + rt_free(queue->queue); return RT_EOK; @@ -386,7 +386,7 @@ rt_uint16_t rt_data_queue_len(struct rt_data_queue *queue) { rt_ubase_t level; rt_int16_t len; - + RT_ASSERT(queue != RT_NULL); RT_ASSERT(queue->magic == DATAQUEUE_MAGIC); @@ -405,7 +405,7 @@ rt_uint16_t rt_data_queue_len(struct rt_data_queue *queue) { len = queue->size + queue->put_index - queue->get_index; } - + rt_hw_interrupt_enable(level); return len; diff --git a/components/drivers/src/waitqueue.c b/components/drivers/src/waitqueue.c index 02240edbdf..ae82f481b3 100644 --- a/components/drivers/src/waitqueue.c +++ b/components/drivers/src/waitqueue.c @@ -103,7 +103,7 @@ int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec) } rt_wqueue_add(queue, &__wait); - rt_thread_suspend(tid); + rt_thread_suspend(tid, RT_UNINTERRUPTIBLE); /* start timer */ if (tick != RT_WAITING_FOREVER) diff --git a/components/drivers/src/workqueue.c b/components/drivers/src/workqueue.c index 2e0280df3a..27cfc8c65e 100644 --- a/components/drivers/src/workqueue.c +++ b/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_thread_suspend(rt_thread_self(), RT_UNINTERRUPTIBLE); rt_schedule(); } diff --git a/components/libc/compilers/newlib/syscalls.c b/components/libc/compilers/newlib/syscalls.c index 228fa0d140..dfbd6cc26e 100644 --- a/components/libc/compilers/newlib/syscalls.c +++ b/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_thread_suspend(self, RT_UNINTERRUPTIBLE); rt_schedule(); } diff --git a/components/libc/libdl/dlmodule.c b/components/libc/libdl/dlmodule.c index 314cf52709..a5954de4d5 100644 --- a/components/libc/libdl/dlmodule.c +++ b/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_thread_suspend(thread, RT_UNINTERRUPTIBLE); } } } diff --git a/components/lwp/arch/arm/cortex-a/lwp_arch.h b/components/lwp/arch/arm/cortex-a/lwp_arch.h index 716e2ce26f..22a0f1fc6c 100644 --- a/components/lwp/arch/arm/cortex-a/lwp_arch.h +++ b/components/lwp/arch/arm/cortex-a/lwp_arch.h @@ -28,6 +28,11 @@ void *arch_kernel_mmu_table_get(void); void arch_kuser_init(rt_mmu_info *mmu_info, void *vectors); int arch_expand_user_stack(void *addr); +rt_inline unsigned long ffz(unsigned long x) +{ + return __builtin_ffs(~x) - 1; +} + #ifdef __cplusplus } #endif diff --git a/components/lwp/lwp.h b/components/lwp/lwp.h index 1667df5c9e..c4a279673d 100644 --- a/components/lwp/lwp.h +++ b/components/lwp/lwp.h @@ -81,11 +81,11 @@ struct rt_lwp struct dfs_fdtable fdt; char cmd[RT_NAME_MAX]; - rt_uint32_t signal; + lwp_sigset_t signal; lwp_sigset_t signal_mask; - lwp_sigset_t signal_mask_bak; + int signal_mask_bak; rt_uint32_t signal_in_process; - lwp_sighandler_t signal_handler[32]; + lwp_sighandler_t signal_handler[_LWP_NSIG]; rt_list_t object_list; struct rt_user_context user_ctx; diff --git a/components/lwp/lwp_ipc.c b/components/lwp/lwp_ipc.c index 3b6f5627e3..0edfd02f99 100644 --- a/components/lwp/lwp_ipc.c +++ b/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_thread_suspend(thread); + rt_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_before(list, &(thread->tlist)); /* list end */ diff --git a/components/lwp/lwp_pid.c b/components/lwp/lwp_pid.c index 1ca9b3ce04..d126427ed6 100644 --- a/components/lwp/lwp_pid.c +++ b/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_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_before(&lwp->wait_list, &(thread->tlist)); rt_schedule(); if (thread->error == RT_EOK) diff --git a/components/lwp/lwp_signal.c b/components/lwp/lwp_signal.c index 22ca341a37..ef921dfbb4 100644 --- a/components/lwp/lwp_signal.c +++ b/components/lwp/lwp_signal.c @@ -12,13 +12,116 @@ #include #include "lwp.h" +#include "lwp_arch.h" +#include "signal.h" + +rt_inline void lwp_sigaddset(lwp_sigset_t *set, int _sig) +{ + unsigned long sig = _sig - 1; + + if (_LWP_NSIG_WORDS == 1) + { + set->sig[0] |= 1UL << sig; + } + else + { + set->sig[sig / _LWP_NSIG_BPW] |= 1UL << (sig % _LWP_NSIG_BPW); + } +} + +rt_inline void lwp_sigdelset(lwp_sigset_t *set, int _sig) +{ + unsigned long sig = _sig - 1; + + if (_LWP_NSIG_WORDS == 1) + { + set->sig[0] &= ~(1UL << sig); + } + else + { + set->sig[sig / _LWP_NSIG_BPW] &= ~(1UL << (sig % _LWP_NSIG_BPW)); + } +} + +rt_inline int lwp_sigisemptyset(lwp_sigset_t *set) +{ + switch (_LWP_NSIG_WORDS) + { + case 4: + return (set->sig[3] | set->sig[2] | + set->sig[1] | set->sig[0]) == 0; + case 2: + return (set->sig[1] | set->sig[0]) == 0; + case 1: + return set->sig[0] == 0; + default: + return 1; + } +} + +rt_inline int lwp_sigismember(lwp_sigset_t *set, int _sig) +{ + unsigned long sig = _sig - 1; + + if (_LWP_NSIG_WORDS == 1) + { + return 1 & (set->sig[0] >> sig); + } + else + { + return 1 & (set->sig[sig / _LWP_NSIG_BPW] >> (sig % _LWP_NSIG_BPW)); + } +} + +rt_inline int next_signal(lwp_sigset_t *pending, lwp_sigset_t *mask) +{ + unsigned long i, *s, *m, x; + int sig = 0; + + s = pending->sig; + m = mask->sig; + + x = *s & ~*m; + if (x) + { + sig = ffz(~x) + 1; + return sig; + } + + switch (_LWP_NSIG_WORDS) + { + default: + for (i = 1; i < _LWP_NSIG_WORDS; ++i) + { + x = *++s &~ *++m; + if (!x) + continue; + sig = ffz(~x) + i*_LWP_NSIG_BPW + 1; + break; + } + break; + + case 2: + x = s[1] &~ m[1]; + if (!x) + break; + sig = ffz(~x) + _LWP_NSIG_BPW + 1; + break; + + case 1: + /* Nothing to do */ + break; + } + + return sig; +} int lwp_signal_check(void) { rt_base_t level; struct rt_thread *thread; struct rt_lwp *lwp; - uint32_t signal = 0; + uint32_t have_signal = 0; level = rt_hw_interrupt_disable(); @@ -36,28 +139,28 @@ int lwp_signal_check(void) goto out; } - signal = thread->signal; - if (signal) + have_signal = !lwp_sigisemptyset(&thread->signal); + if (have_signal) { thread->signal_in_process = 1; goto out; } - signal = lwp->signal; - if (signal) + have_signal = !lwp_sigisemptyset(&lwp->signal); + if (have_signal) { lwp->signal_in_process = 1; } out: rt_hw_interrupt_enable(level); - return signal; + return have_signal; } -uint32_t lwp_signal_backup(void *user_sp, void *user_pc, void* user_flag) +int lwp_signal_backup(void *user_sp, void *user_pc, void* user_flag) { rt_base_t level; struct rt_thread *thread; struct rt_lwp *lwp; - uint32_t signal, sig_bit; + int signal; level = rt_hw_interrupt_disable(); thread = rt_thread_self(); @@ -66,12 +169,12 @@ uint32_t lwp_signal_backup(void *user_sp, void *user_pc, void* user_flag) thread->user_ctx.sp = user_sp; thread->user_ctx.pc = user_pc; thread->user_ctx.flag = user_flag; - signal = thread->signal; - sig_bit = __builtin_ffs(signal); - sig_bit--; - thread->signal_mask |= (1 << sig_bit); - thread->signal_mask_bak = (1 << sig_bit); - thread->signal &= ~(1 << sig_bit); + + signal = next_signal(&thread->signal, &thread->signal_mask); + RT_ASSERT(signal != 0); + lwp_sigaddset(&thread->signal_mask, signal); + thread->signal_mask_bak = signal; + lwp_sigdelset(&thread->signal, signal); } else { @@ -79,15 +182,15 @@ uint32_t lwp_signal_backup(void *user_sp, void *user_pc, void* user_flag) lwp->user_ctx.sp = user_sp; lwp->user_ctx.pc = user_pc; lwp->user_ctx.flag = user_flag; - signal = lwp->signal; - sig_bit = __builtin_ffs(signal); - sig_bit--; - lwp->signal_mask |= (1 << sig_bit); - lwp->signal_mask_bak = (1 << sig_bit); - lwp->signal &= ~(1 << sig_bit); + + signal = next_signal(&lwp->signal, &lwp->signal_mask); + RT_ASSERT(signal != 0); + lwp_sigaddset(&lwp->signal_mask, signal); + lwp->signal_mask_bak = signal; + lwp_sigdelset(&lwp->signal, signal); } rt_hw_interrupt_enable(level); - return sig_bit; + return signal; } struct rt_user_context *lwp_signal_restore(void) @@ -103,7 +206,8 @@ struct rt_user_context *lwp_signal_restore(void) { ctx = &thread->user_ctx; thread->signal_in_process = 0; - thread->signal_mask &= ~thread->signal_mask_bak; + + lwp_sigdelset(&thread->signal_mask, thread->signal_mask_bak); thread->signal_mask_bak = 0; } else @@ -112,7 +216,8 @@ struct rt_user_context *lwp_signal_restore(void) ctx = &lwp->user_ctx; RT_ASSERT(lwp->signal_in_process != 0); lwp->signal_in_process = 0; - lwp->signal_mask &= ~lwp->signal_mask_bak; + + lwp_sigdelset(&lwp->signal_mask, lwp->signal_mask_bak); lwp->signal_mask_bak = 0; } rt_hw_interrupt_enable(level); @@ -122,17 +227,19 @@ struct rt_user_context *lwp_signal_restore(void) void sys_exit(int value); lwp_sighandler_t lwp_sighandler_get(int sig) { - lwp_sighandler_t func; + lwp_sighandler_t func = RT_NULL; struct rt_lwp *lwp; rt_thread_t thread; rt_thread_t main_thread; rt_base_t level; + if (sig == 0 || sig > _LWP_NSIG) + return func; level = rt_hw_interrupt_disable(); thread = rt_thread_self(); if (thread->signal_in_process) { - func = rt_thread_self()->signal_handler[sig]; + func = rt_thread_self()->signal_handler[sig - 1]; if (!func) { lwp = (struct rt_lwp*)thread->lwp; @@ -148,7 +255,7 @@ lwp_sighandler_t lwp_sighandler_get(int sig) sub_thread = rt_list_entry(s_list, struct rt_thread, sibling); /* kill all sub threads */ s_list = sub_thread->sibling.next; - lwp_thread_kill(sub_thread, 0); + lwp_thread_kill(sub_thread, SIGKILL); } } sys_exit(0); @@ -157,11 +264,11 @@ lwp_sighandler_t lwp_sighandler_get(int sig) else { lwp = (struct rt_lwp*)thread->lwp; - func = lwp->signal_handler[sig]; + func = lwp->signal_handler[sig - 1]; if (!func) { main_thread = rt_list_entry(lwp->t_grp.prev, struct rt_thread, sibling); - lwp_thread_kill(main_thread, 0); + lwp_thread_kill(main_thread, SIGKILL); } } rt_hw_interrupt_enable(level); @@ -172,8 +279,12 @@ void lwp_sighandler_set(int sig, lwp_sighandler_t func) { rt_base_t level; + if (sig == 0 || sig > _LWP_NSIG) + return; + if (sig == SIGKILL || sig == SIGSTOP) + return; level = rt_hw_interrupt_disable(); - ((struct rt_lwp*)rt_thread_self()->lwp)->signal_handler[sig] = func; + ((struct rt_lwp*)rt_thread_self()->lwp)->signal_handler[sig - 1] = func; rt_hw_interrupt_enable(level); } @@ -181,11 +292,12 @@ void lwp_thread_sighandler_set(int sig, lwp_sighandler_t func) { rt_base_t level; + if (sig == 0 || sig > _LWP_NSIG) + return; + if (sig == SIGKILL || sig == SIGSTOP) + return; level = rt_hw_interrupt_disable(); - if (sig) /* sig 0 is default behavior */ - { - rt_thread_self()->signal_handler[sig] = func; - } + rt_thread_self()->signal_handler[sig - 1] = func; rt_hw_interrupt_enable(level); } @@ -204,9 +316,13 @@ int lwp_sigprocmask(const lwp_sigset_t *sigset, lwp_sigset_t *oset) { goto out; } - *oset = lwp->signal_mask; - lwp->signal_mask = *sigset; - lwp->signal_mask_bak &= ~*sigset; + if (oset) + { + oset = rt_memcpy(oset, &lwp->signal_mask, sizeof(lwp_sigset_t)); + } + rt_memcpy(&lwp->signal_mask, sigset, sizeof(lwp_sigset_t)); + lwp_sigdelset(&lwp->signal_mask, SIGKILL); + lwp_sigdelset(&lwp->signal_mask, SIGSTOP); ret = 0; out: @@ -218,26 +334,58 @@ int lwp_thread_sigprocmask(const lwp_sigset_t *sigset, lwp_sigset_t *oset) { rt_base_t level; struct rt_thread *thread; - uint32_t value = *sigset; - value &= ~(1 << 0); /* thread sig 0 must not be masked */ level = rt_hw_interrupt_disable(); thread = rt_thread_self(); - *oset = thread->signal_mask; - thread->signal_mask = value; - thread->signal_mask_bak &= ~value; + + if (oset) + { + oset = rt_memcpy(oset, &thread->signal_mask, sizeof(lwp_sigset_t)); + } + rt_memcpy(&thread->signal_mask, sigset, sizeof(lwp_sigset_t)); + lwp_sigdelset(&thread->signal_mask, SIGKILL); + lwp_sigdelset(&thread->signal_mask, SIGSTOP); + rt_hw_interrupt_enable(level); return 0; } +static void _do_signal_wakeup(rt_thread_t thread, int sig) +{ + if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) + { + int need_schedule = 1; + + if ((thread->stat & RT_SIGNAL_COMMON_WAKEUP_MASK) != RT_SIGNAL_COMMON_WAKEUP_MASK) + { + rt_thread_wakeup(thread); + } + else if ((sig == SIGKILL) && ((thread->stat & RT_SIGNAL_KILL_WAKEUP_MASK) != RT_SIGNAL_KILL_WAKEUP_MASK)) + { + rt_thread_wakeup(thread); + } + else + { + need_schedule = 0; + } + + /* do schedule */ + if (need_schedule) + { + rt_schedule(); + } + } +} + int lwp_kill(pid_t pid, int sig) { rt_base_t level; struct rt_lwp *lwp; int ret = -RT_EINVAL; - uint32_t signal; rt_thread_t thread; + if (sig == 0 || sig > _LWP_NSIG) + return ret; level = rt_hw_interrupt_disable(); lwp = lwp_from_pid(pid); if (!lwp) @@ -247,21 +395,13 @@ int lwp_kill(pid_t pid, int sig) /* check main thread */ thread = rt_list_entry(lwp->t_grp.prev, struct rt_thread, sibling); - if ((lwp->signal_mask & (1 << sig)) != 0) + if (lwp_sigismember(&lwp->signal_mask, sig)) /* if signal masked */ { goto out; } - signal = (1 << sig); - signal &= ~lwp->signal_mask; - lwp->signal |= signal; - if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) - { - rt_thread_wakeup(thread); - - /* do schedule */ - rt_schedule(); - } + lwp_sigaddset(&lwp->signal, sig); + _do_signal_wakeup(thread, sig); ret = 0; out: rt_hw_interrupt_enable(level); @@ -272,28 +412,20 @@ int lwp_thread_kill(rt_thread_t thread, int sig) { rt_base_t level; int ret = -RT_EINVAL; - uint32_t signal; if (!thread) return ret; + if (sig == 0 || sig > _LWP_NSIG) + return ret; level = rt_hw_interrupt_disable(); - if ((thread->signal_mask & (1 << sig)) != 0) + if (lwp_sigismember(&thread->signal_mask, sig)) /* if signal masked */ { goto out; } - signal = (1 << sig); - signal &= ~thread->signal_mask; - thread->signal |= signal; - if ((thread->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK) - { - rt_thread_wakeup(thread); - - /* do schedule */ - rt_schedule(); - } + lwp_sigaddset(&thread->signal, sig); + _do_signal_wakeup(thread, sig); ret = 0; - out: rt_hw_interrupt_enable(level); return ret; diff --git a/components/lwp/lwp_signal.h b/components/lwp/lwp_signal.h index fe07a4e173..7e3118bb0e 100644 --- a/components/lwp/lwp_signal.h +++ b/components/lwp/lwp_signal.h @@ -18,7 +18,7 @@ extern "C" { #endif int lwp_signal_check(void); -uint32_t lwp_signal_backup(void *user_sp, void *user_pc, void* user_flag); +int lwp_signal_backup(void *user_sp, void *user_pc, void* user_flag); struct rt_user_context *lwp_signal_restore(void); lwp_sighandler_t lwp_sighandler_get(int sig); void lwp_sighandler_set(int sig, lwp_sighandler_t func); diff --git a/components/vbus/prio_queue.c b/components/vbus/prio_queue.c index bca3cdcd9a..44dd572d94 100644 --- a/components/vbus/prio_queue.c +++ b/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_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_before(&(que->suspended_pop_list), &(thread->tlist)); diff --git a/components/vbus/vbus.c b/components/vbus/vbus.c index 8add15d9db..06fd220057 100644 --- a/components/vbus/vbus.c +++ b/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_thread_suspend(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_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_after(&_chn_suspended_threads[id], &thread->tlist); if (timeout > 0) diff --git a/components/vbus/watermark_queue.h b/components/vbus/watermark_queue.h index 0ecc52d8ff..e5c2c4320d 100644 --- a/components/vbus/watermark_queue.h +++ b/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_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_after(&wg->suspended_threads, &thread->tlist); if (timeout > 0) { diff --git a/examples/kernel/thread_resume.c b/examples/kernel/thread_resume.c index cea814616f..59c7ad0810 100644 --- a/examples/kernel/thread_resume.c +++ b/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_thread_suspend(tid1, RT_UNINTERRUPTIBLE); /* 主动执行线程调度 */ rt_schedule(); diff --git a/examples/kernel/thread_suspend.c b/examples/kernel/thread_suspend.c index 947cc3cbf6..866608ab73 100644 --- a/examples/kernel/thread_suspend.c +++ b/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_thread_suspend(tid1, RT_UNINTERRUPTIBLE); /* 延时10个OS Tick */ rt_thread_delay(10); diff --git a/include/rtdef.h b/include/rtdef.h index 8a73716d60..b61fabe38f 100644 --- a/include/rtdef.h +++ b/include/rtdef.h @@ -516,6 +516,16 @@ typedef siginfo_t rt_siginfo_t; #define RT_THREAD_READY 0x02 /**< Ready status */ #define RT_THREAD_RUNNING 0x03 /**< Running status */ +/* + * for rt_thread_set_suspend_state() + */ +enum +{ + RT_INTERRUPTIBLE = 0, + RT_KILLABLE, + RT_UNINTERRUPTIBLE, +}; + #define RT_THREAD_SUSPEND_MASK 0x04 #define RT_SIGNAL_COMMON_WAKEUP_MASK 0x02 #define RT_SIGNAL_KILL_WAKEUP_MASK 0x01 @@ -589,8 +599,16 @@ struct rt_wakeup void *user_data; }; +#define _LWP_NSIG 64 +#define _LWP_NSIG_BPW 32 +#define _LWP_NSIG_WORDS (_LWP_NSIG / _LWP_NSIG_BPW) + typedef void (*lwp_sighandler_t)(int); -typedef rt_uint32_t lwp_sigset_t; + +typedef struct { + unsigned long sig[_LWP_NSIG_WORDS]; +} lwp_sigset_t; + struct rt_user_context { void *sp; @@ -691,11 +709,11 @@ struct rt_thread rt_uint32_t *kernel_sp; /**< kernel stack point */ rt_list_t sibling; /**< next thread of same process */ - rt_uint32_t signal; + lwp_sigset_t signal; lwp_sigset_t signal_mask; - lwp_sigset_t signal_mask_bak; + int signal_mask_bak; rt_uint32_t signal_in_process; - lwp_sighandler_t signal_handler[32]; + lwp_sighandler_t signal_handler[_LWP_NSIG]; struct rt_user_context user_ctx; struct rt_wakeup wakeup; /**< wakeup data */ diff --git a/include/rtthread.h b/include/rtthread.h index ce0505e9ed..90b7f1cb62 100644 --- a/include/rtthread.h +++ b/include/rtthread.h @@ -147,7 +147,8 @@ rt_err_t rt_thread_delay(rt_tick_t tick); 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); -rt_err_t rt_thread_suspend(rt_thread_t thread); +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_resume(rt_thread_t thread); #ifdef RT_USING_LWP rt_err_t rt_thread_wakeup(rt_thread_t thread); diff --git a/libcpu/arm/AT91SAM7X/trap.c b/libcpu/arm/AT91SAM7X/trap.c index 1c1c351ff8..450ee07757 100644 --- a/libcpu/arm/AT91SAM7X/trap.c +++ b/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_thread_suspend(rt_current_thread, RT_UNINTERRUPTIBLE); rt_schedule(); } diff --git a/libcpu/arm/cortex-a/trap.c b/libcpu/arm/cortex-a/trap.c index 7bdf5a846e..a9ed6c16df 100644 --- a/libcpu/arm/cortex-a/trap.c +++ b/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_thread_suspend(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_thread_suspend(thread_info.thread, RT_UNINTERRUPTIBLE); rt_schedule(); } return ret; diff --git a/src/ipc.c b/src/ipc.c index 30071e3e89..86c449f002 100644 --- a/src/ipc.c +++ b/src/ipc.c @@ -85,7 +85,7 @@ rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t *list, rt_uint8_t flag) { /* suspend thread */ - rt_thread_suspend(thread); + rt_thread_suspend(thread, RT_UNINTERRUPTIBLE); switch (flag) { diff --git a/src/mempool.c b/src/mempool.c index db614032aa..f07f8308e3 100644 --- a/src/mempool.c +++ b/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_thread_suspend(thread, RT_UNINTERRUPTIBLE); rt_list_insert_after(&(mp->suspend_thread), &(thread->tlist)); if (time > 0) diff --git a/src/signal.c b/src/signal.c index 59ecc40b48..1c41e47f0e 100644 --- a/src/signal.c +++ b/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_thread_suspend(tid, RT_UNINTERRUPTIBLE); /* set thread stat as waiting for signal */ tid->stat |= RT_THREAD_STAT_SIGNAL_WAIT; diff --git a/src/thread.c b/src/thread.c index bf549f52ee..65b67c3c1e 100644 --- a/src/thread.c +++ b/src/thread.c @@ -206,8 +206,8 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread, #ifdef RT_USING_LWP thread->lwp = RT_NULL; rt_list_init(&(thread->sibling)); - thread->signal = 0; - thread->signal_mask = 0; + rt_memset(&thread->signal, 0, sizeof(lwp_sigset_t)); + rt_memset(&thread->signal_mask, 0, sizeof(lwp_sigset_t)); thread->signal_mask_bak = 0; thread->signal_in_process = 0; rt_memset(thread->signal_handler, 0, sizeof thread->signal_handler); @@ -506,6 +506,35 @@ rt_err_t rt_thread_yield(void) } RTM_EXPORT(rt_thread_yield); +/** + * This function will set a thread's suspend status + * + * @param thread the thread to be suspend + * @param status flag of the thread, must be one of RT_INTERRUPTIBLE RT_KILLABLE RT_UNINTERRUPTIBLE + */ +void rt_thread_set_suspend_state(struct rt_thread *thread, int suspend_flag) +{ + rt_uint8_t stat = RT_THREAD_SUSPEND_UNINTERRUPTIBLE; + + RT_ASSERT(thread != RT_NULL); + switch (suspend_flag) + { + case RT_INTERRUPTIBLE: + stat = RT_THREAD_SUSPEND_INTERRUPTIBLE; + break; + case RT_KILLABLE: + stat = RT_THREAD_SUSPEND_KILLABLE; + break; + case RT_UNINTERRUPTIBLE: + stat = RT_THREAD_SUSPEND_UNINTERRUPTIBLE; + break; + default: + RT_ASSERT(0); + break; + } + thread->stat = stat | (thread->stat & ~RT_THREAD_STAT_MASK); +} + /** * This function will let current thread sleep for some ticks. * @@ -527,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_thread_suspend(thread, RT_UNINTERRUPTIBLE); /* reset the timeout of thread timer and start it */ rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick); @@ -586,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_thread_suspend(thread, RT_UNINTERRUPTIBLE); /* reset the timeout of thread timer and start it */ rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, tick); @@ -742,13 +771,14 @@ RTM_EXPORT(rt_thread_control); * This function will suspend the specified thread. * * @param thread the thread to be suspended + * @param suspend_flag status flag of the thread to be suspended * * @return the operation status, RT_EOK on OK, -RT_ERROR on error * * @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) +rt_err_t rt_thread_suspend(rt_thread_t thread, int suspend_flag) { register rt_base_t stat; register rt_base_t temp; @@ -777,7 +807,7 @@ rt_err_t rt_thread_suspend(rt_thread_t thread) /* change thread stat */ rt_schedule_remove_thread(thread); - thread->stat = RT_THREAD_SUSPEND | (thread->stat & ~RT_THREAD_STAT_MASK); + rt_thread_set_suspend_state(thread, suspend_flag); /* stop thread timer anyway */ rt_timer_stop(&(thread->thread_timer)); diff --git a/src/timer.c b/src/timer.c index 41d419dc90..3ffdb12104 100644 --- a/src/timer.c +++ b/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_thread_suspend(rt_thread_self(), RT_UNINTERRUPTIBLE); rt_schedule(); } else -- Gitee From a527cff879ec541dc91b08896a570b1bccde9e45 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Wed, 16 Dec 2020 17:58:33 +0800 Subject: [PATCH 04/16] =?UTF-8?q?=E9=9D=9Elwp=E7=BA=BF=E7=A8=8B=E4=B8=8D?= =?UTF-8?q?=E5=85=81=E8=AE=B8kill?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/lwp/lwp_signal.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/components/lwp/lwp_signal.c b/components/lwp/lwp_signal.c index ef921dfbb4..b3250c2efe 100644 --- a/components/lwp/lwp_signal.c +++ b/components/lwp/lwp_signal.c @@ -418,6 +418,10 @@ int lwp_thread_kill(rt_thread_t thread, int sig) if (sig == 0 || sig > _LWP_NSIG) return ret; level = rt_hw_interrupt_disable(); + if (!thread->lwp) + { + goto out; + } if (lwp_sigismember(&thread->signal_mask, sig)) /* if signal masked */ { goto out; -- Gitee From 29dcc08ce5535e7451e41b4bf58ae3f34795208e Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 11 Dec 2020 16:59:01 +0800 Subject: [PATCH 05/16] =?UTF-8?q?suspend=E5=8A=A0=E4=B8=8A=E4=BF=A1?= =?UTF-8?q?=E5=8F=B7=E6=A3=80=E6=B5=8B,=20=E5=AD=98=E5=9C=A8=E9=9C=80?= =?UTF-8?q?=E8=A6=81=E5=93=8D=E5=BA=94=E4=BF=A1=E5=8F=B7=E6=97=B6=EF=BC=8C?= =?UTF-8?q?rt=5Fthread=5Fsuspend=E8=BF=94=E5=9B=9E-RT=5FEINTR?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/lwp/lwp_signal.c | 39 +++++ include/rtthread.h | 40 +++++ src/ipc.c | 288 ++++++++++++++++++++++++++++++++---- src/thread.c | 11 ++ 4 files changed, 351 insertions(+), 27 deletions(-) diff --git a/components/lwp/lwp_signal.c b/components/lwp/lwp_signal.c index b3250c2efe..44efe9dfa9 100644 --- a/components/lwp/lwp_signal.c +++ b/components/lwp/lwp_signal.c @@ -116,6 +116,45 @@ rt_inline int next_signal(lwp_sigset_t *pending, lwp_sigset_t *mask) return sig; } +int lwp_suspend_sigcheck(rt_thread_t thread, int suspend_flag) +{ + struct rt_lwp *lwp = (struct rt_lwp*)thread->lwp; + int ret = 0; + + switch (suspend_flag) + { + case RT_INTERRUPTIBLE: + if (!lwp_sigisemptyset(&thread->signal)) + { + break; + } + if (thread->lwp && !lwp_sigisemptyset(&lwp->signal)) + { + break; + } + ret = 1; + break; + case RT_KILLABLE: + if (lwp_sigismember(&thread->signal, SIGKILL)) + { + break; + } + if (thread->lwp && lwp_sigismember(&thread->signal, SIGKILL)) + { + break; + } + ret = 1; + break; + case RT_UNINTERRUPTIBLE: + ret = 1; + break; + default: + RT_ASSERT(0); + break; + } + return ret; +} + int lwp_signal_check(void) { rt_base_t level; diff --git a/include/rtthread.h b/include/rtthread.h index 90b7f1cb62..6ff8f640cc 100644 --- a/include/rtthread.h +++ b/include/rtthread.h @@ -315,6 +315,8 @@ rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag); rt_err_t rt_sem_delete(rt_sem_t sem); rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time); +rt_err_t rt_sem_take_interruptible(rt_sem_t sem, rt_int32_t time); +rt_err_t rt_sem_take_killable(rt_sem_t sem, rt_int32_t time); rt_err_t rt_sem_trytake(rt_sem_t sem); rt_err_t rt_sem_release(rt_sem_t sem); rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg); @@ -330,6 +332,8 @@ rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag); rt_err_t rt_mutex_delete(rt_mutex_t mutex); rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time); +rt_err_t rt_mutex_take_interruptible(rt_mutex_t mutex, rt_int32_t time); +rt_err_t rt_mutex_take_killable(rt_mutex_t mutex, rt_int32_t time); rt_err_t rt_mutex_release(rt_mutex_t mutex); rt_err_t rt_mutex_control(rt_mutex_t mutex, int cmd, void *arg); #endif @@ -349,6 +353,16 @@ rt_err_t rt_event_recv(rt_event_t event, rt_uint8_t opt, rt_int32_t timeout, rt_uint32_t *recved); +rt_err_t rt_event_recv_interruptible(rt_event_t event, + rt_uint32_t set, + rt_uint8_t opt, + rt_int32_t timeout, + rt_uint32_t *recved); +rt_err_t rt_event_recv_killable(rt_event_t event, + rt_uint32_t set, + rt_uint8_t opt, + rt_int32_t timeout, + rt_uint32_t *recved); rt_err_t rt_event_control(rt_event_t event, int cmd, void *arg); #endif @@ -369,7 +383,15 @@ rt_err_t rt_mb_send(rt_mailbox_t mb, rt_ubase_t value); rt_err_t rt_mb_send_wait(rt_mailbox_t mb, rt_ubase_t value, rt_int32_t timeout); +rt_err_t rt_mb_send_wait_interruptible(rt_mailbox_t mb, + rt_ubase_t value, + rt_int32_t timeout); +rt_err_t rt_mb_send_wait_killable(rt_mailbox_t mb, + rt_ubase_t value, + rt_int32_t timeout); rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout); +rt_err_t rt_mb_recv_interruptibale(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout); +rt_err_t rt_mb_recv_killable(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout); rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg); #endif @@ -391,15 +413,33 @@ rt_mq_t rt_mq_create(const char *name, rt_err_t rt_mq_delete(rt_mq_t mq); rt_err_t rt_mq_send(rt_mq_t mq, const void *buffer, rt_size_t size); +rt_err_t rt_mq_send_interrupt(rt_mq_t mq, const void *buffer, rt_size_t size); +rt_err_t rt_mq_send_killable(rt_mq_t mq, const void *buffer, rt_size_t size); rt_err_t rt_mq_send_wait(rt_mq_t mq, const void *buffer, rt_size_t size, rt_int32_t timeout); +rt_err_t rt_mq_send_wait_interruptible(rt_mq_t mq, + const void *buffer, + rt_size_t size, + rt_int32_t timeout); +rt_err_t rt_mq_send_wait_killable(rt_mq_t mq, + const void *buffer, + rt_size_t size, + rt_int32_t timeout); rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size); rt_err_t rt_mq_recv(rt_mq_t mq, void *buffer, rt_size_t size, rt_int32_t timeout); +rt_err_t rt_mq_recv_interruptible(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout); +rt_err_t rt_mq_recv_killable(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout); rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg); #endif diff --git a/src/ipc.c b/src/ipc.c index 86c449f002..706c6af7b7 100644 --- a/src/ipc.c +++ b/src/ipc.c @@ -82,10 +82,16 @@ rt_inline rt_err_t rt_ipc_object_init(struct rt_ipc_object *ipc) */ rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t *list, struct rt_thread *thread, - rt_uint8_t flag) + rt_uint8_t flag, + int suspend_flag) { + rt_err_t ret = rt_thread_suspend(thread, suspend_flag); + /* suspend thread */ - rt_thread_suspend(thread, RT_UNINTERRUPTIBLE); + if (ret != RT_EOK) + { + return ret; + } switch (flag) { @@ -329,10 +335,11 @@ RTM_EXPORT(rt_sem_delete); * * @return the error code */ -rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time) +static rt_err_t _rt_sem_take(rt_sem_t sem, rt_int32_t time, int suspend_flag) { register rt_base_t temp; struct rt_thread *thread; + rt_err_t ret; /* parameter check */ RT_ASSERT(sem != RT_NULL); @@ -381,9 +388,15 @@ 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), + ret = rt_ipc_list_suspend(&(sem->parent.suspend_thread), thread, - sem->parent.parent.flag); + sem->parent.parent.flag, + suspend_flag); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(temp); + return ret; + } /* has waiting time, start thread timer */ if (time > 0) @@ -415,8 +428,25 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time) return RT_EOK; } + +rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time) +{ + return _rt_sem_take(sem, time, RT_UNINTERRUPTIBLE); +} RTM_EXPORT(rt_sem_take); +rt_err_t rt_sem_take_interruptible(rt_sem_t sem, rt_int32_t time) +{ + return _rt_sem_take(sem, time, RT_INTERRUPTIBLE); +} +RTM_EXPORT(rt_sem_take_interruptible); + +rt_err_t rt_sem_take_killable(rt_sem_t sem, rt_int32_t time) +{ + return _rt_sem_take(sem, time, RT_KILLABLE); +} +RTM_EXPORT(rt_sem_take_killable); + /** * This function will try to take a semaphore and immediately return * @@ -669,10 +699,11 @@ RTM_EXPORT(rt_mutex_delete); * * @return the error code */ -rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time) +static rt_err_t _rt_mutex_take(rt_mutex_t mutex, rt_int32_t time, int suspend_flag) { register rt_base_t temp; struct rt_thread *thread; + rt_err_t ret; /* this function must not be used in interrupt even if time = 0 */ RT_DEBUG_IN_THREAD_CONTEXT; @@ -761,9 +792,15 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time) } /* suspend current thread */ - rt_ipc_list_suspend(&(mutex->parent.suspend_thread), + ret = rt_ipc_list_suspend(&(mutex->parent.suspend_thread), thread, - mutex->parent.parent.flag); + mutex->parent.parent.flag, + suspend_flag); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(temp); + return ret; + } /* has waiting time, start thread timer */ if (time > 0) @@ -807,8 +844,25 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time) return RT_EOK; } + +rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time) +{ + return _rt_mutex_take(mutex, time, RT_UNINTERRUPTIBLE); +} RTM_EXPORT(rt_mutex_take); +rt_err_t rt_mutex_take_interruptible(rt_mutex_t mutex, rt_int32_t time) +{ + return _rt_mutex_take(mutex, time, RT_INTERRUPTIBLE); +} +RTM_EXPORT(rt_mutex_take_interruptible); + +rt_err_t rt_mutex_take_killable(rt_mutex_t mutex, rt_int32_t time) +{ + return _rt_mutex_take(mutex, time, RT_KILLABLE); +} +RTM_EXPORT(rt_mutex_take_killable); + /** * This function will release a mutex, if there are threads suspended on mutex, * it will be waked up. @@ -1178,15 +1232,17 @@ RTM_EXPORT(rt_event_send); * * @return the error code */ -rt_err_t rt_event_recv(rt_event_t event, +static rt_err_t _rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t option, rt_int32_t timeout, - rt_uint32_t *recved) + rt_uint32_t *recved, + int suspend_flag) { struct rt_thread *thread; register rt_ubase_t level; register rt_base_t status; + rt_err_t ret; RT_DEBUG_IN_THREAD_CONTEXT; @@ -1257,9 +1313,15 @@ 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), + ret = rt_ipc_list_suspend(&(event->parent.suspend_thread), thread, - event->parent.parent.flag); + event->parent.parent.flag, + suspend_flag); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(level); + return ret; + } /* if there is a waiting timeout, active thread timer */ if (timeout > 0) @@ -1298,8 +1360,36 @@ rt_err_t rt_event_recv(rt_event_t event, return thread->error; } + +rt_err_t rt_event_recv(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, + rt_uint32_t *recved) +{ + return _rt_event_recv(event, set, option, timeout, recved, RT_UNINTERRUPTIBLE); +} RTM_EXPORT(rt_event_recv); +rt_err_t rt_event_recv_interruptible(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, + rt_uint32_t *recved) +{ + return _rt_event_recv(event, set, option, timeout, recved, RT_INTERRUPTIBLE); +} +RTM_EXPORT(rt_event_recv_interruptible); + +rt_err_t rt_event_recv_killable(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, + rt_uint32_t *recved) +{ + return _rt_event_recv(event, set, option, timeout, recved, RT_KILLABLE); +} +RTM_EXPORT(rt_event_recv_killable); /** * This function can get or set some extra attributions of an event object. * @@ -1502,13 +1592,15 @@ RTM_EXPORT(rt_mb_delete); * * @return the error code */ -rt_err_t rt_mb_send_wait(rt_mailbox_t mb, +static rt_err_t _rt_mb_send_wait(rt_mailbox_t mb, rt_ubase_t value, - rt_int32_t timeout) + rt_int32_t timeout, + int suspend_flag) { struct rt_thread *thread; register rt_ubase_t temp; rt_uint32_t tick_delta; + rt_err_t ret; /* parameter check */ RT_ASSERT(mb != RT_NULL); @@ -1549,9 +1641,16 @@ 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), + ret = rt_ipc_list_suspend(&(mb->suspend_sender_thread), thread, - mb->parent.parent.flag); + mb->parent.parent.flag, + suspend_flag); + + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(temp); + return ret; + } /* has waiting time, start thread timer */ if (timeout > 0) @@ -1631,8 +1730,30 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb, return RT_EOK; } + +rt_err_t rt_mb_send_wait(rt_mailbox_t mb, + rt_ubase_t value, + rt_int32_t timeout) +{ + return _rt_mb_send_wait(mb, value, timeout, RT_UNINTERRUPTIBLE); +} RTM_EXPORT(rt_mb_send_wait); +rt_err_t rt_mb_send_wait_interruptible(rt_mailbox_t mb, + rt_ubase_t value, + rt_int32_t timeout) +{ + return _rt_mb_send_wait(mb, value, timeout, RT_INTERRUPTIBLE); +} +RTM_EXPORT(rt_mb_send_wait_interruptible); + +rt_err_t rt_mb_send_wait_killable(rt_mailbox_t mb, + rt_ubase_t value, + rt_int32_t timeout) +{ + return _rt_mb_send_wait(mb, value, timeout, RT_KILLABLE); +} +RTM_EXPORT(rt_mb_send_wait_killable); /** * This function will send a mail to mailbox object, if there are threads * suspended on mailbox object, it will be waked up. This function will return @@ -1649,6 +1770,18 @@ rt_err_t rt_mb_send(rt_mailbox_t mb, rt_ubase_t value) } RTM_EXPORT(rt_mb_send); +rt_err_t rt_mb_send_interruptible(rt_mailbox_t mb, rt_ubase_t value) +{ + return rt_mb_send_wait_interruptible(mb, value, 0); +} +RTM_EXPORT(rt_mb_send_interruptible); + +rt_err_t rt_mb_send_killable(rt_mailbox_t mb, rt_ubase_t value) +{ + return rt_mb_send_wait_killable(mb, value, 0); +} +RTM_EXPORT(rt_mb_send_killable); + /** * This function will receive a mail from mailbox object, if there is no mail * in mailbox object, the thread shall wait for a specified time. @@ -1659,11 +1792,12 @@ RTM_EXPORT(rt_mb_send); * * @return the error code */ -rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout) +static rt_err_t _rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout, int suspend_flag) { struct rt_thread *thread; register rt_ubase_t temp; rt_uint32_t tick_delta; + rt_err_t ret; /* parameter check */ RT_ASSERT(mb != RT_NULL); @@ -1706,9 +1840,15 @@ 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), + ret = rt_ipc_list_suspend(&(mb->parent.suspend_thread), thread, - mb->parent.parent.flag); + mb->parent.parent.flag, + suspend_flag); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(temp); + return ret; + } /* has waiting time, start thread timer */ if (timeout > 0) @@ -1784,8 +1924,25 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout) return RT_EOK; } + +rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout) +{ + return _rt_mb_recv(mb, value, timeout, RT_UNINTERRUPTIBLE); +} RTM_EXPORT(rt_mb_recv); +rt_err_t rt_mb_recv_interruptibale(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout) +{ + return _rt_mb_recv(mb, value, timeout, RT_INTERRUPTIBLE); +} +RTM_EXPORT(rt_mb_recv_interruptibale); + +rt_err_t rt_mb_recv_killable(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout) +{ + return _rt_mb_recv(mb, value, timeout, RT_KILLABLE); +} +RTM_EXPORT(rt_mb_recv_killable); + /** * This function can get or set some extra attributions of a mailbox object. * @@ -2044,15 +2201,17 @@ RTM_EXPORT(rt_mq_delete); * * @return the error code */ -rt_err_t rt_mq_send_wait(rt_mq_t mq, +static rt_err_t _rt_mq_send_wait(rt_mq_t mq, const void *buffer, rt_size_t size, - rt_int32_t timeout) + rt_int32_t timeout, + int suspend_flag) { register rt_ubase_t temp; struct rt_mq_message *msg; rt_uint32_t tick_delta; struct rt_thread *thread; + rt_err_t ret; /* parameter check */ RT_ASSERT(mq != RT_NULL); @@ -2102,9 +2261,15 @@ 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), + ret = rt_ipc_list_suspend(&(mq->suspend_sender_thread), thread, - mq->parent.parent.flag); + mq->parent.parent.flag, + suspend_flag); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(temp); + return ret; + } /* has waiting time, start thread timer */ if (timeout > 0) @@ -2203,8 +2368,33 @@ rt_err_t rt_mq_send_wait(rt_mq_t mq, return RT_EOK; } + +rt_err_t rt_mq_send_wait(rt_mq_t mq, + const void *buffer, + rt_size_t size, + rt_int32_t timeout) +{ + return _rt_mq_send_wait(mq, buffer, size, timeout, RT_UNINTERRUPTIBLE); +} RTM_EXPORT(rt_mq_send_wait) +rt_err_t rt_mq_send_wait_interruptible(rt_mq_t mq, + const void *buffer, + rt_size_t size, + rt_int32_t timeout) +{ + return _rt_mq_send_wait(mq, buffer, size, timeout, RT_INTERRUPTIBLE); +} +RTM_EXPORT(rt_mq_send_wait_interruptible) + +rt_err_t rt_mq_send_wait_killable(rt_mq_t mq, + const void *buffer, + rt_size_t size, + rt_int32_t timeout) +{ + return _rt_mq_send_wait(mq, buffer, size, timeout, RT_KILLABLE); +} +RTM_EXPORT(rt_mq_send_wait_killable) /** * This function will send a message to message queue object, if there are * threads suspended on message queue object, it will be waked up. @@ -2221,6 +2411,17 @@ rt_err_t rt_mq_send(rt_mq_t mq, const void *buffer, rt_size_t size) } RTM_EXPORT(rt_mq_send); +rt_err_t rt_mq_send_interrupt(rt_mq_t mq, const void *buffer, rt_size_t size) +{ + return rt_mq_send_wait_interruptible(mq, buffer, size, 0); +} +RTM_EXPORT(rt_mq_send_interrupt); + +rt_err_t rt_mq_send_killable(rt_mq_t mq, const void *buffer, rt_size_t size) +{ + return rt_mq_send_wait_killable(mq, buffer, size, 0); +} +RTM_EXPORT(rt_mq_send_killable); /** * This function will send an urgent message to message queue object, which * means the message will be inserted to the head of message queue. If there @@ -2325,15 +2526,17 @@ RTM_EXPORT(rt_mq_urgent); * * @return the error code */ -rt_err_t rt_mq_recv(rt_mq_t mq, +static rt_err_t _rt_mq_recv(rt_mq_t mq, void *buffer, rt_size_t size, - rt_int32_t timeout) + rt_int32_t timeout, + int suspend_flag) { struct rt_thread *thread; register rt_ubase_t temp; struct rt_mq_message *msg; rt_uint32_t tick_delta; + rt_err_t ret; /* parameter check */ RT_ASSERT(mq != RT_NULL); @@ -2378,9 +2581,15 @@ rt_err_t rt_mq_recv(rt_mq_t mq, } /* suspend current thread */ - rt_ipc_list_suspend(&(mq->parent.suspend_thread), + ret = rt_ipc_list_suspend(&(mq->parent.suspend_thread), thread, - mq->parent.parent.flag); + mq->parent.parent.flag, + suspend_flag); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(temp); + return ret; + } /* has waiting time, start thread timer */ if (timeout > 0) @@ -2470,8 +2679,33 @@ rt_err_t rt_mq_recv(rt_mq_t mq, return RT_EOK; } + +rt_err_t rt_mq_recv(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout) +{ + return _rt_mq_recv(mq, buffer, size, timeout, RT_UNINTERRUPTIBLE); +} RTM_EXPORT(rt_mq_recv); +rt_err_t rt_mq_recv_interruptible(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout) +{ + return _rt_mq_recv(mq, buffer, size, timeout, RT_INTERRUPTIBLE); +} +RTM_EXPORT(rt_mq_recv_interruptible); + +rt_err_t rt_mq_recv_killable(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout) +{ + return _rt_mq_recv(mq, buffer, size, timeout, RT_KILLABLE); +} +RTM_EXPORT(rt_mq_recv_killable); /** * This function can get or set some extra attributions of a message queue * object. diff --git a/src/thread.c b/src/thread.c index 65b67c3c1e..b6198a3422 100644 --- a/src/thread.c +++ b/src/thread.c @@ -767,6 +767,9 @@ rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg) } RTM_EXPORT(rt_thread_control); +#ifdef RT_USING_LWP +int lwp_suspend_sigcheck(rt_thread_t thread, int suspend_flag); +#endif /** * This function will suspend the specified thread. * @@ -804,6 +807,14 @@ rt_err_t rt_thread_suspend(rt_thread_t thread, int suspend_flag) /* not suspend running status thread on other core */ RT_ASSERT(thread == rt_thread_self()); } +#ifdef RT_USING_LWP + if (lwp_suspend_sigcheck(thread, suspend_flag) == 0) + { + /* not to suspend */ + rt_hw_interrupt_enable(temp); + return -RT_EINTR; + } +#endif /* change thread stat */ rt_schedule_remove_thread(thread); -- Gitee From 1e13950a6cae8061aa9bb271b13244f72ae92a60 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Mon, 14 Dec 2020 08:40:33 +0800 Subject: [PATCH 06/16] rt_thread_sleep change to RT_INTERRUPTIBLE mode channel change to RT_INTERRUPTIBLE mode poll change to RT_INTERRUPTIBLE mode userspace semaphore mutex change to RT_INTERRUPTIBLE mode --- components/dfs/src/poll.c | 24 +++++++++-------- components/lwp/lwp_ipc.c | 50 +++++++++++++++++++++++++----------- components/lwp/lwp_syscall.c | 4 +-- src/thread.c | 2 +- 4 files changed, 51 insertions(+), 29 deletions(-) diff --git a/components/dfs/src/poll.c b/components/dfs/src/poll.c index 7a1f22c5cd..536be0c04d 100644 --- a/components/dfs/src/poll.c +++ b/components/dfs/src/poll.c @@ -95,20 +95,22 @@ static int poll_wait_timeout(struct rt_poll_table *pt, int msec) if (timeout != 0 && !pt->triggered) { - rt_thread_suspend(thread, RT_UNINTERRUPTIBLE); - if (timeout > 0) + if (rt_thread_suspend(thread, RT_INTERRUPTIBLE) == RT_EOK) { - rt_timer_control(&(thread->thread_timer), - RT_TIMER_CTRL_SET_TIME, - &timeout); - rt_timer_start(&(thread->thread_timer)); - } + if (timeout > 0) + { + rt_timer_control(&(thread->thread_timer), + RT_TIMER_CTRL_SET_TIME, + &timeout); + rt_timer_start(&(thread->thread_timer)); + } - rt_hw_interrupt_enable(level); + rt_hw_interrupt_enable(level); - rt_schedule(); + rt_schedule(); - level = rt_hw_interrupt_disable(); + level = rt_hw_interrupt_disable(); + } } ret = !pt->triggered; @@ -140,7 +142,7 @@ static int do_pollfd(struct pollfd *pollfd, rt_pollreq_t *req) /* dealwith the device return error -1*/ if (mask < 0) - { + { fd_put(f); pollfd->revents = 0; return mask; diff --git a/components/lwp/lwp_ipc.c b/components/lwp/lwp_ipc.c index 0edfd02f99..4eb8660aee 100644 --- a/components/lwp/lwp_ipc.c +++ b/components/lwp/lwp_ipc.c @@ -138,11 +138,14 @@ 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_thread_suspend(thread, RT_UNINTERRUPTIBLE); + rt_err_t ret = rt_thread_suspend(thread, RT_INTERRUPTIBLE); - rt_list_insert_before(list, &(thread->tlist)); /* list end */ + if (ret == RT_EOK) + { + rt_list_insert_before(list, &(thread->tlist)); /* list end */ + } - return RT_EOK; + return ret; } @@ -407,15 +410,16 @@ static rt_err_t _rt_raw_channel_send_recv_timeout(rt_channel_t ch, rt_channel_ms { case RT_IPC_STAT_IDLE: case RT_IPC_STAT_ACTIVE: - /* - * If there is no thread waiting for messages, chain the message - * into the list. - */ - rt_list_insert_before(&ch->wait_msg, &msg->mlist); if (need_reply) { + ret = rt_channel_list_suspend(&ch->wait_thread, thread_send); + if (ret != RT_EOK) + { + _ipc_msg_free(msg); + rt_hw_interrupt_enable(temp); + return ret; + } rt_thread_wakeup_set(thread_send, wakeup_sender_wait_recv, (void*)ch); - rt_channel_list_suspend(&ch->wait_thread, thread_send); if (time > 0) { rt_timer_control(&(thread_send->thread_timer), @@ -431,6 +435,11 @@ static rt_err_t _rt_raw_channel_send_recv_timeout(rt_channel_t ch, rt_channel_ms rt_timer_start(&(thread_send->thread_timer)); } } + /* + * If there is no thread waiting for messages, chain the message + * into the list. + */ + rt_list_insert_before(&ch->wait_msg, &msg->mlist); break; case RT_IPC_STAT_WAIT: /* @@ -440,16 +449,18 @@ static rt_err_t _rt_raw_channel_send_recv_timeout(rt_channel_t ch, rt_channel_ms */ RT_ASSERT(ch->parent.suspend_thread.next != &ch->parent.suspend_thread); - thread_recv = rt_list_entry(ch->parent.suspend_thread.next, struct rt_thread, tlist); - thread_recv->msg_ret = msg; /* to the first suspended receiver */ - thread_recv->error = RT_EOK; - rt_channel_list_resume(&ch->parent.suspend_thread); if (need_reply) { + ret = rt_channel_list_suspend(&ch->wait_thread, thread_send); + if (ret != RT_EOK) + { + _ipc_msg_free(msg); + rt_hw_interrupt_enable(temp); + return ret; + } ch->reply = thread_send; /* record the current waiting sender */ ch->stat = RT_IPC_STAT_ACTIVE; rt_thread_wakeup_set(thread_send, wakeup_sender_wait_reply, (void*)ch); - rt_channel_list_suspend(&ch->wait_thread, thread_send); if (time > 0) { rt_timer_control(&(thread_send->thread_timer), @@ -469,6 +480,10 @@ static rt_err_t _rt_raw_channel_send_recv_timeout(rt_channel_t ch, rt_channel_ms { ch->stat = RT_IPC_STAT_IDLE; } + thread_recv = rt_list_entry(ch->parent.suspend_thread.next, struct rt_thread, tlist); + thread_recv->msg_ret = msg; /* to the first suspended receiver */ + thread_recv->error = RT_EOK; + rt_channel_list_resume(&ch->parent.suspend_thread); break; default: break; @@ -683,8 +698,13 @@ static rt_err_t _rt_raw_channel_recv_timeout(rt_channel_t ch, rt_channel_msg_t d /* no valid message, we must wait */ thread = rt_thread_self(); + ret = rt_channel_list_suspend(&ch->parent.suspend_thread, thread); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(temp); + return ret; + } rt_thread_wakeup_set(thread, wakeup_receiver, (void*)ch); - rt_channel_list_suspend(&ch->parent.suspend_thread, thread); ch->stat = RT_IPC_STAT_WAIT;/* no valid suspended senders */ thread->error = RT_EOK; if (time > 0) diff --git a/components/lwp/lwp_syscall.c b/components/lwp/lwp_syscall.c index 3513aafacb..4f00d0b94c 100644 --- a/components/lwp/lwp_syscall.c +++ b/components/lwp/lwp_syscall.c @@ -667,7 +667,7 @@ rt_err_t sys_sem_delete(rt_sem_t sem) rt_err_t sys_sem_take(rt_sem_t sem, rt_int32_t time) { - return rt_sem_take(sem, time); + return rt_sem_take_interruptible(sem, time); } rt_err_t sys_sem_release(rt_sem_t sem) @@ -687,7 +687,7 @@ rt_err_t sys_mutex_delete(rt_mutex_t mutex) rt_err_t sys_mutex_take(rt_mutex_t mutex, rt_int32_t time) { - return rt_mutex_take(mutex, time); + return rt_mutex_take_interruptible(mutex, time); } rt_err_t sys_mutex_release(rt_mutex_t mutex) diff --git a/src/thread.c b/src/thread.c index b6198a3422..1d1fee2341 100644 --- a/src/thread.c +++ b/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_UNINTERRUPTIBLE); + rt_thread_suspend(thread, RT_INTERRUPTIBLE); /* reset the timeout of thread timer and start it */ rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick); -- Gitee From 6433f1a49e9a9466630858d492a51fb0377d9cc7 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Wed, 16 Dec 2020 09:07:23 +0800 Subject: [PATCH 07/16] =?UTF-8?q?waitqueue=E5=A2=9E=E5=8A=A0=E4=B8=89?= =?UTF-8?q?=E7=8A=B6=E6=80=81suspend=20lwp=5Fconsole=E5=92=8Cserial?= =?UTF-8?q?=E9=A9=B1=E5=8A=A8=E6=94=B9=E4=B8=BA=E6=94=AF=E6=8C=81=E5=8F=AF?= =?UTF-8?q?=E8=A2=ABsignal=E4=B8=AD=E6=AD=A2=20=E4=BF=AE=E6=94=B9serial?= =?UTF-8?q?=E8=AF=BB=E5=A4=B1=E8=B4=A5=E6=97=B6=E7=9A=84=E8=BF=94=E5=9B=9E?= =?UTF-8?q?=E5=80=BC=E4=B8=BA0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/drivers/include/ipc/waitqueue.h | 2 ++ components/drivers/serial/serial.c | 12 ++++++++-- components/drivers/src/waitqueue.c | 26 ++++++++++++++++++++-- components/lwp/lwp_console.c | 11 ++++++++- 4 files changed, 46 insertions(+), 5 deletions(-) diff --git a/components/drivers/include/ipc/waitqueue.h b/components/drivers/include/ipc/waitqueue.h index e26ec1e896..a64b973a9e 100644 --- a/components/drivers/include/ipc/waitqueue.h +++ b/components/drivers/include/ipc/waitqueue.h @@ -43,6 +43,8 @@ rt_inline void rt_wqueue_init(rt_wqueue_t *queue) void rt_wqueue_add(rt_wqueue_t *queue, struct rt_wqueue_node *node); void rt_wqueue_remove(struct rt_wqueue_node *node); int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int timeout); +int rt_wqueue_wait_killable(rt_wqueue_t *queue, int condition, int timeout); +int rt_wqueue_wait_interruptible(rt_wqueue_t *queue, int condition, int timeout); void rt_wqueue_wakeup(rt_wqueue_t *queue, void *key); #define DEFINE_WAIT_FUNC(name, function) \ diff --git a/components/drivers/serial/serial.c b/components/drivers/serial/serial.c index dd234f074a..dc9c7ac2cf 100644 --- a/components/drivers/serial/serial.c +++ b/components/drivers/serial/serial.c @@ -127,6 +127,7 @@ static int serial_fops_read(struct dfs_fd *fd, void *buf, size_t count) { int size = 0; rt_device_t device; + int wait_ret; device = (rt_device_t)fd->data; @@ -137,14 +138,21 @@ static int serial_fops_read(struct dfs_fd *fd, void *buf, size_t count) { if (fd->flags & O_NONBLOCK) { - size = -EAGAIN; break; } - rt_wqueue_wait(&(device->wait_queue), 0, RT_WAITING_FOREVER); + wait_ret = rt_wqueue_wait_interruptible(&(device->wait_queue), 0, RT_WAITING_FOREVER); + if (wait_ret != RT_EOK) + { + break; + } } }while (size <= 0); + if (size < 0) + { + size = 0; + } return size; } diff --git a/components/drivers/src/waitqueue.c b/components/drivers/src/waitqueue.c index ae82f481b3..ab816c7ed1 100644 --- a/components/drivers/src/waitqueue.c +++ b/components/drivers/src/waitqueue.c @@ -74,13 +74,14 @@ void rt_wqueue_wakeup(rt_wqueue_t *queue, void *key) rt_schedule(); } -int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec) +static int _rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec, int suspend_flag) { int tick; rt_thread_t tid = rt_thread_self(); rt_timer_t tmr = &(tid->thread_timer); struct rt_wqueue_node __wait; rt_base_t level; + rt_err_t ret; /* current context checking */ RT_DEBUG_NOT_IN_INTERRUPT; @@ -102,8 +103,14 @@ int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec) goto __exit_wakeup; } + ret = rt_thread_suspend(tid, RT_INTERRUPTIBLE); + if (ret != RT_EOK) + { + rt_hw_interrupt_enable(level); + /* suspend failed */ + return -RT_EINTR; + } rt_wqueue_add(queue, &__wait); - rt_thread_suspend(tid, RT_UNINTERRUPTIBLE); /* start timer */ if (tick != RT_WAITING_FOREVER) @@ -128,3 +135,18 @@ __exit_wakeup: return 0; } + +int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec) +{ + return _rt_wqueue_wait(queue, condition, msec, RT_UNINTERRUPTIBLE); +} + +int rt_wqueue_wait_killable(rt_wqueue_t *queue, int condition, int msec) +{ + return _rt_wqueue_wait(queue, condition, msec, RT_KILLABLE); +} + +int rt_wqueue_wait_interruptible(rt_wqueue_t *queue, int condition, int msec) +{ + return _rt_wqueue_wait(queue, condition, msec, RT_INTERRUPTIBLE); +} diff --git a/components/lwp/lwp_console.c b/components/lwp/lwp_console.c index ce78937822..a11ed26d2a 100644 --- a/components/lwp/lwp_console.c +++ b/components/lwp/lwp_console.c @@ -235,6 +235,7 @@ static int console_fops_read(struct dfs_fd *fd, void *buf, size_t count) struct rt_console_device *console; struct rt_lwp *lwp; struct rt_wqueue *wq; + int wait_ret; console = (struct rt_console_device *)fd->data; RT_ASSERT(console != RT_NULL); @@ -256,9 +257,17 @@ static int console_fops_read(struct dfs_fd *fd, void *buf, size_t count) { break; } - rt_wqueue_wait(wq, 0, RT_WAITING_FOREVER); + wait_ret = rt_wqueue_wait_interruptible(wq, 0, RT_WAITING_FOREVER); + if (wait_ret != 0) + { + break; + } } rt_hw_interrupt_enable(level); + if (size < 0) + { + size = 0; + } return size; } -- Gitee From 8ca1a6aa72e09406d17c10ad618edee63eb7d7be Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 18 Dec 2020 10:55:46 +0800 Subject: [PATCH 08/16] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=BD=91=E7=BB=9C?= =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E7=B3=BB=E7=BB=9F=E8=B0=83=E7=94=A8=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E8=AE=BE=E7=BD=AE=E6=96=B9=E5=90=91=E9=97=AE=E9=A2=98?= =?UTF-8?q?=20=E7=BD=91=E7=BB=9C=E6=8E=A5=E5=8F=A3=E7=B3=BB=E7=BB=9F?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A2=9E=E5=8A=A0=E7=94=A8=E6=88=B7=E6=80=81?= =?UTF-8?q?=E5=9C=B0=E5=9D=80=E6=9C=89=E6=95=88=E6=80=A7=E6=A3=80=E6=B5=8B?= =?UTF-8?q?=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/lwp/lwp_syscall.c | 122 +++++++++++++++++++++++++++++++---- 1 file changed, 111 insertions(+), 11 deletions(-) diff --git a/components/lwp/lwp_syscall.c b/components/lwp/lwp_syscall.c index 4f00d0b94c..0d2e3f861c 100644 --- a/components/lwp/lwp_syscall.c +++ b/components/lwp/lwp_syscall.c @@ -1069,16 +1069,54 @@ rt_size_t sys_device_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt /* network interfaces */ int sys_accept(int socket, struct musl_sockaddr *addr, socklen_t *addrlen) { - struct sockaddr sa; - sockaddr_tolwip(addr, &sa); + int ret; + struct sockaddr ksa; + struct musl_sockaddr kmusladdr; + socklen_t uaddrlen; + socklen_t kaddrlen; + + if (!lwp_data_access_ok(&lwp_self()->mmu_info, addrlen, sizeof (socklen_t *))) + { + return -1; + } + lwp_data_get(&lwp_self()->mmu_info, &uaddrlen, addrlen, sizeof (socklen_t *)); + if (!uaddrlen) + { + return -1; + } + + if (!lwp_data_access_ok(&lwp_self()->mmu_info, addr, uaddrlen)) + { + return -1; + } - return accept(socket, &sa, addrlen); + kaddrlen = sizeof(struct sockaddr); + ret = accept(socket, &ksa, &kaddrlen); + if (ret >= 0) + { + sockaddr_tomusl(&ksa, &kmusladdr); + if (uaddrlen > sizeof(struct musl_sockaddr)) + { + uaddrlen = sizeof(struct musl_sockaddr); + } + lwp_data_put(&lwp_self()->mmu_info, addr, &kmusladdr, uaddrlen); + lwp_data_put(&lwp_self()->mmu_info, addrlen, &uaddrlen, sizeof (socklen_t *)); + } + return ret; } int sys_bind(int socket, const struct musl_sockaddr *name, socklen_t namelen) { struct sockaddr sa; - sockaddr_tolwip(name, &sa); + struct musl_sockaddr kname; + + if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)name, namelen)) + { + return -1; + } + lwp_data_get(&lwp_self()->mmu_info, &kname, (void*)name, namelen); + + sockaddr_tolwip(&kname, &sa); return bind(socket, &sa, namelen); } @@ -1092,10 +1130,38 @@ int sys_getpeername (int socket, struct musl_sockaddr *name, socklen_t *namelen) { int ret; struct sockaddr sa; - sockaddr_tolwip(name, &sa); + struct musl_sockaddr kname; + socklen_t unamelen; + socklen_t knamelen; - ret = getpeername (socket, &sa, namelen); - if (name) sockaddr_tomusl(&sa, name); + if (!lwp_data_access_ok(&lwp_self()->mmu_info, namelen, sizeof (socklen_t *))) + { + return -1; + } + lwp_data_get(&lwp_self()->mmu_info, &unamelen, namelen, sizeof (socklen_t *)); + if (!unamelen) + { + return -1; + } + + if (!lwp_data_access_ok(&lwp_self()->mmu_info, name, unamelen)) + { + return -1; + } + + knamelen = sizeof(struct sockaddr); + ret = getpeername (socket, &sa, &knamelen); + + if (ret == 0) + { + sockaddr_tomusl(&sa, &kname); + if (unamelen > sizeof(struct musl_sockaddr)) + { + unamelen = sizeof(struct musl_sockaddr); + } + lwp_data_put(&lwp_self()->mmu_info, name, &kname, unamelen); + lwp_data_put(&lwp_self()->mmu_info, namelen, &unamelen, sizeof (socklen_t *)); + } return ret; } @@ -1104,11 +1170,37 @@ int sys_getsockname (int socket, struct musl_sockaddr *name, socklen_t *namelen) { int ret; struct sockaddr sa; - sockaddr_tolwip(name, &sa); + struct musl_sockaddr kname; + socklen_t unamelen; + socklen_t knamelen; + + if (!lwp_data_access_ok(&lwp_self()->mmu_info, namelen, sizeof (socklen_t *))) + { + return -1; + } + lwp_data_get(&lwp_self()->mmu_info, &unamelen, namelen, sizeof (socklen_t *)); + if (!unamelen) + { + return -1; + } - ret = getsockname (socket, &sa, namelen); - if (name) sockaddr_tomusl(&sa, name); + if (!lwp_data_access_ok(&lwp_self()->mmu_info, name, unamelen)) + { + return -1; + } + knamelen = sizeof(struct sockaddr); + ret = getsockname (socket, &sa, &knamelen); + if (ret == 0) + { + sockaddr_tomusl(&sa, &kname); + if (unamelen > sizeof(struct musl_sockaddr)) + { + unamelen = sizeof(struct musl_sockaddr); + } + lwp_data_put(&lwp_self()->mmu_info, name, &kname, unamelen); + lwp_data_put(&lwp_self()->mmu_info, namelen, &unamelen, sizeof (socklen_t *)); + } return ret; } @@ -1131,7 +1223,15 @@ int sys_setsockopt (int socket, int level, int optname, const void *optval, sock int sys_connect(int socket, const struct musl_sockaddr *name, socklen_t namelen) { struct sockaddr sa; - sockaddr_tolwip(name, &sa); + struct musl_sockaddr kname; + + if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)name, namelen)) + { + return -1; + } + lwp_data_get(&lwp_self()->mmu_info, &kname, (void*)name, namelen); + + sockaddr_tolwip(&kname, &sa); return connect(socket, &sa, namelen); } -- Gitee From 50565e1fb66a8c1e8a14f62af0e49cf59ab3deaa Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 18 Dec 2020 11:19:22 +0800 Subject: [PATCH 09/16] =?UTF-8?q?lwip-2.0.2=E5=86=85=E6=A0=B8=E7=89=88?= =?UTF-8?q?=E5=8A=A0=E4=B8=8A=E5=8F=AF=E8=A2=AB=E4=BF=A1=E5=8F=B7=E4=B8=AD?= =?UTF-8?q?=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/net/lwip-2.0.2/src/arch/sys_arch.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/net/lwip-2.0.2/src/arch/sys_arch.c b/components/net/lwip-2.0.2/src/arch/sys_arch.c index 40c79011ec..827dcd154b 100644 --- a/components/net/lwip-2.0.2/src/arch/sys_arch.c +++ b/components/net/lwip-2.0.2/src/arch/sys_arch.c @@ -508,7 +508,7 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout) t = timeout / (1000/RT_TICK_PER_SECOND); } - ret = rt_mb_recv(*mbox, (rt_ubase_t *)msg, t); + ret = rt_mb_recv_interruptibale(*mbox, (rt_ubase_t *)msg, t); if(ret != RT_EOK) { return SYS_ARCH_TIMEOUT; -- Gitee From e87dfc1d320d365e5792413a13383f4e06720ba9 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 18 Dec 2020 11:46:29 +0800 Subject: [PATCH 10/16] =?UTF-8?q?SIGCHLD=E5=92=8CSIGCONT=E4=B8=94=E6=97=A0?= =?UTF-8?q?=E6=B3=A8=E5=86=8C=E5=A4=84=E7=90=86=E5=87=BD=E6=95=B0=E6=97=B6?= =?UTF-8?q?=EF=BC=8C=E9=BB=98=E8=AE=A4=E5=BF=BD=E7=95=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/lwp/lwp_signal.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/components/lwp/lwp_signal.c b/components/lwp/lwp_signal.c index 44efe9dfa9..280e85c7ff 100644 --- a/components/lwp/lwp_signal.c +++ b/components/lwp/lwp_signal.c @@ -263,6 +263,15 @@ struct rt_user_context *lwp_signal_restore(void) return ctx; } +rt_inline int _lwp_check_ignore(int sig) +{ + if (sig == SIGCHLD || sig == SIGCONT) + { + return 1; + } + return 0; +} + void sys_exit(int value); lwp_sighandler_t lwp_sighandler_get(int sig) { @@ -281,6 +290,10 @@ lwp_sighandler_t lwp_sighandler_get(int sig) func = rt_thread_self()->signal_handler[sig - 1]; if (!func) { + if (_lwp_check_ignore(sig)) + { + goto out; + } lwp = (struct rt_lwp*)thread->lwp; main_thread = rt_list_entry(lwp->t_grp.prev, struct rt_thread, sibling); if (thread == main_thread) @@ -306,10 +319,15 @@ lwp_sighandler_t lwp_sighandler_get(int sig) func = lwp->signal_handler[sig - 1]; if (!func) { + if (_lwp_check_ignore(sig)) + { + goto out; + } main_thread = rt_list_entry(lwp->t_grp.prev, struct rt_thread, sibling); lwp_thread_kill(main_thread, SIGKILL); } } +out: rt_hw_interrupt_enable(level); return func; } -- Gitee From b3b2f10d71ba5e41b61ea75e5f7d8e31c90b0519 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 18 Dec 2020 15:33:00 +0800 Subject: [PATCH 11/16] =?UTF-8?q?console=E4=BF=AE=E6=94=B9=E4=B8=BActrl-c?= =?UTF-8?q?=E6=97=B6,=E5=AF=B9=E5=BD=93=E5=89=8D=E8=BF=9B=E7=A8=8B?= =?UTF-8?q?=E5=8F=91=E9=80=81SIGINT=E4=BF=A1=E5=8F=B7(=E6=AD=A4=E4=BF=A1?= =?UTF-8?q?=E5=8F=B7=E5=8F=AF=E4=BB=A5=E5=B1=8F=E8=94=BD=E5=8F=8A=E6=88=AA?= =?UTF-8?q?=E8=8E=B7)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/lwp/lwp_console.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/components/lwp/lwp_console.c b/components/lwp/lwp_console.c index a11ed26d2a..f964d6a055 100644 --- a/components/lwp/lwp_console.c +++ b/components/lwp/lwp_console.c @@ -78,7 +78,12 @@ static void console_rx_notify(struct rt_device *dev) } else if (ch == CHAR_CTRL_C) /* ctrl-c */ { - lwp_terminate(console->foreground); + struct rt_lwp *lwp = console->foreground; + + if (lwp) + { + lwp_kill(lwp_to_pid(lwp), SIGINT); + } } else { -- Gitee From e404ab263e9b2ffdfa40ef84a630344a4a9cb4fd Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Fri, 18 Dec 2020 18:54:40 +0800 Subject: [PATCH 12/16] =?UTF-8?q?sys=5Fcall=E6=8E=A5=E5=8F=A3=E5=8A=A0?= =?UTF-8?q?=E5=BC=BA=E7=94=A8=E6=88=B7=E6=80=81=E5=9C=B0=E5=9D=80=E6=A3=80?= =?UTF-8?q?=E6=9F=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../lwp/arch/arm/cortex-a/arch_user_stack.c | 2 +- components/lwp/lwp_syscall.c | 104 +++++++++--------- components/lwp/lwp_user_mm.c | 18 ++- components/lwp/lwp_user_mm.h | 2 +- 4 files changed, 71 insertions(+), 55 deletions(-) diff --git a/components/lwp/arch/arm/cortex-a/arch_user_stack.c b/components/lwp/arch/arm/cortex-a/arch_user_stack.c index e90ed650f3..d65e5750f1 100644 --- a/components/lwp/arch/arm/cortex-a/arch_user_stack.c +++ b/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_data_access_ok(&lwp_self()->mmu_info, addr, 1)) + if (map || lwp_user_access_ok(addr, 1)) { ret = 1; } diff --git a/components/lwp/lwp_syscall.c b/components/lwp/lwp_syscall.c index 0d2e3f861c..733fb276d1 100644 --- a/components/lwp/lwp_syscall.c +++ b/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_data_access_ok(&lwp_self()->mmu_info, (void*)buf, nbyte)) + if (!lwp_user_access_ok((void*)buf, nbyte)) return 0; kmem = kmem_get(nbyte); @@ -284,7 +284,7 @@ ssize_t sys_read(int fd, void *buf, size_t nbyte) ret = read(fd, kmem, nbyte); if (ret) - lwp_data_put(&lwp_self()->mmu_info, buf, kmem, ret); + lwp_put_to_user(buf, kmem, ret); kmem_put(kmem); return ret; @@ -303,14 +303,14 @@ ssize_t sys_write(int fd, const void *buf, size_t nbyte) if (!nbyte) return 0; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)buf, nbyte)) + if (!lwp_user_access_ok((void*)buf, nbyte)) return 0; kmem = kmem_get(nbyte); if (!kmem) return 0; - lwp_data_get(&lwp_self()->mmu_info, kmem, (void *)buf, nbyte); + lwp_get_from_user(kmem, (void *)buf, nbyte); ret = write(fd, kmem, nbyte); kmem_put(kmem); @@ -334,7 +334,7 @@ int sys_open(const char *name, int flag, ...) rt_size_t len; char *kname; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)name, 1)) + if (!lwp_user_access_ok((void*)name, 1)) return -1; len = rt_strlen(name); @@ -345,7 +345,7 @@ int sys_open(const char *name, int flag, ...) if (!kname) return -1; - lwp_data_get(&lwp_self()->mmu_info, kname, (void *)name, len + 1); + lwp_get_from_user(kname, (void *)name, len + 1); ret = open(kname, flag, 0); kmem_put(kname); @@ -378,7 +378,7 @@ int sys_fstat(int file, struct stat *buf) struct stat statbuff; ret = fstat(file, &statbuff); - lwp_data_put(&lwp_self()->mmu_info, buf, &statbuff, sizeof statbuff); + lwp_put_to_user(buf, &statbuff, sizeof statbuff); return ret; #else return fstat(file, buf); @@ -391,16 +391,16 @@ int sys_poll(struct pollfd *fds, nfds_t nfds, int timeout) int ret; struct pollfd *kfds; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)fds, nfds * sizeof *fds)) + if (!lwp_user_access_ok((void*)fds, nfds * sizeof *fds)) return -1; kfds = (struct pollfd *)kmem_get(nfds * sizeof *kfds); if (!kfds) return -1; - lwp_data_get(&lwp_self()->mmu_info, kfds, fds, nfds * sizeof *kfds); + lwp_get_from_user(kfds, fds, nfds * sizeof *kfds); ret = poll(kfds, nfds, timeout); - lwp_data_put(&lwp_self()->mmu_info, fds, kfds, nfds * sizeof *kfds); + lwp_put_to_user(fds, kfds, nfds * sizeof *kfds); kmem_put(kfds); return ret; @@ -417,7 +417,7 @@ int sys_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, s if (readfds) { - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)readfds, sizeof *readfds)) + if (!lwp_user_access_ok((void*)readfds, sizeof *readfds)) { return -1; } @@ -426,11 +426,11 @@ int sys_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, s { goto quit; } - lwp_data_get(&lwp_self()->mmu_info, kreadfds, readfds, sizeof *kreadfds); + lwp_get_from_user(kreadfds, readfds, sizeof *kreadfds); } if (writefds) { - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)writefds, sizeof *writefds)) + if (!lwp_user_access_ok((void*)writefds, sizeof *writefds)) { return -1; } @@ -439,11 +439,11 @@ int sys_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, s { goto quit; } - lwp_data_get(&lwp_self()->mmu_info, kwritefds, writefds, sizeof *kwritefds); + lwp_get_from_user(kwritefds, writefds, sizeof *kwritefds); } if (exceptfds) { - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)exceptfds, sizeof *exceptfds)) + if (!lwp_user_access_ok((void*)exceptfds, sizeof *exceptfds)) { return -1; } @@ -452,21 +452,21 @@ int sys_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, s { goto quit; } - lwp_data_get(&lwp_self()->mmu_info, kexceptfds, exceptfds, sizeof *kexceptfds); + lwp_get_from_user(kexceptfds, exceptfds, sizeof *kexceptfds); } ret = select(nfds, kreadfds, kwritefds, kexceptfds, timeout); if (kreadfds) { - lwp_data_put(&lwp_self()->mmu_info, readfds, kreadfds, sizeof *kreadfds); + lwp_put_to_user(readfds, kreadfds, sizeof *kreadfds); } if (kwritefds) { - lwp_data_put(&lwp_self()->mmu_info, writefds, kwritefds, sizeof *kwritefds); + lwp_put_to_user(writefds, kwritefds, sizeof *kwritefds); } if (kexceptfds) { - lwp_data_put(&lwp_self()->mmu_info, exceptfds, kexceptfds, sizeof *kexceptfds); + lwp_put_to_user(exceptfds, kexceptfds, sizeof *kexceptfds); } quit: if (kreadfds) @@ -494,7 +494,7 @@ int sys_unlink(const char *pathname) rt_size_t len; char *kname; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)pathname, 1)) + if (!lwp_user_access_ok((void*)pathname, 1)) return -1; len = rt_strlen(pathname); @@ -505,7 +505,7 @@ int sys_unlink(const char *pathname) if (!kname) return -1; - lwp_data_get(&lwp_self()->mmu_info, kname, (void *)pathname, len + 1); + lwp_get_from_user(kname, (void *)pathname, len + 1); ret = unlink(kname); kmem_put(kname); @@ -525,17 +525,17 @@ int sys_nanosleep(const struct timespec *rqtp, struct timespec *rmtp) dbg_log(DBG_LOG, "sys_nanosleep\n"); - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)rqtp, sizeof *rqtp)) + if (!lwp_user_access_ok((void*)rqtp, sizeof *rqtp)) return -1; - lwp_data_get(&lwp_self()->mmu_info, &rqtp_k, (void *)rqtp, sizeof rqtp_k); + lwp_get_from_user(&rqtp_k, (void *)rqtp, sizeof rqtp_k); tick = rqtp_k.tv_sec * RT_TICK_PER_SECOND + ((uint64_t)rqtp_k.tv_nsec * RT_TICK_PER_SECOND)/ 1000000000; rt_thread_delay(tick); if (rmtp) { - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)rmtp, sizeof *rmtp)) + if (!lwp_user_access_ok((void*)rmtp, sizeof *rmtp)) return -1; tick = rt_tick_get() - tick; @@ -543,7 +543,7 @@ int sys_nanosleep(const struct timespec *rqtp, struct timespec *rmtp) rmtp_k.tv_sec = tick/RT_TICK_PER_SECOND; rmtp_k.tv_nsec = (tick%RT_TICK_PER_SECOND) * (1000000000/RT_TICK_PER_SECOND); - lwp_data_put(&lwp_self()->mmu_info, rmtp, (void *)&rmtp_k, sizeof rmtp_k); + lwp_put_to_user(rmtp, (void *)&rmtp_k, sizeof rmtp_k); } #else dbg_log(DBG_LOG, "sys_nanosleep\n"); @@ -571,13 +571,13 @@ int sys_gettimeofday(struct timeval *tp, struct timezone *tzp) #ifdef RT_USING_USERSPACE if (tp) { - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)tp, sizeof *tp)) + if (!lwp_user_access_ok((void*)tp, sizeof *tp)) return -1; t_k.tv_sec = rt_tick_get() / RT_TICK_PER_SECOND; t_k.tv_usec = (rt_tick_get() % RT_TICK_PER_SECOND) * (1000000 / RT_TICK_PER_SECOND); - lwp_data_put(&lwp_self()->mmu_info, tp, (void *)&t_k, sizeof t_k); + lwp_put_to_user(tp, (void *)&t_k, sizeof t_k); } #else if (tp) @@ -1075,17 +1075,17 @@ int sys_accept(int socket, struct musl_sockaddr *addr, socklen_t *addrlen) socklen_t uaddrlen; socklen_t kaddrlen; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, addrlen, sizeof (socklen_t *))) + if (!lwp_user_access_ok(addrlen, sizeof (socklen_t *))) { return -1; } - lwp_data_get(&lwp_self()->mmu_info, &uaddrlen, addrlen, sizeof (socklen_t *)); + lwp_get_from_user(&uaddrlen, addrlen, sizeof (socklen_t *)); if (!uaddrlen) { return -1; } - if (!lwp_data_access_ok(&lwp_self()->mmu_info, addr, uaddrlen)) + if (!lwp_user_access_ok(addr, uaddrlen)) { return -1; } @@ -1099,8 +1099,8 @@ int sys_accept(int socket, struct musl_sockaddr *addr, socklen_t *addrlen) { uaddrlen = sizeof(struct musl_sockaddr); } - lwp_data_put(&lwp_self()->mmu_info, addr, &kmusladdr, uaddrlen); - lwp_data_put(&lwp_self()->mmu_info, addrlen, &uaddrlen, sizeof (socklen_t *)); + lwp_put_to_user(addr, &kmusladdr, uaddrlen); + lwp_put_to_user(addrlen, &uaddrlen, sizeof (socklen_t *)); } return ret; } @@ -1110,11 +1110,11 @@ int sys_bind(int socket, const struct musl_sockaddr *name, socklen_t namelen) struct sockaddr sa; struct musl_sockaddr kname; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)name, namelen)) + if (!lwp_user_access_ok((void*)name, namelen)) { return -1; } - lwp_data_get(&lwp_self()->mmu_info, &kname, (void*)name, namelen); + lwp_get_from_user(&kname, (void*)name, namelen); sockaddr_tolwip(&kname, &sa); @@ -1134,17 +1134,17 @@ int sys_getpeername (int socket, struct musl_sockaddr *name, socklen_t *namelen) socklen_t unamelen; socklen_t knamelen; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, namelen, sizeof (socklen_t *))) + if (!lwp_user_access_ok(namelen, sizeof (socklen_t *))) { return -1; } - lwp_data_get(&lwp_self()->mmu_info, &unamelen, namelen, sizeof (socklen_t *)); + lwp_get_from_user(&unamelen, namelen, sizeof (socklen_t *)); if (!unamelen) { return -1; } - if (!lwp_data_access_ok(&lwp_self()->mmu_info, name, unamelen)) + if (!lwp_user_access_ok(name, unamelen)) { return -1; } @@ -1159,8 +1159,8 @@ int sys_getpeername (int socket, struct musl_sockaddr *name, socklen_t *namelen) { unamelen = sizeof(struct musl_sockaddr); } - lwp_data_put(&lwp_self()->mmu_info, name, &kname, unamelen); - lwp_data_put(&lwp_self()->mmu_info, namelen, &unamelen, sizeof (socklen_t *)); + lwp_put_to_user(name, &kname, unamelen); + lwp_put_to_user(namelen, &unamelen, sizeof (socklen_t *)); } return ret; @@ -1174,17 +1174,17 @@ int sys_getsockname (int socket, struct musl_sockaddr *name, socklen_t *namelen) socklen_t unamelen; socklen_t knamelen; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, namelen, sizeof (socklen_t *))) + if (!lwp_user_access_ok(namelen, sizeof (socklen_t *))) { return -1; } - lwp_data_get(&lwp_self()->mmu_info, &unamelen, namelen, sizeof (socklen_t *)); + lwp_get_from_user(&unamelen, namelen, sizeof (socklen_t *)); if (!unamelen) { return -1; } - if (!lwp_data_access_ok(&lwp_self()->mmu_info, name, unamelen)) + if (!lwp_user_access_ok(name, unamelen)) { return -1; } @@ -1198,8 +1198,8 @@ int sys_getsockname (int socket, struct musl_sockaddr *name, socklen_t *namelen) { unamelen = sizeof(struct musl_sockaddr); } - lwp_data_put(&lwp_self()->mmu_info, name, &kname, unamelen); - lwp_data_put(&lwp_self()->mmu_info, namelen, &unamelen, sizeof (socklen_t *)); + lwp_put_to_user(name, &kname, unamelen); + lwp_put_to_user(namelen, &unamelen, sizeof (socklen_t *)); } return ret; } @@ -1225,11 +1225,11 @@ int sys_connect(int socket, const struct musl_sockaddr *name, socklen_t namelen) struct sockaddr sa; struct musl_sockaddr kname; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)name, namelen)) + if (!lwp_user_access_ok((void*)name, namelen)) { return -1; } - lwp_data_get(&lwp_self()->mmu_info, &kname, (void*)name, namelen); + lwp_get_from_user(&kname, (void*)name, namelen); sockaddr_tolwip(&kname, &sa); @@ -1278,7 +1278,7 @@ int sys_recvfrom(int socket, void *mem, size_t len, int flags, if (!len) return -1; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)mem, len)) + if (!lwp_user_access_ok((void*)mem, len)) return -1; kmem = kmem_get(len); @@ -1299,7 +1299,7 @@ int sys_recvfrom(int socket, void *mem, size_t len, int flags, ret = recvfrom(socket, kmem, len, flgs, NULL, NULL); if (ret > 0) - lwp_data_put(&lwp_self()->mmu_info, mem, kmem, len); + lwp_put_to_user(mem, kmem, len); kmem_put(kmem); return ret; @@ -1340,14 +1340,14 @@ int sys_sendto(int socket, const void *dataptr, size_t size, int flags, if (!size) return -1; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)dataptr, size)) + if (!lwp_user_access_ok((void*)dataptr, size)) return -1; kmem = kmem_get(size); if (!kmem) return -1; - lwp_data_get(&lwp_self()->mmu_info, kmem, (void *)dataptr, size); + lwp_get_from_user(kmem, (void *)dataptr, size); if (to) { @@ -1722,7 +1722,7 @@ int sys_access(const char *filename, int mode) rt_size_t len; char *kname; - if (!lwp_data_access_ok(&lwp_self()->mmu_info, (void*)filename, 1)) + if (!lwp_user_access_ok((void*)filename, 1)) return -1; len = rt_strlen(filename); @@ -1733,7 +1733,7 @@ int sys_access(const char *filename, int mode) if (!kname) return -1; - lwp_data_get(&lwp_self()->mmu_info, kname, (void *)filename, len + 1); + lwp_get_from_user(kname, (void *)filename, len + 1); ret = open(kname, mode, 0); kmem_put(kname); #else diff --git a/components/lwp/lwp_user_mm.c b/components/lwp/lwp_user_mm.c index c2631b9f4d..b3483ddeb7 100644 --- a/components/lwp/lwp_user_mm.c +++ b/components/lwp/lwp_user_mm.c @@ -385,17 +385,33 @@ size_t lwp_put_to_user(void *dst, void *src, size_t size) return lwp_data_put(m_info, dst, src, size); } -int lwp_data_access_ok(rt_mmu_info *mmu_info, void *addr, size_t size) +int lwp_user_access_ok(void *addr, size_t size) { void *addr_start, *addr_end, *next_page; void *tmp_addr; + struct rt_lwp *lwp = lwp_self(); + rt_mmu_info *mmu_info = RT_NULL; + if (!lwp) + { + return 0; + } if (!size || !addr) { return 0; } addr_start = addr; addr_end = addr + size; + if (addr_start >= (void*)KERNEL_VADDR_START) + { + return 0; + } + if (addr_start > (void *)KERNEL_VADDR_START) + { + return 0; + } + + mmu_info = &lwp->mmu_info; next_page = (void*)(((size_t)addr_start + ARCH_PAGE_SIZE) & ~(ARCH_PAGE_SIZE - 1)); do { diff --git a/components/lwp/lwp_user_mm.h b/components/lwp/lwp_user_mm.h index 47f5fb604c..f4b22c0ea8 100644 --- a/components/lwp/lwp_user_mm.h +++ b/components/lwp/lwp_user_mm.h @@ -36,10 +36,10 @@ 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); 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); -int lwp_data_access_ok(rt_mmu_info *mmu_info, void *addr, size_t size); void lwp_data_cache_flush(rt_mmu_info *mmu_info, void *vaddr, size_t size); #ifdef __cplusplus -- Gitee From 5f45f59a351a9c16e097dc0e3fb336b56aac32d4 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Sat, 19 Dec 2020 10:34:43 +0800 Subject: [PATCH 13/16] =?UTF-8?q?=E7=AE=80=E5=8C=96=E4=BF=A1=E5=8F=B7?= =?UTF-8?q?=E5=93=8D=E5=BA=94=E6=97=B6=E8=BF=9B=E7=A8=8B=E5=92=8C=E7=BA=BF?= =?UTF-8?q?=E7=A8=8B=E7=9A=84=E4=B8=AD=E6=AD=A2=E6=B5=81=E7=A8=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- components/lwp/lwp_signal.c | 21 ++------------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/components/lwp/lwp_signal.c b/components/lwp/lwp_signal.c index 280e85c7ff..a8f951b7f8 100644 --- a/components/lwp/lwp_signal.c +++ b/components/lwp/lwp_signal.c @@ -278,7 +278,6 @@ lwp_sighandler_t lwp_sighandler_get(int sig) lwp_sighandler_t func = RT_NULL; struct rt_lwp *lwp; rt_thread_t thread; - rt_thread_t main_thread; rt_base_t level; if (sig == 0 || sig > _LWP_NSIG) @@ -294,22 +293,6 @@ lwp_sighandler_t lwp_sighandler_get(int sig) { goto out; } - lwp = (struct rt_lwp*)thread->lwp; - main_thread = rt_list_entry(lwp->t_grp.prev, struct rt_thread, sibling); - if (thread == main_thread) - { - rt_thread_t sub_thread; - rt_list_t *s_list = lwp->t_grp.next; - rt_list_t *m_list = lwp->t_grp.prev; - - while (s_list != m_list) - { - sub_thread = rt_list_entry(s_list, struct rt_thread, sibling); - /* kill all sub threads */ - s_list = sub_thread->sibling.next; - lwp_thread_kill(sub_thread, SIGKILL); - } - } sys_exit(0); } } @@ -323,8 +306,8 @@ lwp_sighandler_t lwp_sighandler_get(int sig) { goto out; } - main_thread = rt_list_entry(lwp->t_grp.prev, struct rt_thread, sibling); - lwp_thread_kill(main_thread, SIGKILL); + lwp_terminate(lwp); + sys_exit(0); } } out: -- Gitee From 98d411674727953079503a051c2e433f1c61f835 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Sat, 19 Dec 2020 17:13:54 +0800 Subject: [PATCH 14/16] =?UTF-8?q?=E6=B6=88=E9=99=A4void*=20=E8=BF=90?= =?UTF-8?q?=E7=AE=97=E8=AD=A6=E5=91=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bsp/gkipc/armv6/rtos_lib.c | 2 +- components/lwp/arch/arm/common/reloc.c | 24 ++++++------- components/lwp/lwp.c | 16 ++++----- components/lwp/lwp_shm.c | 6 ++-- components/lwp/lwp_signal.c | 4 +-- components/lwp/lwp_user_mm.c | 48 +++++++++++++------------- libcpu/arm/cortex-a/backtrace.c | 6 ++-- libcpu/arm/cortex-a/mmu.c | 6 ++-- libcpu/arm/cortex-a/page.c | 4 +-- src/signal.c | 2 +- 10 files changed, 59 insertions(+), 59 deletions(-) diff --git a/bsp/gkipc/armv6/rtos_lib.c b/bsp/gkipc/armv6/rtos_lib.c index 78e7e1ccfa..115d53f611 100644 --- a/bsp/gkipc/armv6/rtos_lib.c +++ b/bsp/gkipc/armv6/rtos_lib.c @@ -524,7 +524,7 @@ void RTOS_SetErrno(const int err) } int RTOS_GetErrno() { - int err; + int err = 0; #if 0 rt_base_t level; level = rt_hw_interrupt_disable(); diff --git a/components/lwp/arch/arm/common/reloc.c b/components/lwp/arch/arm/common/reloc.c index 80b05e5d1c..cab0b76fd7 100644 --- a/components/lwp/arch/arm/common/reloc.c +++ b/components/lwp/arch/arm/common/reloc.c @@ -36,15 +36,15 @@ void lwp_elf_reloc(rt_mmu_info *m_info, void *text_start, void *rel_dyn_start, s memcpy(&v2, rel_dyn_start + rel_off + 4, 4); */ - addr = rt_hw_mmu_v2p(m_info, rel_dyn_start + rel_off); - addr -= PV_OFFSET; + addr = rt_hw_mmu_v2p(m_info, (void*)((char*)rel_dyn_start + rel_off)); + addr = (void*)((char*)addr - PV_OFFSET); memcpy(&v1, addr, 4); - addr = rt_hw_mmu_v2p(m_info, rel_dyn_start + rel_off + 4); - addr -= PV_OFFSET; + addr = rt_hw_mmu_v2p(m_info, (void*)((char*)rel_dyn_start + rel_off + 4)); + addr = (void*)((char*)addr - PV_OFFSET); memcpy(&v2, addr, 4); - addr = rt_hw_mmu_v2p(m_info, text_start + v1); - addr -= PV_OFFSET; + addr = rt_hw_mmu_v2p(m_info, (void*)((char*)text_start + v1)); + addr = (void*)((char*)addr - PV_OFFSET); if ((v2 & 0xff) == R_ARM_RELATIVE) { // *(uint32_t*)(text_start + v1) += (uint32_t)text_start; @@ -57,7 +57,7 @@ void lwp_elf_reloc(rt_mmu_info *m_info, void *text_start, void *rel_dyn_start, s if (t) /* 0 is UDF */ { // *(uint32_t*)(text_start + v1) = (uint32_t)(text_start + dynsym[t].st_value); - *(uint32_t*)addr = (uint32_t)(text_start + dynsym[t].st_value); + *(uint32_t*)addr = (uint32_t)((char*)text_start + dynsym[t].st_value); } } } @@ -70,7 +70,7 @@ void lwp_elf_reloc(rt_mmu_info *m_info, void *text_start, void *rel_dyn_start, s { //*got_item += (uint32_t)text_start; addr = rt_hw_mmu_v2p(m_info, got_item); - addr -= PV_OFFSET; + addr = (void*)((char*)addr - PV_OFFSET); *(uint32_t *)addr += (uint32_t)text_start; } } @@ -89,12 +89,12 @@ void lwp_elf_reloc(void *text_start, void *rel_dyn_start, size_t rel_dyn_size, v { uint32_t v1, v2; - memcpy(&v1, rel_dyn_start + rel_off, 4); - memcpy(&v2, rel_dyn_start + rel_off + 4, 4); + memcpy(&v1, (void*)((char*)rel_dyn_start + rel_off), 4); + memcpy(&v2, (void*)((char*)rel_dyn_start + rel_off + 4), 4); if ((v2 & 0xff) == R_ARM_RELATIVE) { - *(uint32_t*)(text_start + v1) += (uint32_t)text_start; + *(uint32_t*)((char*)text_start + v1) += (uint32_t)text_start; } else if ((v2 & 0xff) == R_ARM_ABS32) { @@ -102,7 +102,7 @@ void lwp_elf_reloc(void *text_start, void *rel_dyn_start, size_t rel_dyn_size, v t = (v2 >> 8); if (t) /* 0 is UDF */ { - *(uint32_t*)(text_start + v1) = (uint32_t)(text_start + dynsym[t].st_value); + *(uint32_t*)((char*)text_start + v1) = (uint32_t)((char*)text_start + dynsym[t].st_value); } } } diff --git a/components/lwp/lwp.c b/components/lwp/lwp.c index 6486e621d5..7d7cd3db89 100644 --- a/components/lwp/lwp.c +++ b/components/lwp/lwp.c @@ -410,7 +410,7 @@ static int load_elf(int fd, int len, struct rt_lwp *lwp, uint8_t *load_addr, str if (!va) return -RT_ERROR; pa = rt_hw_mmu_v2p(m_info, va); - process_header = pa - PV_OFFSET; + process_header = (uint8_t*)pa - PV_OFFSET; #else process_header = (uint8_t *)rt_malloc(process_header_size); if (!process_header) @@ -523,14 +523,14 @@ static int load_elf(int fd, int len, struct rt_lwp *lwp, uint8_t *load_addr, str while (size) { pa = rt_hw_mmu_v2p(m_info, va); - va_self = pa - PV_OFFSET; + va_self = (void*)((char*)pa - PV_OFFSET); LOG_D("va_self = %p pa = %p", va_self, pa); tmp_len = (size < ARCH_PAGE_SIZE) ? size : ARCH_PAGE_SIZE; tmp_len = load_fread(va_self, 1, tmp_len, fd); rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, va_self, tmp_len); read_len += tmp_len; size -= tmp_len; - va += ARCH_PAGE_SIZE; + va = (void*)((char*)va + ARCH_PAGE_SIZE); } } #else @@ -541,7 +541,7 @@ static int load_elf(int fd, int len, struct rt_lwp *lwp, uint8_t *load_addr, str if (pheader.p_filesz < pheader.p_memsz) { #ifdef RT_USING_USERSPACE - void *va = lwp->text_entry + pheader.p_filesz; + void *va = (void*)((char*)lwp->text_entry + pheader.p_filesz); void *va_self; void *pa; uint32_t size = pheader.p_memsz - pheader.p_filesz; @@ -554,12 +554,12 @@ static int load_elf(int fd, int len, struct rt_lwp *lwp, uint8_t *load_addr, str { size_s = (size < ARCH_PAGE_SIZE - off) ? size : ARCH_PAGE_SIZE - off; pa = rt_hw_mmu_v2p(m_info, va); - va_self = pa - PV_OFFSET; - memset(va_self + off, 0, size_s); - rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, va_self + off, size_s); + va_self = (void*)((char*)pa - PV_OFFSET); + memset((void*)((char*)va_self + off), 0, size_s); + rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, (void*)((char*)va_self + off), size_s); off = 0; size -= size_s; - va += ARCH_PAGE_SIZE; + va = (void*)((char*)va + ARCH_PAGE_SIZE); } #else memset((uint8_t *)lwp->text_entry + pheader.p_filesz, 0, (size_t)(pheader.p_memsz - pheader.p_filesz)); diff --git a/components/lwp/lwp_shm.c b/components/lwp/lwp_shm.c index 5c6754664f..022b665877 100644 --- a/components/lwp/lwp_shm.c +++ b/components/lwp/lwp_shm.c @@ -101,7 +101,7 @@ static int _lwp_shmget(size_t key, size_t size, int create) { goto err; } - page_addr_p = page_addr + PV_OFFSET; /* physical address */ + page_addr_p = (void*)((char*)page_addr + PV_OFFSET); /* physical address */ /* initialize the shared memory structure */ p = _shm_ary + id; @@ -198,7 +198,7 @@ static int _lwp_shmrm(int id) return 0; } bit = rt_page_bits(p->size); - rt_pages_free((void*)p->addr - PV_OFFSET, bit); + rt_pages_free((void*)((char*)p->addr - PV_OFFSET), bit); lwp_avl_remove(node_key, &shm_tree_key); node_pa = node_key + 1; lwp_avl_remove(node_pa, &shm_tree_pa); @@ -327,7 +327,7 @@ void *_lwp_shminfo(int id) } p = (struct lwp_shm_struct*)node_key->data; /* p = _shm_ary[id]; */ - return (void *)p->addr - PV_OFFSET; /* get the virtual address */ + return (void*)((char*)p->addr - PV_OFFSET); /* get the virtual address */ } /* A wrapping function: get the virtual address of a shared memory. */ diff --git a/components/lwp/lwp_signal.c b/components/lwp/lwp_signal.c index a8f951b7f8..3c7f0d0195 100644 --- a/components/lwp/lwp_signal.c +++ b/components/lwp/lwp_signal.c @@ -358,7 +358,7 @@ int lwp_sigprocmask(const lwp_sigset_t *sigset, lwp_sigset_t *oset) } if (oset) { - oset = rt_memcpy(oset, &lwp->signal_mask, sizeof(lwp_sigset_t)); + rt_memcpy(oset, &lwp->signal_mask, sizeof(lwp_sigset_t)); } rt_memcpy(&lwp->signal_mask, sigset, sizeof(lwp_sigset_t)); lwp_sigdelset(&lwp->signal_mask, SIGKILL); @@ -380,7 +380,7 @@ int lwp_thread_sigprocmask(const lwp_sigset_t *sigset, lwp_sigset_t *oset) if (oset) { - oset = rt_memcpy(oset, &thread->signal_mask, sizeof(lwp_sigset_t)); + rt_memcpy(oset, &thread->signal_mask, sizeof(lwp_sigset_t)); } rt_memcpy(&thread->signal_mask, sigset, sizeof(lwp_sigset_t)); lwp_sigdelset(&thread->signal_mask, SIGKILL); diff --git a/components/lwp/lwp_user_mm.c b/components/lwp/lwp_user_mm.c index b3483ddeb7..494150f39f 100644 --- a/components/lwp/lwp_user_mm.c +++ b/components/lwp/lwp_user_mm.c @@ -39,7 +39,7 @@ void lwp_mmu_switch(struct rt_thread *thread) if (thread->lwp) { l = (struct rt_lwp*)thread->lwp; - new_mmu_table = (void*)l->mmu_info.vtable + l->mmu_info.pv_off; + new_mmu_table = (void*)((char*)l->mmu_info.vtable + l->mmu_info.pv_off); #ifdef LWP_DEBUG { int i; @@ -93,7 +93,7 @@ static void free_area(struct rt_lwp *lwp, void *addr, size_t size, int auto_free void *va, *pa; int i; - for (va = addr, i = 0; i < size; va += ARCH_PAGE_SIZE, i += ARCH_PAGE_SIZE) + for (va = addr, i = 0; i < size; va = (void*)((char*)va + ARCH_PAGE_SIZE), i += ARCH_PAGE_SIZE) { pa = rt_hw_mmu_v2p(&lwp->mmu_info, va); if (pa) @@ -101,7 +101,7 @@ static void free_area(struct rt_lwp *lwp, void *addr, size_t size, int auto_free rt_hw_mmu_unmap(&lwp->mmu_info, va, ARCH_PAGE_SIZE); if (auto_free) { - rt_pages_free(pa - PV_OFFSET, 0); + rt_pages_free((void*)((char*)pa - PV_OFFSET), 0); } } } @@ -205,7 +205,7 @@ void *lwp_map_user(struct rt_lwp *lwp, void *map_va, size_t map_size) rt_hw_interrupt_enable(level); if (ret) { - ret += offset; + ret = (void*)((char*)ret + offset); } return ret; } @@ -263,7 +263,7 @@ void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t ma rt_hw_interrupt_enable(level); if (ret) { - ret += offset; + ret = (void*)((char*)ret + offset); } return ret; } @@ -346,7 +346,7 @@ size_t lwp_get_from_user(void *dst, void *src, size_t size) { return 0; } - if (src + size > (void*)KERNEL_VADDR_START) + if ((void*)((char*)src + size) > (void*)KERNEL_VADDR_START) { return 0; } @@ -371,7 +371,7 @@ size_t lwp_put_to_user(void *dst, void *src, size_t size) { return 0; } - if (dst + size > (void*)KERNEL_VADDR_START) + if ((void*)((char*)dst + size) > (void*)KERNEL_VADDR_START) { return 0; } @@ -401,7 +401,7 @@ int lwp_user_access_ok(void *addr, size_t size) return 0; } addr_start = addr; - addr_end = addr + size; + addr_end = (void*)((char*)addr + size); if (addr_start >= (void*)KERNEL_VADDR_START) { return 0; @@ -415,7 +415,7 @@ int lwp_user_access_ok(void *addr, size_t size) next_page = (void*)(((size_t)addr_start + ARCH_PAGE_SIZE) & ~(ARCH_PAGE_SIZE - 1)); do { - size_t len = next_page - addr_start; + size_t len = (char*)next_page - (char*)addr_start; if (size < len) { @@ -426,9 +426,9 @@ int lwp_user_access_ok(void *addr, size_t size) { return 0; } - addr_start += len; + addr_start = (void*)((char*)addr_start + len); size -= len; - next_page += ARCH_PAGE_SIZE; + next_page = (void*)((char*)next_page + ARCH_PAGE_SIZE); } while (addr_start < addr_end); return 1; } @@ -446,11 +446,11 @@ size_t lwp_data_get(rt_mmu_info *mmu_info, void *dst, void *src, size_t size) } tmp_dst = dst; addr_start = src; - addr_end = src + size; + addr_end = (void*)((char*)src + size); next_page = (void*)(((size_t)addr_start + ARCH_PAGE_SIZE) & ~(ARCH_PAGE_SIZE - 1)); do { - size_t len = next_page - addr_start; + size_t len = (char*)next_page - (char*)addr_start; if (size < len) { @@ -461,12 +461,12 @@ size_t lwp_data_get(rt_mmu_info *mmu_info, void *dst, void *src, size_t size) { break; } - tmp_src = rt_hw_mmu_v2p(mmu_info, addr_start) - PV_OFFSET; + tmp_src = (void*)((char*)rt_hw_mmu_v2p(mmu_info, addr_start) - PV_OFFSET); rt_memcpy(tmp_dst, tmp_src, len); - tmp_dst += len; - addr_start += len; + tmp_dst = (void*)((char*)tmp_dst + len); + addr_start = (void*)((char*)addr_start + len); size -= len; - next_page += ARCH_PAGE_SIZE; + next_page = (void*)((char*)next_page + ARCH_PAGE_SIZE); copy_len += len; } while (addr_start < addr_end); return copy_len; @@ -485,11 +485,11 @@ size_t lwp_data_put(rt_mmu_info *mmu_info, void *dst, void *src, size_t size) } tmp_src = src; addr_start = dst; - addr_end = dst + size; + addr_end = (void*)((char*)dst + size); next_page = (void*)(((size_t)addr_start + ARCH_PAGE_SIZE) & ~(ARCH_PAGE_SIZE - 1)); do { - size_t len = next_page - addr_start; + size_t len = (char*)next_page - (char*)addr_start; if (size < len) { @@ -500,12 +500,12 @@ size_t lwp_data_put(rt_mmu_info *mmu_info, void *dst, void *src, size_t size) { break; } - tmp_dst = rt_hw_mmu_v2p(mmu_info, addr_start) - PV_OFFSET; + tmp_dst = (void*)((char*)rt_hw_mmu_v2p(mmu_info, addr_start) - PV_OFFSET); rt_memcpy(tmp_dst, tmp_src, len); - tmp_src += len; - addr_start += len; + tmp_src = (void*)((char*)tmp_src + len); + addr_start = (void*)((char*)addr_start + len); size -= len; - next_page += ARCH_PAGE_SIZE; + next_page = (void*)((char*)next_page + ARCH_PAGE_SIZE); copy_len += len; } while (addr_start < addr_end); return copy_len; @@ -516,7 +516,7 @@ void lwp_data_cache_flush(rt_mmu_info *mmu_info, void *vaddr, size_t size) void *paddr; paddr = rt_hw_mmu_v2p(mmu_info, vaddr); - paddr -= PV_OFFSET; + paddr = (void*)((char*)paddr - PV_OFFSET); rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, paddr, size); } diff --git a/libcpu/arm/cortex-a/backtrace.c b/libcpu/arm/cortex-a/backtrace.c index 37a04e90af..695e31ca5a 100644 --- a/libcpu/arm/cortex-a/backtrace.c +++ b/libcpu/arm/cortex-a/backtrace.c @@ -361,11 +361,11 @@ error: #ifdef RT_BACKTRACE_FUNCTION_NAME static char *unwind_get_function_name(void *address) { - uint32_t flag_word = *(uint32_t *)(address - 4); + uint32_t flag_word = *(uint32_t *)((char*)address - 4); if ((flag_word & 0xff000000) == 0xff000000) { - return (char *)(address - 4 - (flag_word & 0x00ffffff)); + return (char *)((char*)address - 4 - (flag_word & 0x00ffffff)); } return RT_NULL; } @@ -384,7 +384,7 @@ int unwind_frame(struct stackframe *frame, const struct unwind_idx **origin_idx, /* store the highest address on the stack to avoid crossing it*/ low = frame->sp; rt_c_thread = rt_thread_self(); - ctrl.sp_high = (unsigned long)(rt_c_thread->stack_addr + rt_c_thread->stack_size); + ctrl.sp_high = (unsigned long)((char*)rt_c_thread->stack_addr + rt_c_thread->stack_size); LOG_D("%s(pc = %08lx lr = %08lx sp = %08lx)", __func__, frame->pc, frame->lr, frame->sp); diff --git a/libcpu/arm/cortex-a/mmu.c b/libcpu/arm/cortex-a/mmu.c index eb9ba0fd8e..b50d7ab92e 100644 --- a/libcpu/arm/cortex-a/mmu.c +++ b/libcpu/arm/cortex-a/mmu.c @@ -665,9 +665,9 @@ err: for (i = 0; i < npages; i++) { pa = rt_hw_mmu_v2p(mmu_info, va); - pa -= mmu_info->pv_off; + pa = (void*)((char*)pa - mmu_info->pv_off); rt_pages_free(pa, 0); - va += ARCH_PAGE_SIZE; + va = (void*)((char*)va + ARCH_PAGE_SIZE); } __rt_hw_mmu_unmap(mmu_info, v_addr, npages); @@ -707,7 +707,7 @@ void *_rt_hw_mmu_map_auto(rt_mmu_info *mmu_info, void *v_addr, size_t size, size if (ret == 0) { rt_hw_cpu_tlb_invalidate(); - return (void*)vaddr + offset; + return (void*)((char*)vaddr + offset); } } return 0; diff --git a/libcpu/arm/cortex-a/page.c b/libcpu/arm/cortex-a/page.c index 24c105cc3d..716e4f1aaf 100644 --- a/libcpu/arm/cortex-a/page.c +++ b/libcpu/arm/cortex-a/page.c @@ -62,7 +62,7 @@ static struct page * addr_to_page(void *addr) { return 0; } - off = addr - page_addr; + off = (size_t)((char*)addr - (char*)page_addr); off >>= ARCH_PAGE_SHIFT; if (off >= page_nr) { @@ -77,7 +77,7 @@ static void* page_to_addr(struct page* p) { return 0; } - return page_addr + ((p - page_start) << ARCH_PAGE_SHIFT); + return (void*)((char*)page_addr + ((p - page_start) << ARCH_PAGE_SHIFT)); } static inline struct page *buddy_get(struct page *p, uint32_t size_bits) diff --git a/src/signal.c b/src/signal.c index 1c41e47f0e..885a68a5e2 100644 --- a/src/signal.c +++ b/src/signal.c @@ -201,7 +201,7 @@ void *rt_signal_check(void* context) rt_hw_interrupt_enable(level); sig_context = rt_hw_stack_init((void *)_signal_entry, context, - (void *)(context - 32), RT_NULL); + (void*)((char*)context - 32), RT_NULL); return sig_context; } } -- Gitee From 3d66341ced9ace3f86c1eb3f029378c761f0eb12 Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Tue, 22 Dec 2020 15:04:43 +0800 Subject: [PATCH 15/16] =?UTF-8?q?=E5=8E=9Frt=5Fthread=5Fsuspend=E6=94=B9?= =?UTF-8?q?=E5=90=8D=E4=B8=BArt=5Fthread=5Fsuspend=5Fwith=5Fflag=20?= =?UTF-8?q?=E6=96=B0rt=5Fthread=5Fsuspend=E5=87=BD=E6=95=B0=E4=B8=BAsuspen?= =?UTF-8?q?d=5Fflag=E4=B8=BART=5FUNITERRUPTIBLE=E7=9A=84rt=5Fthread=5Fsusp?= =?UTF-8?q?end=5Fwith=5Fflag=E8=B0=83=E7=94=A8=20lwp=5Fuser=5Faccess=5Fok?= =?UTF-8?q?=E5=87=BD=E6=95=B0=E6=94=B9=E5=90=8D=E4=B8=BAlwp=5Fuser=5Facces?= =?UTF-8?q?sable?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bsp/gkipc/armv6/rtos_lib.c | 2 +- components/dfs/src/poll.c | 2 +- components/drivers/audio/audio_pipe.c | 4 +- components/drivers/src/completion.c | 2 +- components/drivers/src/dataqueue.c | 4 +- components/drivers/src/waitqueue.c | 2 +- components/drivers/src/workqueue.c | 2 +- components/libc/compilers/newlib/syscalls.c | 2 +- components/libc/libdl/dlmodule.c | 2 +- .../lwp/arch/arm/cortex-a/arch_user_stack.c | 2 +- components/lwp/lwp_ipc.c | 2 +- components/lwp/lwp_pid.c | 2 +- components/lwp/lwp_syscall.c | 44 +++++++++---------- components/lwp/lwp_user_mm.c | 2 +- components/lwp/lwp_user_mm.h | 2 +- components/vbus/prio_queue.c | 2 +- components/vbus/vbus.c | 4 +- components/vbus/watermark_queue.h | 2 +- examples/kernel/thread_resume.c | 2 +- examples/kernel/thread_suspend.c | 2 +- include/rtthread.h | 3 +- libcpu/arm/AT91SAM7X/trap.c | 2 +- libcpu/arm/cortex-a/trap.c | 4 +- src/ipc.c | 2 +- src/mempool.c | 2 +- src/signal.c | 2 +- src/thread.c | 13 ++++-- src/timer.c | 2 +- 28 files changed, 63 insertions(+), 55 deletions(-) diff --git a/bsp/gkipc/armv6/rtos_lib.c b/bsp/gkipc/armv6/rtos_lib.c index 115d53f611..4d0a75a10d 100644 --- a/bsp/gkipc/armv6/rtos_lib.c +++ b/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 ) diff --git a/components/dfs/src/poll.c b/components/dfs/src/poll.c index 536be0c04d..2d948a30a3 100644 --- a/components/dfs/src/poll.c +++ b/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) { diff --git a/components/drivers/audio/audio_pipe.c b/components/drivers/audio/audio_pipe.c index dca9c72be7..4fd8b0edfe 100644 --- a/components/drivers/audio/audio_pipe.c +++ b/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)); diff --git a/components/drivers/src/completion.c b/components/drivers/src/completion.c index cdb6bd8fab..24b85e198e 100644 --- a/components/drivers/src/completion.c +++ b/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)); diff --git a/components/drivers/src/dataqueue.c b/components/drivers/src/dataqueue.c index 196b81598a..3f481a308e 100644 --- a/components/drivers/src/dataqueue.c +++ b/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) diff --git a/components/drivers/src/waitqueue.c b/components/drivers/src/waitqueue.c index ab816c7ed1..830c5bed9c 100644 --- a/components/drivers/src/waitqueue.c +++ b/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); diff --git a/components/drivers/src/workqueue.c b/components/drivers/src/workqueue.c index 27cfc8c65e..564dde78f2 100644 --- a/components/drivers/src/workqueue.c +++ b/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(); } diff --git a/components/libc/compilers/newlib/syscalls.c b/components/libc/compilers/newlib/syscalls.c index dfbd6cc26e..aac6ff1d0b 100644 --- a/components/libc/compilers/newlib/syscalls.c +++ b/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(); } diff --git a/components/libc/libdl/dlmodule.c b/components/libc/libdl/dlmodule.c index a5954de4d5..3c513acc27 100644 --- a/components/libc/libdl/dlmodule.c +++ b/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); } } } diff --git a/components/lwp/arch/arm/cortex-a/arch_user_stack.c b/components/lwp/arch/arm/cortex-a/arch_user_stack.c index d65e5750f1..8911da8209 100644 --- a/components/lwp/arch/arm/cortex-a/arch_user_stack.c +++ b/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; } diff --git a/components/lwp/lwp_ipc.c b/components/lwp/lwp_ipc.c index 4eb8660aee..40126229bc 100644 --- a/components/lwp/lwp_ipc.c +++ b/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) { diff --git a/components/lwp/lwp_pid.c b/components/lwp/lwp_pid.c index d126427ed6..e13c6f33aa 100644 --- a/components/lwp/lwp_pid.c +++ b/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) diff --git a/components/lwp/lwp_syscall.c b/components/lwp/lwp_syscall.c index 733fb276d1..a392698367 100644 --- a/components/lwp/lwp_syscall.c +++ b/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); diff --git a/components/lwp/lwp_user_mm.c b/components/lwp/lwp_user_mm.c index 494150f39f..c5ebe96bf4 100644 --- a/components/lwp/lwp_user_mm.c +++ b/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; diff --git a/components/lwp/lwp_user_mm.h b/components/lwp/lwp_user_mm.h index f4b22c0ea8..d72a1ff300 100644 --- a/components/lwp/lwp_user_mm.h +++ b/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); diff --git a/components/vbus/prio_queue.c b/components/vbus/prio_queue.c index 44dd572d94..0d15da5ab8 100644 --- a/components/vbus/prio_queue.c +++ b/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)); diff --git a/components/vbus/vbus.c b/components/vbus/vbus.c index 06fd220057..d471a9d21b 100644 --- a/components/vbus/vbus.c +++ b/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) diff --git a/components/vbus/watermark_queue.h b/components/vbus/watermark_queue.h index e5c2c4320d..8828ceb1ac 100644 --- a/components/vbus/watermark_queue.h +++ b/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) { diff --git a/examples/kernel/thread_resume.c b/examples/kernel/thread_resume.c index 59c7ad0810..26bebe9160 100644 --- a/examples/kernel/thread_resume.c +++ b/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(); diff --git a/examples/kernel/thread_suspend.c b/examples/kernel/thread_suspend.c index 866608ab73..a6cf11b089 100644 --- a/examples/kernel/thread_suspend.c +++ b/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); diff --git a/include/rtthread.h b/include/rtthread.h index 6ff8f640cc..21e9517a63 100644 --- a/include/rtthread.h +++ b/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); diff --git a/libcpu/arm/AT91SAM7X/trap.c b/libcpu/arm/AT91SAM7X/trap.c index 450ee07757..dbbe2a1684 100644 --- a/libcpu/arm/AT91SAM7X/trap.c +++ b/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(); } diff --git a/libcpu/arm/cortex-a/trap.c b/libcpu/arm/cortex-a/trap.c index a9ed6c16df..bc4cf36a8c 100644 --- a/libcpu/arm/cortex-a/trap.c +++ b/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; diff --git a/src/ipc.c b/src/ipc.c index 706c6af7b7..7e64496e55 100644 --- a/src/ipc.c +++ b/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) diff --git a/src/mempool.c b/src/mempool.c index f07f8308e3..5be9520c94 100644 --- a/src/mempool.c +++ b/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) diff --git a/src/signal.c b/src/signal.c index 885a68a5e2..cef7e85335 100644 --- a/src/signal.c +++ b/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; diff --git a/src/thread.c b/src/thread.c index 1d1fee2341..e77cf46139 100644 --- a/src/thread.c +++ b/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. * diff --git a/src/timer.c b/src/timer.c index 3ffdb12104..38c17687ad 100644 --- a/src/timer.c +++ b/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 -- Gitee From b5194a2273f8ecadd154c6b330aa12a66b3b3a0a Mon Sep 17 00:00:00 2001 From: shaojinchun Date: Wed, 23 Dec 2020 11:37:18 +0800 Subject: [PATCH 16/16] =?UTF-8?q?rt=5Fthread=5Fset=5Fsuspend=5Fstate?= =?UTF-8?q?=E6=94=B9=E4=B8=BAstatic?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/rtdef.h | 2 +- include/rtthread.h | 1 - src/thread.c | 53 +++++++++++++++++++++------------------------- 3 files changed, 25 insertions(+), 31 deletions(-) diff --git a/include/rtdef.h b/include/rtdef.h index b61fabe38f..efc8634e8c 100644 --- a/include/rtdef.h +++ b/include/rtdef.h @@ -517,7 +517,7 @@ typedef siginfo_t rt_siginfo_t; #define RT_THREAD_RUNNING 0x03 /**< Running status */ /* - * for rt_thread_set_suspend_state() + * for rt_thread_suspend_with_flag() */ enum { diff --git a/include/rtthread.h b/include/rtthread.h index 21e9517a63..f6e0889889 100644 --- a/include/rtthread.h +++ b/include/rtthread.h @@ -147,7 +147,6 @@ rt_err_t rt_thread_delay(rt_tick_t tick); 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); 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); diff --git a/src/thread.c b/src/thread.c index e77cf46139..863bf6259a 100644 --- a/src/thread.c +++ b/src/thread.c @@ -506,35 +506,6 @@ rt_err_t rt_thread_yield(void) } RTM_EXPORT(rt_thread_yield); -/** - * This function will set a thread's suspend status - * - * @param thread the thread to be suspend - * @param status flag of the thread, must be one of RT_INTERRUPTIBLE RT_KILLABLE RT_UNINTERRUPTIBLE - */ -void rt_thread_set_suspend_state(struct rt_thread *thread, int suspend_flag) -{ - rt_uint8_t stat = RT_THREAD_SUSPEND_UNINTERRUPTIBLE; - - RT_ASSERT(thread != RT_NULL); - switch (suspend_flag) - { - case RT_INTERRUPTIBLE: - stat = RT_THREAD_SUSPEND_INTERRUPTIBLE; - break; - case RT_KILLABLE: - stat = RT_THREAD_SUSPEND_KILLABLE; - break; - case RT_UNINTERRUPTIBLE: - stat = RT_THREAD_SUSPEND_UNINTERRUPTIBLE; - break; - default: - RT_ASSERT(0); - break; - } - thread->stat = stat | (thread->stat & ~RT_THREAD_STAT_MASK); -} - /** * This function will let current thread sleep for some ticks. * @@ -770,6 +741,30 @@ RTM_EXPORT(rt_thread_control); #ifdef RT_USING_LWP int lwp_suspend_sigcheck(rt_thread_t thread, int suspend_flag); #endif + +static void rt_thread_set_suspend_state(struct rt_thread *thread, int suspend_flag) +{ + rt_uint8_t stat = RT_THREAD_SUSPEND_UNINTERRUPTIBLE; + + RT_ASSERT(thread != RT_NULL); + switch (suspend_flag) + { + case RT_INTERRUPTIBLE: + stat = RT_THREAD_SUSPEND_INTERRUPTIBLE; + break; + case RT_KILLABLE: + stat = RT_THREAD_SUSPEND_KILLABLE; + break; + case RT_UNINTERRUPTIBLE: + stat = RT_THREAD_SUSPEND_UNINTERRUPTIBLE; + break; + default: + RT_ASSERT(0); + break; + } + thread->stat = stat | (thread->stat & ~RT_THREAD_STAT_MASK); +} + /** * This function will suspend the specified thread. * -- Gitee