perkamon - en to fr translation catalogue (130 entries)

note: type: TH
en: 2019-08-02
fr: 2 août 2019

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: clone, __clone2 - create a child process
fr: clone, __clone2 - Créer un processus fils (child)

note: type: Plain text
en: /* Prototype for the glibc wrapper function */
fr: /* Prototype de la fonction d'appel d'enrobage de glibc */

note: type: Plain text
en: B<clone>()  creates a new process, in a manner similar to B<fork>(2).
fr: B<clone>() crée un nouveau processus, de façon analogue à B<fork>(2).

note: type: Plain text
en: This page describes both the glibc B<clone>()  wrapper function and the underlying system call on which it is based.  The main text describes the wrapper function; the differences for the raw system call are described toward the end of this page.
fr: Cette page présente à la fois la fonction d'enrobage B<clone>() de glibc et l'appel système sous-jacent sur lequel elle s'appuie. Le texte principal décrit la fonction d'enrobage ; les différences avec l'appel système brut sont précisées plus bas dans l'article.

note: type: Plain text
en: The I<child_stack> argument specifies the location of the stack used by the child process.  Since the child and calling process may share memory, it is not possible for the child process to execute in the same stack as the calling process.  The calling process must therefore set up memory space for the child stack and pass a pointer to this space to B<clone>().  Stacks grow downward on all processors that run Linux (except the HP PA processors), so I<child_stack> usually points to the topmost address of the memory space set up for the child stack.
fr: L'argument I<child_stack> 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 à B<clone> un pointeur sur cet emplacement. Les piles croissent vers le bas sur tous les processeurs implémentant Linux (sauf le HP PA), donc I<child_stack> doit pointer sur la plus haute adresse de l'espace mémoire prévu pour la pile du processus fils.

note: type: Plain text
en: The low byte of I<flags> contains the number of the I<termination signal> sent to the parent when the child dies.  If this signal is specified as anything other than B<SIGCHLD>, then the parent process must specify the B<__WALL> or B<__WCLONE> options when waiting for the child with B<wait>(2).  If no signal is specified, then the parent process is not signaled when the child terminates.
fr: L'octet de poids faible de I<flags> contient le numéro du signal qui sera envoyé au père lorsque le processus fils se terminera. Si ce signal est différent de B<SIGCHLD>, le processus parent doit également spécifier les options B<__WALL> ou B<__WCLONE> lorsqu'il attend la fin du fils avec B<wait>(2). Si aucun signal n'est indiqué, le processus parent ne sera pas notifié de la terminaison du fils.

note: type: TP
en: B<CLONE_CHILD_CLEARTID> (since Linux 2.5.49)
fr: B<CLONE_CHILD_CLEARTID> (depuis Linux 2.5.49)

note: type: TP
en: B<CLONE_CHILD_SETTID> (since Linux 2.5.49)
fr: B<CLONE_CHILD_SETTID> (depuis Linux 2.5.49)

note: type: TP
en: B<CLONE_FILES> (since Linux 2.0)
fr: B<CLONE_FILES> (depuis Linux 2.0)

note: type: TP
en: B<CLONE_FS> (since Linux 2.0)
fr: B<CLONE_FS> (depuis Linux 2.0)

note: type: Plain text
en: If B<CLONE_FS> is set, the caller and the child process share the same filesystem information.  This includes the root of the filesystem, the current working directory, and the umask.  Any call to B<chroot>(2), B<chdir>(2), or B<umask>(2)  performed by the calling process or the child process also affects the other process.
fr: Si l'attribut B<CLONE_FS> est positionné, le processus appelant et le processus fils partagent les mêmes informations concernant le système de fichiers. Ceci inclut la racine du système de fichiers, le répertoire de travail, et l'umask. Tout appel à B<chroot>(2), B<chdir>(2) ou B<umask>(2) effectué par un processus aura également influence sur l'autre processus.

note: type: TP
en: B<CLONE_IO> (since Linux 2.6.25)
fr: B<CLONE_IO> (depuis Linux 2.6.25)

note: type: Plain text
en: If B<CLONE_IO> is set, then the new process shares an I/O context with the calling process.  If this flag is not set, then (as with B<fork>(2))  the new process has its own I/O context.
fr: Si B<CLONE_IO> est défini, alors le nouveau processus partage un contexte d'entrées-sorties avec le processus appelant. Si cet attribut n'est pas défini, alors (comme pour B<fork>(2)) le nouveau processus a son propre contexte d'entrées-sorties.

note: type: Plain text
en: If the kernel is not configured with the B<CONFIG_BLOCK> option, this flag is a no-op.
fr: Si le noyau n'a pas été configuré avec l'option B<CONFIG_BLOCK>, cet attribut n'a aucun effet.

note: type: TP
en: B<CLONE_NEWCGROUP> (since Linux 4.6)
fr: B<CLONE_NEWCGROUP> (depuis Linux 4.6)

note: type: TP
en: B<CLONE_NEWIPC> (since Linux 2.6.19)
fr: B<CLONE_NEWIPC> (depuis Linux 2.6.19)

note: type: Plain text
en: If B<CLONE_NEWIPC> is set, then create the process in a new IPC namespace.  If this flag is not set, then (as with B<fork>(2)), the process is created in the same IPC namespace as the calling process.  This flag is intended for the implementation of containers.
fr: Si B<CLONE_NEWIPC> est défini, alors créer le processus dans un nouvel espace de noms IPC. Si cet attribut n'est pas défini, alors (comme pour B<fork>(2)) le processus est créé dans le même espace de noms IPC que le processus appelant. Cet attribut est sensé être utilisé pour l'implémentation de conteneurs.

note: type: Plain text
en: Objects created in an IPC namespace are visible to all other processes that are members of that namespace, but are not visible to processes in other IPC namespaces.
fr: Les objets créés dans un espace de noms IPC sont visibles pour tous les processus qui sont membres de cet espace de noms, mais ne sont pas visibles pour les processus des autres espaces de noms IPC.

note: type: Plain text
en: When an IPC namespace is destroyed (i.e., when the last process that is a member of the namespace terminates), all IPC objects in the namespace are automatically destroyed.
fr: Quand un espace de noms est détruit (c'est-à-dire, quand le dernier processus membre de cet espace de noms se termine), tous les objets IPC de cet espace de noms sont automatiquement détruits.

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWIPC>.  This flag can't be specified in conjunction with B<CLONE_SYSVSEM>.
fr: Seul un processus disposant de privilèges (B<CAP_SYS_ADMIN>) peut utiliser B<CLONE_NEWIPC>. Cet attribut ne peut pas être employé en association avec B<CLONE_SYSVSEM>.

note: type: Plain text
en: For further information on IPC namespaces, see B<namespaces>(7).
fr: Pour plus d'informations sur les espaces de noms IPC, reportez vous à B<namespaces>(7).

note: type: TP
en: B<CLONE_NEWNET> (since Linux 2.6.24)
fr: B<CLONE_NEWNET> (depuis Linux 2.6.24)

note: type: Plain text
en: (The implementation of this flag was completed only by about kernel version 2.6.29.)
fr: (L'implémentation de cet attribut n'est complète que depuis le noyau 2.6.29.)

note: type: Plain text
en: If B<CLONE_NEWNET> is set, then create the process in a new network namespace.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same network namespace as the calling process.  This flag is intended for the implementation of containers.
fr: Si B<CLONE_NEWNET> est invoqué, alors créer le processus dans un nouvel espace de noms réseau. Si cet attribut n'est pas invoqué, alors (comme pour B<fork>(2)) le processus est créé dans le même espace de noms réseau que le processus appelant. Cet attribut est sensé être utilisé pour l'implémentation de conteneurs.

note: type: Plain text
en: When a network namespace is freed (i.e., when the last process in the namespace terminates), its physical network devices are moved back to the initial network namespace (not to the parent of the process).  For further information on network namespaces, see B<namespaces>(7).
fr: Quand un espace de noms réseau est libéré (c'est-à-dire, quand le dernier processus de l'espace de noms se termine), ses périphériques réseau physiques sont remis dans l'espace de noms réseau initial (pas celui du processus père). Pour en savoir plus sur les espaces de noms réseau, consultez B<namespaces>(7).

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWNET>.
fr: Seul un processus disposant de privilèges (B<CAP_SYS_ADMIN>) peut appeler B<CLONE_NEWNET>.

note: type: TP
en: B<CLONE_NEWNS> (since Linux 2.4.19)
fr: B<CLONE_NEWNS> (depuis Linux 2.4.19)

note: type: Plain text
en: If B<CLONE_NEWNS> is set, the cloned child is started in a new mount namespace, initialized with a copy of the namespace of the parent.  If B<CLONE_NEWNS> is not set, the child lives in the same mount namespace as the parent.
fr: Si l'attribut B<CLONE_NEWNS> est invoqué, le fils cloné démarre dans un nouvel espace de noms de montage, initialisé avec une copie de l'espace de noms du père. Si B<CLONE_NEWNS> n'est pas invoqué, alors le fils existe dans le même espace de noms de montage que le père.

note: See https://lwn.net/Articles/543273/ type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWNS>.  It is not permitted to specify both B<CLONE_NEWNS> and B<CLONE_FS> in the same B<clone>()  call.
fr: Seul un processus disposant de privilèges (B<CAP_SYS_ADMIN>) peut utiliser l'attribut B<CLONE_NEWNS>. Il n'est pas possible de spécifier à la fois B<CLONE_NEWNS> et B<CLONE_FS> pour le même appel B<clone>().

note: type: TP
en: B<CLONE_NEWPID> (since Linux 2.6.24)
fr: B<CLONE_NEWPID> (depuis Linux 2.6.24)

note: This explanation draws a lot of details from http://lwn.net/Articles/259217/ Authors: Pavel Emelyanov <xemul@openvz.org> and Kir Kolyshkin <kir@openvz.org> The primary kernel commit is 30e49c263e36341b60b735cbef5ca37912549264 Author: Pavel Emelyanov <xemul@openvz.org> type: Plain text
en: If B<CLONE_NEWPID> is set, then create the process in a new PID namespace.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same PID namespace as the calling process.  This flag is intended for the implementation of containers.
fr: Si B<CLONE_NEWPID> est invoqué, alors créer le processus dans un nouvel espace de noms de PID. Si cet attribut n'est pas invoqué, alors (comme pour B<fork>(2)) le processus est créé dans le même espace de noms de PID que le processus appelant. Cet attribut est sensé être utilisé pour l'implémentation de conteneurs.

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWPID>.  This flag can't be specified in conjunction with B<CLONE_THREAD> or B<CLONE_PARENT>.
fr: Seul un processus disposant de privilèges (B<CAP_SYS_ADMIN>) peut utiliser B<CLONE_NEWPID>. Cet attribut ne peut être utilisé en association avec B<CLONE_THREAD> ou avec B<CLONE_PARENT>.

note: type: Plain text
en: If B<CLONE_NEWUSER> is set, then create the process in a new user namespace.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same user namespace as the calling process.
fr: Si B<CLONE_NEWUSER> est invoqué, alors le processus est créé dans un nouvel espace de noms utilisateur. Si cet attribut n'est pas invoqué, alors (comme pour B<fork>(2)) le processus est créé dans le même espace de noms utilisateur que le processus appelant.

note: Before Linux 2.6.29, it appears that only CAP_SYS_ADMIN was needed type: Plain text
en: Before Linux 3.8, use of B<CLONE_NEWUSER> required that the caller have three capabilities: B<CAP_SYS_ADMIN>, B<CAP_SETUID>, and B<CAP_SETGID>.  Starting with Linux 3.8, no privileges are needed to create a user namespace.
fr: Avant Linux 3.8, les processus appelant devait disposer de trois capacités pour utiliser B<CLONE_NEWUSER> :  B<CAP_SYS_ADMIN>, B<CAP_SETUID> et B<CAP_SETGID>.  À partir de Linux 3.8, il n'est plus nécessaire de disposer de privilèges pour créer des espaces de noms utilisateur.

note: commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71 https://lwn.net/Articles/543273/ The fix actually went into 3.9 and into 3.8.3. However, user namespaces were, for practical purposes, unusable in earlier 3.8.x because of the various filesystems that didn't support userns. type: Plain text
en: This flag can't be specified in conjunction with B<CLONE_THREAD> or B<CLONE_PARENT>.  For security reasons, B<CLONE_NEWUSER> cannot be specified in conjunction with B<CLONE_FS>.
fr: Cet attribut ne peut être utilisé en association avec B<CLONE_THREAD> ou avec B<CLONE_PARENT>. Pour des raisons de sécurité, B<CLONE_NEWUSER> ne peut pas être utilisé en association avec B<CLONE_FS>.

note: type: TP
en: B<CLONE_NEWUTS> (since Linux 2.6.19)
fr: B<CLONE_NEWUTS> (depuis Linux 2.6.19)

note: type: Plain text
en: If B<CLONE_NEWUTS> is set, then create the process in a new UTS namespace, whose identifiers are initialized by duplicating the identifiers from the UTS namespace of the calling process.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same UTS namespace as the calling process.  This flag is intended for the implementation of containers.
fr: Si B<CLONE_NEWUTS> est défini, alors créer le processus dans un nouvel espace de noms de UTS, dont les identifiants sont initialisés en dupliquant les identifiants de l'espace de noms UTS du processus appelant. Si cet attribut n'est pas défini, alors (comme pour B<fork>(2)) le processus est créé dans le même espace de noms UTS que le processus appelant. Cet attribut est sensé être utilisé pour l'implémentation de conteneurs.

note: type: Plain text
en: A UTS namespace is the set of identifiers returned by B<uname>(2); among these, the domain name and the hostname can be modified by B<setdomainname>(2)  and B<sethostname>(2), respectively.  Changes made to the identifiers in a UTS namespace are visible to all other processes in the same namespace, but are not visible to processes in other UTS namespaces.
fr: Un espace de noms UTS est l'ensemble des identifiants renvoyés par B<uname>(2) ; parmi lesquels le nom de domaine et le nom d'hôte peuvent être modifiés respectivement à l'aide de B<setdomainname>(2) et B<sethostname>(2). Les modifications apportés à ces identifiants dans un espace de noms UTS sont visibles par tous les processus du même espace de noms, mais ne sont pas visibles des processus des autres espaces de noms UTS.

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWUTS>.
fr: Seul un processus disposant de privilèges (B<CAP_SYS_ADMIN>) peut utiliser B<CLONE_NEWUTS>.

note: type: Plain text
en: For further information on UTS namespaces, see B<namespaces>(7).
fr: Pour obtenir plus d'informations sur les espaces de noms UTS, consultez B<namespaces>(7).

note: type: TP
en: B<CLONE_PARENT> (since Linux 2.3.12)
fr: B<CLONE_PARENT> (depuis Linux 2.3.12)

note: type: Plain text
en: If B<CLONE_PARENT> is set, then the parent of the new child (as returned by B<getppid>(2))  will be the same as that of the calling process.
fr: Si B<CLONE_PARENT> est présent, le père du nouveau fils (comme il est indiqué par B<getppid>(2)) sera le même que celui du processus appelant.

note: type: Plain text
en: If B<CLONE_PARENT> is not set, then (as with B<fork>(2))  the child's parent is the calling process.
fr: Si B<CLONE_PARENT> n'est pas fourni, alors (comme pour B<fork>(2)) le père du processus fils sera le processus appelant.

note: type: Plain text
en: Note that it is the parent process, as returned by B<getppid>(2), which is signaled when the child terminates, so that if B<CLONE_PARENT> is set, then the parent of the calling process, rather than the calling process itself, will be signaled.
fr: Remarquez que c'est le processus père, tel qu'indiqué par B<getppid>(2), qui est notifié lors de la fin du fils. Ainsi, si B<CLONE_PARENT> est présent, alors c'est le père du processus appelant, et non ce dernier, qui sera notifié.

note: type: TP
en: B<CLONE_PARENT_SETTID> (since Linux 2.5.49)
fr: B<CLONE_PARENT_SETTID> (depuis Linux 2.5.49)

note: type: TP
en: B<CLONE_PTRACE> (since Linux 2.2)
fr: B<CLONE_PTRACE> (depuis Linux 2.2)

note: type: Plain text
en: If B<CLONE_PTRACE> is specified, and the calling process is being traced, then trace the child also (see B<ptrace>(2)).
fr: Si l'attribut B<CLONE_PTRACE> est positionné et si l'appelant est suivi par un débogueur, alors le fils sera également suivi (consultez B<ptrace>(2)).

note: type: TP
en: B<CLONE_SETTLS> (since Linux 2.5.32)
fr: B<CLONE_SETTLS> (depuis Linux 2.5.32)

note: type: TP
en: B<CLONE_SIGHAND> (since Linux 2.0)
fr: B<CLONE_SIGHAND> (depuis Linux 2.0)

note: type: Plain text
en: If B<CLONE_SIGHAND> is not set, the child process inherits a copy of the signal handlers of the calling process at the time B<clone>()  is called.  Calls to B<sigaction>(2)  performed later by one of the processes have no effect on the other process.
fr: Si B<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 B<clone>(). Les appels à B<sigaction>(2) effectués ensuite depuis un processus n'ont pas d'effets sur l'autre processus.

note: Precisely: Linux 2.6.0-test2 type: Plain text
en: If B<CLONE_STOPPED> is set, then the child is initially stopped (as though it was sent a B<SIGSTOP> signal), and must be resumed by sending it a B<SIGCONT> signal.
fr: Si l'attribut B<CLONE_STOPPED> est positionné, le fils est initialement stoppé (comme s'il avait reçu le signal B<SIGSTOP>), et doit être relancé en lui envoyant le signal B<SIGCONT>.

note: type: TP
en: B<CLONE_SYSVSEM> (since Linux 2.5.10)
fr: B<CLONE_SYSVSEM> (depuis Linux 2.5.10)

note: type: Plain text
en: If B<CLONE_SYSVSEM> is set, then the child and the calling process share a single list of System V semaphore adjustment (I<semadj>)  values (see B<semop>(2)).  In this case, the shared list accumulates I<semadj> values across all processes sharing the list, and semaphore adjustments are performed only when the last process that is sharing the list terminates (or ceases sharing the list using B<unshare>(2)).  If this flag is not set, then the child has a separate I<semadj> list that is initially empty.
fr: Si B<CLONE_SYSVSEM> est positionné, le fils et le processus appelant partagent la même liste de compteurs «\ undo\ » pour les sémaphores System V (consultez B<semop>(2)). Dans ce cas, cette liste regroupe toutes les valeurs I<semadj> des processus partageant cette liste, et les modifications des sémaphores sont effectuées seulement lorsque le dernier processus de la liste se termine (ou cesse de partager la liste en invoquant B<unshare>(2)). Si cet attribut n'est pas utilisé, le fils a une liste «\ undo\ » séparée, initialement vide.

note: Precisely: Linux 2.6.0-test8 type: Plain text
en: If B<CLONE_THREAD> is set, the child is placed in the same thread group as the calling process.  To make the remainder of the discussion of B<CLONE_THREAD> more readable, the term "thread" is used to refer to the processes within a thread group.
fr: Si B<CLONE_THREAD> est présent, le fils est placé dans le même groupe de threads que le processus appelant. Afin de rendre l'explication de B<CLONE_THREAD> plus lisible, le terme «\ thread\ » est utilisé pour parler des processus dans un même groupe de threads.

note: type: Plain text
en: Thread groups were a feature added in Linux 2.4 to support the POSIX threads notion of a set of threads that share a single PID.  Internally, this shared PID is the so-called thread group identifier (TGID) for the thread group.  Since Linux 2.4, calls to B<getpid>(2)  return the TGID of the caller.
fr: Les groupes de threads sont une fonctionnalité ajoutées dans Linux 2.4 pour supporter la notion POSIX d'ensemble de threads partageant un même PID. En interne, ce PID partagé est appelé identifiant de groupe de threads (TGID).Depuis Linux 2.4, l'appel B<getpid>(2) renvoie l'identifiant du groupe de thread de l'appelant.

note: type: Plain text
en: The threads within a group can be distinguished by their (system-wide)  unique thread IDs (TID).  A new thread's TID is available as the function result returned to the caller of B<clone>(), and a thread can obtain its own TID using B<gettid>(2).
fr: Les threads dans un groupe peuvent être distingués par leur identifiant de thread (TID, unique sur le système). Le TID d'un nouveau thread est renvoyé par B<clone>() au processus appelant, et un thread peut obtenir son propre TID en utilisant B<gettid>(2).

note: type: Plain text
en: When a call is made to B<clone>()  without specifying B<CLONE_THREAD>, then the resulting thread is placed in a new thread group whose TGID is the same as the thread's TID.  This thread is the I<leader> of the new thread group.
fr: Quand B<clone>() est appelé sans positionner B<CLONE_THREAD>, le nouveau thread est placé dans un nouveau groupe de thread dont le TGID est identique au TID du nouveau thread. Ce thread est le I<leader> du nouveau groupe.

note: type: Plain text
en: A new thread created with B<CLONE_THREAD> has the same parent process as the caller of B<clone>()  (i.e., like B<CLONE_PARENT>), so that calls to B<getppid>(2)  return the same value for all of the threads in a thread group.  When a B<CLONE_THREAD> thread terminates, the thread that created it using B<clone>()  is not sent a B<SIGCHLD> (or other termination) signal; nor can the status of such a thread be obtained using B<wait>(2).  (The thread is said to be I<detached>.)
fr: Un nouveau thread créé en utilisant B<CLONE_THREAD> a le même processus père que l'appelant de B<clone>() (de même qu'avec B<CLONE_PARENT>), ainsi les appels à B<getppid>(2) renvoient la même valeur à tous les threads dans un même groupe. Lorsqu'un thread créé avec B<CLONE_THREAD> termine, le thread qui a appelé B<clone>() pour le créer ne reçoit pas le signal B<SIGCHLD> (ou autre notification de terminaison)\ ; de même, l'état d'un tel thread ne peut être obtenu par B<wait>(2). Le thread est dit I<détaché>.

note: type: Plain text
en: After all of the threads in a thread group terminate the parent process of the thread group is sent a B<SIGCHLD> (or other termination) signal.
fr: Lorsque tous les threads d'un groupe de threads terminent, le processus parent du groupe reçoit un signal B<SIGCHLD> (ou autre indicateur de terminaison).

note: type: Plain text
en: If any of the threads in a thread group performs an B<execve>(2), then all threads other than the thread group leader are terminated, and the new program is executed in the thread group leader.
fr: Si l'un des threads dans un groupe de threads appelle B<execve>(2), tous les threads sauf le leader sont tués, et le nouveau programme est exécuté dans le leader du groupe de threads.

note: type: Plain text
en: If one of the threads in a thread group creates a child using B<fork>(2), then any thread in the group can B<wait>(2)  for that child.
fr: Si l'un des threads dans un groupe crée un fils avec B<fork>(2), n'importe lequel des threads du groupe peut utiliser B<wait>(2) sur ce fils.

note: type: Plain text
en: Signal dispositions and actions are process-wide: if an unhandled signal is delivered to a thread, then it will affect (terminate, stop, continue, be ignored in)  all members of the thread group.
fr: Les gestions de signaux sont définies au niveau des processus\ : si un signal sans gestionnaire est reçu par un thread, il affectera (tuera, stoppera, relancera, ou sera ignoré par) tous les membres du groupe de threads.

note: type: TP
en: B<CLONE_UNTRACED> (since Linux 2.5.46)
fr: B<CLONE_UNTRACED> (depuis Linux 2.5.46)

note: type: Plain text
en: If B<CLONE_UNTRACED> is specified, then a tracing process cannot force B<CLONE_PTRACE> on this child process.
fr: Si l'attribut B<CLONE_UNTRACED> est positionné, alors un processus traçant le père ne peut pas forcer B<CLONE_PTRACE> pour ce fils.

note: type: TP
en: B<CLONE_VFORK> (since Linux 2.2)
fr: B<CLONE_VFORK> (depuis Linux 2.2)

note: type: Plain text
en: If B<CLONE_VFORK> is set, the execution of the calling process is suspended until the child releases its virtual memory resources via a call to B<execve>(2)  or B<_exit>(2)  (as with B<vfork>(2)).
fr: Si le bit B<CLONE_VFORK> est actif, l'exécution du processus appelant est suspendue jusqu'à ce que le fils libère ses ressources de mémoire virtuelle par un appel B<execve>(2) ou B<_exit>(2) (comme avec B<vfork>(2)).

note: type: Plain text
en: If B<CLONE_VFORK> is not set, then both the calling process and the child are schedulable after the call, and an application should not rely on execution occurring in any particular order.
fr: Si B<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é.

note: type: TP
en: B<CLONE_VM> (since Linux 2.0)
fr: B<CLONE_VM> (depuis Linux 2.0)

note: type: Plain text
en: If B<CLONE_VM> is set, the calling process and the child process run in the same memory space.  In particular, memory writes performed by the calling process or by the child process are also visible in the other process.  Moreover, any memory mapping or unmapping performed with B<mmap>(2)  or B<munmap>(2)  by the child or calling process also affects the other process.
fr: Si le bit B<CLONE_VM> est actif, le processus appelant et le processus fils s'exécutent dans le même espace mémoire. En particulier, les écritures en mémoire effectuées par l'un des processus sont visibles par l'autre. De même toute projection en mémoire, ou toute suppression de projection, effectuées avec B<mmap>(2) ou B<munmap>(2) par l'un des processus affectera également l'autre processus.

note: type: Plain text
en: If B<CLONE_VM> is not set, the child process runs in a separate copy of the memory space of the calling process at the time of B<clone>().  Memory writes or file mappings/unmappings performed by one of the processes do not affect the other, as with B<fork>(2).
fr: Si B<CLONE_VM> n'est pas actif, le processus fils utilisera une copie distincte de l'espace mémoire de l'appelant. Le cliché est réalisé lors de l'invocation de B<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 B<fork>(2).

note: type: SS
en: blackfin, m68k, and sparc
fr: blackfin, m68k, et sparc

note: Mike Frysinger noted in a 2013 mail: these arches don't define __ARCH_WANT_SYS_CLONE: blackfin ia64 m68k sparc type: Plain text
en: The argument-passing conventions on blackfin, m68k, and sparc are different from the descriptions above.  For details, see the kernel (and glibc) source.
fr: Les conventions de passage des arguments sur blackfin, m68k et sparc sont différentes de celles décrites précédemment. Pour plus de détails, se référer aux sources du noyau (et de glibc).

note: type: Plain text
en: On ia64, a different interface is used:
fr: Sur ia64, une interface différente est utilisée\ :

note: type: Plain text
en: B<__clone2>()  operates in the same way as B<clone>(), except that I<child_stack_base> points to the lowest address of the child's stack area, and I<stack_size> specifies the size of the stack pointed to by I<child_stack_base>.
fr: B<__clone2>() fonctionne comme B<clone>(), aux différences suivantes près : I<child_stack_base> pointe sur la plus petite adresse de la pile du fils, et I<stack_size> indique la taille de la pile sur laquelle pointe I<child_stack_base>.

note: type: SS
en: Linux 2.4 and earlier
fr: Linux 2.4 et antérieurs

note: type: Plain text
en: In Linux 2.4 and earlier, B<clone>()  does not take arguments I<ptid>, I<tls>, and I<ctid>.
fr: Sous Linux\ 2.4 et plus anciens, B<clone>() ne prend pas les arguments I<ptid>, I<tls> et I<ctid>.

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: gettid(2) returns current->pid; getpid(2) returns current->tgid; type: Plain text
en: On success, the thread ID of the child process is returned in the caller's thread of execution.  On failure, -1 is returned in the caller's context, no child process will be created, and I<errno> will be set appropriately.
fr: En cas de réussite, le TID du processus fils est renvoyé dans le thread d'exécution de l'appelant. En cas d'échec, -1 est renvoyé dans le contexte de l'appelant, aucun fils n'est créé, et I<errno> contiendra le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Too many processes are already running; see B<fork>(2).
fr: Trop de processus en cours d'exécution. Consultez B<fork>(2).

note: .TP .B EINVAL Precisely one of .B CLONE_DETACHED and .B CLONE_THREAD was specified. (Since Linux 2.6.0-test6.) type: Plain text
en: B<CLONE_THREAD> was specified, but B<CLONE_SIGHAND> was not.  (Since Linux 2.5.35.)
fr: B<CLONE_THREAD> a été spécifié mais pas B<CLONE_SIGHAND>  (depuis Linux 2.5.35).

note: commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71 type: Plain text
en: Both B<CLONE_FS> and B<CLONE_NEWNS> were specified in I<flags>.
fr: Les attributs B<CLONE_NEWNS> et B<CLONE_FS> figurent simultanément dans I<flags>.

note: type: TP
en: B<EINVAL> (since Linux 3.9)
fr: B<EINVAL> (depuis Linux 3.9)

note: type: Plain text
en: Both B<CLONE_NEWUSER> and B<CLONE_FS> were specified in I<flags>.
fr: Les attributs B<CLONE_NEWUSER> et B<CLONE_FS> figurent simultanément dans I<flags>.

note: type: Plain text
en: Both B<CLONE_NEWIPC> and B<CLONE_SYSVSEM> were specified in I<flags>.
fr: Les attributs B<CLONE_NEWIPC> et B<CLONE_SYSVSEM> figurent simultanément dans I<flags>.

note: type: Plain text
en: One (or both) of B<CLONE_NEWPID> or B<CLONE_NEWUSER> and one (or both) of B<CLONE_THREAD> or B<CLONE_PARENT> were specified in I<flags>.
fr: Au moins l'un des attributs B<CLONE_NEWPID> ou B<CLONE_NEWUSER>, et au moins l'un des attributs B<CLONE_THREAD> ou B<CLONE_PARENT> figurent simultanément dans I<flags>.

note: type: Plain text
en: B<CLONE_NEWIPC> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_SYSVIPC> and B<CONFIG_IPC_NS> options.
fr: B<CLONE_NEWIPC> a été spécifié dans I<flags>, mais le noyau n'a pas été configuré avec les options B<CONFIG_SYSVIPC> et B<CONFIG_IPC_NS>.

note: type: Plain text
en: B<CLONE_NEWNET> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_NET_NS> option.
fr: B<CLONE_NEWNET> a été spécifié dans I<flags>, mais le noyau n'a pas été configuré avec l'option B<CONFIG_NET_NS>.

note: type: Plain text
en: B<CLONE_NEWPID> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_PID_NS> option.
fr: B<CLONE_NEWPID> a été spécifié dans I<flags>, mais le noyau n'a pas été configuré avec l'option B<CONFIG_PID_NS>.

note: type: Plain text
en: Cannot allocate sufficient memory to allocate a task structure for the child, or to copy those parts of the caller's context that need to be copied.
fr: Pas assez de mémoire pour copier les parties du contexte du processus appelant qui doivent être dupliquées, ou pour allouer une structure de tâche pour le processus fils.

note: type: TP
en: B<ENOSPC> (since Linux 3.7)
fr: B<ENOSPC> (depuis Linux 3.7)

note: type: Plain text
en: B<CLONE_NEWUSER> was specified in I<flags>, and the call would cause the limit on the number of nested user namespaces to be exceeded.  See B<user_namespaces>(7).
fr: B<CLONE_NEWUSER> a été spécifié dans I<flags>, et l'appel provoquerait un dépassement de la limite du nombre maximum d'espace de noms utilisateur imbriqués. Consultez B<user_namespaces>(7).

note: type: TP
en: B<ENOSPC> (since Linux 4.9)
fr: B<ENOSPC> (depuis Linux 4.9)

note: type: Plain text
en: B<CLONE_NEWUSER> was specified in I<flags>, but either the effective user ID or the effective group ID of the caller does not have a mapping in the parent namespace (see B<user_namespaces>(7)).
fr: B<CLONE_NEWUSER> a été spécifié dans I<flags>, mais l'identifiant utilisateur effectif ou l'identifiant groupe effectif de l'appelant n'a pas de correspondance dans l'espace de noms père (consultez B<user_namespaces>(7)).

note: type: TP
en: B<EPERM> (since Linux 3.9)
fr: B<EPERM> (depuis Linux 3.9)

note: type: TP
en: B<ERESTARTNOINTR> (since Linux 2.6.17)
fr: B<ERESTARTNOINTR> (depuis Linux 2.6.17)

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: B<clone>()  is Linux-specific and should not be used in programs intended to be portable.
fr: B<clone>() est spécifique à Linux et ne doit pas être utilisé dans des programmes conçus pour être portables.

note: type: Plain text
en: On i386, B<clone>()  should not be called through vsyscall, but directly through I<int $0x80>.
fr: Sur i386, B<clone>() ne devrait pas être appelé via vsyscall, mais directement en utilisant I<int $0x80>.

note: type: SH
en: BUGS
fr: BOGUES

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following program demonstrates the use of B<clone>()  to create a child process that executes in a separate UTS namespace.  The child changes the hostname in its UTS namespace.  Both parent and child then display the system hostname, making it possible to see that the hostname differs in the UTS namespaces of the parent and child.  For an example of the use of this program, see B<setns>(2).
fr: Le programme suivant décrit l'usage de B<clone>() dans le but de créer un processus fils qui s'exécute dans un espace de noms UTS distinct. Le processus fils change le nom d'hôte (hostname) dans son propre espace UTS. Les processus père et fils affichent chacun le nom d'hôte qui leur correspond, permettant ainsi de constater la différence des noms d'hôtes dans leurs espaces de noms UTS respectifs.

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en: static int              /* Start function for cloned child */
    childFunc(void *arg)
    {
        struct utsname uts;
fr: static int              /* Commencer la fonction pour le fils cloné */
    childFunc(void *arg)
    {
        struct utsname uts;

note: type: Plain text
en:     /* Change hostname in UTS namespace of child */
fr:     /* Modifier le nom d'hôte dans l'espace de noms UTS du
           processus fils */

note: type: Plain text
en:     /* Retrieve and display hostname */
fr:     /* Récupérer et afficher le nom d'hôte */

note: type: Plain text
en:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename in child:  %s\en", uts.nodename);
fr:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename dans le fils : %s\en", uts.nodename);

note: type: Plain text
en:     /* Keep the namespace open for a while, by sleeping.
           This allows some experimentation--for example, another
           process might join the namespace. */
fr:     /* Rester en sommeil (fonction sleep) pour conserver l'espace
           de noms ouvert pendant un moment. Cela permet de réaliser
           quelques expérimentations — par exemple, un autre processus
           pourrait rejoindre l'espace de noms. */

note: type: Plain text
en:     return 0;           /* Child terminates now */
    }
fr:     return 0;           /* Le processus fils se termine à ce moment */
    }

note: type: Plain text
en: #define STACK_SIZE (1024 * 1024)    /* Stack size for cloned child */
fr: #define STACK_SIZE (1024 * 1024)    /* Taille de la pile pour le
                                           fils cloné */

note: type: Plain text
en: int
    main(int argc, char *argv[])
    {
        char *stack;                    /* Start of stack buffer */
        char *stackTop;                 /* End of stack buffer */
        pid_t pid;
        struct utsname uts;
fr: int
    main(int argc, char *argv[])
    {
        char *stack;                    /* Début du tampon de la pile */
        char *stackTop;                 /* Fin du tampon de la pile */
        pid_t pid;
        struct utsname uts;

note: type: Plain text
en:     if (argc E<lt> 2) {
            fprintf(stderr, "Usage: %s E<lt>child-hostnameE<gt>\en", argv[0]);
            exit(EXIT_SUCCESS);
        }
fr:     if (argc E<lt> 2) {
            fprintf(stderr, "Utilisation : %s E<lt>nom_d_hôte-filsE<gt>\en", argv[0]);
            exit(EXIT_SUCCESS);
        }

note: type: Plain text
en:     /* Allocate stack for child */
fr:     /* Allouer la pile pour le processus fils */

note: type: Plain text
en:     stack = malloc(STACK_SIZE);
        if (stack == NULL)
            errExit("malloc");
        stackTop = stack + STACK_SIZE;  /* Assume stack grows downward */
fr:     stack = malloc(STACK_SIZE);
        if (stack == NULL)
            errExit("malloc");
        stackTop = stack + STACK_SIZE;  /* Pile supposée s'étendre vers
                                           le bas */

note: type: Plain text
en:     /* Create child that has its own UTS namespace;
           child commences execution in childFunc() */
fr:     /* Créer un processus fils disposant de son propre
           espace de noms UTS ; le processus fils débute
           son exécution dans childFunc() */

note: type: Plain text
en:     pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);
        if (pid == -1)
            errExit("clone");
        printf("clone() returned %ld\en", (long) pid);
fr:     pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);
        if (pid == -1)
            errExit("clone");
        printf("clone() a renvoyé %ld\en", (long) pid);

note: type: Plain text
en:     /* Parent falls through to here */
fr:     /* C'est ici que le processus père échoue */

note: type: Plain text
en:     sleep(1);           /* Give child time to change its hostname */
fr:     sleep(1);           /* Laisser le temps au processus fils de
                               changer son nom d'hôte */

note: type: Plain text
en:     /* Display hostname in parent\(aqs UTS namespace. This will be
           different from hostname in child\(aqs UTS namespace. */
fr:     /* Afficher le nom d'hôte pour l'espace de noms UTS du processus père.
           Celui-ci sera différent du nom d'hôte pour l'espace de noms UTS du
           processus fils. */

note: type: Plain text
en:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename in parent: %s\en", uts.nodename);
fr:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename dans le père : %s\en", uts.nodename);

note: type: Plain text
en:     if (waitpid(pid, NULL, 0) == -1)    /* Wait for child */
            errExit("waitpid");
        printf("child has terminated\en");
fr:     if (waitpid(pid, NULL, 0) == -1)    /* Attendre le processus fils */
            errExit("waitpid");
        printf("Fin du processus fils\en");

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.03 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.02 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2019-03-06
fr: 6 mars 2019

note: commit 7eafd7c74c3f2e67c27621b987b28397110d643f https://lwn.net/Articles/312232/ type: Plain text
en: An IPC namespace provides an isolated view of System\ V IPC objects (see B<svipc>(7))  and (since Linux 2.6.30)  POSIX message queues (see B<mq_overview>(7)).  The common characteristic of these IPC mechanisms is that IPC objects are identified by mechanisms other than filesystem pathnames.
fr: Un espace de noms IPC fournit une vue isolée des objets IPC en System V (consultez B<svipc>(7)) et (à partir de Linux 2.6.30) des files d'attente de messages POSIX (consultez B<mq_overview>(7)). Le point commun entre ces mécanismes IPC est que les objets IPC y sont identifiés par d'autres moyens que des chemins d'accès dans des systèmes de fichiers.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 5.01 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.
