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 56890907c7e462610ef3c1ddcace85e56aa76e93
Author: buxiasen <[email protected]>
AuthorDate: Mon Feb 2 12:09:59 2026 +0800

    drivers/pipes: change rmutex to rspinlock
    
    Fix signal write break the mutex.
    Need nopreempt as there is post and cause possible recursive in diff
    threads.
    Avoid the circbuf_uninit/free cause lock/sched_switch, unlock before
    free should prefer.
    The resize possible do malloc/free cause break rspinlock, need do
    malloc/free with pipe unlocked.
    
    pipecommon_writev() now takes d_bflock the same way as pipecommon_write().
    
    Signed-off-by: buxiasen <[email protected]>
---
 drivers/pipes/pipe_common.c | 232 +++++++++++++++++---------------------------
 drivers/pipes/pipe_common.h |   4 +-
 2 files changed, 89 insertions(+), 147 deletions(-)

diff --git a/drivers/pipes/pipe_common.c b/drivers/pipes/pipe_common.c
index 150e99f5bef..56d71f77822 100644
--- a/drivers/pipes/pipe_common.c
+++ b/drivers/pipes/pipe_common.c
@@ -42,6 +42,7 @@
 
 #include <nuttx/arch.h>
 #include <nuttx/kmalloc.h>
+#include <nuttx/lib/lib.h>
 #include <nuttx/semaphore.h>
 #include <nuttx/fs/fs.h>
 #include <nuttx/fs/ioctl.h>
@@ -105,9 +106,17 @@ FAR struct pipe_dev_s *pipecommon_allocdev(size_t bufsize)
   dev = kmm_zalloc(sizeof(struct pipe_dev_s));
   if (dev)
     {
+      /* Initialize the circular buffer */
+
+      if (circbuf_init(&dev->d_buffer, NULL, bufsize) < 0)
+        {
+          kmm_free(dev);
+          return NULL;
+        }
+
       /* Initialize the private structure */
 
-      nxrmutex_init(&dev->d_bflock);
+      rspin_lock_init(&dev->d_bflock);
       nxsem_init(&dev->d_rdsem, 0, 0);
       nxsem_init(&dev->d_wrsem, 0, 0);
       dev->d_bufsize = bufsize;
@@ -122,9 +131,10 @@ FAR struct pipe_dev_s *pipecommon_allocdev(size_t bufsize)
 
 void pipecommon_freedev(FAR struct pipe_dev_s *dev)
 {
-  nxrmutex_destroy(&dev->d_bflock);
+  DEBUGASSERT(!rspin_lock_is_locked(&dev->d_bflock));
   nxsem_destroy(&dev->d_rdsem);
   nxsem_destroy(&dev->d_wrsem);
+  circbuf_uninit(&dev->d_buffer);
   kmm_free(dev);
 }
 
@@ -136,7 +146,8 @@ int pipecommon_open(FAR struct file *filep)
 {
   FAR struct inode      *inode = filep->f_inode;
   FAR struct pipe_dev_s *dev   = inode->i_private;
-  int                    ret;
+  int                    ret   = OK;
+  irqstate_t             flags;
 
   DEBUGASSERT(dev != NULL);
 
@@ -145,24 +156,7 @@ int pipecommon_open(FAR struct file *filep)
    * the thread was canceled.
    */
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      ferr("ERROR: nxrmutex_lock failed: %d\n", ret);
-      return ret;
-    }
-
-  /* If d_buffer is not initialized, init it. */
-
-  if (!circbuf_is_init(&dev->d_buffer))
-    {
-      ret = circbuf_init(&dev->d_buffer, NULL, dev->d_bufsize);
-      if (ret < 0)
-        {
-          nxrmutex_unlock(&dev->d_bflock);
-          return ret;
-        }
-    }
+  flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
 
   dev->d_crefs++;
 
@@ -194,7 +188,7 @@ int pipecommon_open(FAR struct file *filep)
        * on the pipe.
        */
 
-      nxrmutex_unlock(&dev->d_bflock);
+      rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
 
       /* NOTE: d_wrsem is normally used to check if the write buffer is full
        * and wait for it being read and being able to receive more data. But,
@@ -218,16 +212,7 @@ int pipecommon_open(FAR struct file *filep)
        * signal or if the task is canceled.
        */
 
-      ret = nxrmutex_lock(&dev->d_bflock);
-      if (ret < 0)
-        {
-          ferr("ERROR: nxrmutex_lock failed: %d\n", ret);
-
-          /* Immediately close the pipe that we just opened */
-
-          pipecommon_close(filep);
-          return ret;
-        }
+      flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
     }
 
   /* If opened for reading, increment the count of reader on on the pipe
@@ -258,7 +243,7 @@ int pipecommon_open(FAR struct file *filep)
        * on the pipe.
        */
 
-      nxrmutex_unlock(&dev->d_bflock);
+      rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
 
       /* NOTE: d_rdsem is normally used when the read logic waits for more
        * data to be written.  But until the first writer has opened the
@@ -284,19 +269,10 @@ int pipecommon_open(FAR struct file *filep)
        * signal or if the task is canceled.
        */
 
-      ret = nxrmutex_lock(&dev->d_bflock);
-      if (ret < 0)
-        {
-          ferr("ERROR: nxrmutex_lock failed: %d\n", ret);
-
-          /* Immediately close the pipe that we just opened */
-
-          pipecommon_close(filep);
-          return ret;
-        }
+      flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
     }
 
-  nxrmutex_unlock(&dev->d_bflock);
+  rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
   return ret;
 }
 
@@ -308,7 +284,7 @@ int pipecommon_close(FAR struct file *filep)
 {
   FAR struct inode      *inode = filep->f_inode;
   FAR struct pipe_dev_s *dev   = inode->i_private;
-  int                    ret;
+  irqstate_t             flags;
 
   DEBUGASSERT(dev && dev->d_crefs > 0);
 
@@ -317,13 +293,7 @@ int pipecommon_close(FAR struct file *filep)
    * I've never seen anyone check that.
    */
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      /* The close will not be performed if the task was canceled */
-
-      return ret;
-    }
+  flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
 
   /* Decrement the number of references on the pipe.  Check if there are
    * still outstanding references to the pipe.
@@ -394,9 +364,9 @@ int pipecommon_close(FAR struct file *filep)
   else if (PIPE_IS_POLICY_0(dev->d_flags) ||
            circbuf_is_empty(&dev->d_buffer))
     {
-      /* Policy 0 or the buffer is empty ... deallocate the buffer now. */
+      /* Policy 0 or the buffer is empty ... Reset the buffer now. */
 
-      circbuf_uninit(&dev->d_buffer);
+      circbuf_reset(&dev->d_buffer);
 
       /* And reset all counts and indices */
 
@@ -410,13 +380,14 @@ int pipecommon_close(FAR struct file *filep)
 
       if (PIPE_IS_UNLINKED(dev->d_flags))
         {
+          rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
           pipecommon_freedev(dev);
           return OK;
         }
 #endif
     }
 
-  nxrmutex_unlock(&dev->d_bflock);
+  rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
   return OK;
 }
 
@@ -429,6 +400,7 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char 
*buffer, size_t len)
   FAR struct inode      *inode = filep->f_inode;
   FAR struct pipe_dev_s *dev   = inode->i_private;
   ssize_t                nread = 0;
+  irqstate_t             flags;
   int                    ret;
 
   DEBUGASSERT(dev);
@@ -440,15 +412,7 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char 
*buffer, size_t len)
 
   /* Make sure that we have exclusive access to the device structure */
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      /* May fail because a signal was received or if the task was
-       * canceled.
-       */
-
-      return ret;
-    }
+  flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
 
   /* If the pipe is empty, then wait for something to be written to it */
 
@@ -458,7 +422,7 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char 
*buffer, size_t len)
 
       if (dev->d_nwriters <= 0 && PIPE_IS_POLICY_0(dev->d_flags))
         {
-          nxrmutex_unlock(&dev->d_bflock);
+          rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
           return 0;
         }
 
@@ -466,23 +430,22 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char 
*buffer, size_t len)
 
       if (filep->f_oflags & O_NONBLOCK)
         {
-          nxrmutex_unlock(&dev->d_bflock);
+          rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
           return -EAGAIN;
         }
 
       /* Otherwise, wait for something to be written to the pipe */
 
-      nxrmutex_unlock(&dev->d_bflock);
+      rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
       ret = nxsem_wait(&dev->d_rdsem);
 
-      if (ret < 0 || (ret = nxrmutex_lock(&dev->d_bflock)) < 0)
+      if (ret < 0)
         {
-          /* May fail because a signal was received or if the task was
-           * canceled.
-           */
-
+          ferr("ERROR: nxsem_wait failed: %d\n", ret);
           return ret;
         }
+
+      flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
     }
 
   /* Then return whatever is available in the pipe (which is at least one
@@ -506,7 +469,7 @@ ssize_t pipecommon_read(FAR struct file *filep, FAR char 
*buffer, size_t len)
 
   pipecommon_wakeup(&dev->d_wrsem);
 
-  nxrmutex_unlock(&dev->d_bflock);
+  rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
   pipe_dumpbuffer("From PIPE:", buffer, nread);
   return nread;
 }
@@ -522,6 +485,7 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const 
char *buffer,
   FAR struct pipe_dev_s *dev      = inode->i_private;
   ssize_t                nwritten = 0;
   ssize_t                last;
+  irqstate_t             flags;
   int                    ret;
 
   DEBUGASSERT(dev);
@@ -551,15 +515,7 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const 
char *buffer,
 
   /* Make sure that we have exclusive access to the device structure */
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      /* May fail because a signal was received or if the task was
-       * canceled.
-       */
-
-      return ret;
-    }
+  flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
 
   /* Loop until all of the bytes have been written */
 
@@ -574,7 +530,7 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const 
char *buffer,
 
       if (dev->d_nreaders <= 0 && PIPE_IS_POLICY_0(dev->d_flags))
         {
-          nxrmutex_unlock(&dev->d_bflock);
+          rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
           return nwritten == 0 ? -EPIPE : nwritten;
         }
 
@@ -607,7 +563,7 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const 
char *buffer,
 
               /* Return the number of bytes written */
 
-              nxrmutex_unlock(&dev->d_bflock);
+              rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
               return len;
             }
         }
@@ -645,7 +601,7 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const 
char *buffer,
                   nwritten = -EAGAIN;
                 }
 
-              nxrmutex_unlock(&dev->d_bflock);
+              rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
               return nwritten;
             }
 
@@ -653,9 +609,9 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const 
char *buffer,
            * the pipe
            */
 
-          nxrmutex_unlock(&dev->d_bflock);
+          rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
           ret = nxsem_wait(&dev->d_wrsem);
-          if (ret < 0 || (ret = nxrmutex_lock(&dev->d_bflock)) < 0)
+          if (ret < 0)
             {
               /* Either call nxsem_wait may fail because a signal was
                * received or if the task was canceled.
@@ -663,6 +619,8 @@ ssize_t pipecommon_write(FAR struct file *filep, FAR const 
char *buffer,
 
               return nwritten == 0 ? (ssize_t)ret : nwritten;
             }
+
+          flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
         }
     }
 }
@@ -692,6 +650,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
   FAR const struct iovec *iov;
   size_t                  offset;
   size_t                  total;
+  irqstate_t              flags;
   int                     iovcnt;
   int                     ret;
 
@@ -719,11 +678,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
       iovcnt = uio->uio_iovcnt;
       offset = uio->uio_offset_in_iov;
 
-      ret = nxrmutex_lock(&dev->d_bflock);
-      if (ret < 0)
-        {
-          return ret;
-        }
+      flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
 
       last = 0;
       while (iovcnt > 0)
@@ -748,7 +703,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
 
           if (dev->d_nreaders <= 0 && PIPE_IS_POLICY_0(dev->d_flags))
             {
-              nxrmutex_unlock(&dev->d_bflock);
+              rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
               if (ntotal == 0)
                 {
                   return -EPIPE;
@@ -789,7 +744,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
 
                   pipecommon_wakeup(&dev->d_rdsem);
 
-                  nxrmutex_unlock(&dev->d_bflock);
+                  rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
                   uio_advance(uio, ntotal);
                   return ntotal;
                 }
@@ -815,7 +770,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
 
               if (filep->f_oflags & O_NONBLOCK)
                 {
-                  nxrmutex_unlock(&dev->d_bflock);
+                  rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
                   if (ntotal == 0)
                     {
                       return -EAGAIN;
@@ -829,7 +784,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
                * from the pipe.
                */
 
-              nxrmutex_unlock(&dev->d_bflock);
+              rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
               ret = nxsem_wait(&dev->d_wrsem);
               if (ret < 0)
                 {
@@ -846,21 +801,11 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
                   return ntotal;
                 }
 
-              ret = nxrmutex_lock(&dev->d_bflock);
-              if (ret < 0)
-                {
-                  if (ntotal == 0)
-                    {
-                      return (ssize_t)ret;
-                    }
-
-                  uio_advance(uio, ntotal);
-                  return ntotal;
-                }
+              flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
             }
         }
 
-      nxrmutex_unlock(&dev->d_bflock);
+      rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
       uio_advance(uio, ntotal);
       return ntotal;
     }
@@ -875,17 +820,13 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
       return -EMSGSIZE;
     }
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      return ret;
-    }
+  flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
 
   for (; ; )
     {
       if (dev->d_nreaders <= 0 && PIPE_IS_POLICY_0(dev->d_flags))
         {
-          nxrmutex_unlock(&dev->d_bflock);
+          rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
           return -EPIPE;
         }
 
@@ -896,7 +837,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
 
       if (filep->f_oflags & O_NONBLOCK)
         {
-          nxrmutex_unlock(&dev->d_bflock);
+          rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
           return -EAGAIN;
         }
 
@@ -905,18 +846,14 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
        * publish or to roll back here.
        */
 
-      nxrmutex_unlock(&dev->d_bflock);
+      rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
       ret = nxsem_wait(&dev->d_wrsem);
       if (ret < 0)
         {
           return ret;
         }
 
-      ret = nxrmutex_lock(&dev->d_bflock);
-      if (ret < 0)
-        {
-          return ret;
-        }
+      flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
     }
 
   /* Room for the whole request is guaranteed from here to the notify
@@ -951,7 +888,7 @@ ssize_t pipecommon_writev(FAR struct file *filep, FAR 
struct uio *uio)
 
   pipecommon_wakeup(&dev->d_rdsem);
 
-  nxrmutex_unlock(&dev->d_bflock);
+  rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
 
   uio_advance(uio, total);
   return total;
@@ -966,20 +903,17 @@ int pipecommon_poll(FAR struct file *filep, FAR struct 
pollfd_s *fds,
 {
   FAR struct inode      *inode = filep->f_inode;
   FAR struct pipe_dev_s *dev   = inode->i_private;
+  int                    ret   = OK;
   pollevent_t            eventset;
   pipe_ndx_t             nbytes;
-  int                    ret;
+  irqstate_t             flags;
   int                    i;
 
   DEBUGASSERT(dev && fds);
 
   /* Are we setting up the poll?  Or tearing it down? */
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      return ret;
-    }
+  flags = rspin_lock_irqsave_nopreempt(&dev->d_bflock);
 
   if (setup)
     {
@@ -1077,7 +1011,7 @@ int pipecommon_poll(FAR struct file *filep, FAR struct 
pollfd_s *fds,
     }
 
 errout:
-  nxrmutex_unlock(&dev->d_bflock);
+  rspin_unlock_irqrestore_nopreempt(&dev->d_bflock, flags);
   return ret;
 }
 
@@ -1090,6 +1024,7 @@ int pipecommon_ioctl(FAR struct file *filep, int cmd, 
unsigned long arg)
   FAR struct inode      *inode = filep->f_inode;
   FAR struct pipe_dev_s *dev   = inode->i_private;
   int                    ret   = -EINVAL;
+  irqstate_t             flags;
 
 #ifdef CONFIG_DEBUG_FEATURES
   /* Some sanity checking */
@@ -1100,11 +1035,7 @@ int pipecommon_ioctl(FAR struct file *filep, int cmd, 
unsigned long arg)
     }
 #endif
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      return ret;
-    }
+  flags = rspin_lock_irqsave(&dev->d_bflock);
 
   switch (cmd)
     {
@@ -1183,6 +1114,8 @@ int pipecommon_ioctl(FAR struct file *filep, int cmd, 
unsigned long arg)
       case PIPEIOC_SETSIZE:
         {
           size_t size = (size_t)arg;
+          FAR void *newbuf;
+          FAR void *oldbuf;
 
           if (size == 0)
             {
@@ -1191,13 +1124,26 @@ int pipecommon_ioctl(FAR struct file *filep, int cmd, 
unsigned long arg)
             }
 
           size = MIN(size, CONFIG_DEV_PIPE_MAXSIZE);
-          ret = circbuf_resize(&dev->d_buffer, size);
-          if (ret != 0)
+
+          if (size == dev->d_bufsize)
             {
+              ret = OK;
               break;
             }
 
+          rspin_unlock_irqrestore(&dev->d_bflock, flags);
+          newbuf = lib_malloc(size);
+          if (!newbuf)
+            {
+              return -ENOMEM;
+            }
+
+          flags = rspin_lock_irqsave(&dev->d_bflock);
+          oldbuf = circbuf_reinit(&dev->d_buffer, newbuf, size);
           dev->d_bufsize = size;
+          rspin_unlock_irqrestore(&dev->d_bflock, flags);
+          lib_free(oldbuf);
+          flags = rspin_lock_irqsave(&dev->d_bflock);
         }
         break;
 
@@ -1233,7 +1179,7 @@ int pipecommon_ioctl(FAR struct file *filep, int cmd, 
unsigned long arg)
         break;
     }
 
-  nxrmutex_unlock(&dev->d_bflock);
+  rspin_unlock_irqrestore(&dev->d_bflock, flags);
   return ret;
 }
 
@@ -1245,20 +1191,16 @@ int pipecommon_ioctl(FAR struct file *filep, int cmd, 
unsigned long arg)
 int pipecommon_unlink(FAR struct inode *inode)
 {
   FAR struct pipe_dev_s *dev;
-  int ret;
+  irqstate_t             flags;
 
   DEBUGASSERT(inode->i_private);
   dev = inode->i_private;
 
-  ret = nxrmutex_lock(&dev->d_bflock);
-  if (ret < 0)
-    {
-      return ret;
-    }
+  flags = rspin_lock_irqsave(&dev->d_bflock);
 
   if (dev->d_crefs <= 0)
     {
-      circbuf_uninit(&dev->d_buffer);
+      rspin_unlock_irqrestore(&dev->d_bflock, flags);
       pipecommon_freedev(dev);
       return OK;
     }
@@ -1266,7 +1208,7 @@ int pipecommon_unlink(FAR struct inode *inode)
   /* Mark the pipe unlinked */
 
   PIPE_UNLINK(dev->d_flags);
-  nxrmutex_unlock(&dev->d_bflock);
+  rspin_unlock_irqrestore(&dev->d_bflock, flags);
 
   return OK;
 }
diff --git a/drivers/pipes/pipe_common.h b/drivers/pipes/pipe_common.h
index d4bb8eaabf8..845d5359b69 100644
--- a/drivers/pipes/pipe_common.h
+++ b/drivers/pipes/pipe_common.h
@@ -28,7 +28,7 @@
  ****************************************************************************/
 
 #include <nuttx/config.h>
-#include <nuttx/mutex.h>
+#include <nuttx/spinlock.h>
 #include <nuttx/circbuf.h>
 #include <sys/types.h>
 
@@ -123,7 +123,7 @@ typedef uint8_t pipe_ndx_t;   /*  8-bit index */
 
 struct pipe_dev_s
 {
-  rmutex_t         d_bflock;      /* Used to serialize access to d_buffer and 
indices */
+  rspinlock_t      d_bflock;      /* Used to serialize access to d_buffer and 
indices */
   sem_t            d_rdsem;       /* Empty buffer - Reader waits for data 
write AND
                                    * block O_RDONLY open until there is at 
least one writer */
   sem_t            d_wrsem;       /* Full buffer - Writer waits for data read 
AND

Reply via email to