Concepts de base des processus Linux - état du processus, composition du processus, contrôle du processus

Enterprise 2023-09-17 03:16:27 views: null

Table des matières

Processus Linux

Concepts de base du processus

état du processus

Composition du processus

contrôle de processus

Création et terminaison du processus

Processus Linux

référence:

Concepts de base du processus

Programmes et processus

En termes simples, un programme est un fichier qui contient du code exécutable et est un fichier statique. Un processus est une instance d'un programme dont l'exécution a commencé mais qui n'est pas encore terminée. C'est l'implémentation spécifique du fichier exécutable. Un programme peut avoir plusieurs processus, et chaque processus peut avoir plusieurs processus enfants.

état du processus

  1. État de création : le processus est en cours de création et n'a pas encore été transféré à l'état prêt.

  2. État prêt : le processus a obtenu toutes les ressources requises à l'exception du processeur et peut s'exécuter immédiatement une fois qu'il a obtenu le processeur.

    • Caractéristiques du statut : Ressources processeur (ou ordonnanceur) : seul le processeur manque. Acquisition de ressources : les ressources requises ont été obtenues. Lorsqu'un processeur est obtenu : exécutez-le immédiatement.

    • Transition d'état : État prêt -> État en cours d'exécution : Une fois que le processus à l'état prêt est planifié, il obtient des ressources processeur, de sorte que le processus passe de l'état prêt à l'état en cours d'exécution.

  3. État d'exécution : le processus est en cours d'exécution sur le processeur ; pour un seul processeur, un seul processus est en cours d'exécution à la fois.

    • Transition d'état : État d'exécution -> État Prêt : Cas 1 : Une fois la tranche de temps épuisée, le processus en état d'exécution doit abandonner le processeur puis passer à l'état prêt. Cas 2 : dans un système d'exploitation privable, lorsqu'un processus de priorité plus élevée est prêt, le planificateur convertit le processus en cours d'exécution dans un état prêt pour permettre au processus de priorité plus élevée de s'exécuter.

    • Transition d'état : état d'exécution -> état de blocage (comportement actif) : lorsqu'un processus demande l'utilisation d'une certaine ressource (comme un périphérique) ou attend l'occurrence d'un certain événement (comme l'achèvement d'une opération d'E/S ), il passe de l'état d'exécution Convert à l'état de blocage. Le processus demande au système d'exploitation de fournir des services sous la forme d'un appel système, qui est une forme spéciale dans laquelle un programme en mode utilisateur appelle le processus du noyau du système d'exploitation.

  4. État de blocage : également appelé état d'attente, le processus attend un certain événement et suspend son exécution/sommeil. Par exemple, en attendant la fin d'une certaine ressource ou d'une E/S, le processus ne peut pas s'exécuter même si le processeur est inactif.

    • Caractéristiques de l'état : Ressources du processeur (ou du planificateur) : peuvent être manquantes ; peuvent ne pas manquer. Acquisition de ressources : attendre qu'une ressource soit disponible ou attendre que quelque chose soit terminé. Lors de l'obtention d'un processeur : même si le processeur est inactif, il ne peut toujours pas fonctionner lorsque la tâche qu'il attend n'est pas terminée.

    • Transition d'état : État bloqué -> État prêt (comportement passif, nécessitant l'assistance d'autres processus associés) : Lorsque l'événement que le processus attend arrive, comme la fin de l'opération d'E/S ou la fin de l'interruption, le Le gestionnaire d'interruption doit changer l'état du processus correspondant de la transition d'état bloqué à l'état prêt.

  5. État de fin : le processus est en train de disparaître du système. Il se peut que le processus se termine normalement ou se termine pour d'autres raisons.

Correspondant aux drapeaux de chaque état de processus dans le noyau Linux :

  • TASK_RUNNINGCela signifie que le processus est prêt. Cela dépend si le système d'exploitation alloue ou non une tranche de temps à exécuter sur le CPU. Si le processus obtient une tranche de temps, c'est l'état d'exécution. S'il n'alloue pas de tranche de temps, c'est l'état prêt. Les champs représentant le statut n'ont pas besoin d'être modifiés.

    • En fait, TASK_RUNINGce champ correspond à la fois à l'état prêt du processus et à l'état d'exécution du processus.

    • Seuls les processus dans cet état peuvent s'exécuter sur le processeur. Il peut y avoir plusieurs processus dans l'état exécutable en même temps, et les structures task_struct (blocs de contrôle de processus) de ces processus sont placées dans la file d'attente exécutable de la CPU correspondante (un processus ne peut apparaître que dans la file d'attente exécutable d'une CPU à la plupart). La tâche du planificateur de processus est de sélectionner un processus dans la file d'attente exécutable de chaque processeur à exécuter sur ce processeur.

    • Tant que la file d'attente exécutable n'est pas vide, son CPU correspondant ne peut pas être paresseux et doit exécuter l'un des processus. Le processeur à ce moment-là est généralement appelé « occupé ». De manière correspondante, le processeur « inactif » signifie que sa file d'attente exécutable correspondante est vide, de sorte que le processeur n'a rien à faire.

    • De nombreux manuels de systèmes d'exploitation définissent les processus qui s'exécutent sur le processeur comme l'état RUNNING et les processus qui sont exécutables mais dont l'exécution n'a pas encore été planifiée comme l'état READY. Ces deux états sont unifiés dans l'état TASK_RUNNING sous Linux.

  • TASK_INTERRUPTIBLEet TASK_UNINTERRUPTIBLEsont deux états de sommeil, correspondant à l'état de blocage ci-dessus. TASK_INTERRUPTIBLEPeut être réveillé à nouveau par des signaux, TASK_UNINTERRUPTIBLEmais ne peut pas être réveillé par des signaux.

    • TASK_INTERRUPTIBLE, état de veille interruptible. Le processus dans cet état est suspendu car il attend qu'un certain événement se produise (comme l'attente d'une connexion socket, l'attente d'un sémaphore). Les structures task_struct de ces processus sont mises dans la file d'attente des événements correspondants. Lorsque ces événements se produisent (déclenchés par des interruptions externes ou déclenchés par d'autres processus), un ou plusieurs processus dans la file d'attente correspondante seront réveillés. Grâce à la commande ps, nous verrons que, dans des circonstances normales, la grande majorité des processus de la liste des processus sont dans l'état TASK_INTERRUPTIBLE (sauf si la charge sur la machine est très élevée).

    • TASK_UNINTERRUPTIBLE, état de veille ininterrompu. Semblable à l'état TASK_INTERRUPTIBLE, le processus est dans un état de veille, mais le processus est ininterrompu à ce moment-là. Ininterruptible ne signifie pas que le processeur ne répond pas aux interruptions du matériel externe, mais que le processus ne répond pas aux signaux asynchrones. Autrement dit, kill -9 ne peut pas arrêter/tuer ce type de processus. L'importance de l'état TASK_UNINTERRUPTIBLE est que certains flux de traitement du noyau ne peuvent pas être interrompus. Si vous répondez à un signal asynchrone, un processus de traitement des signaux asynchrones sera inséré dans le flux d'exécution du programme (ce processus inséré ne peut exister qu'en mode noyau, ou peut s'étendre au mode utilisateur), donc le processus d'origine sera être interrompu. .

      Lorsqu'un processus fonctionne sur certains matériels (par exemple, le processus appelle l'appel système de lecture pour lire un fichier de périphérique, et l'appel système de lecture exécute finalement le code du pilote de périphérique correspondant et interagit avec le périphérique physique correspondant), cela peut être Il est nécessaire d'utiliser l'état TASK_UNINTERRUPTIBLE pour protéger le processus afin d'éviter que l'interaction entre le processus et le périphérique ne soit interrompue et ne fasse tomber le périphérique dans un état incontrôlable. L'état TASK_UNINTERRUPTIBLE dans ce cas est toujours de très courte durée et est fondamentalement impossible à capturer via la commande ps. Il existe également un état TASK_UNINTERRUPTIBLE facile à capturer dans les systèmes Linux. Après avoir exécuté l'appel système vfork, le processus parent entrera dans l'état TASK_UNINTERRUPTIBLE jusqu'à ce que le processus enfant appelle exit ou exec.

  • TASK_STOPPEDC'est l'état dans lequel le processus reçoit des signaux tels que SIGSTOP et SIGTTIN. Lorsque votre processus Linux est en cours d'exécution et que vous appuyez sur Ctrl + z, le processus sera dans cet état.

    • Envoyez un signal SIGSTOP à un processus, et il entrera dans l'état TASK_STOPPED en réponse au signal (sauf si le processus lui-même est dans l'état TASK_UNINTERRUPTIBLE et ne répond pas au signal). (SIGSTOP, comme le signal SIGKILL, est très obligatoire. Le processus utilisateur n'est pas autorisé à réinitialiser la fonction de traitement du signal correspondante via l'appel système de la série de signaux.)

    • L'envoi d'un signal SIGCONT au processus peut le restaurer de l'état TASK_STOPPED à l'état TASK_RUNNING.

  • TASK_TRACEDIl s'agit de l'état du processus surveillé.

    • Lorsqu'un processus est tracé, il se trouve dans l'état spécial TASK_TRACED. « Être suivi » signifie que le processus est en pause et attend que le processus qui le suit agisse dessus. Par exemple, si vous définissez un point d'arrêt sur le processus suivi dans gdb, le processus sera dans l'état TASK_TRACED lorsqu'il s'arrêtera au point d'arrêt. À d’autres moments, le processus suivi se trouve toujours dans les états mentionnés précédemment.

    • Jugement de statut TASK_STOPPED et TASK_TRACED. Pour le processus lui-même, les états TASK_STOPPED et TASK_TRACED sont très similaires, indiquant tous deux que le processus est suspendu. L'état TASK_TRACED équivaut à une couche de protection supplémentaire au-dessus de TASK_STOPPED. Le processus dans l'état TASK_TRACED ne peut pas être réveillé en réponse au signal SIGCONT. Le processus débogué ne peut revenir à l'état TASK_RUNNING que jusqu'à ce que le processus de débogage exécute des opérations telles que PTRACE_CONT et PTRACE_DETACH via l'appel système ptrace (opérations spécifiées via les paramètres de l'appel système ptrace) ou que le processus de débogage se termine.

  • TASK_DEAD- EXIT_ZOMBIE, état de sortie, le processus devient un processus zombie. EXIT_DEADC'est l'état final. Entrer dans cet état signifie que le processus sera supprimé du système. EXIT_ZOMBIEC'est EXIT_DEADl'état précédent. À ce moment, le processus est terminé, mais le processus parent n'a pas encore attendu wait()l'appel système pour obtenir son informations de fin. Le processus dans cet état est appelé un processus zombie. . Dans cet état, la commande kill ne peut pas vous tuer. Vous pouvez réfléchir à la manière d'effacer les processus zombies et d'éviter l'existence de processus zombies.

    Concernant l'état du processus lié à la sortie (les quatre ci-dessus), pour plus de détails, veuillez consulter  le blog-CSDN de Linux Process Analysis_deep_explore .

Diagramme de transition de l'état du processus Linux :

Codes STAT courants pour les processus système :

File d'attente prête et file d'attente de blocage :

File d'attente prête : il peut y avoir plusieurs processus à l'état prêt dans le système, et ils sont généralement placés dans une file d'attente. Tant que la file d'attente prête n'est pas vide, la CPU peut toujours planifier l'exécution des processus et rester occupés. Cela n'a rien à voir avec le nombre de processus prêts ; à moins que la file d'attente prête ne soit vide, la CPU entre dans un état d'attente et la CPU l’efficacité diminue.

File d'attente de blocage : le système place généralement les processus bloqués dans une file d'attente et configure même plusieurs files d'attente de blocage en fonction de différentes raisons de blocage.

Composition du processus

Ces structures de données citées à partir du processus - Zhihu (zhihu.com) , la structure task_struct sous Linux - Baidu Library (baidu.com) .

Le processus comprend généralement les parties suivantes :

  • Bloc de contrôle de processus (PCB) : lorsque chaque processus est créé, le système crée un PCB correspondant pour le processus. Le PCB est la seule indication de l'existence d'un processus.

    • L’essence de la création d’un processus est de créer le PCB du processus. PCB doit être capable d'afficher les identités et les relations des processus, de marquer l'état des tâches, de marquer les autorisations, d'aider à la planification des tâches, etc.

    • Dans le noyau Linux, les processus et les threads sont unifiés en tant que tâches. Le bloc de contrôle de processus du noyau Linux est une task_structstructure qui contient :

      • L’identifiant du processus (un identifiant de processus, ou PID) ; (l’identifiant unique du processus, PID)

      • Enregistrer les valeurs du processus incluant notamment les valeurs du compteur de programme et du pointeur de pile du processus ; Compteur de programme PC, etc.)

      • L'espace d'adressage du processus ;

      • Priorité (dans lequel un processus de priorité plus élevée obtient la première préférence. Par exemple, une valeur intéressante sur les systèmes d'exploitation Unix) ;（优先级）

      • Informations de comptabilité de processus, telles que la date de la dernière exécution du processus, le temps CPU accumulé, etc. ;

      • Pointeur vers le prochain PCB, c'est-à-dire pointeur vers le PCB du prochain processus à exécuter ;

      • Informations d'E/S (c'est-à-dire périphériques d'E/S alloués à ce processus, liste des fichiers ouverts, etc.).

    • pid_t pid; // Affiche l'identifiant de votre propre processus 
pid_t tgid; // L'identifiant du thread principal du processus 
struct task_struct *group_leader; // Pointez vers l'adresse du thread principal

      Chaque processus créera un thread principal, donc s'il n'y a qu'un seul processus et que le thread principal créé par le processus par défaut, alors et pidsera tgidlui-même. S'il s'agit d'un thread enfant créé par un processus, alors pidil est le sien idet tgidpointe vers l'identifiant du thread principal du processus.

    • struct task_struct __rcu * real_parent; 
struct task_struct __rcu * parent; // Pointe vers le processus parent 
struct list_head children; // Tous les processus enfants du processus parent sont dans la liste chaînée des processus enfants, et cela pointe vers l'en-tête de la liste chaînée . 
struct list_head sibling; // Connecter les processus frères

      Le processus est une structure arborescente (un arbre composé de listes chaînées). À l'exception du processus n°0, tous les processus sont créés par le processus parent, donc les opérations sur le processus parent peuvent facilement affecter le processus enfant. Par conséquent, la structure des données du processus montre naturellement de quels processus parent, enfant et frère le processus dispose.

  • Segment de programme : un segment de programme est un segment de code de programme dans un processus qui peut être programmé pour être exécuté sur la CPU par le planificateur de processus.

  • Segment de données : Il peut s'agir des données originales traitées par le processus correspondant au programme, ou il peut s'agir du résultat intermédiaire ou des données de résultat générées lors de l'exécution du programme.

contrôle de processus

La fonction principale du contrôle des processus est de gérer efficacement tous les processus du système. Il a pour fonctions de créer de nouveaux processus, d'annuler les processus existants et de réaliser des transitions d'état de processus. En bref, le contrôle des processus consiste à réaliser une transition d'état du processus.

Le segment général du programme de contrôle de processus est une « opération atomique » et ne peut pas être interrompu pendant le processus d'exécution ; il utilise les deux instructions privilégiées « interruption hors instruction » et « interruption sur instruction » pour atteindre l'atomicité.

Création et terminaison du processus

Concepts de contrôle de processus liés à la création et à la fin des processus.

Événements provoquant la création de processus

  • Connexion utilisateur : Dans le système de partage de temps, si l'utilisateur se connecte avec succès, le système créera un nouveau processus pour lui.

  • Planification des tâches : dans un système de traitement par lots multicanal, lorsqu'une nouvelle tâche est mise en mémoire, un nouveau processus est créé pour celle-ci.

  • Fournir des services : lorsque l'utilisateur fait certaines demandes au système d'exploitation, un nouveau processus sera créé pour gérer la demande. Le lancement d'un programme crée un nouveau processus.

  • Demande d'application : le processus utilisateur demande activement la création d'un processus enfant.

Le processus par lequel le système d'exploitation crée un nouveau processus

  1. Étape 1 : Attribuez un numéro d'identification de processus unique au nouveau processus et demandez un PCB vierge (le PCB est limité). Si l'application du PCB échoue, la création échoue.

  2. Étape 2 : allouez les ressources requises au processus, telles que les fichiers, la mémoire, les périphériques d'E/S et le temps CPU. Ces ressources sont obtenues à partir du système d'exploitation ou de son processus parent. Si les ressources sont insuffisantes (comme la mémoire), la création n'échoue pas à ce moment-là, mais elle est dans l'état de création, en attente de ressources mémoire.

  3. Étape 3 : Initialisez le PCB, y compris principalement les informations sur l'indicateur d'initialisation, les informations sur l'état du processeur d'initialisation et les informations de contrôle du processeur d'initialisation, ainsi que la définition de la priorité du processus, etc.

  4. Étape 4 : Si la file d'attente des processus prêts peut accepter le nouveau processus, insérez le nouveau processus dans la file d'attente des processus prêts et attendez que son exécution soit planifiée.

Le processus parent crée un processus enfant

Un processus est autorisé à créer un autre processus. À ce stade, le créateur est appelé processus parent et le processus créé est appelé processus enfant. Le processus enfant peut hériter des ressources appartenant au processus parent ; lorsque le processus enfant est révoqué, les ressources qu'il a obtenues du processus parent doivent être restituées au processus parent ; lorsque le processus parent est révoqué, tous ses processus enfants sont généralement révoqués. en même temps. . Le processus parent et le processus enfant partagent certaines ressources, mais ils ne peuvent pas partager l'espace d'adressage virtuel. Lorsque le processus enfant est créé, des ressources, telles que l'espace d'adressage virtuel, seront allouées au processus enfant.

Bien entendu, le processus parent et le processus enfant peuvent s’exécuter simultanément. Le bloc de contrôle de processus (PCB) est le seul signe de l'existence d'un processus, et chaque processus possède son propre PCB. Le processus parent et le processus enfant ne peuvent pas utiliser la même ressource critique en même temps. Les ressources critiques ne peuvent être utilisées que par un seul processus à la fois (les ressources critiques ont un mécanisme de verrouillage et ne sont accessibles que mutuellement).

Tous les processus créés dans le système Linux sont créés par des processus existants (à l'exception du processus n° 0). Le processus créé est appelé processus enfant et le processus qui crée le processus enfant est appelé processus parent. Les processus Linux sont regroupés dans une structure arborescente.

Événements provoquant l'arrêt du processus

  • Fin normale : indique que la tâche du processus est terminée et est prête à se terminer.

  • Fin anormale : cela signifie qu'un événement anormal s'est produit pendant l'exécution du processus, ce qui a empêché le programme de continuer à s'exécuter, tel qu'une zone de stockage hors limites, une erreur de protection, une instruction illégale, une erreur d'instruction privilégiée, un délai d'exécution, une erreur d'opération arithmétique, Panne d'E/S, etc.

  • Intervention externe : fait référence au processus se terminant à la demande du monde extérieur, comme l'intervention d'un opérateur ou du système d'exploitation, une demande de processus parent et la fin du processus parent.

Le processus par lequel le système d'exploitation termine un processus

  1. Étape 1 : Selon l'identifiant (PID) du processus terminé, récupérez le PCB du processus et lisez-y l'état du processus.

  2. Étape 2 : Si le processus terminé est en cours d'exécution, l'exécution du processus doit être terminée immédiatement et les ressources du processeur doivent être allouées à d'autres processus.

  3. Étape 3 : Si le processus a des processus descendants, tous ses processus descendants doivent être terminés.

  4. Étape 4 : Renvoyez toutes les ressources appartenant au processus à son processus parent ou au système d'exploitation.

  5. Étape 5 : Le PCB est supprimé de la file d'attente.

Visualiser et interpréter des processus individuels

ps - efNous pouvons visualiser le processus actuel du système via la commande sur le système Linux .

  • L'UID est l'identifiant de l'utilisateur (l'UID du processus créé par l'utilisateur root est root. Si je le crée moi-même, ce devrait être mon nom d'utilisateur.

  • PID représente l'ID du processus en cours.

  • PPID représente l'identifiant du processus parent du processus actuel.

Créez le processus n° 1 et le processus n° 2 via le processus n° 0, puis créez un processus en mode utilisateur via le processus n° 1, puis créez un processus en mode noyau via le processus n° 2, générant ainsi une arborescence de processus Linux.

  • 0号进程: Lors du processus d'initialisation du noyau, le processus n°0 sera créé en premier via l'instruction struct task_struct init_task = INIT_TASK(init_task). C'est le seul processus qui n'a pas été généré via fork ou kernel_thread. est le premier dans la liste des processus. Mais ce processus n’est pas un processus au sens propre du terme, il est similaire à la tête d’une liste chaînée. Par conséquent, bien que le processus n°0 ait été créé dans l'état du noyau, nous ne pouvons pas dire que le processus n°0 est le premier processus dans l'état du noyau. Au lieu de cela, nous devons dire que le processus n°2 est le premier processus dans l'état du noyau.

  • 1号进程: Créé en appelant l'instruction kernel_thread(kernel_init, NULL, CLONE_FS) pour passer du mode noyau au mode utilisateur. Le processus n°1 est l'ancêtre de tous les modes utilisateur. Le processus 1 est également appelé processus d'initialisation . Il s'agit du deuxième thread du noyau créé lors de l'initialisation du noyau. Son code d'exécution est la fonction du noyau init(). Tant que le système ne se termine pas, le processus d'initialisation ne se terminera jamais. Il est responsable de la création et de la surveillance des activités de tous les processus en dehors du système d'exploitation.

  • 2号进程: Créé en appelant l'instruction kernel_thread(kthreadd, NULL, ClONE_FS | CLONE_FILES).Le processus n°2 est responsable de la planification et de la gestion de tous les processus de l'état du noyau et est l'ancêtre de tous les processus dans l'état du noyau. (Notez que l'état du noyau ne fait pas de distinction entre les threads et les processus, les processus et les threads sont donc tous deux des tâches).

pstreeCommande pour afficher l'intégralité de l'arborescence des processus,  commande de base Linux --- afficher l'arborescence des processus pstree_weixin_34023863 blog-CSDN blog .

Je suppose que tu aimes

Origine blog.csdn.net/Staokgo/article/details/132630630
conseillé
Classement
du quotidien
Plus
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(2)
2024-06-03(0)
2024-06-02(1)
2024-06-01(0)
2024-05-31(0)

Code World

© 2018 codetd.com