Présentation du système Linux

Dans tout ce qui suit, nous appellerons processus (ou tâche) toute exécution d'un programme à un instant donné, le programme constituant en lui-même un objet inerte, rangé sur disque sous la forme d'un fichier ordinaire exécutable. On peut à ce stade distinguer deux types de processus:

• les processus système qui ne sont attachés à aucun terminal, qui sont créés au lancement du système ou à des dates fixées par l'administrateur du système; les premiers ne sont interrompus qu'à l'arrêt du système (citons le swapper, un certain nombre de processus dits démons comme, par exemple, le processus assurant le bon usage de l'imprimante en spoule ou le processus cron, qui permet de lancer des tâches à une date donnée) ;
• les processus lancés par un utilisateur particulier, depuis un terminal donné ou à une date donnée. En particulier, le fait de se loguer sur un terminal, sous une identification donnée, provoque le lancement d'un processus correspondant à l'exécution d'un programme déterminé à l'avance pour chaque utilisateur (une référence du fichier contenant le programme à exécuter est donnée dans le fichier système /etc/passwd). Il s'agit presque toujours d'un processus correspondant à l'exécution d'un interpréteur de langage de commandes commme par exemple le Bash.

Le lancement d'un processus suppose par conséquent le chargement en mémoire centrale (à partir du disque) du programme correspondant en vue de son exécution. La majorité des programmes Linux sont réentrants, c'est-à-dire que si plusieurs utilisateurs demandent l'exécution d'un même programme, une seule copie du programme est placée en mémoire centrale, le système assurant pour chacun des processus correspondants à la gestion d'une zone de données propre à chacun et le bon déroulement de chacun des processus (sauvegarde de registres en particulier). L'éditeur de liens de LINUX (commande ld) fournit ou non (selon les options) des modules exécutables réentrants (zone instructions protégée en écriture).

Un processus possède un certain nombre de caractéristiques:

• une identification (un nombre entier) ;
• un propriétaire (en fait il y en a deux, qui sont des entiers) ;
• un groupe propriétaire (également deux entiers) ;
• un terminal d'attachement ;
• un certain nombre d'autres attributs (comme par exemple la priorité ou le répertoire de travail) sur lesquels nous reviendrons ultérieurement.

Tout utilisateur a la possibilité de connaître la liste des processus qui sont attachés à son terminal à un instant donné, ainsi que les caractéristiques de ces processus, au moyen de cette commande. L'exemple suivant illustre cette commande pour un utilisateur qui vient de se loguer:

Il est possible d'avoir de plus amples informations sur les processus en utilisant des options. Par exemple:

Petite définition de chaque partie du résultat:

• User: le propriétaire du processus, en général l'utilisateur qui a lancé le processus ;
• PID: le numéro d'identification unique du processus. Sont attribués dans l'ordre de lancement des processus. Quand ils atteignent 30.000 ou plus, le nombre recommence à 0. Les numéros de 0 à 5 sont généralement des processus de bas niveau du système d'exploitation qui ne peuvent être tués ;
• %CPU: pourcentage du temps de CPU consacré à l'exécution de ce processus ;
• %MEM: pourcentage de mémoire totale utilisée par ce processus ;
• VSZ: superficie totale de la mémoire virtuelle, en blocs de 1k ;
• RSS: taille réelle de l'ensemble, le chiffre exact de la mémoire physique allouée à ce processus ;
• TTY: terminal associé à ce processus. Le point d'interrogation indique que le processus n'est relié à aucun terminal ;
• STAT: code d'état du processus. Les différents états sont S - repos, R - exécution (sur file d'attente), Z - zombie, N - tâche de faible priorité ;
• START: lorsque le processus a été lancé, ceci indique en heures et minutes depuis quand le programme a été lancé, ou indique depuis combien de jours le processus est lancé si ilfonctionne depuis plus d'une journée ;
• TIME: temps CPU utilisé par le processus depuis le début du lancement ;
• COMMAND: le nom de la commande.

Il y a aussi ps -ef qui est équivalent à ps aux mais qui a l'avantage de fonctionner sur les versions POSIX qu'on trouve sur les autres systèmes Unix.

Les processus peuvent être, en général, interrompus par l'envoi d'un signal depuis le terminal. L'émission de ce signal est provoquée par la frappe de caractères particuliers que nous désignerons par CTRL + C. Ce signal à pour effet d'interrompre tous les processus attachés au terminal depuis lequel il est émis, sauf demande expresse formulée par le processus comme nous le verrons.

Un certain nombre de processus n'acceptent pas les interruptions par ces signaux. C'est le cas, par exemple, des processus associés au Shell, dont on ne peut sortir depuis le terminal que par CTRL + D (indiquant par là la fin des données à interpréter). Nous verrons plus loin comment forcer l'interruption de processus de ce type et, par ailleurs, comment créer soi-même des tâches ayant ces propriétés.

Les processus fournissant des résultats (par exemple ls, who ou ps) les écrivent sur la sortie standard qui est, par défaut, physiquement associée au terminal de lancement du processus (un fichier spécial /dev/tty"numéro du terminal"). De façon analogique, les processus ayant besoin de données extérieures, en cours d'exécution (par exemple mail, write ou sh) les lisent sur l'entrée standard également associée par défaut à ce terminal. Il est possible d'affecter ces fichiers d'entrée et de sortie standards à d'autres dispositifs que la console qui contrôle le processus. Ce fichier peut être un autre fichier spécial ou un fichier ordinaire; la seule contrainte est que l'utilisateur ait l'autorisation d'écriture ou de lecture (suivant le cas) sur ledit fichier. La redirection de la sortie standard d'une commande dans un fichier répond à la syntaxe commande > référence. Si le fichier existe, il est préalablement supprimé.

Il est également possible d'ajouter des résultats d'un processus à la fin d'un fichier (donc sans effacement de son contenu antérieur) par des commandes de la forme commande >> référence comme l'illustre l'exemple suivant:

On constate que la redirection de la sortie standard est sans aucun effet sur le déroulement du processus. De fait, lors de l'apparition d'une erreur, le message d'erreur n'est pas envoyé sur cette sortie, mais un autre fichier standard appelé sortie d'erreur standard également associée de manière standard au terminal. Il est possible de rediriger cette sortie à peu près de la même manière que la commande précédente commande 2 > référence ou commande 2 >> référence.

On peut, de même, rediriger l'entrée standard d'un processus où sont lues les données. Cette redirection répond à la syntaxe commande < référence.

Pour continuer ce premier contact avec l'univers LINUX, nous montrons quelques autres possibilités supplémentaires communes aux différents langages de commandes. Ainsi il est tout d'abord possible d'enchainer deux ou plusieurs processus de façon totalement indépendante et en séquence, le déroulement du premier n'influant pas sur celui du second qui est lancé à la fin de son exécution.

Les enchaînements de commandes que nous venons de voir ont deux caractéristiques essentielles:

• Ils sont séquentiels, c'est-à-dire qu'une commande n'est lancée (et le processus associé créé) que lorsque la précédente est terminée; il n'y a aucun parallélisme dans l'exécution. Eventuellement, comme c'est le cas des différents Shell, un processus en lance un autre et est suspendu jusqu'à la fin du processus qu'il a lancé.
• Les processus sont totalement indépendants, c'est-à-dire que le déroulement de l'un ne dépend pas de celui des précédents. Il n'y a aucun échange d'informations entre les différents processus.

Les utilisateurs disposent d'un mécanisme leur permettant de lancer un certain nombre de processus de façon concurrente (en quelque sorte parallèlement) et communiquant entre eux par l'intermédiaire de tubes (pipes), le système assurant la synchronisation de l'ensemble des processus ainsi lancés. Le principe général de fonctionnement est assez simple: la sortie standard de chaque processus pipé (excepté le dernier) est redirigée sur un tube et l'entrée standard du processus suivant est redirigée sur ce tube, si bien que les données d'un processus sont constituées par les résultats du précédent dans la liste des processus donnés. Examinons sur un exemple simple ce qui se passe exactement:

La commande grep permet de rechercher une chaîne de caractères dans un fichier. La commande ps aux | grep pts/0 entraîne la création de deux processus concurrents, les résultats du premier (correspondant à la commande ps aux) étant envoyés sur un tube. C'est au niveau du tube que le second processus (correspondant à la commande grep pts/0) prend ses données, plutôt qu'au clavier. La sortie standard du processus ps aux a été redirigée sur le tube et l'entrée standard du processus grep pts/0 également. Le système assure la synchronisation de l'ensemble dans le sens où:

• Il suspend le processus lecteur dans le tube lorsque le tube est vide;
• Il suspend le processus écrivain dans le tube lorsque le tube est plein.

Sur ce dernier exemple vous avez pu voir l'existence effective des deux processus (le processus ps aux et le processus grep pts/0).

Une autre facilité particulièrement intéressante qui est offerte aux utilisateurs est la possibilité de lancer des processus en mode batch: ces processus sont dits en arrière-plan ou background et sont tels que le processus Shell qui les crée reprend son exécution après les avoir créés sans attendre leur achèvement. Ce mécanisme permet ainsi à un même utilisateur de lancer depuis un seul poste de travail plusieurs tâches différentes: c'est, avec le mécanisme décrit précédemment, une seconde illustration de l'aspect multitâches du système pour chaque utilisateur. Il faut cependant être conscient que ce procédé au demeurant fort agréable (en effet rien n'est plus pénible que de lancer la compilation d'un programme et de ne pouvoir utiliser son terminal durant toute cette compilation) conduit souvent à surcharger le système et par conséquent cette facilité doit être utilisée à bon escient.

Nous donnons ci-dessous un exemple de création d'un tel processus en arrière-plan correspondant au démarrage de l'éditeur de texte gedit. Le caractère & qui suit la commande indique que le processus créé doit l'être en arrière plan.

Le système répond en indiquant le numéro du processus créé. Il faut savoir qu'un tel processus a les mêmes sortie standard et sortie erreur standard que le processus qui le crée: ainsi en mode standard, les résultats éventuels sont affichés sur l'écran. Il est possible (et fort agréable) d'utiliser les redirections pour ces processus. Par ailleurs les processus ainsi détachés ne sont plus sous le contrôle direct de la console, en ce sens qu'ils ne peuvent plus lire de données au clavier du terminal. Leur entrée standard doit être redirigée, faute de quoi elle sera redirigée par défaut sur le fichier spécial de référence absolue /dev/null qui est, en quelque sorte, un puits sans fond où les utilisateurs peuvent envoyer tout ce dont ils ne veulent pas. Ces processus ne peuvent, par ailleurs, plus être interrompus par le signal correspondant à CTRL + C dont nous avons parlé un peu avant.

L'interruption des processus lancés en background (ce qui est également vrai pour ceux qui ne le sont pas) peut être réalisée de différentes manières:

• soit en se déloguant (c'est-à-dire en signalant au Shell principal du terminal la fin des données par la séquence CTRL + D) cela a pour effet d'interrompre la session de travail sur le terminal et, par voie de conséquence, tous les processus lancés depuis ce terminal (nous verrons plus tard qu'un signal particulier nommé SIGHUP est alors adressé à tous les processus attachés au terminal) ;
• Soit en lançant un processus d'interruption à destination du processus visé; nous verrons également plus tard qu'un certain nombre de signaux peuvent provoquer l'interruption d'un processus. Les signaux sont identifiés par des nombres (le signal correspondant à CTRL + C vaut 2). Signalons dès maintenant qu'il en est un qui ne peut, en aucun cas, être ignoré par les processus et constitue donc une arme absolue contre les processus indésirables: il s'agit du signal 9 (SIGKILL). Un signal peut être adressé directement à un processus au moyen de la commande kill. On lui fournit, en arguments, le numéro du signal et l'identification du processus destinataire. La commande ps est alors particulièrement utile pour retrouver le numéro d'un processus.

La commande kill -9 IDProcessus permet, en toutes circonstances à un utilisateur de tuer un processus de numéro donné depuis n'importe quel terminal; cela est particulièrement important lorsqu'on a perdu pour une raison ou une autre la main à son terminal et que le signal correspondant à la séquence CTRL + C sont sans effet; il est alors nécessaire d'envoyer ce signal d'interruption depuis une autre console. La seule contrainte à ce niveau est que l'on ne peut envoyer un signal à un processus que si l'on en est le propriétaire (à moins d'être le super-utilisateur).

Pour terminer, signalons que le fait de se déloguer avant l'achèvement des processus lancés depuis un terminal en background provoque l'interruption de ces processus (par l'émission d'un signal particulier que nous verrons plus tard). Pour éviter ce phénomène, il existe une commande nohup qui permet aux processus lancés d'ignorer le signal SIGHUP précédent. Ainsi la commande nohup prog "donnees" resultats& peut être lancée juste avant de se déloguer. Il s'agit du lancement en background du processus correspondant à l'exécution du programme de référence prog prenant ses données dans le fichier de référence "données" et écrivant ses résultats dans le fichier de référence "résultats". Le fait de se déloguer n'interrompt alors plus le processus.