POS47-C. Do not use threads that can be cancelled asynchronously

In threading, pthreads have the option of being set to cancel immediately or defer until a specific cancellation point. Canceling asynchronously (immediately) is dangerous, however, because most threads are in fact not safe to cancel immediately.

The [IEEE standards page] states that:

only functions that are cancel-safe may be called from a thread that is asynchronously cancelable.

Canceling asynchronously would follow the same route as passing a signal in to the thread to kill it, thus posing similarities to POS44-C. Do not use signals to terminate threads, which is strongly related to SIG02-C. Avoid using signals to implement normal functionality. These expand on the dangers of canceling a thread suddenly as this can create a data race condition.

Noncompliant Code Example

In this noncompliant code example the worker thread is doing something as simple as swapping a and b repeatedly.

This code uses one lock. The init_lock mutex is used to ensure that the worker thread is initialized safely, because the worker thread notifies the main thread once it has set its cancellation policy.

/* We need no mutex on these variables. They are initiailized by the main thread,
   then managed exclusively by the worker thread. Finally after the worker thread
   is cancelled, they are once again accessed by the main thread. */
volatile int a, b;

/* Lock to enable worker thread to initialize safely */
pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t init_lock_sig = PTHREAD_COND_INITIALIZER;

void* worker_thread(void* dummy) {
  int i, c;
  int result;

  /* Set the cancelability flag while holding init lock. */
  if ((result = pthread_mutex_lock(&init_lock)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&i)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_cond_signal(&init_lock_sig)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_mutex_unlock(&init_lock)) != 0) {
    /* Handle error */
  }

  while (1) {
    c = b;
    b = a;
    a = c;

    /* now we're safe to cancel, creating cancel point */
    pthread_testcancel();
  }
  return NULL;
}


int main(void) {
  int result;
  a = 5;
  b = 10;
  pthread_t worker;

  /* Creates thread while init_lock is held. This guarantees that we
     don't continue until worker thread is safely initialized. */
  if ((result = pthread_mutex_lock(&init_lock)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_create( &worker, NULL, worker_thread, NULL)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_cond_wait( &init_lock_sig, &init_lock)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_mutex_unlock(&init_lock)) != 0) {
    /* Handle error */
  }

  /* .. Do stuff...meanwhile worker thread runs for some time */

  /* Cancel worker thread, and wait for it to finish before continuing */
  if ((result = pthread_cancel(worker)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_join(worker, 0)) != 0) {
    /* Handle error */
  }

  printf("a: %i | b: %i\n", a, b); /* a should always be different from b */

  /* Clean up */
  if ((result = pthread_mutex_destroy(&init_lock)) != 0) {
    /* Handle error */
  }
  if ((result = pthread_cond_destroy(&init_lock_sig)) != 0) {
    /* Handle error */
  }
  return 0;
}

This code is thread-safe in that it invokes no undefined behavior. However, this program can still create a race condition, because an asynchronous cancel can happen at any time. For instance, the worker thread could be cancelled right before the last line (a = c) and thereby lose the old value of b. Consequently the main thread might print that a and b have the same value.

Compliant Solution

From [IEEE standards page]:

The cancelability state and type of any newly created threads, including the thread in which main() was first invoked, shall be PTHREAD_CANCEL_ENABLE and PTHREAD_CANCEL_DEFERRED respectively.

Since the default condition according to the IEEE standards for POSIX is PTHREAD_CANCEL_DEFERRED, one would simply not set cancel type for the compliant solution.

However, since not all compilers are necessarily guaranteed to follow standards, you should also explicitly call pthread_setcanceltype() with PTHREAD_CANCEL_DEFERRED. All remaining code is identical to the noncompliant example.

void* worker_thread(void* dummy) {
  /* ... */
  if ((result = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,&i)) != 0) {
    /* handle error */
  }
  /* ... */
}

Since this code limits cancellation of the worker thread to the end of the while loop, the worker thread can preserve the data invariant that a == b. Consequently, the program might print that a and b are both 5, or they are both 10, but they will always be revealed to have the same value when the worker thread is cancelled.

Risk Assessment

Incorrectly using threads that asynchronously cancel may result in silent corruption, resource leaks and, in the worst case, unpredictable interactions.

Automated Detection

TODO

Related Vulnerabilities

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

Other Languages

In Java, similar reasoning resulted in the deprecation of Thread.stop() and appears in the Java Secure Coding Standard as [CON24-J. Do not use Thread.stop() to terminate threads] .

References

[[MKS]] pthread_cancel() Man Page
[[Open Group 04]] Threads Overview