Programmation avancée sous Linux

Chaque processus d'un système Linux est identifié par son identifiant de processus unique, quelquefois appelé pid (process ID). Les identifiants de processus sont des nombres de 16 bits assignés de façon séquentielle par Linux aux processus nouvellement créés. Chaque processus a également un processus parent (sauf le processus spécial init, décrit dans la Section 3.4.3, « Processus Zombies »). Vous pouvez donc vous représenter les processus d'un système Linux comme un arbre, le processus init étant la racine. L'identifiant de processus parent (parent process ID), ou ppid, est simplement l'identifiant du parent du processus.

Lorsque vous faites référence aux identifiants de processus au sein d'un programme C ou C++, utilisez toujours le typedef pid_t, défini dans <sys/types.h>. Un programme peut obtenir l'identifiant du processus au sein duquel il s'exécute en utilisant l'appel système getpid() et l'identifiant de son processus parent avec l'appel système getppid(). Par exemple, le programme du Listing printpid affiche son identifiant de processus ainsi que celui de son parent.

#include <stdio.h>
#include <unistd.h>

int main ()
{
  printf ("L'identifiant du processus est %d\n", (int) getpid ());
  printf ("L'identifiant du processus parent est %d\n", (int) getppid ());
  return 0;
}

Notez que si vous invoquez ce programme plusieurs fois, un identifiant de processus différent est indiqué à chaque fois car chaque invocation crée un nouveau processus. Cependant, si vous l'invoquez toujours depuis le même shell, l'identifiant du processus parent (c'est-à-dire l'identifiant de processus du shell) est le même.

La commande ps affiche les processus en cours d'exécution sur votre système. La version GNU/Linux de ps dispose d'un grand nombre d'options car elle tente d'être compatible avec les versions

de ps de plusieurs autres variantes d'UNIX. Ces options contrôlent les processus listés et les informations les concernant qui sont affichées.

Par défaut, invoquer ps affiche les processus contrôlés par le terminal ou la fenêtre de terminal la commande est invoquée. Par exemple:

% ps
  PID TTY       TIME CMD
21693 pts/8 00:00:00 bash
21694 pts/8 00:00:00 ps

Cette invocation de ps montre deux processus. Le premier, bash, est le shell s'exécutant au sein du terminal. Le second est l'instance de ps en cours d'exécution. La première colonne, PID, indique l'identifiant de chacun des processus.

Pour un aperçu plus détaillé des programmes en cours d'exécution sur votre système GNU/Linux, invoquez cette commande:

% ps -e -o pid,ppid,command

L'option -e demande à ps d'afficher tous processus en cours d'exécution sur le système. L'option -o pid,ppid,command indique à ps les informations à afficher sur chaque processus -- dans ce cas, l'identifiant de processus, l'identifiant du processus parent et la commande correspondant au processus.

Avec l'option -o de la commande ps, vous indiquez les informations sur les processus que vous voulez voir s'afficher sous forme d'une liste de valeurs séparées par des virgules. Par exemple, ps -o pid,user,start_time,command affiche l'identifiant de processus, le nom de l'utilisateur propriétaire du processus, l'heure de démarrage du processus et la commande s'exécutant au sein du processus. Consultez la page de manuel de ps pour une liste complète des codes. Vous pouvez utiliser les options -f (full listing, listing complet), -l (long listing) ou -j (jobs listing) pour obtenir trois formats de listing prédéfinis.

Voici les premières et dernières lignes de la sortie de cette commande sur mon système. Elles peuvent différer des vôtres, selon les programmes en cours d'exécution sur votre système:

% ps -e -o pid,ppid,command
  PID PPID COMMAND
    1     0 init [5]
    2     1 [kflushd]
    3     1 [kupdate]
...
21725 21693 xterm
21727 21725 bash
21728 21727 ps -e -o pid,ppid,command

Notez que l'identifiant du processus parent de la commande ps, 21727, est l'identifiant du processus de bash, le shell depuis lequel j'ai invoqué ps. L'identifiant du processus parent de bash est 21725, l'identifiant du processus du programme xterm dans lequel le shell s'exécute.

Vous pouvez tuer un processus en cours d'exécution grâce à la commande kill. Spécifiez simplement sur la ligne de commande l'identifiant du processus à tuer.

La commande kill envoie un signal(Vous pouvez également utiliser la commande kill pour envoyer d'autres signaux à un processus. Reportez-vous à la Section 3.4, « Fin de Processus ») SIGTERM, ou de terminaison au processus. Cela termine le processus, à moins que le programme en cours d'exécution ne gère ou ne masque le signal SIGTERM. Les signaux sont décrits dans la Section 3.3, « Signaux ».

La fonction system de la bibliothèque standard propose une manière simple d'exécuter une commande depuis un programme, comme si la commande avait été tapée dans un shell. En fait, system crée un sous-processus dans lequel s'exécute le shell Bourne standard (/bin/sh) et passe la commande à ce shell pour qu'il l'exécute. Par exemple, le programme du Listing system invoque la commande ls pour afficher le contenu du répertoire racine, comme si vous aviez saisi ls -l / dans un shell.

int main ()
{
  int return_value;
  return_value = system ("ls -l /");
  return return_value;
}

La fonction system renvoie le code de sortie de la commande shell. Si le shell lui-même ne peut pas être lancé, system renvoie 127; si une autre erreur survient, system renvoie -1.

Comme la fonction system utilise un shell pour invoquer votre commande elle est soumise aux fonctionnalités, limitations et failles de sécurité du shell système. Vous ne pouvez pas vous reposer sur la disponibilité d'une version spécifique du shell Bourne. Sur beaucoup de systèmes UNIX, /bin/sh est en fait un lien symbolique vers un autre shell. Par exemple, sur la plupart des systèmes GNU/Linux, /bin/sh pointe vers bash (le Bourne-Again SHell) et des distributions différentes de GNU/Linux utilisent différentes version de bash. Invoquer un programme avec les privilèges root via la fonction system peut donner des résultats différents selon le système GNU/Linux. Il est donc préférable d'utiliser la méthode de fork et exec pour créer des processus.

Les API DOS et Windows proposent la famille de fonctions spawn. Ces fonctions prennent en argument le nom du programme à exécuter et créent une nouvelle instance de processus pour ce programme. Linux ne dispose pas de fonction effectuant tout cela en une seule fois. Au lieu de cela, Linux offre une fonction, fork, qui produit un processus fils qui est l'exacte copie de son processus parent. Linux fournit un autre jeu de fonctions, la famille exec, qui fait en sorte qu'un processus cesse d'être une instance d'un certain programme et devienne une instance d'un autre. Pour créer un nouveau processus, vous utilisez tout d'abord fork pour créer une copie du processus courant. Puis vous utilisez exec pour transformer un de ces processus en une instance du programme que vous voulez créer.

3-2-2-1. Appeler fork et exec▲

int main ()
{
  pid_t child_pid;
  printf ("ID de processus du programme principal : %d\n",(int)getpid ());
  child_pid = fork ();
  if (child_pid != 0) {
    printf ("je suis le processus parent, ID : %d\n", (int) getpid ());
    printf ("Identifiant du processus fils : %d\n", (int) child_pid);
  }
  else
    printf ("je suis le processus fils, ID : %d\n", (int) getpid ());
  return 0;
}

3-2-2-2. Utiliser la Famille de exec▲

3-2-2-3. Utiliser fork et exec▲

#include  <stdio.h>
#include  <stdlib.h>
#include  <sys/types.h>
#include  <unistd.h>
/* Crée un processus fils exécutant un nouveau programme. PROGRAM est le nom 
   du programme à exécuter ; le programme est recherché dans le path.
   ARG_LIST est une liste terminée par NULL de chaînes de caractères à passer 
   au programme comme liste d'arguments. Renvoie l'identifiant du processus
   nouvellement créé. */
int spawn (char* program, char** arg_list)
{
  pid_t child_pid;
  /* Duplique ce processus. */
  child_pid = fork ();
  if (child_pid != 0)
     /* Nous sommes dans le processus parent. */
     return child_pid;
  else {
     /* Exécute PROGRAM en le recherchant dans le path. */
     execvp (program, arg_list);
     /* On ne sort de la fonction execvp uniquement si une erreur survient. */
     fprintf (stderr, "une erreur est survenue au sein de execvp\n");
     abort ();
  }
}
int main ()
{
  /* Liste d'arguments à passer à la commande "ls". */
  char* arg_list[] = {
     "ls",     /* argv[0], le nom du programme. */
     "-l",
     "/",
     NULL      /* La liste d'arguments doit se terminer par NULL.  */
  };
  /* Crée un nouveau processus fils exécutant la commande "ls". Ignore
      l'identifiant du processus fils renvoyé. */
  spawn ("ls", arg_list);
  printf ("Fin du programme principal\n");
  return 0;
}

Linux ordonnance le processus père indépendamment du processus fils; il n'y a aucune garantie sur celui qui sera exécuté en premier ou sur la durée pendant laquelle le premier s'exécutera avant que Linux ne l'interrompe et ne passe la main à l'autre processus (ou à un processus quelconque s'exécutant sur le système). Dans notre cas, lorsque le processus parent se termine, la commande ls peut s'être exécutée entièrement, partiellement ou pas du tout(Une méthode visant à exécuter les deux processus de manière séquentielle est présentée dans la Section 3.4.1, « Attendre la Fin d'un Processus ».). Linux garantit que chaque processus finira par s'exécuter -- aucun processus ne sera à cours de ressources.

Vous pouvez indiquer qu'un processus est moins important -- et devrait avoir une priorité inférieure -- en lui assignant une valeur de priorité d'ordonnancement(NdT. le terme original est niceness (gentillesse), ce qui explique que plus la valeur est grande, plus le processus est « gentil » et donc moins il est prioritaire.) plus grande. Par défaut, chaque processus a une priorité d'ordonnancement de zéro. Une valeur plus élevée signifie que le processus a une priorité d'exécution plus faible; inversement un processus avec une priorité d'ordonnancement plus faible (c'est-à-dire, négative) obtient plus de temps d'exécution.

Pour lancer un programme avec une priorité d'ordonnancement différente de zéro, utilisez la commande nice, en spécifiant la valeur de la priorité d'ordonnancement avec l'option -n. Par exemple, voici comment vous pourriez invoquer la commande sort input.txt > output.txt, une opération de tri longue, avec une priorité réduite afin qu'elle ne ralentisse pas trop le système:

% nice -n 10 sort input.txt > output.txt

Vous pouvez utiliser la commande renice pour changer la priorité d'ordonnancement d'un processus en cours d'exécution depuis la ligne de commande.

Pour changer la priorité d'ordonnancement d'un processus en cours d'exécution par programmation, utilisez la fonction nice. Son argument est une valeur d'ajustement qui est ajoutée à la valeur de la priorité d'ordonnancement du processus qui l'appelle. Souvenez-vous qu'une valeur positive augmente la priorité d'ordonnancement du processus et donc réduit la priorité d'exécution du processus.

Notez que seuls les processus disposant des privilèges root peuvent lancer un processus avec une priorité d'ordonnancement négative ou réduire la valeur de la priorité d'ordonnancement d'un processus en cours d'exécution. Cela signifie que vous ne pouvez passer des valeurs négatives aux commandes nice et renice que lorsque vous êtes connecté en tant que root et seul un processus s'exécutant avec les privilèges root peut passer une valeur négative à la fonction nice. Cela évite que des utilisateurs ordinaires puissent s'approprier tout le temps d'exécution.

Si vous avez saisi et exécuté l'exemple de fork et exec du Listing forkexec, vous pouvez avoir remarqué que la sortie du programme ls apparaît souvent après la fin du programme principal. Cela est dû au fait que le processus fils, au sein duquel s'exécute ls, est ordonnancé indépendamment du processus père. Comme Linux est un système d'exploitation multitâche, les deux processus semblent s'exécuter simultanément et vous ne pas prédire si le programme ls va s'exécuter avant ou après le processus père.

Dans certaines situations, cependant, il est souhaitable que le processus père attende la fin d'un ou plusieurs processus fils. Pour cela, il est possible d'utiliser les appels systèmes de la famille de wait. Ces fonctions vous permettent d'attendre la fin d'un processus et permettent au processus parent d'obtenir des informations sur la façon dont s'est terminé son fils. Il y a quatre appels système différents dans la famille de wait; vous pouvez choisir de récupérer peu ou beaucoup d'informations sur le processus qui s'est terminé et vous pouvez indiquer si vous voulez savoir quel processus fils s'est terminé.

La fonction la plus simple s'appelle simplement wait. Elle bloque le processus appelant jusqu'à ce qu'un de ses processus fils se termine (ou qu'une erreur survienne). Elle retourne un code de statut via un pointeur sur un entier, à partir duquel vous pouvez extraire des informations sur la façon dont s'est terminé le processus fils. Par exemple, la macro WEXITSTATUS extrait le code de sortie du processus fils.

Vous pouvez utiliser la macro WIFEXITED pour déterminer si un processus s'est terminé correctement à partir de son code de statut (via la fonction exit ou la sortie de main) ou est mort à cause d'un signal non intercepté. Dans ce dernier cas, utilisez la macro WTERMSIG pour extraire le numéro du signal ayant causé la mort du processus à partir du code de statut.

Voici une autre version de la fonction main de l'exemple de fork et exec. Cette fois, le processus parent appelle wait pour attendre que le processus fils, dans lequel s'exécute la commande ls, se termine.

int main ()
{
  int child_status;
  /* Liste d'arguments à passer à la commande "ls". */
  char* arg_list[] = {
     "ls",     /* argv[0], le nom du programme. */
     "-l",
     "/",
     NULL      /* La liste d'arguments doit se terminer par NULL.  */
  };
  /* Crée un nouveau processus fils exécutant la commande "ls". Ignore
      l'identifiant du processus fils renvoyé. */
  spawn ("ls", arg_list);
  /* Attend la fin du processus fils. */
  wait (&child_status);
  if (WIFEXITED (child_status))
    printf ("processus fils terminé normalement, le code de sortie %d\n",
             WEXITSTATUS (child_status));
  else
    printf ("processus fils terminé anormalement\n");
  return 0;
}

Plusieurs appels système similaires sont disponibles sous Linux, ils sont plus flexibles ou apportent plus d'informations sur le processus fils se terminant. La fonction waitpid peut être utilisée pour attendre la fin d'un processus fils spécifique au lieu d'attendre n'importe quel processus fils. La fonction wait3 renvoie des statistiques sur l'utilisation du processeur par le

processus fils se terminant et la fonction wait4 vous permet de spécifier des options supplémentaires quant au processus dont on attend la fin.

Si un processus fils se termine alors que son père appelle la fonction wait, le processus fils disparaît et son statut de terminaison est transmis à son père via l'appel à wait. Mais que se passe-t-il lorsqu'un processus se termine et que son père n'appelle pas wait? Disparaît-il tout simplement? Non, car dans ce cas, les informations concernant la façon dont il s'est terminé -- comme le fait qu'il se soit terminé normalement ou son code de sortie -- seraient perdues. Au lieu de cela, lorsqu'un processus fils se termine, il devient un processus zombie.

Un processus zombie est un processus qui s'est terminé mais dont les ressources n'ont pas encore été libérées. Il est de la responsabilité du processus père de libérer les ressources occupées par ses fils zombies. La fonction wait le fait, il n'est donc pas nécessaire de savoir si votre processus fils est toujours en cours d'exécution avant de l'attendre. Supposons, par exemple, qu'un programme crée un processus fils, fasse un certain nombre d'autres opérations puis appelle wait. Si le processus fils n'est pas encore terminé à ce moment, le processus parent sera bloqué dans l'appel de wait jusqu'à ce que le processus fils se termine. Si le processus fils se termine avant que le père n'appelle wait, il devient un processus zombie. Lorsque le processus parent appelle wait, le statut de sortie du processus fils est extrait, le processus fils est supprimé et l'appel de wait se termine immédiatement.

Que se passe-t-il si le père ne libère pas les ressources de ses fils? Ils restent dans le système, sous la forme de processus zombies. Le programme du Listing zombie crée un processus fils qui se termine immédiatement, puis s'interrompt pendant une minute, sans jamais libérer les ressources du processus fils.

#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int main ()
{
  pid_t child_pid;
  /* Crée un processus fils. */
  child_pid = fork ();
  if (child_pid > 0) {
    /* Nous sommes dans le processus parent. Attente d'une minute. */
    sleep (60);
  }
  else {
    /* Nous sommes dans le processus fils. Sortie immédiate. */
    exit (0);
  }
  return 0;
}

Compilez ce fichier en un exécutable appelé make-zombie. Exécutez-le, et pendant ce temps, listez les processus en cours d'exécution sur le système par le biais de la commande suivante dans une autre fenêtre:

% ps -e -o pid,ppid,stat,cmd

Elle dresse la liste des identifiants de processus, de processus pères, de leur statut et de la ligne de commande du processus. Observez qu'en plus du processus père make-zombie, un autre processus make-zombie est affiché. Il s'agit du processus fils; notez que l'identifiant de son père est celui du processus make-zombie principal. Le processus fils est marqué comme <defunct> et son code de statut est Z pour zombie.

Que se passe-t-il lorsque le programme principal de make-zombie se termine sans appeler wait? Le processus zombie est-il toujours présent? Non -- essayez de relancer ps et notez que les deux processus make-zombie ont disparu. Lorsqu'un programme se termine, un processus spécial hérite de ses fils, le programme init, qui s'exécute toujours avec un identifiant de processus valant 1 (il s'agit du premier processus lancé lorsque Linux démarre). Le processus init libère automatiquement les ressources de tout processus zombie dont il hérite.

Si vous utilisez un processus fils uniquement pour appeler exec, il est suffisant d'appeler wait immédiatement dans le processus parent, ce qui le bloquera jusqu'à ce que le processus fils se termine. Mais souvent, vous voudrez que le processus père continue de s'exécuter alors qu'un ou plusieurs fils s'exécutent en parallèle. Comment être sûr de libérer les ressources occupées par tous les processus fils qui se sont terminés afin de ne pas laisser de processus zombie dans la nature, ce qui consomme des ressources?

Une approche envisageable serait que le processus père appelle périodiquement wait3 et wait4 pour libérer les ressources des fils zombies. Appeler wait de cette façon ne fonctionne pas de manière optimale car si aucun fils ne s'est terminé, l'appelant sera bloqué jusqu'à ce que ce soit le cas. Cependant, wait3 et wait4 prennent un paramètre d'option supplémentaire auquel vous pouvez passer le drapeau WNOHANG. Avec ce drapeau, la fonction s'exécute en mode non bloquant -- elle libérera les ressources d'un processus fils terminé s'il y en a un ou se terminera s'il n'y en a pas. La valeur de retour de l'appel est l'identifiant du processus fils s'étant terminé dans le premier cas, zéro dans le second.

Une solution plus élégante est d'indiquer au processus père quand un processus fils se termine. Il y a plusieurs façons de le faire en utilisant les méthodes présentées dans le Chapitre 5, « Communication Interprocessus », mais heureusement, Linux le fait pour vous, en utilisant les signaux. Lorsqu'un processus fils se termine, Linux envoie au processus père le signal SIGCHLD. L'action par défaut pour ce signal est de ne rien faire, c'est la raison pour laquelle vous pouvez ne jamais l'avoir remarqué auparavant.

Donc, une façon élégante de libérer les ressources des processus fils est de gérer SIGCHLD. Bien sûr, lorsque vous libérez les ressources du processus fils, il est important de stocker son statut de sortie si cette information est nécessaire, car une fois que les ressources du processus fils ont été libérées par wait, cette information n'est plus disponible. Le Listing sigchld montre à quoi ressemble un programme utilisant un gestionnaire pour SIGCHLD afin de libérer les ressources de ses processus fils.

#include <signal.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
sig_atomic_t child_exit_status;
void clean_up_child_process (int signal_number)
{
  /* Nettoie le ou les processus fils. */
  int status;
  while(waitpid (-1, &amp;status, WNOHANG));
  /* Stocke la statut de sortie du dernier dans une variable globale.  */
  child_exit_status = status;
}
int main ()
{
  /* Gère SIGCHLD en appelent clean_up_child_process. */
  struct sigaction sigchld_action;
  memset (&amp;sigchld_action, 0, sizeof (sigchld_action));
  sigchld_action.sa_handler = &amp;clean_up_child_process;
  sigaction (SIGCHLD, &amp;sigchld_action, NULL);
  /* Faire diverses choses, entre autres créer un processus fils.  */
  /* ... */
  return 0;
}

Notez comment le gestionnaire de signal stocke le statut de sortie du processus fils dans une variable globale, à laquelle le programme principal peut accéder. Comme la variable reçoit une valeur dans un gestionnaire de signal, elle est de type sig_atomic_t.