This is an automated email from the ASF dual-hosted git repository.

xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git

commit 060859aef3a98a87b0b653e8cdcb8dafd6f629a6
Author: Yongrong Wang <[email protected]>
AuthorDate: Mon Nov 17 16:10:00 2025 +0800

    drivers/rpmsg: fix rpmsg_wait() not returning in the recursive path
    
    rpmsg_wait() run on an rpmsg work queue returned RPMSG_EOPNOTSUPP once
    the recursion reached RPMSG_RECURSIVE_LIMIT, even though the semaphore it
    waited for could still be posted. rpmsg_virtio_notify_wait() then could
    not finish waiting for a tx buffer.
    
    Keep looping until the semaphore is taken: at the limit, only wait
    instead of dispatching more works. Add rpmsg_tickwait() with a timeout,
    make rpmsg_wait() a wrapper with no timeout, and pass the remaining time
    to the transport wait op so that rpmsg_virtio_notify_wait() can give up
    after RPMSG_VIRTIO_TIMEOUT_MS.
    
    Signed-off-by: Yongrong Wang <[email protected]>
    Signed-off-by: Bowen Wang <[email protected]>
---
 drivers/rpmsg/rpmsg.c        | 49 +++++++++++++++++++++++++++++---------------
 drivers/rpmsg/rpmsg.h        |  2 +-
 drivers/rpmsg/rpmsg_virtio.c | 16 +++++++++++----
 include/nuttx/rpmsg/rpmsg.h  |  6 +++++-
 4 files changed, 50 insertions(+), 23 deletions(-)

diff --git a/drivers/rpmsg/rpmsg.c b/drivers/rpmsg/rpmsg.c
index 32631619a17..4befc3be89b 100644
--- a/drivers/rpmsg/rpmsg.c
+++ b/drivers/rpmsg/rpmsg.c
@@ -30,14 +30,17 @@
 #include <limits.h>
 #include <stdio.h>
 #include <syslog.h>
+#include <time.h>
 
 #include <metal/sys.h>
+#include <nuttx/clock.h>
 #include <nuttx/kmalloc.h>
 #include <nuttx/list.h>
 #include <nuttx/mutex.h>
 #include <nuttx/nuttx.h>
 #include <nuttx/rwsem.h>
 #include <nuttx/semaphore.h>
+#include <nuttx/wdog.h>
 #include <nuttx/wqueue.h>
 
 #include "rpmsg.h"
@@ -340,10 +343,12 @@ void rpmsg_initialize(void)
 #endif
 }
 
-int rpmsg_wait(FAR struct rpmsg_endpoint *ept, FAR sem_t *sem)
+int rpmsg_tickwait(FAR struct rpmsg_endpoint *ept, FAR sem_t *sem,
+                   clock_t delay)
 {
   FAR struct rpmsg_wqueue_s *wqueue;
   FAR struct rpmsg_s *rpmsg;
+  clock_t end;
   int ret;
 
   if (!ept || !sem)
@@ -352,17 +357,16 @@ int rpmsg_wait(FAR struct rpmsg_endpoint *ept, FAR sem_t 
*sem)
     }
 
   rpmsg = rpmsg_get_by_rdev(ept->rdev);
-  if (!rpmsg || !rpmsg->ops->wait)
-    {
-      return nxsem_wait_uninterruptible(sem);
-    }
-
-  wqueue = rpmsg_get_current_wqueue(rpmsg);
+  wqueue = rpmsg && rpmsg->ops->wait ?
+           rpmsg_get_current_wqueue(rpmsg) : NULL;
   if (wqueue == NULL)
     {
-      return nxsem_wait_uninterruptible(sem);
+      return delay >= WDOG_MAX_DELAY ?
+             nxsem_wait_uninterruptible(sem) :
+             nxsem_tickwait_uninterruptible(sem, delay);
     }
 
+  end = delay >= WDOG_MAX_DELAY ? 0 : clock_systime_ticks() + delay;
   for (; ; )
     {
       ret = nxsem_trywait(sem);
@@ -371,19 +375,30 @@ int rpmsg_wait(FAR struct rpmsg_endpoint *ept, FAR sem_t 
*sem)
           return ret;
         }
 
-      rpmsg->ops->wait(rpmsg);
-
-      if (wqueue->recursive >= RPMSG_RECURSIVE_LIMIT)
+      if (delay < WDOG_MAX_DELAY)
         {
-          return RPMSG_EOPNOTSUPP;
+          clock_t now = clock_systime_ticks();
+
+          if (clock_compare(end, now))
+            {
+              return -ETIMEDOUT;
+            }
+
+          delay = end - now;
         }
 
-      wqueue->recursive++;
-      work_queue_dispatch(wqueue->kwqueue);
-      wqueue->recursive--;
-    }
+      /* Keep running the queued works until the semaphore is posted: a
+       * deeper level than the limit only waits, so the wait still ends.
+       */
 
-  return OK;
+      rpmsg->ops->wait(rpmsg, delay);
+      if (wqueue->recursive < RPMSG_RECURSIVE_LIMIT)
+        {
+          wqueue->recursive++;
+          work_queue_dispatch(wqueue->kwqueue);
+          wqueue->recursive--;
+        }
+    }
 }
 
 int rpmsg_post(FAR struct rpmsg_endpoint *ept, FAR sem_t *sem)
diff --git a/drivers/rpmsg/rpmsg.h b/drivers/rpmsg/rpmsg.h
index 9b51266c5ec..b542877f8ff 100644
--- a/drivers/rpmsg/rpmsg.h
+++ b/drivers/rpmsg/rpmsg.h
@@ -88,7 +88,7 @@ struct rpmsg_s
 
 struct rpmsg_ops_s
 {
-  CODE int (*wait)(FAR struct rpmsg_s *rpmsg);
+  CODE int (*wait)(FAR struct rpmsg_s *rpmsg, clock_t delay);
   CODE int (*post)(FAR struct rpmsg_s *rpmsg);
   CODE int (*ioctl)(FAR struct rpmsg_s *rpmsg, int cmd, unsigned long arg);
   CODE void (*panic)(FAR struct rpmsg_s *rpmsg);
diff --git a/drivers/rpmsg/rpmsg_virtio.c b/drivers/rpmsg/rpmsg_virtio.c
index b972942c7e2..3e544133594 100644
--- a/drivers/rpmsg/rpmsg_virtio.c
+++ b/drivers/rpmsg/rpmsg_virtio.c
@@ -86,7 +86,7 @@ struct rpmsg_virtio_priv_s
  * Private Function Prototypes
  ****************************************************************************/
 
-static int rpmsg_virtio_wait(FAR struct rpmsg_s *rpmsg);
+static int rpmsg_virtio_wait(FAR struct rpmsg_s *rpmsg, clock_t delay);
 static int rpmsg_virtio_post(FAR struct rpmsg_s *rpmsg);
 static void rpmsg_virtio_dump(FAR struct rpmsg_s *rpmsg, bool verbose);
 
@@ -295,12 +295,17 @@ static void rpmsg_virtio_rx_worker(FAR struct rpmsg_s 
*rpmsg, FAR void *arg)
  * Name: rpmsg_virtio_wait
  ****************************************************************************/
 
-static int rpmsg_virtio_wait(FAR struct rpmsg_s *rpmsg)
+static int rpmsg_virtio_wait(FAR struct rpmsg_s *rpmsg, clock_t delay)
 {
   FAR struct rpmsg_virtio_priv_s *priv =
     (FAR struct rpmsg_virtio_priv_s *)rpmsg;
 
-  return nxsem_tickwait(&priv->semtx, MSEC2TICK(RPMSG_VIRTIO_TIMEOUT_MS));
+  if (delay > MSEC2TICK(RPMSG_VIRTIO_TIMEOUT_MS))
+    {
+      delay = MSEC2TICK(RPMSG_VIRTIO_TIMEOUT_MS);
+    }
+
+  return nxsem_tickwait(&priv->semtx, delay);
 }
 
 /****************************************************************************
@@ -655,8 +660,11 @@ static int rpmsg_virtio_notify_wait(FAR struct 
rpmsg_device *rdev,
 {
   FAR struct rpmsg_virtio_priv_s *priv =
     container_of(rdev, struct rpmsg_virtio_priv_s, rvdev);
+  int ret;
 
-  return rpmsg_wait(&priv->rvdev.rdev.ns_ept, &priv->semtx);
+  ret = rpmsg_tickwait(&priv->rvdev.rdev.ns_ept, &priv->semtx,
+                       MSEC2TICK(RPMSG_VIRTIO_TIMEOUT_MS));
+  return ret == -ETIMEDOUT ? 0 : ret;
 }
 
 /****************************************************************************
diff --git a/include/nuttx/rpmsg/rpmsg.h b/include/nuttx/rpmsg/rpmsg.h
index 8bea27031c7..3944aa3674a 100644
--- a/include/nuttx/rpmsg/rpmsg.h
+++ b/include/nuttx/rpmsg/rpmsg.h
@@ -35,6 +35,7 @@
 #ifdef CONFIG_RPMSG
 
 #include <nuttx/fs/ioctl.h>
+#include <nuttx/semaphore.h>
 #include <openamp/rpmsg.h>
 #include <openamp/rpmsg_internal.h>
 
@@ -52,6 +53,8 @@
 
 #define RPMSG_SIGNAL_RUNNING        TIOCM_CD
 
+#define rpmsg_wait(e, s)            rpmsg_tickwait(e, s, CLOCK_MAX)
+
 /****************************************************************************
  * Public Types
  ****************************************************************************/
@@ -92,7 +95,8 @@ extern "C"
 
 void rpmsg_initialize(void);
 
-int rpmsg_wait(FAR struct rpmsg_endpoint *ept, FAR sem_t *sem);
+int rpmsg_tickwait(FAR struct rpmsg_endpoint *ept, FAR sem_t *sem,
+                   clock_t delay);
 int rpmsg_post(FAR struct rpmsg_endpoint *ept, FAR sem_t *sem);
 
 FAR const char *rpmsg_get_local_cpuname(FAR struct rpmsg_device *rdev);

Reply via email to