clone | Début | Suivant | Sommaire | Préc.page.lue | Accueil |
NOM | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
SYNOPSIS | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
#define _GNU_SOURCE #include <sched.h> int clone(int (*fn)(void *), void *pile_fils, int flags, void *arg, ... /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
DESCRIPTION | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Contrairement à fork(2), cette routine permet le partage d'une partie du contexte d'exécution entre le processus fils et le processus appelant. Le partage peut s'appliquer sur l'espace mémoire, sur la table des descripteurs de fichiers, la table des gestionnaires de signaux... (Notez que sur cette page de manuel, le « processus appelant » correspond normalement au « processus père », mais voyez quand même la description de CLONE_PARENT plus bas).
L'appel système clone() est principalement utilisé pour permettre l'implémentation des threads : un programme est scindé en plusieurs lignes de contrôle, s'exécutant simultanément dans un espace mémoire partagée.
Quand le processus fils est créé, avec clone(), il exécute la fonction fn(arg) de l'application. (Ceci est différent de fork(2) avec lequel l'exécution continue dans le fils au point de l'appel fork(2)) L'argument fn est un pointeur sur la fonction appelée par le processus fils lors de son démarrage. L'argument arg est transmis à la fonction fn lors de son invocation.
Quand la fonction fn(arg) revient, le processus fils se termine. La valeur entière renvoyée par fn est utilisée comme code de retour du processus fils. Ce dernier peut également se terminer de manière explicite en invoquant la fonction exit(2) ou après la réception d'un signal fatal.
L'argument pile_fils indique l'emplacement de la pile utilisée par le processus fils. Comme les processus fils et appelant peuvent partager de la mémoire, il n'est généralement pas possible pour le fils d'utiliser la même pile que son père. Le processus appelant doit donc préparer un espace mémoire pour stocker la pile de son fils, et transmettre à clone() un pointeur sur cet emplacement. Les piles croissent vers le bas sur tous les processeurs implémentant Linux (sauf le HP PA), donc pile_fils doit pointer sur la plus haute adresse de l'espace mémoire prévu pour la pile du processus fils.
L'octet de poids faible de flags contient le numéro du signal de terminaison qui sera envoyé au père lorsque le processus fils se terminera. Si ce signal est différent de SIGCHLD, le processus parent doit également spécifier les options __WALL ou __WCLONE lorsqu'il attend la fin du fils avec wait(2). Si aucun signal n'est indiqué, le processus parent ne sera pas notifié de la terminaison du fils.
flags permet également de préciser ce qui sera partagé entre le père et le fils, en effectuant un OU binaire entre zéro ou plusieurs des constantes suivantes :
Si CLONE_PARENT n'est pas fourni, alors (comme pour fork(2)) le père du processus fils sera le processus appelant.
Remarquez que c'est le processus père, tel qu'indiqué par getppid(2), qui est notifié lors de la fin du fils. Ainsi, si CLONE_PARENT est présent, alors c'est le père du processus appelant, et non ce dernier, qui sera notifié.
Si CLONE_FS n'est pas choisi, le processus travaille sur une copie des informations de l'appelant concernant le système de fichiers. Cette copie est effectuée lors de l'invocation de clone(). Les appels à chroot(2), chdir(2), umask(2) effectués par un processus n'affectent pas l'autre processus.
Si CLONE_FILES n'est pas positionné, le processus fils hérite d'une copie des descripteurs de fichiers ouverts par l'appelant au moment de l'appel clone(). (Les descripteurs de fichiers dupliqués dans le fils font référence aux mêmes descriptions de fichiers ouverts (voir open(2)) que les descripteurs de fichiers correspondant dans le processus appelant.) Les opérations ultérieures qui ouvrent ou ferment les descripteurs de fichiers, ou modifient les drapeaux des descripteurs de fichiers, effectuées soit par le processus appelant soit par le processus fils, n'affectent pas l'autre processus.
Chaque processus se trouve dans un espace de noms. Cet espace de noms du processus regroupe les données décrivant la hiérarchie des fichiers vus par le processus (l'ensemble des montages). Après un fork(2) ou clone() sans l'attribut CLONE_NEWNS le fils se déroule dans le même espace de nom que son père. Les appels système mount(2) et umount(2) modifient l'espace de noms du processus appelant, et affectent ainsi tous les processus se déroulant dans le même espace, sans affecter les processus se trouvant dans d'autres espaces.
Après un clone() avec l'attribut CLONE_NEWNS le fils cloné démarre dans un nouvel espace de noms, initialisé avec une copie de l'espace du père.
Seul un processus privilégié (un processus ayant la capacité CAP_SYS_ADMIN) peut spécifier l'attribut CLONE_NEWNS. Il n'est pas possible de spécifier à la fois CLONE_NEWNS et CLONE_FS pour le même appel clone().
Si CLONE_SIGHAND n'est pas utilisé, le processus fils hérite d'une copie des gestionnaires de signaux de l'appelant lors de l'invocation de clone(). Les appels à sigaction(2) effectués ensuite depuis un processus n'ont pas d'effets sur l'autre processus.
Depuis Linux 2.6.0-test6, flags doit également inclure CLONE_VM si CLONE_SIGHAND est spécifié
Si CLONE_VFORK n'est pas indiqué, alors les deux processus sont ordonnancés à partir de la fin de l'appel, et l'application ne doit pas considérer que l'ordre d'exécution soit déterminé.
Si CLONE_VM n'est pas actif, le processus fils utilisera une copie distincte de l'espace mémoire de l'appelant. Le cliché étant réalisé lors de l'invocation de clone(). Les écritures ou les projections de fichiers en mémoire effectuées par un processus n'affectent pas l'autre processus, comme cela se passe avec fork(2).
Les groupes de threads sont une fonctionnalité ajoutée dans Linux 2.1 pour gérer la notion POSIX de threads d'un ensemble de threads qui partagent un seul PID. De manière interne, ce PID partagé est ainsi appelé identifiant de groupe de threads (TGID) pour le groupe de thread. Depuis Linux 2.4, les appels à getpid(2) renvoient le TGID de l'appelant.
Les threads dans un groupe peuvent être différenciés par (à l'échelle du système) leur identifiant de thread unique (TID). Un nouveau TID est disponible comme le résultat d'une fonction renvoyé à l'appelant de clone(), et un thread peut obtenir son propre TID en utilisant gettid(2).
Lorsqu'un appel à clone() est effectué sans spécifier CLONE_THREAD, le thread résultant est placé dans un nouveau groupe de threads dont le TGId est identique au TID du thrEad. Ce thread est le leader de ce nouveau group de threads
Un nouveau thread créé avec CLONE_THREAD a le même processus parent comme l'appelant de clone() (c'est-à-dire comme CLONE_PARENT), aussi, les appels à getppid(2) renvoient la même valeur pour tous les threads d'un groupe de threads. Lorsqu'un thread CLONE_THREAD se termine, le thread créé par clone() ne se voit pas envoyer de signal SIGCHLD (ou tout autre signal de terminaison) ; on ne peut également pas obtenir l'état d'un tel thread en utilisant wait(2). (Le thread est dit détaché.)
Après que tous les threads d'un groupe de threads se terminent, un signal SIGCHLD (ou tout autre signal de terminaison) est envoyé au processus parent du groupe de threads.
Si l'un des threads dans un groupe de threads effectue un execve(2), tous les threads autres que le leader du groupe se terminent, et le nouveau programme s'exécute dans le leader du groupe de threads.
Si l'un des threads d'un groupe de threads crée un fils avec fork(2), chaque thread du groupe peut attendre (wait(2)) ce fils.
Depuis Linux 2.5.35, flags doit inclure CLONE_SIGHAND si CLONE_THREAD est spécifié.
Les signaux peuvent être envoyés à un groupe de thread dans son ensemble (c'est-à-dire TGID) en utilisant kill(2), ou bien à un thread particulier (c'est-à-dire TID) en utilisant tgkill(2).
Les dispositions et actions des signaux sont à l'échelle du système : si un signal non géré est délivré à un thread, cela affectera (terminaison, stop, continuation, ignoré) tous les membres du groupe de threads.
Chaque thread a son propre masque de signal, configuré avec sigprocmask(2), mais les signaux peuvent être pendant soit pour le processus entier (c'est-à-dire pour chaque membre du groupe de threads), lorsqu'ils sont envoyés par kill(2) soit pour un thread individuel lorsqu'ils sont envoyés par tgkill(2). Un appel a sigpending(2) renvoie un ensemble de signaux qui est l'union des signaux pendants pour le processus entier et des signaux pendants pour le thread appelant.
Si kill(2) est utilisé pour envoyer un signal à un groupe de thread et que ce groupe a installé un gestionnaire pour le signal, le gestionnaire sera invoqué dans exactement un des membres du groupe de threads, arbitrairement sélectionné, qui n'a pas bloqué le signal. Si plusieurs threads dans un groupe sont en attente du même signal en utilisant sigwaitinfo(2), le noyau en sélectionnera arbitrairement un pour recevoir le signal envoyé avec kill(2).
sys_clone | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Une autre différence : pour sys_clone, l'argument pile_fils peut être nul, puisque la sémantique de copie-en-écriture assure que le fils recevra une copie indépendante des pages de la pile dès qu'un des deux processus la modifiera. Pour que cela fonctionne, il faut naturellement que CLONE_VM ne soit PAS présent.
Depuis Linux 2.5.49, l'appel système a cinq paramètres. Les deux nouveaux paramètres sont parent_tidptr qui pointe à l'endroit (dans la mémoire du père et celle du fils) où l'ID du thread fils sera écrit au cas où CLONE_PARENT_SETTID serait spécifié, et child_tidptr qui pointe à l'endroit (dans la mémoire du fils) où l'ID du thread fils sera écrit au cas où CLONE_CHILD_SETTID serait spécifié.
VALEUR RENVOYÉE | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
ERREURS | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
VERSIONS | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
CONFORMITÉ | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
NOTES | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Sur x86, clone() ne devrait pas être appelé à travers vsyscall, mais directement à travers int $0x80.
Sur ia64, un appel système différent est utilisé :
int __clone2(int (*fn)(void *), void *child_stack_base, size_t stack_size, int flags, void *arg, ... /* pid_t *pid, struct user_desc *tls, pid_t *ctid */ );
L'appel système __clone2() opère de la même manière que clone(), excepté que child_stack_base pointe sur l'adresse la plus basse de la zone de pile du fils et que stack_size spécifie la taille de la pile pointée par child_stack_base.
BOGUES | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
#include <syscall.h> pid_t mypid; mypid = syscall(SYS_getpid);
VOIR AUSSI | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
TRADUCTION | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 14 octobre 1996, mise à jour par Alain Portal <aportal AT univ-montp2 DOT fr> le 15 juin 2006 et révisée le 6 juin 2008.
L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 2 clone ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.
Sommaire | Début | Suivant | Sommaire | Préc.page.lue | Accueil |
Table des mots clés | Début | Suivant | Sommaire | Préc.page.lue | Accueil |
CLONE_CHILD_CLEARTID (depuis Linux 2.5.49) | DESCRIPTION |
CLONE_CHILD_SETTID (depuis Linux 2.5.49) | DESCRIPTION |
CLONE_FILES | DESCRIPTION |
CLONE_FS | DESCRIPTION |
CLONE_NEWNS | DESCRIPTION |
CLONE_PARENT | DESCRIPTION |
CLONE_PARENT_SETTID (depuis Linux 2.5.49) | DESCRIPTION |
CLONE_PID | DESCRIPTION |
CLONE_PTRACE | DESCRIPTION |
CLONE_SETTLS (depuis Linux 2.5.32) | DESCRIPTION |
CLONE_SIGHAND | DESCRIPTION |
CLONE_STOPPED (depuis Linux 2.6.0-test2) | DESCRIPTION |
CLONE_SYSVSEM (depuis Linux 2.5.10) | DESCRIPTION |
CLONE_THREAD | DESCRIPTION |
CLONE_UNTRACED (depuis Linux 2.5.46) | DESCRIPTION |
CLONE_VFORK | DESCRIPTION |
CLONE_VM | DESCRIPTION |
EAGAIN | ERREURS |
EINVAL | ERREURS |
ENOMEM | ERREURS |
EPERM | ERREURS |