What is the difference between sigaction and signal?

by

Use sigaction() unless you’ve got very compelling reasons not to do so.

The signal() interface has antiquity (and hence availability) in its favour, and it is defined in the C standard. Nevertheless, it has a number of undesirable characteristics that sigaction() avoids – unless you use the flags explicitly added to sigaction() to allow it to faithfully simulate the old signal() behaviour.

  1. The signal() function does not (necessarily) block other signals from arriving while the current handler is executing; sigaction() can block other signals until the current handler returns.
  2. The signal() function (usually) resets the signal action back to SIG_DFL (default) for almost all signals. This means that the signal() handler must reinstall itself as its first action. It also opens up a window of vulnerability between the time when the signal is detected and the handler is reinstalled during which if a second instance of the signal arrives, the default behaviour (usually terminate, sometimes with prejudice – aka core dump) occurs.
  3. The exact behaviour of signal() varies between systems — and the standards permit those variations.

These are generally good reasons for using sigaction() instead of signal(). However, the interface of sigaction() is undeniably more fiddly.

Whichever of the two you use, do not be tempted by the alternative signal interfaces such as
sighold(),
sigignore(),
sigpause() and
sigrelse().
They are nominally alternatives to sigaction(), but they are only barely standardized and are present in POSIX for backwards compatibility rather than for serious use. Note that the POSIX standard says their behaviour in multi-threaded programs is undefined.

Multi-threaded programs and signals is a whole other complicated story. AFAIK, both signal() and sigaction() are OK in multi-threaded applications.

Cornstalks observes:

The Linux man page for signal() says:

  The effects of signal() in a multi-threaded process are unspecified.

Thus, I think sigaction() is the only that can be used safely in a multi-threaded process.

That’s interesting. The Linux manual page is more restrictive than POSIX in this case. POSIX specifies for signal():

If the process is multi-threaded, or if the process is single-threaded and a signal handler is executed other than as the result of:

  • The process calling abort(), raise(), kill(), pthread_kill(), or sigqueue() to generate a signal that is not blocked
  • A pending signal being unblocked and being delivered before the call that unblocked it returns

the behavior is undefined if the signal handler refers to any object other than errno with static storage duration other than by assigning a value to an object declared as volatile sig_atomic_t, or if the signal handler calls any function defined in this standard other than one of the functions listed in Signal Concepts.

So POSIX clearly specifies the behaviour of signal() in a multi-threaded application.

Nevertheless, sigaction() is to be preferred in essentially all circumstances — and portable multi-threaded code should use sigaction() unless there’s an overwhelming reason why it can’t (such as “only use functions defined by Standard C” — and yes, C11 code can be multi-threaded). Which is basically what the opening paragraph of this answer also says.

More Related Contents:

  1. Checking if errno != EINTR: what does it mean?
  2. How to Raise SIGTERM in Windows [closed]
  3. How to prevent SIGPIPEs (or handle them properly)
  4. Catch Ctrl-C in C
  5. What is the equivalent to Posix popen() in the Win32 API?
  6. How to capture Control+D signal?
  7. POSIX threads and signals
  8. Segmentation fault handling
  9. Does printf always flush the buffer on encountering a newline?
  10. Signal handling with multiple threads in Linux
  11. POSIX API call to list all the pthreads running in a process
  12. Are there any platforms where using structure copy on an fd_set (for select() or pselect()) causes problems?
  13. Is there a way to flush a POSIX socket?
  14. What is the proper #include for the function ‘sleep()’?
  15. How does sig_atomic_t actually work?
  16. How to redirect the output back to the screen after freopen(“out.txt”, “a”, stdout)
  17. Create statically-linked binary that uses getaddrinfo?
  18. Simple Signals – C programming and alarm function
  19. How to make parent wait for all child processes to finish?
  20. Does linux allow any system call to be made from signal handlers?
  21. Redirect stdout to a file
  22. Providing/passing argument to signal handler
  23. Is it possible (and safe) to make an accepting socket non-blocking?
  24. Posix regular expression non-greedy
  25. Difference between C standard library and C POSIX library
  26. Linux: Why is sig_atomic_t typedef’ed to int?
  27. executing default signal handler
  28. How do I get tcsetpgrp() to work in C?
  29. longjmp() from signal handler
  30. Debugging child process after fork (follow-fork-mode child configured)

Leave a Comment