HOWTO · C++
Gérer le signal SIGABRT en C++
Cet article présente la manière de traiter le signal SIGABRT en C++.
Sur cette page
Pour traiter SIGABRT dans un programme C++ POSIX, installez un gestionnaire avec sigaction, puis déterminez s’il doit terminer immédiatement le processus ou demander à l’exécution principale d’organiser l’arrêt. Limitez le travail asynchrone du gestionnaire : le nettoyage C++ ordinaire, les flux, les allocations et la plupart des appels de bibliothèque ne sont pas sûrs dans ce contexte. Les exemples visent les systèmes POSIX et lèvent eux-mêmes le signal afin que chaque exécution se termine sans processus externe.
Signification de SIGABRT et circonstances de son émission
SIGABRT est le signal d’abandon. Par défaut, il termine le processus et produit généralement un fichier core si le système d’exploitation et la configuration du processus le permettent. Un processus peut le recevoir à la suite d’un signal qui lui est adressé, par exemple kill -SIGABRT <pid>, ou le lever lui-même avec abort().
L’origine du signal est importante. Lorsqu’il est envoyé de l’extérieur, le retour du gestionnaire permet normalement à l’exécution interrompue de reprendre selon les règles POSIX relatives aux signaux. En revanche, abort() ne permet pas au gestionnaire d’annuler la terminaison qu’il impose : si un gestionnaire de SIGABRT revient, abort() rétablit l’action par défaut et lève de nouveau le signal. La spécification POSIX de abort() décrit ce comportement. N’utilisez pas le retour avec indicateur présenté plus bas pour récupérer après une assertion interne ou un appel à abort().
Les gestionnaires de signaux s’exécutent de façon asynchrone par rapport au code qu’ils interrompent. C++ impose des restrictions strictes sur ce qu’un gestionnaire peut consulter ou appeler ; voir les règles C++ relatives aux gestionnaires de signaux. En particulier, accéder à des objets partagés ordinaires ou appeler des fonctions comme std::cout, printf ou des destructeurs peut entraîner un comportement indéfini ou un interblocage. Le type spécial volatile sig_atomic_t permet une forme limitée de communication avec un gestionnaire ; il ne rend sûrs ni les variables quelconques, ni les conteneurs, ni les accès concurrents en général. Ces exemples utilisent des API POSIX (sigaction, raise, sigprocmask, sigsuspend et write) et ne sont donc pas portables sur tous les systèmes d’exploitation.
Enregistrer un gestionnaire de SIGABRT avec sigaction
Utilisez sigaction pour définir explicitement l’action associée au signal, puis vérifiez sa valeur de retour. Dans la variante qui termine immédiatement le processus, le gestionnaire écrit un message fixe avec write de POSIX, puis appelle _Exit, ce qui évite d’exécuter les destructeurs C++ ordinaires depuis le contexte du signal. Le nettoyage normal est ainsi volontairement ignoré. La démonstration se termine avec le statut zéro pour pouvoir être exécutée seule ; en production, choisissez un statut d’échec adapté à l’appelant. Cette approche convient lorsque la poursuite de l’exécution est dangereuse et qu’un bref diagnostic est le seul message que le programme puisse fournir sans risque.
Exécutez cet exemple :
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#include <signal.h>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
void terminate_on_sigabrt(int) {
const char message[] = "received SIGABRT; terminating\n";
(void)::write(STDOUT_FILENO, message, sizeof(message) - 1);
std::_Exit(EXIT_SUCCESS);
}
int main() {
struct sigaction action {};
action.sa_handler = terminate_on_sigabrt;
if (::sigemptyset(&action.sa_mask) == -1) {
std::perror("sigemptyset");
return EXIT_FAILURE;
}
if (::sigaction(SIGABRT, &action, nullptr) == -1) {
std::perror("sigaction");
return EXIT_FAILURE;
}
::raise(SIGABRT);
return EXIT_FAILURE;
}
received SIGABRT; terminating
L’exemple lève SIGABRT une fois le gestionnaire enregistré. Celui-ci écrit une ligne de diagnostic et termine le processus avec _Exit ; les sorties mises en tampon ne sont donc pas vidées et le nettoyage normal n’est pas exécuté. write est utilisé parce que cette fonction POSIX est sûre dans un gestionnaire de signal asynchrone, contrairement aux flux C++. Dans un programme de longue durée, remplacez le déclenchement de démonstration par le travail normal du programme, puis envoyez kill -SIGABRT <pid> depuis un autre terminal.
Utiliser sig_atomic_t pour demander l’arrêt
Lorsqu’un SIGABRT est envoyé de l’extérieur et qu’il est approprié de revenir à l’exécution principale, le gestionnaire peut définir un unique indicateur volatile sig_atomic_t. L’exécution principale le vérifie et effectue le nettoyage après le retour du gestionnaire. Les opérations complexes restent ainsi hors du gestionnaire, et les portées se terminent normalement. N’utilisez cette méthode que si l’origine du signal et l’état du programme permettent de poursuivre sans danger ; elle ne permet pas d’ignorer abort().
L’exemple utilise sigprocmask et sigsuspend pour éviter toute fenêtre entre la vérification de l’indicateur et l’attente : sigsuspend rétablit temporairement le masque de signaux précédent et attend de manière atomique. Cet exemple concerne un processus monothread. Dans un programme multithread, bloquez le signal dans tous les threads et choisissez délibérément la manière de le recevoir, généralement avec pthread_sigmask et un thread dédié à l’attente des signaux. L’indicateur ne remplace pas la synchronisation entre threads.
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#include <signal.h>
#include <cstdlib>
#include <cstdio>
volatile sig_atomic_t shutdown_requested = 0;
void request_shutdown(int) {
shutdown_requested = 1;
}
int main() {
sigset_t blocked_set;
sigset_t previous_mask;
if (::sigemptyset(&blocked_set) == -1 ||
::sigaddset(&blocked_set, SIGABRT) == -1 ||
::sigprocmask(SIG_BLOCK, &blocked_set, &previous_mask) == -1) {
std::perror("block SIGABRT");
return EXIT_FAILURE;
}
sigset_t wait_mask = previous_mask;
if (::sigdelset(&wait_mask, SIGABRT) == -1) {
std::perror("sigdelset");
::sigprocmask(SIG_SETMASK, &previous_mask, nullptr);
return EXIT_FAILURE;
}
struct sigaction action {};
action.sa_handler = request_shutdown;
if (::sigemptyset(&action.sa_mask) == -1) {
std::perror("sigemptyset");
::sigprocmask(SIG_SETMASK, &previous_mask, nullptr);
return EXIT_FAILURE;
}
if (::sigaction(SIGABRT, &action, nullptr) == -1) {
std::perror("sigaction");
::sigprocmask(SIG_SETMASK, &previous_mask, nullptr);
return EXIT_FAILURE;
}
::raise(SIGABRT);
while (shutdown_requested == 0) {
::sigsuspend(&wait_mask);
}
if (::sigprocmask(SIG_SETMASK, &previous_mask, nullptr) == -1) {
std::perror("restore signal mask");
return EXIT_FAILURE;
}
// Perform ordinary cleanup here, after the handler has returned.
std::puts("shutdown requested");
return EXIT_SUCCESS;
}
shutdown requested
L’exemple met SIGABRT en attente pendant qu’il est bloqué ; sigsuspend le débloque temporairement, le gestionnaire définit l’indicateur puis revient, et la boucle se termine. Adaptez le nettoyage effectué dans l’exécution principale aux ressources utilisées par votre application. Dans un programme multithread, un signal adressé au processus peut être remis à n’importe quel thread admissible : bloquez-le de façon cohérente et concevez explicitement sa distribution au lieu de supposer qu’un thread de travail particulier le recevra.
Tester et diagnostiquer le traitement de SIGABRT
Compilez l’un ou l’autre exemple avec le compilateur C++ de votre plateforme et les en-têtes de développement POSIX. Chacun lève SIGABRT en interne pour illustrer son comportement et se terminer de lui-même : l’exemple à sortie immédiate écrit un diagnostic puis termine le processus, tandis que celui avec indicateur revient du gestionnaire et reprend son exécution principale. L’appel interne raise(SIGABRT) envoie le signal depuis l’exemple ; la procédure au terminal ci-dessous l’envoie, elle, à un processus en cours d’exécution.
Créez une copie de test du code à sortie immédiate et remplacez sa ligne ::raise(SIGABRT); par for (;;) ::pause();. Le code source inclut déjà <unistd.h>. Dans une copie de test du code avec indicateur, supprimez sa ligne ::raise(SIGABRT); ; la boucle sigsuspend existante attendra alors un signal externe. Enregistrez les copies sous les noms immediate.cpp et flag.cpp. Pour l’une ou l’autre, exécutez ces commandes une par une dans un shell POSIX :
- Compilez le fichier avec
c++ -std=c++11 immediate.cpp -o immediate(pour la variante avec indicateur, utilisezflag.cppet-o flag). - Lancez le programme correspondant en arrière-plan avec
./immediate &(ou./flag &). - Récupérez et affichez son identifiant de processus avec
pid=$!puisprintf '%s\\n' "$pid". - Envoyez le signal avec
kill -SIGABRT "$pid", puis récupérez son statut avecwait "$pid".
Pour la copie à sortie immédiate, attendez-vous à voir received SIGABRT; terminating et à ce que le processus termine avec _Exit. Pour la copie avec indicateur, attendez-vous à voir shutdown requested : le gestionnaire définit l’indicateur, revient, puis l’exécution principale se termine. Les appels internes à raise rendent les exemples affichés autonomes ; en les supprimant des copies de test, les gestionnaires restent enregistrés pendant que les programmes attendent le signal envoyé depuis le second terminal.
Si sigaction signale une erreur, examinez le message de perror et vérifiez que l’environnement est POSIX et que le processus est autorisé à installer l’action. Si le programme termine sans le message personnalisé, vérifiez que le signal a été envoyé au bon processus et que l’enregistrement a réussi ; l’action par défaut termine le processus. Si un gestionnaire semble revenir après un appel à abort() effectué par le programme, rappelez-vous que abort() lève de nouveau SIGABRT avec son action par défaut. Enfin, un signal envoyé à un processus n’est pas équivalent à un signal envoyé à un thread précis : dans une application multithread, définissez et documentez une stratégie de gestion explicite avant de vous fier à la méthode avec indicateur.