W skrócie:
sigaction()
jest dobry i dobrze zdefiniowany, ale jest funkcją Linuksa, więc działa tylko w Linuksie. signal()
jest zły i słabo zdefiniowany, ale jest standardową funkcją C, więc działa na wszystkim.
Co na ten temat mają do powiedzenia strony podręcznika Linux?
man 2 signal
(zobacz tutaj online ) stwierdza:
Zachowanie signal () różni się w różnych wersjach systemu UNIX, a także w przeszłości różniło się w różnych wersjach Linuksa. Unikaj jego używania: używaj sigaction(2)
zamiast tego. Zobacz przenośność poniżej.
Przenośność Jedynym przenośnym zastosowaniem signal () jest ustawienie dyspozycji sygnału na SIG_DFL lub SIG_IGN. Semantyka użycia signal () do ustanowienia programu obsługi sygnału różni się w różnych systemach (a POSIX.1 wyraźnie zezwala na tę odmianę); nie używaj go w tym celu.
Innymi słowy: nie używaj signal()
. Użyj sigaction()
zamiast tego!
Co myśli GCC?
Uwaga dotycząca zgodności: Jak wspomniano powyżej w przypadku signal
, należy unikać tej funkcji, gdy jest to możliwe. sigaction
jest metodą preferowaną.
Źródło: https://www.gnu.org/software/libc/manual/html_node/Basic-Signal-Handling.html#Basic-Signal-Handling
Tak więc, jeśli zarówno Linux, jak i GCC mówią, żeby nie używać signal()
, ale używać sigaction()
zamiast tego, nasuwa się pytanie: jak u licha używamy tej mylącej sigaction()
rzeczy !?
Przykłady użycia:
Przeczytaj DOSKONAŁY signal()
przykład GCC tutaj: https://www.gnu.org/software/libc/manual/html_node/Basic-Signal-Handling.html#Basic-Signal-Handling
I ich DOSKONAŁY sigaction()
przykład tutaj: https://www.gnu.org/software/libc/manual/html_node/Sigaction-Function-Example.html
Po przeczytaniu tych stron wymyśliłem następującą technikę sigaction()
:
1. sigaction()
, ponieważ jest to właściwy sposób dołączania obsługi sygnału, jak opisano powyżej:
#include <errno.h> // errno
#include <signal.h> // sigaction()
#include <stdio.h> // printf()
#include <string.h> // strerror()
#define LOG_LOCATION __FILE__, __LINE__, __func__ // Format: const char *, unsigned int, const char *
#define LOG_FORMAT_STR "file: %s, line: %u, func: %s: "
/// @brief Callback function to handle termination signals, such as Ctrl + C
/// @param[in] signal Signal number of the signal being handled by this callback function
/// @return None
static void termination_handler(const int signal)
{
switch (signal)
{
case SIGINT:
printf("\nSIGINT (%i) (Ctrl + C) signal caught.\n", signal);
break;
case SIGTERM:
printf("\nSIGTERM (%i) (default `kill` or `killall`) signal caught.\n", signal);
break;
case SIGHUP:
printf("\nSIGHUP (%i) (\"hang-up\") signal caught.\n", signal);
break;
default:
printf("\nUnk signal (%i) caught.\n", signal);
break;
}
// DO PROGRAM CLEANUP HERE, such as freeing memory, closing files, etc.
exit(signal);
}
/// @brief Set a new signal handler action for a given signal
/// @details Only update the signals with our custom handler if they are NOT set to "signal ignore" (`SIG_IGN`),
/// which means they are currently intentionally ignored. GCC recommends this "because non-job-control
/// shells often ignore certain signals when starting children, and it is important for children
/// to respect this." See
/// https://www.gnu.org/software/libc/manual/html_node/Basic-Signal-Handling.html#Basic-Signal-Handling
/// and https://www.gnu.org/software/libc/manual/html_node/Sigaction-Function-Example.html.
/// Note that termination signals can be found here:
/// https://www.gnu.org/software/libc/manual/html_node/Termination-Signals.html#Termination-Signals
/// @param[in] signal Signal to set to this action
/// @param[in] action Pointer to sigaction struct, including the callback function inside it, to attach to this signal
/// @return None
static inline void set_sigaction(int signal, const struct sigaction *action)
{
struct sigaction old_action;
// check current signal handler action to see if it's set to SIGNAL IGNORE
sigaction(signal, NULL, &old_action);
if (old_action.sa_handler != SIG_IGN)
{
// set new signal handler action to what we want
int ret_code = sigaction(signal, action, NULL);
if (ret_code == -1)
{
printf(LOG_FORMAT_STR "sigaction failed when setting signal to %i;\n"
" errno = %i: %s\n", LOG_LOCATION, signal, errno, strerror(errno));
}
}
}
int main(int argc, char *argv[])
{
//...
// Register callbacks to handle kill signals; prefer the Linux function `sigaction()` over the C function
// `signal()`: "It is better to use sigaction if it is available since the results are much more reliable."
// Source: https://www.gnu.org/software/libc/manual/html_node/Basic-Signal-Handling.html#Basic-Signal-Handling
// and /programming/231912/what-is-the-difference-between-sigaction-and-signal/232711#232711.
// See here for official gcc `sigaction()` demo, which this code is modeled after:
// https://www.gnu.org/software/libc/manual/html_node/Sigaction-Function-Example.html
// Set up the structure to specify the new action, per GCC's demo.
struct sigaction new_action;
new_action.sa_handler = termination_handler; // set callback function
sigemptyset(&new_action.sa_mask);
new_action.sa_flags = 0;
// SIGINT: ie: Ctrl + C kill signal
set_sigaction(SIGINT, &new_action);
// SIGTERM: termination signal--the default generated by `kill` and `killall`
set_sigaction(SIGTERM, &new_action);
// SIGHUP: "hang-up" signal due to lost connection
set_sigaction(SIGHUP, &new_action);
//...
}
2. I signal()
nawet jeśli nie jest to dobry sposób na podłączenie modułu obsługi sygnału, jak opisano powyżej, nadal dobrze jest wiedzieć, jak go używać.
Oto kod demonstracyjny GCC skopiowany i wklejony, ponieważ jest mniej więcej tak dobry, jak będzie:
#include <signal.h>
void
termination_handler (int signum)
{
struct temp_file *p;
for (p = temp_file_list; p; p = p->next)
unlink (p->name);
}
int
main (void)
{
…
if (signal (SIGINT, termination_handler) == SIG_IGN)
signal (SIGINT, SIG_IGN);
if (signal (SIGHUP, termination_handler) == SIG_IGN)
signal (SIGHUP, SIG_IGN);
if (signal (SIGTERM, termination_handler) == SIG_IGN)
signal (SIGTERM, SIG_IGN);
…
}
Główne linki, o których należy pamiętać:
- Sygnały standardowe: https://www.gnu.org/software/libc/manual/html_node/Standard-Signals.html#Standard-Signals
- Sygnały zakończenia: https://www.gnu.org/software/libc/manual/html_node/Termination-Signals.html#Termination-Signals
- Podstawowa obsługa sygnałów, w tym oficjalny
signal()
przykład użycia GCC : https://www.gnu.org/software/libc/manual/html_node/Basic-Signal-Handling.html#Basic-Signal-Handling
- Oficjalny
sigaction()
przykład użycia GCC : https://www.gnu.org/software/libc/manual/html_node/Sigaction-Function-Example.html
- Zestawy sygnałowe, w tym
sigemptyset()
i sigfillset()
; Nadal nie rozumiem ich dokładnie, ale wiem, że są ważne: https://www.gnu.org/software/libc/manual/html_node/Signal-Sets.html
Zobacz też:
- Obsługa sygnałów w programie TutorialsPoint C ++ [z doskonałym kodem demonstracyjnym]: https://www.tutorialspoint.com/cplusplus/cpp_signal_handling.htm
- https://www.tutorialspoint.com/c_standard_library/signal_h.htm
signal
dotyczy w rzeczywistości zachowania systemu Unix V. POSIX pozwala albo na to zachowanie, albo na znacznie bardziej rozsądne zachowanie BSD, ale ponieważ nie możesz być pewien, które z nich uzyskasz, nadal najlepiej jest go używaćsigaction
.