Page History

UNDER CONSTRUCTION

The cnd_wait() and cnd_timedwait() functions temporarily The wait(), wait_for(), and wait_until() member functions of the std::condition_variable class temporarily cede possession of a mutex so that other threads that may be requesting the mutex can proceed. These functions must always be called from code that is protected by locking a mutex. The waiting thread resumes execution only after it has been notified, generally as the result of the invocation of the cndnotify_signalone() or cndnotify_broadcastall() function  member functions invoked by another thread.

The cnd_wait() function must be invoked from a loop that checks whether a condition predicate holds. A condition predicate is an expression constructed from the variables of a function that must be true for a thread to be allowed to continue execution. The thread pauses execution , via cnd_waitvia wait(), wait_for(), cndwait_timedwaituntil(), or some other mechanism, and is resumed later, presumably when the condition predicate is true and the thread is notified.

#include <threads.h><condition_variable>
#include <stdbool.h><mutex>
 
extern bool until_finish(void);
extern mtx_t lockstd::mutex m;
extern cnd_tstd::condition_variable condition;
 
void func(void) {
  if (thrd_success != mtx_lock(&lock)) {
    /* Handle error */
}

std::unique_lock<std::mutex> lk(m);

  while (until_finish()) {  //* Predicate does not hold */.
  if (thrd_success != cnd_condition.wait(&condition, &lock)) {lk);
  }
 
 /* Handle error */
  }
}
 
/* Resume when condition holds */

  if (thrd_success != mtx_unlock(&lock)) {
    /* Handle error */
  }
.
}

The notification mechanism notifies the waiting thread and allows it to check its condition predicate. The invocation of cndnotify_broadcastall() in another thread cannot precisely determine which waiting thread will be resumed. Condition predicate statements allow notified threads to determine whether they should resume upon receiving the notification. 

...

This thread pauses execution using cnd_wait() and resumes when notified, presumably when the list has elements to be consumed. It is possible for the thread to be notified even if the list is still empty, perhaps because the notifying thread used cndnotify_broadcastall(), which notifies all threads. Notification using cndnotify_broadcastall() is frequently preferred over using cndnotify_signalone(). (see CON38See CON55-CCPP. Preserve thread safety and liveness when using condition variables for more information.).

Note that a condition A condition predicate is typically the negation of the condition expression in the loop. In this noncompliant code example, the condition predicate for removing an element from a linked list is (list->next != NULLnullptr), whereas the condition expression for the while loop condition is (list->next == NULLnullptr).

This noncompliant code example nests the cnd_call to wait() function inside  inside an if block and consequently fails to check the condition predicate after the notification is received. If the notification was spurious or malicious, the thread would wake up prematurely.

#include <stddef.h><condition_variable>
#include <threads.h><mutex>
  
struct node_tNode {
  void *node;
  struct node_tNode *next;
};
  
structstatic node_tNode list;
static mtx_t lockstd::mutex m;
static cnd_tstd::condition_variable condition;
  
void consume_list_element(voidstd::condition_variable &condition) {
  if (thrd_success != mtx_lock(&lock)) {
    /* Handle error */
  }
 std::unique_lock<std::mutex> lk(m);
  
  if (list.next == NULLnullptr) {
    if (thrd_success != cnd_wait(&condition, &lock)) {
      /* Handle error */
    }
  }

  /*condition.wait(lk);
  }
 
  // Proceed when condition holds */

  if (thrd_success != mtx_unlock(&lock)) {
    /* Handle error */
  }.
}

Compliant Solution (Explicit loop with predicate)

This compliant solution calls the cnd_wait() function  member function from within a while loop to check the condition both before and after the call to cnd_wait():.

#include <stddef.h><condition_variable>
#include <threads.h><mutex>
  
struct node_tNode {
  void *node;
  struct node_tNode *next;
};
  
structstatic node_tNode list;
static mtx_t lockstd::mutex m;
static cnd_tstd::condition_variable condition;
  
void consume_list_element(void) {
  if (thrd_success != mtx_lock(&lock)) {
    /* Handle error */
  }
 
  std::unique_lock<std::mutex> lk(m);
  
  while (list.next == NULLnullptr) {
    condition.wait(lk);
  }
  if (thrd_success != cnd_wait(&condition, &lock)) {
      /* Handle error */
    }
  }

  /* Proceed when condition holds */

  if (thrd_success != mtx_unlock(&lock)) {
    /* Handle error */
  }
  // Proceed when condition holds.
}

Compliant Solution (Implicit loop with lambda predicate)

The std::condition_variable::wait() function has an overloaded form that accepts a function object representing the predicate. This form of wait() behaves as if it were implemented as while (!pred()) wait(lock);. This compliant solution uses a lambda as a predicate and passes it to the wait() function. The predicate is expected to return true when it is safe to proceed, which reverses the predicate logic from the compliant solution using an explicit loop predicate.

#include <condition_variable>
#include <mutex>
 
struct Node {
  void *node;
  struct Node *next;
};
  
static Node list;
static std::mutex m;
static std::condition_variable condition;
  
void consume_list_element() {
  std::unique_lock<std::mutex> lk(m);
 
  condition.wait(lk, []{ return list.next; });
  // Proceed when condition holds.
}

Failure to enclose calls to the cnd_wait() or cnd_timedwait() functions wait(), wait_for(), or wait_until() member functions inside a while loop can lead to indefinite blocking and denial of service (DoS).

Automated Detection

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website. 

Related Guidelines

Bibliography

...

...

Image Modified Image Modified Image Modified