Check return from nxsem_wait_initialize()

Resolution of Issue 619 will require multiple steps, this part of the first step in that resolution:  Every call to nxsem_wait_uninterruptible() must handle the return value from nxsem_wait_uninterruptible properly.  This commit is only for rwbuffer.c and those files under drivers/serial, drivers/timers, and drivers/usbdev.

This commit completes that step for all of the files under drivers/.  Still remaining:  All of the files under arch/.

drivers/rwbuffer.c

@@ -63,9 +63,37 @@
  * Name: rwb_semtake
  ****************************************************************************/
 
-static void rwb_semtake(FAR sem_t *sem)
+static int rwb_semtake(FAR sem_t *sem)
 {
-  nxsem_wait_uninterruptible(sem);
+  return nxsem_wait_uninterruptible(sem);
+}
+
+/****************************************************************************
+ * Name: rwb_forcetake
+ ****************************************************************************/
+
+static int rwb_forcetake(FAR sem_t *sem)
+{
+  int result;
+  int ret = OK;
+
+  do
+    {
+      result = rwb_semtake(sem);
+
+      /* The only expected failure is if the thread is canceled */
+
+      DEBUGASSERT(result == OK || result == -ECANCELED);
+      if (ret == OK && result < 0)
+        {
+          /* Remember the first error */
+
+          ret = result;
+        }
+    }
+  while (result < 0);
+
+  return ret;
 }
 
 /****************************************************************************
@@ -166,7 +194,7 @@ static void rwb_wrtimeout(FAR void *arg)
    * worker thread.
    */
 
-  rwb_semtake(&rwb->wrsem);
+  rwb_forcetake(&rwb->wrsem);
   rwb_wrflush(rwb);
   rwb_semgive(&rwb->wrsem);
 }
@@ -394,7 +422,11 @@ int rwb_invalidate_writebuffer(FAR struct rwbuffer_s *rwb,
 
       finfo("startblock=%d blockcount=%p\n", startblock, blockcount);
 
-      rwb_semtake(&rwb->wrsem);
+      ret = rwb_semtake(&rwb->wrsem);
+      if (ret < 0)
+        {
+          return ret;
+        }
 
       /* Now there are five cases:
        *
@@ -531,7 +563,11 @@ int rwb_invalidate_readahead(FAR struct rwbuffer_s *rwb,
 
       finfo("startblock=%d blockcount=%p\n", startblock, blockcount);
 
-      rwb_semtake(&rwb->rhsem);
+      ret = rwb_semtake(&rwb->rhsem);
+      if (ret < 0)
+        {
+          return ret;
+        }
 
       /* Now there are five cases:
        *
@@ -763,9 +799,14 @@ static ssize_t rwb_read_(FAR struct rwbuffer_s *rwb, off_t startblock,
     {
       size_t remaining;
 
+      ret = nxsem_wait(&rwb->rhsem);
+      if (ret < 0)
+        {
+          return (ssize_t)ret;
+        }
+
       /* Loop until we have read all of the requested blocks */
 
-      rwb_semtake(&rwb->rhsem);
       for (remaining = nblocks; remaining > 0; )
         {
           /* Is there anything in the read-ahead buffer? */
@@ -852,9 +893,14 @@ ssize_t rwb_read(FAR struct rwbuffer_s *rwb, off_t startblock,
 
   if (rwb->wrmaxblocks > 0)
     {
+      ret = nxsem_wait(&rwb->wrsem);
+      if (ret < 0)
+        {
+          return (ssize_t)ret;
+        }
+
       /* If the write buffer overlaps the block(s) requested */
 
-      rwb_semtake(&rwb->wrsem);
       if (rwb_overlap(rwb->wrblockstart, rwb->wrnblocks, startblock,
                       nblocks))
         {
@@ -924,7 +970,12 @@ ssize_t rwb_write(FAR struct rwbuffer_s *rwb, off_t startblock,
        * streaming applications.
        */
 
-      rwb_semtake(&rwb->rhsem);
+      ret = nxsem_wait(&rwb->rhsem);
+      if (ret < 0)
+        {
+          return (ssize_t)ret;
+        }
+
       if (rwb_overlap(rwb->rhblockstart, rwb->rhnblocks, startblock,
                       nblocks))
         {
@@ -958,7 +1009,12 @@ ssize_t rwb_write(FAR struct rwbuffer_s *rwb, off_t startblock,
         {
           /* First flush the cache */
 
-          rwb_semtake(&rwb->wrsem);
+          ret = nxsem_wait(&rwb->wrsem);
+          if (ret < 0)
+            {
+              return (ssize_t)ret;
+            }
+
           rwb_wrflush(rwb);
           rwb_semgive(&rwb->wrsem);
 
@@ -970,7 +1026,12 @@ ssize_t rwb_write(FAR struct rwbuffer_s *rwb, off_t startblock,
         {
           /* Buffer the data in the write buffer */
 
-          rwb_semtake(&rwb->wrsem);
+          ret = nxsem_wait(&rwb->wrsem);
+          if (ret < 0)
+            {
+              return (ssize_t)ret;
+            }
+
           ret = rwb_writebuffer(rwb, startblock, nblocks, wrbuffer);
           rwb_semgive(&rwb->wrsem);
         }
@@ -1036,7 +1097,12 @@ int rwb_mediaremoved(FAR struct rwbuffer_s *rwb)
 #ifdef CONFIG_DRVR_WRITEBUFFER
   if (rwb->wrmaxblocks > 0)
     {
-      rwb_semtake(&rwb->wrsem);
+      ret = rwb_semtake(&rwb->wrsem);
+      if (ret < 0)
+        {
+          return ret;
+        }
+
       rwb_resetwrbuffer(rwb);
       rwb_semgive(&rwb->wrsem);
     }
@@ -1045,7 +1111,12 @@ int rwb_mediaremoved(FAR struct rwbuffer_s *rwb)
 #ifdef CONFIG_DRVR_READAHEAD
   if (rwb->rhmaxblocks > 0)
     {
-      rwb_semtake(&rwb->rhsem);
+      ret = rwb_semtake(&rwb->rhsem);
+      if (ret < 0)
+        {
+          return ret;
+        }
+
       rwb_resetrhbuffer(rwb);
       rwb_semgive(&rwb->rhsem);
     }
@@ -1102,12 +1173,14 @@ int rwb_invalidate(FAR struct rwbuffer_s *rwb,
 #ifdef CONFIG_DRVR_WRITEBUFFER
 int rwb_flush(FAR struct rwbuffer_s *rwb)
 {
-  rwb_semtake(&rwb->wrsem);
+  int ret;
+
+  ret = rwb_forcetake(&rwb->wrsem);
   rwb_wrcanceltimeout(rwb);
   rwb_wrflush(rwb);
   rwb_semgive(&rwb->wrsem);
 
-  return OK;
+  return ret;
 }
 #endif