Page History

Do not send an uncaught signal to a thread to kill it because the signal kills the entire process rather than killing just the individual thread. This rule is a specific instance of recommendation SIG02-C. Avoid using signals to implement normal functionality.Calling the signal() function in a multithreaded program is undefined behavior. (See undefined behavior 135.)

Noncompliant Code Example

This code uses the pthread_killnoncompliant code example invokes the signal() function to send a SIGKILL signal to the created thread. The thread receives the signal and the entire process is terminated.from a multithreaded program:

Code Block

bgColor	#ffcccc
lang	c

#include <signal.h>
#include <stddef.h>
#include <threads.h>
 
volatile sig_atomic_t flag = 0;

void funchandler(voidint *foosignum) {
  flag = 1;
}

/* Execution of threadRuns until user sends SIGUSR1 */
}

int mainfunc(void *data) {
  while int result;(!flag) {
  pthread_t thread;

 /* if ((result = pthread_create(&thread, NULL, func, 0)) != 0... */
  }
  return 0;
}

int main(void) {
  signal(SIGUSR1, handler); /* HandleUndefined Errorbehavior */
  thrd_t tid;
  }
  if ((resultthrd_success != pthreadthrd_kill(threadcreate(&tid, func, SIGKILL)) != 0NULL)) {
    /* Handle Errorerror */
  }

  /* Continue executing until the signal kills the process */
... */
  return 0;
}

NOTE: The SIGUSR1 signal value is not defined in the C Standard; consequently, this is not a C-compliant code example.

Compliant Solution

This code instead uses the pthread_cancel() function to terminate the thread. The thread continues to run until it reaches a cancellation point. See [Open Group 2004] for lists of functions that are required and allowed to be cancellation points. If the cancellation type is set to asynchronous, the thread is terminated immediately. However, POSIX only requires the pthread_cancel(), pthread_setcancelstate(), and pthread_setcanceltype() functions to be async-cancel safe. An application that calls other POSIX functions with asynchronous cancellation enabled is non-conforming. Consequently, we recommend disallowing asynchronous cancellation, as expalined by rule POS47-C. Do not use threads that can be cancelled asynchronously.compliant solution uses an object of type atomic_bool to indicate when the child thread should terminate its loop:

Code Block

bgColor	#ccccff
lang	c

#include <stdatomic.h>
#include <stdbool.h>
#include <stddef.h>
#include <threads.h>
 
atomic_bool flag = ATOMIC_VAR_INIT(false);

int func(void *data) {
  while (!flag

Code Block

bgColor	#ccccff


void func(void *foo) {
    /* ... */
 Execution }
 of threadreturn */0;
}

int main(void) {
  intthrd_t resulttid;
  pthread_t thread;

  if ((resultthrd_success != pthreadthrd_create(&threadtid, NULL, func, 0NULL)) != 0) {
    /* Handle Errorerror */
  }
  if ((result = pthread_cancel(thread)) != 0) {/* ... */
  /* Set /*flag Handlewhen Errordone */
  }

flag  /* Continue executing */= true;

  return 0;
}

Exceptions

CON37-C-EX1: Implementations such as POSIX that provide defined behavior when multithreaded programs use custom signal handlers are exempt from this rule [IEEE Std 1003.1-2013].

Risk Assessment

Sending the signal to a process causes it to be abnormally terminatedMixing signals and threads causes undefined behavior 135.

Rule	Severity	Likelihood	Detectable

Remediation Cost

Repairable	Priority	Level

POS44-C

low

probable

low

P6

L2

Bibliography

Wiki Markup

\[[OpenBSD|AA. Bibliography#OpenBSD]\] [{{signal()}} Man Page|http://www.openbsd.org/cgi-bin/man.cgi?query=signal]
\[[MKS|AA. Bibliography#MKS]\] [{{pthread_cancel()}} Man Page|http://www.mkssoftware.com/docs/man3/pthread_cancel.3.asp]
\[[Open Group 2004|AA. Bibliography#Open Group 04]\] [Threads Overview|http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_09.html]

CON37-C

Low

Probable

Yes

No

P4

L3