Merge pull request #1579 from RT-Thread/fix_waitqueue

Fix waitqueue issue

3 files changed, 96 insertions, 21 deletions

diff --git a/components/drivers/include/ipc/waitqueue.h b/components/drivers/include/ipc/waitqueue.h
index 1746d0f1cd..8cb0989f73 100644
--- a/components/drivers/include/ipc/waitqueue.h
+++ b/components/drivers/include/ipc/waitqueue.h
@@ -1,25 +1,59 @@
+/*
+ * File      : waitqueue.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018/06/26     Bernard      Fix the wait queue issue when wakeup a soon 
+ *                             to blocked thread.
+ */
+
 #ifndef WAITQUEUE_H__
 #define WAITQUEUE_H__
 
 #include <rtthread.h>
 
-struct rt_wqueue_node;
+#define RT_WQ_FLAG_CLEAN    0x00
+#define RT_WQ_FLAG_WAKEUP   0x01
 
-typedef rt_list_t rt_wqueue_t;
+struct rt_wqueue_node;
 typedef int (*rt_wqueue_func_t)(struct rt_wqueue_node *wait, void *key);
 
 struct rt_wqueue_node
 {
-	rt_thread_t polling_thread;
-	rt_list_t   list;
+    rt_thread_t polling_thread;
+    rt_list_t   list;
 
-	rt_wqueue_func_t wakeup;
-	rt_uint32_t key;
+    rt_wqueue_func_t wakeup;
+    rt_uint32_t key;
 };
 typedef struct rt_wqueue_node rt_wqueue_node_t;
 
 int __wqueue_default_wake(struct rt_wqueue_node *wait, void *key);
 
+rt_inline void rt_wqueue_init(rt_wqueue_t *queue)
+{
+    RT_ASSERT(queue != RT_NULL);
+
+    queue->flag = RT_WQ_FLAG_CLEAN;
+    rt_list_init(&(queue->waiting_list));
+}
+
 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);
diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c
index 09264ffbe3..a971401ce3 100644
--- a/components/drivers/src/pipe.c
+++ b/components/drivers/src/pipe.c
@@ -438,8 +438,8 @@ rt_pipe_t *rt_pipe_create(const char *name, int bufsz)
 
     rt_memset(pipe, 0, sizeof(rt_pipe_t));
     rt_mutex_init(&(pipe->lock), name, RT_IPC_FLAG_FIFO);
-    rt_list_init(&(pipe->reader_queue));
-    rt_list_init(&(pipe->writer_queue));
+    rt_wqueue_init(&(pipe->reader_queue));
+    rt_wqueue_init(&(pipe->writer_queue));
 
     RT_ASSERT(bufsz < 0xFFFF);
     pipe->bufsz = bufsz;
diff --git a/components/drivers/src/waitqueue.c b/components/drivers/src/waitqueue.c
index 7fff2d3825..a4c392a27c 100644
--- a/components/drivers/src/waitqueue.c
+++ b/components/drivers/src/waitqueue.c
@@ -1,17 +1,40 @@
+/*
+ * File      : waitqueue.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2018, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018/06/26     Bernard      Fix the wait queue issue when wakeup a soon 
+ *                             to blocked thread.
+ */
+
 #include <stdint.h>
 
 #include <rthw.h>
 #include <rtdevice.h>
 #include <rtservice.h>
 
-extern struct rt_thread *rt_current_thread;
-
 void rt_wqueue_add(rt_wqueue_t *queue, struct rt_wqueue_node *node)
 {
     rt_base_t level;
 
     level = rt_hw_interrupt_disable();
-    rt_list_insert_before(queue, &(node->list));
+    rt_list_insert_before(&(queue->waiting_list), &(node->list));
     rt_hw_interrupt_enable(level);
 }
 
@@ -34,23 +57,29 @@ void rt_wqueue_wakeup(rt_wqueue_t *queue, void *key)
     rt_base_t level;
     register int need_schedule = 0;
 
+    rt_list_t *queue_list;
     struct rt_list_node *node;
     struct rt_wqueue_node *entry;
 
-    if (rt_list_isempty(queue))
-        return;
+    queue_list = &(queue->waiting_list);
 
     level = rt_hw_interrupt_disable();
-    for (node = queue->next; node != queue; node = node->next)
+    /* set wakeup flag in the queue */
+    queue->flag = RT_WQ_FLAG_WAKEUP;
+
+    if (!(rt_list_isempty(queue_list)))
     {
-        entry = rt_list_entry(node, struct rt_wqueue_node, list);
-        if (entry->wakeup(entry, key) == 0)
+        for (node = queue_list->next; node != queue_list; node = node->next)
         {
-            rt_thread_resume(entry->polling_thread);
-            need_schedule = 1;
+            entry = rt_list_entry(node, struct rt_wqueue_node, list);
+            if (entry->wakeup(entry, key) == 0)
+            {
+                rt_thread_resume(entry->polling_thread);
+                need_schedule = 1;
 
-            rt_wqueue_remove(entry);
-            break;
+                rt_wqueue_remove(entry);
+                break;
+            }
         }
     }
     rt_hw_interrupt_enable(level);
@@ -62,7 +91,7 @@ void rt_wqueue_wakeup(rt_wqueue_t *queue, void *key)
 int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec)
 {
     int tick;
-    rt_thread_t tid = rt_current_thread;
+    rt_thread_t tid = rt_thread_self();
     rt_timer_t  tmr = &(tid->thread_timer);
     struct rt_wqueue_node __wait;
     rt_base_t level;
@@ -81,6 +110,12 @@ int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec)
     rt_list_init(&__wait.list);
 
     level = rt_hw_interrupt_disable();
+    if (queue->flag == RT_WQ_FLAG_WAKEUP)
+    {
+        /* already wakeup */
+        goto __exit_wakeup;
+    }
+
     rt_wqueue_add(queue, &__wait);
     rt_thread_suspend(tid);
 
@@ -97,6 +132,12 @@ int rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec)
 
     rt_schedule();
 
+    level = rt_hw_interrupt_disable();
+
+__exit_wakeup:
+    queue->flag = 0;
+    rt_hw_interrupt_enable(level);
+
     rt_wqueue_remove(&__wait);
 
     return 0;