Qu'est ce qu'un onduleur processus?

Parfois, à chaque fois que j'écris un programme sous Linux et il se bloque à cause d'un bug de la sorte, il deviendra une source ininterrompue de processus et de continuer à fonctionner indéfiniment jusqu'à ce que je redémarre mon ordinateur (même si j'en fin de session). Mes questions sont les suivantes:

  • Quelles sont les causes d'un processus de devenir de secours?
  • Comment puis-je empêcher cela?
  • C'est probablement une question stupide, mais est-il possible de l'interrompre sans redémarrage de mon ordinateur?
  • Est-il possible qu'un programme peut être écrit pour initier un processus qui va dans un TASK_UNINTERUPTIBLE état chaque fois que le système n'est pas dans un état inactif, ce qui force la collecte de données, dans l'attente de transmettre une fois le super utilisateur quitte? Ce serait une mine d'or pour les pirates informatiques pour récupérer des informations, retour à l'état zombie, et de transmettre des informations à travers le réseau sur inactif. Certains peuvent dire que c'est une façon de créer un Blackdoor pour le pouvoir en place, d'entrer et de sortir tout système désiré. Je crois fermement à cette faille peut être scellé pour de bon, en éliminant les " TASK_UNINTERUPTIB
  • serait il vous plaît partager le code?
InformationsquelleAutor Jason Baker | 2008-10-21
  1. 189

    Une source ininterrompue de processus est un processus qui se trouve être dans un appel système (noyau de la fonction) qui ne peut être interrompu par un signal.

    À comprendre ce que cela signifie, vous avez besoin de comprendre le concept de interruptible appel système. L'exemple classique est read(). C'est un appel système qui peut prendre du temps (secondes), car il peut potentiellement impliquer en rotation d'un disque dur, ou de déplacer les têtes. Pendant la plus grande partie de ce temps, le processus sera de dormir, le blocage sur le matériel.

    Alors que le processus est endormi dans l'appel système, il peut recevoir un Unix asynchrone signal (par exemple, SIGTERM), puis le suivant se produit:

    • Les appels système quitte prématurément, et est configuré pour retour EINTR vers l'espace utilisateur.
    • Le gestionnaire de signal est exécuté.
    • Si le processus est toujours en cours d'exécution, il obtient la valeur de retour de l'appel système, et il peut faire la même appeler à nouveau.

    Retour au début de l'appel système permet à l'utilisateur de l'espace de code à modifier immédiatement son comportement en réponse au signal. Par exemple, la terminaison proprement en réaction à SIGINT ou SIGTERM.

    D'autre part, certains appels système ne sont pas autorisés à être interrompu. Si le système des appels stands pour une raison quelconque, le processus peut indéfiniment reste dans ce unkillable état.

    LWN, a couru un l'article de nice qui a abordé ce sujet en juillet.

    Pour répondre à la question d'origine:

    • Comment empêcher que cela se passe: comprendre le pilote qui est à l'origine de vos ennuis, et cessez de l'utiliser, ou devenir un noyau de pirates et de le corriger.

    • Comment tuer une source ininterrompue de processus sans avoir à redémarrer: faire en quelque sorte le système d'appel mettre fin. Souvent la manière la plus efficace de le faire sans frapper l'interrupteur d'alimentation est de tirer le cordon d'alimentation. Vous pouvez aussi devenir un noyau de pirates et de permettre au conducteur d'utiliser TASK_KILLABLE, comme expliqué dans l'article LWN.

    • J'ai tiré le cordon d'alimentation sur mon portable et il ne fonctionne pas, malheureusement. 😉
    • N'est-il pas EINTR au lieu de EAGAIN? Lire aussi() renvoie -1 et errno est positionnée à l'erreur.
    • Il semble EINTR est en effet le code d'erreur approprié. J'avais des souvenirs d'appels d'e/s de retour EAGAIN sans traitement correct dans la bibliothèque Python code quelques années en arrière, mais je n'étais apparemment mal. Merci, j'ai corrigé la réponse.
    • Vous pouvez aussi devenir un noyau de pirates et de permettre au conducteur d'utiliser TASK_KILLABLE Ce besoins pour être construit à droite dans un code du noyau. Peut-être changer le code du noyau dans la mémoire qui est de l'exécution de l'appel système à juste retour? Tuer tous les deux de la mode utilisateur et en mode noyau partie du processus? Je parie qu'il y a pour être un moyen de tuer en toute sécurité, même ceux "sans coupure" des processus. Juste faire ce qu'il est en attente sur IGNORER le résultat et bam, il n'est plus sans coupure! Je pensais vraiment que ce genre de processus ont été pour Windows uniquement de problème.
    • faire en quelque sorte le système d'appel mettre fin ...ou le noyau du système d'exploitation lui-même peut, après la fin de l'appel système, de vérifier si son processus appelant est encore en vie, et de ne rien faire si ce n'est-ce pas? De cette façon, sans coupure processus pourrait être en toute sécurité tués, et leur mémoire libérée, et ce qu'il attend par la suite serait de l'ignorer. Ai-je raté quelque chose ou est-elle facile?
    • En effet, vous êtes à côté de la question. Lire l'article LWN: lwn.net/Articles/288056. Ces problèmes sont causés par des paresseux du pilote de périphérique de programmeurs, et ils ont besoin d'être fixé dans le pilote de périphérique de code.
    • Je viens de lire que l'article LWN et rien dans l'article ou des commentaires m'a fait penser à l'onduleur problème du processus ne peut pas vraiment être résolu simplement dans l'OS lui-même. Un OS devrait être fait d'une manière qui rend TOUS les pilotes toujours en toute sécurité interruptible. Tout noyau de système d'exploitation pas fait de cette façon est mauvais, point.
    • la tradition (et donc la quasi-totalité des applications) croient magasin de fichier écrit non signal interruptible. Il ne serait pas sécuritaire ou une pratique de changement de garantie". -> C'est la plus mauvaise partie de tout cela, de l'OMI. Vient interrompre la demande de lecture/écriture du pilote, et lorsque le périphérique (disque dur / carte réseau / etc) fournit les données, de les ignorer. Un noyau de système d'exploitation devrait être fait d'une manière qu'AUCUN développeur ne peut le visser en place.
    • vous avez l'air d'un micro-noyau fanboy. Ce n'est pas ce que Linux est. Votre troll n'est pas pertinent.
    • Je sais que Linux n'est pas un micro-noyau, bien que je ne suis pas sûr de ce que la partie de mon commentaire se rapporte à elle... Et puis, est-ce que votre commentaire dire qu'un micro-noyau de l'OS n'a pas un problème avec ces "sans coupure" processus? Parce que si elle ne le fait pas, c'est peut-être temps pour moi de devenir un micro-noyau fan... 😀
    • Alternativement, vous pouvez utiliser un bazooka pour se débarrasser de la zigzaguant processus et de libérer les pauvres de l'ordinateur de l'existence.

    InformationsquelleAutor ddaa
  2. 47

    Lorsqu'un processus est en mode utilisateur, il peut être interrompu à tout moment (passage en mode noyau). Lorsque le noyau renvoie au mode utilisateur, il vérifie s'il y a des signaux en attente (y compris ceux qui sont utilisés pour tuer le processus, tels que SIGTERM et SIGKILL). Cela signifie qu'un processus peut être tué seulement sur le retour au mode utilisateur.

    La raison pour laquelle un processus ne peut pas être tué en mode noyau, c'est qu'il pourrait potentiellement endommager le noyau des structures utilisées par tous les autres processus sur la même machine (de la même façon de tuer un thread peut potentiellement endommager les structures de données utilisées par les autres threads du même processus).

    Lorsque le noyau a besoin de faire quelque chose qui pourrait prendre un certain temps (en attente sur un tuyau écrit par un autre processus ou en attente pour le matériel pour faire quelque chose, par exemple), il dort en marquant lui-même comme le sommeil et l'appel à l'ordonnanceur pour passer à un autre processus (si il n'y a pas de non-sommeil processus, elle passe à un "dummy" processus qui indique au processeur de ralentir un peu et se trouve dans une boucle de la boucle d'inactivité).

    Si un signal est envoyé à un processus en mode veille, il doit être réveillé avant de il sera de retour à l'espace utilisateur, et donc de processus en attente du signal. Nous avons ici la différence entre les deux types de sommeil: le sommeil

    • TASK_INTERRUPTIBLE, le interruptible de sommeil. Si une tâche est marqué avec ce drapeau, c'est le sommeil, mais peut être réveillé par des signaux. Cela signifie que le code qui a marqué la tâche que dormir attend un signal possible, et après il se réveille, va vérifier et de retour de l'appel système. Après que le signal est traité, l'appel système peut potentiellement être redémarré automatiquement (et je n'entrerai pas dans les détails sur comment ça marche).
    • TASK_UNINTERRUPTIBLE, le secours de sommeil. Si une tâche est marqué avec ce drapeau, il n'attend pas d'être réveillé par rien d'autre que ce qu'il attend, soit parce qu'il ne peut pas facilement être redémarré, ou parce que les programmes attendons l'appel système atomique. Cela peut aussi être utilisé pour dort connu pour être très court.

    TASK_KILLABLE (mentionné dans l'article LWN liés par ddaa de réponse) est une nouvelle variante.

    Cela répond à votre première question. Quant à votre deuxième question: vous ne pouvez pas éviter de secours dort, ils sont une chose normale (il arrive, par exemple, à chaque fois qu'un processus de lectures/écritures à partir de/vers le disque); toutefois, ils devraient durer qu'une fraction de seconde. Si elles durent beaucoup plus longtemps, cela signifie généralement un problème matériel (ou un pilote de périphérique problème, qui semble la même pour le noyau), où le pilote de périphérique est en attente pour le matériel pour faire quelque chose qui n'arrivera jamais. Il peut également signifier que vous êtes à l'aide de NFS et le serveur NFS est en bas (il est en attente pour le serveur pour récupérer; vous pouvez également utiliser la fonction "intr" option pour éviter le problème).

    Enfin, la raison pour laquelle vous ne pouvez pas récupérer est la même raison, le noyau attend jusqu'à ce que le retour au mode utilisateur afin d'obtenir un signal ou tuer le processus: il risquerait de corrompre le noyau de structures de données (code en attente sur un interruptible sommeil peut recevoir une erreur qui lui dit de retourner à l'utilisateur de l'espace, où le processus peut être tué; code en attente sur une source ininterrompue de sommeil ne s'attend à aucun message d'erreur).

    • Système de fichiers de verrouillage bug est une cause probable, IME.
    • Je ne comprends pas tout cela. "vous ne pouvez pas éviter de secours dort" - ne peut pas l'OS être fait de telle manière que, sans coupure de sommeil tout simplement ne pas EXISTER en tant qu'état? Ensuite, la partie concernant la corruption ne peut pas le mode noyau le cadre du processus lui-même (ou tout ce qui PEUT provoquer la corruption) être résilié ou tout simplement son code modifiées dans la mémoire à juste retour? Veuillez expliquer pourquoi est-ce si difficile / impossible à faire même Linux ne l'a pas fait. (Je pensais que ce problème n'existe que sur Windows)
    • Le seul cas je pense, qui ferait (en toute sécurité) le fait de tuer ces processus vraiment impossible (et pas seulement, disons, exceptionnellement dur) si le matériel lui-même pourrait provoquer la corruption. Le matériel ne peut pas être contrôlé; noyau peut. Mais c'est le noyau qui récupère les données à partir de matériel et modifie la mémoire (c'est pourquoi il ne doit pas être libéré avant le processus retourne en mode utilisateur et pourquoi la corruption se produire)... modifier le code du noyau en mémoire et pas plus de problèmes.
    • penser le noyau, comme s'il s'agissait d'un seul processus multithread, où le mode noyau le cadre de chaque processus est un thread dans le noyau. Votre suggestion serait aussi mauvais que le fait de tuer un seul thread dans un programme multi-threadé: elle pourrait laisser pendre les serrures, les structures de données modifiée temporairement ou dans le milieu de la modification, et ainsi de suite.
    • eh bien vous avez raison sur le meurtre d'un fil... Mais ne peut pas la "main" thread (ce qui serait le noyau de système d'exploitation et les autres threads serait pilotes par exemple) d'une certaine manière de la gérer? Bien que ces structures "dans le milieu de l'être modifié" semble être un très difficile problème... peut-être nous sera jamais vraiment voir un OS où sans coupure processus serait impossible 🙁
    InformationsquelleAutor CesarB
  3. 23

    Sans coupure processus sont souvent en attente d'e/S, à la suite d'une défaillance de page.

    Considérez ceci:

    • Le thread tente d'accéder à une page qui n'est pas dans la base (soit un exécutable qui est la demande bien chargé, une page de la mémoire anonyme qui a été échangé, ou un mmap()'d fichier qui est chargé de la demande, qui sont bien de la même chose)
    • Le noyau est maintenant (essayer de) le charger dans
    • Le processus ne peut pas continuer jusqu'à ce que la page est disponible.

    La tâche ne peut pas être interrompu dans cet état, parce qu'il ne peut pas gérer des signaux; si elle l'a fait, une autre page de faute qui allait arriver, et il serait là où il était.

    Quand je dis "processus", je veux dire vraiment "tâche", ce qui sous Linux (2.6) se traduit approximativement par "fil" qui peut ou peut ne pas avoir une personne de "groupe de thread" entrée dans /proc

    Dans certains cas, il peut être en attente pendant une longue période. Un exemple typique de ce serait l'endroit où le fichier exécutable ou mmap avais fichier est sur un système de fichier réseau où le serveur a échoué. Si l'I/O finalement réussit, la tâche de continuer. Si elle échoue finalement, la tâche sera généralement obtenir un SIGBUS ou quelque chose.

    • Si elle échoue finalement, la tâche sera généralement obtenir un SIGBUS ou quelque chose. Attendre, ne peut pas le noyau être faite de sorte que, lors de la tuer ces "sans coupure" des processus, il leur DIT simplement l'opération d'e/S a échoué? Ensuite, le processus serait de revenir en mode utilisateur et être allé? Il y A un moyen sécuritaire de tuer ceux que le " D " de l'état des processus. Je pense que c'est juste pas facile et c'est pourquoi, ni de Windows ou de Linux que de possibilité. De l'autre côté, j'ai envie d'être capable de tuer ces processus au moins mal. Je ne l'aime pas possible de plantage du système ou quoi...
    InformationsquelleAutor MarkR
  4. 1

    À votre 3ème question:
    Je pense que vous pouvez tuer les sans coupure les processus en cours d'exécution
    sudo kill -HUP 1.
    Il va redémarrer init sans mettre fin à un processus en cours d'exécution et après l'exécution d'elle, mon interrompu processus ont disparu.

    InformationsquelleAutor Ron Granger
  5. -3

    Si vous parlez d'un "zombie" (qui est désigné comme "zombie" dans le ps), alors c'est un inoffensif enregistrement dans la liste des processus en attente de quelqu'un pour recueillir son code de retour et il peut être ignoré en toute sécurité.

    Pourriez-vous décrire ce et "sans coupure processus" est fait pour vous? Il ne survit à la "kill -9" et heureusement souffle le long? Si c'est le cas, alors il est coincé sur certains syscall, qui est coincé dans un conducteur, et vous êtes coincé avec ce processus jusqu'à redémarrer (et parfois il est préférable de redémarrer bientôt) ou le déchargement d'un pilote concerné (ce qui est peu probable). Vous pouvez essayer d'utiliser "strace" pour savoir où votre processus est bloqué et l'éviter à l'avenir.

    • Ne pouvez pas les pilotes de force déchargé de la même façon qu'un processus peut être tué? Je sais en mode noyau a plus d'un accès privilégié que le mode utilisateur, mais il ne peut jamais être plus privilégié que le système d'exploitation lui-même. Rien d'exécution en mode noyau peut toujours trafiquer avec autre chose que de l'exécution en mode noyau - il n'y a pas de contrôle.
    InformationsquelleAutor ADEpt