L’étape fork()¶

Depuis la glibc 2.24, la fonction posix_spawn() commence par appeler clone(2) avec les drapeaux CLONE_VM et CLONE_VFORK. Les implémentations plus anciennes utilisent fork(2) ou même vfork(2) (voir ci-dessous).

L'identifiant du nouveau processus enfant est placé dans *pid. La fonction posix_spawn() rend alors la main au processus appelant.

Ensuite, le parent peut utiliser l'un des appels système décrits dans wait(2) pour vérifier l’état du processus enfant. Si l'enfant échoue dans n'importe laquelle des étapes de nettoyage décrites ci-dessous ou n'arrive pas à exécuter le fichier indiqué, il retourne avec un état 127.

Avant la glibc 2.24, le processus enfant est créé avec vfork(2) au lieu de fork(2) lorsqu'une des conditions suivantes est remplie :

• l'élément spawn-flags de l'objet d'attributs sur lequel attrp pointe contient le drapeau POSIX_SPAWN_USEVFORK spécifique à GNU ; ou
• file_actions est NULL et l'élément spawn-flags de l'objet d'attributs sur lequel pointe attrp ne contient pas POSIX_SPAWN_SETSIGMASK, POSIX_SPAWN_SETSIGDEF, POSIX_SPAWN_SETSCHEDPARAM, POSIX_SPAWN_SETSCHEDULER, POSIX_SPAWN_SETPGROUP ou POSIX_SPAWN_RESETIDS.

En d'autres termes, vfork(2) est utilisée si l'appelant le demande ou si aucun nettoyage n'est attendu dans l'enfant avant qu'il n'exec(3)ute le fichier demandé.

L’étape pré-exec() : nettoyage¶

Entre les étapes fork() et exec(), un processus enfant peut avoir à effectuer un ensemble d'actions de nettoyage. Les fonctions posix_spawn() et posix_spawnp() prennent en charge un ensemble, petit et bien déterminé, de tâches système que l'enfant peut accomplir avant d'exécuter le fichier exécutable. Ces opérations sont contrôlées par l'objet d'attributs sur lequel attrp pointe et l'objet d'actions sur fichier sur lequel file_actions pointe. Dans l'enfant, le traitement est fait dans l'ordre suivant :

1.

Actions d'attributs de processus : masque de signaux, gestionnaires de signaux par défaut, algorithme d'ordonnancement et paramètres, groupe du processus, et les identifiants d'utilisateur et de groupe effectifs sont changés comme indiqué dans l'objet d'attributs vers lequel attrp pointe.

2.

Les actions sur fichier, telles qu'indiquées dans l'argument file_action, sont effectuées dans l'ordre dans lequel elles ont été spécifiées par les appels aux fonctions posix_spawn_file_actions_add*().

3.

Les descripteurs de fichiers avec le drapeau FD_CLOEXEC sont fermés.

Tous les attributs de processus de l'enfant, autres que ceux affectés par les attributs indiqués dans l'objet vers lequel attrp pointe et par les actions sur fichier indiquées dans l'objet vers lequel file_actions pointe, seront affectés comme si l'enfant avait été créé par fork(2) et que le programme avait été exécuté par execve(2).

Les actions d'attributs de processus sont définies par l'objet d'attributs vers lequel attrp pointe. L'attribut spawn-flags (indiqué par un appel à posix_spawnattr_setflags(3)) contrôle les actions globales effectuées, et les autres attributs de l'objet déterminent les valeurs utilisées durant ces actions.

Les effets des drapeaux qui peuvent être indiqués dans spawn-flags sont les suivants :

POSIX_SPAWN_SETSIGMASK

Fixe le masque de signaux à l'ensemble donné dans l'attribut spawn-sigmask de l'objet vers lequel attrp pointe. Si le drapeau POSIX_SPAWN_SETSIGMASK n'est pas levé, alors l'enfant hérite du masque de signaux de son parent.

POSIX_SPAWN_SETSIGDEF

Réétablit la disposition de tous les signaux indiqués dans l'attribut spawn-sigdefault de l'objet vers lequel attrp pointe à la valeur par défaut. Pour le traitement des dispositions de signaux non spécifiées dans l'attribut spawn-sigdefault ou le traitement lorsque POSIX_SPAWN_SETSIGDEF n'est pas spécifié, consultez execve(2).

POSIX_SPAWN_SETSCHEDPARAM

Si ce drapeau est levé et que le drapeau POSIX_SPAWN_SETSCHEDULER n'est pas levé, fixer alors les paramètres de l'ordonnanceur aux paramètres définis dans l'attribut spawn-schedparam de l'objet sur lequel attrp pointe.

POSIX_SPAWN_SETSCHEDULER

Fixe l'algorithme de stratégie d'ordonnancement et les paramètres de l'enfant comme suit :

POSIX_SPAWN_RESETIDS

Si le drapeau est levé, réinitialiser les UID et GID effectifs aux UID et GID réels du processus parent. Si ce drapeau n'est pas indiqué, alors l'enfant conserve les UID et GID effectifs du processus parent. Dans les deux cas, si les bits de permission set-user-ID et set-group-ID sont activés sur le fichier exécutable, leur effet surcharge la valeur des UID et GID effectifs (voir execve(2)).

POSIX_SPAWN_SETPGROUP

Fixer le groupe du processus à la valeur indiquée dans l'attribut spawn-pgroup de l'objet sur lequel attrp pointe. Si l'attribut spawn-pgroup à une valeur de 0, l'identifiant de groupe du processus enfant est rendu identique à l'identifiant de processus. Si le drapeau POSIX_SPAWN_SETPGROUP n'est pas levé, l'enfant hérite de l'identifiant de groupe du processus parent.

POSIX_SPAWN_USEVFORK

Depuis la version 2.24 de la glibc, ce drapeau n'a aucun effet. Sur des implémentations plus anciennes, lever ce drapeau force l’étape fork() à utiliser vfork(2) à la place de fork(2). La macro de test de fonctionnalités _GNU_SOURCE doit être définie pour obtenir une définition de cette constante.

POSIX_SPAWN_SETSID (depuis la glibc 2.26)

Si ce drapeau est levé, le processus enfant doit créer une nouvelle session et devenir le responsable de cette session. Le processus enfant doit aussi devenir le responsable du nouveau groupe du processus de la session (voir setid(2)). La macro de test de fonctionnalités _GNU_SOURCE doit être définie pour obtenir la définition de cette constante.

Si attrp est NULL, alors les comportements par défaut décrits plus haut pour chaque drapeau s'appliquent.

L'argument file_actions indique une séquence d'opérations sur fichier effectuées dans le processus enfant après le traitement général décrit plus haut et avant de faire l’étape exec(). Si file_actions est NULL, aucune action spécifique n'est effectuée et la sémantique standard de exec(3) s'applique : les descripteurs de fichier ouverts avant exec() restent ouverts dans le nouveau processus à l'exception de ceux pour lesquels le drapeau FD_CLOEXEC a été levé. Les verrous de fichier restent en place.

Si file_actions n'est pas NULL, il contient un ensemble ordonné de demandes pour exécuter open(2), close(2) et dup2() sur des fichiers . Ces requêtes sont ajoutées à file_actions par posix_spawn_file_actions_addopen(3), posix_spawn_file_actions_addclose(3) et posix_spawn_file_actions_adddup2(3). Les opérations demandées sont effectuées dans l'ordre dans lequel elles ont été ajoutées à file_actions.

Si une des actions de nettoyage échoue (à cause de mauvaises valeurs ou pour toute autre raison pour laquelle la gestion de signaux, l'ordonnancement de processus, les fonctions d'identifiant de groupe de processus ou d'opérations de descripteur de fichier peuvent échouer), le processus enfant termine avec un code de retour de 127.

L’étape exec()¶

Une fois que l'enfant s'est dédoublé sans erreur et a exécuté toutes les étapes pré-exec(), l'enfant lance l'exécutable souhaité.

Le processus enfant récupère son environnement depuis l'argument envp, analysé comme si execve(2) avait été appelé avec. Les arguments du processus créé viennent de l'argument argv, analysé comme pour execve(2).

Source du programme¶

#include <spawn.h>
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>
#include <errno.h>
#define errExit(msg)    do { perror(msg); \


                             exit(EXIT_FAILURE); } while (0)
#define errExitEN(en, msg) \


                        do { errno = en; perror(msg); \


                             exit(EXIT_FAILURE); } while (0)
char **environ;
int
main(int argc, char *argv[])
{


    pid_t child_pid;


    int s, opt, status;


    sigset_t mask;


    posix_spawnattr_t attr;


    posix_spawnattr_t *attrp;


    posix_spawn_file_actions_t file_actions;


    posix_spawn_file_actions_t *file_actionsp;


    /* Lire les options de la ligne de commande pouvant être utilisées pour indiquer


       un objet d'attributs et un objet d'actions sur fichier pour l'enfant. */


    attrp = NULL;


    file_actionsp = NULL;


    while ((opt = getopt(argc, argv, "sc")) != -1) {


        switch (opt) {


        case 'c':       /* -c: fermer la sortie standard dans l'enfant */


            /* Créer un objet d'actions de fichier et lui ajouter


               une action "fermer". */


            s = posix_spawn_file_actions_init(&file_actions);


            if (s != 0)


                errExitEN(s, "posix_spawn_file_actions_init");


            s = posix_spawn_file_actions_addclose(&file_actions,


                                                  STDOUT_FILENO);


            if (s != 0)


                errExitEN(s, "posix_spawn_file_actions_addclose");


            file_actionsp = &file_actions;


            break;


        case 's':       /* -s: bloquer tous les signaux dans l'enfant */


            /* Créer un objet d'attributs et lui ajouter


               une action "établir un masque de signaux". */


            s = posix_spawnattr_init(&attr);


            if (s != 0)


                errExitEN(s, "posix_spawnattr_init");


            s = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSIGMASK);


            if (s != 0)


                errExitEN(s, "posix_spawnattr_setflags");


            sigfillset(&mask);


            s = posix_spawnattr_setsigmask(&attr, &mask);


            if (s != 0)


                errExitEN(s, "posix_spawnattr_setsigmask");


            attrp = &attr;


            break;


        }


    }


    /* Créer l'enfant. Le nom du programme à exécuter et les arguments de


       la ligne de commande sont récupérés dans les arguments de la ligne


       de commande de ce programme. L'environnement du programme exécuté


       dans l'enfant est identique à l'environnement du parent. */


    s = posix_spawnp(&child_pid, argv[optind], file_actionsp, attrp,


                     &argv[optind], environ);


    if (s != 0)


        errExitEN(s, "posix_spawn");


    /* Détruire tout objet créé précédemment. */


    if (attrp != NULL) {


        s = posix_spawnattr_destroy(attrp);


        if (s != 0)


            errExitEN(s, "posix_spawnattr_destroy");


    }


    if (file_actionsp != NULL) {


        s = posix_spawn_file_actions_destroy(file_actionsp);


        if (s != 0)


            errExitEN(s, "posix_spawn_file_actions_destroy");


    }


    printf("PID de l'enfant : %jd\n", (intmax_t) child_pid);


    /* Observer l’état de l'enfant jusqu'à son arrêt. */


    do {


        s = waitpid(child_pid, &status, WUNTRACED | WCONTINUED);


        if (s == -1)


            errExit("waitpid");


        printf("Statut de l'enfant : ");


        if (WIFEXITED(status)) {


            printf("terminé, état=%d\n", WEXITSTATUS(status));


        } else if (WIFSIGNALED(status)) {


            printf("tué par le signal %d\n", WTERMSIG(status));


        } else if (WIFSTOPPED(status)) {


            printf("arrêté par le signal %d\n", WSTOPSIG(status));


        } else if (WIFCONTINUED(status)) {


            printf("reprise\n");


        }


    } while (!WIFEXITED(status) && !WIFSIGNALED(status));


    exit(EXIT_SUCCESS);
}