Traitement du Signal avec plusieurs threads sous Linux

Sous Linux, ce qui se produit lorsqu'un programme (qui a peut-être plusieurs threads) reçoit un signal, comme un SIGTERM ou SIGHUP?

Thread qui intercepte le signal? Plusieurs threads peuvent obtenir le même signal? Est-il un fil spécial entièrement dédié à la manipulation des signaux? Si pas, ce qui se passe à l'intérieur de la thread qui est de gérer le signal? Comment fonctionne l'exécution reprend après le gestionnaire de signal de routine finitions?

InformationsquelleAutor | 2012-07-26
  1. 35

    Ce qui est légèrement nuancée, en fonction de la version du noyau Linux que vous utilisez.

    En supposant 2.6 threads posix, et si l'on parle de l'OS de l'envoi de signal SIGTERM ou SIGHUP, le signal est envoyé, ce qui est reçue par et traitées par la racine fil. À l'aide de threads POSIX, vous pouvez également envoyé SIGTERM de threads individuels en tant que bien, mais je soupçonne que vous posez sur ce qui se passe lorsque le système d'exploitation envoie le signal au processus.

    En 2.6, SIGTERM sera la cause de threads enfants à la sortie "propre", où, comme 2.4, threads enfants ont été laissés dans un état indéterminé.

    • Et ce qui se passe à l'intérieur de la racine de fil quand un signal est reçu? Disons que j'ai écrit une coutume gestionnaire de signal pour le signal SIGUSR1, et maintenant je suis l'envoi de ce signal au processus. La racine thread va obtenir ce signal. C'est peut-être dans le milieu d'une certaine fonction à ce moment-là. Qu'est-ce que va se passer?
    • si vous avez un gestionnaire de l'installation, il sera considéré comme une interruption, et le programme s'arrête et votre gestionnaire personnalisé sera exécuté. Une fois qu'il est exécuté, le contrôle sera de retour, en supposant que vous n'avez rien fait pour altérer le flux normal (sortie etc).
    • Notez que ceci est spécifique à SIGUSR1, qui, autant que je me souvienne de ne pas interrompre les appels système. Si vous avez essayé cela avec SIGINT par exemple, il peut interrompre le flux de lire, et quand vous êtes allé à revenir à la lecture, le flux peut renvoyer une erreur qu'il a été interrompu.
    • Je suis un peu confus au sujet de ce que l'on entend par "racine du fil". Est-ce à dire que le gestionnaire de signal SIGTERM sera toujours exécuté dans le thread principal, ou peut-il être exécuté dans un thread?
    • Cette réponse, qui stipule que l'arbitraire d'un thread est choisie pour traiter le signal, va à l'encontre de votre réponse.
    InformationsquelleAutor Alan
  2. 122

    pthreads(7) décrit que POSIX.1 exige que tous les threads d'un processus de partage d'attributs, y compris:

    • signal dispositions

    POSIX.1 exige également certains attributs pour être distinctes pour chaque thread, y compris:

    Le noyau Linux est complete_signal routine a le bloc de code suivant -- les commentaires sont très utiles:

    /*
 * Now find a thread we can wake up to take the signal off the queue.
 *
 * If the main thread wants the signal, it gets first crack.
 * Probably the least surprising to the average bear.
 */
if (wants_signal(sig, p))
        t = p;
else if (!group || thread_group_empty(p))
        /*
         * There is just one thread and it does not need to be woken.
         * It will dequeue unblocked signals before it runs again.
         */
        return;
else {
        /*
         * Otherwise try to find a suitable thread.
         */
        t = signal->curr_target;
        while (!wants_signal(sig, t)) {
                t = next_thread(t);
                if (t == signal->curr_target)
                        /*
                         * No thread needs to be woken.
                         * Any eligible threads will see
                         * the signal in the queue soon.
                         */
                        return;
        }
        signal->curr_target = t;
}

/*
 * Found a killable thread.  If the signal will be fatal,
 * then start taking the whole group down immediately.
 */
if (sig_fatal(p, sig) &&
    !(signal->flags & SIGNAL_GROUP_EXIT) &&
    !sigismember(&t->real_blocked, sig) &&
    (sig == SIGKILL || !p->ptrace)) {
        /*
         * This signal will be fatal to the whole group.
         */

    Donc, vous voyez que vous êtes en charge de la où les signaux sont livrés:

    Si votre processus a mis un signal de la disposition à SIG_IGN ou SIG_DFL, puis le signal est ignoré (ou par défaut -- tuer, de base, ou de l'ignorer) pour tous les threads.

    Si votre processus a mis un signal de la disposition d'un gestionnaire spécifique de routine, alors vous pouvez contrôler le thread qui va recevoir les signaux en manipulant thread spécifique masques de signal à l'aide de pthread_sigmask(3). Vous pouvez nommer un thread pour gérer tous les, ou de créer un thread par signal, ou tout mélange de ces options pour des signaux spécifiques, ou vous comptez sur le noyau Linux actuelles du comportement par défaut de la distribution du signal pour le thread principal.

    Certains signaux, cependant, sont spéciaux selon les signal(7) homme page:

    Un signal peut être généré (et donc en attente) pour un ensemble du processus de
    (par exemple, lorsqu'il est envoyé à l'aide de kill(2)) ou pour un thread spécifique (par exemple,
    certains signaux, comme SIGSEGV et SIGFPE, générés en
    conséquence de l'exécution d'une machine spécifique de l'enseignement de langue sont
    fil réalisé, comme le sont les signaux ciblés à un thread spécifique à l'aide de
    pthread_kill(3)). Un processus dirigé signal peut être livré à l'un
    l'un des fils qui n'ont actuellement pas le signal bloqué.
    Si plus d'un des fils a le signal non bloqué, puis le
    noyau choisit l'arbitraire d'un thread pour fournir le signal.

    InformationsquelleAutor sarnold