perkamon - en to fr translation catalogue (431 entries)

note: type: TH
en: 2012-03-15
fr: 15 mars 2012

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: CPU_SET, CPU_CLR, CPU_ISSET, CPU_ZERO, CPU_COUNT, CPU_AND, CPU_OR, CPU_XOR, CPU_EQUAL, CPU_ALLOC, CPU_ALLOC_SIZE, CPU_FREE, CPU_SET_S, CPU_CLR_S, CPU_ISSET_S, CPU_ZERO_S, CPU_COUNT_S, CPU_AND_S, CPU_OR_S, CPU_XOR_S, CPU_EQUAL_S - macros for manipulating CPU sets
fr: CPU_SET, CPU_CLR, CPU_ISSET, CPU_ZERO, CPU_COUNT, CPU_AND, CPU_OR, CPU_XOR, CPU_EQUAL, CPU_ALLOC, CPU_ALLOC_SIZE, CPU_FREE, CPU_SET_S, CPU_CLR_S, CPU_ISSET_S, CPU_ZERO_S, CPU_COUNT_S, CPU_AND_S, CPU_OR_S, CPU_XOR_S, CPU_EQUAL_S - macros de manipulation d'un «\ ensemble de CPUs\ »

note: type: Plain text
en: B<#define _GNU_SOURCE>             /* See feature_test_macros(7) */
    B<#include E<lt>sched.hE<gt>>
fr: B<#define _GNU_SOURCE>             /* Consultez feature_test_macros(7) */
    B<#include E<lt>sched.hE<gt>>

note: type: Plain text
en: The I<cpu_set_t> data structure represents a set of CPUs.  CPU sets are used by B<sched_setaffinity>(2)  and similar interfaces.
fr: La structure de données I<cpu_set_t> représente un «\ ensemble de CPUs\ ». Les «\ ensembles de CPUs\ » sont utilisés par B<sched_setaffinity>(2) et les interfaces similaires.

note: type: Plain text
en: The I<cpu_set_t> data type is implemented as a bitset.  However, the data structure treated as considered opaque: all manipulation of CPU sets should be done via the macros described in this page.
fr: Le type I<cpu_set_t> est un champ de bits. Cependant, la structure de données traitée est considérée comme opaque\ : toute manipulation d'un «\ ensemble de CPU\ » devrait être effectuée avec les macros décrites dans cette page.

note: type: Plain text
en: The following macros are provided to operate on the CPU set I<set>:
fr: Les macros suivantes sont fournies pour opérer sur l'ensemble I<set>\ :

note: type: Plain text
en: Clears I<set>, so that it contains no CPUs.
fr: Mettre à zéro I<set>, ainsi, il ne contient aucun CPU.

note: type: Plain text
en: Add CPU I<cpu> to I<set>.
fr: Ajouter le CPU I<cpu> à I<set>.

note: type: Plain text
en: Remove CPU I<cpu> from I<set>.
fr: Supprimer le CPU I<cpu> de I<set>.

note: type: Plain text
en: Test to see if CPU I<cpu> is a member of I<set>.
fr: Tester si le CPU I<cpu> est un membre de I<set>.

note: type: Plain text
en: Return the number of CPUs in I<set>.
fr: Renvoyer le nombre de CPU de I<set>.

note: type: Plain text
en: Where a I<cpu> argument is specified, it should not produce side effects, since the above macros may evaluate the argument more than once.
fr: Lorsque l'argument I<cpu> est spécifié, il ne devrait pas produire d'effet de bord puisque les macros ci-dessus pourraient évaluer l'argument plus d'une fois.

note: type: Plain text
en: The first available CPU on the system corresponds to a I<cpu> value of 0, the next CPU corresponds to a I<cpu> value of 1, and so on.  The constant B<CPU_SETSIZE> (currently 1024) specifies a value one greater than the maximum CPU number that can be stored in I<cpu_set_t>.
fr: Le premier CPU disponible sur un système correspond à la valeur I<cpu> 0, le CPU suivant à la valeur I<cpu> 1. La constante B<CPU_SETSIZE> (habituellement 1024) spécifie le nombre maximal de CPUs qui peut être enregistré dans I<cpu_set_t>.

note: type: Plain text
en: The following macros perform logical operations on CPU sets:
fr: Les macros suivantes réalisent des opérations logiques sur les «\ ensembles de CPUs\ »\ :

note: type: Plain text
en: Store the intersection of the sets I<srcset1> and I<srcset2> in I<destset> (which may be one of the source sets).
fr: Enregistre l'intersection (ET logique) des ensembles I<srcset1> et I<srcset2> dans I<destset> (qui peut être un ensemble source).

note: type: Plain text
en: Store the union of the sets I<srcset1> and I<srcset2> in I<destset> (which may be one of the source sets).
fr: Enregistre l'union (OU logique) des ensembles I<srcset1> et I<srcset2> dans I<destset> (qui peut être un ensemble source).

note: type: Plain text
en: Store the XOR of the sets I<srcset1> and I<srcset2> in I<destset> (which may be one of the source sets).  The XOR means the set of CPUs that are in either I<srcset1> or I<srcset2>, but not both.
fr: Enregistre le OU EXCLUSIF logique des ensembles I<srcset1> et I<srcset2> dans I<destset> (qui peut être un ensemble source). Le OU EXCLUSIF signifie que les ensembles appartiennent soit à I<srcset1>, soit à I<srcset2>, mais pas aux deux à la fois.

note: type: Plain text
en: Test whether two CPU set contain exactly the same CPUs.
fr: Tester si deux ensembles de CPUs contiennent les mêmes CPUs.

note: type: SS
en: Dynamically sized CPU sets
fr: Ensemble de CPUs de taille dynamique

note: type: Plain text
en: Because some applications may require the ability to dynamically size CPU sets (e.g., to allocate sets larger than that defined by the standard I<cpu_set_t> data type), glibc nowadays provides a set of macros to support this.
fr: Certaines applications nécessite des ensembles CPUs de taille dynamique (par exemple, pour allouer des ensembles plus grands que ceux définis avec le type I<cpu_set_t>), la glibc propose aujourd'hui un jeu de macro pour cette fonctionnalité.

note: type: Plain text
en: The following macros are used to allocate and deallocate CPU sets:
fr: Les macros suivantes sont utilisées pour allouer et désallouer des ensembles de CPUs\ :

note: type: Plain text
en: Allocate a CPU set large enough to hold CPUs in the range 0 to I<num_cpus-1>.
fr: Allouer un ensemble CPUs assez grand pour contenir I<num_cpus-1> CPU.

note: type: Plain text
en: Return the size in bytes of the CPU set that would be needed to hold CPUs in the range 0 to I<num_cpus-1>.  This macro provides the value that can be used for the I<setsize> argument in the B<CPU_*_S>()  macros described below.
fr: Renvoie la taille en octets de l'ensemble CPUs nécessaire pour contenir les I<num_cpus-1> cpu. Cette macro fournit la valeur de l'argument I<setsize> des macros B<CPU_*_S>() définies ci-dessous.

note: type: Plain text
en: Free a CPU set previously allocated by B<CPU_ALLOC>().
fr: Libérer un ensemble alloué avec B<CPU_ALLOC>().

note: type: Plain text
en: The macros whose names end with "_S" are the analogs of the similarly named macros without the suffix.  These macros perform the same tasks as their analogs, but operate on the dynamically allocated CPU set(s) whose size is I<setsize> bytes.
fr: Les macros dont le nom se termine par «\ _S\ » sont les macros équivalentes aux macros sans «\ _S\ » qui opèrent sur les ensembles de taille dynamique de taille I<setsize>.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: B<CPU_ISSET>()  and B<CPU_ISSET_S>()  return nonzero if I<cpu> is in I<set>; otherwise, it returns 0.
fr: B<CPU_ISSET>()  et B<CPU_ISSET_S>() renvoient une valeur non nulle si I<cpu> est présent dans I<set>, 0 sinon.

note: type: Plain text
en: B<CPU_COUNT>()  and B<CPU_COUNT_S>()  return the number of CPUs in I<set>.
fr: B<CPU_COUNT>() et B<CPU_COUNT_S>() renvoient le nombre de CPUs présent dans I<set>.

note: type: Plain text
en: B<CPU_EQUAL>()  and B<CPU_EQUAL_S>()  return nonzero if the two CPU sets are equal; otherwise it returns 0.
fr: B<CPU_EQUAL>() et B<CPU_EQUAL_S>() renvoient une valeur non nulle si les deux ensemble CPUs sont égaux, 0 sinon.

note: type: Plain text
en: B<CPU_ALLOC>()  returns a pointer on success, or NULL on failure.  (Errors are as for B<malloc>(3).)
fr: B<CPU_ALLOC>() renvoie un pointeur en cas de succès et NULL en cas d'échec. Les erreurs sont les mêmes que B<malloc>(3).

note: type: Plain text
en: B<CPU_ALLOC_SIZE>()  returns the number of bytes required to store a CPU set of the specified cardinality.
fr: B<CPU_ALLOC_SIZE>() renvoie le nombre d'octets nécessaire pour sauvegarder un ensemble avec une cardinalité spécifique.

note: type: Plain text
en: The other functions do not return a value.
fr: Les autres fonctions ne renvoient pas de valeur.

note: type: Plain text
en: The B<CPU_ZERO>(), B<CPU_SET>(), B<CPU_CLR>(), and B<CPU_ISSET>()  macros were added in glibc 2.3.3.
fr: Les macros B<CPU_ZERO>(), B<CPU_SET>(), B<CPU_CLR>() et B<CPU_ISSET>() ont été ajoutées dans la glibc\ 2.3.3.

note: type: Plain text
en: B<CPU_COUNT>()  first appeared in glibc 2.6.
fr: B<CPU_COUNT>() est apparue dans le glibc2.6.

note: type: Plain text
en: B<CPU_AND>(), B<CPU_OR>(), B<CPU_XOR>(), B<CPU_EQUAL>(), B<CPU_ALLOC>(), B<CPU_ALLOC_SIZE>(), B<CPU_FREE>(), B<CPU_ZERO_S>(), B<CPU_SET_S>(), B<CPU_CLR_S>(), B<CPU_ISSET_S>(), B<CPU_AND_S>(), B<CPU_OR_S>(), B<CPU_XOR_S>(), and B<CPU_EQUAL_S>()  first appeared in glibc 2.7.
fr: B<CPU_AND>(), B<CPU_OR>(), B<CPU_XOR>(), B<CPU_EQUAL>(), B<CPU_ALLOC>(), B<CPU_ALLOC_SIZE>(), B<CPU_FREE>(), B<CPU_ZERO_S>(), B<CPU_SET_S>(), B<CPU_CLR_S>(), B<CPU_ISSET_S>(), B<CPU_AND_S>(), B<CPU_OR_S>(), B<CPU_XOR_S>() et B<CPU_EQUAL_S>() sont apparues en premier dans la glibc\ 2.7.

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

note: type: Plain text
en: These interfaces are Linux-specific.
fr: Ces interfaces sont spécifiques à Linux.

note: type: Plain text
en: To duplicate a CPU set, use B<memcpy>(3).
fr: Pour dupliquer un ensemble, utilisez B<memcpy>(3).

note: type: Plain text
en: Since CPU sets are bitsets allocated in units of long words, the actual number of CPUs in a dynamically allocated CPU set will be rounded up to the next multiple of I<sizeof(unsigned long)>.  An application should consider the contents of these extra bits to be undefined.
fr: Comme les ensembles de CPUs sont des champs de bits alloués par unité de mots de type I<long>, le nombre actuel de CPUs dans un ensemble dynamique doit être arrondi au multiple suivant de I<sizeof(unsigned long)>. Une application doit considérer les bits non utilisés comme indéfinis.

note: type: Plain text
en: Notwithstanding the similarity in the names, note that the constant B<CPU_SETSIZE> indicates the number of CPUs in the I<cpu_set_t> data type (thus, it is effectively a count of bits in the bitset), while the I<setsize> argument of the B<CPU_*_S>()  macros is a size in bytes.
fr: Notez que la constante B<CPU_SETSIZE> indique le nombre de CPUs dans la structure I<cpu_set_t> (c'est un comptage de bits dans le champ de bits) alors que l'argument I<setsize> des macros B<CPU_*_S>() est une taille en octets.

note: type: Plain text
en: The data types for arguments and return values shown in the SYNOPSIS are hints what about is expected in each case.  However, since these interfaces are implemented as macros, the compiler won't necessarily catch all type errors if you violate the suggestions.
fr: Les types de données des arguments et des valeurs de retour vues dans le SYNOPSIS sont des suggestions sur ce qui est prévu dans chaque cas. Cependant, puisque ces interfaces sont des macros, le compilateur ne va pas nécessairement attraper toutes les erreurs de type si vous violez ces suggestions.

note: type: SH
en: BUGS
fr: BOGUES

note: http://sourceware.org/bugzilla/show_bug.cgi?id=7029 type: Plain text
en: On 32-bit platforms with glibc 2.8 and earlier, B<CPU_ALLOC>()  allocates twice as much space as is required, and B<CPU_ALLOC_SIZE>()  returns a value twice as large as it should.  This bug should not affect the semantics of a program, but does result in wasted memory and less efficient operation of the macros that operate on dynamically allocated CPU sets.  These bugs are fixed in glibc 2.9.
fr: Sur une plate-forme 32\ bits avec une glibc\ 2.8 ou plus récente, B<CPU_ALLOC>() alloue deux fois plus d'espace que nécessaire, et B<CPU_ALLOC_SIZE>() renvoie une valeur deux fois plus grande que la valeur attendue. Ce bogue ne devrait pas affecter la sémantique d'un programme mais il provoque une surconsommation mémoire et les macros opérant sur un ensemble dynamique sont moins performantes. Ce bogue est corrigé avec la glibc\ 2.9.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following program demonstrates the use of some of the macros used for dynamically allocated CPU sets.
fr: Le programme suivant est un exemple d'utilisation de macros dans le cas d'un ensemble de CPUs dynamique.

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

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

note: type: TH
en: 2014-02-27
fr: 27 février 2014

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: /* Prototype for the raw system call */
fr: /* Prototype de l'appel système brut */

note: type: Plain text
en: Feature Test Macro Requirements for glibc wrapper function (see B<feature_test_macros>(7)):
fr: Conditions requises par la macro de test de fonctionnalités pour la fonction d'enrobage de glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<clone>():
fr: B<clone>() :

note: type: TP
en: Since glibc 2.14:
fr: À partir de glibc 2.14 :

note: See http://sources.redhat.com/bugzilla/show_bug.cgi?id=4749 type: TP
en: Before glibc 2.14:
fr: Avant glibc 2.14 :

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE
        /* _GNU_SOURCE also suffices */
fr: _BSD_SOURCE || _SVID_SOURCE
        /* _GNU_SOURCE est également suffisant */

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: Unlike B<fork>(2), B<clone>()  allows the child process to share parts of its execution context with the calling process, such as the memory space, the table of file descriptors, and the table of signal handlers.  (Note that on this manual page, "calling process" normally corresponds to "parent process".  But see the description of B<CLONE_PARENT> below.)
fr: Contrairement à B<fork>(2), B<clone>() 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 ou 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 B<CLONE_PARENT> plus bas).

note: type: Plain text
en: The main use of B<clone>()  is to implement threads: multiple threads of control in a program that run concurrently in a shared memory space.
fr: L'appel système B<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.

note: type: Plain text
en: When the child process is created with B<clone>(), it executes the function I<fn>(I<arg>).  (This differs from B<fork>(2), where execution continues in the child from the point of the B<fork>(2)  call.)  The I<fn> argument is a pointer to a function that is called by the child process at the beginning of its execution.  The I<arg> argument is passed to the I<fn> function.
fr: Quand le processus fils est créé par B<clone>(), il exécute la fonction I<fn>(I<arg>). Ceci est différent de B<fork>(2),  pour lequel l'exécution continue dans le processus fils à partir du moment de l'appel de B<fork>(2). L'argument I<fn> est un pointeur vers la fonction appelée par le processus fils lors de son démarrage. L'argument I<arg> est transmis à la fonction I<fn> lors de son invocation.

note: type: Plain text
en: When the I<fn>(I<arg>)  function application returns, the child process terminates.  The integer returned by I<fn> is the exit code for the child process.  The child process may also terminate explicitly by calling B<exit>(2)  or after receiving a fatal signal.
fr: Quand la fonction I<fn>(I<arg>) revient, le processus fils se termine. La valeur entière renvoyée par I<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 B<exit>(2) ou après la réception d'un signal fatal.

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: Plain text
en: I<flags> may also be bitwise-or'ed with zero or more of the following constants, in order to specify what is shared between the calling process and the child process:
fr: I<flags> permet également de préciser ce qui sera partagé entre le père et le fils, en effectuant un OU binaire entre une ou plusieurs des constantes suivantes\ :

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: Plain text
en: Erase child thread ID at location I<ctid> in child memory when the child exits, and do a wakeup on the futex at that address.  The address involved may be changed by the B<set_tid_address>(2)  system call.  This is used by threading libraries.
fr: Effacer l'ID du thread enfant à I<ctid> dans la mémoire du fils lorsqu'il se termine, et réveiller le futex à cette adresse. L'adresse concernée peut être modifiée par l'appel système B<set_tid_address>(2). Cela est utilisé dans les bibliothèques de gestion de threads.

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: Plain text
en: Store child thread ID at location I<ctid> in child memory.
fr: Enregistrer l'ID du thread enfant à I<ctid> dans la mémoire du fils.

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

note: type: Plain text
en: If B<CLONE_FILES> is set, the calling process and the child process share the same file descriptor table.  Any file descriptor created by the calling process or by the child process is also valid in the other process.  Similarly, if one of the processes closes a file descriptor, or changes its associated flags (using the B<fcntl>(2)  B<F_SETFD> operation), the other process is also affected.
fr: Si l'attribut B<CLONE_FILES> est positionné, le processus appelant et le processus fils partagent la même table des descripteurs de fichier. Tout descripteur créé par un processus est également valide pour l'autre processus. De même si un processus ferme un descripteur, ou modifie ses attributs (en utilisant l'opération B<fcntl>(2) B<F_SETFD>), l'autre processus en est aussi affecté.

note: type: Plain text
en: If B<CLONE_FILES> is not set, the child process inherits a copy of all file descriptors opened in the calling process at the time of B<clone>().  (The duplicated file descriptors in the child refer to the same open file descriptions (see B<open>(2))  as the corresponding file descriptors in the calling process.)  Subsequent operations that open or close file descriptors, or change file descriptor flags, performed by either the calling process or the child process do not affect the other process.
fr: Si B<CLONE_FILES> n'est pas positionné, le processus fils hérite d'une copie des descripteurs de fichier ouverts par l'appelant au moment de l'appel B<clone>(). (Les copies des descripteurs de fichier dans le fils sont associées aux mêmes descriptions de fichiers ouverts (consultez B<open>(2)) que les descripteurs de fichier correspondants dans le processus appelant.) Les opérations effectuées ensuite sur un descripteur par un des processus n'affectent pas l'autre processus.

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: Plain text
en: If B<CLONE_FS> is not set, the child process works on a copy of the filesystem information of the calling process at the time of the B<clone>()  call.  Calls to B<chroot>(2), B<chdir>(2), B<umask>(2)  performed later by one of the processes do not affect the other process.
fr: Si B<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 B<clone>(). Les appels à B<chroot>(2), B<chdir>(2), B<umask>(2) effectués par un processus n'affectent pas 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: The following based on text from Jens Axboe the anticipatory and CFQ scheduler with CFQ and AS. type: Plain text
en: The I/O context is the I/O scope of the disk scheduler (i.e, what the I/O scheduler uses to model scheduling of a process's I/O).  If processes share the same I/O context, they are treated as one by the I/O scheduler.  As a consequence, they get to share disk time.  For some I/O schedulers, if two processes share an I/O context, they will be allowed to interleave their disk access.  If several threads are doing I/O on behalf of the same process (B<aio_read>(3), for instance), they should employ B<CLONE_IO> to get better I/O performance.
fr: Le contexte d'entrées-sorties correspond à la visibilité que l'ordonnanceur de disques a des entrées-sorties (c'est-à-dire, ce que l'ordonnanceur d'entrée-sorties utilise pour modéliser l'ordonnancement des entrées-sorties d'un processus). Si des processus partagent le même contexte d'entrées-sorties, ils sont traités comme un seul par l'ordonnanceur d'entrées-sorties. Par conséquent, ils partagent le même temps d'accès aux disques. Pour certains ordonnanceurs d'entrées-sorties, si deux processus partagent un contexte d'entrées-sorties, ils seront autorisés à intercaler leurs accès disque. Si plusieurs threads utilisent des entrées-sorties pour le même processus (B<aio_read>(3), par exemple), ils devraient utiliser B<CLONE_IO> pour obtenir de meilleurs performances 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_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: 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: 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: Use of this flag requires: a kernel configured with the B<CONFIG_SYSVIPC> and B<CONFIG_IPC_NS> options and that the process be privileged (B<CAP_SYS_ADMIN>).  This flag can't be specified in conjunction with B<CLONE_SYSVSEM>.
fr: Utiliser cet attribut nécessite : un noyau configuré avec les options B<CONFIG_SYSVIPC> et B<CONFIG_IPC_NS> et que le processus soit privilégié (B<CAP_SYS_ADMIN>). Cet attribut ne peut pas être utilisé en même temps que B<CLONE_SYSVSEM>.

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

note: FIXME Check when the implementation was completed 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 défini, alors créer le processus dans un nouvel espace de noms réseau. 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 réseau que le processus appelant. Cet attribut est sensé être utilisé pour l'implémentation de conteneurs.

note: FIXME Add pointer to veth(4) page when it is eventually completed type: Plain text
en: A network namespace provides an isolated view of the networking stack (network device interfaces, IPv4 and IPv6 protocol stacks, IP routing tables, firewall rules, the I</proc/net> and I</sys/class/net> directory trees, sockets, etc.).  A physical network device can live in exactly one network namespace.  A virtual network device ("veth") pair provides a pipe-like abstraction that can be used to create tunnels between network namespaces, and can be used to create a bridge to a physical network device in another namespace.
fr: Un espace de noms réseau fournit une vue isolée de la pile réseau (interfaces des périphériques réseau, piles des protocoles IPv4 et IPv6, tables de routage, règles de pare-feu, les arbres de répertoire I</proc/net> et I</sys/class/net>, les sockets, etc.). Un périphérique réseau physique ne peut être que dans un seul espace de noms réseau. Une paire d'interface réseau virtuelle (« veth ») fournit une abstraction similaire à pipe qui peut être utilisé pour créer un pont vers une interface réseau physique d'un autre espace de noms réseau.

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).
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).

note: type: Plain text
en: Use of this flag requires: a kernel configured with the B<CONFIG_NET_NS> option and that the process be privileged (B<CAP_SYS_ADMIN>).
fr: Utiliser cet attribut nécessite : un noyau configuré avec l'option B<CONFIG_NET_NS> et que le processus soit privilégié (B<CAP_SYS_ADMIN>).

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: Start the child in a new mount namespace.
fr: Démarrer le processus dans un nouvel espace de noms de montage.

note: type: Plain text
en: Every process lives in a mount namespace.  The I<namespace> of a process is the data (the set of mounts) describing the file hierarchy as seen by that process.  After a B<fork>(2)  or B<clone>()  where the B<CLONE_NEWNS> flag is not set, the child lives in the same mount namespace as the parent.  The system calls B<mount>(2)  and B<umount>(2)  change the mount namespace of the calling process, and hence affect all processes that live in the same namespace, but do not affect processes in a different mount namespace.
fr: Chaque processus se trouve dans un espace de noms de montage. Cet I<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 B<fork>(2) ou B<clone>() sans l'attribut B<CLONE_NEWNS> le fils se déroule dans le même espace de noms de montage que son père. Les appels système B<mount>(2) et B<umount>(2) modifient l'espace de noms de montage du processus appelant, et affectent ainsi tous les processus se déroulant dans le même espace de noms, sans affecter les processus se trouvant dans d'autres espaces de noms de montage.

note: type: Plain text
en: After a B<clone>()  where the B<CLONE_NEWNS> flag is set, the cloned child is started in a new mount namespace, initialized with a copy of the namespace of the parent.
fr: Après un B<clone>() avec l'attribut B<CLONE_NEWNS> 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.

note: type: Plain text
en: Only a privileged process (one having the B<CAP_SYS_ADMIN> capability)  may specify the B<CLONE_NEWNS> flag.  It is not permitted to specify both B<CLONE_NEWNS> and B<CLONE_FS> in the same B<clone>()  call.
fr: Seul un processus privilégié (un processus ayant la capacité B<CAP_SYS_ADMIN>) peut spécifier 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 défini, alors créer le processus dans un nouvel espace de noms de PID. 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 de PID que le processus appelant. Cet attribut est sensé être utilisé pour l'implémentation de conteneurs.

note: type: Plain text
en: A PID namespace provides an isolated environment for PIDs: PIDs in a new namespace start at 1, somewhat like a standalone system, and calls to B<fork>(2), B<vfork>(2), or B<clone>()  will produce processes with PIDs that are unique within the namespace.
fr: Un espace de noms de PID fournit un environnement isolés pour les PID : les PID d'un nouvel espace de noms de PID commence à 1, comme pour un système seul, et les appels à B<fork>(2), B<vfork>(2) et B<clone>() produiront des processus avec des PID uniques dans l'espace de noms.

note: type: Plain text
en: The first process created in a new namespace (i.e., the process created using the B<CLONE_NEWPID> flag) has the PID 1, and is the "init" process for the namespace.  Children that are orphaned within the namespace will be reparented to this process rather than B<init>(8).  Unlike the traditional B<init> process, the "init" process of a PID namespace can terminate, and if it does, all of the processes in the namespace are terminated.
fr: Le premier processus créé dans un nouvel espace de noms (c'est-à-dire, le processus créé en utilisant l'attribut B<CLONE_NEWPID>) a un PID de 1 et est le processus « init » pour l'espace de noms. Les fils qui deviennent orphelins dans cet espace de noms seront adoptés par ce processus plutôt que par B<init>(8). Contrairement à l'B<init> traditionnel, le processus « init » d'un espace de noms de PID peut se terminer et, s'il le fait, tous les processus dans l'espace de noms sont alors terminés.

note: type: Plain text
en: PID namespaces form a hierarchy.  When a new PID namespace is created, the processes in that namespace are visible in the PID namespace of the process that created the new namespace; analogously, if the parent PID namespace is itself the child of another PID namespace, then processes in the child and parent PID namespaces will both be visible in the grandparent PID namespace.  Conversely, the processes in the "child" PID namespace do not see the processes in the parent namespace.  The existence of a namespace hierarchy means that each process may now have multiple PIDs: one for each namespace in which it is visible; each of these PIDs is unique within the corresponding namespace.  (A call to B<getpid>(2)  always returns the PID associated with the namespace in which the process lives.)
fr: Les espaces de noms de PID forment une hiérarchie. Quand un espace de noms de PID est créé, les processus de cet espace de noms sont visibles depuis l'espace de noms de PID du processus qui a créé le nouvel espace de noms ; de la même façon, si l'espace de noms parent est lui-même le fils d'un autre espace de noms de PID, alors les processus du fils et du père seront tous visibles de l'espace de noms grand-père. À l'inverse, les processus de l'espace de noms de PID fils ne voient pas les processus de l'espace de noms parent. L'existence d'une hiérarchie d'espaces de noms signifie que chaque processus peut désormais avoir plusieurs PID : un par espace de noms dans lequel il est visible ; chacun de ces PID est unique dans les espaces de noms correspondants. (Un appel à B<getpid>(2) renvoie toujours le PID associé à l'espace de noms dans lequel le processus se trouve.)

note: mount -t proc proc /proc type: Plain text
en: After creating the new namespace, it is useful for the child to change its root directory and mount a new procfs instance at I</proc> so that tools such as B<ps>(1)  work correctly.  (If B<CLONE_NEWNS> is also included in I<flags>, then it isn't necessary to change the root directory: a new procfs instance can be mounted directly over I</proc>.)
fr: Après avoir créé un nouvel espace de noms, il est utile pour le fils de changer son répertoire racine et monter une nouvelle instance de procfs dans I</proc> de telle sorte que des outils comme B<ps>(1) fonctionnent correctement. (Si B<CLONE_NEWNS> est également présent dans I<flags>, alors il n'est pas nécessaire de changer de répertorie racine : une nouvelle instance de procfs peut être monté directement dans I</proc>.)

note: type: Plain text
en: Use of this flag requires: a kernel configured with the B<CONFIG_PID_NS> option and that the process be privileged (B<CAP_SYS_ADMIN>).  This flag can't be specified in conjunction with B<CLONE_THREAD>.
fr: L'utilisation de cet attribut nécessite : un noyau configuré avec l'option B<CONFIG_PID_NS> et que le processus soit privilégié (B<CAP_SYS_ADMIN>). Cet attribut ne peut pas être utilisé en même temps que B<CLONE_THREAD>.

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: Use of this flag requires: a kernel configured with the B<CONFIG_UTS_NS> option and that the process be privileged (B<CAP_SYS_ADMIN>).
fr: L'utilisation de cet attribut nécessite : un noyau configuré avec l'option B<CONFIG_UTS_NS> et que le processus soit privilégié (B<CAP_SYS_ADMIN>).

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: Plain text
en: Store child thread ID at location I<ptid> in parent and child memory.  (In Linux 2.5.32-2.5.48 there was a flag B<CLONE_SETTID> that did this.)
fr: Enregistrer l'ID du thread enfant à I<ptid> dans la mémoire du père et du fils. (Dans Linux 2.5.32-2.5.48 il y a un attribut B<CLONE_SETTID> qui fait cela.)

note: type: TP
en: B<CLONE_PID> (obsolete)
fr: B<CLONE_PID> (obsolète)

note: type: Plain text
en: If B<CLONE_PID> is set, the child process is created with the same process ID as the calling process.  This is good for hacking the system, but otherwise of not much use.  Since 2.3.21 this flag can be specified only by the system boot process (PID 0).  It disappeared in Linux 2.5.16.
fr: Si l'attribut B<CLONE_PID> est positionné, les processus appelant et fils ont le même numéro de processus. C'est bien pour hacker le système, mais autrement il n'est plus utilisé. Depuis 2.3.21, cet attribut ne peut être utilisé que par le processus de démarrage du système (PID 0). Il a disparu dans Linux 2.5.16.

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: Plain text
en: The I<newtls> argument is the new TLS (Thread Local Storage) descriptor.  (See B<set_thread_area>(2).)
fr: Le paramètre I<newtls> est le nouveau descripteur TLS (Thread Local Storage). (Consultez B<set_thread_area>(2).)

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 set, the calling process and the child process share the same table of signal handlers.  If the calling process or child process calls B<sigaction>(2)  to change the behavior associated with a signal, the behavior is changed in the other process as well.  However, the calling process and child processes still have distinct signal masks and sets of pending signals.  So, one of them may block or unblock some signals using B<sigprocmask>(2)  without affecting the other process.
fr: Si l'attribut B<CLONE_SIGHAND> est positionné, le processus appelant et le processus fils partagent la même table des gestionnaires de signaux. Si l'appelant, ou le fils, appelle B<sigaction>(2) pour modifier le comportement associé à un signal, ce comportement est également changé pour l'autre processus. Néanmoins, l'appelant et le fils ont toujours des masques de signaux distincts, et leurs ensembles de signaux bloqués sont indépendants. L'un des processus peut donc bloquer un signal en utilisant B<sigprocmask>(2) sans affecter l'autre processus.

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: type: Plain text
en: Since Linux 2.6.0-test6, I<flags> must also include B<CLONE_VM> if B<CLONE_SIGHAND> is specified
fr: Depuis Linux 2.6.0-test6, l'attribut B<CLONE_VM> doit également être spécifié dans I<flags> si B<CLONE_SIGHAND> l'est.

note: type: TP
en: B<CLONE_STOPPED> (since Linux 2.6.0-test2)
fr: B<CLONE_STOPPED> (depuis Linux 2.6.0-test2)

note: 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: glibc 2.8 removed this defn from bits/sched.h type: Plain text
en: This flag was I<deprecated> from Linux 2.6.25 onward, and was I<removed> altogether in Linux 2.6.38.
fr: Cet attribut est marqué comme obsolète depuis Linux 2.6.25, et a été complètement supprimé dans Linux 2.6.38.

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 undo values (see B<semop>(2)).  If this flag is not set, then the child has a separate undo list, which 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)). Si cet attribut n'est pas utilisé, le fils a une liste «\ undo\ » séparée, initialement vide.

note: type: TP
en: B<CLONE_THREAD> (since Linux 2.4.0-test8)
fr: B<CLONE_THREAD> (depuis Linux 2.4.0-test8)

note: 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: Since Linux 2.5.35, I<flags> must also include B<CLONE_SIGHAND> if B<CLONE_THREAD> is specified (and note that, since Linux 2.6.0-test6, B<CLONE_SIGHAND> also requires B<CLONE_VM> to be included).
fr: Depuis Linux 2.5.35, l'attribut B<CLONE_SIGHAND> de I<flags> doit être positionné si B<CLONE_THREAD> l'est. Depuis Linux 2.6.0-test6, B<CLONE_SIGHAND> a également besoin de B<CLONE_THREAD>.

note: type: Plain text
en: Signals may be sent to a thread group as a whole (i.e., a TGID) using B<kill>(2), or to a specific thread (i.e., TID) using B<tgkill>(2).
fr: Un signal peut être envoyé à un groupe de threads dans son ensemble (c'est\(hyà\(hydire à un TGID) avec B<kill>(2), ou bien à un thread en particulier (à un TID) avec B<tgkill>(2).

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: Plain text
en: Each thread has its own signal mask, as set by B<sigprocmask>(2), but signals can be pending either: for the whole process (i.e., deliverable to any member of the thread group), when sent with B<kill>(2); or for an individual thread, when sent with B<tgkill>(2).  A call to B<sigpending>(2)  returns a signal set that is the union of the signals pending for the whole process and the signals that are pending for the calling thread.
fr: Chaque thread a son propre masque de signaux, défini par B<sigprocmask>(2), mais les signaux peuvent être en attente soit pour le processus dans son ensemble (donc peut être reçu par n'importe lequel des threads du groupe), quand ils sont envoyés avec B<kill>(2), soit pour un thread particulier, lorsqu'ils sont envoyés par B<tgkill>(2). Un appel à B<sigpending>(2) renvoie un ensemble de signaux qui est l'union des processus en attente pour le processus et ceux en attente pour le thread appelant.

note: type: Plain text
en: If B<kill>(2)  is used to send a signal to a thread group, and the thread group has installed a handler for the signal, then the handler will be invoked in exactly one, arbitrarily selected member of the thread group that has not blocked the signal.  If multiple threads in a group are waiting to accept the same signal using B<sigwaitinfo>(2), the kernel will arbitrarily select one of these threads to receive a signal sent using B<kill>(2).
fr: Si B<kill>(2) est utilisé pour envoyer un signal à un groupe de threads, et si le groupe a installé un gestionnaire pour ce signal, alors le gestionnaire sera exécuté dans exactement un des membres du groupe de threads, choisi de façon arbitraire parmi ceux qui n'ont pas bloqué ce signal. Si plusieurs threads dans un groupe attendent le même signal en utilisant B<sigwaitinfo>(2), le noyau choisira arbitrairement l'un d'entre eux pour délivrer le signal envoyé par B<kill>(2).

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: The raw system call interface
fr: L'interface de l'appel système brut

note: type: Plain text
en: The raw B<clone>()  system call corresponds more closely to B<fork>(2)  in that execution in the child continues from the point of the call.  As such, the I<fn> and I<arg> arguments of the B<clone>()  wrapper function are omitted.  Furthermore, the argument order changes.  The raw system call interface on x86 and many other architectures is roughly:
fr: L'appel système B<clone> ressemble plus à B<fork>(2), en ceci que l'exécution dans le processus fils continue à partir du point d'appel. À ce titre, les arguments I<fn> et I<arg> de la fonction d'enrobage de B<clone>() sont omis. De plus, l'ordre des arguments change. L'interface de l'appel système brut sur x86 et sur plusieurs autres architectures est à peu près :

note: type: Plain text
en: B<long clone(unsigned long >I<flags>B<, void *>I<child_stack>B<,>
    B<           void *>I<ptid>B<, void *>I<ctid>B<,>
    B<           struct pt_regs *>I<regs>B<);>
fr: B<long clone(unsigned long >I<flags>B<, void *>I<child_stack>B<,>
    B<           void * >I<ptid>B<, void *>I<ctid>B<,>
    B<           struct pt_regs *>I<regs>B<);>

note: type: Plain text
en: Another difference for the raw system call is that the I<child_stack> argument may be zero, in which case copy-on-write semantics ensure that the child gets separate copies of stack pages when either process modifies the stack.  In this case, for correct operation, the B<CLONE_VM> option should not be specified.
fr: Une autre différence\ : pour l'appel système brut, l'argument I<child_stack> 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 B<CLONE_VM> ne soit pas présent.

note: type: Plain text
en: For some architectures, the order of the arguments for the system call differs from that shown above.  On the score, microblaze, ARM, ARM 64, PA-RISC, arc, Power PC, xtensa, and MIPS architectures, the order of the fourth and fifth arguments is reversed.  On the cris and s390 architectures, the order of the first and second arguments is reversed.
fr: Pour certaines architectures, l'ordre des arguments de l'appel système diffère de ce qui est décrit ci-dessus. Sur les architectures score, microblaze, ARM, ARM 64, PA-RISC, arc, Power PC, xtensa, et MIPS, l'ordre des quatrième et cinquième arguments est inversé. Sur les architectures cris et s390, l'ordre des premier et deuxième arguments est inversé.

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

note: type: Plain text
en: The argument-passing conventions on blackfin, m68k, and sparc are different from 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: The prototype shown above is for the glibc wrapper function; the raw system call interface has no I<fn> or I<arg> argument, and changes the order of the arguments so that I<flags> is the first argument, and I<tls> is the last argument.
fr: Le prototype présenté plus haut correspond à la fonction intermédiaire de glibc ; l'interface de l'appel système brut ne reconnaît pas les arguments I<fn> ou I<arg>, et modifie l'ordre des arguments, de sorte que  I<flags> devient le premier argument, et I<tls> le dernier.

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: 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.
fr: Trop de processus en cours d'exécution.

note: type: Plain text
en: B<CLONE_SIGHAND> was specified, but B<CLONE_VM> was not.  (Since Linux 2.6.0-test6.)
fr: B<CLONE_SIGHAND> a été spécifié mais pas B<CLONE_VM> (depuis Linux 2.6.0-test6).

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: 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> ont été indiqués 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> ont été indiqués simultanément dans I<flags>.

note: type: Plain text
en: Both B<CLONE_NEWPID> and B<CLONE_THREAD> were specified in I<flags>.
fr: Les attributs B<CLONE_NEWPID> et B<CLONE_THREAD> ont été indiqués simultanément dans I<flags>.

note: type: Plain text
en: Returned by B<clone>()  when a zero value is specified for I<child_stack>.
fr: Renvoyée par B<clone>() quand une valeur nulle a été indiquée pour le paramètre I<child_stack>.

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é indiqué 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é indiqué 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é indiqué dans I<flags>, mais le noyau n'a pas été configuré avec l'option B<CONFIG_PID_NS>.

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

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: Plain text
en: B<CLONE_NEWIPC>, B<CLONE_NEWNET>, B<CLONE_NEWNS>, B<CLONE_NEWPID>, or B<CLONE_NEWUTS> was specified by an unprivileged process (process without B<CAP_SYS_ADMIN>).
fr: B<CLONE_NEWIPC>, B<CLONE_NEWNET>, B<CLONE_NEWNS>, B<CLONE_NEWPID> ou B<CLONE_NEWUTS> a été spécifié par un processus non privilégié (processus sans B<CAP_SYS_ADMIN>).

note: type: Plain text
en: B<CLONE_PID> was specified by a process other than process 0.
fr: B<CLONE_PID> a été réclamé par un processus autre que le processus 0.

note: type: Plain text
en: There is no entry for B<clone>()  in libc5.  glibc2 provides B<clone>()  as described in this manual page.
fr: Il n'y a pas de définition pour B<clone>() dans la libc5. glibc2 fournit une définition de B<clone>() comme décrit ici.

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: In the kernel 2.4.x series, B<CLONE_THREAD> generally does not make the parent of the new thread the same as the parent of the calling process.  However, for kernel versions 2.4.7 to 2.4.18 the B<CLONE_THREAD> flag implied the B<CLONE_PARENT> flag (as in kernel 2.6).
fr: Dans les noyaux 2.4.x, B<CLONE_THREAD> ne rend pas en général le processus père de l'appelant père du nouveau thread. Cependant, pour les versions 2.4.7 à 2.4.18 du noyau, l'attribut B<CLONE_THREAD> impliquait B<CLONE_PARENT> (de même qu'avec les noyaux 2.6).

note: type: Plain text
en: For a while there was B<CLONE_DETACHED> (introduced in 2.5.32): parent wants no child-exit signal.  In 2.6.2 the need to give this together with B<CLONE_THREAD> disappeared.  This flag is still defined, but has no effect.
fr: B<CLONE_DETACHED> a existé pendant un moment (introduit dans 2.5.32): le père ne veut pas de signal à la mort du fils. Dans 2.6.2, la nécessité d'utiliser ce paramètre avec B<CLONE_THREAD> a été supprimée. Cet attribut est toujours défini, mais n'a plus aucun effet.

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: Plain text
en: Versions of the GNU C library that include the NPTL threading library contain a wrapper function for B<getpid>(2)  that performs caching of PIDs.  This caching relies on support in the glibc wrapper for B<clone>(), but as currently implemented, the cache may not be up to date in some circumstances.  In particular, if a signal is delivered to the child immediately after the B<clone>()  call, then a call to B<getpid>(2)  in a handler for the signal may return the PID of the calling process ("the parent"), if the clone wrapper has not yet had a chance to update the PID cache in the child.  (This discussion ignores the case where the child was created using B<CLONE_THREAD>, when B<getpid>(2)  I<should> return the same value in the child and in the process that called B<clone>(), since the caller and the child are in the same thread group.  The stale-cache problem also does not occur if the I<flags> argument includes B<CLONE_VM>.)  To get the truth, it may be necessary to use code such as the following:
fr: Les versions de la bibliothèque C GNU qui gèrent la bibliothèque de gestion des threads NPTL contiennent une fonction enveloppe pour B<getpid>(2) qui effectue un cache des PID. Ce cache nécessite une prise en charge par l'enveloppe de B<clone>() de la glibc, mais telle qu'il est actuellement implémenté, le cache peut ne pas être à jour sous certaines circonstances. En particulier, si un signal est distribué à un fils juste après l'appel à B<clone>(), alors un appel à B<getpid>(2) dans le gestionnaire de signaux du signal peut renvoyer le PID du processus appelant (le père), si l'enveloppe de clone n'a toujours pas eu le temps de mettre le cache de PID à jour pour le fils. (Cette discussion ignore le cas où le fils a été créé en utilisant B<CLONE_THREAD>, quand B<getpid>(2) I<doit> renvoyer la même valeur pour le fils et pour le processus qui a appelé B<clone>(), puisque l'appelant et le fils se trouvent dans le même groupe de threads. Ce problème de cache n'apparaît pas non plus si le paramètre I<flags> contient B<CLONE_VM>.) Pour obtenir la véritable valeur, il peut être nécessaire d'utiliser quelque chose comme ceci :

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: Code 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: TH
en: 2013-12-08
fr: 8 décembre 2013

note: type: Plain text
en: kcmp - compare two processes to determine if they share a kernel resource
fr: kcmp - compare deux processus afin de déterminer s'ils partagent des ressources du noyau

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: I<Note> : Il n'existe pas de fonction d'encapsulation dans glibc pour cet appel système ; consultez NOTES.

note: type: Plain text
en: The B<kcmp>()  system call can be used to check whether the two processes identified by I<pid1> and I<pid2> share a kernel resource such as virtual memory, file descriptors, and so on.
fr: L'appel système  B<kcmp>() peut être utilisé pour vérifier si deux processus identifiés par I<pid1> et I<pid2> partagent des ressources du noyau, telles que de la mémoire virtuelle, des descripteurs de fichiers, etc.

note: type: Plain text
en: The I<type> argument specifies which resource is to be compared in the two processes.  It has one of the following values:
fr: L'argument I<nstype> indique pour quelle ressource une comparaison doit être effectuée entre les deux processus. Il peut prendre l'une des valeurs suivantes :

note: type: Plain text
en: Check whether a file descriptor I<idx1> in the process I<pid1> refers to the same open file description (see B<open>(2))  as file descriptor I<idx2> in the process I<pid2>.
fr: Vérifie si un descripteur de fichier I<idx1> utilisé par le processus I<pid1> fait référence à la même description de fichier ouvert (consultez B<open>(2)) que le descripteur de fichier I<idx2> utilisé par le processus I<pid2>.

note: type: Plain text
en: Check whether the process share the same set of open file descriptors.  The arguments I<idx1> and I<idx2> are ignored.
fr: Vérifier si le processus partage un même ensemble de descripteurs de fichiers ouverts. Les arguments  I<idx1> et I<idx2> ne sont pas pris en compte.

note: type: Plain text
en: Check whether the processes share the same filesystem information (i.e., file mode creation mask, working directory, and filesystem root).  The arguments I<idx1> and I<idx2> are ignored.
fr: Vérifie si les processus partagent les même informations relatives au système de fichiers (c'est-à-dire le masque de création de fichiers, le répertoire de travail, et la racine du système de fichiers). Les arguments I<idx1> et I<idx2> ne sont pas pris en compte.

note: type: Plain text
en: Check whether the processes share I/O context.  The arguments I<idx1> and I<idx2> are ignored.
fr: Vérifie si les processus partagent un contexte E/S. Les arguments I<idx1> et I<idx2> ne sont pas pris en compte.

note: type: Plain text
en: Check whether the processes share the same table of signal dispositions.  The arguments I<idx1> and I<idx2> are ignored.
fr: Vérifie si les processus partagent la même table de disposition des signaux. Les arguments I<idx1> et I<idx2> ne sont pas pris en compte.

note: type: Plain text
en: Check whether the processes share the same list of System V semaphore undo operations.  The arguments I<idx1> and I<idx2> are ignored.
fr: Vérifie si les processus partagent la même liste d'opérations «\ undo\ » pour les sémaphores System V. Les arguments I<idx1> et I<idx2> ne sont pas pris en compte.

note: type: Plain text
en: Check whether the processes share the same address space.  The arguments I<idx1> and I<idx2> are ignored.
fr: Vérifie si les processus partagent le même espace d'adressage. Les arguments I<idx1> et I<idx2> ne sont pas pris en compte.

note: type: Plain text
en: Note the B<kcmp>()  is not protected against false positives which may occur if tasks are running.  One should stop tasks by sending B<SIGSTOP> (see B<signal>(7))  prior to inspection with this system call to obtain meaningful results.
fr: Remarquez que B<kcmp>() n'est pas à l'abri de «faux positifs» qui peuvent survenir si des tâches sont en cours d'exécution. Pour obtenir des résultats pertinents, il faut arrêter ces tâches au moyen de B<SIGSTOP> (consulter B<signal>(7)) avant de commencer l'examen des processus.

note: type: Plain text
en: The return value of a successful call to B<kcmp>()  is simply the result of arithmetic comparison of kernel pointers (when the kernel compares resources, it uses their memory addresses).
fr: La valeur renvoyée par un appel réussi à B<kcmp>() est le résultat de la comparaison arithmétique des pointeurs du noyau (lorsque le noyau compare des ressources, il utilise leurs adresses en mémoire).

note: type: Plain text
en: The easiest way to explain is to consider an example.  Suppose that I<v1> and I<v2> are the addresses of appropriate resources, then the return value is one of the following:
fr: Pour mieux comprendre, regardons l'exemple suivant. Supposons que I<v1> and I<v2> sont les adresses des ressources concernées, alors la valeur renvoyée sera l'une des suivantes :

note: type: Plain text
en: I<v1> is equal to I<v2>; in other words, the two processes share the resource.
fr: I<v1> est égal à I<v2> ; en d'autres termes, les deux processus partagent la même ressource.

note: type: Plain text
en: I<v1> is less than I<v2>.
fr: I<v1> est inférieur à I<v2>.

note: type: Plain text
en: I<v1> is greater than I<v2>.
fr: I<v1> est supérieur à I<v2>.

note: type: Plain text
en: I<v1> is not equal to I<v2>, but ordering information is unavailable.
fr: I<v1> n'est pas égal à I<v2>, mais aucune information concernant l'ordre des nombres n'est disponible.

note: type: Plain text
en: On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas d'erreur, le retour vaut -1 et I<errno> reçoit une valeur correspondante.

note: type: Plain text
en: B<kcmp>()  was designed to return values suitable for sorting.  This is particularly handy if one needs to compare a large number of file descriptors.
fr: B<kcmp>() a été conçu pour renvoyer des variables pouvant être triées. C'est particulièrement pratique lorsqu'on souhaite comparer un grand nombre de descripteurs de fichiers.

note: type: Plain text
en: I<type> is B<KCMP_FILE> and I<fd1> or I<fd2> is not an open file descriptor.
fr: I<type> est B<KCMP_FILE> et I<fd1> ou I<fd2> n'est pas un descripteur de fichier ouvert.

note: type: Plain text
en: I<type> is invalid.
fr: I<type> n'est pas valide.

note: type: Plain text
en: Insufficient permission to inspect process resources.  The B<CAP_SYS_PTRACE> capability is required to inspect processes that you do not own.
fr: Permissions insuffisantes pour inspecter les ressources du noyau. Le privilège B<CAP_SYS_PTRACE> est nécessaire pour inspecter les processus dont vous n'êtes pas propriétaire.

note: type: Plain text
en: Process I<pid1> or I<pid2> does not exist.
fr: Au moins l'un des processus I<pid1> ou I<pid2> n'existe pas.

note: type: Plain text
en: The B<kcmp>()  system call first appeared in Linux 3.5.
fr: L'appel système B<setns>() a fait son apparition dans la version 3.5 de Linux.

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

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2).
fr: Glibc ne fournit pas de fonction d'encapsulation pour cet appel système ; utilisez B<syscall>(2) pour l'appeler.

note: type: Plain text
en: This system call is available only if the kernel was configured with B<CONFIG_CHECKPOINT_RESTORE>.  The main use of the system call is for the checkpoint/restore in user space (CRIU) feature.  The alternative to this system call would have been to expose suitable process information via the B<proc>(5)  filesystem; this was deemed to be unsuitable for security reasons.
fr: Cet appel système n'est disponible que si le noyau a été configuré avec B<CONFIG_CHECKPOINT_RESTORE>. Cet appel est utilisé principalement pour la fonctionnalité de gel des applications (checkpoint/restore) dans l'espace utilisateur (CRIU). L'alternative à cet appel système aurait consisté à présenter les informations pertinentes concernant le processus via le système de fichier B<proc>(5) ; cette solution n'a pas été jugée satisfaisante pour des raisons de sécurité.

note: type: Plain text
en: See B<clone>(2)  for some background information on the shared resources referred to on this page.
fr: Consultez B<clone>(2) pour obtenir des informations générales sur les ressources partagées dont il est fait mention dans cette page.

note: type: TH
en: 2013-09-23
fr: 23 septembre 2013

note: type: Plain text
en: sched_get_priority_max, sched_get_priority_min - get static priority range
fr: sched_get_priority_max, sched_get_priority_min - Obtenir l'intervalle de priorités statiques de l'ordonnanceur

note: type: Plain text
en: B<sched_get_priority_max>()  returns the maximum priority value that can be used with the scheduling algorithm identified by I<policy>.  B<sched_get_priority_min>()  returns the minimum priority value that can be used with the scheduling algorithm identified by I<policy>.  Supported I<policy> values are B<SCHED_FIFO>, B<SCHED_RR>, B<SCHED_OTHER>, B<SCHED_BATCH>, and B<SCHED_IDLE>.  Further details about these policies can be found in B<sched_setscheduler>(2).
fr: B<sched_get_priority_max>() renvoie la valeur maximale de priorité qui puisse être utilisée avec la politique d'ordonnancement identifiée par I<policy>. B<sched_get_priority_min>() renvoie la valeur minimale de priorité qui puisse être utilisée avec la politique d'ordonnancement identifiée par I<policy>. Les valeurs de I<policy> pour les politiques d'ordonnancement proposées sont\ : B<SCHED_FIFO>, B<SCHED_RR>, B<SCHED_OTHER>, B<SCHED_BATCH> et B<SCHED_IDLE>. Pour plus de détails sur ces politiques, consultez B<sched_setscheduler>(2).

note: type: Plain text
en: Processes with numerically higher priority values are scheduled before processes with numerically lower priority values.  Thus, the value returned by B<sched_get_priority_max>()  will be greater than the value returned by B<sched_get_priority_min>().
fr: Les processus ayant des valeurs de priorité hautes sont sélectionnés avant les processus de basse priorité. Ainsi, la valeur renvoyée par B<sched_get_priority_max>() sera supérieure à celle renvoyée par B<sched_get_priority_min>().

note: type: Plain text
en: Linux allows the static priority value range 1 to 99 for B<SCHED_FIFO> and B<SCHED_RR> and the priority 0 for B<SCHED_OTHER>, B<SCHED_BATCH>, and B<SCHED_IDLE>.  Scheduling priority ranges for the various policies are not alterable.
fr: Linux offre un intervalle de priorités statiques allant de 1 à 99 pour les politiques d'ordonnancements B<SCHED_FIFO> et B<SCHED_RR> et une priorité statique 0 pour B<SCHED_OTHER>, B<SCHED_BATCH> et B<SCHED_IDLE>. Les intervalles de priorités des différents algorithmes ne sont pas modifiables.

note: type: Plain text
en: The range of scheduling priorities may vary on other POSIX systems, thus it is a good idea for portable applications to use a virtual priority range and map it to the interval given by B<sched_get_priority_max>()  and B<sched_get_priority_min>().  POSIX.1-2001 requires a spread of at least 32 between the maximum and the minimum values for B<SCHED_FIFO> and B<SCHED_RR>.
fr: Les intervalles peuvent varier suivant les systèmes POSIX, et il est conseillé pour une application portable d'utiliser un intervalle de priorité virtuel, que l'on associera avec l'intervalle donné par B<sched_get_priority_max>() et B<sched_get_priority_min>(). POSIX.1-2001 réclame une distance d'au moins 32 entre les valeurs maximale et minimale des politiques B<SCHED_FIFO> et B<SCHED_RR>.

note: type: Plain text
en: POSIX systems on which B<sched_get_priority_max>()  and B<sched_get_priority_min>()  are available define B<_POSIX_PRIORITY_SCHEDULING> in I<E<lt>unistd.hE<gt>>.
fr: Les systèmes POSIX sur lesquels B<sched_get_priority_max>() et B<sched_get_priority_min>() sont disponibles définissent B<_POSIX_PRIORITY_SCHEDULING> dans I<E<lt>unistd.hE<gt>>.

note: type: Plain text
en: On success, B<sched_get_priority_max>()  and B<sched_get_priority_min>()  return the maximum/minimum priority value for the named scheduling policy.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<sched_get_priority_max>() et B<sched_get_priority_min>() renvoient les valeurs de priorités maximale/minimale s'ils réussissent. En cas d'échec -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: The argument I<policy> does not identify a defined scheduling policy.
fr: le paramètre I<policy> ne correspond pas à une politique d'ordonnancement supportée.

note: type: Plain text
en: I<Programming for the real world - POSIX.4> by Bill O. Gallmeister, O'Reilly & Associates, Inc., ISBN 1-56592-074-0.
fr: I<Programming for the real world - POSIX.4> de Bill O. Gallmeister, O'Reilly & Associates, Inc., ISBN 1-56592-074-0.

note: type: TH
en: 2013-04-17
fr: 17 avril 2013

note: type: Plain text
en: sched_getcpu - determine CPU on which the calling thread is running
fr: sched_getcpu - Déterminer le processeur sur lequel le processus appelant est en cours d'exécution

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Conditions requises par la macro de test des fonctionnalités pour glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<sched_getcpu>()  returns the number of the CPU on which the calling thread is currently executing.
fr: B<sched_getcpu>() renvoie le numéro de processeur sur lequel le processus appelant est actuellement en cours d'exécution.

note: type: Plain text
en: On success, B<sched_getcpu>()  returns a nonnegative CPU number.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: Si elle réussit, B<sched_getcpu>() renvoie un numéro de processeur non négatif. Si elle échoue, elle renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: This kernel does not implement B<getcpu>(2).
fr: Ce noyau n'implémente pas l'appel système B<getcpu>(2).

note: type: Plain text
en: This function is available since glibc 2.6.
fr: Cette fonction est disponible depuis la glibc 2.6.

note: type: Plain text
en: B<sched_getcpu>()  is glibc-specific.
fr: B<sched_getcpu>() est spécifique à la glibc.

note: type: Plain text
en: The call
fr: L'appel

note: type: Plain text
en: is equivalent to the following B<getcpu>(2)  call:
fr: est équivalent à l'appel B<getcpu>(2) suivant :

note: type: TH
en: 2013-03-18
fr: 18 mars 2013

note: type: Plain text
en: sched_rr_get_interval - get the SCHED_RR interval for the named process
fr: sched_rr_get_interval - Obtenir l'intervalle SCHED_RR pour le processus indiqué

note: type: Plain text
en: B<sched_rr_get_interval>()  writes into the I<timespec> structure pointed to by I<tp> the round-robin time quantum for the process identified by I<pid>.  The specified process should be running under the B<SCHED_RR> scheduling policy.
fr: B<sched_rr_get_interval>() remplit la structure I<timespec> pointée par I<tp> avec le «\ round robin time quantum\ » du processus identifié par I<pid>. Ce processus devrait fonctionner avec la politique d'ordonnancement B<SCHED_RR>.

note: type: Plain text
en: The I<timespec> structure has the following form:
fr: La structure I<timespec> est déclarée comme suit\ :

note: type: Plain text
en: struct timespec {
        time_t tv_sec;    /* seconds */
        long   tv_nsec;   /* nanoseconds */
    };
fr: struct timespec {
        time_t tv_sec;    /* secondes     */
        long   tv_nsec;   /* nanosecondes */
    };

note: FIXME . On Linux, sched_rr_get_interval() returns the timeslice for SCHED_OTHER processes -- this timeslice is influenced by the nice value. For SCHED_FIFO processes, this always returns 0. The round-robin time quantum value is not alterable under Linux 1.3.81. type: Plain text
en: If I<pid> is zero, the time quantum for the calling process is written into I<*tp>.
fr: Si l'identifiant du processus I<pid> est égal à zéro, le quantum de temps pour le processus appelant est écrit dans I<*tp>.

note: type: Plain text
en: On success, B<sched_rr_get_interval>()  returns 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<sched_rr_get_interval>() renvoie 0 s'il réussit. En cas d'échec, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: Problem with copying information to user space.
fr: Problème lors de la copie d'information vers l'espace utilisateur.

note: type: Plain text
en: Invalid pid.
fr: PID invalide.

note: type: Plain text
en: The system call is not yet implemented (only on rather old kernels).
fr: L'appel système n'a pas encore été implémenté (seulement pour les noyaux relativement anciens).

note: type: Plain text
en: Could not find a process with the ID I<pid>.
fr: Impossible de trouver un processus avec l'identifiant I<pid>.

note: type: Plain text
en: POSIX systems on which B<sched_rr_get_interval>()  is available define B<_POSIX_PRIORITY_SCHEDULING> in I<E<lt>unistd.hE<gt>>.
fr: Les systèmes POSIX sur lesquels B<sched_rr_get_interval>() est disponible définissent B<_POSIX_PRIORITY_SCHEDULING> dans I<E<lt>unistd.hE<gt>>.

note: type: SS
en: Linux notes
fr: Notes sur Linux

note: commit a4ec24b48ddef1e93f7578be53270f0b95ad666c type: Plain text
en: POSIX does not specify any mechanism for controlling the size of the round-robin time quantum.  Older Linux kernels provide a (nonportable) method of doing this.  The quantum can be controlled by adjusting the process's nice value (see B<setpriority>(2)).  Assigning a negative (i.e., high) nice value results in a longer quantum; assigning a positive (i.e., low) nice value results in a shorter quantum.  The default quantum is 0.1 seconds; the degree to which changing the nice value affects the quantum has varied somewhat across kernel versions.  This method of adjusting the quantum was removed starting with Linux 2.6.24.
fr: POSIX n'indique aucun mécanisme pour contrôler la taille du «\ round robin time quantum\ ». Cependant, Linux fournit une méthode (non portable) pour cela. Le quantum peut être contrôlé en ajustant la valeur de «\ politesse\ » du processus (consultez B<setpriority>(2)). Assigner une valeur de politesse négative (c'est-à-dire haute) résulte en un quantum de temps plus long ; assigner une valeur de politesse positive (c'est-à-dire basse) résulte en un quantum de temps plus court. Le quantum de temps par défaut est de 0,1 secondes ; l'influence du changement de valeur de politesse sur le quantum a varié suivant les versions du noyau. Cette méthode d'ajustement du quantum a été supprimée à partir de la version 2.6.24 de Linux.

note: commit ce0dbbbb30aee6a835511d5be446462388ba9eee .SH BUGS As of Linux 1.3.81 .BR sched_rr_get_interval () returns with error ENOSYS, because SCHED_RR has not yet been fully implemented and tested properly. type: Plain text
en: Linux 3.9 added a new mechanism for adjusting (and viewing) the B<SCHED_RR> quantum: the I</proc/sys/kernel/sched_rr_timeslice_ms> file exposes the quantum as a millisecond value, whose default is 100.  Writing 0 to this file resets the quantum to the default value.
fr: Linux 3.9 a introduit un mécanisme d'ajustement (et d'observation) du quantum de B<SCHED_RR> : le fichier I</proc/sys/kernel/sched_rr_timeslice_ms> contient la valeur du quantum exprimée en millisecondes, qui par défaut vaut 100. Écrire 0 dans ce fichier a pour effet de réinitialiser le quantum à sa valeur par défaut.

note: type: Plain text
en: B<sched_setscheduler>(2)  has a description of the Linux scheduling scheme.
fr: B<sched_setscheduler>(2) décrit les politiques d'ordonnancement sous Linux.

note: type: TH
en: 2013-09-17
fr: 17 septembre 2013

note: type: Plain text
en: sched_setaffinity, sched_getaffinity - set and get a thread's CPU affinity mask
fr: sched_setaffinity, sched_getaffinity - Définir et récupérer le masque d'affinité CPU d'un thread

note: type: Plain text
en: A thread's CPU affinity mask determines the set of CPUs on which it is eligible to run.  On a multiprocessor system, setting the CPU affinity mask can be used to obtain performance benefits.  For example, by dedicating one CPU to a particular thread (i.e., setting the affinity mask of that thread to specify a single CPU, and setting the affinity mask of all other threads to exclude that CPU), it is possible to ensure maximum execution speed for that thread.  Restricting a thread to run on a single CPU also avoids the performance cost caused by the cache invalidation that occurs when a thread ceases to execute on one CPU and then recommences execution on a different CPU.
fr: Le masque d'affinité CPU d'un thread détermine l'ensemble de processeurs sur lesquels il est susceptible de s'exécuter. Sur un système multiprocesseur, définir le masque d'affinité CPU permet d'obtenir une meilleure performance. Par exemple, en dédiant un CPU à un thread particulier (c'est-à-dire définir le masque d'affinité de ce thread pour indiquer un seul CPU, et définir le masque d'affinité de tous les autres threads pour exclure ce CPU), il est possible d'assurer une vitesse d'exécution maximale pour ce thread. Restreindre un processus pour qu'il ne s'exécute que sur un seul CPU réduit le coût lié à l'invalidation du cache qui se produit lorsqu'un thread cesse de s'exécuter sur un CPU puis est relancé sur un autre CPU.

note: type: Plain text
en: A CPU affinity mask is represented by the I<cpu_set_t> structure, a "CPU set", pointed to by I<mask>.  A set of macros for manipulating CPU sets is described in B<CPU_SET>(3).
fr: Un masque d'affinité CPU est représenté par la structure I<cpu_set_t>, un ensemble de CPU (« CPU set »), pointé par I<mask>. Des macros pour manipuler des ensembles de CPU sont décrites dans B<CPU_SET>(3).

note: type: Plain text
en: B<sched_setaffinity>()  sets the CPU affinity mask of the thread whose ID is I<pid> to the value specified by I<mask>.  If I<pid> is zero, then the calling thread is used.  The argument I<cpusetsize> is the length (in bytes) of the data pointed to by I<mask>.  Normally this argument would be specified as I<sizeof(cpu_set_t)>.
fr: B<sched_setaffinity>() définit le masque d'affinité CPU du thread dont l'identifiant est I<pid> à la valeur donnée par I<mask>. Si I<pid> est 0, le thread appelant est utilisé. L'argument I<cpusetsize> est la taille (en octets) de la structure pointée par I<mask>. Normalement, cet argument doit être spécifié comme I<sizeof(cpu_set_t)>.

note: type: Plain text
en: If the thread specified by I<pid> is not currently running on one of the CPUs specified in I<mask>, then that thread is migrated to one of the CPUs specified in I<mask>.
fr: Si le thread indiqué par I<pid> n'est pas actuellement en cours d'exécution sur l'un des CPU spécifiés dans I<mask>, alors ce thread est migré vers l'un des CPU spécifiés dans I<mask>.

note: type: Plain text
en: B<sched_getaffinity>()  writes the affinity mask of the thread whose ID is I<pid> into the I<cpu_set_t> structure pointed to by I<mask>.  The I<cpusetsize> argument specifies the size (in bytes) of I<mask>.  If I<pid> is zero, then the mask of the calling thread is returned.
fr: La fonction B<sched_getaffinity>() écrit dans la structure I<cpu_set_t> pointée par I<mask> le masque de préférences du thread I<pid>. L'argument I<cpusetsize> indique la taille (en octets) de I<mask>. Si I<pid> vaut zéro, le masque du thread en cours est renvoyé.

note: type: Plain text
en: On success, B<sched_setaffinity>()  and B<sched_getaffinity>()  return 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<sched_setaffinity>() et B<sched_getaffinity>() renvoient 0 s'ils réussissent. En cas d'échec, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: A supplied memory address was invalid.
fr: Une adresse mémoire fournie n'est pas correcte.

note: type: Plain text
en: The affinity bit mask I<mask> contains no processors that are currently physically on the system and permitted to the thread according to any restrictions that may be imposed by the "cpuset" mechanism described in B<cpuset>(7).
fr: Le masque de bits d'affinité I<mask> ne contient pas de processeurs qui soit actuellement physiquement sur le système et autorisé pour le thread d'après les restrictions imposées par le mécanisme d'ensembles de CPU décrit dans B<cpuset>(7).

note: type: Plain text
en: (B<sched_getaffinity>()  and, in kernels before 2.6.9, B<sched_setaffinity>())  I<cpusetsize> is smaller than the size of the affinity mask used by the kernel.
fr: (B<sched_getaffinity>() et, pour les noyaux antérieurs à 2.6.9, B<sched_setaffinity>()) I<cpusetsize> est plus petit que la taille du masque d'affinité utilisé par le noyau.

note: type: Plain text
en: (B<sched_setaffinity>())  The calling thread does not have appropriate privileges.  The caller needs an effective user ID equal to the real user ID or effective user ID of the thread identified by I<pid>, or it must possess the B<CAP_SYS_NICE> capability.
fr: (B<sched_setaffinity>()) Le thread appelant n'a pas les privilèges appropriés. L'appelant doit avoir un UID effectif égal à l'UID effectif ou réel du thread identifié par I<pid>, ou avoir la capacité B<CAP_SYS_NICE>.

note: type: Plain text
en: The thread whose ID is I<pid> could not be found.
fr: Le thread numéro I<pid> n'existe pas.

note: type: Plain text
en: The CPU affinity system calls were introduced in Linux kernel 2.5.8.  The system call wrappers were introduced in glibc 2.3.  Initially, the glibc interfaces included a I<cpusetsize> argument, typed as I<unsigned int>.  In glibc 2.3.3, the I<cpusetsize> argument was removed, but was then restored in glibc 2.3.4, with type I<size_t>.
fr: Les appels système d'affinité ont été introduits dans Linux 2.5.8. Les fonctions enveloppes pour ces appels système ont été introduites dans la glibc 2.3. Au départ, les interfaces de la glibc avaient un paramètre I<cpusetsize> de type I<unsigned int>. Dans glibc 2.3.3, ce paramètre a été supprimé, mais il a été réintroduit dans glibc 2.3.4, avec pour type I<size_t>.

note: type: Plain text
en: These system calls are Linux-specific.
fr: Ces appels système sont spécifiques à Linux.

note: type: Plain text
en: After a call to B<sched_setaffinity>(), the set of CPUs on which the thread will actually run is the intersection of the set specified in the I<mask> argument and the set of CPUs actually present on the system.  The system may further restrict the set of CPUs on which the thread runs if the "cpuset" mechanism described in B<cpuset>(7)  is being used.  These restrictions on the actual set of CPUs on which the thread will run are silently imposed by the kernel.
fr: Après un appel à B<sched_setaffinity>(), l'ensemble de CPU sur lesquels le thread s'exécutera est l'intersection de l'ensemble spécifié dans le paramètre I<mask> et l'ensemble des CPU actuellement présents sur le système. Le système peut restreindre encore plus l'ensemble des CPU sur lesquels le thread peut tourner si le mécanisme « cpuset », décrit dans B<cpuset>(7), est utilisé. Ces restrictions sur le véritable ensemble de CPU sur lesquels le thread peut tourner sont imposées sans avertissement par le noyau.

note: type: Plain text
en: The affinity mask is a per-thread attribute that can be adjusted independently for each of the threads in a thread group.  The value returned from a call to B<gettid>(2)  can be passed in the argument I<pid>.  Specifying I<pid> as 0 will set the attribute for the calling thread, and passing the value returned from a call to B<getpid>(2)  will set the attribute for the main thread of the thread group.  (If you are using the POSIX threads API, then use B<pthread_setaffinity_np>(3)  instead of B<sched_setaffinity>().)
fr: Le masque d'affinité est un attribut de thread, qui peut être modifié indépendamment pour chacun des threads d'un groupe de threads. La valeur renvoyée par B<gettid>(2) peut être passée dans l'argument I<pid>. Spécifier un I<pid> de 0 définira l'attribut pour le thread appelant, et une valeur égale à celle renvoyée par B<getpid>(2) définira l'attribut pour le thread principal du groupe de thread. (Si vous utilisez l'API POSIX des threads, alors utilisez B<pthread_setaffinity_np>(3) au lieu de B<sched_setaffinity>().)

note: type: Plain text
en: A child created via B<fork>(2)  inherits its parent's CPU affinity mask.  The affinity mask is preserved across an B<execve>(2).
fr: Un processus fils créé par B<fork>(2) hérite du masque d'affinité CPU de son père. Le masque d'affinité est conservé au travers d'un B<execve>(2).

note: type: Plain text
en: This manual page describes the glibc interface for the CPU affinity calls.  The actual system call interface is slightly different, with the I<mask> being typed as I<unsigned long\ *>, reflecting the fact that the underlying implementation of CPU sets is a simple bit mask.  On success, the raw B<sched_getaffinity>()  system call returns the size (in bytes) of the I<cpumask_t> data type that is used internally by the kernel to represent the CPU set bit mask.
fr: Cette page de manuel décrit l'interface de la glibc pour les appels liés à l'affinité CPU. L'interface des appels système est légèrement différente, I<mask> ayant le type I<unsigned long\ *>, montrant le fait que l'implémentation des ensembles de CPU est en réalité un simple masque de bits. En cas de succès, l'appel système B<sched_getaffinity>() brut renvoie la taille (en octets) du type I<cpumask_t> utilisé en interne par le noyau pour représenter le masque d'ensemble de CPU.

note: type: Plain text
en: sched_setparam, sched_getparam - set and get scheduling parameters
fr: sched_getparam, sched_setparam - Lire/écrire les paramètres d'ordonnancement

note: type: Plain text
en: B<sched_setparam>()  sets the scheduling parameters associated with the scheduling policy for the process identified by I<pid>.  If I<pid> is zero, then the parameters of the calling process are set.  The interpretation of the argument I<param> depends on the scheduling policy of the process identified by I<pid>.  See B<sched_setscheduler>(2)  for a description of the scheduling policies supported under Linux.
fr: B<sched_setparam>() définit les paramètres associés à la politique d'ordonnancement du processus identifié par I<pid>. Si I<pid> vaut zéro, les paramètres concernant le processus appelant sont définis. L'interprétation du paramètre I<param> dépend de la politique d'ordonnancement du processus identifié par I<pid>. Consultez B<sched_setscheduler>(2) pour une description des politiques d'ordonnancement possibles sous Linux.

note: type: Plain text
en: B<sched_getparam>()  retrieves the scheduling parameters for the process identified by I<pid>.  If I<pid> is zero, then the parameters of the calling process are retrieved.
fr: B<sched_getparam>() lit les paramètres associés à la politique d'ordonnancement du processus identifié par I<pid>. Si I<pid> vaut zéro, les paramètres concernant le processus appelant sont lus.

note: type: Plain text
en: B<sched_setparam>()  checks the validity of I<param> for the scheduling policy of the thread.  The value I<param-E<gt>sched_priority> must lie within the range given by B<sched_get_priority_min>(2)  and B<sched_get_priority_max>(2).
fr: B<sched_setparam>() vérifie la validité de I<param> pour la politique d'ordonnancement concernée. Le valeur de I<param-E<gt>sched_priority> doit se situer dans l'intervalle obtenu par B<sched_get_priority_min>(2) et B<sched_get_priority_max>(2).

note: type: Plain text
en: For a discussion of the privileges and resource limits related to scheduling priority and policy, see B<sched_setscheduler>(2).
fr: Pour une explication des privilèges et limites de ressources liées à la priorité et à la politique d'ordonnancement, consultez B<sched_setscheduler>(2).

note: type: Plain text
en: POSIX systems on which B<sched_setparam>()  and B<sched_getparam>()  are available define B<_POSIX_PRIORITY_SCHEDULING> in I<E<lt>unistd.hE<gt>>.
fr: Les systèmes POSIX sur lesquels B<sched_setparam>() et B<sched_getparam>() sont disponibles définissent B<_POSIX_PRIORITY_SCHEDULING> dans I<E<lt>unistd.hE<gt>>.

note: type: Plain text
en: On success, B<sched_setparam>()  and B<sched_getparam>()  return 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<sched_setparam>() et B<sched_getparam>() renvoient 0 s'ils réussissent. En cas d'échec, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: The argument I<param> does not make sense for the current scheduling policy.
fr: Le paramètre I<param> n'a pas de sens pour la politique d'ordonnancement utilisée.

note: type: Plain text
en: The calling process does not have appropriate privileges (Linux: does not have the B<CAP_SYS_NICE> capability).
fr: L'appelant n'a pas les privilèges nécessaires (Linux\ : n'a pas la capacité B<CAP_SYS_NICE>).

note: type: Plain text
en: The process whose ID is I<pid> could not be found.
fr: Le processus numéro I<pid> n'existe pas.

note: type: Plain text
en: Scheduling parameters are in fact per-thread attributes on Linux; see B<sched_setscheduler>(2).
fr: Sous Linux, les paramètres d'ordonnancement sont des attributs des threads ; consultez B<sched_setscheduler>(2).

note: type: Plain text
en: sched_setscheduler, sched_getscheduler - set and get scheduling policy/parameters
fr: sched_setscheduler, sched_getscheduler - Lire et définir la politique d'ordonnancement et ses paramètres

note: type: Plain text
en: B<sched_setscheduler>()  sets both the scheduling policy and the associated parameters for the thread whose ID is specified in I<pid>.  If I<pid> equals zero, the scheduling policy and parameters of the calling thread will be set.  The interpretation of the argument I<param> depends on the selected policy.  Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
fr: B<sched_setscheduler>() définit à la fois la politique d'ordonnancement et ses paramètres pour le thread dont l'identifiant est indiqué par I<pid>. Si I<pid> vaut zéro, la politique d'ordonnancement et ses paramètres pour le thread en cours seront définis. L'interprétation du paramètre I<param> dépend de la politique employée. Actuellement, les politiques normales (c'est-à-dire non temps réel) proposées par Linux sont les suivantes :

note: In the 2.6 kernel sources, SCHED_OTHER is actually called SCHED_NORMAL. type: Plain text
en: the standard round-robin time-sharing policy;
fr: politique standard de temps partagé «\ round-robin\ » :

note: type: Plain text
en: for "batch" style execution of processes; and
fr: pour une exécution de style traitement par lot des processus ; et

note: type: Plain text
en: for running I<very> low priority background jobs.
fr: pour l'exécution de tâches de I<très> faible priorité en arrière-plan.

note: type: Plain text
en: The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable threads are selected for execution:
fr: Les politiques temps réel suivantes sont également gérées, pour des applications particulières sensibles au temps qui nécessitent un contrôle précis sur la façon dont sont choisis pour exécution les threads exécutables :

note: type: Plain text
en: a first-in, first-out policy; and
fr: une politique de « premier entré, premier sorti » ; et

note: type: Plain text
en: a round-robin policy.
fr: une politique « round-robin ».

note: type: Plain text
en: The semantics of each of these policies are detailed below.
fr: La sémantique de chacune de ces politiques est décrite ci-dessous.

note: type: Plain text
en: B<sched_getscheduler>()  queries the scheduling policy currently applied to the thread identified by I<pid>.  If I<pid> equals zero, the policy of the calling thread will be retrieved.
fr: B<sched_getscheduler>() lit la politique d'ordonnancement et ses paramètres pour le thread identifié par I<pid>. Si I<pid> vaut zéro, la politique du thread en cours sera renvoyée.

note: type: SS
en: Scheduling policies
fr: Politiques d'ordonnancement

note: type: Plain text
en: The scheduler is the kernel component that decides which runnable thread will be executed by the CPU next.  Each thread has an associated scheduling policy and a I<static> scheduling priority, I<sched_priority>; these are the settings that are modified by B<sched_setscheduler>().  The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all threads on the system.
fr: L'ordonnanceur est la partie du noyau qui décide quel thread prêt va être exécuté ensuite. Chaque processus a une politique d'ordonnancement associée et une priorité d'ordonnancement I<statique>, I<sched_priority> ; ce sont les réglages modifiés par B<sched_setscheduler>(). L'ordonnanceur prend ses décisions en fonction de la politique d'ordonnancement et de la priorité statique de tous les threads du système.

note: type: Plain text
en: For threads scheduled under one of the normal scheduling policies (B<SCHED_OTHER>, B<SCHED_IDLE>, B<SCHED_BATCH>), I<sched_priority> is not used in scheduling decisions (it must be specified as 0).
fr: Pour les threads ordonnancés sous l'une des politiques d'ordonnancement normales (B<SCHED_OTHER>, B<SCHED_IDLE>, B<SCHED_BATCH>), I<sched_priority> n'est pas utilisée dans les décisions d'ordonnancement (et doit valoir 0).

note: type: Plain text
en: Processes scheduled under one of the real-time policies (B<SCHED_FIFO>, B<SCHED_RR>) have a I<sched_priority> value in the range 1 (low) to 99 (high).  (As the numbers imply, real-time threads always have higher priority than normal threads.)  Note well: POSIX.1-2001 requires an implementation to support only a minimum 32 distinct priority levels for the real-time policies, and some systems supply just this minimum.  Portable programs should use B<sched_get_priority_min>(2)  and B<sched_get_priority_max>(2)  to find the range of priorities supported for a particular policy.
fr: Les processus ordonnancés sous l'une des politiques d'ordonnancement temps réel (B<SCHED_FIFO>, B<SCHED_RR>) ont une valeur de I<sched_priority> dans l'intervalle 1 (faible) à 99 (haute). (Comme les nombres l'impliquent, les threads temps réel ont toujours une priorité plus haute que les threads normaux.) Notez bien : POSIX.1-2001 exige seulement d'une implémentation qu'elle gère un minimum de 32 niveaux de priorité distincts pour les politiques temps réel et certains systèmes n'offrent que ce minimum. Les programmes portables doivent utiliser B<sched_get_priority_min>(2) et B<sched_get_priority_max>(2) pour connaître l'intervalle des priorités gérées pour une politique particulière.

note: type: Plain text
en: Conceptually, the scheduler maintains a list of runnable threads for each possible I<sched_priority> value.  In order to determine which thread runs next, the scheduler looks for the nonempty list with the highest static priority and selects the thread at the head of this list.
fr: Conceptuellement, l'ordonnanceur dispose d'une liste de tous les threads prêts pour chaque valeur possible de I<sched_priority>. Afin de déterminer quel processus doit s'exécuter ensuite, l'ordonnanceur recherche la liste non vide de plus haute priorité statique et choisit le thread en tête de cette liste.

note: type: Plain text
en: A thread's scheduling policy determines where it will be inserted into the list of threads with equal static priority and how it will move inside this list.
fr: La politique d'ordonnancement d'un thread détermine l'emplacement où il sera inséré dans la liste contenant les threads de même priorité statique, et comment il se déplacera dans cette liste.

note: type: Plain text
en: All scheduling is preemptive: if a thread with a higher static priority becomes ready to run, the currently running thread will be preempted and returned to the wait list for its static priority level.  The scheduling policy determines the ordering only within the list of runnable threads with equal static priority.
fr: Tout ordonnancement est préemptif\ : si un thread avec une priorité statique plus élevée devient prêt, le thread actuellement en cours d'exécution est interrompu et retourne dans la liste d'attente avec son niveau de priorité statique. La politique d'ordonnancement détermine simplement l'ordre utilisé dans une liste de threads prêts avec des priorités statiques égales.

note: type: SS
en: SCHED_FIFO: First in-first out scheduling
fr: SCHED_FIFO\ : Ordonnancement First In-First Out (premier arrivé, premier servi)

note: type: Plain text
en: B<SCHED_FIFO> can be used only with static priorities higher than 0, which means that when a B<SCHED_FIFO> threads becomes runnable, it will always immediately preempt any currently running B<SCHED_OTHER>, B<SCHED_BATCH>, or B<SCHED_IDLE> thread.  B<SCHED_FIFO> is a simple scheduling algorithm without time slicing.  For threads scheduled under the B<SCHED_FIFO> policy, the following rules apply:
fr: B<SCHED_FIFO> ne peut être utilisée qu'avec des priorités statiques supérieures à 0, ce qui signifie que dès qu'un thread B<SCHED_FIFO> devient prêt, un thread normal B<SCHED_OTHER>, B<SCHED_BATCH> ou B<SCHED_IDLE> en cours d'exécution sera interrompu. B<SCHED_FIFO> est un ordonnancement simple sans tranches de temps. Pour les threads ordonnancés par B<SCHED_FIFO> les règles suivantes sont appliquées :

note: type: Plain text
en: A B<SCHED_FIFO> thread that has been preempted by another thread of higher priority will stay at the head of the list for its priority and will resume execution as soon as all threads of higher priority are blocked again.
fr: Un thread B<SCHED_FIFO> qui a été préempté par un autre thread de priorité supérieure restera en tête de sa liste et reprendra son exécution dès que tous les threads de priorités supérieures sont à nouveau bloqués.

note: type: Plain text
en: When a B<SCHED_FIFO> thread becomes runnable, it will be inserted at the end of the list for its priority.
fr: Quand un thread B<SCHED_FIFO> devient prêt, il est inséré à la fin de sa liste.

note: In 2.2.x and 2.4.x, the thread is placed at the front of the queue In 2.0.x, the Right Thing happened: the thread went to the back -- MTK type: Plain text
en: A call to B<sched_setscheduler>()  or B<sched_setparam>(2)  will put the B<SCHED_FIFO> (or B<SCHED_RR>) thread identified by I<pid> at the start of the list if it was runnable.  As a consequence, it may preempt the currently running thread if it has the same priority.  (POSIX.1-2001 specifies that the thread should go to the end of the list.)
fr: Un appel système B<sched_setscheduler>() ou B<sched_setparam>(2) placera le thread B<SCHED_FIFO> (ou B<SCHED_RR>) identifié par I<pid> en tête de sa liste s'il est prêt. Il pourra donc stopper le thread en cours d'exécution si sa priorité est au moins aussi grande. (Selon POSIX.1-2001, le thread devrait aller à la fin de sa liste.)

note: type: Plain text
en: A thread calling B<sched_yield>(2)  will be put at the end of the list.
fr: Un thread appelant B<sched_yield>(2) sera placé à la fin de sa liste.

note: type: Plain text
en: No other events will move a thread scheduled under the B<SCHED_FIFO> policy in the wait list of runnable threads with equal static priority.
fr: Aucun autre événement ne modifiera l'ordre des listes de priorités statiques égales avec B<SCHED_FIFO>.

note: type: Plain text
en: A B<SCHED_FIFO> thread runs until either it is blocked by an I/O request, it is preempted by a higher priority thread, or it calls B<sched_yield>(2).
fr: Un thread B<SCHED_FIFO> s'exécute jusqu'à ce qu'il soit bloqué par une opération d'entrée-sortie, qu'il soit préempté par un thread de priorité supérieure, ou qu'il appelle B<sched_yield>(2).

note: type: SS
en: SCHED_RR: Round-robin scheduling
fr: SCHED_RR\ : Ordonnancement Round Robin

note: On Linux 2.4, the length of the RR interval is influenced by the process nice value -- MTK type: Plain text
en: B<SCHED_RR> is a simple enhancement of B<SCHED_FIFO>.  Everything described above for B<SCHED_FIFO> also applies to B<SCHED_RR>, except that each thread is allowed to run only for a maximum time quantum.  If a B<SCHED_RR> thread has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority.  A B<SCHED_RR> thread that has been preempted by a higher priority thread and subsequently resumes execution as a running thread will complete the unexpired portion of its round-robin time quantum.  The length of the time quantum can be retrieved using B<sched_rr_get_interval>(2).
fr: B<SCHED_RR> est une amélioration simple de la politique B<SCHED_FIFO>. Tout ce qui est décrit pour B<SCHED_FIFO> s'applique aussi à B<SCHED_RR>, sauf que chaque thread ne dispose que d'une tranche temporelle limitée pour son exécution. Si un thread sous politique B<SCHED_RR> s'est exécuté depuis une durée supérieure ou égale à la tranche temporelle (time quantum), il sera placé à la fin de la liste de sa priorité. Un thread sous B<SCHED_RR> qui a été préempté par un thread de priorité supérieure terminera sa tranche de temps lorsqu'il reprendra son exécution. La longueur du quantum de temps peut être lue avec B<sched_rr_get_interval>(2).

note: type: SS
en: SCHED_OTHER: Default Linux time-sharing scheduling
fr: SCHED_OTHER\ : Ordonnancement temps\(hypartagé par défaut

note: type: Plain text
en: B<SCHED_OTHER> can be used at only static priority 0.  B<SCHED_OTHER> is the standard Linux time-sharing scheduler that is intended for all threads that do not require the special real-time mechanisms.  The thread to run is chosen from the static priority 0 list based on a I<dynamic> priority that is determined only inside this list.  The dynamic priority is based on the nice value (set by B<nice>(2)  or B<setpriority>(2))  and increased for each time quantum the thread is ready to run, but denied to run by the scheduler.  This ensures fair progress among all B<SCHED_OTHER> threads.
fr: La politique B<SCHED_OTHER> ne peut être utilisée qu'avec des priorités statiques à 0. C'est la politique standard de l'ordonnanceur temps partagé de Linux, et est conçue pour tous les thread ne réclamant pas de fonctionnalités temps-réel. Le thread à exécuter est choisi dans la liste des threads de priorités statiques nulles, en utilisant une priorité I<dynamique> qui ne s'applique que dans cette liste. La priorité dynamique est basée sur la valeur de «\ politesse\ » du thread (définie avec les appels système B<nice>(2) ou B<setpriority>(2)) et est incrémentée à chaque quantum de temps où le thread est prêt mais non sélectionné par l'ordonnanceur. Ceci garantit une progression équitable de tous les thread B<SCHED_OTHER>.

note: type: SS
en: SCHED_BATCH: Scheduling batch processes
fr: SCHED_BATCH\ : Ordonnancement de processus de traitement par lots

note: type: Plain text
en: (Since Linux 2.6.16.)  B<SCHED_BATCH> can be used only at static priority 0.  This policy is similar to B<SCHED_OTHER> in that it schedules the thread according to its dynamic priority (based on the nice value).  The difference is that this policy will cause the scheduler to always assume that the thread is CPU-intensive.  Consequently, the scheduler will apply a small scheduling penalty with respect to wakeup behaviour, so that this thread is mildly disfavored in scheduling decisions.
fr: (Depuis Linux 2.6.16) B<SCHED_BATCH> ne peut être utilisée qu'avec une priorité statique de 0. Cette politique est similaire à B<SCHED_OTHER>, en ce qu'elle ordonnance les threads conformément à leur priorité dynamique (basée sur la valeur de politesse). La différence est que cette politique fera que l'ordonnanceur considérera toujours que ce thread demande beaucoup de ressources processeur. Par conséquent, il lui appliquera une pénalité d'ordonnancement vis-à-vis du comportement au réveil, et le thread sera légèrement désavantagé dans les décisions d'ordonnancement.

note: The following paragraph is drawn largely from the text that accompanied Ingo Molnar's patch for the implementation of SCHED_BATCH. commit b0a9499c3dd50d333e2aedb7e894873c58da3785 type: Plain text
en: This policy is useful for workloads that are noninteractive, but do not want to lower their nice value, and for workloads that want a deterministic scheduling policy without interactivity causing extra preemptions (between the workload's tasks).
fr: Cette politique est utile pour les processus non interactifs, mais qui ne souhaitent pas diminuer leur valeur de politesse, ou pour ceux qui veulent une politique d'ordonnancement déterministe, sans que l'interactivité ne cause de préemptions supplémentaires.

note: type: SS
en: SCHED_IDLE: Scheduling very low priority jobs
fr: SCHED_IDLE : Ordonnancement de tâches de très faible priorité

note: type: Plain text
en: (Since Linux 2.6.23.)  B<SCHED_IDLE> can be used only at static priority 0; the process nice value has no influence for this policy.
fr: (Depuis Linux 2.6.23.) B<SCHED_IDLE> ne peut être utilisée qu'avec une priorité statique de 0 ; la valeur de courtoisie n'a pas d'influence pour cette politique.

note: type: Plain text
en: This policy is intended for running jobs at extremely low priority (lower even than a +19 nice value with the B<SCHED_OTHER> or B<SCHED_BATCH> policies).
fr: Cette politique est conçue pour l'exécution de tâches de très faible priorité (inférieure même à une valeur de courtoisie +19 dans les politiques B<SCHED_OTHER> ou B<SCHED_BATCH>).

note: type: SS
en: Resetting scheduling policy for child processes
fr: Réinitialiser la politique d'ordonnancement pour les processus fils

note: type: Plain text
en: Since Linux 2.6.32, the B<SCHED_RESET_ON_FORK> flag can be ORed in I<policy> when calling B<sched_setscheduler>().  As a result of including this flag, children created by B<fork>(2)  do not inherit privileged scheduling policies.  This feature is intended for media-playback applications, and can be used to prevent applications evading the B<RLIMIT_RTTIME> resource limit (see B<getrlimit>(2))  by creating multiple child processes.
fr: Depuis Linux 2.6.32, l'attribut B<SCHED_RESET_ON_FORK> peut être inclus à l'aide d'un OU binaire dans I<policy> dans l'appel à B<sched_setscheduler>(). Avec cet attribut, les fils créés par B<fork>(2)  n'héritent pas de politiques d'ordonnancement privilégiées. Cette fonctionnalité est prévue pour des applications de lecture audiovisuelle, et peut être utilisée pour empêcher les applications de passer outre la limite de ressource B<RLIMIT_RTTIME> (consultez B<getrlimit>(2)) en créant de nombreux processus fils.

note: type: Plain text
en: More precisely, if the B<SCHED_RESET_ON_FORK> flag is specified, the following rules apply for subsequently created children:
fr: Plus précisément, si l'attribut B<SCHED_RESET_ON_FORK> est utilisé, les règles suivantes seront appliquées lors de la création ultérieure des fils :

note: type: Plain text
en: If the calling thread has a scheduling policy of B<SCHED_FIFO> or B<SCHED_RR>, the policy is reset to B<SCHED_OTHER> in child processes.
fr: Si le thread appelant a une politique d'ordonnancement B<SCHED_FIFO> ou B<SCHED_RR>, la politique pour les processus fils est réinitialisée à B<SCHED_OTHER>.

note: type: Plain text
en: If the calling process has a negative nice value, the nice value is reset to zero in child processes.
fr: Si le processus appelant a une valeur de politesse négative, elle est mise à zéro pour les processus fils.

note: type: Plain text
en: After the B<SCHED_RESET_ON_FORK> flag has been enabled, it can be reset only if the thread has the B<CAP_SYS_NICE> capability.  This flag is disabled in child processes created by B<fork>(2).
fr: Une fois que l'attribut B<SCHED_RESET_ON_FORK> est activé, il ne peut être désactivé que si le thread possède la capacité B<CAP_SYS_NICE>. Cet attribut est désactivé pour les processus fils créés avec B<fork>(2).

note: type: Plain text
en: The B<SCHED_RESET_ON_FORK> flag is visible in the policy value returned by B<sched_getscheduler>()
fr: L'attribut B<SCHED_RESET_ON_FORK> est visible dans la valeur de la politique du processus renvoyée par B<sched_getscheduler>()

note: type: SS
en: Privileges and resource limits
fr: Privilèges et limites de ressources

note: type: Plain text
en: In Linux kernels before 2.6.12, only privileged (B<CAP_SYS_NICE>)  threads can set a nonzero static priority (i.e., set a real-time scheduling policy).  The only change that an unprivileged thread can make is to set the B<SCHED_OTHER> policy, and this can be done only if the effective user ID of the caller of B<sched_setscheduler>()  matches the real or effective user ID of the target thread (i.e., the thread specified by I<pid>)  whose policy is being changed.
fr: Avec les noyaux Linux antérieurs à 2.6.12, seuls les threads privilégiés (B<CAP_SYS_NICE>) pouvaient attribuer une priorité statique non nulle (c'est-à-dire définir une politique d'ordonnancement temps réel). Le seul changement qu'un thread non privilégié pouvait faire était d'affecter la politique B<SCHED_OTHER>, et seulement si l'UID effectif de l'appelant de B<sched_setscheduler>() était le même que l'UID réel ou effectif du thread cible (c'est-à-dire le thread spécifié par I<pid>), dont la politique est modifiée.

note: type: Plain text
en: Since Linux 2.6.12, the B<RLIMIT_RTPRIO> resource limit defines a ceiling on an unprivileged thread's static priority for the B<SCHED_RR> and B<SCHED_FIFO> policies.  The rules for changing scheduling policy and priority are as follows:
fr: Depuis Linux 2.6.12, la limite de ressources B<RLIMIT_RTPRIO> définit un plafond pour la priorité statique d'un thread non privilégié pour les politiques B<SCHED_RR> et B<SCHED_FIFO>. Les règles pour modifier la politique d'ordonnancement et la priorité sont les suivantes :

note: type: Plain text
en: If an unprivileged thread has a nonzero B<RLIMIT_RTPRIO> soft limit, then it can change its scheduling policy and priority, subject to the restriction that the priority cannot be set to a value higher than the maximum of its current priority and its B<RLIMIT_RTPRIO> soft limit.
fr: Si un thread non privilégié a une limite souple B<RLIMIT_RTPRIO> non nulle, il peut modifier sa politique et sa priorité d'ordonnancement, à condition que la priorité reste inférieure au maximum de sa priorité actuelle et à la limite souple B<RLIMIT_RTPRIO>.

note: type: Plain text
en: If the B<RLIMIT_RTPRIO> soft limit is 0, then the only permitted changes are to lower the priority, or to switch to a non-real-time policy.
fr: Si la limite souple B<RLIMIT_RTPRIO> est nulle, les seules modifications permises sont une diminution de la priorité ou bien un basculement vers une politique qui ne soit pas temps réel.

note: type: Plain text
en: Subject to the same rules, another unprivileged thread can also make these changes, as long as the effective user ID of the thread making the change matches the real or effective user ID of the target thread.
fr: Soumis aux mêmes règles, un autre thread non privilégié peut également faire ces modifications à partir du moment où l'UID effectif du thread effectuant la modification correspond à l'UID réel ou effectif du thread cible.

note: commit c02aa73b1d18e43cfd79c2f193b225e84ca497c8 type: Plain text
en: Special rules apply for the B<SCHED_IDLE>.  In Linux kernels before 2.6.39, an unprivileged thread operating under this policy cannot change its policy, regardless of the value of its B<RLIMIT_RTPRIO> resource limit.  In Linux kernels since 2.6.39, an unprivileged thread can switch to either the B<SCHED_BATCH> or the B<SCHED_NORMAL> policy so long as its nice value falls within the range permitted by its B<RLIMIT_NICE> resource limit (see B<getrlimit>(2)).
fr: Des règles particulières s'appliquent à B<SCHED_IDLE>. Dans les noyaux Linux antérieurs à 2.6.39, un thread non privilégié opérant sous cette politique ne peut pas modifier sa politique, quelle que soit la valeur de sa limite souple de ressources B<RLIMIT_RTPRIO>. Dans les noyaux Linux postérieurs à 2.6.39, un thread non privilégié peut basculer vers la politique B<SCHED_BATCH> ou B<SCHED_NORMAL> tant que sa valeur de politesse tombe dans l'intervalle permis par sa limite de ressources B<RLIMIT_NICE> (consultez B<getrlimit>(2)).

note: type: Plain text
en: Privileged (B<CAP_SYS_NICE>)  threads ignore the B<RLIMIT_RTPRIO> limit; as with older kernels, they can make arbitrary changes to scheduling policy and priority.  See B<getrlimit>(2)  for further information on B<RLIMIT_RTPRIO>.
fr: Les threads privilégiés (B<CAP_SYS_NICE>) ignorent la limite B<RLIMIT_RTPRIO> : comme avec d'anciens noyaux, ils peuvent modifier arbitrairement la politique d'ordonnancement et la priorité. Consultez B<getrlimit>(2) pour plus d'informations sur B<RLIMIT_RTPRIO>.

note: type: SS
en: Response time
fr: Temps de réponse

note: as described in .BR request_irq (9). type: Plain text
en: A blocked high priority thread waiting for the I/O has a certain response time before it is scheduled again.  The device driver writer can greatly reduce this response time by using a "slow interrupt" interrupt handler.
fr: Un thread de haute priorité bloqué en attente d'entrées-sorties est affecté d'un certain temps de réponse avant d'être sélectionné à nouveau. Le concepteur d'un gestionnaire de périphérique peut réduire grandement ce temps de réponse en utilisant un gestionnaire d'interruptions lentes.

note: type: SS
en: Miscellaneous
fr: Divers

note: type: Plain text
en: Child processes inherit the scheduling policy and parameters across a B<fork>(2).  The scheduling policy and parameters are preserved across B<execve>(2).
fr: Les processus fils héritent de la politique d'ordonnancement et des paramètres associés lors d'un B<fork>(2). L'algorithme et les paramètres d'ordonnancement sont conservés au travers d'un B<execve>(2).

note: type: Plain text
en: Memory locking is usually needed for real-time processes to avoid paging delays; this can be done with B<mlock>(2)  or B<mlockall>(2).
fr: Le verrouillage de pages en mémoire est généralement nécessaire pour les processus temps réel afin d'éviter les délais de pagination ; ceci peut être effectué avec B<mlock>(2) ou B<mlockall>(2).

note: type: Plain text
en: Since a nonblocking infinite loop in a thread scheduled under B<SCHED_FIFO> or B<SCHED_RR> will block all threads with lower priority forever, a software developer should always keep available on the console a shell scheduled under a higher static priority than the tested application.  This will allow an emergency kill of tested real-time applications that do not block or terminate as expected.  See also the description of the B<RLIMIT_RTTIME> resource limit in B<getrlimit>(2).
fr: Comme une boucle sans fin non bloquante dans un thread ordonnancé sous une politique B<SCHED_FIFO> ou B<SCHED_RR> bloquera indéfiniment tous les threads avec une priorité plus faible, le développeur d'applications temps\(hyréel devrait toujours conserver sur une console un shell ordonnancé avec une priorité supérieure à celle de l'application testée. Ceci permettra un B<kill>(1) d'urgence des applications testées qui ne se bloquent pas ou qui ne se terminent pas comme prévu. Consultez également la description de la limite de ressources B<RLIMIT_RTTIME> dans B<getrlimit>(2).

note: type: Plain text
en: POSIX systems on which B<sched_setscheduler>()  and B<sched_getscheduler>()  are available define B<_POSIX_PRIORITY_SCHEDULING> in I<E<lt>unistd.hE<gt>>.
fr: Les systèmes POSIX sur lesquels B<sched_setscheduler>() et B<sched_getscheduler>() sont disponibles définissent B<_POSIX_PRIORITY_SCHEDULING> dans I<E<lt>unistd.hE<gt>>.

note: type: Plain text
en: On success, B<sched_setscheduler>()  returns zero.  On success, B<sched_getscheduler>()  returns the policy for the thread (a nonnegative integer).  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<sched_setscheduler>() renvoie 0 s'il réussit. B<sched_getscheduler>() renvoie la politique pour le thread (un entier E<gt>= 0) s'il réussit. En cas d'échec, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: The scheduling I<policy> is not one of the recognized policies, I<param> is NULL, or I<param> does not make sense for the I<policy>.
fr: La valeur de politique d'ordonnancement I<policy> n'existe pas, I<param> vaut NULL ou n'a pas de signification pour la politique I<policy>.

note: type: Plain text
en: The calling thread does not have appropriate privileges.
fr: Le thread appelant ne possède pas les privilèges nécessaires.

note: type: Plain text
en: POSIX.1-2001 (but see BUGS below).  The B<SCHED_BATCH> and B<SCHED_IDLE> policies are Linux-specific.
fr: POSIX.1-2001 (voir la section BOGUES ci-dessous). Les politiques B<SCHED_BATCH> et B<SCHED_IDLE> sont spécifiques à Linux.

note: type: Plain text
en: POSIX.1 does not detail the permissions that an unprivileged thread requires in order to call B<sched_setscheduler>(), and details vary across systems.  For example, the Solaris 7 manual page says that the real or effective user ID of the caller must match the real user ID or the save set-user-ID of the target.
fr: POSIX.1 ne détaille pas quelles permissions sont nécessaire pour qu'un thread non privilégié puisse appeler B<sched_setscheduler>(), et les détails dépendent des systèmes. Par exemple, la page de manuel de Solaris 7 dit que l'UID réel ou effectif du thread appelant doit correspondre à l'UID réel ou sauvé du processus visé.

note: type: Plain text
en: The scheduling policy and parameters are in fact per-thread attributes on Linux.  The value returned from a call to B<gettid>(2)  can be passed in the argument I<pid>.  Specifying I<pid> as 0 will operate on the attribute for the calling thread, and passing the value returned from a call to B<getpid>(2)  will operate on the attribute for the main thread of the thread group.  (If you are using the POSIX threads API, then use B<pthread_setschedparam>(3), B<pthread_getschedparam>(3), and B<pthread_setschedprio>(3), instead of the B<sched_*>(2)  system calls.)
fr: Sous Linux, la politique et les paramètres d'ordonnancement sont,  des attributs des threads. La valeur renvoyée par un appel à B<gettid>(2) peut être passée via l'argument I<pid>. Lorsque la valeur de I<pid> indiquée est 0, l'attribut sera défini pour le thread appelant ; lorsque cette valeur est celle renvoyée par B<getpid>(2), l'attribut modifié sera celui du thread principal du groupe de threads (si vous utilisez l'API de manipulation des threads POSIX, alors utilisez B<pthread_setschedparam>(3), B<pthread_getschedparam>(3) et B<pthread_setschedprio>(3) plutôt que les appels système B<sched_*>(2)).

note: type: Plain text
en: Originally, Standard Linux was intended as a general-purpose operating system being able to handle background processes, interactive applications, and less demanding real-time applications (applications that need to usually meet timing deadlines).  Although the Linux kernel 2.6 allowed for kernel preemption and the newly introduced O(1) scheduler ensures that the time needed to schedule is fixed and deterministic irrespective of the number of active tasks, true real-time computing was not possible up to kernel version 2.6.17.
fr: À l'origine, le noyau Linux standard visait un système d'exploitation à vocation généraliste, devant gérer des processus en arrière-plan, des applications interactives, et des applications en temps réel souple (qui ont besoin en général de répondre à des critères de temps maximal). Bien que le noyau Linux 2.6 ait permis la préemption du noyau et que le nouvellement introduit ordonnanceur O(1) assure que le temps nécessaire pour planifier soit fixe et déterministe quel que soit le nombre de tâches, une vraie gestion temps réel n'était pas possible avant le noyau 2.6.17.

note: type: SS
en: Real-time features in the mainline Linux kernel
fr: Fonctionnalités temps réel dans le noyau Linux principal

note: FIXME . Probably this text will need some minor tweaking by about the time of 2.6.30; ask Carsten Emde about this then. type: Plain text
en: From kernel version 2.6.18 onward, however, Linux is gradually becoming equipped with real-time capabilities, most of which are derived from the former I<realtime-preempt> patches developed by Ingo Molnar, Thomas Gleixner, Steven Rostedt, and others.  Until the patches have been completely merged into the mainline kernel (this is expected to be around kernel version 2.6.30), they must be installed to achieve the best real-time performance.  These patches are named:
fr: Toutefois, depuis le noyau 2.6.18, Linux s'est vu graduellement équipé de possibilités temps réel, la plupart étant dérivées des ajouts de préemption temps réel (I<realtime-preempt>) réalisés par Ingo Molnar, Thomas Gleixner, Steven Rostedt et autres. Jusqu'à ce que ces ajouts aient été entièrement fusionnés dans le noyau principal (c'est attendu aux alentours des versions 2.6.30), ils doivent être installés pour atteindre les meilleures performances temps réel. Ces ajouts s'appellent :

note: type: Plain text
en: patch-I<kernelversion>-rtI<patchversion>
fr: patch-I<version-noyau>-rtI<version-patch>

note: type: Plain text
en: and can be downloaded from E<.UR http://www.kernel.org\:/pub\:/linux\:/kernel\:/projects\:/rt/> E<.UE .>
fr: et peuvent être téléchargés à partir de E<.UR http://www.kernel.org\:/pub\:/linux\:/kernel\:/projects\:/rt/> E<.UE .>

note: type: Plain text
en: Without the patches and prior to their full inclusion into the mainline kernel, the kernel configuration offers only the three preemption classes B<CONFIG_PREEMPT_NONE>, B<CONFIG_PREEMPT_VOLUNTARY>, and B<CONFIG_PREEMPT_DESKTOP> which respectively provide no, some, and considerable reduction of the worst-case scheduling latency.
fr: Sans les ajouts et avant leur complète inclusion dans le noyau principal, la configuration du noyau n'offre que trois classes de préemption B<CONFIG_PREEMPT_NONE>, B<CONFIG_PREEMPT_VOLUNTARY> et B<CONFIG_PREEMPT_DESKTOP> qui fournissement respectivement « aucune », « quelque » et une « considérable » réduction de la latence d'ordonnancement de pire cas.

note: type: Plain text
en: With the patches applied or after their full inclusion into the mainline kernel, the additional configuration item B<CONFIG_PREEMPT_RT> becomes available.  If this is selected, Linux is transformed into a regular real-time operating system.  The FIFO and RR scheduling policies that can be selected using B<sched_setscheduler>()  are then used to run a thread with true real-time priority and a minimum worst-case scheduling latency.
fr: Avec les ajouts appliqués ou après leur pleine inclusion dans le noyau principal, la configuration supplémentaire B<CONFIG_PREEMPT_RT> devient disponible. Si elle est choisie, Linux est transformé en un système d'exploitation temps réel ordinaire. Les politiques d'ordonnancement FIFO et RR qui peuvent être définies avec B<sched_setscheduler>() sont alors utilisées pour lancer un thread avec une vraie priorité temps réel et une latence minimum d'ordonnancement de pire cas.

note: type: Plain text
en: POSIX says that on success, B<sched_setscheduler>()  should return the previous scheduling policy.  Linux B<sched_setscheduler>()  does not conform to this requirement, since it always returns 0 on success.
fr: POSIX dit qu'en cas de réussite, B<sched_setscheduler>() devrait renvoyer la politique d'ordonnancement précédente. La version Linux de B<sched_setscheduler>() ne se conforme par à cette demande puisqu'elle renvoie toujours 0 en cas de réussite.

note: type: Plain text
en: The Linux kernel source file I<Documentation/scheduler/sched-rt-group.txt>
fr: Le fichier des sources du noyau Linux I<Documentation/scheduler/sched-rt-group.txt>

note: type: TH
en: 2008-10-18
fr: 18 octobre 2008

note: type: Plain text
en: sched_yield - yield the processor
fr: sched_yield - Céder le processeur

note: type: Plain text
en: B<sched_yield>()  causes the calling thread to relinquish the CPU.  The thread is moved to the end of the queue for its static priority and a new thread gets to run.
fr: B<sched_yield>() force le thread appelant à libérer le CPU. Le thread est déplacé à la fin de la liste des processus prêts de sa priorité, et un autre thread sera exécuté.

note: type: Plain text
en: On success, B<sched_yield>()  returns 0.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<sched_yield>() renvoie 0 s'il réussit ou -1 s'il échoue auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: In the Linux implementation, B<sched_yield>()  always succeeds.
fr: L'implémentation Linux de B<sched_yield>() réussit toujours.

note: type: Plain text
en: If the calling thread is the only thread in the highest priority list at that time, it will continue to run after a call to B<sched_yield>().
fr: Si le thread appelant est le seul avec la priorité la plus élevée au moment de l'appel, il continuera son exécution après un appel à B<sched_yield>().

note: type: Plain text
en: POSIX systems on which B<sched_yield>()  is available define B<_POSIX_PRIORITY_SCHEDULING> in I<E<lt>unistd.hE<gt>>.
fr: Les systèmes POSIX sur lesquels B<sched_yield>() est disponible définissent B<_POSIX_PRIORITY_SCHEDULING> dans I<E<lt>unistd.hE<gt>>.

note: type: Plain text
en: Strategic calls to B<sched_yield>()  can improve performance by giving other threads or processes a chance to run when (heavily) contended resources (e.g., mutexes)  have been released by the caller.  Avoid calling B<sched_yield>()  unnecessarily or inappropriately (e.g., when resources needed by other schedulable threads are still held by the caller), since doing so will result in unnecessary context switches, which will degrade system performance.
fr: Des appels stratégiques à B<sched_yield>() peuvent améliorer les performances en donnant à d'autres thread ou processus une chance de s'exécuter quand des ressources (très) demandées (par exemple, des mutex) sont libérées par l'appelant. Évitez d'appeler B<sched_yield>() si ce n'est pas nécessaire ou inapproprié (par exemple, si les ressources nécessaires pour d'autres threads pouvant être ordonnancés sont encore tenues par l'appelant), puisqu'en faisant ainsi provoquera des changements de contexte non nécessaire, qui dégraderont les performances du système.

note: type: Plain text
en: B<sched_setscheduler>(2)  for a description of Linux scheduling
fr: B<sched_setscheduler>(2) pour une description de l'ordonnancement sous Linux

note: type: TH
en: 2013-01-01
fr: 1er janvier 2013

note: type: Plain text
en: setns - reassociate thread with a namespace
fr: setns - Réassocier un thread avec un espace de noms

note: type: Plain text
en: Given a file descriptor referring to a namespace, reassociate the calling thread with that namespace.
fr: Étant donné un descripteur de fichiers faisant référence à un espace de noms, réassocier le thread appelant à cet espace de noms.

note: type: Plain text
en: The I<fd> argument is a file descriptor referring to one of the namespace entries in a I</proc/[pid]/ns/> directory; see B<proc>(5)  for further information on I</proc/[pid]/ns/>.  The calling thread will be reassociated with the corresponding namespace, subject to any constraints imposed by the I<nstype> argument.
fr: L'argument I<fd> est un descripteur de fichier faisant référence à un des espaces de noms présents sous la forme d'entrées dans un répertoire I</proc/[pid]/ns/>. Consultez B<proc>(5) pour plus d'informations sur I</proc/[pid]/ns>. Le thread appelant sera réassocié avec l'espace de noms correspondant, si les contraintes imposées par l'argument I<nstype> sont satisfaites.

note: type: Plain text
en: The I<nstype> argument specifies which type of namespace the calling thread may be reassociated with.  This argument can have one of the following values:
fr: L'argument I<nstype> indique les types d'espaces de noms auxquels le thread appelant peut être réassocié. Cet argument peut prendre une des valeurs suivantes :

note: type: Plain text
en: Allow any type of namespace to be joined.
fr: I<fd> peut faire référence à n'importe quel type d'espace de noms.

note: type: Plain text
en: I<fd> must refer to an IPC namespace.
fr: I<fd> doit faire référence à un espace de noms IPC.

note: type: Plain text
en: I<fd> must refer to a network namespace.
fr: I<fd> doit faire référence à un espace de noms réseau.

note: type: Plain text
en: I<fd> must refer to a UTS namespace.
fr: I<fd> doit faire référence à un espace de noms UTS.

note: type: Plain text
en: Specifying I<nstype> as 0 suffices if the caller knows (or does not care)  what type of namespace is referred to by I<fd>.  Specifying a nonzero value for I<nstype> is useful if the caller does not know what type of namespace is referred to by I<fd> and wants to ensure that the namespace is of a particular type.  (The caller might not know the type of the namespace referred to by I<fd> if the file descriptor was opened by another process and, for example, passed to the caller via a UNIX domain socket.)
fr: Définir la valeur de I<nstype> à zéro est suffisant si le thread appelant connaît (ou n'a pas besoin de connaître) le type d'espace de noms auquel I<fd> fait référence. Définir I<nstype> à une valeur non nulle est utile si l'appelant ne connaît pas le type de l'espace de noms référencé par I<fd> et veut s'assurer que l'espace de noms est du type souhaité. (L'appelant pourrait ne pas connaître le type de l'espace de noms auquel I<fd> fait référence si le descripteur de fichiers a été ouvert par un autre processus et qu'il a, par exemple, été passé à l'appelant par une socket UNIX.)

note: type: Plain text
en: On success, I<setns>()  returns 0.  On failure, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, I<setns>() renvoie zéro, sinon il renvoie -1 et remplit I<errno> avec le code d'erreur.

note: type: Plain text
en: I<fd> is not a valid file descriptor.
fr: I<fd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: I<fd> refers to a namespace whose type does not match that specified in I<nstype>, or there is problem with reassociating the the thread with the specified namespace.
fr: I<fd> fait référence à un espace de noms dont le type ne correspond pas à celui indiqué dans I<nstype>, ou bien un problème s'est produit lors de la réassociation du thread avec l'espace de noms indiqué.

note: type: Plain text
en: Cannot allocate sufficient memory to change the specified namespace.
fr: Impossible d'allouer suffisamment de mémoire pour changer l'espace de noms indiqué.

note: type: Plain text
en: The calling thread did not have the required privilege (B<CAP_SYS_ADMIN>)  for this operation.
fr: Le processus appelant n'avait pas les privilèges (B<CAP_SYS_ADMIN>) pour effectuer cette opération.

note: type: Plain text
en: The B<setns>()  system call first appeared in Linux in kernel 3.0; library support was added to glibc in version 2.14.
fr: L'appel système B<setns>() est apparu dans Linux 3.0 ; son support a été ajouté dans la version 2.14 de la glibc.

note: type: Plain text
en: The B<setns>()  system call is Linux-specific.
fr: L'appel système B<setns>() est spécifique à Linux.

note: type: Plain text
en: Not all of the attributes that can be shared when a new thread is created using B<clone>(2)  can be changed using B<setns>().
fr: Certains des attributs qui peuvent être partagés avec un nouveau thread créé avec B<clone>(2) ne peuvent pas être modifiés en utilisant B<setns>().

note: type: Plain text
en: The program below takes two or more arguments.  The first argument specifies the pathname of a namespace file in an existing I</proc/[pid]/ns/> directory.  The remaining arguments specify a command and its arguments.  The program opens the namespace file, joins that namespace using B<setns>(), and executes the specified command inside that namespace.
fr: Le programme ci-dessous attend au moins deux arguments. Le premier précise le chemin d'un fichier d'espace de noms dans un répertoire I</proc/[pid]/ns/> qui doit exister préalablement. Les arguments suivants précisent une commande et ses arguments. Le programme ouvre le fichier d'espace de noms, s'associe à l'espace de noms en utilisant B<setns>(), et exécute la commande indiquée dans cet espace de noms.

note: type: Plain text
en: The following shell session demonstrates the use of this program (compiled as a binary named I<ns_exec>)  in conjunction with the B<CLONE_NEWUTS> example program in the B<clone>(2)  man page (complied as a binary named I<newuts>).
fr: La session d'invite de commandes suivante présente l'utilisation du programme (compilé dans un binaire appelé I<ns_exec>) en lien avec le programme B<CLONE_NEWUTS> donné en example dans la page de manuel B<clone>(2) (compilé dans un binaire appelé I<newuts>).

note: type: Plain text
en: We begin by executing the example program in B<clone>(2)  in the background.  That program creates a child in a separate UTS namespace.  The child changes the hostname in its namespace, and then both processes display the hostnames in their UTS namespaces, so that we can see that they are different.
fr: Nous commençons par exécuter le programme donné à titre d'exemple dans B<clone>(2) en tâche de fond. Ce programme crée un processus fils dans un espace de noms UTS distinct. Le processus fils change le nom d'hôtes dans son espace de noms, puis les deux processus affichent leur noms d'hôtes dans leurs espaces de noms UTS respectifs, de façon à bien montrer leur différence.

note: type: Plain text
en: $ B<su>                   # Need privilege for namespace operations
    Password:
    # B<./newuts bizarro &>
    [1] 3549
    clone() returned 3550
    uts.nodename in child:  bizarro
    uts.nodename in parent: antero
    # B<uname -n>             # Verify hostname in the shell
    antero
fr: $ B<su>       # Privilèges nécessaires aux opérations sur l'espace de noms
    Mot de passe : 
    # B<./newuts bizarro &>
    [1] 3549
    clone() à renvoyé 3550
    uts.nodename dans le fils : bizarro
    uts.nodename dans le père : antero
    # B<uname -n> # Vérifier le nom d'hôte dans l'invite de commande
    antero

note: type: Plain text
en: We then run the program shown below, using it to execute a shell.  Inside that shell, we verify that the hostname is the one set by the child created by the first program:
fr: Nous appelons alors le programme présenté ci-dessous afin de lancer une invite de commande. Dans cette invite, on vérifie que le nom d'hôte est bien celui défini par le processus fils créé dans le premier programme :

note: type: Plain text
en: # B<./ns_exec /proc/3550/ns/uts /bin/bash>
    # B<uname -n>             # Executed in shell started by ns_exec
    bizarro
fr: # B<./ns_exec /proc/3550/ns/uts /bin/bash>
    # B<uname -n>             # Exécuté dans l'invite lancée par ns_exec
    bizarro

note: type: Plain text
en:     fd = open(argv[1], O_RDONLY);   /* Get descriptor for namespace */
        if (fd == -1)
            errExit("open");
fr:     fd = open(argv[1], O_RDONLY);   /* Récupérer le descripteur pour
                                           l'espace de noms */
        if (fd == -1)
            errExit("open");

note: type: Plain text
en:     if (setns(fd, 0) == -1)         /* Join that namespace */
            errExit("setns");
fr:     if (setns(fd, 0) == -1)         /* S'associer à l'espace de noms */
            errExit("setns");

note: type: Plain text
en:     execvp(argv[2], &argv[2]);      /* Execute a command in namespace */
        errExit("execvp");
    }
fr:     execvp(argv[2], &argv[2]);      /* Exécuter la commande dans
                                           l'espace de noms */
        errExit("execvp");
    }

note: type: Plain text
en: unshare - disassociate parts of the process execution context
fr: unshare - Désassocier certaines parties du contexte d'exécution

note: type: Plain text
en: B<unshare>()  allows a process to disassociate parts of its execution context that are currently being shared with other processes.  Part of the execution context, such as the mount namespace, is shared implicitly when a new process is created using B<fork>(2)  or B<vfork>(2), while other parts, such as virtual memory, may be shared by explicit request when creating a process using B<clone>(2).
fr: B<unshare>() permet à un processus de désassocier certaines parties de son contexte d'exécution qui sont actuellement partagées avec d'autres processus. Une partie du contexte d'exécution, comme l'espace de noms de montage, est implicitement partagé quand un processus est créé avec B<fork>(2) ou B<vfork>(2), alors que d'autres parties, comme la mémoire virtuelle, peuvent être partagées en faisant explicitement la demande lors de la création d'un processus avec B<clone>(2).

note: type: Plain text
en: The main use of B<unshare>()  is to allow a process to control its shared execution context without creating a new process.
fr: L'intérêt principal de B<unshare>() est de permettre à un processus de contrôler son contexte d'exécution partagé sans avoir à créer un nouveau processus.

note: type: Plain text
en: The I<flags> argument is a bit mask that specifies which parts of the execution context should be unshared.  This argument is specified by ORing together zero or more of the following constants:
fr: L'argument I<flags> est un masque qui indique quelles parties du contexte d'exécution doivent être désassociées. Cet argument est construit comme un OU binaire entre les constantes suivantes\ :

note: type: Plain text
en: Reverse the effect of the B<clone>(2)  B<CLONE_FILES> flag.  Unshare the file descriptor table, so that the calling process no longer shares its file descriptors with any other process.
fr: A l'effet inverse de l'attribut B<CLONE_FILES> de B<clone>(2). Supprimer le partage de la table des descripteurs de fichier, afin que le processus appelant ne partage plus ses descripteurs de fichier avec d'autres processus.

note: type: Plain text
en: Reverse the effect of the B<clone>(2)  B<CLONE_FS> flag.  Unshare filesystem attributes, so that the calling process no longer shares its root directory (B<chroot>(2)), current directory (B<chdir>(2)), or umask (B<umask>(2))  attributes with any other process.
fr: Annuler l'effet de l'attribut B<CLONE_FS> de B<clone>(2). Départager les attributs de système de fichiers, afin que le processus appelant ne partage plus son répertoire racine (B<chroot>(2)), son répertoire courant (B<chdir>(2)) et sa valeur d'umask (B<umask>(2)) avec d'autres processus.

note: type: Plain text
en: This flag has the same effect as the B<clone>(2)  B<CLONE_NEWIPC> flag.  Unshare the System V IPC namespace, so that the calling process has a private copy of the System V IPC namespace which is not shared with any other process.  Specifying this flag automatically implies B<CLONE_SYSVSEM> as well.  Use of B<CLONE_NEWIPC> requires the B<CAP_SYS_ADMIN> capability.
fr: Cet attribut a le même effet que l'attribut B<CLONE_NEWIPC> de B<clone>(2). Départager l'espace de noms IPC System V, afin que le processus appelant ait une copie privée de l'espace de noms IPC System V qui ne soit pas partagée avec d'autres processus. L'utilisation de cet attribut implique B<CLONE_SYSVSEM>. L'utilisation de B<CLONE_NEWIPC> nécessite la capacité B<CAP_SYS_ADMIN>.

note: type: Plain text
en: This flag has the same effect as the B<clone>(2)  B<CLONE_NEWNET> flag.  Unshare the network namespace, so that the calling process is moved into a new network namespace which is not shared with any previously existing process.  Use of B<CLONE_NEWNET> requires the B<CAP_SYS_ADMIN> capability.
fr: Cet attribut a le même effet que l'attribut B<CLONE_NEWNET> de B<clone>(2). Départager l'espace de noms de réseau, afin que le processus appelant soit déplacé dans un nouvel espace de noms de réseau qui n'est pas partagé avec d'autres processus. B<CLONE_NEWNET> nécessite la capacité B<CAP_SYS_ADMIN>.

note: These flag name are inconsistent: CLONE_NEWNS does the same thing in clone(), but CLONE_VM, CLONE_FS, and CLONE_FILES reverse the action of the clone() flags of the same name. type: Plain text
en: This flag has the same effect as the B<clone>(2)  B<CLONE_NEWNS> flag.  Unshare the mount namespace, so that the calling process has a private copy of its namespace which is not shared with any other process.  Specifying this flag automatically implies B<CLONE_FS> as well.  Use of B<CLONE_NEWNS> requires the B<CAP_SYS_ADMIN> capability.
fr: Cet attribut a le même effet que l'attribut B<CLONE_NEWNS> de B<clone>(2). Départager l'espace de noms de montage, afin que le processus appelant ait une copie privée de son espace de noms qui ne soit pas partagée avec d'autres processus. L'utilisation de cet attribut implique B<CLONE_FS>. L'utilisation de B<CLONE_NEWNS> nécessite la capacité B<CAP_SYS_ADMIN>.

note: type: Plain text
en: This flag has the same effect as the B<clone>(2)  B<CLONE_NEWUTS> flag.  Unshare the UTS IPC namespace, so that the calling process has a private copy of the UTS namespace which is not shared with any other process.  Use of B<CLONE_NEWUTS> requires the B<CAP_SYS_ADMIN> capability.
fr: Cet attribut a le même effet que l'attribut B<CLONE_NEWUTS> de B<clone>(2). Départager l'espace de noms IPC UTS, afin que le processus appelant ait une copie privée de l'espace de noms UTS qui ne soit pas partagée avec d'autres processus. L'utilisation de B<CLONE_NEWUTS> nécessite la capacité B<CAP_SYS_ADMIN>.

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

note: commit 9edff4ab1f8d82675277a04e359d0ed8bf14a7b7 As at 2.6.16, the following forced implications also apply, although the relevant flags are not yet implemented. If CLONE_THREAD is set force CLONE_VM. If CLONE_VM is set, force CLONE_SIGHAND. CLONE_NEWNSIf CLONE_SIGHAND is set and signals are also bei
en: This flag reverses the effect of the B<clone>(2)  B<CLONE_SYSVSEM> flag.  Unshare System V semaphore undo values, so that the calling process has a private copy which is not shared with any other process.  Use of B<CLONE_SYSVSEM> requires the B<CAP_SYS_ADMIN> capability.
fr: Cet attribut inverse l'effet de l'attribut B<CLONE_SYSVSEM> de B<clone>(2). Départager les valeurs « undo » des sémaphores System V, afin que le processus appelant ait une copie privée qui ne soit pas partagée avec d'autres processus. L'utilisation de B<CLONE_SYSVSEM> nécessite la capacité B<CAP_SYS_ADMIN>.

note: type: Plain text
en: If I<flags> is specified as zero, then B<unshare>()  is a no-op; no changes are made to the calling process's execution context.
fr: Si I<flags> est nul, B<unshare>() n'a aucun effet\ : le contexte d'exécution du processus appelant n'est pas modifié.

note: type: Plain text
en: On success, zero returned.  On failure, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit l'appel renvoie zéro, sinon il renvoie -1 et remplit I<errno> avec le code d'erreur.

note: type: Plain text
en: An invalid bit was specified in I<flags>.
fr: Un attribut invalide est indiqué dans I<flags>.

note: type: Plain text
en: Cannot allocate sufficient memory to copy parts of caller's context that need to be unshared.
fr: Impossible d'allouer suffisamment de mémoire pour copier les parties du contexte de l'appelant qui doivent être rendues privées.

note: type: Plain text
en: The calling process did not have the required privileges for this operation.
fr: Le processus appelant n'avait pas les privilèges appropriés pour effectuer cette opération.

note: type: Plain text
en: The B<unshare>()  system call was added to Linux in kernel 2.6.16.
fr: L'appel système B<unshare>() est apparu dans Linux 2.6.16.

note: type: Plain text
en: The B<unshare>()  system call is Linux-specific.
fr: L'appel système B<unshare>() est spécifique à Linux.

note: FIXME all of the following needs to be reviewed for the current kernel However, we can do unshare(CLONE_SIGHAND) if CLONE_SIGHAND was not specified when doing clone(); i.e., unsharing signal handlers is permitted if we are not actually sharing signal handlers.   mtk However, we can do unshare(CLONE_
en: Not all of the process attributes that can be shared when a new process is created using B<clone>(2)  can be unshared using B<unshare>().  In particular, as at kernel 3.8, B<unshare>()  does not implement flags that reverse the effects of B<CLONE_SIGHAND>, B<CLONE_THREAD>, or B<CLONE_VM>.  Such functionality may be added in the future, if required.
fr: Tous les attributs de processus qui peuvent être partagés lorsqu'un processus est créé avec B<clone>(2) ne peuvent pas être rendus privés avec B<unshare>(). En particulier, dans le noyau 3.8, B<unshare>() n'implémente pas de drapeaux inversant les effets de B<CLONE_SIGHAND>, B<CLONE_THREAD> ou B<CLONE_VM>. Cette fonctionnalité pourra être ajoutée plus tard si nécessaire.

note: type: Plain text
en: I<Documentation/unshare.txt> in the Linux kernel source tree
fr: I<Documentation/unshare.txt> dans les sources du noyau Linux
