Add logic to disable cancellation points within the OS. This is useful when...

Add logic to disable cancellation points within the OS.  This is useful when an internal OS function that is NOT a cancellation point calls an OS function which is a cancellation point.  In that case, irrecoverable states may occur if the cancellation is within the OS.

sched/pthread/pthread.h

@@ -121,6 +121,14 @@ void pthread_mutex_inconsistent(FAR struct pthread_tcb_s *tcb);
 #  define pthread_mutex_give(m)    pthread_givesemaphore(&(m)->sem)
 #endif
 
+#ifdef CONFIG_CANCELLATION_POINTS
+uint16_t pthread_disable_cancel(void);
+void pthread_enable_cancel(uint16_t oldstate);
+#else
+#  define pthread_disable_cancel() (0)
+#  define pthread_enable_cancel(s) UNUSED(s)
+#endif
+
 #ifdef CONFIG_PTHREAD_MUTEX_TYPES
 int pthread_mutexattr_verifytype(int type);
 #endif

sched/pthread/pthread_condtimedwait.c

@@ -167,9 +167,10 @@ int pthread_cond_timedwait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex,
                            FAR const struct timespec *abstime)
 {
   FAR struct tcb_s *rtcb = this_task();
+  irqstate_t flags;
+  uint16_t oldstate;
   int ticks;
   int mypid = (int)getpid();
-  irqstate_t flags;
   int ret = OK;
   int status;
 
@@ -316,7 +317,11 @@ int pthread_cond_timedwait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex,
                   /* Reacquire the mutex (retaining the ret). */
 
                   sinfo("Re-locking...\n");
+
+                  oldstate = pthread_disable_cancel();
                   status = pthread_mutex_take(mutex, false);
+                  pthread_enable_cancel(oldstate);
+
                   if (status == OK)
                     {
                       mutex->pid = mypid;

sched/pthread/pthread_condwait.c

@@ -95,6 +95,8 @@ int pthread_cond_wait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex)
     }
   else
     {
+      uint16_t oldstate;
+
       /* Give up the mutex */
 
       sinfo("Give up mutex / take cond\n");
@@ -117,12 +119,17 @@ int pthread_cond_wait(FAR pthread_cond_t *cond, FAR pthread_mutex_t *mutex)
 
       /* Reacquire the mutex.
        *
-       * REVISIT: When cancellation points are enabled, we will almost
-       * certainly hold the mutex when the pthread is canceled.
+       * When cancellation points are enabled, we need to
+       * hold the mutex when the pthread is canceled and
+       * cleanup handlers, if any, are entered.
        */
 
       sinfo("Reacquire mutex...\n");
+
+      oldstate = pthread_disable_cancel();
       status = pthread_mutex_take(mutex, false);
+      pthread_enable_cancel(oldstate);
+
       if (ret == OK)
         {
           /* Report the first failure that occurs */

sched/pthread/pthread_mutex.c

@@ -95,8 +95,8 @@ static void pthread_mutex_add(FAR struct pthread_mutex_s *mutex)
  *   mutex to the list of mutexes held by this thread.
  *
  * Parameters:
- *  mutex - The mux to be locked
- *  intr  - false: ignore EINTR errors when locking; true tread EINTR as
+ *  mutex - The mutex to be locked
+ *  intr  - false: ignore EINTR errors when locking; true treat EINTR as
  *          other errors by returning the errno value
  *
  * Return Value:
@@ -126,15 +126,11 @@ int pthread_mutex_take(FAR struct pthread_mutex_s *mutex, bool intr)
       else
         {
           /* Take semaphore underlying the mutex.  pthread_takesemaphore
-           * returns zero on success and a positive errno value on failue.
+           * returns zero on success and a positive errno value on failure.
            */
 
           ret = pthread_takesemaphore(&mutex->sem, intr);
-          if (ret != OK)
-            {
-              ret = get_errno();
-            }
-          else
+          if (ret == OK)
             {
               /* Check if the holder of the mutex has terminated without
                * releasing.  In that case, the state of the mutex is
@@ -169,8 +165,8 @@ int pthread_mutex_take(FAR struct pthread_mutex_s *mutex, bool intr)
  *   mutex to the list of mutexes held by this thread.
  *
  * Parameters:
- *  mutex - The mux to be locked
- *  intr  - false: ignore EINTR errors when locking; true tread EINTR as
+ *  mutex - The mutex to be locked
+ *  intr  - false: ignore EINTR errors when locking; true treat EINTR as
  *          other errors by returning the errno value
  *
  * Return Value:
@@ -283,3 +279,70 @@ int pthread_mutex_give(FAR struct pthread_mutex_s *mutex)
   return ret;
 }
 
+/****************************************************************************
+ * Name: pthread_disable_cancel() and pthread_enable_cancel()
+ *
+ * Description:
+ *   Temporarily disable cancellation and return old cancel state, which
+ *   can later be restored.  This is useful when a cancellation point
+ *   function is called from within the OS by a non-cancellation point:
+ *   In certain such cases, we need to defer the cancellation to prevent
+ *   bad things from happening.
+ *
+ * Parameters:
+ *   saved cancel flags for pthread_enable_cancel()
+ *
+ * Return Value:
+ *   old cancel flags for pthread_disable_cancel()
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_CANCELLATION_POINTS
+uint16_t pthread_disable_cancel(void)
+{
+   FAR struct pthread_tcb_s *tcb = (FAR struct pthread_tcb_s *)this_task();
+   irqstate_t flags;
+   uint16_t old;
+
+   /* We need perform the following operations from within a critical section
+    * because it can compete with interrupt level activity.
+    */
+
+   flags = enter_critical_section();
+   old = tcb->cmn.flags & (TCB_FLAG_CANCEL_PENDING | TCB_FLAG_NONCANCELABLE);
+   tcb->cmn.flags &= ~(TCB_FLAG_CANCEL_PENDING | TCB_FLAG_NONCANCELABLE);
+   leave_critical_section(flags);
+   return old;
+}
+
+void pthread_enable_cancel(uint16_t cancelflags)
+{
+   FAR struct pthread_tcb_s *tcb = (FAR struct pthread_tcb_s *)this_task();
+   irqstate_t flags;
+
+   /* We need perform the following operations from within a critical section
+    * because it can compete with interrupt level activity.
+    */
+
+   flags = enter_critical_section();
+   tcb->cmn.flags |= cancelflags;
+
+   /* What should we do if there is a pending cancellation?
+    *
+    * If the thread is executing with deferred cancellation, we need do
+    * nothing more; the cancellation cannot occur until the next
+    * cancellation point.
+    *
+    * However, if the thread is executing in asynchronous cancellation mode,
+    * then we need to terminate now by simply calling pthread_exit().
+    */
+
+   if ((tcb->cmn.flags & TCB_FLAG_CANCEL_DEFERRED) == 0 &&
+       (tcb->cmn.flags & TCB_FLAG_CANCEL_PENDING) != 0)
+     {
+       pthread_exit(NULL);
+     }
+
+   leave_critical_section(flags);
+}
+#endif /* CONFIG_CANCELLATION_POINTS */