perkamon - en to fr translation catalogue (207 entries)

note: type: TH
en: 2019-10-10
fr: 10 octobre 2019

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

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: 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> or B<PTRACE_SEIZE>.
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> ou B<PTRACE_SEIZE>.

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: If the B<PTRACE_O_TRACEEXEC> option is not in effect, all successful calls to B<execve>(2)  by the traced process will cause it to be sent a B<SIGTRAP> signal, giving the parent a chance to gain control before the new program begins execution.
fr: Si l'option B<PTRACE_O_TRACEEXEC> n'est pas effective, tous les appels réussis d'B<execve>(2) par le processus suivi déclencheront l'envoi d'un signal B<SIGTRAP>, ce qui permet au père de reprendre le contrôle avant que le nouveau programme commence son exécution.

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.  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. Un processus ne devrait sans doute 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_ATTACH>, B<PTRACE_SEIZE>, B<PTRACE_INTERRUPT>, and 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_ATTACH>, B<PTRACE_SEIZE>, B<PTRACE_INTERRUPT> et 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; but see NOTES.)
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é, consultez la section NOTES).

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; but see NOTES.)
fr: Lire un mot à la position 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é, consultez la section B<NOTES>).

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 le mot I<data> 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 user space 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 le mot I<data> vers l'adresse 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.)  Note that SPARC systems have the meaning of I<data> and I<addr> reversed; that is, I<data> is ignored and the registers are copied to the address I<addr>.  B<PTRACE_GETREGS> and B<PTRACE_GETFPREGS> are not present on all architectures.
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 de ces données (I<addr> est ignoré). Remarquez que les systèmes SPARC ont la signification de I<data> et I<addr> inversée, c'est-à-dire que I<data> est ignoré et les registres sont copiés vers l'adresse I<addr>. B<PTRACE_GETREGS> et B<PTRACE_GETFPREGS> ne sont pas présents sur toutes les architectures.

note: type: TP
en: B<PTRACE_GETREGSET> (since Linux 2.6.34)
fr: B<PTRACE_GETREGSET> (depuis Linux 2.6.34)

note: type: Plain text
en: Read the tracee's registers.  I<addr> specifies, in an architecture-dependent way, the type of registers to be read.  B<NT_PRSTATUS> (with numerical value 1)  usually results in reading of general-purpose registers.  If the CPU has, for example, floating-point and/or vector registers, they can be retrieved by setting I<addr> to the corresponding B<NT_foo> constant.  I<data> points to a B<struct iovec>, which describes the destination buffer's location and length.  On return, the kernel modifies B<iov.len> to indicate the actual number of bytes returned.
fr: Lire les registres de l'observé. I<addr> indique, de manière dépendante de l'architecture, le type de registres à lire. B<NT_PRSTATUS> (avec une valeur numérique de 1) a pour conséquence habituelle la lecture de registres généraux. Si le processeur a, par exemple, des registres en virgule flottante ou en vecteur, ils peuvent être récupéré en configurant I<addr> à la constante B<NT_foo> correspondante. I<data> pointe vers une B<struct iovec>, qui décrit l'emplacement et la taille du tampon de destination. Le noyau modifie B<iov.len> au retour pour indiquer le véritable nombre d'octets renvoyés.

note: FIXME . In the preceding sentence, which modifications are disallowed, and when they are disallowed, how does user space discover that fact? type: Plain text
en: Modify 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.)  Note that SPARC systems have the meaning of I<data> and I<addr> reversed; that is, I<data> is ignored and the registers are copied from the address I<addr>.  B<PTRACE_SETREGS> and B<PTRACE_SETFPREGS> are not present on all architectures.
fr: Modifier les registres généraux ou du processeur en virgule flottante de l'observé, depuis l'adresse I<data> de l'observateur. Comme pour B<PTRACE_POKEUSER>, certaines modifications de registres généraux pourraient être interdites (I<addr> est ignoré). Remarquez que les systèmes SPARC ont la signification de I<data> et I<addr> inversée, c'est-à-dire que I<data> est ignoré et les registres sont copiés depuis l'adresse I<addr>. B<PTRACE_SETREGS> et B<PTRACE_SETFPREGS> ne sont pas présents sur toutes les architectures.

note: type: TP
en: B<PTRACE_SETREGSET> (since Linux 2.6.34)
fr: B<PTRACE_SETREGSET> (depuis Linux 2.6.34)

note: type: Plain text
en: Modify the tracee's registers.  The meaning of I<addr> and I<data> is analogous to B<PTRACE_GETREGSET>.
fr: Modifier les registres de l'observé. La signification de I<addr> et I<data> est analogue à B<PTRACE_GETREGSET>.

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: 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_PEEKSIGINFO> (since Linux 3.10)
fr: B<PTRACE_PEEKSIGINFO> (depuis Linux 3.10)

note: commit 84c751bd4aebbaae995fe32279d3dba48327bad4 type: Plain text
en: Retrieve I<siginfo_t> structures without removing signals from a queue.  I<addr> points to a I<ptrace_peeksiginfo_args> structure that specifies the ordinal position from which copying of signals should start, and the number of signals to copy.  I<siginfo_t> structures are copied into the buffer pointed to by I<data>.  The return value contains the number of copied signals (zero indicates that there is no signal corresponding to the specified ordinal position).  Within the returned I<siginfo> structures, the I<si_code> field includes information (B<__SI_CHLD>, B<__SI_FAULT>, etc.) that are not otherwise exposed to user space.
fr: Récupérer les structures I<siginfo_t> sans supprimer les signaux d’une file d’attente. I<addr> pointe vers une structure I<ptrace_peeksiginfo_args> qui indique la position ordinale à partir de laquelle la copie des signaux devrait commencer et le nombre de signaux à copier. Les structures I<siginfo_t> sont copiées dans le tampon pointé par I<data>. La valeur de retour contient le nombre de signaux copiés (zéro indique qu’il n’y a pas de signal correspondant à la position ordinale indiquée). Dans les structures I<siginfo> renvoyées, le champ I<si_code> contient des renseignements (B<__SI_CHLD>, B<__SI_FAULT>, etc.) qui ne sont sinon pas exposés à l’espace utilisateur.

note: type: Plain text
en: struct ptrace_peeksiginfo_args {
        u64 off;    /* Ordinal position in queue at which
                       to start copying signals */
        u32 flags;  /* PTRACE_PEEKSIGINFO_SHARED or 0 */
        s32 nr;     /* Number of signals to copy */
    };
fr: struct ptrace_peeksiginfo_args {
        u64 off;    /* Position ordinale dans la file d’attente
                       où commencer la copie de signaux */
        u32 flags;  /* PTRACE_PEEKSIGINFO_SHARED ou 0 */
        s32 nr;     /* Nombre de signaux à copier */
    };

note: type: Plain text
en: Currently, there is only one flag, B<PTRACE_PEEKSIGINFO_SHARED>, for dumping signals from the process-wide signal queue.  If this flag is not set, signals are read from the per-thread queue of the specified thread.
fr: Actuellement, seul l’attribut B<PTRACE_PEEKSIGINFO_SHARED> permet de vider les signaux de la file de signaux par processus. Si cet attribut n’est pas défini, les signaux sont lus depuis la file par thread du thread indiqué.

note: type: TP
en: B<PTRACE_GETSIGMASK> (since Linux 3.11)
fr: B<PTRACE_GETSIGMASK> (depuis Linux 3.11)

note: commit 29000caecbe87b6b66f144f72111f0d02fbbf0c1 type: Plain text
en: Place a copy of the mask of blocked signals (see B<sigprocmask>(2))  in the buffer pointed to by I<data>, which should be a pointer to a buffer of type I<sigset_t>.  The I<addr> argument contains the size of the buffer pointed to by I<data> (i.e., I<sizeof(sigset_t)>).
fr: Placer une copie du masque des signaux bloqués (consultez B<sigprocmask>(2)) dans le tampon pointé par I<data> qui devrait être un pointeur vers un tampon de type I<sigset_t>. L’argument I<addr> contient la taille du tampon pointé par I<data> (c’est-à-dire I<sizeof(sigset_t)>).

note: type: TP
en: B<PTRACE_SETSIGMASK> (since Linux 3.11)
fr: B<PTRACE_SETSIGMASK> (depuis Linux 3.11)

note: type: Plain text
en: Change the mask of blocked signals (see B<sigprocmask>(2))  to the value specified in the buffer pointed to by I<data>, which should be a pointer to a buffer of type I<sigset_t>.  The I<addr> argument contains the size of the buffer pointed to by I<data> (i.e., I<sizeof(sigset_t)>).
fr: Modifier le masque des signaux bloqués (consultez B<sigprocmask>(2)) à la valeur indiquée dans le tampon pointé par I<data> qui devrait être un pointeur vers un tampon de type I<sigset_t>. L’argument I<addr> contient la taille du tampon pointé par I<data> (c’est-à-dire I<sizeof(sigset_t)>).

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_EXITKILL> (since Linux 3.8)
fr: B<PTRACE_O_EXITKILL> (depuis Linux 3.8)

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>, or B<PTRACE_EVENT_STOP> if B<PTRACE_SEIZE> was used.  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>, ou B<PTRACE_EVENT_STOP> si B<PTRACE_SEIZE> est utilisé. 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: 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: Plain text
en: If the execing thread is not a thread group leader, the thread ID is reset to thread group leader's ID before this stop.  Since Linux 3.0, the former thread ID can be retrieved with B<PTRACE_GETEVENTMSG>.
fr: Si le thread en cours d'exécution n'est pas un leader de groupe de threads, l'identifiant de thread est réinitialisé à l'identifiant du leader de groupe de threads avant cet arrêt. Depuis Linux 3.0, le premier identifiant de thread peut ê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_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>, or B<PTRACE_EVENT_STOP> if B<PTRACE_SEIZE> was used.  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>, ou B<PTRACE_EVENT_STOP> si B<PTRACE_SEIZE> est utilisé. Un B<waitpid>(2) par l'observateur renverra une valeur I<status> comme

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: 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>, or B<PTRACE_EVENT_STOP> if B<PTRACE_SEIZE> was used.  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>, ou B<PTRACE_EVENT_STOP> si B<PTRACE_SEIZE> est utilisé. 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_GETEVENTMSG> (since Linux 2.5.46)
fr: B<PTRACE_GETEVENTMSG> (depuis Linux 2.5.46)

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>.  (I<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: TP
en: B<PTRACE_LISTEN> (since Linux 3.4)
fr: B<PTRACE_LISTEN> (depuis Linux 3.4)

note: type: Plain text
en: Restart the stopped tracee, but prevent it from executing.  The resulting state of the tracee is similar to a process which has been stopped by a B<SIGSTOP> (or other stopping signal).  See the "group-stop" subsection for additional information.  B<PTRACE_LISTEN> works only on tracees attached by B<PTRACE_SEIZE>.
fr: Redémarrer l'observé arrêté, mais en l'empêchant de s'exécuter. L'état résultant de l'observé est similaire a celui d'un processus qui a été arrêté par un B<SIGSTOP> (ou autre signal d'arrêt). Consultez la sous-section B<Arrêt-groupe> pour des renseignements supplémentaires. B<PTRACE_LISTEN> ne fonctionne que sur les observés attachés par B<PTRACE_SEIZE>.

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: type: TP
en: B<PTRACE_INTERRUPT> (since Linux 3.4)
fr: B<PTRACE_INTERRUPT> (depuis Linux 3.4)

note: type: Plain text
en: Stop a tracee.  If the tracee is running or sleeping in kernel space and B<PTRACE_SYSCALL> is in effect, the system call is interrupted and syscall-exit-stop is reported.  (The interrupted system call is restarted when the tracee is restarted.)  If the tracee was already stopped by a signal and B<PTRACE_LISTEN> was sent to it, the tracee stops with B<PTRACE_EVENT_STOP> and I<WSTOPSIG(status)> returns the stop signal.  If any other ptrace-stop is generated at the same time (for example, if a signal is sent to the tracee), this ptrace-stop happens.  If none of the above applies (for example, if the tracee is running in user space), it stops with B<PTRACE_EVENT_STOP> with I<WSTOPSIG(status)> == B<SIGTRAP>.  B<PTRACE_INTERRUPT> only works on tracees attached by B<PTRACE_SEIZE>.
fr: Arrêter un observé. Si l’observé est en cours d’exécution ou en sommeil dans l’espace utilisateur et que B<PTRACE_SYSCALL> est effectif, l’appel système est interrompu et l'arrêt-sortie-appel-système est signalé (l’appel système interrompu est redémarré quand l’observé est redémarré). Si l’observé avait déjà été arrêté par un signal et que B<PTRACE_LISTEN> lui avait été envoyé, l’observé s’arrête avec B<PTRACE_EVENT_STOP> et B<WSTOPSIG(status)> renvoie le signal d’arrêt. Si n’importe quel autre arrêt-ptrace est créé en même temps (par exemple, si un signal est envoyé à l’observé), cet arrêt-ptrace arrive. Si rien de ce qui précède ne s’applique (par exemple si l’observé est en cours d’exécution en espace utilisateur), il s’arrête avec B<PTRACE_EVENT_STOP> avec I<WSTOPSIG(status)> == B<SIGTRAP>. B<PTRACE_INTERRUPT> ne fonctionne que sur les observés attachés par B<PTRACE_SEIZE>.

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: type: TP
en: B<PTRACE_SEIZE> (since Linux 3.4)
fr: B<PTRACE_SEIZE> (depuis Linux 3.4)

note: type: Plain text
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> does not generate signal-delivery-stop 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> ne génère pas d'arrêt-distribution-signal 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: 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.  For the purposes of ptrace, a tracee which is blocked in a system call (such as B<read>(2), B<pause>(2), etc.)  is nevertheless considered to be running, even if the tracee is blocked for a long time.  The state of the tracee after B<PTRACE_LISTEN> is somewhat of a gray area: it is not in any ptrace-stop (ptrace commands won't work on it, and it will deliver B<waitpid>(2)  notifications), but it also may be considered "stopped" because it is not executing instructions (is not scheduled), and if it was in group-stop before B<PTRACE_LISTEN>, it will not respond to signals until B<SIGCONT> is received.
fr: Deux états existent pour un observé : en cours d'exécution ou à l'arrêt. Du point de vue de ptrace, un observé qui est bloqué dans un appel système (comme B<read>(2), B<pause>(2), etc.) est néanmoins considéré en cours d’exécution, même si l’observé est bloqué depuis longtemps. L’état de l’observé après B<PTRACE_LISTEN> est en quelque sorte une zone d’ombre : il n’est dans aucun arrêt-ptrace (les commandes ptrace n’auront aucun effet sur lui et il distribuera des notifications B<waitpid>(2)), mais il pourrait aussi être considéré « arrêté » parce qu’il n’est pas en train d’exécuter des instructions (pas de programmation) et, s’il était en arrêt-groupe avant B<PTRACE_LISTEN>, il ne répondra pas aux signaux avant de recevoir B<SIGCONT>.

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: 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: The following kinds of ptrace-stops exist: signal-delivery-stops, group-stops, B<PTRACE_EVENT> stops, syscall-stops.  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<(statusE<gt>E<gt>8)\ &\ 0xff>.)
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<(statusE<gt>E<gt>8)\ &\ 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 signal returned by I<WSTOPSIG(status)>.  If the 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 renvoyé par I<WSTOPSIG(status)>. Si le signal 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.  In this case, system calls will be restarted: the tracer will observe the tracee to reexecute the interrupted system call (or B<restart_syscall>(2)  system call for a few system calls which use a different mechanism for restarting) if the tracer uses B<PTRACE_SYSCALL>.  Even system calls (such as B<poll>(2))  which are not restartable after signal are restarted after signal is suppressed; however, kernel bugs exist which cause some system calls to 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. Dans ce cas, les appels système seront redémarrés : l'observateur forcera l'observé à réexécuter l'appel système interrompu (ou l'appel système B<restart_syscall>(2) pour les quelques appels système qui utilisent un autre mécanisme de redémarrage) si l'observateur utilise B<PTRACE_SYSCALL>. Même les appels système (comme B<poll>(2)) qui ne sont pas redémarrables après signal sont redémarré après la suppression du signal ; cependant, des bogues du noyau existent et certains appels système échouent 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: 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: If tracee was attached using B<PTRACE_SEIZE>, group-stop is indicated by B<PTRACE_EVENT_STOP>: I<statusE<gt>E<gt>16 == PTRACE_EVENT_STOP>.  This allows detection of group-stops without requiring an extra B<PTRACE_GETSIGINFO> call.
fr: Si l’observé était attaché en utilisant B<PTRACE_SEIZE>, un arrêt-groupe est indiqué par B<PTRACE_EVENT_STOP> : I<statusE<gt>E<gt>16 == PTRACE_EVENT_STOP>. Cela permet la détection d’arrêts-groupe sans nécessiter d’appel B<PTRACE_GETSIGINFO> supplémentaire.

note: type: Plain text
en: As of Linux 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 Linux 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: Plain text
en: Since Linux 3.4, there is a method to overcome this problem: instead of B<PTRACE_CONT>, a B<PTRACE_LISTEN> command can be used to restart a tracee in a way where it does not execute, but waits for a new event which it can report via B<waitpid>(2)  (such as when it is restarted by a B<SIGCONT>).
fr: Depuis Linux 3.4, une méthode permet d'éviter ce problème : à la place de B<PTRACE_CONT>, une commande B<PTRACE_LISTEN> peut être utilisée pour redémarrer un observé de façon à ce qu'il ne s'exécute pas, mais attende un nouvel événement qu'il peut signaler à l'aide de B<waitpid>(2) (comme s'il était redémarré par un B<SIGCONT>).

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).  Since Linux 3.0, B<PTRACE_GETEVENTMSG> returns the former thread ID.
fr: Arrêt avant le retour d'B<execve>(2). Depuis Linux 3.0, B<PTRACE_GETEVENTMSG> renvoie le premier identifiant de thread.

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

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

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 user-space 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 d'une 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 distinguish 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: 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: FIXME . document stops occurring with PTRACE_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_SEIZE>, B<PTRACE_TRACEME>, B<PTRACE_INTERRUPT>, 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_SEIZE>, B<PTRACE_TRACEME>, B<PTRACE_INTERRUPT> 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_LISTEN>, 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_LISTEN>, 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: type: Plain text
en: or
fr: ou

note: FIXME Describe how to attach to a thread which is already group-stopped. type: Plain text
en: B<PTRACE_ATTACH> 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: B<PTRACE_ATTACH> envoie aussi B<SIGSTOP> à ce thread. Si l'observateur veut 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 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 B<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 B<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: Since Linux 3.4, B<PTRACE_SEIZE> can be used instead of B<PTRACE_ATTACH>.  B<PTRACE_SEIZE> does not stop the attached process.  If you need to stop it after attach (or at any other time) without sending it any signals, use B<PTRACE_INTERRUPT> command.
fr: Depuis Linux 3.4, B<PTRACE_SEIZE> peut être utilisé à la place de B<PTRACE_ATTACH>. B<PTRACE_SEIZE> n'arrête pas le processus attaché. Si vous devez l'arrêter après attachement (ou à n'importe quel autre moment) sans lui envoyer de signal du tout, utilisez la commande B<PTRACE_INTERRUPT>.

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) CLONE_THREAD 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: 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: 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: If the thread group leader has reported its B<PTRACE_EVENT_EXIT> stop by this time, it appears to the tracer that the dead thread leader "reappears from nowhere".  (Note: the thread group leader does not report death via I<WIFEXITED(status)> until there is at least one other live thread.  This eliminates the possibility that the tracer will see it dying and then reappearing.)  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é son arrêt B<PTRACE_EVENT_EXIT> pendant ce temps, le leader de thread mort à l'air de « revenir de nulle part » du point de vue de l'observateur (remarque : le leader de groupe de threads ne signale pas sa mort à l'aide de I<WIFEXITED(status)> tant qu'au moins un autre thread est en vie. Cela enlève la possibilité à l'observateur de le voir mourir puis réapparaître). 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: 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: 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-enter-stop in thread 1: **
    PID1 execve("/bin/foo", "foo" E<lt>unfinished ...E<gt>
    *** we issue PTRACE_SYSCALL for thread 1 **
    *** we get syscall-enter-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: 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: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: Plain text
en: 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: B<ptrace>() renvoie -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: SH
en: ERRORS
fr: ERREURS

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 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: SH
en: CONFORMING TO
fr: CONFORMITÉ

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.  It is recommended to always supply four arguments, even if the requested operation does not use them, setting unused/ignored arguments to I<0L> or I<(void\ *)\ 0>.
fr: Bien que les arguments de B<ptrace>() soient interprétés comme dans le  prototype donné, la bibliothèque glibc déclare B<ptrace> comme une fonction variadique où seul l'argument I<request> est corrigé. Il vaut mieux toujours fournir quatre arguments, même si l'opération demandée ne les utilise pas, en configurant les arguments non utilisés ou ignorés à I<0L> ou I<(void\ *)\ 0>.

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

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: This page documents the way the B<ptrace>()  call works currently in Linux.  Its behavior differs significantly 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 significativement 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: At the system call level, the B<PTRACE_PEEKTEXT>, B<PTRACE_PEEKDATA>, and B<PTRACE_PEEKUSER> requests have a different API: they store the result at the address specified by the I<data> parameter, and the return value is the error flag.  The glibc wrapper function provides the API given in DESCRIPTION above, with the result being returned via the function return value.
fr: L'interface de programmation de l'appel système est différente pour les requêtes  B<PTRACE_PEEKTEXT>, B<PTRACE_PEEKDATA> et B<PTRACE_PEEKUSER> : elles stockent le résultat à l’adresse indiquée par le paramètre I<data>, et la valeur de retour est l’attribut d’erreur. La fonction glibc encapsulant cet appel fournit une interface détaillée dans la section B<DESCRIPTION> ci-dessus, et le résultat qu'elle renvoie est le résultat de l'appel système.

note: type: SH
en: BUGS
fr: BOGUES

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: Some system calls return with B<EINTR> if a signal was sent to a tracee, but delivery was suppressed by the tracer.  (This is very typical operation: it is usually done by debuggers on every attach, in order to not introduce a bogus B<SIGSTOP>).  As of Linux 3.2.9, the following system calls are affected (this list is likely incomplete): B<epoll_wait>(2), and B<read>(2)  from an B<inotify>(7)  file descriptor.  The usual symptom of this bug is that when you attach to a quiescent process with the command
fr: Certains appels système renvoient B<EINTR> si un signal a été envoyé à l'observé, mais que la distribution a été supprimée par l'observateur (c'est une opération tout à fait caractéristique : elle est normalement réalisée par les débogueurs sur tous les attachements, afin de ne pas introduire de B<SIGSTOP> défectueux). Depuis Linux 3.2.9, les appels système suivants sont concernés (cette liste est sans doute incomplète) : B<epoll_wait>(2) et B<read>(2) depuis un descripteur de fichier B<inotify>(7). Le symptôme classique de ce bogue est qu'en attachant à un processus quiescent avec la commande

note: type: Plain text
en: then, instead of the usual and expected one-line output such as
fr: alors, au lieu de la ligne de sortie habituelle attendue comme

note: type: Plain text
en: ('_' denotes the cursor position), you observe more than one line.  For example:
fr: (« _ » indique la position du curseur), plusieurs lignes sont affichées. Par exemple :

note: type: Plain text
en: What is not visible here is that the process was blocked in B<epoll_wait>(2)  before B<strace>(1)  has attached to it.  Attaching caused B<epoll_wait>(2)  to return to user space with the error B<EINTR>.  In this particular case, the program reacted to B<EINTR> by checking the current time, and then executing B<epoll_wait>(2)  again.  (Programs which do not expect such "stray" B<EINTR> errors may behave in an unintended way upon an B<strace>(1)  attach.)
fr: Ce qui n'est pas visible ici est que le processus a été bloqué dans B<epoll_wait>(2) avant que B<strace>(1) ne s'y soit attaché. L'attachement a forcé B<epoll_wait>(2) à revenir dans l'espace utilisateur avec l'erreur B<EINTR>. Dans ce cas particulier, le programme a réagit à B<EINTR> en vérifiant l'heure actuelle et en exécutant encore B<epoll_wait>(2) (les programmes qui ne s'attendent pas à de telles erreurs B<EINTR> « perdue » risquent de se comporter de façon inattendue sur une attache B<strace>(1)).

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

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

note: type: TH
en: 2018-04-30
fr: 30 avril 2018

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

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