perkamon - en to fr translation catalogue (510 entries)

note: type: TH
en: 2007-12-26
fr: 26 décembre 2007

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: arch_prctl - set architecture-specific thread state
fr: arch_prctl - Fixer l'état spécifique à l'architecture

note: type: Plain text
en: The B<arch_prctl>()  function sets architecture-specific process or thread state.  I<code> selects a subfunction and passes argument I<addr> to it; I<addr> is interpreted as either an I<unsigned long> for the "set" operations, or as an I<unsigned long *>, for the "get" operations.
fr: La fonction B<arch_prctl>() fixe l'état spécifique à l'architecture pour le thread ou le processus. I<code> sélectionne une sous\(hyfonction et lui passe l'argument I<addr> ; I<addr> est interprété comme un I<unsigned long> pour les opérations « set », ou comme un I<unsigned long *>, pour les opérations « get ».

note: type: Plain text
en: Sub functions for x86-64 are:
fr: Les sous\(hyfonctions pour l'architecture x86-64 sont\ :

note: type: Plain text
en: Set the 64-bit base for the I<FS> register to I<addr>.
fr: Remplit la base 64 bits pour le registre I<FS> avec I<addr>.

note: type: Plain text
en: Return the 64-bit base value for the I<FS> register of the current thread in the I<unsigned long> pointed to by I<addr>.
fr: Renvoie la base 64 bits pour le registre I<FS> du thread en cours dans la variable I<unsigned long> pointée par I<addr>.

note: type: Plain text
en: Set the 64-bit base for the I<GS> register to I<addr>.
fr: Remplit la base 64 bits pour le registre I<GS> avec I<addr>.

note: type: Plain text
en: Return the 64-bit base value for the I<GS> register of the current thread in the I<unsigned long> pointed to by I<addr>.
fr: Renvoie la base 64 bits pour le registre I<GS> du thread en cours dans la variable I<unsigned long> pointée par I<addr>.

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

note: type: Plain text
en: On success, B<arch_prctl>()  returns 0; on error, -1 is returned, and I<errno> is set to indicate the error.
fr: S'il réussit, B<arch_prctl>() renvoie zéro. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: I<addr> points to an unmapped address or is outside the process address space.
fr: I<addr> pointe vers une adresse non affectée ou est en dehors de l'espace d'adressage.

note: type: Plain text
en: I<code> is not a valid subcommand.
fr: I<code> n'est pas une sous\(hycommande valide.

note: .SH AUTHOR Man page written by Andi Kleen. type: Plain text
en: I<addr> is outside the process address space.
fr: I<addr> pointe en dehors de l'espace d'adressage du processus.

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

note: type: Plain text
en: B<arch_prctl>()  is a Linux/x86-64 extension and should not be used in programs intended to be portable.
fr: B<arch_prctl>() est une extension Linux/x86-64 et ne doit pas être employée dans un programme portable.

note: type: Plain text
en: B<arch_prctl>()  is only supported on Linux/x86-64 for 64-bit programs currently.
fr: B<arch_prctl>() n'est supporté sur Linux/x86-64 que pour les programmes 64 bits.

note: type: Plain text
en: The 64-bit base changes when a new 32-bit segment selector is loaded.
fr: La base 64 bits change lorsqu'un nouveau sélecteur de segment 32 bits est chargé.

note: type: Plain text
en: B<ARCH_SET_GS> is disabled in some kernels.
fr: B<ARCH_SET_GS> est inactif dans certains noyaux.

note: type: Plain text
en: Context switches for 64-bit segment bases are rather expensive.  It may be a faster alternative to set a 32-bit base using a segment selector by setting up an LDT with B<modify_ldt>(2)  or using the B<set_thread_area>(2)  system call in kernel 2.5 or later.  B<arch_prctl>()  is only needed when you want to set bases that are larger than 4GB.  Memory in the first 2GB of address space can be allocated by using B<mmap>(2)  with the B<MAP_32BIT> flag.
fr: Les changements de contexte pour les bases 64 bits sont assez coûteux. Il peut être plus rapide de fixer une base 32 bits avec un sélecteur de segment en fixant une LDT avec B<modify_ldt>(2) ou en utilisant l'appel système B<set_thread_area>(2) des noyaux 2.5 et suivants. B<arch_prctl>() n'est utile que si vous désirez fixer des bases plus grandes que 4\ Go. La mémoire dans les premiers 2\ Go d'adressage peut être allouée en utilisant B<mmap>(2) avec l'attribut B<MAP_32BIT>.

note: type: Plain text
en: As of version 2.7, glibc provides no prototype for B<arch_prctl>().  You have to declare it yourself for now.  This may be fixed in future glibc versions.
fr: Il n'y a pas de prototype pour B<arch_prctl>() dans la glibc 2.7. Vous devez le déclarer vous\(hymême. Ceci sera peut\(hyêtre corrigé dans les futures versions de la glibc.

note: type: Plain text
en: I<FS> may be already used by the threading library.
fr: I<FS> peut être déjà utilisé par la bibliothèque de multi\(hythreading.

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

note: type: Plain text
en: AMD X86-64 Programmer's manual
fr: Manuel du programmeur AMD X86-64

note: type: Plain text
en: This page is part of release 3.37 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.37 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse E<lt>URL:http://www.kernel.org/doc/man-pages/E<gt>.

note: type: TH
en: 2010-08-29
fr: 29 août 2010

note: type: Plain text
en: futex - Fast Userspace Locking system call
fr: futex - Mécanisme de verrouillage rapide en mode utilisateur

note: type: Plain text
en: The B<futex>()  system call provides a method for a program to wait for a value at a given address to change, and a method to wake up anyone waiting on a particular address (while the addresses for the same memory in separate processes may not be equal, the kernel maps them internally so the same memory mapped in different locations will correspond for B<futex>()  calls).  This system call is typically used to implement the contended case of a lock in shared memory, as described in B<futex>(7).
fr: L'appel système B<futex>() donne à un programme la possibilité d'attendre qu'une valeur à une adresse donnée change, ou de réveiller tous ceux qui sont en attente sur cette adresse. Bien que les adresses soient différentes dans des processus séparés, le noyau fera la correspondance lors de l'appel système. Cet appel système est typiquement employé pour implémenter les verrous en mémoire partagée, tels qu'ils sont décrits dans B<futex>(7).

note: type: Plain text
en: When a B<futex>(7)  operation did not finish uncontended in userspace, a call needs to be made to the kernel to arbitrate.  Arbitration can either mean putting the calling process to sleep or, conversely, waking a waiting process.
fr: Quand une opération B<futex>(7) ne se termine pas de manière satisfaisante dans l'espace utilisateur, un appel au noyau est nécessaire pour l'arbitrage. Ceci signifie soit endormir le processus appelant, soit réveiller le processus en attente.

note: type: Plain text
en: Callers of this function are expected to adhere to the semantics as set out in B<futex>(7).  As these semantics involve writing nonportable assembly instructions, this in turn probably means that most users will in fact be library authors and not general application developers.
fr: Les appelants de cette fonction doivent accepter les sémantiques décrites dans B<futex>(7). Comme celles\(hyci impliquent l'écriture d'instructions non portables en assembleur, leurs utilisateurs sont des auteurs de bibliothèques plus que des développeurs applicatifs.

note: type: Plain text
en: The I<uaddr> argument needs to point to an aligned integer which stores the counter.  The operation to execute is passed via the I<op> argument, along with a value I<val>.
fr: Le paramètre I<uaddr> doit pointer sur un entier aligné qui stocke le compteur. L'opération à exécuter est transmise dans le paramètre I<op>, avec la valeur I<val>.

note: type: Plain text
en: Five operations are currently defined:
fr: Cinq opérations sont définies pour le moment\ :

note: type: Plain text
en: This operation atomically verifies that the futex address I<uaddr> still contains the value I<val>, and sleeps awaiting B<FUTEX_WAKE> on this futex address.  If the I<timeout> argument is non-NULL, its contents describe the maximum duration of the wait, which is infinite otherwise.  The arguments I<uaddr2> and I<val3> are ignored.
fr: Cette opération vérifie que l'adresse du futex I<uaddr> contient toujours la valeur I<val> indiquée et s'endort en attendant un B<FUTEX_WAKE> à cette adresse. Les deux étapes sont liées atomiquement. Si l'argument I<timeout> est non nul, il contient la durée maximale de sommeil. Sinon, elle est infinie. Les arguments I<uaddr2> et I<val3> sont ignorés.

note: type: Plain text
en: For B<futex>(7), this call is executed if decrementing the count gave a negative value (indicating contention), and will sleep until another process releases the futex and executes the B<FUTEX_WAKE> operation.
fr: D'après B<futex>(7), cet appel est exécuté si la décrémentation du compteur donne une valeur négative (indiquant un conflit) et le sommeil durera jusqu'à ce qu'un autre processus relâche le futex et exécute B<FUTEX_WAKE>.

note: type: Plain text
en: This operation wakes at most I<val> processes waiting on this futex address (i.e., inside B<FUTEX_WAIT>).  The arguments I<timeout>, I<uaddr2> and I<val3> are ignored.
fr: Cette opération réveille au plus I<val> processus en attente sur l'adresse du futex (endormis dans B<FUTEX_WAIT>). Les arguments I<timeout>, I<uaddr2> et I<val3> sont ignorés.

note: type: Plain text
en: For B<futex>(7), this is executed if incrementing the count showed that there were waiters, once the futex value has been set to 1 (indicating that it is available).
fr: D'après B<futex>(7), ceci est exécuté si l'incrémentation du compteur montre qu'il y a des processus en attente, une fois que la valeur du futex a été mise à 1 (indiquant qu'il est disponible).

note: type: TP
en: B<FUTEX_FD> (present up to and including Linux 2.6.25)
fr: B<FUTEX_FD> (présent jusqu'à Linux 2.6.25 inclus)

note: , suitable for .BR poll (2). type: Plain text
en: To support asynchronous wakeups, this operation associates a file descriptor with a futex.  If another process executes a B<FUTEX_WAKE>, the process will receive the signal number that was passed in I<val>.  The calling process must close the returned file descriptor after use.  The arguments I<timeout>, I<uaddr2> and I<val3> are ignored.
fr: Pour permettre des réveils asynchrones, cette opération associe un descripteur de fichier avec un futex. Si un autre processus exécute un B<FUTEX_WAKE>, l'appelant recevra le signal dont le numéro a été indiqué dans I<val>. L'appelant doit refermer le descripteur de fichier après utilisation. Les arguments I<timeout>, I<uaddr2> et I<val3> sont ignorés.

note: type: Plain text
en: To prevent race conditions, the caller should test if the futex has been upped after B<FUTEX_FD> returns.
fr: Pour éviter les situations de concurrence, l'appelant doit tester si le futex a été libéré après le retour de B<FUTEX_FD>.

note: type: Plain text
en: Because it was inherently racy, B<FUTEX_FD> has been removed from Linux 2.6.26 onward.
fr: Parce qu'il était de façon inhérent sujet à des situations de concurrence, B<FUTEX_FD> a été supprimé de Linux 2.6.26 et les suivants.

note: type: TP
en: B<FUTEX_REQUEUE> (since Linux 2.5.70)
fr: B<FUTEX_REQUEUE> (depuis Linux 2.5.70)

note: type: Plain text
en: This operation was introduced in order to avoid a "thundering herd" effect when B<FUTEX_WAKE> is used and all processes woken up need to acquire another futex.  This call wakes up I<val> processes, and requeues all other waiters on the futex at address I<uaddr2>.  The arguments I<timeout> and I<val3> are ignored.
fr: Cette opération a été introduite dans le but d'éviter que trop de processus nécessitant un autre futex ne soient activés lors de l'utilisation de B<FUTEX_WAKE>. Cet appel réactive I<val> processus, et remet en file d'attente tous les autres qui attendaient le futex à l'adresse I<uaddr2>. Les arguments I<timeout> et I<val3> sont ignorés.

note: type: TP
en: B<FUTEX_CMP_REQUEUE> (since Linux 2.6.7)
fr: B<FUTEX_CMP_REQUEUE> (depuis Linux 2.6.7)

note: type: Plain text
en: There was a race in the intended use of B<FUTEX_REQUEUE>, so B<FUTEX_CMP_REQUEUE> was introduced.  This is similar to B<FUTEX_REQUEUE>, but first checks whether the location I<uaddr> still contains the value I<val3>.  If not, the operation fails with the error B<EAGAIN>.  The argument I<timeout> is ignored.
fr: Il y a un problème de concurrence dans l'utilisation prévue pour B<FUTEX_REQUEUE>, aussi B<FUTEX_CMP_REQUEUE> a été introduit. Cette opération est similaire à B<FUTEX_REQUEUE>, sauf qu'elle vérifie si l'adresse I<uaddr> contient encore la valeur I<val3>. Si non, l'opération échoue avec l' erreur B<EAGAIN>.L'argument I<timeout> est ignoré.

note: type: Plain text
en: Depending on which operation was executed, the returned value for a successful call can have differing meanings.
fr: Suivant l'opération exécutée, la valeur renvoyée en cas de succès peut avoir différentes significations.

note: type: Plain text
en: Returns 0 if the process was woken by a B<FUTEX_WAKE> call.  In case of timeout, the operation fails with the error B<ETIMEDOUT>.  If the futex was not equal to the expected value, the operation fails with the error B<EWOULDBLOCK>.  Signals (see B<signal>(7))  or other spurious wakeups cause B<FUTEX_WAIT> to fail with the error B<EINTR>.
fr: Renvoie 0 si le processus a été réveillé par un appel B<FUTEX_WAKE>. En cas  de dépassement de délai, l'opération échoue avec l'erreur B<ETIMEDOUT>. L'opération échoue avec l'erreur B<EWOULDBLOCK> si le futex n'avait pas la valeur attendue. L'arrivée d'un signal (consultez B<signal>(7)) ou un autre réveil intempestif peut causer l'échec d'un B<FUTEX_WAIT> avec l'erreur B<EINTR>.

note: type: Plain text
en: Returns the number of processes woken up.
fr: Renvoie le nombre de processus réveillés.

note: type: Plain text
en: Returns the new file descriptor associated with the futex.
fr: Renvoie le nouveau descripteur associé au futex.

note: type: Plain text
en: In the event of an error, all operations return -1, and set I<errno> to indicate the error.
fr: En cas d'erreur, toutes les opérations renvoient -1, et I<errno> contient le code d'erreur.

note: type: Plain text
en: No read access to futex memory.
fr: Pas d'accès en lecture à la mémoire futex.

note: type: Plain text
en: B<FUTEX_CMP_REQUEUE> found an unexpected futex value.  (This probably indicates a race; use the safe B<FUTEX_WAKE> now.)
fr: B<FUTEX_CMP_REQUEUE> a trouvé une valeur inattendue de futex. (Cela indique probablement une condition de concurrence\ ; utilisez maintenant B<FUTEX_WAKE>.)

note: type: Plain text
en: Error in getting I<timeout> information from userspace.
fr: Erreur lors de la récupération de l'information I<timeout> à partir de l'espace utilisateur.

note: type: Plain text
en: An operation was not defined or error in page alignment.
fr: Une opération n'a pas été définie ou il y a une erreur d'alignement de page.

note: type: Plain text
en: The system limit on the total number of open files has been reached.
fr: La limite du nombre total de fichiers ouverts sur le système a été atteinte.

note: type: Plain text
en: Invalid operation specified in I<op>.
fr: I<op> contient une opération non valable.

note: type: Plain text
en: Initial futex support was merged in Linux 2.5.7 but with different semantics from what was described above.  A 4-argument system call with the semantics described in this page was introduced in Linux 2.5.40.  In Linux 2.5.70 one argument was added.  In Linux 2.6.7 a sixth argument was added\(emmessy, especially on the s390 architecture.
fr: Le support initial des futex a été ajouté dans Linux 2.5.7 mais avec une sémantique différente de celle décrite ci\(hydessus. Un appel système à 4 paramètres avec la sémantique décrite dans cette page a été ajouté dans Linux 2.5.40. Dans Linux 2.5.70, un paramètre supplémentaire a été ajouté. Un sixième paramètre a été ajouté dans Linux 2.6.7 \(em compliqué, surtout sur l'architecture s390.

note: type: Plain text
en: This system call is Linux-specific.
fr: Cet appel système est spécifique à Linux.

note: .SH "AUTHORS" .PP Futexes were designed and worked on by Hubertus Franke (IBM Thomas J. Watson Research Center), Matthew Kirkwood, Ingo Molnar (Red Hat) and Rusty Russell (IBM Linux Technology Center). This page written by bert hubert. type: Plain text
en: To reiterate, bare futexes are not intended as an easy-to-use abstraction for end-users.  (There is no wrapper function for this system call in glibc.)  Implementors are expected to be assembly literate and to have read the sources of the futex userspace library referenced below.
fr: Répétons\(hyle, les futex de base ne sont pas conçus comme une abstraction facile à employer pour les utilisateurs (mais la glibc ne fournit pas de fonction autour de cet appel système). Les implémenteurs doivent maîtriser l'assembleur et avoir lu les sources de la bibliothèque en espace utilisateur décrite ci-dessous.

note: type: Plain text
en: I<Fuss, Futexes and Furwocks: Fast Userlevel Locking in Linux> (proceedings of the Ottawa Linux Symposium 2002), online at
fr: «\ Fuss, Futexes and Furwocks: Fast Userlevel Locking in Linux\ » (proceedings of the Ottawa Linux Symposium 2002), disponible en ligne à

note: type: Plain text
en: Futex example library, futex-*.tar.bz2 at
fr: La bibliothèque d'exemple de futex, futex-*.tar.bz2 à

note: type: TH
en: 2010-11-04
fr: 4 novembre 2010

note: type: Plain text
en: kexec_load - load a new kernel for later execution
fr: kexec_load - charger un nouveau noyau pour une exécution ultérieure

note: type: Plain text
en: The B<kexec_load>()  system call loads a new kernel that can be executed later by B<reboot>(2).
fr: L'appel système B<kexec_load>() charge un nouveau noyau qui peut être exécuté plus tard avec un B<reboot>(2).

note: type: Plain text
en: The I<flags> argument is a mask whose high-order bits control the operation of the call.  The following values can be specified in I<flags>:
fr: Le paramètre I<flags> est un masque dont les bits de poids fort contrôlent l'opération de l'appel. Les valeurs suivantes peuvent être spécifiées dans I<flags> :

note: type: TP
en: B<KEXEC_ON_CRASH> (since Linux 2.6.13)
fr: B<KEXEC_ON_CRASH> (depuis Linux 2.6.13)

note: FIXME figure out how this is really used type: Plain text
en: Execute the new kernel automatically on a system crash.
fr: Exécuter automatiquement le nouveau noyau en cas de crash système.

note: type: TP
en: B<KEXEC_PRESERVE_CONTEXT> (since Linux 2.7.27)
fr: B<KEXEC_PRESERVE_CONTEXT> (depuis Linux 2.7.27)

note: type: Plain text
en: Preserve the system hardware and software states before executing the new kernel.  This could be used for system suspend.  This flag is only available if the kernel was configured with B<CONFIG_KEXEC_JUMP>, and is only effective if I<nr_segments> is greater than 0.
fr: Préserver le matériel système et les états logiciels avant d'exécuter le nouveau noyau. Ceci pourrait être utilisé pour la mise en veille prolongée du système. Cet attribut n'est disponible que si le noyau a été configuré avec B<CONFIG_KEXEC_JUMP>, et n'est effectif que si I<nr_segments> est strictement positif.

note: type: Plain text
en: The low-order bits of I<flags> contain the architecture of the to-be-executed kernel.  Specify (OR) the constant B<KEXEC_ARCH_DEFAULT> to use the current architecture, or one of the following architecture constants B<KEXEC_ARCH_386>, B<KEXEC_ARCH_X86_64>, B<KEXEC_ARCH_PPC>, B<KEXEC_ARCH_PPC64>, B<KEXEC_ARCH_IA_64>, B<KEXEC_ARCH_ARM>, B<KEXEC_ARCH_S390>, B<KEXEC_ARCH_SH>, B<KEXEC_ARCH_MIPS>, and B<KEXEC_ARCH_MIPS_LE>.  The architecture must be executable on the CPU of the system.
fr: Les bits de poids faible de I<flags> contiennent l'architecture du noyau qui est en attente d'exécution. Indiquez la constante B<KEXEC_ARCH_DEFAULT> pour utiliser l'architecture actuelle, ou une ou plusieurs (en utilisant l'opérateur OU) des constantes d'architecture suivantes : B<KEXEC_ARCH_386>, B<KEXEC_ARCH_X86_64>, B<KEXEC_ARCH_PPC>, B<KEXEC_ARCH_PPC64>, B<KEXEC_ARCH_IA_64>, B<KEXEC_ARCH_ARM>, B<KEXEC_ARCH_S390>, B<KEXEC_ARCH_SH>, B<KEXEC_ARCH_MIPS> et B<KEXEC_ARCH_MIPS_LE>. L'architecture doit pouvoir être exécutée sur le processeur du système.

note: type: Plain text
en: The I<entry> argument is the physical entry address in the kernel image.  The I<nr_segments> argument is the number of segments pointed to by the I<segments> pointer.  The I<segments> argument is an array of I<kexec_segment> structures which define the kernel layout:
fr: Le paramètre I<entry> est l'adresse du point d'entrée physique dans l'image noyau. Le paramètre I<nr_segments> est le nombre de segments pointés par le pointeur I<segments>. Le paramètre I<segments> est un tableau de I<kexec_segment> structures qui définissent la disposition du noyau :

note: type: Plain text
en: struct kexec_segment {
        void   *buf;        /* Buffer in user space */
        size_t  bufsz;      /* Buffer length in user space */
        void   *mem;        /* Physical address of kernel */
        size_t  memsz;      /* Physical address length */
    };
fr: struct kexec_segment {
        void   *buf;        /* Tampon dans l'espace utilisateur */
        size_t  bufsz;      /* Taille du tampon */
        void   *mem;        /* Adresse physique du noyau */
        size_t  memsz;      /* Taille de l'adresse physique */
    };

note: FIXME elaborate on the following: type: Plain text
en: The kernel image defined by I<segments> is copied from the calling process into previously reserved memory.
fr: L'image noyau définie par I<segments> est copiée depuis le processus appelant dans la mémoire préalablement réservée.

note: type: Plain text
en: On success, B<kexec_load>()  returns 0.  On error, -1 is returned and I<errno> is set to indicate the error.
fr: S'il réussit, B<kexec_load>() renvoie zéro. En cas d'erreur, il renvoie -1 et remplit I<errno> avec la valeur d'erreur.

note: type: Plain text
en: Another crash kernel is already being loaded or a crash kernel is already in use.
fr: Un autre crash du noyau est déjà en train de charger, ou un crash du noyau est déjà utilisé.

note: KEXEC_SEGMENT_MAX == 16 type: Plain text
en: I<flags> is invalid; or I<nr_segments> is too large
fr: I<flags> est invalide, ou I<nr_segments> est trop grand

note: type: Plain text
en: The caller does not have the B<CAP_SYS_BOOT> capability.
fr: L'appelant n'a pas la capacité B<CAP_SYS_BOOT>.

note: type: Plain text
en: The B<kexec_load>()  system call first appeared in Linux 2.6.13.
fr: L'appel système B<kexec_load>() est apparu pour la première fois avec le noyau Linux 2.6.13.

note: type: Plain text
en: Currently, there is no glibc support for B<kexec_load>().  Call it using B<syscall>(2).
fr: Actuellement, il n'y a pas de prise en charge de B<kexec_load>() dans la glibc. Il faut l'appeler avec B<syscall>(2).

note: FIXME Andi submitted a patch for this. Check if it got accepted later. type: Plain text
en: The required constants are in the kernel source file I<linux/kexec.h>, which is not currently exported to glibc.  Therefore, these constants must be defined manually.
fr: Les constantes nécessaires sont définies dans le fichier source du noyau I<linux/kexec.h>, qui n'est actuellement pas exporté par la glibc. Ces constantes doivent donc être définies manuellement.

note: type: Plain text
en: This system call is only available if the kernel was configured with B<CONFIG_KEXEC>.
fr: Cet appel système n'est disponible que si le noyau a été configuré avec B<CONFIG_KEXEC>.

note: type: TH
en: 2004-06-17
fr: 17 juin 2004

note: type: Plain text
en: lookup_dcookie - return a directory entry's path
fr: lookup_dcookie - Renvoyer le chemin d'accès d'un élément de répertoire

note: type: Plain text
en: Look up the full path of the directory entry specified by the value I<cookie>.  The cookie is an opaque identifier uniquely identifying a particular directory entry.  The buffer given is filled in with the full path of the directory entry.
fr: Renvoie le chemin complet de l'élément de répertoire spécifié par la valeur I<cookie>. Le cookie est un identifiant opaque référençant de manière unique un élément de répertoire donné. Le tampon fourni est rempli avec le chemin d'accès complet de cet élément.

note: type: Plain text
en: For B<lookup_dcookie>()  to return successfully, the kernel must still hold a cookie reference to the directory entry.
fr: Pour que B<lookup_dcookie>() fonctionne, le noyau doit déjà connaître le I<cookie> référençant l'élément de répertoire.

note: type: Plain text
en: On success, B<lookup_dcookie>()  returns the length of the path string copied into the buffer.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, B<lookup_dcookie>() renvoie la longueur de la chaîne copiée dans le tampon. En cas d'erreur, il renvoie -1 et remplit I<errno> avec le code d'erreur.

note: type: Plain text
en: The buffer was not valid.
fr: Le tampon est invalide.

note: type: Plain text
en: The kernel has no registered cookie/directory entry mappings at the time of lookup, or the cookie does not refer to a valid directory entry.
fr: Le noyau n'a pas d'association cookie/élément de répertoire correspondant au cookie, ou le cookie ne fait pas référence à un élément valide.

note: type: Plain text
en: The name could not fit in the buffer.
fr: Le nom ne tient pas dans le tampon.

note: type: Plain text
en: The kernel could not allocate memory for the temporary buffer holding the path.
fr: Le noyau ne peut pas allouer assez de mémoire pour les tampons temporaires.

note: type: Plain text
en: The process does not have the capability B<CAP_SYS_ADMIN> required to look up cookie values.
fr: Le processus n'a pas la capacité B<CAP_SYS_ADMIN> nécessaire pour lire des valeurs de cookie.

note: type: Plain text
en: The buffer was not large enough to hold the path of the directory entry.
fr: Le tampon fourni n'est pas assez grand pour contenir le chemin d'accès.

note: type: Plain text
en: Available since Linux 2.5.43.  The B<ENAMETOOLONG> error return was added in 2.5.70.
fr: Disponible depuis Linux 2.5.43. L'erreur B<ENAMETOOLONG> a été ajoutée dans Linux 2.5.70.

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

note: type: Plain text
en: B<lookup_dcookie>()  is a special-purpose system call, currently used only by the oprofile profiler.  It relies on a kernel driver to register cookies for directory entries.
fr: B<lookup_dcookie>() est un appel système spécial, utilisé actuellement uniquement par le profiler oprofile. Il s'appuie sur un pilote du noyau pour enregistrer les cookies des éléments de répertoire.

note: type: Plain text
en: The path returned may be suffixed by the string " (deleted)" if the directory entry has been removed.
fr: Le chemin renvoyé peut avoir un suffixe «\ (deleted)\ » si l'élément de répertoire a été supprimé.

note: type: TH
en: 2007-06-01
fr: 1er juin 2007

note: type: Plain text
en: modify_ldt - get or set ldt
fr: modify_ldt - Lire/écrire la LDT

note: type: Plain text
en: B<modify_ldt>()  reads or writes the local descriptor table (ldt) for a process.  The ldt is a per-process memory management table used by the i386 processor.  For more information on this table, see an Intel 386 processor handbook.
fr: B<modify_ldt>() lit ou écrit la table des descripteurs locaux (Local Descriptor Table) du processus. La LDT est une table de gestion mémoire par processus utilisée par les processeurs i386. Pour plus d'informations sur cette table, se reporter au manuel Intel 386.

note: type: Plain text
en: When I<func> is 0, B<modify_ldt>()  reads the ldt into the memory pointed to by I<ptr>.  The number of bytes read is the smaller of I<bytecount> and the actual size of the ldt.
fr: Quand I<func> vaut 0, B<modify_ldt>() lit la LDT et la place dans la mémoire pointée par I<ptr>. Le nombre d'octets lus est le minimum entre I<bytecount> et la vraie taille de la LDT.

note: FIXME ? say something about func == 2 and func == 0x11? In Linux 2.4, func == 2 returned "the default ldt" In Linux 2.6, func == 2 is a nop, returning a zeroed out structure. Linux 2.4 and 2.6 implement an operation for func == 0x11 type: Plain text
en: When I<func> is 1, B<modify_ldt>()  modifies one ldt entry.  I<ptr> points to a I<user_desc> structure and I<bytecount> must equal the size of this structure.
fr: Quand I<func> vaut 1, B<modify_ldt>() modifie une entrée de la LDT. I<ptr> pointe sur une structure I<user_desc> et I<bytecount> doit être égal à la taille de cette structure.

note: type: Plain text
en: The I<user_desc> structure is defined in I<E<lt>asm/ldt.hE<gt>> as:
fr: La structure I<user_desc> est déclarée dans I<E<lt>asm/ldt.hE<gt>> comme suit\ :

note: .PP The ldt is specific for the calling process. Any attempts to change the ldt to include the address space of another process or the kernel will result in a segmentation violation when trying to access the memory outside of the process address space. The memory protection is enforced at the paging
en: In Linux 2.4 and earlier, this structure was named I<modify_ldt_ldt_s>.
fr: Sous Linux 2.4 et les versions précédentes, cette structure s'appelait I<modify_ldt_ldt_s>.

note: type: Plain text
en: On success, B<modify_ldt>()  returns either the actual number of bytes read (for reading)  or 0 (for writing).  On failure, B<modify_ldt>()  returns -1 and sets I<errno> to indicate the error.
fr: S'il réussit B<modify_ldt>() renvoie soit le nombre d'octets lus soit 0 (écriture). En cas d'échec -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<ptr> points outside the address space.
fr: I<ptr> pointe en dehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<ptr> is 0, or I<func> is 1 and I<bytecount> is not equal to the size of the structure I<modify_ldt_ldt_s>, or I<func> is 1 and the new ldt entry has invalid values.
fr: I<ptr> est nul, ou I<func> vaut 1 et I<bytecount> n'est pas égal à la taille de la structure I<modify_ldt_ldt_s>, ou I<func> vaut 1 et la nouvelle entrée de LDT a des valeurs illégales.

note: type: Plain text
en: I<func> is neither 0 nor 1.
fr: I<func> n'est ni 0 ni 1.

note: type: Plain text
en: This call is Linux-specific and should not be used in programs intended to be portable.
fr: Cet appel système est spécifique à Linux et ne doit pas être employé dans des programmes destinés à être portables.

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

note: type: TH
en: 2012-03-05
fr: 5 mars 2012

note: type: Plain text
en: nfsservctl - syscall interface to kernel nfs daemon
fr: nfsservctl - Appel système d'interface pour le démon NFS du noyau

note: type: Plain text
en: I<Note>: Since Linux 3.1, this system call no longer exists.
fr: I<Remarque> : depuis Linux 3.1, cet appel système n'existe plus.

note: type: Plain text
en: /*
     * These are the commands understood by nfsctl().
     */
    #define NFSCTL_SVC          0    /* This is a server process. */
    #define NFSCTL_ADDCLIENT    1    /* Add an NFS client. */
    #define NFSCTL_DELCLIENT    2    /* Remove an NFS client. */
    #define NFSCTL_EXPORT       3    /* export a file system. */
    #define NFSCTL_UNEXPORT     4    /* unexport a file system. */
    #define NFSCTL_UGIDUPDATE   5    /* update a client's UID/GID map. */
    #define NFSCTL_GETFH        6    /* get an fh (used by mountd) */
fr: /*
     * Voici les commandes comprises par nfsctl().
     */
    #define NFSCTL_SVC          0       /* Voici le processus serveur */
    #define NFSCTL_ADDCLIENT    1       /* Ajouter un client NFS      */
    #define NFSCTL_DELCLIENT    2       /* Supprimer un client NFS    */
    #define NFSCTL_EXPORT       3       /* Exporter un système de     */
                                        /* fichiers.                  */
    #define NFSCTL_UNEXPORT     4       /* Arrêter l'exportation d'un */
                                        /* système de fichiers.       */
    #define NFSCTL_UGIDUPDATE   5       /* Mise à jour de la table    */
                                        /* uid/gid du client.         */
    #define NFSCTL_GETFH        6       /* obtenir un fh (utilisé par */
                                        /* mountd).                   */

note: type: Plain text
en: struct nfsctl_arg {
        int                       ca_version;     /* safeguard */
        union {
            struct nfsctl_svc     u_svc;
            struct nfsctl_client  u_client;
            struct nfsctl_export  u_export;
            struct nfsctl_uidmap  u_umap;
            struct nfsctl_fhparm  u_getfh;
            unsigned int          u_debug;
        } u;
    }
fr: struct nfsctl_arg {
        int                       ca_version;     /* garde-fou */
        union {
            struct nfsctl_svc     u_svc;
            struct nfsctl_client  u_client;
            struct nfsctl_export  u_export;
            struct nfsctl_uidmap  u_umap;
            struct nfsctl_fhparm  u_getfh;
            unsigned int          u_debug;
        } u;
    }

note: type: Plain text
en: On success, zero is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: S'il réussit, cet appel système renvoie 0. S'il échoue, il renvoie -1 et remplit I<errno> en conséquence.

note: type: Plain text
en: This call is Linux-specific.
fr: Cet appel système est spécifique à Linux.

note: type: TH
en: 1995-11-29
fr: 29 novembre 1995

note: type: Plain text
en: outb, outw, outl, outsb, outsw, outsl, inb, inw, inl, insb, insw, insl, outb_p, outw_p, outl_p, inb_p, inw_p, inl_p - port I/O
fr: outb, outw, outl, outsb, outsw, outsl, inb, inw, inl, insb, insw, insl, outb_p, outw_p, outl_p, inb_p, inw_p, inl_p - Lire/Écrire sur un port

note: type: Plain text
en: This family of functions is used to do low-level port input and output.  The out* functions do port output, the in* functions do port input; the b-suffix functions are byte-width and the w-suffix functions word-width; the _p-suffix functions pause until the I/O completes.
fr: Cette famille de fonctions est utilisée pour des entrées-sorties de bas niveau. Les fonctions out* effectuent une écriture sur un port alors que les fonctions in* effectuent une lecture. Les fonctions suffixées avec «\ b\ » travaillent sur des octets alors que les fonctions suffixées avec «\ w\ » travaillent sur des mots. Les fonctions suffixées avec «\ _p\ » attendent que les entrées-sorties soient achevées.

note: , given the following information in addition to that given in .BR outb (9). type: Plain text
en: They are primarily designed for internal kernel use, but can be used from user space.
fr: Elles ont principalement été conçues pour un usage interne au noyau, mais sont quand même utilisables avec des processus utilisateurs.

note: type: Plain text
en: You compile with B<-O> or B<-O2> or similar.  The functions are defined as inline macros, and will not be substituted in without optimization enabled, causing unresolved references at link time.
fr: Compiler le programme avec les options B<-O> ou B<-O2> ou équivalent. Ces fonctions sont en réalité des macros développées en ligne, et ne seront pas substituées sans valider l'optimisation. Ceci causerait des erreurs de références non résolues au moment de l'édition des liens.

note: type: Plain text
en: You use B<ioperm>(2)  or alternatively B<iopl>(2)  to tell the kernel to allow the user space application to access the I/O ports in question.  Failure to do this will cause the application to receive a segmentation fault.
fr: Utiliser B<ioperm>(2) ou éventuellement B<iopl>(2) pour demander au noyau d'autoriser l'application à accéder aux ports d'entrées-sorties en question. Une omission de cette étape déclencherait une faute de segmentation.

note: type: Plain text
en: B<outb>()  and friends are hardware-specific.  The I<value> argument is passed first and the I<port> argument is passed second, which is the opposite order from most DOS implementations.
fr: B<outb>() et les autres fonctions dépendent du matériel. Les arguments I<port> et I<value> sont dans l'ordre inverse de la plupart des implémentations équivalentes sous DOS.

note: type: TH
en: 2003-07-14
fr: 14 juillet 2003

note: type: Plain text
en: pciconfig_read, pciconfig_write, pciconfig_iobase - pci device information handling
fr: pciconfig_read, pciconfig_write, pciconfig_iobase - Gestion d'information des périphériques pci

note: type: Plain text
en: Most of the interaction with PCI devices is already handled by the kernel PCI layer, and thus these calls should not normally need to be accessed from userspace.
fr: La plupart des interactions avec les périphériques PCI est déjà gérée par la couche PCI du noyau, aussi il ne devrait pas être nécessaire d'accéder à ces appels à partir de l'espace utilisateur.

note: type: Plain text
en: Reads to I<buf> from device I<dev> at offset I<off> value.
fr: Lit dans I<buf> à partir du périphérique I<dev> à l'offset I<off>.

note: type: Plain text
en: Writes from I<buf> to device I<dev> at offset I<off> value.
fr: Écrit à partir de I<buf> vers le périphérique I<dev> à l'offset I<off>.

note: type: Plain text
en: You pass it a bus/devfn pair and get a physical address for either the memory offset (for things like prep, this is 0xc0000000), the IO base for PIO cycles, or the ISA holes if any.
fr: Vous lui passez une paire «\ bus/devfn\ » et vous récupérez une adresse physique pour chacun des offset mémoire (pour des choses comme prep, c'est 0xc0000000), l'adresse d'entrée-sortie (IO) de base pour les cycles PIO ou bien les trous ISA s'il y en a.

note: type: Plain text
en: On success zero is returned.  On error, -1 is returned and I<errno> is set appropriately.
fr: En cas de réussite, zéro est renvoyé, sinon -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: Returns information on locations of various I/O regions in physical memory according to the I<which> value.  Values for I<which> are: B<IOBASE_BRIDGE_NUMBER>, B<IOBASE_MEMORY>, B<IOBASE_IO>, B<IOBASE_ISA_IO>, B<IOBASE_ISA_MEM>.
fr: Renvoie l'information de localisation de diverses régions d'entrées-sorties dans la mémoire physique en fonction de la valeur de I<which>. Les valeurs possibles pour I<which> sont\ : B<IOBASE_BRIDGE_NUMBER>, B<IOBASE_MEMORY>, B<IOBASE_IO>, B<IOBASE_ISA_IO>, B<IOBASE_ISA_MEM>.

note: type: Plain text
en: I<len> value is invalid.  This does not apply to B<pciconfig_iobase>().
fr: La valeur de I<len> n'est pas valide. Ceci ne s'applique pas à B<pciconfig_iobase>().

note: type: Plain text
en: I/O error.
fr: Erreur d'entrée-sortie.

note: type: Plain text
en: For B<pciconfig_iobase>(), "hose" value is NULL.  For the other calls, could not find a slot.
fr: Pour B<pciconfig_iobase>(), la valeur basse (« hose value ») est NULL. Pour les autres appels, ne peut pas trouver une entrée.

note: type: Plain text
en: The system has not implemented these calls (B<CONFIG_PCI> not defined).
fr: Le système n'a pas implémenté ces appels (B<CONFIG_PCI> n'est pas défini).

note: type: Plain text
en: This return value is only valid for B<pciconfig_iobase>().  It is returned if the value for I<which> is invalid.
fr: Cette valeur de retour est valide seulement pour B<pciconfig_iobase>(). Elle correspond au cas où I<which> est invalide.

note: type: Plain text
en: User does not have the B<CAP_SYS_ADMIN> capability.  This does not apply to B<pciconfig_iobase>().
fr: L'utilisateur n'a pas la capacité B<CAP_SYS_ADMIN>. Ceci ne s'applique pas à B<pciconfig_iobase>().

note: type: Plain text
en: These calls are Linux-specific, available since Linux 2.0.26/2.1.11.
fr: Ces appels sont spécifiques à Linux, disponibles à partir des versions Linux 2.0.26/2.1.11.

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

note: type: Plain text
en: personality - set the process execution domain
fr: personality - Indiquer le domaine d'exécution du processus

note: type: Plain text
en: Linux supports different execution domains, or personalities, for each process.  Among other things, execution domains tell Linux how to map signal numbers into signal actions.  The execution domain system allows Linux to provide limited support for binaries compiled under other UNIX-like operating systems.
fr: Linux propose différents domaines d'exécution, ou personnalités, pour chaque processus. Entre autres choses, le domaine d'exécution indique au noyau la manière de convertir les numéros de signaux en actions. Le domaine d'exécution permet à Linux d'offrir un support (limité) à des fichiers binaires compilés sous d'autres systèmes d'exploitation compatibles UNIX.

note: type: Plain text
en: This function will return the current B<personality>()  when I<persona> equals 0xffffffff.  Otherwise, it will make the execution domain referenced by I<persona> the new execution domain of the calling process.
fr: Cette fonction renvoie le domaine d'exécution en cours si B<persona> vaut 0xFFFFFFFF. Sinon, B<personality>() va utiliser le domaine d'exécution référencé par la valeur I<persona> comme domaine d'exécution du processus appelant.

note: type: Plain text
en: On success, the previous I<persona> is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: Renvoie l'ancienne valeur I<persona> s'il réussit, ou -1 s'il échoue, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: The kernel was unable to change the personality.
fr: Le noyau n'a pas pu changer la personnalité.

note: type: Plain text
en: B<personality>()  is Linux-specific and should not be used in programs intended to be portable.
fr: B<personality>() est spécifique à Linux, et ne devrait pas être utilisé dans des programmes destinés à être portables.

note: type: Plain text
en: pivot_root - change the root file system
fr: pivot_root - Modifier la racine du système de fichiers

note: The .B CAP_SYS_ADMIN capability is required. type: Plain text
en: B<pivot_root>()  moves the root file system of the calling process to the directory I<put_old> and makes I<new_root> the new root file system of the calling process.
fr: B<pivot_root>() déplace la racine du système de fichiers pour le processus appelant vers le répertoire I<put_old> et fait de I<new_root> la nouvelle racine du système de fichiers pour le processus appelant.

note: type: Plain text
en: The typical use of B<pivot_root>()  is during system startup, when the system mounts a temporary root file system (e.g., an B<initrd>), then mounts the real root file system, and eventually turns the latter into the current root of all relevant processes or threads.
fr: L'utilisation typique de B<pivot_root>() est durant le boot, lorsque le système monte un système de fichiers temporaire (par exemple un B<initrd>) puis monte le véritable système de fichiers, et le transforme en racine pour tous les processus et threads concernés.

note: type: Plain text
en: B<pivot_root>()  may or may not change the current root and the current working directory of any processes or threads which use the old root directory.  The caller of B<pivot_root>()  must ensure that processes with root or current working directory at the old root operate correctly in either case.  An easy way to ensure this is to change their root and current working directory to I<new_root> before invoking B<pivot_root>().
fr: B<pivot_root>() peut changer ou non les répertoires racine et de travail en cours de tous les processus et threads qui utilisaient l'ancien répertoire racine. L'appelant de B<pivot_root>() doit s'assurer que les processus ayant pour racine ou répertoire de travail l'ancien répertoire se comportent correctement. Le meilleur moyen est de modifier leur répertoire de travail et répertoire racine pour I<new_root> avant d'invoquer B<pivot_root>().

note: type: Plain text
en: The paragraph above is intentionally vague because the implementation of B<pivot_root>()  may change in the future.  At the time of writing, B<pivot_root>()  changes root and current working directory of each process or thread to I<new_root> if they point to the old root directory.  This is necessary in order to prevent kernel threads from keeping the old root directory busy with their root and current working directory, even if they never access the file system in any way.  In the future, there may be a mechanism for kernel threads to explicitly relinquish any access to the file system, such that this fairly intrusive mechanism can be removed from B<pivot_root>().
fr: Le paragraphe ci-dessus est intentionnellement flou, car l'implémentation de B<pivot_root>() peut changer dans le futur. Actuellement, B<pivot_root>() modifie la racine et le répertoire de travail de tous les processus ou threads en I<new_root> s'ils pointent sur l'ancien répertoire. Ceci est nécessaire pour éviter que des threads du noyau ne conservent l'ancien répertoire occupé, même s'ils accèdent au nouveau système de fichiers. Dans le futur, il y aura peut-être un mécanisme pour les threads du noyau pour renoncer explicitement à tout accès au système de fichiers, ce qui évitera ce mécanisme un peu invasif.

note: type: Plain text
en: Note that this also applies to the calling process: B<pivot_root>()  may or may not affect its current working directory.  It is therefore recommended to call B<chdir("/")> immediately after B<pivot_root>().
fr: Notez que ceci s'applique aussi au processus appelant\ : B<pivot_root>() peut changer ou non son répertoire de travail. Il vaut mieux donc appeler B<chdir("/")> immédiatement après B<pivot_root>().

note: type: Plain text
en: The following restrictions apply to I<new_root> and I<put_old>:
fr: Les restrictions suivantes s'appliquent à I<new_root> et I<put_old>\ :

note: type: Plain text
en: They must be directories.
fr: Ils doivent être des répertoires,

note: type: Plain text
en: I<new_root> and I<put_old> must not be on the same file system as the current root.
fr: I<new_root> et I<put_old> ne doivent pas être sur le même système de fichiers que la racine actuelle.

note: type: Plain text
en: I<put_old> must be underneath I<new_root>, that is, adding a nonzero number of I</..> to the string pointed to by I<put_old> must yield the same directory as I<new_root>.
fr: I<put_old> doit être un descendant de I<new_root>\ : ajouter un nombre non-nul de I</..> à la chaîne I<put_old> doit ramener au même répertoire que I<new_root>.

note: type: Plain text
en: No other file system may be mounted on I<put_old>.
fr: Aucun système de fichiers ne doit être monté sur I<put_old>.

note: type: Plain text
en: See also B<pivot_root>(8)  for additional usage examples.
fr: Consultez B<pivot_root>(8) pour des exemples d'utilisation supplémentaires.

note: type: Plain text
en: If the current root is not a mount point (e.g., after B<chroot>(2)  or B<pivot_root>(), see also below), not the old root directory, but the mount point of that file system is mounted on I<put_old>.
fr: Si la racine en cours n'est pas un point de montage (après un B<chroot>(2) ou un B<pivot_root>(), voir plus bas), ce n'est pas l'ancien répertoire, mais le point de montage du système de fichiers qui est monté dans I<put_old>.

note: type: Plain text
en: I<new_root> does not have to be a mount point.  In this case, I</proc/mounts> will show the mount point of the file system containing I<new_root> as root (I</>).
fr: I<new_root> n'a pas besoin d'être un point de montage. Dans ce cas, I</proc/mounts> montrera le point de montage concernant I<new_root> comme racine (I</>).

note: type: Plain text
en: B<pivot_root>()  may return (in I<errno>) any of the errors returned by B<stat>(2).  Additionally, it may return:
fr: B<pivot_root>() peut renvoyer (dans I<errno>) toute erreur renvoyée par B<stat>(2). De plus, il peut renvoyer\ :

note: type: Plain text
en: I<new_root> or I<put_old> are on the current root file system, or a file system is already mounted on I<put_old>.
fr: I<new_root> ou I<put_old> sont sur le système de fichiers principal actuel, ou un système de fichiers est déjà monté sur I<put_old>.

note: type: Plain text
en: I<put_old> is not underneath I<new_root>.
fr: I<put_old> n'est pas un descendant de I<new_root>.

note: type: Plain text
en: I<new_root> or I<put_old> is not a directory.
fr: I<new_root> ou I<put_old> n'est pas un répertoire.

note: type: Plain text
en: The calling process does not have the B<CAP_SYS_ADMIN> capability.
fr: Le processus appelant n'a pas la capacité B<CAP_SYS_ADMIN>.

note: type: Plain text
en: B<pivot_root>()  was introduced in Linux 2.3.41.
fr: B<pivot_root>() a été introduit dans Linux 2.3.41.

note: type: Plain text
en: B<pivot_root>()  is Linux-specific and hence is not portable.
fr: B<pivot_root>() est spécifique à Linux et donc non portable.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: B<pivot_root>()  should not have to change root and current working directory of all other processes in the system.
fr: B<pivot_root>() ne devrait pas modifier le répertoire racine et le répertoire de travail des autres processus du système.

note: type: Plain text
en: Some of the more obscure uses of B<pivot_root>()  may quickly lead to insanity.
fr: Les utilisations les plus obscures de B<pivot_root>() peuvent rapidement rendre fou.

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

note: type: Plain text
en: ptrace - process trace
fr: ptrace - Suivre un processus

note: type: Plain text
en: The B<ptrace>()  system call provides a means by which one process (the "tracer")  may observe and control the execution of another process (the "tracee"), and examine and change the tracee's memory and registers.  It is primarily used to implement breakpoint debugging and system call tracing.
fr: L'appel système B<ptrace>() fournit à un processus (l'« observateur ») un moyen d'observer et contrôler l'exécution d'un autre processus (l'« observé ») et d'examiner et éditer la mémoire et les registres de l'observé. L'utilisation principale de cette fonction est l'implémentation de points d'arrêt pour le débogage, et pour suivre les appels système.

note: type: Plain text
en: A tracee first needs to be attached to the tracer.  Attachment and subsequent commands are per thread: in a multithreaded process, every thread can be individually attached to a (potentially different) tracer, or left not attached and thus not debugged.  Therefore, "tracee" always means "(one) thread", never "a (possibly multithreaded) process".  Ptrace commands are always sent to a specific tracee using a call of the form
fr: Un observé doit d'abord être attaché à l'observateur. L'attachement et les commandes suivantes sont par thread : dans un processus multithreadé, chaque thread peut être attaché individuellement à un observateur (éventuellement différent), ou être laissé détaché et donc non débogué. Par conséquent, l'« observé » signifie toujours « (un) thread », jamais « un processus (éventuellement multithreadé) ». Les commandes ptrace sont toujours envoyées à un observé spécifique en utilisant un appel de la forme

note: type: Plain text
en:     ptrace(PTRACE_foo, pid, ...)
fr:     ptrace(PTRACE_truc, pid, ...)

note: type: Plain text
en: where I<pid> is the thread ID of the corresponding Linux thread.
fr: où I<pid> est l'identifiant de thread du thread Linux correspondant.

note: type: Plain text
en: (Note that in this page, a "multithreaded process" means a thread group consisting of threads created using the B<clone>(2)  B<CLONE_THREAD> flag.)
fr: (Remarquez que dans cette page, un « processus multithreadé » signifie un groupe de threads constitué de threads créés en utilisant l'attribut B<CLONE_THREAD> de B<clone>(2).)

note: type: Plain text
en: A process can initiate a trace by calling B<fork>(2)  and having the resulting child do a B<PTRACE_TRACEME>, followed (typically) by an B<execve>(2).  Alternatively, one process may commence tracing another process using B<PTRACE_ATTACH>.
fr: Un processus peut démarrer un suivi en appelant B<fork>(2) et faire en sorte que le fils créé fasse un B<PTRACE_TRACEME>, suivi (en général) par un B<execve>(2). Autrement, un processus peut commencer à suivre un autre processus en utilisant B<PTRACE_ATTACH>.

note: type: Plain text
en: While being traced, the tracee will stop each time a signal is delivered, even if the signal is being ignored.  (An exception is B<SIGKILL>, which has its usual effect.)  The tracer will be notified at its next call to B<waitpid>(2)  (or one of the related "wait" system calls); that call will return a I<status> value containing information that indicates the cause of the stop in the tracee.  While the tracee is stopped, the tracer can use various ptrace requests to inspect and modify the tracee.  The tracer then causes the tracee to continue, optionally ignoring the delivered signal (or even delivering a different signal instead).
fr: L'observé s'arrêtera à chaque fois qu'un signal lui sera distribué, même si le signal est ignoré (à l'exception de B<SIGKILL> qui a les effets habituels). L'observateur sera prévenu à son prochain appel de B<waitpid>(2) (ou un des appels système liés à « wait ») ; cet appel renverra une valeur I<status> contenant les renseignements indiquant la raison de l'arrêt de l'observé. Lorsque l'observé est arrêté, l'observateur peut utiliser plusieurs requêtes ptrace pour inspecter et modifier l'observé. L'observateur peut également laisser continuer l'exécution de l'observé, en ignorant éventuellement le signal ayant déclenché l'arrêt, ou même en envoyant un autre signal.

note: type: Plain text
en: When the tracer is finished tracing, it can cause the tracee to continue executing in a normal, untraced mode via B<PTRACE_DETACH>.
fr: Quand l'observateur a fini le suivi, il peut forcer l'observé à continuer normalement, en mode non suivi, avec B<PTRACE_DETACH>.

note: type: Plain text
en: The value of I<request> determines the action to be performed:
fr: La valeur de l'argument I<request> indique précisément l'action à entreprendre.

note: type: Plain text
en: Indicate that this process is to be traced by its parent.  Any signal (except B<SIGKILL>)  delivered to this process will cause it to stop and its parent to be notified via B<waitpid>(2).  In addition, all subsequent calls to B<execve>(2)  by the traced process will cause a B<SIGTRAP> to be sent to it, giving the parent a chance to gain control before the new program begins execution.  A process probably shouldn't make this request if its parent isn't expecting to trace it.  (I<pid>, I<addr>, and I<data> are ignored.)
fr: Le processus en cours va être suivi par son père. Tout signal (sauf B<SIGKILL>) reçu par le processus l'arrêtera, et le père sera avisé grâce à B<waitpid>(2). De plus, les appels ultérieurs à B<execve>(2) par le processus suivi lui enverront B<SIGTRAP>, ce qui permet au père de reprendre le contrôle avant que le nouveau programme continue son exécution. Un processus ne doit pas envoyer cette requête si son père n'est pas prêt à le suivre. Dans cette requête I<pid>, I<addr>, et I<data> sont ignorés.

note: type: Plain text
en: The B<PTRACE_TRACEME> request is used only by the tracee; the remaining requests are used only by the tracer.  In the following requests, I<pid> specifies the thread ID of the tracee to be acted on.  For requests other than B<PTRACE_KILL>, the tracee must be stopped.
fr: La requête B<PTRACE_TRACEME> ne sert qu'à l'observé. Les requêtes restantes ne servent qu'à l'observateur. Par la suite, I<pid> précise l'identifiant de thread de l'observé sur lequel agir. Pour les requêtes différentes de B<PTRACE_KILL>, l'observé doit être arrêté.

note: type: Plain text
en: Read a word at the address I<addr> in the tracee's memory, returning the word as the result of the B<ptrace>()  call.  Linux does not have separate text and data address spaces, so these two requests are currently equivalent.  (I<data> is ignored.)
fr: Lire un mot à l'adresse I<addr> dans l'espace mémoire de l'observé et le renvoyer en résultat de l'appel B<ptrace>(). Linux ne sépare pas les espaces d'adressage de code et de données, donc ces deux requêtes sont équivalentes (I<data> est ignoré).

note: PTRACE_PEEKUSR in kernel source, but glibc uses PTRACE_PEEKUSER, and that is the name that seems common on other systems. type: Plain text
en: Read a word at offset I<addr> in the tracee's USER area, which holds the registers and other information about the process (see I<E<lt>sys/user.hE<gt>>).  The word is returned as the result of the B<ptrace>()  call.  Typically, the offset must be word-aligned, though this might vary by architecture.  See NOTES.  (I<data> is ignored.)
fr: Lire un mot à l'adresse I<addr> dans l'espace USER de l'observé, qui contient les registres et divers renseignements sur le processus (voir I<E<lt>sys/user.hE<gt>>). La valeur est renvoyée en résultat de B<ptrace>(). En principe, l'adresse doit être alignée sur une frontière de mots, bien que cela varie selon les architectures. Consultez la section B<NOTES> (I<data> est ignoré).

note: type: Plain text
en: Copy the word I<data> to the address I<addr> in the tracee's memory.  As for B<PTRACE_PEEKTEXT> and B<PTRACE_PEEKDATA>, these two requests are currently equivalent.
fr: Copier un mot depuis l'adresse I<data> de la mémoire de l'observateur vers l'adresse I<addr> de la mémoire de l'observé. Comme pour B<PTRACE_PEEKTEXT> et B<PTRACE_PEEKDATA>, ces deux requêtes sont équivalentes.

note: PTRACE_POKEUSR in kernel source, but glibc uses PTRACE_POKEUSER, and that is the name that seems common on other systems. FIXME In the preceding sentence, which modifications are disallowed, and when they are disallowed, how does userspace discover that fact? type: Plain text
en: Copy the word I<data> to offset I<addr> in the tracee's USER area.  As for B<PTRACE_PEEKUSER>, the offset must typically be word-aligned.  In order to maintain the integrity of the kernel, some modifications to the USER area are disallowed.
fr: Copier un mot depuis l'emplacement I<data> de la mémoire de l'observateur vers l'emplacement I<addr> dans l'espace USER de l'observé. Comme pour B<PTRACE_PEEKUSER>, les emplacements doivent être alignés sur une frontière de mot. Pour maintenir l'intégrité du noyau, certaines modifications de la zone USER sont interdites.

note: type: Plain text
en: Copy the tracee's general-purpose or floating-point registers, respectively, to the address I<data> in the tracer.  See I<E<lt>sys/user.hE<gt>> for information on the format of this data.  (I<addr> is ignored.)
fr: Copier les registres généraux ou du processeur en virgule flottante de l'observé, vers l'adresse I<data> de l'observateur. Consultez I<E<lt>sys/user.hE<gt>> pour les détails sur le format des données (I<addr> est ignoré).

note: type: TP
en: B<PTRACE_GETSIGINFO> (since Linux 2.3.99-pre6)
fr: B<PTRACE_GETSIGINFO> (depuis Linux 2.3.99-pre6)

note: type: Plain text
en: Retrieve information about the signal that caused the stop.  Copy a I<siginfo_t> structure (see B<sigaction>(2))  from the tracee to the address I<data> in the tracer.  (I<addr> is ignored.)
fr: Récupérer des renseignements sur le signal qui a provoqué l'arrêt. Pour ce faire, copier une structure I<siginfo_t> (consultez B<sigaction>(2)) de l'observé à l'adresse I<data> de l'observateur (I<addr> est ignoré).

note: FIXME In the preceding sentence, which modifications are disallowed, and when they are disallowed, how does userspace discover that fact? type: Plain text
en: Copy the tracee's general-purpose or floating-point registers, respectively, from the address I<data> in the tracer.  As for B<PTRACE_POKEUSER>, some general-purpose register modifications may be disallowed.  (I<addr> is ignored.)
fr: Remplir les registres généraux ou du processeur en virgule flottante de l'observé, à partir du contenu de l'adresse I<data> de l'observateur. Comme pour B<PTRACE_POKEUSER> certaines modifications sont interdites (I<addr> est ignoré).

note: type: TP
en: B<PTRACE_SETSIGINFO> (since Linux 2.3.99-pre6)
fr: B<PTRACE_SETSIGINFO> (depuis Linux 2.3.99-pre6)

note: type: Plain text
en: Set signal information: copy a I<siginfo_t> structure from the address I<data> in the tracer to the tracee.  This will affect only signals that would normally be delivered to the tracee and were caught by the tracer.  It may be difficult to tell these normal signals from synthetic signals generated by B<ptrace>()  itself.  (I<addr> is ignored.)
fr: Définir les renseignements de signaux : copier une structure I<siginfo_t> de l'adresse I<data> de l'observateur vers l'observé. Cela n'affecte que les signaux qui auraient dû être distribués à l'observé et ont été interceptés à cause de B<ptrace>(). Différencier ces signaux normaux des signaux créés par B<ptrace>() lui-même peut être délicat (I<addr> est ignoré).

note: type: TP
en: B<PTRACE_SETOPTIONS> (since Linux 2.4.6; see BUGS for caveats)
fr: B<PTRACE_SETOPTIONS> (depuis Linux 2.4.6, consultez les remarques de B<BOGUES>)

note: type: Plain text
en: Set ptrace options from I<data>.  (I<addr> is ignored.)  I<data> is interpreted as a bit mask of options, which are specified by the following flags:
fr: Définir les options de ptrace à partir de l'adresse I<data> (I<addr> est ignoré). I<data> est interprété comme un masque d'options, qui est construit à partir des attributs suivants.

note: type: TP
en: B<PTRACE_O_TRACESYSGOOD> (since Linux 2.4.6)
fr: B<PTRACE_O_TRACESYSGOOD> (depuis Linux 2.4.6)

note: type: Plain text
en: When delivering system call traps, set bit 7 in the signal number (i.e., deliver I<SIGTRAP|0x80>).  This makes it easy for the tracer to distinguish normal traps from those caused by a system call.  (B<PTRACE_O_TRACESYSGOOD> may not work on all architectures.)
fr: Lors des interceptions d'appel système, mettre à 1 le bit 7 du numéro de signal (envoyer I<SIGTRAP\ |\ 0x80>). Cela permet au processus utilisant B<ptrace>() de faire la différence entre les interceptions normales et celles provoquées par un appel système. B<PTRACE_O_TRACESYSGOOD> peut ne pas fonctionner sur toutes les architectures.

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

note: type: Plain text
en: Stop the tracee at the next B<fork>(2)  and automatically start tracing the newly forked process, which will start with a B<SIGSTOP>.  A B<waitpid>(2)  by the tracer will return a I<status> value such that
fr: Arrêter l'observé au prochain B<fork>(2) et commencer automatiquement à suivre le nouveau processus créé, qui démarrera avec un signal B<SIGSTOP>. Un B<waitpid>(2) par l'observateur renverra une valeur I<status> comme

note: type: Plain text
en: The PID of the new process can be retrieved with B<PTRACE_GETEVENTMSG>.
fr: Le PID du nouveau processus peut être récupéré avec B<PTRACE_GETEVENTMSG>.

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

note: type: Plain text
en: Stop the tracee at the next B<vfork>(2)  and automatically start tracing the newly vforked process, which will start with a B<SIGSTOP>.  A B<waitpid>(2)  by the tracer will return a I<status> value such that
fr: Arrêter l'observé au prochain B<vfork>(2) et commencer automatiquement à suivre le nouveau processus créé, qui démarrera avec un signal B<SIGSTOP>. Un B<waitpid>(2) par l'observateur renverra une valeur I<status> comme

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

note: type: Plain text
en: Stop the tracee at the next B<clone>(2)  and automatically start tracing the newly cloned process, which will start with a B<SIGSTOP>.  A B<waitpid>(2)  by the tracer will return a I<status> value such that
fr: Arrêter l'observé au prochain B<clone>(2) et commencer automatiquement à suivre le nouveau processus cloné, qui démarrera avec un signal B<SIGSTOP>. Un B<waitpid>(2) par l'observateur renverra une valeur I<status> comme

note: type: Plain text
en: This option may not catch B<clone>(2)  calls in all cases.  If the tracee calls B<clone>(2)  with the B<CLONE_VFORK> flag, B<PTRACE_EVENT_VFORK> will be delivered instead if B<PTRACE_O_TRACEVFORK> is set; otherwise if the tracee calls B<clone>(2)  with the exit signal set to B<SIGCHLD>, B<PTRACE_EVENT_FORK> will be delivered if B<PTRACE_O_TRACEFORK> is set.
fr: Cette option peut ne pas intercepter tous les appels B<clone>(2). Si l'observé appelle B<clone>(2) avec l'attribut B<CLONE_VFORK>, B<PTRACE_EVENT_VFORK> sera envoyé si B<PTRACE_O_TRACEVFORK> est utilisé. Sinon, si l'observé appelle B<clone>(2) avec B<SIGCHLD> comme signal de terminaison, B<PTRACE_EVENT_FORK> sera envoyé si B<PTRACE_O_TRACEFORK> est utilisé.

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

note: type: Plain text
en: Stop the tracee at the next B<execve>(2).  A B<waitpid>(2)  by the tracer will return a I<status> value such that
fr: Arrêter l'observé au prochain B<execve>(2). Un B<waitpid>(2) par l'observateur renverra une valeur I<status> comme

note: type: TP
en: B<PTRACE_O_TRACEVFORKDONE> (since Linux 2.5.60)
fr: B<PTRACE_O_TRACEVFORKDONE> (depuis Linux 2.5.60)

note: type: Plain text
en: Stop the tracee at the completion of the next B<vfork>(2).  A B<waitpid>(2)  by the tracer will return a I<status> value such that
fr: Arrêter l'observé à la fin du prochain B<vfork>(2). Un B<waitpid>(2) par l'observateur renverra une valeur I<status> comme

note: type: Plain text
en: The PID of the new process can (since Linux 2.6.18) be retrieved with B<PTRACE_GETEVENTMSG>.
fr: Le PID du nouveau processus peut (depuis Linux 2.6.18) être récupéré avec B<PTRACE_GETEVENTMSG>.

note: type: TP
en: B<PTRACE_O_TRACEEXIT> (since Linux 2.5.60)
fr: B<PTRACE_O_TRACEEXIT> (depuis Linux 2.5.60)

note: type: Plain text
en: Stop the tracee at exit.  A B<waitpid>(2)  by the tracer will return a I<status> value such that
fr: Arrêter l'observé à la terminaison. Un B<waitpid>(2) par l'observateur renverra une valeur I<status> comme

note: type: Plain text
en: The tracee's exit status can be retrieved with B<PTRACE_GETEVENTMSG>.
fr: L'état de fin de l'observé peut être récupéré avec B<PTRACE_GETEVENTMSG>.

note: type: Plain text
en: The tracee is stopped early during process exit, when registers are still available, allowing the tracer to see where the exit occurred, whereas the normal exit notification is done after the process is finished exiting.  Even though context is available, the tracer cannot prevent the exit from happening at this point.
fr: L'observé est arrêté tôt dans la terminaison du processus, alors que les registres sont toujours disponibles, ce qui permet au processus utilisant B<ptrace>() de voir où la terminaison s'est produite, alors que la notification de terminaison normale a lieu à la fin de cette terminaison. Même si le contexte est disponible, l'observateur ne peut pas empêcher la terminaison à ce moment là.

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

note: type: Plain text
en: Retrieve a message (as an I<unsigned long>)  about the ptrace event that just happened, placing it at the address I<data> in the tracer.  For B<PTRACE_EVENT_EXIT>, this is the tracee's exit status.  For B<PTRACE_EVENT_FORK>, B<PTRACE_EVENT_VFORK>, B<PTRACE_EVENT_VFORK_DONE>, and B<PTRACE_EVENT_CLONE>, this is the PID of the new process.  (I<addr> is ignored.)
fr: Récupérer un message (dans un I<unsigned long>) concernant l'événement ptrace qui vient d'arriver, en le plaçant à l'adresse I<data> de l'observateur. Pour B<PTRACE_EVENT_EXIT>, il s'agit du code de retour de l'observé. Pour B<PTRACE_EVENT_FORK>, B<PTRACE_EVENT_VFORK>, B<PTRACE_EVENT_VFORK_DONE> et B<PTRACE_EVENT_CLONE>, il s'agit du PID du nouveau processus (I<addr> est ignoré).

note: type: Plain text
en: Restart the stopped tracee process.  If I<data> is nonzero, it is interpreted as the number of a signal to be delivered to the tracee; otherwise, no signal is delivered.  Thus, for example, the tracer can control whether a signal sent to the tracee is delivered or not.  (I<addr> is ignored.)
fr: Redémarrer l'observé arrêté. Si I<data> est non nul, il est interprété comme un numéro de signal à distribuer à l'observé ; sinon aucun signal n'est distribué. L'observateur peut ainsi contrôler si un signal envoyé à l'observé doit lui être distribué ou non (I<addr> est ignoré).

note: type: Plain text
en: Restart the stopped tracee as for B<PTRACE_CONT>, but arrange for the tracee to be stopped at the next entry to or exit from a system call, or after execution of a single instruction, respectively.  (The tracee will also, as usual, be stopped upon receipt of a signal.)  From the tracer's perspective, the tracee will appear to have been stopped by receipt of a B<SIGTRAP>.  So, for B<PTRACE_SYSCALL>, for example, the idea is to inspect the arguments to the system call at the first stop, then do another B<PTRACE_SYSCALL> and inspect the return value of the system call at the second stop.  The I<data> argument is treated as for B<PTRACE_CONT>.  (addr is ignored.)
fr: Redémarrer l'observé arrêté comme pour B<PTRACE_CONT>, mais en s'arrangeant pour qu'il soit arrêté à la prochaine entrée ou sortie d'un appel système, ou après la prochaine instruction, respectivement (l'observé sera aussi arrêté par l'arrivée d'un signal). Du point de vue de l'observateur, l'observé semblera être arrêté par B<SIGTRAP>. Ainsi, pour B<PTRACE_SYSCALL> l'idée est d'inspecter les arguments de l'appel système au premier arrêt puis de faire un autre B<PTRACE_SYSCALL> et d'inspecter la valeur de retour au second arrêt. Le paramètre I<data> est interprété comme pour B<PTRACE_CONT> (I<addr> est ignoré).

note: type: TP
en: B<PTRACE_SYSEMU>, B<PTRACE_SYSEMU_SINGLESTEP> (since Linux 2.6.14)
fr: B<PTRACE_SYSEMU>, B<PTRACE_SYSEMU_SINGLESTEP> (depuis Linux 2.6.14)

note: type: Plain text
en: For B<PTRACE_SYSEMU>, continue and stop on entry to the next system call, which will not be executed.  For B<PTRACE_SYSEMU_SINGLESTEP>, do the same but also singlestep if not a system call.  This call is used by programs like User Mode Linux that want to emulate all the tracee's system calls.  The I<data> argument is treated as for B<PTRACE_CONT>.  (I<addr> is ignored; not supported on all architectures.)
fr: Pour B<PTRACE_SYSEMU>, continuer puis s'arrêter lors du prochain appel système, qui ne sera pas exécuté. Pour B<PTRACE_SYSEMU_SINGLESTEP>, faire la même chose, mais exécuter pas à pas s'il ne s'agit pas d'un appel système. Cette fonction est utilisée par des programmes comme User Mode Linux, qui veulent émuler tous les appels système de l'observé. Le paramètre I<data> est interprété comme pour B<PTRACE_CONT> (I<addr> est ignoré\ ; cet appel n'est pas disponible sur toutes les architectures).

note: type: Plain text
en: Send the tracee a B<SIGKILL> to terminate it.  (I<addr> and I<data> are ignored.)
fr: Envoyer à l'observé un signal B<SIGKILL> pour le terminer (I<addr> et I<data> sont ignorés).

note: [Note from Denys Vlasenko: deprecation suggested by Oleg Nesterov. He prefers to deprecate it instead of describing (and needing to support) PTRACE_KILL's quirks.] type: Plain text
en: I<This operation is deprecated; do not use it!> Instead, send a B<SIGKILL> directly using B<kill>(2)  or B<tgkill>(2).  The problem with B<PTRACE_KILL> is that it requires the tracee to be in signal-delivery-stop, otherwise it may not work (i.e., may complete successfully but won't kill the tracee).  By contrast, sending a B<SIGKILL> directly has no such limitation.
fr: I<Cette opération est obsolète, ne l'utilisez pas.> À la place, envoyez un B<SIGKILL> directement en utilisant B<kill>(2) ou B<tgkill>(2). Le problème avec B<PTRACE_KILL> est qu'il nécessite que l'observé soit en arrêt-distribution-signal, sinon cela risque de ne pas fonctionner (c'est-à-dire risque de se terminer avec succès sans tuer l'observé). En revanche, envoyer B<SIGKILL> directement n'est pas concerné par cette limite.

note: No longer true (removed by Denys Vlasenko, 2011, who remarks: "I think it isn't true in non-ancient 2.4 and in 2.6/3.x. Basically, it's not true for any Linux in practical use. ; the behavior of the tracee is as if it had done a .BR PTRACE_TRACEME . The calling process actually becomes the parent of
en: Attach to the process specified in I<pid>, making it a tracee of the calling process.  The tracee is sent a B<SIGSTOP>, but will not necessarily have stopped by the completion of this call; use B<waitpid>(2)  to wait for the tracee to stop.  See the "Attaching and detaching" subsection for additional information.  (I<addr> and I<data> are ignored.)
fr: Attacher le processus numéro I<pid>, pour le suivre. L'observé va recevoir un B<SIGSTOP>, mais il ne sera peut-être pas arrêté tout de suite, utilisez B<waitid>(2) pour attendre son arrêt. Consultez la sous-section B<Attachement et détachement> pour obtenir de plus amples renseignements (I<addr> et I<data> sont ignorés).

note: In the text below, we decided to avoid prettifying the text with markup: it would make the source nearly impossible to edit, and we _do_ intend to edit it often, in order to keep it updated: ptrace API is full of quirks, no need to compound this situation by making it excruciatingly painful to docum
en: Restart the stopped tracee as for B<PTRACE_CONT>, but first detach from it.  Under Linux, a tracee can be detached in this way regardless of which method was used to initiate tracing.  (I<addr> is ignored.)
fr: Relancer l'observé arrêté comme avec B<PTRACE_CONT>, mais en commençant par s'en détacher. Sous Linux un observé peut être détaché ainsi quelque soit la méthode employée pour démarrer le suivi (I<addr> est ignoré).

note: type: SS
en: Death under ptrace
fr: Mort sous ptrace

note: type: Plain text
en: When a (possibly multithreaded) process receives a killing signal (one whose disposition is set to B<SIG_DFL> and whose default action is to kill the process), all threads exit.  Tracees report their death to their tracer(s).  Notification of this event is delivered via B<waitpid>(2).
fr: Quand un processus (éventuellement multithreadé) reçoit un signal pour le tuer (un dont la disposition est configurée à B<SIG_DFL> et dont l'action par défaut est de tuer le processus), tous les threads se terminent. Chaque observé signale sa mort à son ou ses observateurs. La notification de cet événement est distribuée par B<waitpid>(2).

note: type: Plain text
en: Note that the killing signal will first cause signal-delivery-stop (on one tracee only), and only after it is injected by the tracer (or after it was dispatched to a thread which isn't traced), will death from the signal happen on I<all> tracees within a multithreaded process.  (The term "signal-delivery-stop" is explained below.)
fr: Remarquez que le signal tueur provoquera d'abord un arrêt-distribution-signal (sur un seul observé) et, seulement après être injecté par l'observateur (ou après être envoyé à un thread qui n'est pas suivi), la mort du signal arrivera sur I<tous> les observés d'un processus multithreadé (le terme « arrêt-distribution-signal » est expliqué plus bas).

note: type: Plain text
en: B<SIGKILL> operates similarly, with exceptions.  No signal-delivery-stop is generated for B<SIGKILL> and therefore the tracer can't suppress it.  B<SIGKILL> kills even within system calls (syscall-exit-stop is not generated prior to death by B<SIGKILL>).  The net effect is that B<SIGKILL> always kills the process (all its threads), even if some threads of the process are ptraced.
fr: B<SIGKILL> se comporte de la même façon, à part quelques exceptions. Aucun arrêt-distribution-signal n'est créé pour B<SIGKILL> et l'observateur ne peut par conséquent pas le supprimer. B<SIGKILL> tue même à l'intérieur des appels systèmes (arrêt-sortie-appel-système n'est pas créé avant la mort par B<SIGKILL>). L'effet direct est que B<SIGKILL> tue toujours le processus (tout ses threads), même si certains threads du processus sont suivis avec ptrace.

note: type: Plain text
en: When the tracee calls B<_exit>(2), it reports its death to its tracer.  Other threads are not affected.
fr: Quand l'observé appelle B<_exit>(2), il signale sa mort à son observateur. Les autres threads ne sont pas concernés.

note: type: Plain text
en: When any thread executes B<exit_group>(2), every tracee in its thread group reports its death to its tracer.
fr: Quand n'importe quel thread exécute B<exit_group>(2), tous les observés de son groupe de threads signalent leur mort à leur observateur.

note: type: Plain text
en: If the B<PTRACE_O_TRACEEXIT> option is on, B<PTRACE_EVENT_EXIT> will happen before actual death.  This applies to exits via B<exit>(2), B<exit_group>(2), and signal deaths (except B<SIGKILL>), and when threads are torn down on B<execve>(2)  in a multithreaded process.
fr: Si l'option B<PTRACE_O_TRACEEXIT> est active, B<PTRACE_EVENT_EXIT> arrivera avant la mort réelle. Cela s'applique aux terminaisons avec B<exit>(2), B<exit_group>(2) et aux morts de signal (sauf B<SIGKILL>), et lorsque les threads sont démolis par B<execve>(2) dans un processus multithreadé .

note: type: Plain text
en: The tracer cannot assume that the ptrace-stopped tracee exists.  There are many scenarios when the tracee may die while stopped (such as B<SIGKILL>).  Therefore, the tracer must be prepared to handle an B<ESRCH> error on any ptrace operation.  Unfortunately, the same error is returned if the tracee exists but is not ptrace-stopped (for commands which require a stopped tracee), or if it is not traced by the process which issued the ptrace call.  The tracer needs to keep track of the stopped/running state of the tracee, and interpret B<ESRCH> as "tracee died unexpectedly" only if it knows that the tracee has been observed to enter ptrace-stop.  Note that there is no guarantee that I<waitpid(WNOHANG)> will reliably report the tracee's death status if a ptrace operation returned B<ESRCH>.  I<waitpid(WNOHANG)> may return 0 instead.  In other words, the tracee may be "not yet fully dead", but already refusing ptrace requests.
fr: L'observateur ne peut pas assumer que l'observé arrêté-ptrace existe. L'observé risque de mourir avant d'être arrêté dans plusieurs cas (comme avec B<SIGKILL>). Par conséquent, le tracé doit être préparé pour traiter une erreur B<ESRCH> sur n'importe quel opération ptrace. Malheureusement, la même erreur est renvoyée si l'observé existe mais n'est pas arrêté-ptrace (pour les commandes qui nécessitent un observé arrêté), ou s'il n'est pas suivi par le processus qui a envoyé l'appel ptrace. L'observateur doit garder une trace de l'état arrêté ou en fonctionnement de l'observé, et interpréter B<ESRCH> comme « l'observé s'est achevé de manière inattendue » seulement s'il sait que l'observé est effectivement entré en arrêt-ptrace. Remarquez qu'il n'est pas garanti que I<waitpid(WNOHANG)> signale de façon fiable l'état de mort de l'observé si une opération ptrace renvoie B<ESRCH>. I<waitpid(WNOHANG)> pourrait plutôt renvoyer 0. Autrement dit, l'observé pourrait « ne pas être encore mort », mais déjà refuser des requêtes ptrace.

note: type: Plain text
en: The tracer can't assume that the tracee I<always> ends its life by reporting I<WIFEXITED(status)> or I<WIFSIGNALED(status)>; there are cases where this does not occur.  For example, if a thread other than thread group leader does an B<execve>(2), it disappears; its PID will never be seen again, and any subsequent ptrace stops will be reported under the thread group leader's PID.
fr: L'observateur ne peut pas assumer que l'observé finit I<toujours> sa vie en signalant I<WIFEXITED(status)> ou I<WIFSIGNALED(status)> ; dans certains cas ça n'arrive pas. Par exemple si un thread différent du leader de groupe de threads fait un B<execve>(2), il disparaît ; son PID ne sera plus jamais vu, tous les arrêts suivants de ptrace seront signalés sous le PID du leader de groupe de threads.

note: type: SS
en: Stopped states
fr: États arrêtés

note: type: Plain text
en: A tracee can be in two states: running or stopped.
fr: Deux états existent pour un observé : en cours d'exécution ou à l'arrêt.

note: type: Plain text
en: There are many kinds of states when the tracee is stopped, and in ptrace discussions they are often conflated.  Therefore, it is important to use precise terms.
fr: De nombreuses sortes d'états sont possibles quand l'observé est arrêté, et les discussions dans ptrace sont souvent confondues. Par conséquent, l'utilisation de termes précis est importante.

note: type: Plain text
en: In this manual page, any stopped state in which the tracee is ready to accept ptrace commands from the tracer is called I<ptrace-stop>.  Ptrace-stops can be further subdivided into I<signal-delivery-stop>, I<group-stop>, I<syscall-stop>, and so on.  These stopped states are described in detail below.
fr: Dans cette page de manuel, tous les états d'arrêt dans lesquels l'observé est prêt à accepter des commandes ptrace de l'observateur sont appelés I<arrêts-ptrace>. Les arrêts-ptrace peuvent ensuite être sous-divisés en I<arrêt-distribution-signal>, I<arrêt-groupe>, I<arrêt-appel-système>, etc. Ces états d'arrêt sons décrits en détail ci-dessous.

note: type: Plain text
en: When the running tracee enters ptrace-stop, it notifies its tracer using B<waitpid>(2)  (or one of the other "wait" system calls).  Most of this manual page assumes that the tracer waits with:
fr: Lorsque l'observé en cours d'exécution entre en arrêt-ptrace, il avise son observateur en utilisant B<waitpid>(2) (ou un des autres appels système « wait »). La plupart de cette page de manuel suppose que l'observateur attend avec :

note: type: Plain text
en:     pid = waitpid(pid_or_minus_1, &status, __WALL);
fr:     pid = waitpid(pid_ou_moins_1, &status, __WALL);

note: Denys Vlasenko: Do we require __WALL usage, or will just using 0 be ok? (With 0, I am not 100% sure there aren't ugly corner cases.) Are the rules different if user wants to use waitid? Will waitid require WEXITED? type: Plain text
en: Ptrace-stopped tracees are reported as returns with I<pid> greater than 0 and I<WIFSTOPPED(status)> true.
fr: Les observés arrêtés-ptrace sont signalés comme renvoyés avec un I<pid> strictement positif et I<WIFSTOPPED(status)> vrai.

note: type: Plain text
en: The B<__WALL> flag does not include the B<WSTOPPED> and B<WEXITED> flags, but implies their functionality.
fr: L'attribut B<__WALL> ne contient pas les attributs B<WSTOPPED> et B<WEXITED>, mais implique leur fonctionnalité.

note: type: Plain text
en: Setting the B<WCONTINUED> flag when calling B<waitpid>(2)  is not recommended: the "continued" state is per-process and consuming it can confuse the real parent of the tracee.
fr: La configuration de l'attribut B<WCONTINUED> en appelant B<waitpid>(2) n'est pas conseillée : l'état « exécuté » est relatif au processus et l'utiliser peut embrouiller le vrai père de l'observé.

note: type: Plain text
en: Use of the B<WNOHANG> flag may cause B<waitpid>(2)  to return 0 ("no wait results available yet")  even if the tracer knows there should be a notification.  Example:
fr: Utiliser l'attribut B<WNOHANG> pourrait forcer B<waitpid>(2) à renvoyer 0 (« aucun résultat d'attente encore disponible ») même si l'observateur sait qu'il devrait y avoir une notification. Exemple :

note: type: Plain text
en:     kill(tracee, SIGKILL);
        waitpid(tracee, &status, __WALL | WNOHANG);
fr:     kill(observé, SIGKILL);
        waitpid(observé, &status, __WALL | WNOHANG);

note: type: Plain text
en: The following kinds of ptrace-stops exist: signal-delivery-stops, group-stop, PTRACE_EVENT stops, syscall-stops B<PTRACE_SINGLESTEP>, B<PTRACE_SYSEMU>, and B<PTRACE_SYSEMU_SINGLESTEP>.  They all are reported by B<waitpid>(2)  with I<WIFSTOPPED(status)> true.  They may be differentiated by examining the value I<statusE<gt>E<gt>8>, and if there is ambiguity in that value, by querying B<PTRACE_GETSIGINFO>.  (Note: the I<WSTOPSIG(status)> macro can't be used to perform this examination, because it returns the value (I<status\E<gt>E<gt>8)\ >B<&\ 0xff>B<.)>
fr: Les sortes d'arrêts-ptrace suivants existent : arrêts-distribution-signal, arrêts-groupe, arrêts B<PTRACE_EVENT> et arrêts-appel-système. Ils sont signalés par B<waitpid>(2) avec I<WIFSTOPPED(status)> vrai. Ils peuvent être distingués en examinant la valeur I<statusE<gt>E<gt>8>, et en cas d'ambiguïté dans cette valeur, en faisant une requête B<PTRACE_GETSIGINFO> (remarque : la macro I<WSTOPSIG(status)> ne peut pas être utilisée pour réaliser cet examen, car elle renvoie la valeur (I<status\E<gt>E<gt>8>)\ B<&\ 0xff>).

note: type: SS
en: Signal-delivery-stop
fr: Arrêt-distribution-signal

note: type: Plain text
en: When a (possibly multithreaded) process receives any signal except B<SIGKILL>, the kernel selects an arbitrary thread which handles the signal.  (If the signal is generated with B<tgkill>(2), the target thread can be explicitly selected by the caller.)  If the selected thread is traced, it enters signal-delivery-stop.  At this point, the signal is not yet delivered to the process, and can be suppressed by the tracer.  If the tracer doesn't suppress the signal, it passes the signal to the tracee in the next ptrace restart request.  This second step of signal delivery is called I<signal injection> in this manual page.  Note that if the signal is blocked, signal-delivery-stop doesn't happen until the signal is unblocked, with the usual exception that B<SIGSTOP> can't be blocked.
fr: Quand un processus (éventuellement multithreadé) reçoit n'importe quel signal sauf B<SIGKILL>, le noyau choisi un thread arbitraire pour traiter le signal (si le signal est créé avec B<tgill>(2), le thread cible peut être explicitement choisi par l'appelant). Si le thread choisi est suivi, il entre en arrêt-distribution-signal. À ce moment là, le signal n'est pas encore distribué au processus, et peut être supprimé par l'observateur. Si l'observateur ne supprime pas le signal, il passe le signal à l'observé lors de la requête suivante de redémarrage de ptrace. Cette deuxième étape de distribution de signal est appelée I<injection de signal> dans cette page de manuel. Remarquez que si le signal est bloqué, l'arrêt-distribution-signal n'arrive pas avant que le signal soit débloqué, à l'exception habituelle que B<SIGSTOP> ne peut pas être bloqué.

note: type: Plain text
en: Signal-delivery-stop is observed by the tracer as B<waitpid>(2)  returning with I<WIFSTOPPED(status)> true, with the stopping signal returned by I<WSTOPSIG(status)>.  If the stopping signal is B<SIGTRAP>, this may be a different kind of ptrace-stop; see the "Syscall-stops" and "execve" sections below for details.  If I<WSTOPSIG(status)> returns a stopping signal, this may be a group-stop; see below.
fr: L'arrêt-distribution-signal est respecté par l'observateur tant que B<waitpid>(2) retourne avec I<WIFSTOPPED(status)> vrai, avec le signal d'arrêt renvoyé par I<WSTOPSIG(status)>. Si le signal d'arrêt est B<SIGTRAP>, cela pourrait être un arrêt-ptrace de nature différente ; consultez les sections B<Arrêts-appel-système> et B<execve(2) sous ptrace> plus bas pour obtenir de plus amples précisions. Si I<WSTOPSIG(status)> renvoie un signal d'arrêt, cela pourrait être un arrêt-groupe ; voir ci-dessous.

note: type: SS
en: Signal injection and suppression
fr: Injection et suppression de signal

note: type: Plain text
en: After signal-delivery-stop is observed by the tracer, the tracer should restart the tracee with the call
fr: Après un arrêt-distribution-signal respecté par l'observateur, l'observateur devrait redémarrer l'observé avec l'appel

note: type: Plain text
en:     ptrace(PTRACE_restart, pid, 0, sig)
fr:     ptrace(PTRACE_redémarrer, pid, 0, sig)

note: type: Plain text
en: where B<PTRACE_restart> is one of the restarting ptrace requests.  If I<sig> is 0, then a signal is not delivered.  Otherwise, the signal I<sig> is delivered.  This operation is called I<signal injection> in this manual page, to distinguish it from signal-delivery-stop.
fr: où B<PTRACE_redémarrer> est une des requêtes ptrace de redémarrage. Si I<sig> est 0, alors aucun signal n'est distribué. Sinon, le signal I<sig> est distribué. Cette opération est appelée I<injection de signal> dans cette page de manuel, pour la distinguer de l'arrêt-distribution-signal.

note: type: Plain text
en: The I<sig> value may be different from the I<WSTOPSIG(status)> value: the tracer can cause a different signal to be injected.
fr: La valeur de I<sig> peut être différente de celle de I<WSTOPSIG(status)> : l'observateur peut provoquer l'injection d'un autre signal.

note: type: Plain text
en: Note that a suppressed signal still causes system calls to return prematurely.  Restartable system calls will be restarted (the tracer will observe the tracee to execute B<restart_syscall(2)> if the tracer uses B<PTRACE_SYSCALL>); non-restartable system calls may fail with B<EINTR> even though no observable signal is injected to the tracee.
fr: Remarquez qu'un signal supprimé provoque toujours un retour prématuré des appels système. Les appels système redémarrables seront redémarrés  (l'observateur forcera l'observé à exécuter B<restart_syscall>(2) si l'observateur utilise B<PTRACE_SYSCALL>) ; les appels système non redémarrables risquent d'échouer avec B<EINTR> même si aucun signal observable n'est injecté dans l'observé.

note: type: Plain text
en: Restarting ptrace commands issued in ptrace-stops other than signal-delivery-stop are not guaranteed to inject a signal, even if I<sig> is nonzero.  No error is reported; a nonzero I<sig> may simply be ignored.  Ptrace users should not try to "create a new signal" this way: use B<tgkill>(2)  instead.
fr: Lors du redémarrage des commandes ptrace émises dans d'autres arrêts-ptrace qu'arrêt-distribution-signal, l'injection de signal n'est pas garantie, même si I<sig> est non nul. Aucune erreur n'est signalée ; un I<sig> non nul risque simplement d'être ignoré. Les utilisateurs de ptrace ne devraient pas essayer de « créer un nouveau signal » de cette façon : utilisez plutôt B<tgkill>(2).

note: type: Plain text
en: The fact that signal injection requests may be ignored when restarting the tracee after ptrace stops that are not signal-delivery-stops is a cause of confusion among ptrace users.  One typical scenario is that the tracer observes group-stop, mistakes it for signal-delivery-stop, restarts the tracee with
fr: Le fait que des requêtes d'injection de signal puissent être ignorées lors du redémarrage de l'observé après des arrêts ptrace qui ne sont pas des arrêts-distribution-signal est une source de confusion pour les utilisateurs de ptrace. Un scénario typique est que l'observateur remarque un arrêt-groupe, le confonde avec un arrêt-distribution-signal, et redémarre l'observé avec

note: type: Plain text
en:     ptrace(PTRACE_rest, pid, 0, stopsig)
fr:     ptrace(PTRACE_repos, pid, 0, stopsig)

note: type: Plain text
en: with the intention of injecting I<stopsig>, but I<stopsig> gets ignored and the tracee continues to run.
fr: dans le but d'injecter I<stopsig>, alors que I<stopsig> sera ignoré et que l'observé continuera de fonctionner.

note: type: Plain text
en: The B<SIGCONT> signal has a side effect of waking up (all threads of)  a group-stopped process.  This side effect happens before signal-delivery-stop.  The tracer can't suppress this side-effect (it can only suppress signal injection, which only causes the B<SIGCONT> handler to not be executed in the tracee, if such a handler is installed).  In fact, waking up from group-stop may be followed by signal-delivery-stop for signal(s)  I<other than> B<SIGCONT>, if they were pending when B<SIGCONT> was delivered.  In other words, B<SIGCONT> may be not the first signal observed by the tracee after it was sent.
fr: Le signal B<SIGCONT> a pour effet de bord de réveiller (tous les threads d')un processus arrêté-groupe. Cet effet de bord arrive avant un arrêt-distribution-signal. L'observateur ne peut pas supprimer cet effet de bord (il ne peut que supprimer l'injection de signal, qui force seulement le gestionnaire de B<SIGCONT> à ne pas être exécuté dans l'observé, si un gestionnaire de ce type est installé). En fait, le réveil depuis un arrêt-groupe pourrait être suivi par un arrêt-distribution-signal pour le ou les signaux I<différents> de B<SIGCONT>, s'ils étaient en attente quand B<SIGCONT> a été distribué. Autrement dit, B<SIGCONT> pourrait ne pas être le premier signal remarqué par l'observé après avoir été envoyé.

note: type: Plain text
en: Stopping signals cause (all threads of) a process to enter group-stop.  This side effect happens after signal injection, and therefore can be suppressed by the tracer.
fr: L'arrêt de signaux force (tous les threads d')un processus à entrer en arrêt-groupe. Cet effet de bord arrive après une injection de signal, et peut par conséquent être supprimé par l'observateur.

note: In the Linux 2.4 sources, in arch/i386/kernel/signal.c::do_signal(), there is: /* The debugger continued.  Ignore SIGSTOP.  */ if (signr == SIGSTOP) continue; type: Plain text
en: In Linux 2.4 and earlier, the B<SIGSTOP> signal can't be injected.
fr: Sous Linux 2.4 et les versions précédentes, le signal B<SIGSTOP> ne pouvait pas être injecté.

note: type: Plain text
en: B<PTRACE_GETSIGINFO> can be used to retrieve a I<siginfo_t> structure which corresponds to the delivered signal.  B<PTRACE_SETSIGINFO> may be used to modify it.  If B<PTRACE_SETSIGINFO> has been used to alter I<siginfo_t>, the I<si_signo> field and the I<sig> parameter in the restarting command must match, otherwise the result is undefined.
fr: B<PTRACE_GETSIGINFO> peut être utilisé pour récupérer une structure I<siginfo_t> qui correspond au signal distribué. B<PTRACE_SETSIGINFO> pourrait être utilisé pour le modifier. Si B<PTRACE_SETSIGINFO> a été utilisé pour modifier I<siginfo_t>, le champ I<si_signo> et le paramètre I<sig> de la commande de redémarrage doivent correspondre, sinon le résultat est indéfini.

note: type: SS
en: Group-stop
fr: Arrêt-groupe

note: type: Plain text
en: When a (possibly multithreaded) process receives a stopping signal, all threads stop.  If some threads are traced, they enter a group-stop.  Note that the stopping signal will first cause signal-delivery-stop (on one tracee only), and only after it is injected by the tracer (or after it was dispatched to a thread which isn't traced), will group-stop be initiated on I<all> tracees within the multithreaded process.  As usual, every tracee reports its group-stop separately to the corresponding tracer.
fr: Quand un processus (éventuellement multithreadé) reçoit un signal d'arrêt, tous les threads s'arrêtent. Si certains threads sont suivis, ils entrent en arrêt-groupe. Remarquez que le signal d'arrêt provoquera d'abord un arrêt-distribution-signal (sur un seul observé) et, seulement après avoir été injecté par l'observateur (ou après avoir été envoyé à un thread qui n'est pas suivi), l'arrêt-groupe sera initié sur I<tous> les observés d'un processus multithreadé. Comme d'habitude, tous les observés signalent leur arrêt-groupe séparément à l'observateur correspondant.

note: type: Plain text
en: Group-stop is observed by the tracer as B<waitpid>(2)  returning with I<WIFSTOPPED(status)> true, with the stopping signal available via I<WSTOPSIG(status)>.  The same result is returned by some other classes of ptrace-stops, therefore the recommended practice is to perform the call
fr: L'arrêt-groupe est respecté par l'observateur tant que B<waitpid>(2) retourne avec I<WIFSTOPPED(status)> vrai, avec le signal d'arrêt disponible par l'intermédiaire de I<WSTOPSIG(status)>. Le même résultat est renvoyé par d'autres classes d'arrêts-ptrace, par conséquent la méthode conseillée est de réaliser l'appel

note: type: Plain text
en: The call can be avoided if the signal is not B<SIGSTOP>, B<SIGTSTP>, B<SIGTTIN>, or B<SIGTTOU>; only these four signals are stopping signals.  If the tracer sees something else, it can't be a group-stop.  Otherwise, the tracer needs to call B<PTRACE_GETSIGINFO>.  If B<PTRACE_GETSIGINFO> fails with B<EINVAL>, then it is definitely a group-stop.  (Other failure codes are possible, such as B<ESRCH> ("no such process") if a B<SIGKILL> killed the tracee.)
fr: L'appel peut être évité si le signal n'est pas B<SIGSTOP>, B<SIGTSTP>, B<SIGTTIN> ou B<SIGTTOU> ; seuls ces quatre signaux sont des signaux d'arrêt. Si l'observateur voit autre chose, ce ne peut pas être un arrêt-groupe. Sinon, l'observateur doit appeler B<PTRACE_GETSIGINFO>. Si B<PTRACE_GETSIGINFO> échoue avec B<EINVAL>, alors c'est définitivement un arrêt-groupe (d'autres codes d'échec sont possibles, comme B<ESRCH> (« pas de processus de ce type ») si un B<SIGKILL> a tué l'observé).

note: type: Plain text
en: As of kernel 2.6.38, after the tracer sees the tracee ptrace-stop and until it restarts or kills it, the tracee will not run, and will not send notifications (except B<SIGKILL> death) to the tracer, even if the tracer enters into another B<waitpid>(2)  call.
fr: Depuis le noyau 2.6.38, après que l'observateur a vu l'arrêt-ptrace de l'observé et jusqu'à ce qu'il le redémarre ou le tue, l'observé ne fonctionnera pas, et n'enverra pas de notification (sauf mort par B<SIGKILL>) à l'observateur, même si l'observateur entre dans un autre appel B<waitpid>(2).

note: type: Plain text
en: The kernel behavior described in the previous paragraph causes a problem with transparent handling of stopping signals.  If the tracer restarts the tracee after group-stop, the stopping signal is effectively ignored\(emthe tracee doesn't remain stopped, it runs.  If the tracer doesn't restart the tracee before entering into the next B<waitpid>(2), future B<SIGCONT> signals will not be reported to the tracer; this would cause the B<SIGCONT> signals to have no effect on the tracee.
fr: Le comportement du noyau décrit dans le paragraphe précédent pose un problème avec la gestion transparente de signaux d'arrêt. Si l'observateur redémarre l'observé après un arrêt-groupe, le signal d'arrêt est effectivement ignoré — l'observé ne reste pas arrêté, il fonctionne. Si l'observateur ne redémarre pas l'observé avant d'entrer dans le prochain B<waitpid>(2), les signaux B<SIGCONT> suivants ne seront pas signalés à l'observateur ; cela pourrait forcer des signaux B<SIGCONT> à être sans effet sur l'observé.

note: type: SS
en: PTRACE_EVENT stops
fr: Arrêts PTRACE_EVENT

note: type: Plain text
en: If the tracer sets B<PTRACE_O_TRACE_*> options, the tracee will enter ptrace-stops called B<PTRACE_EVENT> stops.
fr: Si l'observateur configure des options B<PTRACE_O_TRACE_*>, l'observé entrera en arrêts-ptrace appelés arrêts B<PTRACE_EVENT>.

note: type: Plain text
en: B<PTRACE_EVENT> stops are observed by the tracer as B<waitpid>(2)  returning with I<WIFSTOPPED(status)>, and I<WSTOPSIG(status)> returns B<SIGTRAP>.  An additional bit is set in the higher byte of the status word: the value I<statusE<gt>E<gt>8> will be
fr: Les arrêts B<PTRACE_EVENT> sont respectés par l'observateur tant que B<waitpid>(2) retourne avec I<WIFSTOPPED(status)>, et que I<WSTOPSIG(status)> renvoie B<SIGTRAP>. Un bit supplémentaire est configuré dans l'octet le plus haut du mot d'état : la valeur I<statusE<gt>E<gt>8> sera

note: type: Plain text
en:     (SIGTRAP | PTRACE_EVENT_foo E<lt>E<lt> 8).
fr:     (SIGTRAP | PTRACE_EVENT_truc E<lt>E<lt> 8).

note: type: Plain text
en: The following events exist:
fr: Les événements suivants existent.

note: type: Plain text
en: Stop before return from B<vfork>(2)  or B<clone>(2)  with the B<CLONE_VFORK> flag.  When the tracee is continued after this stop, it will wait for child to exit/exec before continuing its execution (in other words, the usual behavior on B<vfork>(2)).
fr: Arrêt avant de revenir de B<vfork>(2) ou B<clone>(2) avec l'attribut B<CLONE_VFORK>. Quand l'observé est continué après cet arrêt, il attendra une sortie ou exécution du fils avant de continuer son exécution (autrement dit, le comportement normal avec B<vfork>(2)).

note: type: Plain text
en: Stop before return from B<fork>(2)  or B<clone>(2)  with the exit signal set to B<SIGCHLD>.
fr: Arrêt avant de revenir de B<fork>(2) ou B<clone>(2) avec le signal de sortie configuré à B<SIGCHLD>.

note: type: Plain text
en: Stop before return from B<clone>(2)
fr: Arrêt avant de revenir de B<clone>(2).

note: type: Plain text
en: Stop before return from B<vfork>(2)  or B<clone>(2)  with the B<CLONE_VFORK> flag, but after the child unblocked this tracee by exiting or execing.
fr: Arrêt avant de revenir de B<vfork>(2) ou B<clone>(2) avec l'attribut B<CLONE_VFORK>, mais après que le fils a débloqué son observé par sortie ou exécution.

note: type: Plain text
en: For all four stops described above, the stop occurs in the parent (i.e., the tracee), not in the newly created thread.  B<PTRACE_GETEVENTMSG> can be used to retrieve the new thread's ID.
fr: Pour les quatre arrêts décrits ci-dessus, l'arrêt arrive dans le père (c'est-à-dire l'observé), pas dans le nouveau thread créé. B<PTRACE_GETEVENTMSG> permet de récupérer l'identifiant du nouveau thread.

note: type: Plain text
en: Stop before return from B<execve>(2).
fr: Arrêt avant le retour d'B<execve>(2).

note: type: Plain text
en: Stop before exit (including death from B<exit_group>(2)), signal death, or exit caused by B<execve>(2)  in a multithreaded process.  B<PTRACE_GETEVENTMSG> returns the exit status.  Registers can be examined (unlike when "real" exit happens).  The tracee is still alive; it needs to be B<PTRACE_CONT>ed or B<PTRACE_DETACH>ed to finish exiting.
fr: Arrêt avant la sortie (y compris la mort depuis B<exit_group>(2)), la mort du signal ou la sortie provoquée par B<execve>(2) dans un processus multithreadé. B<PTRACE_GETEVENTMSG> renvoie l'état de sortie. Les registres peuvent être examinés (contrairement à quand une « vraie » sortie arrive). L'observé est toujours actif ; il a besoin de B<PTRACE_CONT> ou B<PTRACE_DETACH> pour terminer sa sortie.

note: type: Plain text
en: B<PTRACE_GETSIGINFO> on B<PTRACE_EVENT> stops returns B<SIGTRAP in> I<si_signo>, with I<si_code> set to I<(eventE<lt>E<lt>8)\ |\ SIGTRAP>.
fr: B<PTRACE_GETSIGINFO> sur les arrêts B<PTRACE_EVENT> renvoie B<SIGTRAP> dans I<si_signo>, avec I<si_code> configuré à (I<eventE<lt>E<lt>8>)\ B<|\ SIGTRAP>.

note: type: SS
en: Syscall-stops
fr: Arrêts-appel-système

note: type: Plain text
en: If the tracee was restarted by B<PTRACE_SYSCALL>, the tracee enters syscall-enter-stop just prior to entering any system call.  If the tracer restarts the tracee with B<PTRACE_SYSCALL>, the tracee enters syscall-exit-stop when the system call is finished, or if it is interrupted by a signal.  (That is, signal-delivery-stop never happens between syscall-enter-stop and syscall-exit-stop; it happens I<after> syscall-exit-stop.)
fr: Si l'observé était redémarré par B<PTRACE_SYSCALL>, l'observé entre en arrêt-entrée-appel-système juste avant d'entrer dans n'importe quel appel système. Si l'observateur redémarre l'observé avec B<PTRACE_SYSCALL>, l'observé entre en arrêt-sortie-appel-système quand l'appel système est terminé, ou s'il est interrompu par un signal (c'est à dire qu'un arrêt-distribution-signal n'arrive jamais entre un arrêt-entrée-appel-système et un arrêt-sortie-appel-système : il arrive I<après> l'arrêt-sortie-appel-système).

note: type: Plain text
en: Other possibilities are that the tracee may stop in a B<PTRACE_EVENT> stop, exit (if it entered B<_exit>(2)  or B<exit_group>(2)), be killed by B<SIGKILL>, or die silently (if it is a thread group leader, the B<execve>(2)  happened in another thread, and that thread is not traced by the same tracer; this situation is discussed later).
fr: D'autres possibilités sont que l'observé pourrait s'arrêter dans un arrêt B<PTRACE_EVENT>, sortir (s'il est entré en B<_exit>(2) ou B<exit_group>(2)), être tué par B<SIGKILL> ou mourir silencieusement (s'il s'agit d'un leader de groupe de threads, que l'B<execve>(2) est arrivé dans un autre thread et que ce thread n'est pas suivi par le même observateur ; cette situation sera abordée plus tard).

note: type: Plain text
en: Syscall-enter-stop and syscall-exit-stop are observed by the tracer as B<waitpid>(2)  returning with I<WIFSTOPPED(status)> true, and I<WSTOPSIG(status)> giving B<SIGTRAP>.  If the B<PTRACE_O_TRACESYSGOOD> option was set by the tracer, then I<WSTOPSIG(status)> will give the value I<(SIGTRAP\ |\ 0x80)>.
fr: Les arrêt-entrée-appel-système et arrêt-sortie-appel-système sont respectés par l'observateur tant que B<waitpid>(2) retourne avec I<WIFSTOPPED(status)> vrai, et que I<WSTOPSIG(status)> donne B<SIGTRAP>. Si l'option B<PTRACE_O_TRACESYSGOOD> était configurée par l'observateur, alors I<WSTOPSIG(status)> donnera la valeur (B<SIGTRAP\ |\ 0x80>).

note: type: Plain text
en: Syscall-stops can be distinguished from signal-delivery-stop with B<SIGTRAP> by querying B<PTRACE_GETSIGINFO> for the following cases:
fr: Les arrêts-appel-système peuvent être distingués d'un arrêt-distribution-signal avec B<SIGTRAP> en demandant B<PTRACE_GETSIGINFO> pour les cas suivants.

note: type: Plain text
en: B<SIGTRAP> was delivered as a result of a userspace action, for example, a system call (B<tgkill>(2), B<kill>(2), B<sigqueue>(3), etc.), expiration of a POSIX timer, change of state on a POSIX message queue, or completion of an asynchronous I/O request.
fr: B<SIGTRAP> a été distribué comme résultat dune action en espace utilisateur, par exemple, un appel système (B<tgkill>(2), B<kill>(2), B<sigqueue>(3), etc.), l'expiration d'un minuteur POSIX, la modification d'état sur une file de messages POSIX où la fin d'une requête d'E/S asynchrone.

note: type: Plain text
en: B<SIGTRAP> was sent by the kernel.
fr: B<SIGTRAP> a été envoyé par le noyau.

note: type: TP
en: I<si_code> == SIGTRAP or I<si_code> == (SIGTRAP|0x80)
fr: I<si_code> == SIGTRAP ou I<si_code> == (SIGTRAP|0x80)

note: type: Plain text
en: This is a syscall-stop.
fr: C'est un arrêt-appel-système.

note: type: Plain text
en: However, syscall-stops happen very often (twice per system call), and performing B<PTRACE_GETSIGINFO> for every syscall-stop may be somewhat expensive.
fr: Cependant, les arrêts-appel-système arrivent très souvent (deux fois par appel système) et réaliser B<PTRACE_GETSIGINFO> pour chaque arrêt-appel-système pourrait être assez coûteux.

note: type: Plain text
en: Some architectures allow the cases to be distinguished by examining registers.  For example, on x86, I<rax> == -B<ENOSYS> in syscall-enter-stop.  Since B<SIGTRAP> (like any other signal) always happens I<after> syscall-exit-stop, and at this point I<rax> almost never contains -B<ENOSYS>, the B<SIGTRAP> looks like "syscall-stop which is not syscall-enter-stop"; in other words, it looks like a "stray syscall-exit-stop" and can be detected this way.  But such detection is fragile and is best avoided.
fr: Certaines architectures permettent de distinguer ces cas en examinant les registres. Par exemple, sur x86, I<rax> == -B<ENOSYS> en arrêt-entrée-appel-système. Puisque B<SIGTRAP> (comme tout autre signal) arrive toujours I<après> l'arrêt-sortie-appel-système et que I<rax> ne contient à ce moment presque jamais -B<ENOSYS>, le B<SIGTRAP> ressemble à un « arrêt-appel-système qui n'est pas un arrêt-entrée-appel-système » ; autrement dit, il ressemble à un « arrêt-sortie-appel-système perdu » et peut être détecté de cette façon. Une telle détection est néanmoins fragile, elle est donc a éviter.

note: type: Plain text
en: Using the B<PTRACE_O_TRACESYSGOOD> option is the recommended method to distinquish syscall-stops from other kinds of ptrace-stops, since it is reliable and does not incur a performance penalty.
fr: L'utilisation de l'option B<PTRACE_O_TRACESYSGOOD> est la méthode conseillée pour distinguer les arrêts-appel-système des autres sortes d'arrêts-ptrace, puisqu'il est fiable et n'induit pas de perte de performances.

note: type: Plain text
en: Syscall-enter-stop and syscall-exit-stop are indistinguishable from each other by the tracer.  The tracer needs to keep track of the sequence of ptrace-stops in order to not misinterpret syscall-enter-stop as syscall-exit-stop or vice versa.  The rule is that syscall-enter-stop is always followed by syscall-exit-stop, B<PTRACE_EVENT> stop or the tracee's death; no other kinds of ptrace-stop can occur in between.
fr: Les arrêt-entrée-appel-système et arrêt-sortie-appel-système ne sont pas différentiables l'un de l'autre. L'observateur doit garder une trace de la suite d'arrêts-ptrace afin de ne pas mal interpréter un arrêt-entrée-appel-système comme un arrêt-sortie-appel-système ou vice versa. La règle est que l'arrêt-entrée-appel-système est toujours suivi par un arrêt-sortie-appel-système, un arrêt B<PTRACE_EVENT> ou la mort de l'observé ; aucune autre sorte d'arrêt-ptrace ne peut arriver entre-deux.

note: type: Plain text
en: If after syscall-enter-stop, the tracer uses a restarting command other than B<PTRACE_SYSCALL>, syscall-exit-stop is not generated.
fr: Si suite à un arrêt-entrée-appel-système, l'observateur utilise une commande de redémarrage différente de B<PTRACE_SYSCALL>, l'arrêt-sortie-appel-système n'est pas créé.

note: type: Plain text
en: B<PTRACE_GETSIGINFO> on syscall-stops returns B<SIGTRAP> in I<si_signo>, with I<si_code> set to B<SIGTRAP> or I<(SIGTRAP|0x80)>.
fr: B<PTRACE_GETSIGINFO> sur les arrêts-appel-système renvoie B<SIGTRAP> dans I<si_signo>, avec I<si_code> configuré à B<SIGTRAP> ou (B<SIGTRAP\ |\ 0x80>).

note: type: SS
en: PTRACE_SINGLESTEP, PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP stops
fr: Arrêts PTRACE_SINGLESTEP, PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP

note: FIXME document stops occurring with PTRACE_SINGLESTEP, PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP type: Plain text
en: [Details of these kinds of stops are yet to be documented.]
fr: [Les précisions sur ces types d'arrêts sont encore à documenter.]

note: type: SS
en: Informational and restarting ptrace commands
fr: Commandes ptrace d'information et de redémarrage

note: type: Plain text
en: Most ptrace commands (all except B<PTRACE_ATTACH>, B<PTRACE_TRACEME>, and B<PTRACE_KILL>)  require the tracee to be in a ptrace-stop, otherwise they fail with B<ESRCH>.
fr: La plupart des commandes ptrace (toutes sauf B<PTRACE_ATTACH>, B<PTRACE_TRACEME> et B<PTRACE_KILL>) nécessitent que l'observé soit en arrêt-ptrace, sinon il échoue avec B<ESRCH>.

note: type: Plain text
en: When the tracee is in ptrace-stop, the tracer can read and write data to the tracee using informational commands.  These commands leave the tracee in ptrace-stopped state:
fr: Quand l'observé est en arrêt-ptrace, l'observateur peut lire et écrire les donnés sur l'observé en utilisant les commandes d'information. Ces commandes laissent l'observé en état arrêté-ptrace :

note: type: Plain text
en: Note that some errors are not reported.  For example, setting signal information (I<siginfo>)  may have no effect in some ptrace-stops, yet the call may succeed (return 0 and not set I<errno>); querying B<PTRACE_GETEVENTMSG> may succeed and return some random value if current ptrace-stop is not documented as returning a meaningful event message.
fr: Remarquez que certaines erreurs ne sont pas signalées. Par exemple, la configuration d'informations de signal (I<siginfo>) pourrait être sans effet pour certains arrêts-ptrace, alors que l'appel pourrait-être réussi (en renvoyant 0 et sans définir I<errno>) ; la demande de B<PTRACE_GETEVENTMSG> pourrait réussir et renvoyer une quelconque valeur aléatoire si l'arrêt-ptrace actuel n'est pas documenté comme renvoyant un message d'événement significatif.

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

note: type: Plain text
en: affects one tracee.  The tracee's current flags are replaced.  Flags are inherited by new tracees created and "auto-attached" via active B<PTRACE_O_TRACEFORK>, B<PTRACE_O_TRACEVFORK>, or B<PTRACE_O_TRACECLONE> options.
fr: ne concerne qu'un observé. Les attributs actuels de l'observé sont remplacés. Les attributs sont hérités par les nouveaux observés créés et « attachés automatiquement » à l'aide d'options B<PTRACE_O_TRACEFORK>, B<PTRACE_O_TRACEVFORK> ou B<PTRACE_O_TRACECLONE> actives.

note: type: Plain text
en: Another group of commands makes the ptrace-stopped tracee run.  They have the form:
fr: Un autre groupe de commandes peut redémarrer l'observé arrêté ptrace. Ils sont de la forme :

note: type: Plain text
en: where I<cmd> is B<PTRACE_CONT>, B<PTRACE_DETACH>, B<PTRACE_SYSCALL>, B<PTRACE_SINGLESTEP>, B<PTRACE_SYSEMU>, or B<PTRACE_SYSEMU_SINGLESTEP.> If the tracee is in signal-delivery-stop, I<sig> is the signal to be injected (if it is nonzero).  Otherwise, I<sig> may be ignored.  (When restarting a tracee from a ptrace-stop other than signal-delivery-stop, recommended practice is to always pass 0 in I<sig .)>
fr: où  I<cmd> est B<PTRACE_CONT>, B<PTRACE_DETACH>, B<PTRACE_SYSCALL>, B<PTRACE_SINGLESTEP>, B<PTRACE_SYSEMU> ou B<PTRACE_SYSEMU_SINGLESTEP>. Si l'observé est en arrêt-distribution-signal, I<sig> est le signal à injecter (s'il est non nul). Sinon, I<sig> pourrait être ignoré (lors du redémarrage d'un observé depuis un arrêt-ptrace différent d'un arrêt-distribution-signal, il est conseillé de toujours passer 0 à I<sig>).

note: type: SS
en: Attaching and detaching
fr: Attachement et détachement

note: type: Plain text
en: A thread can be attached to the tracer using the call
fr: Un thread peut être attaché à l'observateur en utilisant l'appel

note: FIXME: Describe how to attach to a thread which is already group-stopped. type: Plain text
en: This also sends B<SIGSTOP> to this thread.  If the tracer wants this B<SIGSTOP> to have no effect, it needs to suppress it.  Note that if other signals are concurrently sent to this thread during attach, the tracer may see the tracee enter signal-delivery-stop with other signal(s) first! The usual practice is to reinject these signals until B<SIGSTOP> is seen, then suppress B<SIGSTOP> injection.  The design bug here is that a ptrace attach and a concurrently delivered B<SIGSTOP> may race and the concurrent B<SIGSTOP> may be lost.
fr: Cela envoie aussi B<SIGSTOP> à ce thread. Si l'observateur veux que B<SIGSTOP> soit sans effet, il doit le supprimer. Remarquez que si d'autres signaux sont envoyés en même temps à ce thread pendant l'attachement, l'observateur pourrait voir l'observé entrer en arrêt-distribution-signal avec d'autres signaux d'abord ! Ces signaux sont sont d'habitude réinjectés jusqu'à ce que B<SIGSTOP> soit vu, puis l'injection B<SIGSTOP> est supprimée. Le bogue de conception ici est qu'un attachement ptrace et un B<SIGSTOP> distribués en même temps peuvent entrer en compétition et le B<SIGSTOP> risque d'être perdu.

note: type: Plain text
en: Since attaching sends B<SIGSTOP> and the tracer usually suppresses it, this may cause a stray I<EINTR> return from the currently executing system call in the tracee, as described in the "signal injection and suppression" section.
fr: Puisque l'attachement envoie B<SIGSTOP> et que l'observateur le supprime normalement, cela risque de forcer le retour d'un I<EINTR> perdu de l'appel système en cours d'exécution dans l'observé, tel que c'est décrit dans la section B<Injection et suppression de signal>.

note: type: Plain text
en: The request
fr: La requête

note: type: Plain text
en: turns the calling thread into a tracee.  The thread continues to run (doesn't enter ptrace-stop).  A common practice is to follow the B<PTRACE_TRACEME> with
fr: transforme le thread appelant en observé. L'appel continue d'être exécuté (n'entre pas en arrêt-ptrace). B<PTRACE_TRACEME> est habituellement suivi avec

note: type: Plain text
en: and allow the parent (which is our tracer now) to observe our signal-delivery-stop.
fr: et permet au père (qui est maintenant l'observateur) de respecter l'arrêt-distribution-signal.

note: type: Plain text
en: If the B<PTRACE_O_TRACEFORK>, B<PTRACE_O_TRACEVFORK>, or B<PTRACE_O_TRACECLONE> options are in effect, then children created by, respectively, B<vfork>(2)  or B<clone>(2)  with the B<CLONE_VFORK> flag, B<fork>(2)  or B<clone>(2)  with the exit signal set to B<SIGCHLD>, and other kinds of B<clone>(2), are automatically attached to the same tracer which traced their parent.  B<SIGSTOP> is delivered to the children, causing them to enter signal-delivery-stop after they exit the system call which created them.
fr: Si les options B<PTRACE_O_TRACEFORK>, B<PTRACE_O_TRACEVFORK> ou B<PTRACE_O_TRACECLONE> font effet, alors les fils respectivement créés par B<vfork>(2) ou B<clone>(2) avec l'attribut B<CLONE_VFORK>, B<vfork>(2) ou B<clone>(2) avec le signal de sortie configuré à B<SIGCHLD>, et d'autres sortes de B<clone>(2), sont automatiquement attachés au même observateur qui à suivi leur père. B<SIGSTOP> est distribué aux fils, les forçant à entrer en arrêt-distribution-signal après être sortis de l'appel système qu'ils ont créé.

note: type: Plain text
en: Detaching of the tracee is performed by:
fr: Le détachement de l'observé est réalisé par :

note: type: Plain text
en: B<PTRACE_DETACH> is a restarting operation; therefore it requires the tracee to be in ptrace-stop.  If the tracee is in signal-delivery-stop, a signal can be injected.  Otherwise, the I<sig> parameter may be silently ignored.
fr: B<PTRACE_DETACH> est une opération de redémarrage ; par conséquent elle nécessite que l'observé soit en arrêt-ptrace. Si l'observé est en arrêt-distribution-signal, un signal peut être injecté. Sinon, le paramètre I<sig> pourrait être silencieusement ignoré.

note: FIXME: Describe how to detach from a group-stopped tracee so that it doesn't run, but continues to wait for SIGCONT. type: Plain text
en: If the tracee is running when the tracer wants to detach it, the usual solution is to send B<SIGSTOP> (using B<tgkill>(2), to make sure it goes to the correct thread), wait for the tracee to stop in signal-delivery-stop for B<SIGSTOP> and then detach it (suppressing B<SIGSTOP> injection).  A design bug is that this can race with concurrent B<SIGSTOP>s.  Another complication is that the tracee may enter other ptrace-stops and needs to be restarted and waited for again, until B<SIGSTOP> is seen.  Yet another complication is to be sure that the tracee is not already ptrace-stopped, because no signal delivery happens while it is\(emnot even B<SIGSTOP>.
fr: Si l'observé est en cours d'exécution quand l'observateur veut le détacher, la solution habituelle est d'envoyer B<SIGSTOP> (en utilisant B<tgkill>(2), pour s'assurer qu'il va au bon thread), d'attendre que l'observé s'arrête en arrêt-distribution-signal pour B<SIGSTOP> et ensuite de le détacher (en supprimant l'injection B<SIGSTOP>). Un bogue de conception est que l'observé pourrait entrer dans d'autres arrêts-ptrace et avoir besoin d'être redémarré et attendre encore, jusqu'à ce que B<SIGSTOP> soit vu. Encore une autre complication est de s'assurer que l'observé n'est pas déjà arrêté-ptrace, parce qu'aucune distribution de signal n'arrive tant qu'il l'est — pas même B<SIGSTOP>.

note: type: Plain text
en: If the tracer dies, all tracees are automatically detached and restarted, unless they were in group-stop.  Handling of restart from group-stop is currently buggy, but the "as planned" behavior is to leave tracee stopped and waiting for B<SIGCONT>.  If the tracee is restarted from signal-delivery-stop, the pending signal is injected.
fr: Si l'observateur meurt, tous les observés sont automatiquement détachés et redémarrés, sauf s'il étaient en arrêt-groupe. Le gestion de redémarrage depuis un arrêt-groupe est en ce moment dysfonctionnelle, mais le comportement « prévu » est de laisser les observés arrêtés et d'attendre un B<SIGCONT>. Si l'observé est redémarré depuis un arrêt-distribution-signal, le signal en attente est injecté.

note: type: SS
en: execve(2) under ptrace
fr: execve(2) sous ptrace

note: clone(2) THREAD_CLONE says: If  any  of the threads in a thread group performs an execve(2), then all threads other than the thread group leader are terminated, and the new program is executed in the thread group leader. In kernel 3.1 sources, see fs/exec.c::de_thread() type: Plain text
en: When one thread in a multithreaded process calls B<execve>(2), the kernel destroys all other threads in the process, and resets the thread ID of the execing thread to the thread group ID (process ID).  (Or, to put things another way, when a multithreaded process does an B<execve>(2), at completion of the call, it appears as though the B<execve>(2)  occurred in the thread group leader, regardless of which thread did the B<execve>(2).)  This resetting of the thread ID looks very confusing to tracers:
fr: Quand un thread de processus multithreadé appelle B<execve>(2), le noyau détruit tous les autres threads du processus, et réinitialise l'identifiant de thread du thread exécuté à l'identifiant de groupe de threads (PID) (ou, pour le présenter autrement, quand un processus multithreadé fait un B<execve>(2), à la fin de l'appel, il apparaît comme si l'B<execve>(2) s'était appliqué au leader de groupe de threads, quelque soit le thread qui a fait B<execve>(2)). Cette réinitialisation de l'identifiant de thread semble est très déroutante pour les observateurs.

note: type: Plain text
en: All other threads stop in B<PTRACE_EVENT_EXIT> stop, if the B<PTRACE_O_TRACEEXIT> option was turned on.  Then all other threads except the thread group leader report death as if they exited via B<_exit>(2)  with exit code 0.
fr: Tous les autres threads s'arrêtent en arrêt B<PTRACE_EVENT_EXIT>, si l'option B<PTRACE_O_TRACEEXIT> était activée. Alors tous les autres threads sauf le leader de groupe de threads signalent leur mort comme s'il s'étaient terminés par l'intermédiaire de B<_exit>(2) avec un code de retour 0.

note: type: Plain text
en: Then a B<PTRACE_EVENT_EXEC> stop happens, if the B<PTRACE_O_TRACEEXEC> option was turned on.
fr: Ensuite un arrêt B<PTRACE_EVENT_EXEC> arrive, si l'option B<PTRACE_O_TRACEEXEC> était activée.

note: type: Plain text
en: The execing tracee changes its thread ID while it is in the B<execve>(2).  (Remember, under ptrace, the "pid" returned from B<waitpid>(2), or fed into ptrace calls, is the tracee's thread ID.)  That is, the tracee's thread ID is reset to be the same as its process ID, which is the same as the thread group leader's thread ID.
fr: L'observé en cours d'exécution modifie son identifiant de thread pendant qu'il est dans l'B<execve>(2) (rappelez-vous que, sous ptrace, le « pid » renvoyé par B<waitpid>(2) ou fourni dans les appels ptrace, est l'identifiant de thread de l'observé). Ainsi, l'identifiant de thread de l'observé est réinitialisé pour être le même que son identifiant de processus (PID), qui est le même que l'identifiant de thread du leader de groupe de threads.

note: type: Plain text
en: If the thread group leader has reported its death by this time, it appears to the tracer that the dead thread leader "reappears from nowhere".  If the thread group leader was still alive, for the tracer this may look as if thread group leader returns from a different system call than it entered, or even "returned from a system call even though it was not in any system call".  If the thread group leader was not traced (or was traced by a different tracer), then during B<execve>(2)  it will appear as if it has become a tracee of the tracer of the execing tracee.
fr: Si le leader de groupe de threads a signalé sa mort pendant ce temps, le leader de thread mort à l'air de « revenir de nulle part » du point de vue de l'observateur. Si le leader de groupe de threads était encore en vie, cela pourrait être vu par l'observateur comme si le leader de groupe revenait d'un autre appel système que celui dans lequel il était entré, ou même « revenait d'un appel système même s'il n'y avait pas d'appel système ». Si le leader de groupe de threads n'était pas suivi (ou était suivi par un autre observateur), alors pendant B<execve>(2) il apparaîtra comme s'il était devenu un observé de l'observateur de l'observé en cours d'exécution.

note: type: Plain text
en: All of the above effects are the artifacts of the thread ID change in the tracee.
fr: Tous les effets précédents sont des artifices de la modification d'identifiant de thread de l'observé.

note: type: Plain text
en: The B<PTRACE_O_TRACEEXEC> option is the recommended tool for dealing with this situation.  It enables B<PTRACE_EVENT_EXEC> stop, which occurs before B<execve>(2)  returns.  First, it enables B<PTRACE_EVENT_EXEC>-stop, which occurs before B<execve(2)> returns.  In this stop, the tracer can use B<PTRACE_GETEVENTMSG> to retrieve the tracee's former thread ID.  (This feature was introduced in Linux 3.0).  Second, the B<PTRACE_O_TRACEEXEC> option disables legacy B<SIGTRAP> generation on B<execve>(2).
fr: L'option B<PTRACE_O_TRACEEXEC> est l'outil conseillé pour s'occuper de cette situation. Elle active l'arrêt B<PTRACE_EVENT_EXEC>, qui arrive avant le retour d'B<execve>(2). D'abord, elle  active l'arrêt B<PTRACE_EVENT_EXEC>, qui arrive avant le retour d'B<execve>(2). Dans cet arrêt, l'observateur peut utiliser B<PTRACE_GETEVENTMSG> pour récupérer l'ancien identifiant de thread de l'observé (cette fonctionnalité a été introduite avec Linux 3.0). Ensuite, l'option B<PTRACE_O_TRACEEXEC> désactive la création obsolète de B<SIGTRAP> dans B<execve>(2).

note: type: Plain text
en: When the tracer receives B<PTRACE_EVENT_EXEC> stop notification, it is guaranteed that except this tracee and the thread group leader, no other threads from the process are alive.
fr: Quand l'observé reçoit une notification d'arrêt B<PTRACE_EVENT_EXEC>, il est garanti qu'à part cet observé et le leader de groupe de threads, aucun autre thread du processus n'est en vie.

note: type: Plain text
en: On receiving the B<PTRACE_EVENT_EXEC> stop notification, the tracer should clean up all its internal data structures describing the threads of this process, and retain only one data structure\(emone which describes the single still running tracee, with
fr: Lors de la réception d'une notification d'arrêt B<PTRACE_EVENT_EXEC>, l'observateur devrait nettoyer toutes ses structures de données internes décrivant les threads de ce processus et ne garder qu'une seule structure de données — celle qui décrit l'unique observé en cours d'exécution, avec

note: type: Plain text
en:     thread ID == thread group ID == process id.
fr:     identifiant de thread == identifiant de groupe de threads == identifiant de processus.

note: type: Plain text
en: Currently, there is no way to retrieve the former thread ID of the execing tracee.  If the tracer doesn't keep track of its tracees' thread group relations, it may be unable to know which tracee execed and therefore no longer exists under the old thread ID due to a thread ID change.
fr: Deux façons permettent en ce moment de récupérer l'ancien identifiant de thread de l'observé en cours d'exécution. Si l'observé ne garde pas trace des relations de groupe de threads de ses observés, il pourrait être incapable de savoir quel observé a été exécuté et par conséquent n'existe plus sous l'ancien identifiant de thread à cause d'une modification de l'identifiant de thread.

note: type: Plain text
en: Example: two threads call B<execve>(2)  at the same time:
fr: Par exemple, soient deux threads qui appellent B<execve>(2) en même temps :

note: type: Plain text
en: *** we get syscall-entry-stop in thread 1: **
    PID1 execve("/bin/foo", "foo" E<lt>unfinished ...E<gt>
    *** we issue PTRACE_SYSCALL for thread 1 **
    *** we get syscall-entry-stop in thread 2: **
    PID2 execve("/bin/bar", "bar" E<lt>unfinished ...E<gt>
    *** we issue PTRACE_SYSCALL for thread 2 **
    *** we get PTRACE_EVENT_EXEC for PID0, we issue PTRACE_SYSCALL **
    *** we get syscall-exit-stop for PID0: **
    PID0 E<lt>... execve resumedE<gt> )             = 0
fr: *** arrêt-entrée-appel-système obtenu dans le thread 1 : **
    PID1 execve("/bin/truc", "truc" E<lt>pas terminé…E<gt>
    *** PTRACE_SYSCALL émis pour le thread 1 **
    *** arrêt-entrée-appel-système obtenu dans le thread 2 : **
    PID2 execve("/bin/bidule", "bidule" E<lt>pas terminé…E<gt>
    *** PTRACE_SYSCALL émis pour le thread 2 **
    *** PTRACE_EVENT_EXEC obtenu pour PID0, PTRACE_SYSCALL émis **
    *** arrêt-sortie-appel-système obtenu pour PID0 : **
    PID0 E<lt>… retour d'execveE<gt> )             = 0

note: type: Plain text
en: In this situation, there is no way to know which B<execve>(2)  succeeded.
fr: Dans ce cas, il est impossible de savoir quel B<execve>(2) a réussi.

note: type: Plain text
en: If the B<PTRACE_O_TRACEEXEC> option is I<not> in effect for the execing tracee, the kernel delivers an extra B<SIGTRAP> to the tracee after B<execve>(2)  returns.  This is an ordinary signal (similar to one which can be generated by I<kill -TRAP>), not a special kind of ptrace-stop.  Employing B<PTRACE_GETSIGINFO> for this signal returns I<si_code> set to 0 (I<SI_USER>).  This signal may be blocked by signal mask, and thus may be delivered (much) later.
fr: Si l'option B<PTRACE_O_TRACEEXEC> n'est I<pas> effective pour l'observé en cours d'exécution, le noyau distribue un B<SIGTRAP> supplémentaire à l'observé après le retour d'B<execve>(2). C'est un signal normal (similaire à celui qui peut être créé par I<kill -TRAP>), pas une sorte spéciale d'arrêt-ptrace. L'utilisation de B<PTRACE_GETSIGINFO> pour ce signal renvoie I<si_code> configuré à 0 (I<SI_USER>). Ce signal pourrait être bloqué par un masque de signal, et pourrait ainsi être distribué (bien) plus tard.

note: type: Plain text
en: Usually, the tracer (for example, B<strace>(1))  would not want to show this extra post-execve B<SIGTRAP> signal to the user, and would suppress its delivery to the tracee (if B<SIGTRAP> is set to B<SIG_DFL>, it is a killing signal).  However, determining I<which> B<SIGTRAP> to suppress is not easy.  Setting the B<PTRACE_O_TRACEEXEC> option and thus suppressing this extra B<SIGTRAP> is the recommended approach.
fr: Normalement, l'observé (par exemple B<strace>(1)) ne voudrait pas montrer ce signal B<SIGTRAP> post-execve supplémentaire à l'utilisateur, et voudrait supprimer sa distribution à l'observé (si B<SIGTRAP> est configuré à B<SIG_DFL>, s'est un signal tueur). Cependant, déterminer I<quel> est le B<SIGTRAP> à supprimer n'est pas simple. La configuration de l'option B<PTRACE_O_TRACEEXEC> et par conséquent la suppression du B<SIGTRAP> supplémentaire est l'approche conseillée.

note: type: SS
en: Real parent
fr: Vrai père

note: type: Plain text
en: The ptrace API (ab)uses the standard UNIX parent/child signaling over B<waitpid>(2).  This used to cause the real parent of the process to stop receiving several kinds of B<waitpid>(2)  notifications when the child process is traced by some other process.
fr: L'interface de programmation de ptrace utilise (parfois mal) la norme UNIX de signalement de père ou fils par l'intermédiaire de B<waitpid>(2). Cela a régulièrement forcé le vrai père du processus à arrêter de recevoir plusieurs sortes de notifications de B<waitpid>(2) quand le processus fils est suivi par un autre processus.

note: type: Plain text
en: Many of these bugs have been fixed, but as of Linux 2.6.38 several still exist; see BUGS below.
fr: Nombreux bogues de ce type ont été corrigés, mais il en reste encore beaucoup dans Linux 2.6.38. Consultez la section B<BOGUES> ci dessous.

note: type: Plain text
en: As of Linux 2.6.38, the following is believed to work correctly:
fr: Depuis Linux 2.6.38, ce qui suit est censé fonctionner correctement :

note: type: Plain text
en: exit/death by signal is reported first to the tracer, then, when the tracer consumes the B<waitpid>(2)  result, to the real parent (to the real parent only when the whole multithreaded process exits).  If the tracer and the real parent are the same process, the report is sent only once.
fr: l'exécution ou la mort par signal sont d'abord signalées à l'observateur, puis, quand l'observateur consomme le résultat de B<waitpid>(2), au vrai père (au vrai père seulement quand l'intégralité du processus multithreadé se termine). Si l'observateur et le vrai père sont le même processus, le signalement n'est envoyé qu'une fois.

note: type: Plain text
en: On success, B<PTRACE_PEEK*> requests return the requested data, while other requests return zero.  On error, all requests return -1, and I<errno> is set appropriately.  Since the value returned by a successful B<PTRACE_PEEK*> request may be -1, the caller must clear I<errno> before the call, and then check it afterward to determine whether or not an error occurred.
fr: Pour les requêtes B<PTRACE_PEEK*>, B<ptrace>() renvoie la valeur réclamée et zéro pour les autres requêtes, ou -1 en cas d'échec en remplissant I<errno> avec le code d'erreur. Comme la valeur renvoyée par une requête B<PTRACE_PEEK*> peut légitimement être -1, l'appelant doit effacer I<errno> avant l'appel, et ensuite le vérifier pour savoir si une erreur s'est produite.

note: type: Plain text
en: (i386 only) There was an error with allocating or freeing a debug register.
fr: (i386 seulement) Une erreur est survenue lors de l'allocation ou de la libération d'un registre de débogage.

note: type: Plain text
en: There was an attempt to read from or write to an invalid area in the tracer's or the tracee's memory, probably because the area wasn't mapped or accessible.  Unfortunately, under Linux, different variations of this fault will return B<EIO> or B<EFAULT> more or less arbitrarily.
fr: Tentative de lire ou écrire dans une zone mémoire non valable de l'observateur ou de l'observé, probablement parce que la zone n'était pas projetée ou accessible. Malheureusement sous Linux, certaines variantes de cette erreur déclencheront B<EIO> ou B<EFAULT> plus ou moins arbitrairement.

note: type: Plain text
en: An attempt was made to set an invalid option.
fr: Tentative d'utiliser une option non valable.

note: type: Plain text
en: I<request> is invalid, or an attempt was made to read from or write to an invalid area in the tracer's or the tracee's memory, or there was a word-alignment violation, or an invalid signal was specified during a restart request.
fr: La requête I<request> n'est pas valable ou une tentative de lecture ou d'écriture dans une zone non valable de mémoire de l'observateur ou de l'observé a eu lieu. Un problème d'alignement a aussi pu survenir sur une frontière de mot, ou une tentative de redémarrage en envoyant un signal non valable.

note: type: Plain text
en: The specified process cannot be traced.  This could be because the tracer has insufficient privileges (the required capability is B<CAP_SYS_PTRACE>); unprivileged processes cannot trace processes that they cannot send signals to or those running set-user-ID/set-group-ID programs, for obvious reasons.  Alternatively, the process may already be being traced, or (on kernels before 2.6.26) be B<init>(8)  (PID 1).
fr: Le processus indiqué ne peut pas être suivi. Cela peut être dû à un manque de privilège de l'observateur (la capacité nécessaire est B<CAP_SYS_PTRACE>). Les processus non privilégiés ne peuvent pas suivre les processus auxquels ils ne peuvent envoyer de signal, ou ceux qui s'exécutent Set-UID/Set-GID. En outre, le processus visé peut être déjà suivi, ou (sur les noyaux antérieurs à 2.6.26) être B<init>(8) (le processus numéro 1).

note: type: Plain text
en: The specified process does not exist, or is not currently being traced by the caller, or is not stopped (for requests that require a stopped tracee).
fr: Le processus indiqué n'existe pas, ou n'est pas suivi par l'appelant, ou n'est pas arrêté (pour les requêtes qui ont besoin d'un observé arrêté).

note: type: Plain text
en: SVr4, 4.3BSD.
fr: SVr4, BSD\ 4.3.

note: type: Plain text
en: Although arguments to B<ptrace>()  are interpreted according to the prototype given, glibc currently declares B<ptrace>()  as a variadic function with only the I<request> argument fixed.  This means that unneeded trailing arguments may be omitted, though doing so makes use of undocumented B<gcc>(1)  behavior.
fr: Bien que les arguments de B<ptrace>() soient interprétés comme dans le prototype plus haut, la bibliothèque glibc déclare B<ptrace> comme une fonction variadique où seul l'argument I<request> est fixé. Ceci signifie que les arguments finaux inutiles peuvent être omis, bien que cela utilise un comportement non documenté de B<gcc>(1).

note: See commit 00cd5c37afd5f431ac186dd131705048c0a11fdb type: Plain text
en: In Linux kernels before 2.6.26, B<init>(8), the process with PID 1, may not be traced.
fr: Dans les noyaux antérieurs à 2.6.26, B<init>(8), le processus numéro 1, ne peut pas être suivi.

note: See http://lkml.org/lkml/2008/5/8/375 type: Plain text
en: The layout of the contents of memory and the USER area are quite operating-system- and architecture-specific.  The offset supplied, and the data returned, might not entirely match with the definition of I<struct user>.
fr: La disposition du contenu de la mémoire et de la zone USER dépendent du système d'exploitation et de l'architecture. Le décalage fourni et les données renvoyées peuvent ne pas correspondre entièrement avec la définition d'une structure I<struct user>.

note: type: Plain text
en: The size of a "word" is determined by the operating-system variant (e.g., for 32-bit Linux it is 32 bits, etc.).
fr: La taille d'un mot («\ word\ ») est déterminée par la version du système d'exploitation (par exemple 32 bits pour Linux 32 bits, etc.)

note: type: Plain text
en: This page documents the way the B<ptrace>()  call works currently in Linux.  Its behavior differs noticeably on other flavors of UNIX.  In any case, use of B<ptrace>()  is highly specific to the operating system and architecture.
fr: Cette page documente le fonctionnement actuel de B<ptrace>() sous Linux. Celui-ci peut varier sensiblement sur d'autres types d'UNIX. De toute façon, l'utilisation de B<ptrace>() dépend fortement de l'architecture et du système d'exploitation.

note: type: Plain text
en: On hosts with 2.6 kernel headers, B<PTRACE_SETOPTIONS> is declared with a different value than the one for 2.4.  This leads to applications compiled with 2.6 kernel headers failing when run on 2.4 kernels.  This can be worked around by redefining B<PTRACE_SETOPTIONS> to B<PTRACE_OLDSETOPTIONS>, if that is defined.
fr: Sur les machines ayant des en-têtes du noyau 2.6, B<PTRACE_SETOPTIONS> est déclaré avec une valeur différente de celle du noyau 2.4. De ce fait, les applications compilées avec des en-têtes du noyau 2.6 ne peuvent pas s'exécuter sous des noyaux 2.4. Il est possible de contourner cette difficulté en redéfinissant B<PTRACE_SETOPTIONS> à B<PTRACE_OLDSETOPTIONS>, si cette dernière constante est définie.

note: type: Plain text
en: Group-stop notifications are sent to the tracer, but not to real parent.  Last confirmed on 2.6.38.6.
fr: Les notifications d'arrêt-groupe sont envoyées à l'observateur, mais pas au vrai père. C'était encore vrai en 2.6.38.6.

note: Note from Denys Vlasenko: Here "exits" means any kind of death - _exit, exit_group, signal death. Signal death and exit_group cases are trivial, though: since signal death and exit_group kill all other threads too, "until all other threads exit" thing happens rather soon in these cases. Therefore, o
en: If a thread group leader is traced and exits by calling B<_exit>(2), a B<PTRACE_EVENT_EXIT> stop will happen for it (if requested), but the subsequent B<WIFEXITED> notification will not be delivered until all other threads exit.  As explained above, if one of other threads calls B<execve>(2), the death of the thread group leader will I<never> be reported.  If the execed thread is not traced by this tracer, the tracer will never know that B<execve>(2)  happened.  One possible workaround is to B<PTRACE_DETACH> the thread group leader instead of restarting it in this case.  Last confirmed on 2.6.38.6.
fr: Si un leader de groupe de threads est suivi et existe en appelant B<_exit>(2), un arrêt B<PTRACE_EVENT_EXIT> lui arrivera (si réclamé), mais la notification B<WIFEXITED> suivante ne sera pas distribuée avant la fin de tous les autres threads. Comme expliqué précédemment, si un des autres threads appelle B<execve>(2), la mort du leader de groupe de threads ne sera I<jamais> signalée. Si le thread exécuté n'est pas suivi par cet observateur, l'observé ne saura jamais qu'B<execve>(2) est arrivé. Un contournement possible est de B<PTRACE_DETACH>er le leader de groupe de threads au lieu de le redémarrer dans ce cas. C'était encore vrai en 2.6.38.6.

note: type: Plain text
en: A B<SIGKILL> signal may still cause a B<PTRACE_EVENT_EXIT> stop before actual signal death.  This may be changed in the future; B<SIGKILL> is meant to always immediately kill tasks even under ptrace.  Last confirmed on 2.6.38.6.
fr: Un signal B<SIGKILL> pourrait encore provoquer un arrêt B<PTRACE_EVENT_EXIT> avant une véritable mort du signal. Cela pourrait évoluer à l'avenir. B<SIGKILL> est supposé tuer immédiatement les tâches même sous ptrace. C'était encore vrai en 2.6.38.6.

note: type: TH
en: 2010-06-16
fr: 16 juin 2010

note: type: Plain text
en: quotactl - manipulate disk quotas
fr: quotactl - Manipuler les quotas de disque

note: type: Plain text
en: The quota system can be used to set per-user and per-group limits on the amount of disk space used on a file system.  For each user and/or group, a soft limit and a hard limit can be set for each file system.  The hard limit can't be exceeded.  The soft limit can be exceeded, but warnings will ensue.  Moreover, the user can't exceed the soft limit for more than one week (by default) at a time; after this time, the soft limit counts as a hard limit.
fr: Le système de quotas permet de fixer une limite sur la quantité d'espace disque utilisé sur un système de fichiers, qui peut être mise par utilisateur ou par groupe. Pour chaque utilisateur ou groupe, une limite souple et une limite impérative peuvent être fixées sur chaque système de fichiers. La limite impérative ne peut pas être dépassée. La limite souple peut être dépassée, mais des avertissements s'en suivront. De plus, l'utilisateur ne peut pas dépasser une limite souple pendant plus d'une semaine (par défaut) d'affilée. Une fois la semaine écoulée, la limite souple devient une limite impérative.

note: type: Plain text
en: The B<quotactl>()  call manipulates disk quotas.  The I<cmd> argument indicates a command to be applied to the user or group ID specified in I<id>.  To initialize the I<cmd> argument, use the I<QCMD(subcmd, type)> macro.  The I<type> value is either B<USRQUOTA>, for user quotas, or B<GRPQUOTA>, for group quotas.  The I<subcmd> value is described below.
fr: L'appel B<quotactl>() manipule ces quotas. L'argument I<cmd> indique une commande à appliquer à l'identifiant d'utilisateur ou de groupe spécifié dans I<id>. Pour initialiser l'argument I<cmd>, utilisez la macro B<QCMD(>I<subcmd>B<,>I<type>B<)>. La valeur I<type> vaut soit B<USRQUOTA> (pour les quotas d'utilisateur), soit B<GRPQUOTA> (pour les quotas de groupe). La valeur de I<subcmd> est décrite plus bas.

note: type: Plain text
en: The I<special> argument is a pointer to a null-terminated string containing the pathname of the (mounted) block special device for the file system being manipulated.
fr: L'argument I<special> est un pointeur vers une chaîne de caractères (terminée par le caractère nul) contenant le chemin du périphérique spécial en mode bloc pour le système de fichiers à manipuler.

note: type: Plain text
en: The I<addr> argument is the address of an optional, command-specific, data structure that is copied in or out of the system.  The interpretation of I<addr> is given with each command below.
fr: L'argument I<addr> est l'adresse d'une structure de données optionnelle, spécifique à la commande, qui est copiée sur ou depuis le système. L'interprétation d'I<addr> est donnée avec chaque commande ci-dessous.

note: type: Plain text
en: The I<subcmd> value is one of the following:
fr: La valeur de I<subcmd> prend une de ces valeurs\ :

note: type: Plain text
en: Turn on quotas for a file system.  The I<id> argument is the identification number of the quota format to be used.  Currently, there are three supported quota formats:
fr: Activer les quotas pour un système de fichiers. L'argument I<id> est le numéro d'identification du format de quotas à utiliser. Il existe actuellement trois formats possibles de quotas :

note: type: Plain text
en: The original quota format.
fr: Le format original de quotas.

note: type: Plain text
en: The standard VFS v0 quota format, which can handle 32-bit UIDs and GIDs and quota limits up to 2^42 bytes and 2^32 inodes.
fr: Le standard VFS v0 format de quotas, qui peut manipuler des identifiants d'utilisateur et de groupe sur 32 bits, et des limites de quotas jusqu'à 2^42 octets et 2^32 inœuds.

note: type: Plain text
en: A quota format that can handle 32-bit UIDs and GIDs and quota limits of 2^64 bytes and 2^64 inodes.
fr: Un format de quotas qui peut manipuler des identifiants d'utilisateur et de groupe sur 32 bits, et des limites de quotas jusqu'à 2^64 octets et 2^64 inœuds.

note: type: Plain text
en: The I<addr> argument points to the pathname of a file containing the quotas for the file system.  The quota file must exist; it is normally created with the B<quotacheck>(8)  program.  This operation requires privilege (B<CAP_SYS_ADMIN>).
fr: L'argument I<addr> pointe sur le chemin d'un fichier contenant les quotas du système de fichiers. Le fichier de quotas doit exister ; il est habituellement créé par la commande B<quotacheck>(8). Cette opération nécessite le privilège B<CAP_SYS_ADMIN>.

note: type: Plain text
en: Turn off quotas for a file system.  The I<addr> and I<id> arguments are ignored.  This operation requires privilege (B<CAP_SYS_ADMIN>).
fr: Désactiver les quotas pour un système de fichiers. Les arguments I<addr> et I<id> sont ignorés. Cette opération nécessite le privilège B<CAP_SYS_ADMIN>.

note: type: Plain text
en: Get disk quota limits and current usage for user or group I<id>.  The I<addr> argument is a pointer to a I<dqblk> structure defined in I<E<lt>sys/quota.hE<gt>> as follows:
fr: Obtenir les limites actuelles et l'utilisation courante de l'espace disque pour l'utilisateur ou le groupe I<id>. L'argument I<addr> est un pointeur sur une structure I<dqblk> définie dans I<E<lt>sys/quota.hE<gt>> comme ceci :

note: type: Plain text
en: /* uint64_t is an unsigned 64-bit integer;
       uint32_t is an unsigned 32-bit integer */
fr: /* uint64_t est un entier non signé 64 bits
       uint32_t est un entier non signé 32 bits */

note: type: Plain text
en: struct dqblk {          /* Definition since Linux 2.4.22 */
        uint64_t dqb_bhardlimit;   /* absolute limit on disk
                                      quota blocks alloc */
        uint64_t dqb_bsoftlimit;   /* preferred limit on
                                      disk quota blocks */
        uint64_t dqb_curspace;     /* current quota block
                                      count */
        uint64_t dqb_ihardlimit;   /* maximum number of
                                      allocated inodes */
        uint64_t dqb_isoftlimit;   /* preferred inode limit */
        uint64_t dqb_curinodes;    /* current number of
                                      allocated inodes */
        uint64_t dqb_btime;        /* time limit for excessive
                                      disk use */
        uint64_t dqb_itime;        /* time limit for excessive
                                      files */
        uint32_t dqb_valid;        /* bit mask of QIF_*
                                      constants */
    };
fr: struct dqblk {          /* Definition depuis Linux 2.4.22 */
        uint64_t dqb_bhardlimit;   /* limite impérative sur le
                                      nombre de blocs disques */
        uint64_t dqb_bsoftlimit;   /* limite douce sur le nombre
                                      de blocs disques */
        uint64_t dqb_curspace;     /* nombre de blocs actuel dans
                                      le quota */
        uint64_t dqb_ihardlimit;   /* nombre maximal d'inœuds
                                      alloués */
        uint64_t dqb_isoftlimit;   /* limite douce d'inœuds */
        uint64_t dqb_curinodes;    /* nombre d'inœuds actuellement
                                      alloués */
        uint64_t dqb_btime;        /* limite de temps pour utilisation
                                      abusive du disque */
        uint64_t dqb_itime;        /* limite de temps pour utilisation
                                      des fichiers */
        uint32_t dqb_valid;        /* masque de bit des constantes
                                      QIF_* */
    };

note: type: Plain text
en: /* Flags in dqb_valid that indicate which fields in
       dqblk structure are valid. */
fr: /* Attributs de dqb_valid qui indiquent quels champs
       de la structure dqblk sont valables. */

note: type: Plain text
en: The I<dqb_valid> field is a bit mask that is set to indicate the entries in the I<dqblk> structure that are valid.  Currently, the kernel fills in all entries of the I<dqblk> structure and marks them as valid in the I<dqb_valid> field.  Unprivileged users may retrieve only their own quotas; a privileged user (B<CAP_SYS_ADMIN>)  can retrieve the quotas of any user.
fr: Le champ I<dqb_valid> est un masque de bit qui permet d'indiquer quelles entrées de la structure sont valables. Actuellement, le noyau remplit toutes les entrées de la structure I<dqblk> et les marque comme valables dans le champ I<dqb_valid>. Les utilisateurs non privilégiés ne peuvent connaitre que leurs propres quotas ; un utilisateur avec le privilège B<CAP_SYS_ADMIN> peut connaitre les quotas de tous les utilisateurs.

note: type: Plain text
en: Set quota information for user or group I<id>, using the information supplied in the I<dqblk> structure pointed to by I<addr>.  The I<dqb_valid> field of the I<dqblk> structure indicates which entries in the structure have been set by the caller.  This operation supersedes the B<Q_SETQLIM> and B<Q_SETUSE> operations in the previous quota interfaces.  This operation requires privilege (B<CAP_SYS_ADMIN>).
fr: Définir les informations de quotas pour l'utilisateur ou le groupe I<id>, en utilisant les informations fournies par la structure I<dqblk> dont l'adresse est contenue dans I<addr>. Le champ I<dqb_valid> de la structure I<dqblk> indique quelles entrées de la structure ont été définies par l'appelant. Cette opération remplace les opérations B<Q_SETQLIM> et B<Q_SETUSE> de l'interface antérieure de quotas. Cette opération nécessite le privilège B<CAP_SYS_ADMIN>.

note: type: Plain text
en: Get information (like grace times) about quotafile.  The I<addr> argument should be a pointer to a I<dqinfo> structure.  This structure is defined in I<E<lt>sys/quota.hE<gt>> as follows:
fr: Obtenir les limites actuelles et l'utilisation courante de l'espace disque. L'argument I<addr> est un pointeur sur une structure dqblk (définie dans I<E<lt>sys/quota.hE<gt>>).

note: type: Plain text
en: struct dqinfo {         /* Defined since kernel 2.4.22 */
        uint64_t dqi_bgrace;    /* Time before block soft limit
                                   becomes hard limit */
fr: struct dqinfo {          /* Définie depuis le noyau 2.4.22 */
        uint64_t dqi_bgrace; /* Temps avant qu'une limite douce sur
                                les blocs ne devienne impérative */

note: type: Plain text
en:     uint64_t dqi_igrace;    /* Time before inode soft limit
                                   becomes hard limit */
        uint32_t dqi_flags;     /* Flags for quotafile
                                   (DQF_*) */
        uint32_t dqi_valid;
    };
fr:     uint64_t dqi_igrace;    /* Temps avant qu'une limite douce sur
                                   les inœuds ne devienne impérative */
        uint32_t dqi_flags;     /* Attributs pour le fichier de quotas
                                   (DQF_*) */
        uint32_t dqi_valid;
    };

note: type: Plain text
en: /* Bits for dqi_flags */
fr: /* Bits pour dqi_flags */

note: type: Plain text
en: /* Quota format QFMT_VFS_OLD */
fr: /* Format de quota QFMT_VFS_OLD */

note: type: Plain text
en: #define V1_DQF_RSQUASH	1   /* Root squash enabled */
fr: #define V1_DQF_RSQUASH	1   /* Activer « root squash » */

note: type: Plain text
en: /* Other quota formats have no dqi_flags bits defined */
fr: /* Les autres formats de quotas n'ont pas de bits dqi_flags définis */

note: type: Plain text
en: /* Flags in dqi_valid that indicate which fields in
       dqinfo structure are valid. */
fr: /* Attributs de dqi_valid qui indiquent quels champs
       de la structure dqinfo sont valables. */

note: type: Plain text
en: The I<dqi_valid> field in the I<dqinfo> structure indicates the entries in the structure that are valid.  Currently, the kernel fills in all entries of the I<dqinfo> structure and marks them all as valid in the I<dqi_valid> field.  The I<id> argument is ignored.
fr: Le champ I<dqi_valid> de la structure I<dqinfo> indique les entrées de la structure qui sont valables. Le noyau remplit actuellement toutes les entrées de la structure I<dqinfo> et les marque comme étant valables dans le champ I<dqi_valid>. L'argument I<id> est ignoré.

note: type: Plain text
en: Set information about quotafile.  The I<addr> argument should be a pointer to a I<dqinfo> structure.  The I<dqi_valid> field of the I<dqinfo> structure indicates the entries in the structure that have been set by the caller.  This operation supersedes the B<Q_SETGRACE> and B<Q_SETFLAGS> operations in the previous quota interfaces.  The I<id> argument is ignored.  This operation requires privilege (B<CAP_SYS_ADMIN>).
fr: Définir les informations au sujet du fichier de quotas. L'argument I<addr> devrait être un pointeur vers une structure I<dqinfo>. Le champ I<dqi_valid> de la structure I<dqinfo> indique quelles entrées de la structure ont été définies par l'appelant. Cette opération remplace les opérations B<Q_SETGRACE> et B<Q_SETFLAGS> de l'interface antérieure de quotas. L'argument I<id> est ignoré. Cette opération nécessite le privilège B<CAP_SYS_ADMIN>.

note: type: Plain text
en: Get quota format used on the specified file system.  The I<addr> argument should be a pointer to a 4-byte buffer where the format number will be stored.
fr: Obtenir le format de quotas utilisé sur le système de fichiers spécifié. L'argument I<addr> est un pointeur sur un tampon de 4 octets qui contient le numéro du format.

note: type: Plain text
en: Update the on-disk copy of quota usages for a file system.  If I<special> is NULL, then all file systems with active quotas are sync'ed.  The I<addr> and I<id> arguments are ignored.
fr: Met à jour la copie sur disque de l'utilisation des quotas sur un système de fichiers. Si I<special> vaut NULL, alors tous les systèmes de fichiers avec des quotas activés sont synchronisés. Les arguments I<addr> et I<id> sont ignorés.

note: Q_GETSTATS was removed in kernel 2.4.22. type: Plain text
en: Get statistics and other generic information about the quota subsystem.  The I<addr> argument should be a pointer to a I<dqstats> structure in which data should be stored.  This structure is defined in I<E<lt>sys/quota.hE<gt>.> The I<special> and I<id> arguments are ignored.  This operation is obsolete and not supported by recent kernels.  Files in I</proc/sys/fs/quota/> carry the information instead.
fr: Récupère des statistiques et d'autres informations génériques sur le sous-système de quotas. L'argument I<addr> doit être un pointeur sur une structure I<dqstats> dans laquelle les données seront stockées. Cette structure est définie dans I<E<lt>sys/quota.hE<gt>>. Les arguments I<special> et I<id> sont ignorés. Cette opération est obsolète et n'est plus acceptée par les noyaux récents ; elle est remplacée par les fichiers dans I</proc/sys/fs/quota/>, qui contiennent les informations.

note: type: Plain text
en: For XFS file systems making use of the XFS Quota Manager (XQM), the above commands are bypassed and the following commands are used:
fr: Pour des systèmes de fichiers XFS qui utilisent le gestionnaire de quotas XFS (I<XFS Quota Manager>, ou XQM), les commandes ci-dessus doivent être remplacées par les commandes suivantes :

note: type: Plain text
en: Turn on quotas for an XFS file system.  XFS provides the ability to turn on/off quota limit enforcement with quota accounting.  Therefore, XFS expects I<addr> to be a pointer to an I<unsigned int> that contains either the flags B<XFS_QUOTA_UDQ_ACCT> and/or B<XFS_QUOTA_UDQ_ENFD> (for user quota), or B<XFS_QUOTA_GDQ_ACCT> and/or B<XFS_QUOTA_GDQ_ENFD> (for group quota), as defined in I<E<lt>xfs/xqm.hE<gt>>.  This operation requires privilege (B<CAP_SYS_ADMIN>).
fr: Activer les quotas sur un système de fichiers XFS. XFS permet d'activer et désactiver le renforcement des limites avec la gestion des quotas. Par conséquent, XFS attend qu'I<addr> soit un pointeur sur un I<unsigned int> qui contient soit les attributs B<XFS_QUOTA_UDQ_ACCT> et/ou B<XFS_QUOTA_UDQ_ENFD> (pour les quotas d'utilisateur), ou B<XFS_QUOTA_GDQ_ACCT> et/ou B<XFS_QUOTA_GDQ_ENFD> (pour les quotas de groupe), comme défini dans I<E<lt>xfs/xqm.hE<gt>>. Cette opération nécessite le privilège B<CAP_SYS_ADMIN>.

note: type: Plain text
en: Turn off quotas for an XFS file system.  As with B<Q_QUOTAON>, XFS file systems expect a pointer to an I<unsigned int> that specifies whether quota accounting and/or limit enforcement need to be turned off.  This operation requires privilege (B<CAP_SYS_ADMIN>).
fr: Désactiver les quotas pour un système de fichiers XFS. Comme pour B<Q_QUOTAON>, le système de fichier XFS attend un pointeur vers un I<unsigned int> qui spécifie si le décompte des quotas et/ou le renforcement des limites doit être désactivé. Cette opération nécessite le privilège B<CAP_SYS_ADMIN>.

note: type: Plain text
en: Get disk quota limits and current usage for user I<id>.  The I<addr> argument is a pointer to an I<fs_disk_quota> structure (defined in I<E<lt>xfs/xqm.hE<gt>>).  Unprivileged users may retrieve only their own quotas; a privileged user (B<CAP_SYS_ADMIN>)  may retrieve the quotas of any user.
fr: Obtenir les limites actuelles et l'utilisation courante de l'espace disque pour l'utilisateur I<id>. L'argument I<addr> est un pointeur sur une structure I<fs_disk_quota> (définie dans I<E<lt>xfs/xqm.hE<gt>>). Les utilisateurs non privilégiés ne peuvent connaitre que leurs propres quotas ; un utilisateur avec le privilège B<CAP_SYS_ADMIN> peut connaitre les quotas de tous les utilisateurs.

note: type: Plain text
en: Set disk quota limits for user I<id>.  The I<addr> argument is a pointer to an I<fs_disk_quota> structure (defined in I<E<lt>xfs/xqm.hE<gt>>).  This operation requires privilege (B<CAP_SYS_ADMIN>).
fr: Définir les informations de quotas pour l'utilisateur I<id>. L'argument I<addr> contient un pointeur vers une structure I<fs_disk_quota> (définie dans I<E<lt>xfs/xqm.hE<gt>>). Cette opération nécessite le privilège B<CAP_SYS_ADMIN>.

note: type: Plain text
en: Returns an I<fs_quota_stat> structure containing XFS file system specific quota information.  This is useful for finding out how much space is used to store quota information, and also to get quotaon/off status of a given local XFS file system.
fr: Renvoie une structure I<fs_quota_stat> contenant des informations de quotas spécifiques au système de fichiers XFS. Ceci est utile pour savoir combien d'espace est utilisé pour stocker les informations sur les quotas, ainsi que pour connaitre l'état activé ou non des quotas d'un système de fichiers local XFS spécifique.

note: type: Plain text
en: Free the disk space taken by disk quotas.  Quotas must have already been turned off.
fr: Libère l'espace disque pris par les quotas sur le disque. Les quotas doivent avoir été désactivés au préalable.

note: type: Plain text
en: There is no command equivalent to B<Q_SYNC> for XFS since B<sync>(1)  writes quota information to disk (in addition to the other file system metadata that it writes out).
fr: Il n'existe pas de commande équivalente à B<Q_SYNC> pour XFS puisque B<sync>(1)  écrit les informations de quotas sur le disque (en plus des autres méta-données du système de fichiers qui sont écrits sur le disque).

note: type: SH
en: RETURN VALUES
fr: VALEURS RENVOYÉES

note: type: Plain text
en: On success, B<quotactl>()  returns 0; on error -1 is returned, and I<errno> is set to indicate the error.
fr: L'appel renvoie zéro s'il réussit, ou -1 s'il échoue auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: I<addr> or I<special> is invalid.
fr: I<addr> ou I<special> n'est pas valable.

note: type: Plain text
en: I<cmd> or I<type> is invalid.
fr: I<cmd> ou I<type> n'est pas valable.

note: type: Plain text
en: The file specified by I<special> or I<addr> does not exist.
fr: Le fichier spécifié par I<special> ou I<addr> n'existe pas.

note: type: Plain text
en: The kernel has not been compiled with the B<CONFIG_QUOTA> option.
fr: Le noyau a été compilé sans l'option B<CONFIG_QUOTA>.

note: type: Plain text
en: I<special> is not a block device.
fr: I<special> n'est pas un périphérique bloc.

note: type: Plain text
en: The caller lacked the required privilege (B<CAP_SYS_ADMIN>)  for the specified operation.
fr: L'appelant ne possède pas le privilège nécessaire (B<CAP_SYS_ADMIN>)  pour l'opération demandée.

note: type: Plain text
en: No disk quota is found for the indicated user.  Quotas have not been turned on for this file system.
fr: Aucun quota de disque n'est imposé pour l'utilisateur spécifié. Les quotas n'ont pas été activés sur ce système de fichiers.

note: type: Plain text
en: If I<cmd> is B<Q_SETQUOTA>, B<quotactl>()  may also set I<errno> to:
fr: Si I<cmd> vaut B<Q_SETQUOTA>, B<quotactl>() peut aussi définir I<errno> ainsi :

note: type: Plain text
en: Specified limits are out of range allowed by quota format.
fr: Les limites spécifiées sont en dehors de l'intervalle autorisé for le format de quotas.

note: type: Plain text
en: If I<cmd> is B<Q_QUOTAON>, B<quotactl>()  may also set I<errno> to:
fr: Si I<cmd> vaut B<Q_QUOTAON>, B<quotactl>() peut aussi définir I<errno> ainsi :

note: type: Plain text
en: The quota file pointed to by I<addr> exists, but is not a regular file; or, the quota file pointed to by I<addr> exists, but is not on the file system pointed to by I<special>.
fr: Le fichier de quotas pointé par I<addr> existe, mais n'est pas un fichier normal ; ou alors, le fichier de quotas pointé par I<addr> existe, mais n'est pas dans le système de fichiers pointé par I<special>.

note: type: Plain text
en: B<Q_QUOTAON> attempted, but another B<Q_QUOTAON> had already been performed.
fr: Tentative de B<Q_QUOTAON>, mais un autre B<Q_QUOTAON> a déjà été réalisé.

note: type: Plain text
en: The quota file is corrupted.
fr: Le fichier de quotas est corrompu.

note: type: Plain text
en: Specified quota format was not found.
fr: Le format de quotas spécifié n'a pas été trouvé.

note: type: TH
en: 2011-09-14
fr: 14 septembre 2011

note: type: Plain text
en: sendfile - transfer data between file descriptors
fr: sendfile - Transfert de données entre descripteurs de fichier

note: type: Plain text
en: B<sendfile>()  copies data between one file descriptor and another.  Because this copying is done within the kernel, B<sendfile>()  is more efficient than the combination of B<read>(2)  and B<write>(2), which would require transferring data to and from user space.
fr: B<sendfile>() copie des données entre deux descripteurs de fichier. Comme la copie est assurée à l'intérieur du noyau, B<sendfile>() ne perd pas de temps à transférer des données entre l'espace noyau et l'espace utilisateur, et est donc plus efficace que la combinaison B<read>(2)/B<write>(2).

note: type: Plain text
en: I<in_fd> should be a file descriptor opened for reading and I<out_fd> should be a descriptor opened for writing.
fr: I<in_fd> doit être un descripteur de fichier ouvert en lecture, et I<out_fd> un descripteur ouvert en écriture.

note: type: Plain text
en: If I<offset> is not NULL, then it points to a variable holding the file offset from which B<sendfile>()  will start reading data from I<in_fd>.  When B<sendfile>()  returns, this variable will be set to the offset of the byte following the last byte that was read.  If I<offset> is not NULL, then B<sendfile>()  does not modify the current file offset of I<in_fd>; otherwise the current file offset is adjusted to reflect the number of bytes read from I<in_fd>.
fr: Si I<offset> n'est pas NULL, c'est un pointeur sur une variable contenant la tête de lecture (Ndt\ : file offset) à partir de laquelle B<sendfile>() commencera la lecture dans I<in_fd>. Lorsque B<sendfile>() se termine, la variable est remplie avec la position de l'octet immédiatement après le dernier octet lu. Si I<offset> n'est pas NULL, B<sendfile>() ne modifie pas la position courante dans le fichier I<in_fd>\ ; autrement, la position courante de la tête de lecture est ajustée pour refléter le nombre d'octets lus à partir de I<in_fd>.

note: type: Plain text
en: If I<offset> is NULL, then data will be read from I<in_fd> starting at the current file offset, and the file offset will be updated by the call.
fr: Si I<offset> est NULL, les données sont lues dans I<in_fd> à partir de la position courante de la tête de lecture, et celle-ci sera ajustée par l'appel.

note: type: Plain text
en: I<count> is the number of bytes to copy between the file descriptors.
fr: L'argument I<count> est le nombre d'octets à copier entre les descripteurs de fichiers.

note: type: Plain text
en: The I<in_fd> argument must correspond to a file which supports B<mmap>(2)-like operations (i.e., it cannot be a socket).
fr: L'argument I<in_fd> doit correspondre à un fichier prenant en charge les opérations de type B<mmap>(2), et ne peut donc pas être une socket.

note: type: Plain text
en: In Linux kernels before 2.6.33, I<out_fd> must refer to a socket.  Since Linux 2.6.33 it can be any file.  If it is a regular file, then B<sendfile>()  changes the file offset appropriately.
fr: Jusqu'à la version 2.6.33 de Linux, I<out_fd> doit correspondre à une socket. Depuis la version 2.6.33 de Linux, ce peut être n'importe quel fichier. Si c'est un fichier normal, B<sendfile>() modifie la position de tête de lecture en conséquence.

note: type: Plain text
en: If the transfer was successful, the number of bytes written to I<out_fd> is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: Si le transfert a réussi, le nombre d'octets écrits dans I<out_fd> est renvoyé. Sinon, B<sendfile>() renvoie -1, et I<errno> est configuré.

note: type: Plain text
en: Nonblocking I/O has been selected using B<O_NONBLOCK> and the write would block.
fr: L'écriture est non bloquante (attribut B<O_NONBLOCK> du descripteur), et l'opération devrait bloquer.

note: type: Plain text
en: The input file was not opened for reading or the output file was not opened for writing.
fr: Le fichier d'entrée n'est pas ouvert en lecture, ou celui de sortie en écriture.

note: type: Plain text
en: Bad address.
fr: Un pointeur se trouve en dehors de l'espace d'adressage.

note: type: Plain text
en: Descriptor is not valid or locked, or an B<mmap>(2)-like operation is not available for I<in_fd>.
fr: Le descripteur est invalide ou verrouillé, ou une opération de type B<mmap>(2) n'est pas disponible sur I<in_fd>.

note: type: Plain text
en: Unspecified error while reading from I<in_fd>.
fr: Erreur pendant la lecture depuis I<in_fd>.

note: type: Plain text
en: Insufficient memory to read from I<in_fd>.
fr: Mémoire insuffisante pour lire depuis I<in_fd>.

note: type: Plain text
en: B<sendfile>()  is a new feature in Linux 2.2.  The include file I<E<lt>sys/sendfile.hE<gt>> is present since glibc 2.1.
fr: L'appel système B<sendfile>() est une nouveauté de Linux 2.2. Le fichier d'en-tête I<E<lt>sys/sendfile.hE<gt>> est présent depuis la glibc 2.1.

note: type: Plain text
en: Not specified in POSIX.1-2001, or other standards.
fr: Pas spécifié dans POSIX.1-2001, ni dans d'autres normes.

note: type: Plain text
en: Other UNIX systems implement B<sendfile>()  with different semantics and prototypes.  It should not be used in portable programs.
fr: D'autres systèmes UNIX implémentent B<sendfile>() avec d'autres sémantiques, et d'autres prototypes. Il ne faut pas l'utiliser dans un programme portable.

note: type: Plain text
en: If you plan to use B<sendfile>()  for sending files to a TCP socket, but need to send some header data in front of the file contents, you will find it useful to employ the B<TCP_CORK> option, described in B<tcp>(7), to minimize the number of packets and to tune performance.
fr: Si vous voulez utiliser B<sendfile>() pour envoyer un fichier au travers d'une socket TCP, tout en le précédant de données d'en-tête, voyez l'option B<TCP_CORK> de B<tcp>(7) pour minimiser le nombre de paquets, et optimiser les performances.

note: type: Plain text
en: In Linux 2.4 and earlier, I<out_fd> could also refer to a regular file, and B<sendfile>()  changed the current offset of that file.
fr: Sous Linux 2.4 et précédents, I<out_fd> pouvait aussi correspondre à un fichier ordinaire, et B<sendfile>() modifiait la position courante dans ce fichier.

note: type: Plain text
en: The original Linux B<sendfile>()  system call was not designed to handle large file offsets.  Consequently, Linux 2.4 added B<sendfile64>(), with a wider type for the I<offset> argument.  The glibc B<sendfile>()  wrapper function transparently deals with the kernel differences.
fr: L'appel système B<sendfile>() original de Linux ne permettait pas de gérer les positions dans les gros fichiers. En conséquence, Linux 2.4 a ajouté B<sendfile64>(), avec un type élargi pour le paramètre I<offset>. La fonction B<sendfile>() de la glibc qui l'encapsule gère de manière transparente ces différences entre noyaux.

note: type: Plain text
en: Applications may wish to fall back to B<read>(2)/B<write>(2)  in the case where B<sendfile>()  fails with B<EINVAL> or B<ENOSYS>.
fr: Les applications peuvent se rabattre sur B<read>(2)/B<write>(2) au cas où B<sendfile>() échoue avec B<EINVAL> ou B<ENOSYS>.

note: type: Plain text
en: The Linux-specific B<splice>(2)  call supports transferring data between arbitrary files (e.g., a pair of sockets).
fr: L'appel B<splice>(2) spécifique à Linux gère le transfert de données entre fichiers arbitraires (par exemple entre deux sockets).

note: type: TH
en: 2004-09-10
fr: 10 septembre 2004

note: type: Plain text
en: set_tid_address - set pointer to thread ID
fr: set_tid_address - Positionner un pointeur vers un identifiant de thread (TID)

note: type: Plain text
en: The kernel keeps for each process two values called I<set_child_tid> and I<clear_child_tid> that are NULL by default.
fr: Le noyau conserve, pour chaque processus, deux valeurs nommées I<set_child_tid> et I<clear_child_tid> qui sont nulles par défaut.

note: type: Plain text
en: If a process is started using B<clone>(2)  with the B<CLONE_CHILD_SETTID> flag, I<set_child_tid> is set to I<child_tidptr>, the fifth argument of that system call.
fr: Si un processus est démarré en utilisant B<clone>(2) avec l'attribut B<CLONE_CHILD_SETTID>, I<set_child_tid> est remplie avec I<child_tidptr>, le cinquième paramètre de cet appel système.

note: type: Plain text
en: When I<set_child_tid> is set, the very first thing the new process does is writing its PID at this address.
fr: Lorsque I<set_child_tid> est remplie, la toute première chose que le nouveau processus fait est d'écrire son PID à cette adresse.

note: type: Plain text
en: If a process is started using B<clone>(2)  with the B<CLONE_CHILD_CLEARTID> flag, I<clear_child_tid> is set to I<child_tidptr>, the fifth argument of that system call.
fr: Si un processus est démarré en utilisant B<clone>(2) avec l'attribut B<CLONE_CHILD_CLEARTID>, I<clear_child_tid> est remplie avec I<child_tidptr>, le cinquième paramètre de cet appel système.

note: type: Plain text
en: The system call B<set_tid_address>()  sets the I<clear_child_tid> value for the calling process to I<tidptr>.
fr: L'appel système B<set_tid_address>() remplit la valeur I<clear_child_tid> pour le processus appelant à I<tidptr>.

note: type: Plain text
en: When I<clear_child_tid> is set, and the process exits, and the process was sharing memory with other processes or threads, then 0 is written at this address, and a I<futex(child_tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);> call is done.  (That is, wake a single process waiting on this futex.)  Errors are ignored.
fr: Lorsque I<clear_child_tid> est remplie, que le processus finit et qu'il avait de la mémoire partagée avec d'autres processus ou threads, 0 est écrit à cette adresse et un appel à I<futex(child_tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);> est réalisé (c'est-à-dire que l'un des processus bloqués sur ce futex est réveillé). Les erreurs sont ignorées.

note: type: Plain text
en: B<set_tid_address>()  always returns the PID of the calling process.
fr: B<set_tid_address>() renvoie toujours le PID du processus appelant.

note: type: Plain text
en: B<set_tid_address>()  always succeeds.
fr: B<set_tid_address>() réussit toujours.

note: type: Plain text
en: This call is present since Linux 2.5.48.  Details as given here are valid since Linux 2.5.49.
fr: Cet appel est présent depuis Linux 2.5.48. Les détails fournis ici sont valides depuis Linux 2.5.49.

note: type: TH
en: 2009-09-15
fr: 15 septembre 2009

note: type: Plain text
en: splice - splice data to/from a pipe
fr: splice - Copier des données vers/depuis un tube

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

note: type: Plain text
en: B<splice>()  moves data between two file descriptors without copying between kernel address space and user address space.  It transfers up to I<len> bytes of data from the file descriptor I<fd_in> to the file descriptor I<fd_out>, where one of the descriptors must refer to a pipe.
fr: B<splice>() déplace des données entre deux descripteurs de fichier sans les copier entre l'espace d'adressage noyau et l'espace utilisateur. Jusqu'à I<len> octets de données sont transférés du descripteur de fichier I<fd_in> au descripteur de fichier I<fd_out>, où l'un des descripteurs doit correspondre à un tube.

note: type: Plain text
en: If I<fd_in> refers to a pipe, then I<off_in> must be NULL.  If I<fd_in> does not refer to a pipe and I<off_in> is NULL, then bytes are read from I<fd_in> starting from the current file offset, and the current file offset is adjusted appropriately.  If I<fd_in> does not refer to a pipe and I<off_in> is not NULL, then I<off_in> must point to a buffer which specifies the starting offset from which bytes will be read from I<fd_in>; in this case, the current file offset of I<fd_in> is not changed.  Analogous statements apply for I<fd_out> and I<off_out>.
fr: Si I<fd_in> correspond à un tube, alors I<off_in> doit être NULL. Si I<fd_in> ne correspond pas à un tube et I<off_in> est NULL, alors les octets sont lus depuis I<fd_in> à partir de la position courante dans le fichier et la position courante est mise à jour de façon appropriée. Si I<fd_in> ne correspond pas à un tube et I<off_in> n'est pas NULL, alors I<off_in> doit pointer vers un tampon qui indique la position à partir de laquelle les données seront lues dans I<fd_in>\ ; dans ce cas, la position courante dans I<fd_in> n'est pas modifiée. Il en va de même pour I<fd_out> et I<off_out>.

note: type: Plain text
en: The I<flags> argument is a bit mask that is composed by ORing together zero or more of the following values:
fr: L'argument I<flags> est constitué par un I<OU> binaire entre une ou plusieurs des valeurs suivantes\ :

note: type: Plain text
en: Attempt to move pages instead of copying.  This is only a hint to the kernel: pages may still be copied if the kernel cannot move the pages from the pipe, or if the pipe buffers don't refer to full pages.  The initial implementation of this flag was buggy: therefore starting in Linux 2.6.21 it is a no-op (but is still permitted in a B<splice>()  call); in the future, a correct implementation may be restored.
fr: Essayer de déplacer des pages au lieu de les copier. Ceci n'est qu'un conseil au noyau\ : des pages peuvent quand même être copiées si le noyau ne peut pas déplacer les pages du tube, ou si les tampons du tube ne correspondent pas à des pages entières. La première implémentation de cet attribut comportait un bogue : ainsi, à partir de Linux 2.6.21 il ne fait rien (mais est toujours permis dans un appel à B<splice>()) ; dans le futur, une implémentation correcte pourra être restaurée.

note: type: Plain text
en: Do not block on I/O.  This makes the splice pipe operations nonblocking, but B<splice>()  may nevertheless block because the file descriptors that are spliced to/from may block (unless they have the B<O_NONBLOCK> flag set).
fr: Ne pas bloquer sur les entrées-sorties. Cela rend les opérations de splice sur le tube non bloquantes, mais B<splice>() peut tout de même bloquer car les descripteurs de fichier sur lesquels il opère peuvent bloquer (sauf s'ils ont l'attribut B<O_NONBLOCK>).

note: type: Plain text
en: More data will be coming in a subsequent splice.  This is a helpful hint when the I<fd_out> refers to a socket (see also the description of B<MSG_MORE> in B<send>(2), and the description of B<TCP_CORK> in B<tcp>(7))
fr: Des données supplémentaires seront copiées plus tard. C'est un indice utile lorsque I<fd_out> correspond à une socket (voir aussi la description de B<MSG_MORE> dans B<send>(2), et la description de B<TCP_CORK> dans B<tcp>(7)).

note: type: Plain text
en: Unused for B<splice>(); see B<vmsplice>(2).
fr: N'a pas d'effet pour B<splice>()\ ; consultez B<vmsplice>(2).

note: type: Plain text
en: Upon successful completion, B<splice>()  returns the number of bytes spliced to or from the pipe.  A return value of 0 means that there was no data to transfer, and it would not make sense to block, because there are no writers connected to the write end of the pipe referred to by I<fd_in>.
fr: En cas de réussite, B<splice>() renvoie le nombre d'octets raccordés depuis ou vers le tube. Une valeur de retour de 0 signifie qu'il n'y avait pas de données à transférer, et qu'il serait insensé de bloquer, parce qu'il n'y a pas d'écrivain connecté à l'autre bout du tube correspondant à I<fd_in>.

note: type: Plain text
en: On error, B<splice>()  returns -1 and I<errno> is set to indicate the error.
fr: En cas d'erreur, B<splice>() renvoie -1 et I<errno> est positionné pour indiquer la cause de l'erreur.

note: type: Plain text
en: One or both file descriptors are not valid, or do not have proper read-write mode.
fr: Au moins un des descripteurs de fichier n'est pas valide, ou n'a pas le mode de lecture ou d'écriture approprié.

note: The append-mode error is given since 2.6.27; in earlier kernels, splice() in append mode was broken type: Plain text
en: Target file system doesn't support splicing; target file is opened in append mode; neither of the descriptors refers to a pipe; or offset given for nonseekable device.
fr: Le système de fichiers cible ne gère pas le splice ; le fichier cible est ouvert en mode ajout ; aucun des descripteurs de fichiers ne correspond à un tube ; ou bien une position a été indiquée pour un périphérique sur lequel le déplacement est impossible.

note: type: Plain text
en: Out of memory.
fr: Plus de mémoire disponible.

note: type: Plain text
en: Either I<off_in> or I<off_out> was not NULL, but the corresponding file descriptor refers to a pipe.
fr: I<off_in> ou I<off_out> est différent de NULL, mais le descripteur de fichier correspondant pointe vers un tube.

note: type: Plain text
en: The B<splice>()  system call first appeared in Linux 2.6.17.
fr: L'appel système B<splice>() est apparu dans Linux 2.6.17.

note: type: Plain text
en: The three system calls B<splice>(), B<vmsplice>(2), and B<tee>(2), provide userspace programs with full control over an arbitrary kernel buffer, implemented within the kernel using the same type of buffer that is used for a pipe.  In overview, these system calls perform the following tasks:
fr: Les trois appels système B<splice>(), B<vmsplice>(2) et B<tee>(2) fournissent aux programmes utilisateur le contrôle complet d'un tampon arbitraire du noyau, implémenté côté noyau en utilisant le même type de tampons que pour les tubes. Ces appels système assurent les tâches suivantes\ :

note: type: Plain text
en: moves data from the buffer to an arbitrary file descriptor, or vice versa, or from one buffer to another.
fr: déplace des données depuis le tampon vers un descripteur de fichier arbitraire, ou vice versa, ou bien depuis un tampon vers un autre.

note: type: Plain text
en: "copies" the data from one buffer to another.
fr: «\ copie\ » les données d'un tampon vers un autre.

note: type: Plain text
en: "copies" data from user space into the buffer.
fr: «\ copie\ » des données de l'espace utilisateur vers le tampon.

note: Linus: Now, imagine using the above in a media server, for example. Let's say that a year or two has passed, so that the video drivers have been updated to be able to do the splice thing, and what can you do? You can: - splice from the (mpeg or whatever - let's just assume that the video input is ei
en: Though we talk of copying, actual copies are generally avoided.  The kernel does this by implementing a pipe buffer as a set of reference-counted pointers to pages of kernel memory.  The kernel creates "copies" of pages in a buffer by creating new pointers (for the output buffer) referring to the pages, and increasing the reference counts for the pages: only pointers are copied, not the pages of the buffer.
fr: Bien qu'il soit question de copie, les vraies copies sont en général évitées. Le noyau implémente en effet le tampon d'un tube comme un ensemble de pointeurs vers des pages de mémoire noyau pouvant être référencées plusieurs fois. Le noyau crée des «\ copies\ » des pages dans un tampon en créant de nouveaux pointeurs (pour le tampon de sortie) pointant vers les pages, et en incrémentant les compteurs de références des pages\ : seuls les pointeurs sont copiés, et pas les pages du tampon.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: See B<tee>(2).
fr: Consultez B<tee>(2).

note: type: Plain text
en: tee - duplicating pipe content
fr: tee - Dupliquer le contenu d'un tube

note: Example programs http://brick.kernel.dk/snaps add a "tee(in, out1, out2)" system call that duplicates the pages (again, incrementing their reference count, not copying the data) from one pipe to two other pipes. type: Plain text
en: B<tee>()  duplicates up to I<len> bytes of data from the pipe referred to by the file descriptor I<fd_in> to the pipe referred to by the file descriptor I<fd_out>.  It does not consume the data that is duplicated from I<fd_in>; therefore, that data can be copied by a subsequent B<splice>(2).
fr: B<tee>() duplique jusqu'à I<len> octets de données du tube auquel le descripteur de fichier I<fd_in> fait référence vers le tube référencé par I<fd_out>. Il ne consomme pas les données qui sont dupliquées depuis I<fd_in>\ ; ces données peuvent donc être copiées par un futur appel à B<splice>(2).

note: type: Plain text
en: I<flags> is a series of modifier flags, which share the name space with B<splice>(2)  and B<vmsplice>(2):
fr: I<flags> est un ensemble de paramètres modificateurs, dont l'espace de nommage est partagé avec B<splice>(2) et B<vmsplice>(2)\ :

note: type: Plain text
en: Currently has no effect for B<tee>(); see B<splice>(2).
fr: N'a pas d'effet pour B<tee>() actuellement\ ; consultez B<splice>(2).

note: Not used for vmsplice May be in the future -- therefore EAGAIN type: Plain text
en: Do not block on I/O; see B<splice>(2)  for further details.
fr: Ne pas bloquer pendant les entrées-sorties\ ; consultez B<splice>(2) pour plus de détails.

note: type: Plain text
en: Currently has no effect for B<tee>(), but may be implemented in the future; see B<splice>(2).
fr: N'a pas d'effet pour B<tee>() actuellement, mais pourrait être implémenté un jour\ ; consultez B<splice>(2).

note: type: Plain text
en: Unused for B<tee>(); see B<vmsplice>(2).
fr: Inutilisé pour B<tee>()\ ; consultez B<vmsplice>(2).

note: type: Plain text
en: Upon successful completion, B<tee>()  returns the number of bytes that were duplicated between the input and output.  A return value of 0 means that there was no data to transfer, and it would not make sense to block, because there are no writers connected to the write end of the pipe referred to by I<fd_in>.
fr: En cas de succès, B<tee>() renvoie le nombre d'octets dupliqués entre les tubes d'entrée et de sortie. La valeur de retour 0 signifie qu'il n'y avait aucune donnée à transférer, et que bloquer n'aurait pas de sens car il n'y a aucun écrivain connecté à l'extrémité d'écriture du tube référencé par I<fd_in>.

note: type: Plain text
en: On error, B<tee>()  returns -1 and I<errno> is set to indicate the error.
fr: En cas d'erreur, B<tee>() renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<fd_in> or I<fd_out> does not refer to a pipe; or I<fd_in> and I<fd_out> refer to the same pipe.
fr: I<fd_in> ou I<fd_out> ne correspond pas à un tube\ ; ou bien I<fd_in> et I<fd_out> font référence au même tube.

note: type: Plain text
en: The B<tee>()  system call first appeared in Linux 2.6.17.
fr: L'appel système B<tee>() est apparu dans Linux 2.6.17.

note: type: Plain text
en: Conceptually, B<tee>()  copies the data between the two pipes.  In reality no real data copying takes place though: under the covers, B<tee>()  assigns data in the output by merely grabbing a reference to the input.
fr: Conceptuellement, B<tee>() copie les données entre deux tubes. En fait, il n'y a pas de réelle copie de données\ : B<tee>() attache les données au tube de sortie en prenant une référence sur les données en entrée.

note: type: Plain text
en: The following example implements a basic B<tee>(1)  program using the B<tee>()  system call.
fr: L'exemple suivant implémente une version basique du programme B<tee>(1) en utilisant l'appel système B<tee>().

note: type: Plain text
en:     if (argc != 2) {
            fprintf(stderr, "Usage: %s E<lt>fileE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc != 2) {
            fprintf(stderr, "Utilisation : %s E<lt>fichierE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     do {
            /*
             * tee stdin to stdout.
             */
            len = tee(STDIN_FILENO, STDOUT_FILENO,
                      INT_MAX, SPLICE_F_NONBLOCK);
fr:     do {
            /*
             * Duplique l'entrée standard dans la sortie standard.
             */
            len = tee(STDIN_FILENO, STDOUT_FILENO,
                      INT_MAX, SPLICE_F_NONBLOCK);

note: type: Plain text
en:         /*
             * Consume stdin by splicing it to a file.
             */
            while (len E<gt> 0) {
                slen = splice(STDIN_FILENO, NULL, fd, NULL,
                              len, SPLICE_F_MOVE);
                if (slen E<lt> 0) {
                    perror("splice");
                    break;
                }
                len -= slen;
            }
        } while (1);
fr:         /*
             * Consomme l'entrée standard en la raccordant à un fichier.
             */
            while (len E<gt> 0) {
                slen = splice(STDIN_FILENO, NULL, fd, NULL,
                              len, SPLICE_F_MOVE);
                if (slen E<lt> 0) {
                    perror("splice");
                    break;
                }
                len -= slen;
            }
        } while (1);

note: type: TH
en: 2009-02-20
fr: 20 février 2009

note: type: Plain text
en: vm86old, vm86 - enter virtual 8086 mode
fr: vm86old, vm86 - Entrer en mode 8086 virtuel

note: type: Plain text
en: The system call B<vm86>()  was introduced in Linux 0.97p2.  In Linux 2.1.15 and 2.0.28 it was renamed to B<vm86old>(), and a new B<vm86>()  was introduced.  The definition of I<struct vm86_struct> was changed in 1.1.8 and 1.1.9.
fr: L'appel système B<vm86>() a été introduit dans Linux 0.97p2. Depuis Linux 2.1.15 et 2.0.28, il a été renommé en B<vm86old>(), et un nouvel appel B<vm86>() a été introduit. La définition de I<struct vm86_struct> a été modifiée dans Linux 1.1.8 et 1.1.9.

note: type: Plain text
en: These calls cause the process to enter VM86 mode (virtual-8086 in Intel literature), and are used by B<dosemu>.
fr: Ces appels permettent au processus d'entrer en mode VM86, et sont utilisés par B<dosemu>.

note: type: Plain text
en: VM86 mode is an emulation of real mode within a protected mode task.
fr: Le mode VM86 est une émulation du mode réel, dans une tâche s'exécutant en mode protégé.

note: type: Plain text
en: This return value is specific to i386 and indicates a problem with getting userspace data.
fr: Cette valeur de retour est spécifique à l'architecture i386 et indique un problème lors de la récupération de données à partir de l'espace utilisateur.

note: type: Plain text
en: This return value indicates the call is not implemented on the present architecture.
fr: L'appel n'est pas implémenté sur cette architecture.

note: type: Plain text
en: Saved kernel stack exists.  (This is a kernel sanity check; the saved stack should only exist within vm86 mode itself.)
fr: Il existe une pile sauvegardée du noyau. (C'est une vérification de l'état du système, une pile sauvegardée ne devrait exister que dans le mode vm86 lui-même).

note: type: Plain text
en: This call is specific to Linux on 32-bit Intel processors, and should not be used in programs intended to be portable.
fr: Cet appel système est spécifique à Linux sur les processeurs Intel 32 bits, et ne doit pas être utilisé dans des programmes destinés à être portables.

note: type: Plain text
en: vmsplice - splice user pages into a pipe
fr: vmsplice - Raccorder des pages utilisateur à un tube

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

note: Linus: vmsplice() system call to basically do a "write to the buffer", but using the reference counting and VM traversal to actually fill the buffer. This means that the user needs to be careful not to reuse the user-space buffer it spliced into the kernel-space one (contrast this to "write()", whic
en: The B<vmsplice>()  system call maps I<nr_segs> ranges of user memory described by I<iov> into a pipe.  The file descriptor I<fd> must refer to a pipe.
fr: L'appel système B<vmsplice>() projette les I<nr_segs> segments de mémoire utilisateur décrits par I<iov> dans un tube. Le descripteur de fichier I<fd> doit faire référence à un tube.

note: type: Plain text
en: The pointer I<iov> points to an array of I<iovec> structures as defined in I<E<lt>sys/uio.hE<gt>>:
fr: Le pointeur I<iov> pointe vers un tableau de structures I<iovec> définies dans I<E<lt>sys/uio.hE<gt>>\ :

note: type: Plain text
en: struct iovec {
        void  *iov_base;            /* Starting address */
        size_t iov_len;             /* Number of bytes */
    };
fr: struct iovec {
        void *iov_base;           /* Adresse de début */
        size_t iov_len;           /* Nombre d'octets  */
    };

note: type: Plain text
en: Unused for B<vmsplice>(); see B<splice>(2).
fr: Non utilisé pour B<vmsplice>()\ ; consultez B<splice>(2).

note: type: Plain text
en: Currently has no effect for B<vmsplice>(), but may be implemented in the future; see B<splice>(2).
fr: N'a pas d'effet pour B<vmsplice>() actuellement, mais pourrait être implémenté un jour\ ; consultez B<splice>(2).

note: FIXME Explain the following line in a little more detail: .... if we expect to later SPLICE_F_MOVE to the cache. type: Plain text
en: The user pages are a gift to the kernel.  The application may not modify this memory ever, or page cache and on-disk data may differ.  Gifting pages to the kernel means that a subsequent B<splice>(2)  B<SPLICE_F_MOVE> can successfully move the pages; if this flag is not specified, then a subsequent B<splice>(2)  B<SPLICE_F_MOVE> must copy the pages.  Data must also be properly page aligned, both in memory and length.
fr: Les pages utilisateur sont offertes au noyau. L'application ne pourra plus jamais modifier cette mémoire, sans quoi le cache de pages et les données stockées sur disque pourraient être différentes. Offrir des pages au noyau signifie qu'un futur appel à B<splice>(2) B<SPLICE_F_MOVE> peut effectivement déplacer les pages\ ; si ce paramètre n'est pas spécifié, un futur appel à B<splice>(2) B<SPLICE_F_MOVE> doit copier les pages. Les données doivent par ailleurs être correctement alignées sur des frontières de pages, que ce soit en mémoire ou en taille.

note: type: Plain text
en: Upon successful completion, B<vmsplice>()  returns the number of bytes transferred to the pipe.  On error, B<vmsplice>()  returns -1 and I<errno> is set to indicate the error.
fr: S'il réussit, B<vmsplice>() renvoie le nombre d'octets transférés dans le tube. En cas d'erreur, B<vmsplice>() renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: I<fd> either not valid, or doesn't refer to a pipe.
fr: I<fd> est invalide ou ne correspond pas à un tube.

note: type: Plain text
en: I<nr_segs> is 0 or greater than B<IOV_MAX>; or memory not aligned if B<SPLICE_F_GIFT> set.
fr: I<nr_segs> est nul ou supérieur à B<IOV_MAX>, ou bien la mémoire n'est pas alignée si B<SPLICE_F_GIFT> est spécifié.

note: type: Plain text
en: The B<vmsplice>()  system call first appeared in Linux 2.6.17.
fr: L'appel système B<vmsplice>() est apparu dans Linux 2.6.17.

note: type: Plain text
en: B<vmsplice>()  follows the other vectorized read/write type functions when it comes to limitations on number of segments being passed in.  This limit is B<IOV_MAX> as defined in I<E<lt>limits.hE<gt>>.  At the time of this writing, that limit is 1024.
fr: B<vmsplice>() suit les conventions des autres fonctions vectorielles de type read/write quant aux limites sur le nombre de segments qui peuvent être passés. Cette limite est B<IOV_MAX>, défini dans I<E<lt>limits.hE<gt>>. Lorsque cette page a été écrite, cette limite était 1024.
