manpages-de 4.09 - en to de translation catalogue (321 entries)

note: type: TH
en: 2019-10-10
de: 10. Oktober 2019

note: type: TH
en: Linux Programmer's Manual
de: Linux-Programmierhandbuch

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: ptrace - process trace
de: ptrace - Prozessverfolgung

note: type: SH
en: SYNOPSIS
de: ÜBERSICHT

note: type: Plain text
en: B<long ptrace(enum __ptrace_request >I<request>B<, pid_t >I<pid>B<, >
    B<            void *>I<addr>B<, void *>I<data>B<);>
de: B<long ptrace(enum __ptrace_request >I<Anfrage>B<, pid_t >I<PID>B<, >
    B<            void *>I<Adresse>B<, void *>I<Daten>B<);>

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

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.
de: Der Systemaufruf B<ptrace>() stellt ein Mittel bereit, wodurch ein Prozess (der »Verfolger«) die Ausführung eines anderen Prozesses (des »verfolgten Prozesses«) beobachten und steuern kann und seinen Speicher sowie die Register untersuchen und ändern kann. Er wird in erster Linie benutzt, um Fehlersuche mittels Haltepunkten zu implementieren und Systemaufrufe zu verfolgen.

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
de: Ein verfolgter Prozess muss zuerst an den Verfolger angehängt werden. Anhängen und nachfolgende Befehle bestehen pro Thread: In einem Prozess mit mehreren Threads kann jeder Thread individuell an einen (möglicherweise unterschiedlichen) Verfolger angehängt werden oder nicht angehängt und folglich nicht auf Fehler untersucht werden. Daher bedeutet »verfolgter Prozess« immer »(ein) Thread«, niemals »ein Prozess (mit möglicherweise mehreren Threads)«. Ptrace-Befehle werden immer an einen bestimmten verfolgten Prozess gesandt. Der Aufruf hat folgende Form:

note: type: Plain text
en:     ptrace(PTRACE_foo, pid, ...)
de:     ptrace(PTRACE_foo, PID, …)

note: type: Plain text
en: where I<pid> is the thread ID of the corresponding Linux thread.
de: wobei I<PID> die Thread-Kennung des zugehörigen Linux-Threads ist.

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.)
de: (Beachten Sie, dass auf dieser Seite ein »Prozess aus mehreren Threads« eine Thread-Gruppe bezeichnet, die aus Threads besteht, die mittels des B<clone>(2)-Schalters B<CLONE_THREAD> erzeugt wurde.)

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>.
de: Ein Prozess kann eine Verfolgung mittels B<fork>(2) starten und als Ergebnis einen Kindprozess erhalten, der B<PTRACE_TRACEME> ausführt, was (üblicherweise) von einem B<execve>(2) gefolgt wird. Alternativ kann ein Prozess die Verfolgung eines anderen Prozesses mittels B<PTRACE_ATTACH> oder B<PTRACE_SEIZE> beginnen.

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).
de: Während der Prozess verfolgt wird, wird er jedesmal stoppen, wenn ein Signal gesandt wird, sogar wenn das Signal ignoriert wird. (Eine Ausnahme ist B<SIGKILL>, das seine normale Wirkung erzielt.) Der Verfolger wird bei seinem nächsten Aufruf von B<waitpid>(2) (oder den zugehörigen »wait«-Systemaufrufen) benachrichtigt; dies wird einen I<Status>wert zurückgeben, der Informationen enthält, die den Grund angeben, weshalb der verfolgte Prozess stoppte. Während der verfolgte Prozess angehalten ist, kann der Verfolger verschiedene Ptrace-Anfragen verwenden, um den verfolgten Prozess zu untersuchen und zu verändern. Dann veranlasst der Verfolger den verfolgten Prozess fortzufahren und wahlweise das versandte Signal zu ignorieren (oder stattdessen sogar ein anderes Signal zu senden).

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.
de: Falls die Option B<PTRACE_O_TRACEEXEC> nicht in Kraft ist, werden alle erfolgreichen Aufrufe von B<execve>(2) durch den verfolgten Prozess zum Senden eines B<SIGTRAP>-Signals veranlassen, um dem Elternprozess die Möglichkeit zu geben, die Kontrolle zu erlangen, bevor die Ausführung des neuen Programms beginnt.

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>.
de: Wenn der Verfolger die Verfolgung beendet hat, kann er veranlassen, das der verfolgte Prozess mit B<PTRACE_DETACH> in einem normal Modus ohne Verfolgung fortfährt.

note: type: Plain text
en: The value of I<request> determines the action to be performed:
de: Der Wert des Arguments I<Anfrage> legt die Aktion des Systemaufrufs fest:

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.)
de: zeigt an, dass dieser Prozess durch seinen Elternprozess verfolgt wird. Ein Prozess sollte diese Anfrage wahrscheinlich nicht stellen, falls sein Elternprozess nicht erwartet, ihn zu verfolgen.(I<PID>, I<Adresse> und I<Daten> werden ignoriert.)

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.
de: Die B<PTRACE_TRACEME>-Anfrage wird nur vom verfolgten Prozess benutzt; die verbleibenden Anfragen werden nur vom verfolgenden Prozess benutzt. In den folgenden Anfragen gibt I<PID> die Thread-Kennung des verfolgten Prozesses an, der beeinflusst werden soll. Für andere Anfragen als B<PTRACE_ATTACH>, B<PTRACE_SEIZE>, B<PTRACE_INTERRUPT> und B<PTRACE_KILL> muss der verfolgte Prozess gestoppt werden.

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.)
de: liest ein »word« an der Stelle I<Adresse> im Speicher des verfolgten Prozesses und gibt das »word« als Ergebnis des B<ptrace>()-Aufrufs zurück. Linux hat keine separaten Adressräume für Text und Daten, daher sind diese beiden Anfragen derzeit gleichwertig. (Das Argument I<Daten> wird ignoriert, lesen Sie aber auch ANMERKUNGEN.)

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.)
de: Liest ein »word« bei Versatz I<Adresse> im BENUTZERbereich des verfolgten Prozesses, der die Register und andere Informationen über den Prozess enthält (siehe I<E<lt>sys/user.hE<gt>>). Das »word« wird als Ergebnis des B<ptrace>()-Aufrufs zurückgegeben. Typischerweise muss der Versatz am »word« ausgerichtet sein, obwohl dies je nach Architektur variieren kann. Lesen Sie die ANMERKUNGEN. (I<Daten> wird ignoriert, lesen Sie aber auch ANMERKUNGEN.)

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.
de: kopiert das »word« I<Daten> an die Stelle I<Adresse> im Speicher des verfolgenden Prozesses. Wie bei B<PTRACE_PEEKTEXT> und B<PTRACE_PEEKDATA> sind die beiden Anfragen derzeit gleichwertig.

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.
de: kopiert das »word« I<Daten> an den Versatz I<Adresse> im BENUTZERbereich des verfolgten Prozesses. Wie für B<PTRACE_PEEKUSER> muss der Versatz am »word« ausgerichtet sein. Um die Integrität des Kernels aufrecht zu erhalten, sind einige Änderungen in BENUTZERbereich nicht erlaubt.

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.
de: kopiert die Mehrzweck- beziehungsweise Fließpunktregister des verfolgten Prozesses an die Stelle I<Daten> im Verfolger. Lesen Sie I<E<lt>sys/user.hE<gt>>, um Informationen über das Format dieser Daten zu erhalten. (I<Adresse> wird ignoriert.) Beachten Sie, dass auf SPARC-Systemen die Bedeutung von I<Daten> und I<Adresse> umgekehrt ist; daher wird I<Daten> ignoriert und die Register werden an die Adresse I<Adresse> kopiert. B<PTRACE_GETREGS> und B<PTRACE_GETFPREGS> sind nicht auf allen Architekturen verfügbar.

note: type: TP
en: B<PTRACE_GETREGSET> (since Linux 2.6.34)
de: B<PTRACE_GETREGSET> (seit 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.
de: liest die Register des verfolgten Prozesses. I<Adresse> gibt auf eine von der Architektur unabhängige Weise den Typ des Registers an, das gelesen werden soll. B<NT_PRSTATUS> (mit numerischem Wert 1) führt normalerweise dazu, dass Allzweckregister gelesen werden. Falls die CPU zum Beispiel Fließkomma- und/oder Vektorregister hat, können sie durch Setzen von I<Adresse> auf die entsprechende Konstante B<NT_foo> ermittelt werden. I<Daten> zeigt auf einen B<struct iovec>, der den Speicherort und die Länge des Zielpuffers beschreibt. Bei der Rückkehr ändert der Kernel B<iov.len>, um die tatsächliche Anzahl zurückgegebener Byte anzuzeigen.

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.
de: verändert die Mehrzweck- beziehungsweise Fließpunktregister des verfolgten Prozesses von der Adresse I<Daten> im Verfolger. Wie für B<PTRACE_POKEUSER> können einige Änderungen am Mehrzweckregister verboten sein. (I<Adresse> wird ignoriert.) Beachten Sie, dass auf SPARC-Systemen die Bedeutung von I<Daten> und I<Adresse> umgekehrt ist; daher wird I<Daten> ignoriert und die Register werden von der Adresse I<Adresse> kopiert. B<PTRACE_SETREGS> und B<PTRACE_SETFPREGS> sind nicht auf allen Architekturen verfügbar.

note: type: TP
en: B<PTRACE_SETREGSET> (since Linux 2.6.34)
de: B<PTRACE_SETREGSET> (seit 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>.
de: verändert die Register des verfolgten Prozesses. Die Bedeutung von I<Adresse> und I<Daten> ist analog zu B<PTRACE_GETREGSET>.

note: type: TP
en: B<PTRACE_GETSIGINFO> (since Linux 2.3.99-pre6)
de: B<PTRACE_GETSIGINFO> (seit 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.)
de: ruft Informationen über das Signal ab, das den Stopp verursachte. Kopiert eine I<siginfo_t>-Struktur (siehe B<sigaction>(2)) vom verfolgten Prozess an die Stelle I<Daten> im Verfolger. (I<Adresse> wird ignoriert.)

note: type: TP
en: B<PTRACE_SETSIGINFO> (since Linux 2.3.99-pre6)
de: B<PTRACE_SETSIGINFO> (seit 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.)
de: setzt Signalinformationen: kopiert eine I<siginfo_t>-Struktur von der Adresse I<Daten> vom verfolgenden zum verfolgten Prozess. Dies wird nur Signale betreffen, die normalerweise an den verfolgten Prozess zugestellt würden und vom Verfolger abgefangen wurden. Es könnte schwierig werden, diese normalen Signale von künstlichen Signalen zu unterscheiden, die von B<ptrace>() selbst generiert wurden. (I<Adresse> wird ignoriert.)

note: type: TP
en: B<PTRACE_PEEKSIGINFO> (since Linux 3.10)
de: B<PTRACE_PEEKSIGINFO> (seit 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.
de: fragt I<siginfo_t>-Strukturen ab, ohne Signale aus einer Warteschlange zu entfernen. I<Adresse> zeigt auf eine I<ptrace_peeksiginfo_args>-Struktur, die die Ordnungsposition angibt, von der das Kopieren der Signale starten soll sowie die Anzahl zu kopierender Signale. I<siginfo_t>-Strukturen werden in den Puffer kopiert, auf den I<Daten> verweist. Der Rückgabewert enthält die Anzahl der kopierten Signale (null zeigt an, dass es an der angegebenen Ordnungsposition kein entsprechendes Signal gibt). Innerhalb der zurückgegebenen I<siginfo>-Strukturen enthält das Feld I<si_code> Informationen (B<__SI_CHLD>, B<__SI_FAULT>, etc.), die ansonsten nicht an den Anwendungsraum offengelegt werden.

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 */
    };
de: struct ptrace_peeksiginfo_args {
        u64 off;    /* Ordnungsposition in der Warteschlange, an der
                       mit dem Kopieren der Signale begonnen wird */
        u32 flags;  /* PTRACE_PEEKSIGINFO_SHARED oder 0 */
        s32 nr;     /* Anzahl zu kopierender Signale */
    };

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.
de: Derzeit gibt es nur einen Schalter, B<PTRACE_PEEKSIGINFO_SHARED>, um Signale aus der prozessweiten Signalwarteschlange auszugeben. Falls dieser Schalter nicht gesetzt ist, werden Signale von der Thread-eigenen Warteschlange des angegebenen Threads gelesen.

note: type: TP
en: B<PTRACE_GETSIGMASK> (since Linux 3.11)
de: B<PTRACE_GETSIGMASK> (seit 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)>).
de: Platzieren Sie eine Kopie der Maske blockierter Signale (siehe B<sigprocmask>(2)) in den Puffer, auf den I<Daten> zeigt. Dies sollte ein Zeiger auf einen Puffer des Typs I<sigset_t> sein. Das Argument I<Adresse> enthält die Größe des Puffers, auf den I<Daten> zeigt (d.h. I<sizeof(sigset_t)>).

note: type: TP
en: B<PTRACE_SETSIGMASK> (since Linux 3.11)
de: B<PTRACE_SETSIGMASK> (seit 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)>).
de: ändert die Maske blockierter Signale (siehe B<sigprocmask>(2)) auf den Wert, der im Puffer angegeben wird, auf den I<Daten> zeigt. Dies sollte ein Zeiger auf einen Puffer des Typs I<sigset_t> sein. Das Argument I<Adresse> enthält die Größe des Puffers, auf den I<Daten> zeigt (d.h. I<sizeof(sigset_t)>).

note: type: TP
en: B<PTRACE_SETOPTIONS> (since Linux 2.4.6; see BUGS for caveats)
de: B<PTRACE_SETOPTIONS> (seit Linux 2.4.6; siehe FEHLER für Vorsichtsmaßnahmen)

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:
de: setzt Ptrace-Optionen von I<Daten>. (I<Adresse> wird ignoriert.) I<Daten> wird als Bit in der Maske der Optionen interpretiert, die durch die folgenden Schalter angegeben wird:

note: type: TP
en: B<PTRACE_O_EXITKILL> (since Linux 3.8)
de: B<PTRACE_O_EXITKILL> (seit Linux 3.8)

note: commit 992fb6e170639b0849bace8e49bf31bd37c4123 type: Plain text
en: Send a B<SIGKILL> signal to the tracee if the tracer exits.  This option is useful for ptrace jailers that want to ensure that tracees can never escape the tracer's control.
de: schickt an den verfolgten Prozess ein B<SIGKILL>-Signal, falls der verfolgende Prozess beendet wird. Diese Option ist für diejenigen nützlich, die Ptrace einsperren und sicherstellen wollen, dass der verfolgte Prozess nie der Steuerung des verfolgenden Prozesses entkommt.

note: type: TP
en: B<PTRACE_O_TRACECLONE> (since Linux 2.5.46)
de: B<PTRACE_O_TRACECLONE> (seit 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
de: stoppt den verfolgten Prozess beim nächsten Aufruf von B<clone>(2) und startet automatisch die Verfolgung des neu geklonten Prozesses, der mit einem B<SIGSTOP> oder, falls B<PTRACE_SEIZE> benutzt wurde, mit B<PTRACE_EVENT_STOP> starten wird. Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie diesen zurückgeben:

note: type: Plain text
en: The PID of the new process can be retrieved with B<PTRACE_GETEVENTMSG>.
de: Die PID des neuen Prozesses kann mit B<PTRACE_GETEVENTMSG> abgefragt werden.

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.
de: Diese Option kann nicht in allen Fällen B<clone>(2)-Aufrufe abfangen. Falls der verfolgte Prozess B<clone>(2) mit dem Schalter B<CLONE_VFORK> aufruft, wird stattdessen B<PTRACE_EVENT_VFORK> geschickt, wenn B<PTRACE_O_TRACEVFORK> gesetzt ist; andernfalls wird B<PTRACE_EVENT_FORK> geschickt, wenn der verfolgte Prozess B<clone>(2) mit dem auf B<SIGCHLD> gesetzten Beendigungssignal aufgerufen wird, falls B<PTRACE_O_TRACEFORK> gesetzt ist.

note: type: TP
en: B<PTRACE_O_TRACEEXEC> (since Linux 2.5.46)
de: B<PTRACE_O_TRACEEXEC> (seit 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
de: stoppt den verfolgten Prozess beim nächsten B<execve>(2). Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie diesen zurückgeben:

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>.
de: Falls der ausführende Thread kein führender Thread der Gruppe ist, wird die Thread-Kennung vor dem Stopp auf die Kennung des führenden Threads der Gruppe zurückgesetzt. Seit Linux 3.0 kann die vorherige Thread-Kennung mit B<PTRACE_GETEVENTMSG> abgefragt werden.

note: type: TP
en: B<PTRACE_O_TRACEEXIT> (since Linux 2.5.60)
de: B<PTRACE_O_TRACEEXIT> (seit 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
de: stoppt den verfolgten Prozess beim Beenden. Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie diesen zurückgeben:

note: type: Plain text
en: The tracee's exit status can be retrieved with B<PTRACE_GETEVENTMSG>.
de: Der Exit-Status des verfolgten Prozesses kann mit B<PTRACE_GETEVENTMSG> abgefragt werden.

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.
de: Der verfolgte Prozess wird frühzeitig während des Beendens gestoppt, wenn die Register noch verfügbar sind, was es dem Verfolger ermöglicht, zu sehen, wo das Beenden veranlasst wurde, wohingegen die normale Benachrichtigung über die Beendigung geschickt wird, wenn der Prozess das Beenden abgeschlossen hat. Auch wenn der Kontext verfügbar ist, kann der Verfolger das Beenden an diesem Punkt nicht mehr verhindern.

note: type: TP
en: B<PTRACE_O_TRACEFORK> (since Linux 2.5.46)
de: B<PTRACE_O_TRACEFORK> (seit 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
de: stoppt den verfolgten Prozess beim nächsten Aufruf von B<fork>(2) und startet die Verfolgung des neuen Prozesszweiges, der mit einem B<SIGSTOP> oder, falls B<PTRACE_SEIZE> benutzt wurde, mit B<PTRACE_EVENT_STOP> starten wird. Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie diesen zurückgeben:

note: type: TP
en: B<PTRACE_O_TRACESYSGOOD> (since Linux 2.4.6)
de: B<PTRACE_O_TRACESYSGOOD> (seit Linux 2.4.6)

note: type: Plain text
en: When delivering system call traps, set bit 7 in the signal number (i.e., deliver I<SIGTRAP|0x80>).  This makes it easy for the tracer to distinguish normal traps from those caused by a system call.
de: Wenn Systemaufrufe abgefangen werden, wird Bit 7 in der Signalnummer gesetzt (d.h. I<SIGTRAP | 0x80> geschickt). Dies erleichtert es dem Verfolger, den Unterschied zwischen normalen, abgefangenen Signalen und denen, die durch einen Systemaufruf verursacht wurden, mitzuteilen.

note: type: TP
en: B<PTRACE_O_TRACEVFORK> (since Linux 2.5.46)
de: B<PTRACE_O_TRACEVFORK> (seit 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
de: stoppt den verfolgten Prozess beim nächsten Aufruf von B<vfork>(2) und startet automatisch die Verfolgung des neuen »vfork«-Prozesszweiges, der mit einem B<SIGSTOP> oder, falls B<PTRACE_SEIZE> benutzt wurde, mit B<PTRACE_EVENT_STOP> starten wird. Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie diesen zurückgeben:

note: type: TP
en: B<PTRACE_O_TRACEVFORKDONE> (since Linux 2.5.60)
de: B<PTRACE_O_TRACEVFORKDONE> (seit 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
de: stoppt den verfolgten Prozess bei Vollendung des nächsten B<vfork>(2). Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie diesen zurückgeben:

note: type: Plain text
en: The PID of the new process can (since Linux 2.6.18) be retrieved with B<PTRACE_GETEVENTMSG>.
de: Die PID des neuen Prozesses kann (seit Linux 2.6.18) abgefragt werden mit

note: type: TP
en: B<PTRACE_O_TRACESECCOMP> (since Linux 3.5)
de: B<PTRACE_O_TRACESECCOMP> (seit Linux 3.5)

note: type: Plain text
en: Stop the tracee when a B<seccomp>(2)  B<SECCOMP_RET_TRACE> rule is triggered.  A B<waitpid>(2)  by the tracer will return a I<status> value such that
de: stoppt den verfolgten Prozess, wenn eine B<seccomp>(2) B<SECCOMP_RET_TRACE>-Regel ausgelöst wird. Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie diesen zurückgeben:

note: type: Plain text
en: While this triggers a B<PTRACE_EVENT> stop, it is similar to a syscall-enter-stop.  For details, see the note on B<PTRACE_EVENT_SECCOMP> below.  The seccomp event message data (from the B<SECCOMP_RET_DATA> portion of the seccomp filter rule) can be retrieved with B<PTRACE_GETEVENTMSG>.
de: Während dies ein B<PTRACE_EVENT>-Stopp auslöst, ist es einem Systemaufrufeintrittsstopp ähnlich. Für Details lesen Sie die Bemerkungen über B<PTRACE_EVENT_SECCOMP> weiter unten. Die Seccomp-Ereignisnachrichtendaten (aus dem Abschnitt B<SECCOMP_RET_DATA> der Seccomp-Filterregel) können über B<PTRACE_GETEVENTMSG> ermittelt werden.

note: type: TP
en: B<PTRACE_O_SUSPEND_SECCOMP> (since Linux 4.3)
de: B<PTRACE_O_SUSPEND_SECCOMP> (seit Linux 4.3)

note: commit 13c4a90119d28cfcb6b5bdd820c233b86c2b0237 type: Plain text
en: Suspend the tracee's seccomp protections.  This applies regardless of mode, and can be used when the tracee has not yet installed seccomp filters.  That is, a valid use case is to suspend a tracee's seccomp protections before they are installed by the tracee, let the tracee install the filters, and then clear this flag when the filters should be resumed.  Setting this option requires that the tracer have the B<CAP_SYS_ADMIN> capability, not have any seccomp protections installed, and not have B<PTRACE_O_SUSPEND_SECCOMP> set on itself.
de: setzt den Seccomp-Schutz des verfolgten Prozesses aus. Dies gilt unabhängig vom Modus und kann verwandt werden, wenn der verfolgte Prozess noch keine Seccomp-Filter installiert hat. Das bedeutet, dass ein gültiger Anwendungsfall darin besteht, den Seccomp-Schutz auszusetzen, bevor er von dem verfolgten Prozess installiert wird, dann den verfolgten Prozess die Filter installieren zu lassen und danach diesen Schalter wieder zurückzusetzen, wenn die Filter wiederaufgenommen werden sollen. Um diese Option zu setzen, muss der verfolgende Prozess über die Capability B<CAP_SYS_ADMIN> verfügen, er darf selber keinen Seccomp-Schutz installiert haben und darf nicht B<PTRACE_O_SUSPEND_SECCOMP> auf sich selbst setzen.

note: type: TP
en: B<PTRACE_GETEVENTMSG> (since Linux 2.5.46)
de: B<PTRACE_GETEVENTMSG> (seit Linux 2.5.46)

note: type: Plain text
en: Retrieve a message (as an I<unsigned long>)  about the ptrace event that just happened, placing it at the address I<data> in the tracer.  For B<PTRACE_EVENT_EXIT>, this is the tracee's exit status.  For B<PTRACE_EVENT_FORK>, B<PTRACE_EVENT_VFORK>, B<PTRACE_EVENT_VFORK_DONE>, and B<PTRACE_EVENT_CLONE>, this is the PID of the new process.  For B<PTRACE_EVENT_SECCOMP>, this is the B<seccomp>(2)  filter's B<SECCOMP_RET_DATA> associated with the triggered rule.  (I<addr> is ignored.)
de: fragt eine Nachricht (als I<unsigned long>) über das Ptrace-Ereignis, das einfach so auftrat, ab und platziert es an die Adresse I<Daten> im Verfolger. Für B<PTRACE_EVENT_EXIT> ist dies der Exit-Status des verfolgten Prozesses. Für B<PTRACE_EVENT_FORK>, B<PTRACE_EVENT_VFORK> und B<PTRACE_EVENT_CLONE> ist dies die PID des neuen Prozesses. Für B<PTRACE_EVENT_SECCOMP> ist das B<SECCOMP_RET_DATA> von B<seccomp>(2)s Filter, das der ausgelösten Regel zugeordnet ist. (I<Adresse> wird ignoriert.)

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.)
de: startet den gestoppten, verfolgten Prozess erneut. Falls I<Daten> nicht null ist, wird es als Nummer des Signals interpretiert, das an den verfolgten Prozess geschickt wird; andernfalls wird kein Signal geschickt. Dadurch kann der Verfolger zum Beispiel steuern, ob ein Signal an den verfolgten Prozess geschickt wird oder nicht. (I<Adresse> wird ignoriert.)

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.)
de: startet den gestoppten, verfolgten Prozess wie für B<PTRACE_CONT>, arrangiert aber, dass der verfolgte Prozess beim nächsten Eintritt oder einem Systemaufruf beziehungsweise nach der Ausführung einer einzelnen Anweisung gestoppt wird. (Der verfolgte Prozess wird auch, wie üblich, über den Empfang des Signals gestoppt.) Aus der Sicht des Verfolgers scheint es, als ob der verfolgte Prozess durch Empfang eines B<SIGTRAP> gestoppt wurde. Daher gibt es zum Beispiel für B<PTRACE_SYSCALL> die Idee, beim ersten Stopp die Argumente des Systemaufrufs zu prüfen, dann einen anderen B<PTRACE_SYSCALL> zu schicken und den Rückgabewert des Systemaufrufs am zweiten Stopp zu prüfen. Das Argument I<Daten> wird wie für B<PTRACE_CONT> behandelt. (I<Adresse> wird ignoriert.)

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

note: As at 3.7 type: Plain text
en: For B<PTRACE_SYSEMU>, continue and stop on entry to the next system call, which will not be executed.  See the documentation on syscall-stops below.  For B<PTRACE_SYSEMU_SINGLESTEP>, do the same but also singlestep if not a system call.  This call is used by programs like User Mode Linux that want to emulate all the tracee's system calls.  The I<data> argument is treated as for B<PTRACE_CONT>.  The I<addr> argument is ignored.  These requests are currently supported only on x86.
de: für B<PTRACE_SYSEMU> beim nächsten Eintritt für den Systemaufruf, der nicht ausgeführt wird, fortfahren und stoppen. Siehe die Dokumentation zu Systemaufrufstopps weiter unten. Für B<PTRACE_SYSEMU_SINGLESTEP> das gleiche tun, aber in einem einzigen Schritt, wenn es sich nicht um einen Systemaufruf handelt. Dieser Aufruf wird von Programmen wie »User Mode Linux« verwandt, die die Systemaufrufe des verfolgten Prozesses emulieren wollen. Das Argument I<Daten> wird wie für B<PTRACE_CONT> behandelt. Das Argument I<Adresse> wird ignoriert. Diese Anfragen werden derzeit nur unter x86 unterstützt.

note: type: TP
en: B<PTRACE_LISTEN> (since Linux 3.4)
de: B<PTRACE_LISTEN> (seit 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>.
de: startet den gestoppten verfolgten Prozess erneut, verhindert jedoch seine Ausführung. Der resultierende Status ist dem eines Prozesses ähnlich, der durch ein B<SIGSTOP> (oder ein anderes Stoppsignal) angehalten wurde. Zusätzliche Informationen finden Sie im Unterabschnitt »Gruppenstopp«. B<PTRACE_LISTEN> funktioniert nur bei verfolgten Prozessen, die durch B<PTRACE_SEIZE> angehängt wurden.

note: type: Plain text
en: Send the tracee a B<SIGKILL> to terminate it.  (I<addr> and I<data> are ignored.)
de: sendet dem verfolgten Prozess ein B<SIGKILL>, um ihn zu beenden. (I<Adresse> und I<Daten> werden ignoriert.)

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.
de: I<Diese Aktion ist überholt; benutzen Sie sie nicht!> Senden Sie stattdessen ein B<SIGKILL> direkt mittels B<kill>(2) oder B<tgkill>(2). Das Problem bei B<PTRACE_KILL> ist, dass es verlangt, dass sich der verfolgte Prozess in einem Signallieferstopp befindet, andernfalls funktioniert es möglicherweise nicht (d.h. es könnte komplett erfolgreich sein, würde aber den verfolgten Prozess killen). Im Gegensatz dazu hat das direkte Senden von einem B<SIGKILL> keine derartige Beschränkung.

note: type: TP
en: B<PTRACE_INTERRUPT> (since Linux 3.4)
de: B<PTRACE_INTERRUPT> (seit 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>.
de: stoppt einen verfolgten Prozess. Falls der verfolgte Prozess im Kernel-Space läuft oder schläft und B<PTRACE_SYSCALL> in Kraft ist, wird der Systemaufruf unterbrochen und Systemaufrufbeendigungsstopp gemeldet. (Der unterbrochene Systemaufruf wird beim Neustart des verfolgten Prozesses ebenfalls neu gestartet.) Falls der verfolgte Prozess bereits durch ein Signal gestoppt und B<PTRACE_LISTEN> an ihn gesendet wurde, stoppt der verfolgte Prozess mit B<PTRACE_EVENT_STOP> und I<WSTOPSIG(Status)> gibt das Stoppsignal zurück. Falls zur selben Zeit irgendein anderes »ptrace-stop« erzeugt wird (zum Beispiel, weil ein Signal an den verfolgten Prozess gesendet wird), tritt dieses »ptrace-stop« auf. Falls nichts von obigem zutrifft (zum Beispiel, weil der verfolgte Prozess im Anwendungsraum läuft), stoppt er mit B<PTRACE_EVENT_STOP> mit I<WSTOPSIG(status)> == B<SIGTRAP>. B<PTRACE_INTERRUPT> funktioniert nur bei verfolgten Prozessen, die durch B<PTRACE_SEIZE> angehängt wurden.

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.)
de: hängt an den Prozess, der durch I<PID> angegeben wird, an und lässt ihn zum verfolgten Prozess des aufrufenden Prozesses werden. Dem verfolgten Prozess wird ein B<SIGSTOP> gesandt, er wird aber nicht notwendigerweise durch die Vollendung dieses Aufrufs gestoppt; benutzen Sie B<waitpid>(2), um auf das Stoppen des verfolgten Prozesses zu warten. Lesen Sie den Unterabschnitt »Anhängen und Loslösen«, um zusätzliche Informationen zu erhalten. (I<Adresse> und I<Daten> werden ignoriert.)

note: type: Plain text
en: Permission to perform a B<PTRACE_ATTACH> is governed by a ptrace access mode B<PTRACE_MODE_ATTACH_REALCREDS> check; see below.
de: Berechtigungen, ein B<PTRACE_ATTACH> durchzuführen, werden durch eine Ptrace-Zugriffsmodus-B<PTRACE_MODE_ATTACH_REALCREDS>-Überprüfung geregelt; siehe unten.

note: type: TP
en: B<PTRACE_SEIZE> (since Linux 3.4)
de: B<PTRACE_SEIZE> (seit Linux 3.4)

note: Noted by Dmitry Levin: PTRACE_SEIZE was introduced by commit v3.1-rc1~308^2~28, but it had to be used along with a temporary flag PTRACE_SEIZE_DEVEL, which was removed later by commit v3.4-rc1~109^2~20. That is, [before] v3.4 we had a test mode of PTRACE_SEIZE API, which was not compatible with the 
en: Attach to the process specified in I<pid>, making it a tracee of the calling process.  Unlike B<PTRACE_ATTACH>, B<PTRACE_SEIZE> does not stop the process.  Group-stops are reported as B<PTRACE_EVENT_STOP> and I<WSTOPSIG(status)> returns the stop signal.  Automatically attached children stop with B<PTRACE_EVENT_STOP> and I<WSTOPSIG(status)> returns B<SIGTRAP> instead of having B<SIGSTOP> signal delivered to them.  B<execve>(2)  does not deliver an extra B<SIGTRAP>.  Only a B<PTRACE_SEIZE>d process can accept B<PTRACE_INTERRUPT> and B<PTRACE_LISTEN> commands.  The "seized" behavior just described is inherited by children that are automatically attached using B<PTRACE_O_TRACEFORK>, B<PTRACE_O_TRACEVFORK>, and B<PTRACE_O_TRACECLONE>.  I<addr> must be zero.  I<data> contains a bit mask of ptrace options to activate immediately.
de: hängt an den zu dem in I<PID> angegebenen Prozess an, wodurch er ein verfolgter Prozess des aufrufenden Prozesses wird. Anders als B<PTRACE_ATTACH> beendet B<PTRACE_SEIZE> den Prozess nicht. Gruppenstopps werden als B<PTRACE_EVENT_STOP> berichtet und I<WSTOPSIG(status)> liefert das Stopp-Signal zurück. Automatisch angehängte Kinder stoppen mit B<PTRACE_EVENT_STOP> und I<WSTOPSIG(status)> liefert B<SIGTRAP> zurück, statt ein B<SIGSTOP> Signal geliefert zu bekommen. B<execve>(2) liefert kein zusätzliches B<SIGTRAP> aus. Nur ein Prozess, der B<PTRACE_SEIZE> ist, kann die Befehle B<PTRACE_INTERRUPT> und B<PTRACE_LISTEN> akzeptieren. Das gerade beschriebene »beschlagnahmte« (engl. »seized«) Verhalten wird von Kindern geerbt, die automatisch mittels B<PTRACE_O_TRACEFORK>, B<PTRACE_O_TRACEVFORK> und B<PTRACE_O_TRACECLONE> angehängt sind. I<Adresse> muss Null sein. I<Daten> enthält eine Bitmaske, die die sofort zu aktivierenden Optionen enthält.

note: type: Plain text
en: Permission to perform a B<PTRACE_SEIZE> is governed by a ptrace access mode B<PTRACE_MODE_ATTACH_REALCREDS> check; see below.
de: Berechtigungen, ein B<PTRACE_SEIZE> durchzuführen, werden durch eine Ptrace-Zugriffsmodus-B<PTRACE_MODE_ATTACH_REALCREDS>-Überprüfung geregelt; siehe unten.

note: type: TP
en: B<PTRACE_SECCOMP_GET_FILTER> (since Linux 4.4)
de: B<PTRACE_SECCOMP_GET_FILTER> (seit Linux 4.4)

note: commit f8e529ed941ba2bbcbf310b575d968159ce7e895 type: Plain text
en: This operation allows the tracer to dump the tracee's classic BPF filters.
de: Diese Aktion erlaubt es dem verfolgenden Prozess, die klassischen BPF-Filter des verfolgten Prozesses auszugeben.

note: type: Plain text
en: I<addr> is an integer specifying the index of the filter to be dumped.  The most recently installed filter has the index 0.  If I<addr> is greater than the number of installed filters, the operation fails with the error B<ENOENT>.
de: I<Adresse> ist eine Ganzzahl, die den Index des Filters, der ausgegeben werden soll, festlegt. Der neuste installierte Filter hat den Index 0. Falls I<Adresse> größer als die Anzahl der installierten Filter ist, schlägt die Aktion mit dem Fehler B<ENOENT> fehl.

note: type: Plain text
en: I<data> is either a pointer to a I<struct sock_filter> array that is large enough to store the BPF program, or NULL if the program is not to be stored.
de: I<Daten> ist entweder ein Zeiger auf ein Feld I<struct sock_filter>, das groß genug ist, ein BPF-Programm zu speichern, oder NULL, falls das Programm nicht gespeichert werden soll.

note: type: Plain text
en: Upon success, the return value is the number of instructions in the BPF program.  If I<data> was NULL, then this return value can be used to correctly size the I<struct sock_filter> array passed in a subsequent call.
de: Im Erfolgsfall ist der Rückgabewert die Anzahl der Befehle in dem BPF-Programm. Falls I<Daten> NULL war, dann kann dieser Rückgabewert benutzt werden, um in einem folgenden Aufruf die korrekte Größe des Feldes I<struct sock_filter> zu übergeben.

note: type: Plain text
en: This operation fails with the error B<EACCES> if the caller does not have the B<CAP_SYS_ADMIN> capability or if the caller is in strict or filter seccomp mode.  If the filter referred to by I<addr> is not a classic BPF filter, the operation fails with the error B<EMEDIUMTYPE>.
de: Diese Aktion schlägt mit dem Fehler B<EACCES> fehl, falls der Aufrufende nicht die Capability B<CAP_SYS_ADMIN> hat oder falls der Aufrufende in einem strikten oder Filter-Seccomp-Modus ist. Falls der durch I<Adresse> referenzierte Filter kein klassischer BPF-Filter ist, schlägt die Aktion mit dem Fehler B<EMEDIUMTYPE> fehl.

note: type: Plain text
en: This operation is available if the kernel was configured with both the B<CONFIG_SECCOMP_FILTER> and the B<CONFIG_CHECKPOINT_RESTORE> options.
de: Diese Aktion ist verfügbar, falls der Kernel mit den Optionen B<CONFIG_SECCOMP_FILTER> und B<CONFIG_CHECKPOINT_RESTORE> konfiguriert wurde.

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.)
de: startet den gestoppten, verfolgten Prozess wie für B<PTRACE_CONT>, löst ihn aber zuerst vom Prozess ab. Unter Linux kann ein verfolgter Prozess auf diese Art abgelöst werden, ohne Rücksicht darauf zu nehmen, welche Methode zum Starten der Verfolgung benutzt wurde. (I<Adresse> wird ignoriert.)

note: type: TP
en: B<PTRACE_GET_THREAD_AREA> (since Linux 2.6.0)
de: B<PTRACE_GET_THREAD_AREA> (seit Linux 2.6.0)

note: type: Plain text
en: This operation performs a similar task to B<get_thread_area>(2).  It reads the TLS entry in the GDT whose index is given in I<addr>, placing a copy of the entry into the I<struct user_desc> pointed to by I<data>.  (By contrast with B<get_thread_area>(2), the I<entry_number> of the I<struct user_desc> is ignored.)
de: Diese Aktion führt eine ähnliche Aufgabe wie B<get_thread_area>(2) durch. Sie liest den TLS-Eintrag in dem GDT, dessen Index in I<addr> gegeben ist und legt eine Kopie des Eintrags in das durch I<Daten> verwiesende I<struct user_desc>. (Im Gegensatz wird mit B<get_thread_area>(2) die I<entry_number> des I<struct user_desc> ignoriert.)

note: type: TP
en: B<PTRACE_SET_THREAD_AREA> (since Linux 2.6.0)
de: B<PTRACE_SET_THREAD_AREA> (seit Linux 2.6.0)

note: type: Plain text
en: This operation performs a similar task to B<set_thread_area>(2).  It sets the TLS entry in the GDT whose index is given in I<addr>, assigning it the data supplied in the I<struct user_desc> pointed to by I<data>.  (By contrast with B<set_thread_area>(2), the I<entry_number> of the I<struct user_desc> is ignored; in other words, this ptrace operation can't be used to allocate a free TLS entry.)
de: Diese Aktion führt eine ähnliche Aufgabe wie B<set_thread_area>(2) durch. Sie setzt den TLS-Eintrag in dem GDT, dessen Index in I<Adresse> gegeben ist, und weist ihm die in dem durch I<Daten> verwiesenen I<struct user_desc> zu. (Im Gegensatz zu B<set_thread_area>(2) wird die I<entry_number> des I<struct user_desc> ignoriert; mit anderen Worten, diese Ptrace-Aktion kann nicht zur Bereitstellung eines freien TLS-Eintrags verwandt werden.)

note: type: TP
en: B<PTRACE_GET_SYSCALL_INFO> (since Linux 5.3)
de: B<PTRACE_GET_SYSCALL_INFO> (seit Linux 5.3)

note: type: Plain text
en: The I<ptrace_syscall_info> structure contains the following fields:
de: Die Struktur I<ptrace_syscall_info> enthält die folgenden Felder:

note: type: SS
en: Death under ptrace
de: Tod unter 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).
de: Wenn ein Prozess (der möglicherweise aus mehreren Threads besteht) ein tötendes Signal erhält (eines, dessen Zuordnung auf B<SIG_DFL> gesetzt ist und dessen Standardaktion das Töten des Prozesses ist) werden alle Threads beendet. Verfolgte Prozesse melden ihren Tod an ihre(n) Verfolger. Die Benachrichtigung über dieses Ereignis wird über B<waitpid>(2) zugestellt.

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.)
de: Beachten Sie, dass das killende Signal zuerst einen Signallieferstopp (auf nur einen verfolgten Prozess) verursachen wird und nur nachdem es durch den Verfolger eingespeist wurde (oder nachdem es an einen nicht verfolgten Thread versandt wurde), wird der Tod von dem Signal auf I<alle> verfolgten Prozesse innerhalb eines Prozesses mit mehreren Threads ausgehen. (Der Begriff »Signallieferstopp« wird nachfolgend erklärt.)

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.
de: B<SIGKILL> erzeugt keinen »Signallieferstopp«. Daher kann der Verfolger es nicht unterdrücken. B<SIGKILL> killt sogar innerhalb von Systemaufrufen (der Systemaufrufbeendigungsstopp wird nicht vorrangig vor dem Tod durch B<SIGKILL> erzeugt). Der reine Effekt besteht darin, dass B<SIGKILL> den Prozess (all seine Threads) immer killt, sogar dann, wenn einige Threads des Prozesses verfolgt werden.

note: type: Plain text
en: When the tracee calls B<_exit>(2), it reports its death to its tracer.  Other threads are not affected.
de: Wenn der verfolgte Prozess B<_exit>(2) aufruft, meldet er seinem Verfolger seinen Tod. Andere Threads werden nicht beeinflusst.

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.
de: Wenn irgendein Thread B<exit_group>(2) ausführt, meldet jeder verfolgte Prozess in dessen Gruppe seinen Tod an den Verfolger.

note: type: Plain text
en: If the B<PTRACE_O_TRACEEXIT> option is on, B<PTRACE_EVENT_EXIT> will happen before actual death.  This applies to exits via B<exit>(2), B<exit_group>(2), and signal deaths (except B<SIGKILL>, depending on the kernel version; see BUGS below), and when threads are torn down on B<execve>(2)  in a multithreaded process.
de: Falls die Option B<PTRACE_O_TRACEEXIT> aktiv ist, wird B<PTRACE_EVENT_EXIT> vor dem tatsächlichen Tod auftreten. Dies wird angewandt, um mittels B<exit>(2), B<exit_group>(2) und Todessignalen (ausgenommen B<SIGKILL>, abhängig von der Kernel-Version, siehe FEHLER unten) zu beenden und wenn Threads bei B<execve>(2) in einem Prozess mit mehreren Threads zerrissen werden.

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.
de: Der Verfolger kann nicht abschätzen, ob der von Ptrace gestoppte Prozess existiert. Es gibt mehrere Szenarien, in denen der verfolgte Prozess sterben kann, während er gestoppt ist (wie B<SIGKILL>). Daher muss der Verfolger vorbereitet werden, bei allen Ptrace-Aktionen einen B<ESRCH>-Fehler zu handhaben. Leider wird der gleiche Fehler zurückgegeben, falls der verfolgte Prozess existiert, aber nicht von Ptrace gestoppt wurde (für Befehle, die einen gestoppten, verfolgten Prozess erfordern) oder falls er nicht durch den Prozess verfolgt wird, der den Ptrace-Aufruf abschickte. Der Verfolger muss den Überblick über den »laufend«-/»gestoppt«-Status des verfolgten Prozesses behalten und B<ESRCH> nur dann als »verfolgter Prozess starb unerwartet« interpretieren, falls er weiß, dass der verfolgte Prozess beobachtet wurde, um in einen Ptrace-Stopp einzutreten. Beachten Sie, dass es keine Garantie gibt, dass I<waitpid(WNOHANG)> zuverlässig den Todesstatus des verfolgten Prozesses meldet, falls eine Ptrace-Aktion B<ESRCH> zurückgibt. I<waitpid(WNOHANG)> könnte stattdessen 0 zurückgeben. In anderen Worten kann es sein, dass der verfolgte Prozess »noch nicht vollständig tot« ist, aber bereits Ptrace-Anfragen ablehnt.

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.
de: Der Verfolger kann nicht abschätzen, ob der verfolgte Prozess I<immer> sein Leben durch Melden von I<WIFEXITED(status)> oder I<WIFSIGNALED(status)> aushaucht. Es gibt Fälle, in denen dies nicht geschieht. Falls ein Thread, der nicht führender Thread der Thread-Gruppe ist, zum Beispiel ein B<execve>(2) ausführt, verschwindet er; seine PID wird nie wieder gesehen und alle nachfolgenden Ptrace-Stopps werden unter der PID des führenden Threads der Thread-Gruppe gemeldet.

note: type: SS
en: Stopped states
de: Gestoppt-Status

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.
de: Ein verfolgter Prozess kann zwei Status haben: laufend oder gestoppt. Für die Zwecke von Ptrace wird ein durch einen Systemaufruf (wie B<read>(2), B<pause>(2), etc.) blockierter verfolgter Prozess dennoch als laufend betrachtet, sogar, wenn der verfolgte Prozess für lange Zeit blockiert ist. Der Status des verfolgten Prozesses nach B<PTRACE_LISTEN> ist eine Grauzone: Er ist nicht in einem Ptrace-Stopp (Ptrace-Befehle funktionieren nicht bei ihm und er wird B<waitpid>(2)-Benachrichtigungen übermitteln), aber er kann auch als »gestoppt« angesehen werden, da er keine Anweisungen ausführt (ist nicht eingeplant) und falls er vor B<PTRACE_LISTEN> in einem Gruppenstopp war, wird er nicht auf Signale antworten, bis er B<SIGCONT> empfängt.

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.
de: Es gibt viele Arten von Status, wenn ein verfolgter Prozess gestoppt wurde und in Ptrace-Diskussionen werden sie oft durcheinandergebracht. Daher ist es wichtig, präzise Begriffe zu verwenden.

note: type: Plain text
en: In this manual page, any stopped state in which the tracee is ready to accept ptrace commands from the tracer is called I<ptrace-stop>.  Ptrace-stops can be further subdivided into I<signal-delivery-stop>, I<group-stop>, I<syscall-stop>, I<PTRACE_EVENT stops>, and so on.  These stopped states are described in detail below.
de: In dieser Handbuchseite wird jeder Gestoppt-Status, in dem der verfolgte Prozess bereit ist, Ptrace-Befehle vom Verfolger zu akzeptieren, I<Ptrace-Stopp> genannt. Ptrace-Stopps können weiter in I<Signallieferstopp>, I<Gruppenstopp>, I<PTRACE_EVENT stops> und so fort unterteilt werden. Diese gestoppten Status werden nachfolgend im Detail beschrieben.

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:
de: Wenn der laufende, verfolgte Prozess in Ptrace-Stopp eintritt, benachrichtigt er seinen Verfolger mittels B<waitpid>(2) (oder einem anderen der »wait«-Systemaufrufe). Meistens geht diese Handbuchseite davon aus, dass der Verfolger wartet mit:

note: type: Plain text
en:     pid = waitpid(pid_or_minus_1, &status, __WALL);
de:     PID = waitpid(PID_ODER_Minus1, &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.
de: Mit Ptrace-Stopp angehaltene, verfolgte Prozesse werden als Rückgaben mit I<PID> größer als 0 und »I<WIFSTOPPED(status)> true« gemeldet.

note: type: Plain text
en: The B<__WALL> flag does not include the B<WSTOPPED> and B<WEXITED> flags, but implies their functionality.
de: Der Schalter B<__WALL> enthält nicht die Schalter B<WSTOPPED> und B<WEXITED>, impliziert aber ihre Funktionalität.

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.
de: Es wird nicht empfohlen, den Schalter B<WCONTINUED> zu setzen, wenn B<waitpid>(2) aufgerufen wird: Der Status »continued« gilt pro Prozess und ihn zu verbrauchen, kann den echten Elternprozess des verfolgten Prozesses verwirren.

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:
de: Die Benutzung des Schalters B<WNOHANG> könnte B<waitpid>(2) veranlassen, 0 zurückzugeben (»noch keine Warteergebnisse verfügbar«), sogar dann, wenn der Verfolger weiß, dass dort eine Benachrichtigung sein soll. Beispiel:

note: type: Plain text
en: errno = 0;
    ptrace(PTRACE_CONT, pid, 0L, 0L);
    if (errno == ESRCH) {
        /* tracee is dead */
        r = waitpid(tracee, &status, __WALL | WNOHANG);
        /* r can still be 0 here! */
    }
de: errno = 0;
    ptrace(PTRACE_CONT, pid, 0L, 0L);
    if (errno == ESRCH) {
        /* verfolgter Prozess ist tot */
        r = waitpid(tracee, &status, __WALL | WNOHANG);
        /* r kann hier immer noch 0 sein! */
    }

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>.)
de: Die folgenden Arten von Ptrace-Stopps existieren: Signallieferstopps, Gruppenstopps, B<PTRACE_EVENT>-Stopps und Systemaufrufstopps. Sie alle werden von B<waitpid>(2) mit »I<WIFSTOPPED(status)> true« gemeldet. Sie könnten durch Untersuchen des Wertes I<statusE<gt>E<gt>8> unterschieden werden und, falls es eine Unklarheit im Wert gibt, durch Abfragen von B<PTRACE_GETSIGINFO>. (Hinweis: Das Makro I<WSTOPSIG(status)> kann nicht für diese Untersuchung verwandt werden, da es den Wert I<(statusE<gt>E<gt>8)\ &\ 0xff> zurückgibt.)

note: type: SS
en: Signal-delivery-stop
de: Signallieferstopp

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.
de: Wenn ein Prozess (möglicherweise mit mehreren Threads) ein Signal außer B<SIGKILL> empfängt, wählt der Kernel einen beliebigen Thread aus, der das Signal handhabt. (Falls das Signal mit B<tgkill>(2) erzeugt wurde, kann der Ziel-Thread explizit durch den Aufrufenden ausgewählt werden.) Falls der ausgewählte Thread verfolgt wird, tritt er in einen Signallieferstopp ein. An diesem Punkt wird das Signal noch nicht an den Prozess zugestellt und kann durch den Verfolger unterdrückt werden. Falls der Verfolger das Signal nicht unterdrückt, übergibt er das Signal bei der nächsten Ptrace-Neustartanfrage an den verfolgten Prozess. Dieser zweite Schritt der Signalzustellung wird in dieser Handbuchseite I<Signaleinspeisung> genannt. Beachten Sie, dass, falls das Signal blockiert ist, der Signallieferstopp nicht auftritt, bis die Blockade des Signals aufgehoben wurde, mit der üblichen Ausnahme, dass B<SIGSTOP> nicht blockiert werden kann.

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.
de: Der Signallieferstopp wird vom Verfolger als B<waitpid>(2) beobachtet und kehrt mit »I<WIFSTOPPED(status)> true« mit dem Signal zurück, das von I<WSTOPSIG(status)> zurückgegeben wurde. Falls das Signal B<SIGTRAP> ist, könnte dies eine andere Art eines Ptrace-Stopps sein; Einzelheiten finden Sie in den Abschnitten »Systemaufrufstopps« und »execve« unterhalb. Falls I<WSTOPSIG(status)> ein stoppendes Signal zurückgibt, könnte dies ein Gruppenstopp sein; siehe unten.

note: type: SS
en: Signal injection and suppression
de: Signaleinspeisung und -unterdrückung

note: type: Plain text
en: After signal-delivery-stop is observed by the tracer, the tracer should restart the tracee with the call
de: Nachdem der Signallieferstopp durch den Verfolger beobachtet wurde, sollte der Verfolger den verfolgten Prozess mit dem Aufruf

note: type: Plain text
en:     ptrace(PTRACE_restart, pid, 0, sig)
de:     ptrace(PTRACE_restart, PID, 0, Signal)

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.
de: neu starten, wobei B<PTRACE_restart> einer der neu startenden Ptrace-Anfragen ist. Falls I<Signal> 0 ist, wird das Signal nicht zugestellt. Andernfalls wird das Signal I<Signal> zugestellt. Diese Aktion wird in dieser Handbuchseite I<Signaleinspeisung> genannt, um sie vom Signallieferstopp zu unterscheiden.

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.
de: Der I<Signal>wert kann sich vom Wert I<WSTOPSIG(status)> unterschieden: Der Verfolger kann veranlassen, dass ein anderes Signal eingespeist wird.

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.
de: Beachten Sie, dass ein unterdrücktes Signal immer noch Systemaufrufe verursacht, um vorzeitig zurückzukehren. In diesem Fall werden Systemaufrufe neu gestartet: Der Verfolger wird den verfolgten Prozess beobachten, um den unterbrochenen Systemaufruf neu auszuführen (oder den Systemaufruf B<restart_syscall>(2) für wenige Systemaufrufe, die unterschiedliche Mechanismen zum erneuten Starten verwenden), falls der Verfolger B<PTRACE_SYSCALL> benutzt. Sogar Systemaufrufe (wie B<poll>(2)), die nach einem Signal nicht mehr neu startbar sind, werden nach dem Unterdrücken des Signals neu gestartet werden. Es existieren jedoch einige Kernelfehler, die zum Fehlschlagen einiger Systemaufrufe mit B<EINTR> führen, sogar, wenn kein beobachtbares Signal in den verfolgten Prozess eingespeist wurde.

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.
de: Es wird nicht garantiert, dass beim Neustarten von Ptrace-Befehlen, die in anderen Ptrace-Stopps als Signallieferstopps angestoßen wurden,ein Signal eingespeist wird, nicht einmal, wenn I<Signal> nicht Null ist. Es wird kein Fehler gemeldet; ein I<Signal> ungleich Null könnte einfach ignoriert werden. Ptrace-Benutzer sollten nicht versuchen, auf diese Art »ein neues Signal zu erzeugen«: Benutzen Sie stattdessen 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
de: Die Tatsache, dass Signaleinspeisungsanfragen beim erneuten Starten des verfolgten Prozesses nach Ptrace-Stopps, die keine Signallieferstopps sind, ignoriert werden können, ist ein Grund für Verwirrung bei Ptrace-Benutzern. Ein typisches Szenario ist, dass der Verfolger Gruppenstopps beobachtet, sie fälschlicherweise für Signallieferstopps hält und den verfolgen Prozess mit

note: type: Plain text
en:     ptrace(PTRACE_restart, pid, 0, stopsig)
de:     ptrace(PTRACE_restart, PID, 0, Stoppsignal)

note: type: Plain text
en: with the intention of injecting I<stopsig>, but I<stopsig> gets ignored and the tracee continues to run.
de: neu startet mit der Absicht I<Stoppsignal> einzuspeisen, I<Stoppsignal> aber ignoriert wird und der verfolgte Prozess weiter läuft.

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.
de: Das Signal B<SIGCONT> hat einen Seiteneffekt, dass es einen Prozess im Gruppenstopp (alle Threads davon) aufweckt. Dieser Seiteneffekt tritt vor dem Signallieferstopp auf. Der Verfolger kann diesen Seiteneffekt nicht unterdrücken (er kann nur Signaleinspeisung unterdrücken, was nur dazu führt, dass die B<SIGCONT>-Handhabung nicht im verfolgten Prozess ausgeführt wird, falls eine solche Handhabung installiert ist). Tatsächlich könnte dem Aufwecken aus den Gruppenstopp ein Signallieferstopp für I<andere> Signale als B<SIGCONT> folgen, falls sie ausstehen, wenn B<SIGCONT> gesandt wurde. In anderen Worten könnte es sein, dass B<SIGCONT> nicht das erste durch den Verfolger beobachtete Signal ist, nachdem es gesandt wurde.

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.
de: Stoppen von Signalen führt dazu, das ein Prozess (alle Threads davon) in einen Gruppenstopp eintritt. Dieser Seiteneffekt tritt nach der Signaleinspeisung auf und kann daher durch den Verfolger unterdrückt werden.

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.
de: In Linux 2.4 und älter kann das Signal B<SIGSTOP> nicht eingespeist werden.

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.
de: B<PTRACE_GETSIGINFO> kann benutzt werden, um eine I<siginfo_t>-Struktur zu erhalten, die dem gesandten Signal entspricht. B<PTRACE_SETSIGINFO> kann benutzt werden, um es zu verändern. Falls B<PTRACE_SETSIGINFO> benutzt wurde, um I<siginfo_t> zu verändern, müssen das Feld I<si_signo> und der Parameter I<Signal> im Befehl zum Neustart übereinstimmen, andernfalls ist das Ergebnis undefiniert.

note: type: SS
en: Group-stop
de: Gruppenstopp

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.
de: Wenn ein Prozess (der möglicherweise aus mehreren Threads besteht) ein Stoppsignal empfängt, werden alle Threads gestoppt. Falls einige Threads verfolgt werden, treten sie in eine Thread-Gruppe ein. Beachten Sie, dass das Stoppsignal zuerst einen Signallieferstopp verursachen wird (nur auf den verfolgten Prozess) und nur, nachdem es durch den Verfolger eingespeist wurde (oder nachdem es an einen Thread geschickt wurde, der nicht verfolgt wird), wird der Gruppenstopp auf I<alle> verfolgten Prozesse innerhalb eines Prozesses aus mehreren Threads eingeleitet. Wie üblich meldet jeder verfolgte Prozess seinen Gruppenstopp separat an den entsprechenden Verfolger.

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
de: Der Gruppenstopp wird vom Verfolger als B<waitpid>(2) beobachtet und kehrt mit »I<WIFSTOPPED(status)> true« mit dem Stoppsignal zurück, das über I<WSTOPSIG(status)> verfügbar ist. Dasselbe Ergebnis wird von einigen anderen Klassen von Ptrace-Stopps zurückgegeben, daher ist die empfohlene Vorgehensweise, folgenden Aufruf zu tätigen:

note: type: Plain text
en:     ptrace(PTRACE_GETSIGINFO, pid, 0, &siginfo)
de:     ptrace(PTRACE_GETSIGINFO, PID, 0, &siginfo)

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.)
de: Der Aufruf kann vermieden werden, falls das Signal nicht B<SIGSTOP>, B<SIGTSTP>, B<SIGTTIN> oder B<SIGTTOU> ist. Nur diese vier Signale sind Stoppsignale. Falls der Verfolger etwas anderes sieht, kann es kein Gruppenstopp sein. Andernfalls benötigt der Verfolger den Aufruf B<PTRACE_GETSIGINFO>. Falls B<PTRACE_GETSIGINFO> mit B<EINVAL> fehlschlägt, ist es definitiv ein Gruppenstopp. (Andere Fehlerkodes wie B<ESRCH> (»kein derartiger Prozess«) sind möglich, falls ein B<SIGKILL> den verfolgten Prozess gekillt hat.

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.
de: Falls ein verfolgter Prozess mittels B<PTRACE_SEIZE> angehängt wurde, wird ein Gruppenstopp durch B<PTRACE_EVENT_STOP> angezeigt: I<StatusE<gt>E<gt>16 == PTRACE_EVENT_STOP>. Dies ermöglicht, einen Gruppenstopp festzustellen, ohne dass ein zusätzlicher B<PTRACE_GETSIGINFO>-Aufruf erforderlich ist.

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.
de: Ab Linux 2.6.38 wird der verfolgte Prozess, nachdem der Verfolger den Ptrace-Stopp des verfolgten Prozesses sieht und bis er neu startet oder ihn killt, nicht laufen und keine Benachrichtigungen an den Verfolger senden (außer dem Tod durch B<SIGKILL>), nicht einmal, wenn der Verfolger in einen anderen B<waitpid>(2)-Aufruf gelangt.

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.
de: Das im vorhergehenden Absatz beschriebene Verhalten verursacht ein Problem bei transparenter Behandlung von Stoppsignalen. Falls der Verfolger den verfolgten Prozess nach einem Gruppenstopp neu startet, wird das Stoppsignal effektiv ignoriert – der verfolgte Prozess bleibt nicht gestoppt, er läuft. Falls der Verfolger den verfolgten Prozess neu startet, bevor er in das nächste B<waitpid>(2) eintritt, werden zukünftige B<SIGCONT>-Signale nicht an den Verfolger gemeldet. Dies würde dazu führen, dass die B<SIGCONT>-Signale keine Auswirkungen auf den verfolgten Prozess haben.

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>).
de: Seit Linux 3.4 gibt es eine Methode, die dieses Problem bewältigt: Statt B<PTRACE_CONT> kann ein B<PTRACE_LISTEN>-Befehl zum Neustart eines verfolgten Prozesses auf eine Weise benutzt werden, die ihn nicht ausführt, aber auf ein neues Ereignis wartet, das er über B<waitpid>(2) melden kann, wenn er zum Beispiel mit B<SIGCONT> neu gestartet wird.

note: type: SS
en: PTRACE_EVENT stops
de: PTRACE_EVENT-Stopps

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.
de: Falls der Verfolger B<PTRACE_O_TRACE_*>-Optionen setzt, wird der verfolgte Prozess in B<PTRACE_EVENT>-Stopps genannte Stopps gelangen.

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
de: B<PTRACE_EVENT>-Stopps werden durch den Verfolger als B<waitpid>(2) beobachtet, kehren mit »I<WIFSTOPPED(status)> true« zurück und I<WSTOPSIG(status)> gibt B<SIGTRAP> zurück. Es wird ein zusätzliches Bit in das höhere Bit des Status (Datentyp Word) gesetzt: Der Wert I<statusE<gt>E<gt>8> wird wie folgt sein:

note: type: Plain text
en: The following events exist:
de: Es gibt die folgenden Ereignisse:

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)).
de: stoppt vor dem Zurückkehren von B<vfork>(2) oder B<clone>(2) mit dem Schalter B<CLONE_VFORK>. Wenn der verfolgte Prozess nach diesem Stopp fortgeführt wird, wird er auf das Beenden/Ausführen des Kindprozesses warten, bevor er mit seiner Ausführung fortfährt (in anderen Worten, das übliche Verhalten auf 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>.
de: stoppt vor dem Zurückkehren von B<fork>(2) oder B<clone>(2) mit dem auf B<SIGCHLD> gesetzten Beendigungssignal.

note: type: Plain text
en: Stop before return from B<clone>(2).
de: stoppt vor dem Zurückkehren von 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.
de: stoppt vor dem Zurückkehren von B<vfork>(2) oder B<clone>(2) mit dem Schalter B<CLONE_VFORK>, aber nachdem die Blockade dieses verfolgten Prozesses durch Beenden oder Ausführung aufgehoben wurde.

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.
de: Für alle vier oben beschriebenen Stopps tritt der Stopp im Elternprozess auf (d.h. im verfolgenden Prozess), nicht im neu erstellten Thread. B<PTRACE_GETEVENTMSG> kann benutzt werden, um die Kennung des neuen Threads zu erhalten.

note: type: Plain text
en: Stop before return from B<execve>(2).  Since Linux 3.0, B<PTRACE_GETEVENTMSG> returns the former thread ID.
de: stoppt vor dem Zurückkehren von B<execve>(2). Ab Linux 3.0, gibt B<PTRACE_GETEVENTMSG> die vorherige Thread-Kennung zurück.

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.
de: stoppt vor dem Beenden (einschließlich des Todes aus B<exit_group>(2)), dem Signaltod oder endet, verursacht durch B<execve>(2), in einem Prozess aus mehreren Threads. B<PTRACE_GETEVENTMSG> gibt den Exit-Status zurück. Register können untersucht werden (solange nicht »wirklich« beendet wird). Der verfolgte Prozess ist immer noch lebendig; er benötigt zum Fertigstellen des Beendens B<PTRACE_CONT> oder B<PTRACE_DETACH>.

note: type: Plain text
en: Stop induced by B<PTRACE_INTERRUPT> command, or group-stop, or initial ptrace-stop when a new child is attached (only if attached using B<PTRACE_SEIZE>).
de: Stopp, der durch einen B<PTRACE_INTERRUPT>-Befehl, einen Gruppenstopp oder ein »ptrace-stop« zu Beginn veranlasst wurde, wenn ein neuer Kindprozess angehängt wird (nur beim Anhängen mittels B<PTRACE_SEIZE>).

note: type: Plain text
en: Stop triggered by a B<seccomp>(2)  rule on tracee syscall entry when B<PTRACE_O_TRACESECCOMP> has been set by the tracer.  The seccomp event message data (from the B<SECCOMP_RET_DATA> portion of the seccomp filter rule) can be retrieved with B<PTRACE_GETEVENTMSG>.  The semantics of this stop are described in detail in a separate section below.
de: Stopp, der durch eine B<seccomp>(2)-Regel durch den Eintritt des verfolgten Prozesses in einen Systemaufruf ausgelöst wird, wenn B<PTRACE_O_TRACESECCOMP> vom Verfolger gesetzt wird. Die Seccomp-Ereignisdaten (von dem Anteil B<SECCOMP_RET_DATA> der Filterregel) können durch B<PTRACE_GETEVENTMSG> ermittelt werden. Die Semantik dieses Stopps werden in einem separaten Abschnitt weiter unten beschrieben.

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>.
de: B<PTRACE_GETSIGINFO> auf B<PTRACE_EVENT>-Stopps gibt B<SIGTRAP> in I<si_signo> zurück, wobei I<si_code> auf I<(eventE<lt>E<lt>8)\ |\ SIGTRAP> gesetzt ist.

note: type: SS
en: Syscall-stops
de: Systemaufrufstopps

note: type: Plain text
en: If the tracee was restarted by B<PTRACE_SYSCALL> or B<PTRACE_SYSEMU>, the tracee enters syscall-enter-stop just prior to entering any system call (which will not be executed if the restart was using B<PTRACE_SYSEMU>, regardless of any change made to registers at this point or how the tracee is restarted after this stop).  No matter which method caused the syscall-entry-stop, if the tracer restarts the tracee with B<PTRACE_SYSCALL>, the tracee enters syscall-exit-stop when the system call is finished, or if it is interrupted by a signal.  (That is, signal-delivery-stop never happens between syscall-enter-stop and syscall-exit-stop; it happens I<after> syscall-exit-stop.).  If the tracee is continued using any other method (including B<PTRACE_SYSEMU>), no syscall-exit-stop occurs.  Note that all mentions B<PTRACE_SYSEMU> apply equally to B<PTRACE_SYSEMU_SINGLESTEP.>
de: Falls der verfolgte Prozess durch B<PTRACE_SYSCALL> oder B<PTRACE_SYSEMU> neu gestartet wurde, gerät der verfolgte Prozess in einen Systemaufrufeintrittsstopp kurz vor dem Eintritt in irgendeinen Systemaufruf (der nicht ausgeführt wird, falls der Neustart B<PTRACE_SYSEMU> verwandte, unabhängig von allen Änderungen, die zu diesem Zeitpunkt an den Registern vorgenommen wurden oder wie der verfolgte Prozess nach diesem Stopp neu gestartet wird). Unabhängig davon, welche Methode den Systemaufrufeintrittsstopp verursachte, falls der Verfolger den verfolgten Prozess mit B<PTRACE_SYSCALL> neu startet, gerät der verfolgte Prozess in einen Systemaufrufbeendigungsstopp, wenn der Systemaufruf beendet ist oder falls er durch ein Signal unterbrochen wurde. (Sprich, der Signallieferstopp tritt nie zwischen Systemaufrufeintrittsstopp und Systemaufrufbeendigungsstopp auf; er findet I<nach> dem Systemaufrufbeendigungsstopp statt.) Falls der verfolgte Prozess mittels irgendeiner anderen Methode fortgesetzt wird (einschließlich B<PTRACE_SYSEMU>), erfolgt kein Systemaufrufbeendigungsstop. Beachten Sie, dass alle Erwähnungen von B<PTRACE_SYSEMU> genauso auf B<PTRACE_SYSEMU_SINGLESTEP> zutreffen.

note: type: Plain text
en: However, even if the tracee was continued using B<PTRACE_SYSCALL>, it is not guaranteed that the next stop will be a syscall-exit-stop.  Other possibilities are that the tracee may stop in a B<PTRACE_EVENT> stop (including seccomp stops), exit (if it entered B<_exit>(2)  or B<exit_group>(2)), be killed by B<SIGKILL>, or die silently (if it is a thread group leader, the B<execve>(2)  happened in another thread, and that thread is not traced by the same tracer; this situation is discussed later).
de: Selbst falls der verfolgte Prozess mittels B<PTRACE_SYSCALL> fortgesetzt wird, wird nicht garantiert, dass der nächste Stopp ein Systemaufrufbeendigungsstopp sein wird. Andere Möglichkeiten sind, dass der verfolgte Prozess in einem B<PTRACE_EVENT>-Stopp (einschließlich Seccomp-Stopp) stoppen könnte, endet (falls er in B<_exit>(2) oder B<exit_group>(2) eintritt), durch B<SIGKILL> gekillt wird oder leise stirbt (falls er die Thread-Gruppe anführt, kommt das B<execve>(2) in einem anderen Thread vor und der Thread wird nicht vom selben Verfolger verfolgt; diese Situation wird später besprochen).

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)>.
de: Systemaufrufeintrittsstopp und Systemaufrufbeendigungsstopp werden vom Verfolger als B<waitpid>(2) beobachtet, kehren mit »I<WIFSTOPPED(status)> true« zurück und I<WSTOPSIG(status)> gibt B<SIGTRAP> zurück. Falls die Option B<PTRACE_O_TRACESYSGOOD> durch den Verfolger gesetzt wurde, wird I<WSTOPSIG(status)> den Wert I<(SIGTRAP\ |\ 0x80)> zurückgeben.

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:
de: Systemaufrufstopps können von Signallieferstopps mit B<SIGTRAP> durch Abfrage von B<PTRACE_GETSIGINFO> für die folgenden Fälle unterschieden werden:

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.
de: B<SIGTRAP> wurde mit einem Ergebnis einer Anwendungsraumaktion, zum Beispiel einem Systemaufruf ((B<tgkill>(2), B<kill>(2), B<sigqueue>(3), etc.), Ablauf eines POSIX-Timers, Statusänderung einer POSIX-Nachrichtenwarteschlange oder Vervollständigung einer asynchronen E/A-Anfrage geliefert.

note: type: Plain text
en: B<SIGTRAP> was sent by the kernel.
de: B<SIGTRAP> wurde vom Kernel gesandt.

note: type: Plain text
en: This is a syscall-stop.
de: Dies ist ein Systemaufrufstopp.

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.
de: Systemaufrufstopps kommen jedoch sehr oft vor (zweimal pro Systemaufruf) und das Ausführen von B<PTRACE_GETSIGINFO> für jeden Systemaufrufstopp könnte etwas aufwendig sein.

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.
de: Einige Architekturen erlauben, die Fälle durch Untersuchen der Register zu unterscheiden. Zum Beispiel auf x86, I<rax> == -B<ENOSYS> im Systemaufrufeintrittsstopp. Da B<SIGTRAP> (wie jedes andere Signal) immer I<nach> dem Systemaufrufbeendigungsstopp auftritt und I<rax> an diesem Punkt fast nie B<ENOSYS> enthält, sieht das B<SIGTRAP> aus wie ein »Systemaufrufstopp, der kein Systemaufrufeintrittsstopp ist«; in anderen Worten, er sieht aus wie ein »herrenloser Systemaufrufbeendigungsstopp« und kann auf diese Art erkannt werden. Aber eine solche Erkennung ist fragil und wird am besten vermieden.

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.
de: Die Benutzung der Option B<PTRACE_O_TRACESYSGOOD> ist die empfohlene Methode, um Systemaufrufstopps von anderen Arten der Ptrace-Stopps zu unterscheiden, da sie zuverlässig ist und sich keine Leistungseinbuße zuzieht.

note: type: Plain text
en: Syscall-enter-stop and syscall-exit-stop are indistinguishable from each other by the tracer.  The tracer needs to keep track of the sequence of ptrace-stops in order to not misinterpret syscall-enter-stop as syscall-exit-stop or vice versa.  In general, a syscall-enter-stop is always followed by syscall-exit-stop, B<PTRACE_EVENT> stop, or the tracee's death; no other kinds of ptrace-stop can occur in between.  However, note that seccomp stops (see below) can cause syscall-exit-stops, without preceding syscall-entry-stops.  If seccomp is in use, care needs to be taken not to misinterpret such stops as syscall-entry-stops.
de: Systemaufrufeintrittsstopp und Systemaufrufbeendigungsstopp sind für den Verfolger nicht voneinander zu unterscheiden. Der Verfolger muss den Überblick über die Abfolge der Ptrace-Stopps behalten, um nicht den Systemaufrufeintrittsstopp fälschlicherweise als Systemaufrufbeendigungsstopp oder umgekehrt zu interpretieren. Im Allgemeinen folgt diesem Systemaufrufeintrittsstopp immer ein Systemaufrufbeendigungsstopp, B<PTRACE_EVENT>-Stopp oder der Tod des verfolgten Prozesses; dazwischen können keine anderen Arten von Ptrace-Stopps auftreten. Beachten Sie allerdings, dass Seccomp-Stopps (siehe unten) Systemaufrufbeendigungsstopps ohne vorhergehende Systemaufrufeintrittsstopps hervorrufen können. Falls Seccomp verwandt wird, muss Sorgfalt eingesetzt werden, um solche Stopps nicht als Systemaufrufeintrittsstopps misszuinterpretieren.

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.
de: Falls der Verfolger nach dem Systemaufrufeintrittsstopp einen anderen Befehl zum Neustarten als B<PTRACE_SYSCALL> verwendet, wird der Systemaufrufbeendigungsstopp nicht erzeugt.

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)>.
de: B<PTRACE_GETSIGINFO> auf Systemaufrufstopps gibt B<SIGTRAP> in I<si_signo> zurück, wobei I<si_code> auf B<SIGTRAP> oder I<(SIGTRAP|0x80)> gesetzt ist.

note: type: SS
en: PTRACE_EVENT_SECCOMP stops (Linux 3.5 to 4.7)
de: PTRACE_EVENT_SECCOMP-Stopps (Linux 3.5 bis 4.7)

note: type: Plain text
en: The behavior of B<PTRACE_EVENT_SECCOMP> stops and their interaction with other kinds of ptrace stops has changed between kernel versions.  This documents the behavior from their introduction until Linux 4.7 (inclusive).  The behavior in later kernel versions is documented in the next section.
de: Das Verhalten des B<PTRACE_EVENT_SECCOMP>-Stopps und seiner Wechselwirkung mit anderen Arten von Ptrace-Stopps hat sich zwischen Kernel-Versionen geändert. Hier wird das Verhalten von seiner Einführung bis Linux 4.7 (einschließlich) beschrieben. Das Verhalten in neueren Kernelversionen wird im nächsten Abschnitt beschrieben.

note: type: Plain text
en: A B<PTRACE_EVENT_SECCOMP> stop occurs whenever a B<SECCOMP_RET_TRACE> rule is triggered.  This is independent of which methods was used to restart the system call.  Notably, seccomp still runs even if the tracee was restarted using B<PTRACE_SYSEMU> and this system call is unconditionally skipped.
de: Ein B<PTRACE_EVENT_SECCOMP>-Stopp erfolgt, wann immer eine B<SECCOMP_RET_TRACE>-Regel ausgelöst wird. Dies ist von der Methode, die zum Neustart des Systemaufrufes verwandt wurde, unabhängig. Insbesondere läuft Seccomp immer noch, selbst falls der verfolgte Prozess mittels B<PTRACE_SYSEMU> neu gestartet wurde und dieser Systemaufruf wird bedingungslos übersprungen.

note: type: Plain text
en: Restarts from this stop will behave as if the stop had occurred right before the system call in question.  In particular, both B<PTRACE_SYSCALL> and B<PTRACE_SYSEMU> will normally cause a subsequent syscall-entry-stop.  However, if after the B<PTRACE_EVENT_SECCOMP> the system call number is negative, both the syscall-entry-stop and the system call itself will be skipped.  This means that if the system call number is negative after a B<PTRACE_EVENT_SECCOMP> and the tracee is restarted using B<PTRACE_SYSCALL>, the next observed stop will be a syscall-exit-stop, rather than the syscall-entry-stop that might have been expected.
de: Neustarts aus diesem Stopp verhalten sich so, als ob der Stopp direkt vor dem in Frage stehenden Systemaufruf stattgefunden hätte. Insbesondere werden sowohl B<PTRACE_SYSCALL> als auch B<PTRACE_SYSEMU> normalerweise einen folgenden Systemaufrufeintrittsstopp auslösen. Falls allerdings nach dem B<PTRACE_EVENT_SECCOMP> die Systemaufrufnummer negativ ist, werden sowohl der Systemaufrufeintrittsstopp als auch der Systemaufruf selbst übersprungen. Das bedeutet, dass falls die Systemaufrufnummer nach dem B<PTRACE_EVENT_SECCOMP> negativ ist und der verfolgte Prozess mittels B<PTRACE_SYSCALL> neu gestartet wird, der nächste beobachtete Stopp ein Systemaufrufbeendigungsstopp statt des vielleicht erwarteten Systemaufrufeintrittsstopps sein wird.

note: type: SS
en: PTRACE_EVENT_SECCOMP stops (since Linux 4.8)
de: PTRACE_EVENT_SECCOMP-Stopps (seit Linux 4.8)

note: commit 93e35efb8de45393cf61ed07f7b407629bf698ea type: Plain text
en: Starting with Linux 4.8, the B<PTRACE_EVENT_SECCOMP> stop was reordered to occur between syscall-entry-stop and syscall-exit-stop.  Note that seccomp no longer runs (and no B<PTRACE_EVENT_SECCOMP> will be reported) if the system call is skipped due to B<PTRACE_SYSEMU>.
de: Beginnend mit Linux 4.8 wurde der Stopp B<PTRACE_EVENT_SECCOMP> neu geordnet, so dass er zwischen Systemaufrufeintrittsstopp und Systemaufrufbeendigungsstopp auftritt. Beachten Sie, dass Seccomp nicht länger ausgeführt wird (und kein B<PTRACE_EVENT_SECCOMP> berichtet wird) falls der Systemaufruf aufgrund B<PTRACE_SYSEMU> übersprungen wird.

note: type: Plain text
en: Functionally, a B<PTRACE_EVENT_SECCOMP> stop functions comparably to a syscall-entry-stop (i.e., continuations using B<PTRACE_SYSCALL> will cause syscall-exit-stops, the system call number may be changed and any other modified registers are visible to the to-be-executed system call as well).  Note that there may be, but need not have been a preceding syscall-entry-stop.
de: Funktional arbeitet ein B<PTRACE_EVENT_SECCOMP>-Stopp vergleichbar mit einem Systemaufrufeintrittsstopp (d.h. Fortsetzungen mittels B<PTRACE_SYSCALL> werden einen Systemaufrufbeendigungsstopp auslösen, die Systemaufrufnummer könnte sich ändern und alle anderen veränderten Register sind im gleich auszuführenden Systemaufruf ebenfalls sichtbar). Beachten Sie, dass es einen vorhergehenden Systemaufrufeintrittsstopp gegeben haben kann, aber nicht muss.

note: type: Plain text
en: After a B<PTRACE_EVENT_SECCOMP> stop, seccomp will be rerun, with a B<SECCOMP_RET_TRACE> rule now functioning the same as a B<SECCOMP_RET_ALLOW>.  Specifically, this means that if registers are not modified during the B<PTRACE_EVENT_SECCOMP> stop, the system call will then be allowed.
de: Nach einem Stopp B<PTRACE_EVENT_SECCOMP> wird Seccomp mit einer Regel B<SECCOMP_RET_TRACE>, die identisch zu einer B<SECCOMP_RET_ALLOW> funktioniert, erneut ausgeführt. Insbesondere bedeutet dies, dass falls Register nicht während des Stopps B<PTRACE_EVENT_SECCOMP> verändert wurden, der Systemaufruf dann erlaubt wird.

note: type: SS
en: PTRACE_SINGLESTEP stops
de: PTRACE_SINGLESTEP-Stopps

note: FIXME . document stops occurring with PTRACE_SINGLESTEP type: Plain text
en: [Details of these kinds of stops are yet to be documented.]
de: [Einzelheiten dieser Arten von Stopps sind noch nicht dokumentiert.]

note: type: SS
en: Informational and restarting ptrace commands
de: Benachrichtigende und neustartende Ptrace-Befehle

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>.
de: Die meisten Ptrace-Befehle (alle außer B<PTRACE_ATTACH>, B<PTRACE_SEIZE>, B<PTRACE_TRACEME>, B<PTRACE_INTERRUPT> und B<PTRACE_KILL>) erfordern, dass der verfolgte Prozess in einem Ptrace-Stopp ist, andernfalls scheitern sie mit 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:
de: Wenn der verfolgte Prozess im Ptrace-Stopp ist, kann der Verfolger Daten des verfolgten Prozesses mittels benachrichtigenden Befehlen lesen und schreiben. Diese Befehle belassen den verfolgten Prozess im Status Ptrace-gestoppt:

note: type: Plain text
en: ptrace(PTRACE_PEEKTEXT/PEEKDATA/PEEKUSER, pid, addr, 0);
    ptrace(PTRACE_POKETEXT/POKEDATA/POKEUSER, pid, addr, long_val);
    ptrace(PTRACE_GETREGS/GETFPREGS, pid, 0, &struct);
    ptrace(PTRACE_SETREGS/SETFPREGS, pid, 0, &struct);
    ptrace(PTRACE_GETREGSET, pid, NT_foo, &iov);
    ptrace(PTRACE_SETREGSET, pid, NT_foo, &iov);
    ptrace(PTRACE_GETSIGINFO, pid, 0, &siginfo);
    ptrace(PTRACE_SETSIGINFO, pid, 0, &siginfo);
    ptrace(PTRACE_GETEVENTMSG, pid, 0, &long_var);
    ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_flags);
de: ptrace(PTRACE_PEEKTEXT/PEEKDATA/PEEKUSER, PID, Adresse, 0);
    ptrace(PTRACE_POKETEXT/POKEDATA/POKEUSER, PID, Adresse, long_val);
    ptrace(PTRACE_GETREGS/GETFPREGS, PID, 0, &struct);
    ptrace(PTRACE_SETREGS/SETFPREGS, PID, 0, &struct);
    ptrace(PTRACE_GETREGSET, PID, NT_foo, &iov);
    ptrace(PTRACE_SETREGSET, PID, NT_foo, &iov);
    ptrace(PTRACE_GETSIGINFO, PID, 0, &siginfo);
    ptrace(PTRACE_SETSIGINFO, PID, 0, &siginfo);
    ptrace(PTRACE_GETEVENTMSG, PID, 0, &long_var);
    ptrace(PTRACE_SETOPTIONS, PID, 0, PTRACE_O_flags);

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.
de: Beachten Sie, dass einige Fehler nicht gemeldet wurden. Das Setzen des Informationssignals (I<siginfo>) hat zum Beispiel in einigen Ptrace-Stopps möglicherweise keine Auswirkungen, der Aufruf kann jedoch erfolgreich sein (0 zurückgeben und I<errno> nicht setzen); Abfragen von B<PTRACE_GETEVENTMSG> könnte erfolgreich sein und einen zufälligen Wert zurückgeben, falls der aktuelle Ptrace-Stopp nicht dokumentiert ist, um eine aussagekräftige Ereignisnachricht zurückzugeben.

note: type: Plain text
en: The call
de: Der Aufruf

note: type: Plain text
en:     ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_flags);
de:     ptrace(PTRACE_SETOPTIONS, PID, 0, PTRACE_O_flags);

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.
de: beeinflusst einen verfolgten Prozess. Die aktuellen Schalter des verfolgten Prozesses werden ersetzt. Schalter werden geerbt durch neu erzeugte Prozesse und »automatisch angehängt« über aktive B<PTRACE_O_TRACEFORK>-, B<PTRACE_O_TRACEVFORK>- oder B<PTRACE_O_TRACECLONE>-Optionen.

note: type: Plain text
en: Another group of commands makes the ptrace-stopped tracee run.  They have the form:
de: Eine weitere Gruppe von Befehlen lässt die per Ptrace gestoppten, verfolgten Prozesse laufen. Sie haben die Form:

note: type: Plain text
en:     ptrace(cmd, pid, 0, sig);
de:     ptrace(Befehl, PID, 0, Signal);

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>.)
de: wobei I<Befehl> B<PTRACE_CONT>, B<PTRACE_LISTEN>, B<PTRACE_DETACH>, B<PTRACE_SYSCALL>, B<PTRACE_SINGLESTEP>, B<PTRACE_SYSEMU> oder B<PTRACE_SYSEMU_SINGLESTEP> ist. Falls der verfolgte Prozess sich im Signallieferstopp befindet, ist I<Signal> das Signal, das eingespeist wird (falls es ungleich Null ist). Andernfalls kann I<Signal> ignoriert werden. (Wenn ein verfolgter Prozess von einem anderen Ptrace-Stopp als dem Signallieferstopp neu gestartet wird, ist die empfohlene Vorgehensweise, 0 in I<Signal> zu übergeben.)

note: type: SS
en: Attaching and detaching
de: Anhängen und Loslösen

note: type: Plain text
en: A thread can be attached to the tracer using the call
de: Ein Thread kann an den Verfolger angehängt werden mit dem Aufruf

note: type: Plain text
en:     ptrace(PTRACE_ATTACH, pid, 0, 0);
de:     ptrace(PTRACE_ATTACH, PID, 0, 0);

note: type: Plain text
en: or
de: oder

note: type: Plain text
en:     ptrace(PTRACE_SEIZE, pid, 0, PTRACE_O_flags);
de:     ptrace(PTRACE_SEIZE, PID, 0, PTRACE_O_flags);

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.
de: B<PTRACE_ATTACH> sendet außerdem B<SIGSTOP> an diesen Thread. Falls der Verfolger möchte, dass dieser B<SIGSTOP> keine Auswirkungen hat, muss er ihn unterdrücken. Beachten Sie, dass der Verfolger, falls während des Anhängens gleichzeitig weitere Signale an diesen Thread gesandt werden, den Eintritt in den Signallieferstopp mit anderen Signalen zuerst sieht! Die übliche Vorgehensweise ist, diese Signale neu einzuspeisen, bis B<SIGSTOP> gesehen wird und dann die Einspeisung von B<SIGSTOP> zu unterdrücken. Der Entwurfsfehler ist hierbei, dass sich ein Ptrace-Anhängen und ein gleichzeitig gesandtes B<SIGSTOP> einen Wettlauf liefern und das gleichzeitige B<SIGSTOP> verloren gegangen sein kann.

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.
de: Da Anhängen B<SIGSTOP> sendet und der Verfolger es üblicherweise unterdrückt, könnte dies zu einer herrenlosen B<EINTR>-Rückgabe vom aktuell ausgeführten Systemaufruf in diesem verfolgten Prozess führen, wie er im Abschnitt »Signaleinspeisung und -unterdrückung« beschrieben wird.

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.
de: Seit Linux 3.4 kann B<PTRACE_SEIZE> anstelle von B<PTRACE_ATTACH> benutzt werden. B<PTRACE_SEIZE> stoppt nicht den angehängten Prozess. Falls Sie ihn nach dem Anhängen (oder zu einem anderen Zeitpunkt) stoppen wollen ohne irgendwelche Signale zu senden, verwenden Sie den Befehl B<PTRACE_INTERRUPT>.

note: type: Plain text
en: The request
de: Die Anfrage

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
de: verwandelt den aufrufenden Thread in einen verfolgten Prozess. Der Thread fährt mit der Ausführung fort (gerät nicht in den Ptrace-Stopp). Eine übliche Vorgehensweise besteht darin, B<PTRACE_TRACEME> mit

note: type: Plain text
en: and allow the parent (which is our tracer now) to observe our signal-delivery-stop.
de: zu folgen und dem Elternprozess (der nun der Verfolger ist) zu ermöglichen, den Signallieferstopp zu beobachten.

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.
de: Falls die Optionen B<PTRACE_O_TRACEFORK>, B<PTRACE_O_TRACEVFORK> oder B<PTRACE_O_TRACECLONE> in Kraft sind, werden Kindprozesse mit B<vfork>(2), beziehungsweise B<clone>(2) mit dem Schalter B<CLONE_VFORK>, B<fork>(2) oder B<clone>(2) mit auf B<SIGCHLD> gesetztem Beendigungssignal und anderen Arten von B<clone>(2) automatisch an den gleichen Verfolger angehängt, der ihren Elternprozess verfolgte. B<SIGSTOP> wird an die Kindprozesse gesandt, was sie veranlasst, in einen Signallieferstopp zu gelangen, nachdem sie den Systemaufruf beenden, der sie erzeugt hat.

note: type: Plain text
en: Detaching of the tracee is performed by:
de: Loslösen des verfolgten Prozesses wird erreicht durch:

note: type: Plain text
en:     ptrace(PTRACE_DETACH, pid, 0, sig);
de:     ptrace(PTRACE_DETACH, PID, 0, Signal);

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.
de: B<PTRACE_DETACH> ist eine Neustartaktion; daher erfordert sie, dass der verfolgte Prozess in einem Ptrace-Stopp ist. Falls der verfolgte Prozess in einem Signallieferstopp ist, kann ein Signal eingespeist werden. Andernfalls wird der Parameter I<Signal> stillschweigend ignoriert.

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>.
de: Falls der verfolgte Prozess läuft, wenn der Verfolger ihn loslösen möchte, besteht die übliche Lösung darin, B<SIGSTOP> zu senden (mittels B<tgkill>(2), um sicherzustellen, dass es an den korrekten Thread geht), darauf zu warten, dass der verfolgte Prozess in einen Signallieferstopp für B<SIGSTOP> stoppt und ihn dann loszulösen (B<SIGSTOP>-Einspeisung wird unterdrückt). Ein Entwurfsfehler besteht darin, dass sich dies mit gleichzeitigen B<SIGSTOP>s Ressourcenwettläufe liefern kann. Eine weitere Komplikation besteht darin, dass der verfolgte Prozess in andere Ptrace-Stopps geraten kann und neu gestartet werden muss und nochmals gewartet werden muss, bis B<SIGSTOP> gesehen wird. Noch eine weitere Komplikation besteht darin, dass nicht sicher ist, ob der verfolgte Prozess nicht bereits mit Ptrace gestoppt wurde, da keine Signallieferung stattfindet, obwohl es noch nicht einmal B<SIGSTOP> ist.

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.
de: Falls der Verfolger stirbt, werden alle verfolgten Prozesse automatisch losgelöst und neu gestartet, es sei denn, sie sind im Gruppenstopp. Die Handhabung des Neustarts aus dem Gruppenstopp ist derzeit fehlerhaft, aber das »wie-geplant«-Verhalten ist, den verfolgten Prozess gestoppt zu lassen und auf B<SIGCONT> zu warten. Falls der verfolgte Prozess neu vom Signallieferstopp gestartet wurde, wird das ausstehende Signal einspeist.

note: type: SS
en: execve(2) under ptrace
de: execve(2) unter 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:
de: Wenn ein Thread in einem Prozess mit mehreren Threads B<execve>(2) aufruft, zerstört der Kernel alle anderen Threads im Prozess und setzt die Thread-Kennung des ausführenden Threads auf die Gruppenkennung (Prozesskennung) zurück. (Oder anders ausgedrückt, wenn ein Prozess mit mehreren Threads ein B<execve>(2) bei Vervollständigung des Aufrufs ausführt, scheint es durch das B<execve>(2) im führenden Thread der Prozessgruppe aufzutreten, unabhängig davon, welcher Thread das B<execve>(2) aufrief.) Dieses Zurücksetzen der Thread-Kennung sieht für Verfolger sehr verwirrend aus:

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.
de: Alle anderen Threads stoppen im B<PTRACE_EVENT_EXIT>-Stopp, falls die Option B<PTRACE_O_TRACEEXIT> eingeschaltet wurde. Dann melden alle anderen Threads außer dem führenden Thread der Gruppe den Tod, als ob sie über B<_exit>(2) mit dem Exit-Code 0 beendet worden wären.

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.
de: Der ausführende, verfolgte Prozess ändert seine Thread-Kennung, während er in dem B<execve>(2) ist. (Denken Sie daran, unter Ptrace ist die von B<waitpid>(2) zurückgegebene oder in Ptrace-Aufrufe gespeiste »PID«, die Thread-Kennung des verfolgten Prozesses.) Sprich, die Thread-Kennung des verfolgten Prozesses wird zurückgesetzt, so dass sie ihrer Prozesskennung entspricht, die dieselbe ist, wie die Thread-Kennung des führenden Threads der Thread-Gruppe.

note: type: Plain text
en: Then a B<PTRACE_EVENT_EXEC> stop happens, if the B<PTRACE_O_TRACEEXEC> option was turned on.
de: Dann kommt es zu einem B<PTRACE_EVENT_EXEC>-Stopp, falls die Option B<PTRACE_O_TRACEEXEC> eingeschaltet wurde.

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.
de: Falls der führende Thread der Gruppe seinen B<PTRACE_EVENT_EXEC>-Stopp mittlerweile gemeldet hat, scheint es für den Verfolger, als ob der tote führende Thread »aus dem Nichts wieder auftaucht«. (Hinweis: Der führende Thread der Gruppe meldet den Tod nicht über I<WIFEXITED(status)> bis es mindestens einen lebenden anderen Thread gibt. Dies eliminiert die Möglichkeit, dass der Verfolger ihn sterben und dann erneut erscheinen sieht.) Falls der führende Thread der Gruppe immer noch lebt, könnte dies für den Verfolger so aussehen, als ob der führende Thread der Gruppe von einem anderen Systemaufruf als dem beigetretenen zurückkehrt oder sogar »von einem Systemaufruf zurückkehrt, obwohl er in keinem Systemaufruf war«. Falls der führende Thread der Gruppe nicht verfolgt wurde (oder von einem anderen Verfolger verfolgt wurde), dann wird es während B<execve>(2) so aussehen, als ob er ein verfolgter Prozess des Verfolgers des ausführenden verfolgten Prozesses geworden wäre.

note: type: Plain text
en: All of the above effects are the artifacts of the thread ID change in the tracee.
de: All die Auswirkungen oberhalb sind Artefakte des Thread-Kennungswechsels im verfolgten Prozess.

note: type: Plain text
en: The B<PTRACE_O_TRACEEXEC> option is the recommended tool for dealing with this situation.  First, it enables B<PTRACE_EVENT_EXEC> stop, which occurs before B<execve>(2)  returns.  In this stop, the tracer can use B<PTRACE_GETEVENTMSG> to retrieve the tracee's former thread ID.  (This feature was introduced in Linux 3.0.)  Second, the B<PTRACE_O_TRACEEXEC> option disables legacy B<SIGTRAP> generation on B<execve>(2).
de: Die Option B<PTRACE_O_TRACEEXEC> ist das empfohlene Werkzeug für den Umgang mit dieser Situation. Zuerst aktiviert es B<PTRACE_EVENT_EXEC>-Stopp, der vor der Rückkehr von B<execve>(2) auftritt. In diesem Stopp kann der Verfolger B<PTRACE_GETEVENTMSG> verwenden, um die vorherige Thread-Kennung des verfolgten Prozesses zu erhalten. (Diese Funktion wurde in Lunux 3.0 eingeführt.) Als zweites deaktiviert die Option B<PTRACE_O_TRACEEXEC> die alte B<SIGTRAP>-Erzeugung auf B<execve>(2).

note: type: Plain text
en: When the tracer receives B<PTRACE_EVENT_EXEC> stop notification, it is guaranteed that except this tracee and the thread group leader, no other threads from the process are alive.
de: Wenn der Verfolger die B<PTRACE_EVENT_EXEC>-Stoppbenachrichtigung empfängt, ist garantiert, dass außer diesem verfolgten Prozess und dem führenden Thread der Gruppe keine anderen Threads des Prozesses lebendig sind.

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
de: Beim Empfang der B<PTRACE_EVENT_EXEC>-Stoppbenachrichtigung sollte der Verfolger all seine internen Datenstrukturen aufräumen, die Threads dieses Prozesses beschreiben und nur eine Datenstruktur behalten, – eine, die den einzelnen, laufenden, verfolgten Prozess beschreibt mit

note: type: Plain text
en:     thread ID == thread group ID == process ID.
de:     Thread-Kennung == Thread-Gruppenkennung == Prozesskennung.

note: type: Plain text
en: Example: two threads call B<execve>(2)  at the same time:
de: Beispiel: Zwei Threads rufen zur gleichen Zeit B<execve>(2) auf:

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
de: *** wir bekommen einen Systemaufrufeintrittsstopp in Thread 1: **
    PID1 execve("/bin/foo", "foo" E<lt>nicht abgeschlossen …E<gt>
    *** wir liefern PTRACE_SYSCALL für Thread 1 **
    *** wir bekommen einen Systemaufrufeintrittsstopp in Thread 2: **
    PID2 execve("/bin/bar", "bar" E<lt>nicht abgeschlossen …E<gt>
    *** wir liefern PTRACE_SYSCALL für Thread 2 **
    *** wir bekommen PTRACE_EVENT_EXEC für PID0, wir liefern  PTRACE_SYSCALL **
    *** wir bekommen Systemaufrufbeendigungsstopp für PID0: **
    PID0 E<lt>… execve wieder aufgenommenE<gt> )             = 0

note: type: Plain text
en: If the B<PTRACE_O_TRACEEXEC> option is I<not> in effect for the execing tracee, and if the tracee was B<PTRACE_ATTACH>ed rather that B<PTRACE_SEIZE>d, the kernel delivers an extra B<SIGTRAP> to the tracee after B<execve>(2)  returns.  This is an ordinary signal (similar to one which can be generated by I<kill -TRAP>), not a special kind of ptrace-stop.  Employing B<PTRACE_GETSIGINFO> for this signal returns I<si_code> set to 0 (I<SI_USER>).  This signal may be blocked by signal mask, and thus may be delivered (much) later.
de: Falls die Option B<PTRACE_O_TRACEEXEC> für den ausführenden, verfolgten Prozess I<nicht> in Kraft ist und falls der verfolgte Prozess B<PTRACE_ATTACH>ed statt B<PTRACE_SEIZE>d war, sendet der Kernel ein zusätzliches B<SIGTRAP> an den verfolgten Prozess, nachdem B<execve>(2) zurückgekehrt ist. Dies ist ein gewöhnliches Signal (ähnlich einem, das durch I<kill -TRAP> erzeugt werden kann), keine Spezialart eines Ptrace-Stopps. Unter Einsatz von B<PTRACE_GETSIGINFO> für dieses Signal gibt I<si_code> auf 0 gesetzt (I<SI_USER>) zurück. Dieses Signal kann durch die Signalmaske blockiert sein und könnte daher (viel) später gesandt werden.

note: type: Plain text
en: Usually, the tracer (for example, B<strace>(1))  would not want to show this extra post-execve B<SIGTRAP> signal to the user, and would suppress its delivery to the tracee (if B<SIGTRAP> is set to B<SIG_DFL>, it is a killing signal).  However, determining I<which> B<SIGTRAP> to suppress is not easy.  Setting the B<PTRACE_O_TRACEEXEC> option or using B<PTRACE_SEIZE> and thus suppressing this extra B<SIGTRAP> is the recommended approach.
de: Üblicherweise würde der Verfolger dem Anwender dieses zusätzliche B<SIGTRAP>-Signal nach Execve nicht zeigen wollen und seinen Versand an den verfolgten Prozess unterdrücken (falls B<SIGTRAP> auf B<SIGTRAP> gesetzt ist, killt es das Signal). Es ist jedoch nicht einfach zu bestimmen, I<welches> B<SIGTRAP> zu unterdrücken ist. Die empfohlene Herangehensweise ist, die Option B<PTRACE_O_TRACEEXEC> zu setzen oder B<PTRACE_SEIZE> zu verwenden und damit dieses zusätzliche B<SIGTRAP> zu unterdrücken.

note: type: SS
en: Real parent
de: Echter Elternprozess

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.
de: Die Ptrace-Programmierschnittstelle (miss)braucht die Standard-UNIX-Eltern-/Kindprozess-Signalgebung über B<waitpid>(2). Diese wird benutzt, um den echten Elternprozess zum Stopp des Empfangs mehrerer Arten von B<waitpid>(2)-Benachrichtigungen zu veranlassen, wenn der Kindprozess durch einen anderen Prozess verfolgt wird.

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.
de: Viele dieser Fehler wurden behoben, aber ab Linux 2.6.38 existieren etliche immer noch; siehe FEHLER oberhalb.

note: type: Plain text
en: As of Linux 2.6.38, the following is believed to work correctly:
de: Ab Linux 2.6.38 wird davon ausgegangen, dass folgendes korrekt funktioniert:

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.
de: Beenden/Sterben durch Signal wird zuerst an den Verfolger gemeldet, dann, wenn der Verfolger das B<waitpid>(2)-Ergebnis verbraucht, an den echten Elternprozess (an den echten Elternprozess nur, wenn der ganze Prozess aus mehreren Threads existiert). Falls der Verfolger und der echte Elternprozess derselbe Prozess sind, wird der Bericht nur einmal gesandt.

note: type: SH
en: RETURN VALUE
de: RÜCKGABEWERT

note: type: Plain text
en: On success, the B<PTRACE_PEEK*> requests return the requested data (but see NOTES), the B<PTRACE_SECCOMP_GET_FILTER> request returns the number of instructions in the BPF program, and other requests return zero.
de: Bei Erfolg geben die B<PTRACE_PEEK*>-Anfragen die angeforderten Daten zurück (aber siehe die ANMERKUNGEN), die Anfrage B<PTRACE_SECCOMP_GET_FILTER> liefert die Anzahl der Anweisungen in dem BPF-Programm zurück und andere Anfragen geben Null zurück.

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.
de: Bei einem Fehler geben alle Anfragen -1 zurück und I<errno> wird entsprechend gesetzt. Da der Wert, der von einer erfolgreichen B<PTRACE_PEEK*>-Anfrage zurückgegeben wurde, -1 sein könnte, muss der Aufrufende vor dem Aufruf I<errno> leeren und es dann hinterher untersuchen, um festzustellen, ob ein Fehler aufgetreten ist oder nicht.

note: type: SH
en: ERRORS
de: FEHLER

note: type: Plain text
en: (i386 only) There was an error with allocating or freeing a debug register.
de: (nur i386) Es ist beim Reservieren oder der Freigabe eines Debug-Registers ein Fehler aufgetreten.

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.
de: Es gab einen Versuch in einem ungültigen Bereich im Speicher des Verfolgers oder des verfolgten Prozesses zu lesen oder zu schreiben, wahrscheinlich, weil der Bereich nicht abgebildet war oder kein Zugriff möglich war. Unglücklicherweise geben unter Linux mehrere Variationen dieser Ausnahmebehandlung mehr oder weniger willkürlich B<EIO> oder B<EFAULT> zurück.

note: type: Plain text
en: An attempt was made to set an invalid option.
de: Es wurde versucht, eine ungültige Option zu setzen.

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.
de: I<Anfrage> ist ungültig, es wurde versucht, in einem ungültigen Bereich im Speicher des Verfolgers oder des verfolgten Prozesses zu lesen oder zu schreiben, es gab eine Verletzung der Ausrichtung an der »word«-Größe oder es wurde während des Neustarts der Abfrage ein ungültiges Signal angegeben.

note: type: Plain text
en: The specified process cannot be traced.  This could be because the tracer has insufficient privileges (the required capability is B<CAP_SYS_PTRACE>); unprivileged processes cannot trace processes that they cannot send signals to or those running set-user-ID/set-group-ID programs, for obvious reasons.  Alternatively, the process may already be being traced, or (on kernels before 2.6.26) be B<init>(1)  (PID 1).
de: Der angegebene Prozess kann nicht verfolgt werden. Dies könnte daher rühren, dass der Verfolger über unzureichende Privilegien verfügt (die Capability B<CAP_SYS_PTRACE> wird benötigt); unprivilegierte Prozesse können keine Prozesse verfolgen, denen sie keine Signale senden können oder die SUID-/SGID-Programme ausführen, was naheliegend ist. Alternativ könnte der Prozess bereits verfolgt werden oder (auf Kerneln vor 2.6.26) B<init>(1) (PID 1) sein.

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).
de: Der angegebene Prozess existiert nicht, wird derzeit nicht vom Aufrufenden verfolgt oder ist nicht gestoppt (bei Anfragen, die einen gestoppten verfolgten Prozess erfordern).

note: type: SH
en: CONFORMING TO
de: KONFORM ZU

note: type: SH
en: NOTES
de: ANMERKUNGEN

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>.
de: Obwohl Argumente für B<ptrace>() gemäß dem angegebenen Prototypen interpretiert werden, deklariert Glibc derzeit B<ptrace>() als eine variable Funktion mit nur dem festen I<Anfrage>-Argument. Es wird empfohlen, immer vier Argumente anzugeben, sogar dann, wenn die angeforderte Aktion sie nicht verwendet. Setzen Sie unbenutzte/ignorierte Argumente auf I<0L> oder I<(void\ *)\ 0>.

note: See commit 00cd5c37afd5f431ac186dd131705048c0a11fdb type: Plain text
en: In Linux kernels before 2.6.26, B<init>(1), the process with PID 1, may not be traced.
de: In Linux-Kerneln vor 2.6.26 kann B<init>(1) den Prozess mit der Prozessnummer 1 nicht verfolgen.

note: type: Plain text
en: A tracees parent continues to be the tracer even if that tracer calls B<execve>(2).
de: Der Elternprozess des verfolgten Prozesses wird weiterhin der Verfolger sein, selbst wenn der Verfolger B<execve>(2) aufruft.

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>.
de: Das Layout des Speicherinhalts und des BENUTZERbereichs sind ziemlich betriebsystem- und architekturspezifisch. Der mitgelieferte Versatz und die zurückgegebenen Daten passen möglicherweise nicht ganz zu der Definition von 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).
de: Die Größe eines »word« wird durch die Betriebsystemvariante festgelegt (z.B. ist es für ein 32-Bit-Linux 32 Bit).

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.
de: Diese Seite dokumentiert die Möglichkeit, wie der B<ptrace>()-Aufruf derzeit in Linux arbeitet. Sein Verhalten unterscheidet sich auf anderen unixoiden Betriebssystemen deutlich. Auf jeden Fall ist die Benutzung von B<ptrace>() in hohem Grad abhängig vom Betriebssystem und der Architektur.

note: type: SS
en: Ptrace access mode checking
de: Ptrace-Zugriffsmodusüberprüfung

note: type: Plain text
en: Various parts of the kernel-user-space API (not just B<ptrace>()  operations), require so-called "ptrace access mode" checks, whose outcome determines whether an operation is permitted (or, in a few cases, causes a "read" operation to return sanitized data).  These checks are performed in cases where one process can inspect sensitive information about, or in some cases modify the state of, another process.  The checks are based on factors such as the credentials and capabilities of the two processes, whether or not the "target" process is dumpable, and the results of checks performed by any enabled Linux Security Module (LSM)\(emfor example, SELinux, Yama, or Smack\(emand by the commoncap LSM (which is always invoked).
de: Verschiedene Teile des Kernel-Benutzerraum-APIs (nicht nur B<ptrace>()-Aktionen) benötigen sogenannte »Ptrace-Zugriffsmodusüberprüfungen«, deren Ergebnis bestimmt, ob eine Aktion erlaubt (oder, in wenigen Fällen, einer »Lese«-Aktion bereinigte Daten zurückliefern) wird. Diese Überprüfungen werden in Fällen durchgeführt, in denen ein Prozess vertrauliche Informationen über einen anderen Prozess einsehen könnte oder in einigen Fällen den Zustand eines anderen Prozesse verändern könnte. Die Überprüfungen basieren auf Faktoren wie den Berechtigungsnachweisen und den Capabilitys der zwei Prozesse, ob der Speicherinhalt des »Zielprozesses« ausgegeben werden kann und dem Ergebnis der Überprüfungen, die durch jedes aktivierte Linux-Sicherheitsmodul (LSM) – zum Beispiel SELinux, Yama oder Smack – und durch das Commoncap-LSM (das immer ausgeführt wird), ausgeführt wird.

note: commit 006ebb40d3d65338bd74abb03b945f8d60e362bd type: Plain text
en: Prior to Linux 2.6.27, all access checks were of a single type.  Since Linux 2.6.27, two access mode levels are distinguished:
de: Vor Linux 2.6.27 waren alle Zugriffsprüfungen von einem einzigen Typ. Seit Linux 2.6.27 werden zwei Zugriffsmodi unterschieden:

note: type: Plain text
en: For "read" operations or other operations that are less dangerous, such as: B<get_robust_list>(2); B<kcmp>(2); reading I</proc/[pid]/auxv>, I</proc/[pid]/environ>, or I</proc/[pid]/stat>; or B<readlink>(2)  of a I</proc/[pid]/ns/*> file.
de: Für »Lese«-Aktionen oder andere Aktionen, die weniger gefährlich sind, wie B<get_robust_list>(2); B<kcmp>(2); Lesen aus I</proc/[PID]/auxv>, I</proc/[PID]/environ> oder I</proc/[PID]/stat>; oder B<readlink>(2) einer I</proc/[PID]/ns/*>-Datei.

note: Regarding the above description of the distinction between PTRACE_MODE_READ and PTRACE_MODE_ATTACH, Stephen Smalley notes: That was the intent when the distinction was introduced, but it doesn't appear to have been properly maintained, e.g. there is now a common helper lock_trace() that is used for 
en: For "write" operations, or other operations that are more dangerous, such as: ptrace attaching (B<PTRACE_ATTACH>)  to another process or calling B<process_vm_writev>(2).  (B<PTRACE_MODE_ATTACH> was effectively the default before Linux 2.6.27.)
de: Für »Schreibe«-Aktionen oder andere Aktionen, die gefährlicher sind, wie Ptrace-Anhängungen (B<PTRACE_ATTACH>) an einen anderen Prozess oder Aufrufe von B<process_vm_writev>(2). (B<PTRACE_MODE_ATTACH> war tatsächlich die Vorgabe vor Linux 2.6.27.)

note: commit caaee6234d05a58c5b4d05e7bf766131b810a657 type: Plain text
en: Since Linux 4.5, the above access mode checks are combined (ORed) with one of the following modifiers:
de: Seit Linux 4.5 sind die obigen Zugriffsmodusprüfungen mittels ODER mit einem der folgenden Modifikatoren verknüpft:

note: type: Plain text
en: Use the caller's filesystem UID and GID (see B<credentials>(7))  or effective capabilities for LSM checks.
de: Die Dateisystem-UID und -GID (siehe B<credentials>(7)) oder die effektiven Capabilitys für LSM-Prüfungen des Aufrufenden verwenden.

note: type: Plain text
en: Use the caller's real UID and GID or permitted capabilities for LSM checks.  This was effectively the default before Linux 4.5.
de: Die reale UID und GID oder die erlaubten Capabilitys für LSM-Prüfungen des Aufrufenden verwenden. Dies war vor Linux 4.5 die Vorgabe.

note: type: Plain text
en: Because combining one of the credential modifiers with one of the aforementioned access modes is typical, some macros are defined in the kernel sources for the combinations:
de: Da die Kombination eines der Berechtigungsnachweise-Modifikatoren mit einem der vorgenannten Zugriffsmodi typisch ist, sind ein paar Makros in den Kernelquellen für die Kombinationen definiert.

note: type: Plain text
en: Defined as B<PTRACE_MODE_READ | PTRACE_MODE_FSCREDS>.
de: Definiert als B<PTRACE_MODE_READ | PTRACE_MODE_FSCREDS>.

note: type: Plain text
en: Defined as B<PTRACE_MODE_READ | PTRACE_MODE_REALCREDS>.
de: Definiert als B<PTRACE_MODE_READ | PTRACE_MODE_REALCREDS>.

note: type: Plain text
en: Defined as B<PTRACE_MODE_ATTACH | PTRACE_MODE_FSCREDS>.
de: Definiert als B<PTRACE_MODE_ATTACH | PTRACE_MODE_FSCREDS>.

note: type: Plain text
en: Defined as B<PTRACE_MODE_ATTACH | PTRACE_MODE_REALCREDS>.
de: Definiert als B<PTRACE_MODE_ATTACH | PTRACE_MODE_REALCREDS>.

note: type: Plain text
en: One further modifier can be ORed with the access mode:
de: Ein weiterer Modifikator kann mit den Zugriffsmodus mittels ODER verknüpft werden:

note: type: TP
en: B<PTRACE_MODE_NOAUDIT> (since Linux 3.3)
de: B<PTRACE_MODE_NOAUDIT> (seit Linux 3.3)

note: commit 69f594a38967f4540ce7a29b3fd214e68a8330bd Just for /proc/pid/stat type: Plain text
en: Don't audit this access mode check.  This modifier is employed for ptrace access mode checks (such as checks when reading I</proc/[pid]/stat>)  that merely cause the output to be filtered or sanitized, rather than causing an error to be returned to the caller.  In these cases, accessing the file is not a security violation and there is no reason to generate a security audit record.  This modifier suppresses the generation of such an audit record for the particular access check.
de: Diese Zugriffsmodusprüfung nicht auditieren. Dieser Modifikator wird für Ptrace-Zugriffsmodusprüfungen eingesetzt (wie z.B. Prüfungen beim Lesen von I</proc/[PID]/stat>), die lediglich die Ausgabe filtern oder bereinigen, statt dem Aufrufenden einen Fehler zurückzuliefern. In diesen Fällen ist der Zugriff auf die Datei keine Sicherheitsverletzung und es gibt keinen Grund, einen Sicherheitsauditdatensatz zu erstellen. Dieser Modifikator unterdrückt die Erstellung eines solchen Auditdatensatzes für diese Zugriffsprüfung.

note: type: Plain text
en: Note that all of the B<PTRACE_MODE_*> constants described in this subsection are kernel-internal, and not visible to user space.  The constant names are mentioned here in order to label the various kinds of ptrace access mode checks that are performed for various system calls and accesses to various pseudofiles (e.g., under I</proc>).  These names are used in other manual pages to provide a simple shorthand for labeling the different kernel checks.
de: Beachten Sie, dass alle in diesem Unterabschnitt beschriebenen Konstanten B<PTRACE_MODE_*> kernelintern und nicht im Anwendungsraum sichtbar sind. Die Konstantennamen werden hier benannt, um den verschiedenen Arten von Ptrace-Zugriffsmodusprüfungen, die für verschiedene Systemaufrufe und Zugriff auf verschiedene Pseudodateien (z.B. unter I</proc>) durchgeführt werden, einen Namen zu geben. Diese Namen werden in anderen Handbuchseiten benutzt, um eine einfache Abkürzung für die Benennung der verschiedenen Kernelprüfungen bereitzustellen.

note: type: Plain text
en: The algorithm employed for ptrace access mode checking determines whether the calling process is allowed to perform the corresponding action on the target process.  (In the case of opening I</proc/[pid]> files, the "calling process" is the one opening the file, and the process with the corresponding PID is the "target process".)  The algorithm is as follows:
de: Der für Ptrace-Zugriffsmodusprüfungen eingesetzte Algorithmus bestimmt, ob dem aufrufenden Prozess erlaubt wird, die entsprechende Aktion auf dem Zielprozess durchzuführen. (Im Falle des Öffnens von I</proc/[PID]>-Dateien ist der »aufrufende Prozess« derjenige, der die Datei öffnet, und der Prozess mit der entsprechenden PID der »Zielprozess«). Der Algorithmus geht wie folgt:

note: type: Plain text
en: If the calling thread and the target thread are in the same thread group, access is always allowed.
de: Falls der aufrufende Thread und der Ziel-Thread in der gleichen Thread-Gruppe sind, wird der Zugriff immer erlaubt.

note: type: Plain text
en: If the access mode specifies B<PTRACE_MODE_FSCREDS>, then, for the check in the next step, employ the caller's filesystem UID and GID.  (As noted in B<credentials>(7), the filesystem UID and GID almost always have the same values as the corresponding effective IDs.)
de: Falls der Zugriffsmodus B<PTRACE_MODE_FSCREDS> festlegt, dann wird für die Prüfung im nächsten Schritt die Dateisystem-UID und -GID des Aufrufenden verwandt. (Wie in B<credentials>(7) vermerkt, haben die Dateisystem-UID und -GID fast immer die gleichen Werte wie die entsprechenden effektiven Kennungen.)

note: type: Plain text
en: Otherwise, the access mode specifies B<PTRACE_MODE_REALCREDS>, so use the caller's real UID and GID for the checks in the next step.  (Most APIs that check the caller's UID and GID use the effective IDs.  For historical reasons, the B<PTRACE_MODE_REALCREDS> check uses the real IDs instead.)
de: Andernfalls legt der Zugriffsmodus B<PTRACE_MODE_REALCREDS> fest, so dass die reale UID und GID für die Prüfungen im nächsten Schritt verwandt werden. (Die meisten APIs, die die UIDs und GIDs des Aufrufenden prüfen, verwenden effektive Kennungen. Aus historischen Gründen verwendet die Prüfung B<PTRACE_MODE_REALCREDS> stattdessen die realen Kennungen.)

note: type: Plain text
en: Deny access if I<neither> of the following is true:
de: Zugriff verweigern, falls I<keines> der Folgenden wahr ist:

note: type: Plain text
en: The real, effective, and saved-set user IDs of the target match the caller's user ID, I<and> the real, effective, and saved-set group IDs of the target match the caller's group ID.
de: Die reale, effektive und saved-set-Benutzerkennungen des Zieles passen auf die der Benutzerkennung des Aufrufenden I<und> die reale, effektive und saved-set-Gruppenkennung des Zieles passen auf die der Gruppenkennung des Aufrufenden.

note: type: Plain text
en: The caller has the B<CAP_SYS_PTRACE> capability in the user namespace of the target.
de: Der Aufrufende verfügt über die Capability B<CAP_SYS_PTRACE> in dem Benutzernamensraum des Ziels.

note: type: Plain text
en: Deny access if the target process "dumpable" attribute has a value other than 1 (B<SUID_DUMP_USER>; see the discussion of B<PR_SET_DUMPABLE> in B<prctl>(2)), and the caller does not have the B<CAP_SYS_PTRACE> capability in the user namespace of the target process.
de: Verweigert den Zugriff, falls das Attribut »dumpable« einen anderen Wert als 1 (B<SUID_DUMP_USER>, siehe die Diskussion von B<PR_SET_DUMPABLE> in B<prctl>(2)) hat und der Aufrufende nicht über die Capability B<CAP_SYS_PTRACE> in dem Benutzernamensraum des Zielprozesses verfügt.

note: (in cap_ptrace_access_check()): type: Plain text
en: The kernel LSM I<security_ptrace_access_check>()  interface is invoked to see if ptrace access is permitted.  The results depend on the LSM(s).  The implementation of this interface in the commoncap LSM performs the following steps:
de: Die Schnittstelle I<security_ptrace_access_check>() wird aufgerufen, um zu erkennen, ob Ptrace-Zugriff erlaubt ist. Das Ergebnis hängt von dem/den LSM(en) ab. Die Implementierung dieser Schnittstelle im LSM Commoncap führt die folgenden Schritte durch:

note: type: Plain text
en: If the access mode includes B<PTRACE_MODE_FSCREDS>, then use the caller's I<effective> capability set in the following check; otherwise (the access mode specifies B<PTRACE_MODE_REALCREDS>, so) use the caller's I<permitted> capability set.
de: Falls der Zugriffsmodus B<PTRACE_MODE_FSCREDS> enthält, dann wird die I<effektive> Capability-Menge des Aufrufenden in der nachfolgenden Prüfung verwandt, andernfalls (der Zugriffsmodus legt B<PTRACE_MODE_REALCREDS> fest) wird die I<erlaubte> Capability-Menge des Aufrufenden verwandt.

note: type: Plain text
en: The caller and the target process are in the same user namespace, and the caller's capabilities are a superset of the target process's I<permitted> capabilities.
de: Der aufrufende und der Zielprozess sind im gleichen Benutzernamensraum und die Capabilitys des Aufrufenden sind eine Obermenge der I<erlaubten> Capabilitys des Zielprozesses.

note: type: Plain text
en: The caller has the B<CAP_SYS_PTRACE> capability in the target process's user namespace.
de: Der Aufrufende verfügt über die Capability B<CAP_SYS_PTRACE> in dem Benutzernamensraum des Zielprozesses.

note: type: Plain text
en: Note that the commoncap LSM does not distinguish between B<PTRACE_MODE_READ> and B<PTRACE_MODE_ATTACH>.
de: Beachten Sie, dass das LSM Commoncap nicht zwischen B<PTRACE_MODE_READ> und B<PTRACE_MODE_ATTACH> unterscheidet.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: If access has not been denied by any of the preceding steps, then access is allowed.
de: Falls der Zugriff in den vorhergehenden Schritten nicht verweigert wurde, dann wird er erlaubt.

note: commit 2d514487faf188938a4ee4fb3464eeecfbdcf8eb type: Plain text
en: On systems with the Yama Linux Security Module (LSM) installed (i.e., the kernel was configured with B<CONFIG_SECURITY_YAMA>), the I</proc/sys/kernel/yama/ptrace_scope> file (available since Linux 3.4)  can be used to restrict the ability to trace a process with B<ptrace>()  (and thus also the ability to use tools such as B<strace>(1)  and B<gdb>(1)).  The goal of such restrictions is to prevent attack escalation whereby a compromised process can ptrace-attach to other sensitive processes (e.g., a GPG agent or an SSH session) owned by the user in order to gain additional credentials that may exist in memory and thus expand the scope of the attack.
de: Auf Systemen, auf denen das Yama Linux Security Module (LSM) installiert (d.h. der Kernel mit B<CONFIG_SECURITY_YAMA> konfiguriert worden) ist, kann die Datei I</proc/sys/kernel/yama/ptrace_scope> (verfügbar seit Linux 3.4) zum Einschränken der Nachverfolgung von Prozessen mit B<ptrace>() verwandt werden (und damit auch die Möglichkeit, Werkzeuge wie B<strace>(1) und B<gdb>(1) zu verwenden). Das Ziel einer solchen Einschränkung besteht darin, Angriffseskalationen zu vermeiden, bei denen ein kompromittierter Prozess sich mittels Ptrace-attach an andere sensitive Prozesse (z.B. einem GPG-Agenten oder einer SSH-Sitzung), die dem Benutzer gehören, anhängen könnte, um zusätzliche Berechtigungsnachweise zu erlangen, die im Speicher existieren, und damit den Umfang des Angriffs zu erhöhen.

note: type: Plain text
en: More precisely, the Yama LSM limits two types of operations:
de: Genauer gesagt begrenzt die Yama LSM zwei Arten von Aktionen:

note: type: Plain text
en: Any operation that performs a ptrace access mode B<PTRACE_MODE_ATTACH> check\(emfor example, B<ptrace>()  B<PTRACE_ATTACH>.  (See the "Ptrace access mode checking" discussion above.)
de: Jede Aktion, die eine Ptrace-Zugriffsmodusprüfung B<PTRACE_MODE_ATTACH> durchführt – beispielsweise B<ptrace>() B<PTRACE_ATTACH>. (Siehe die obige Diskussion »Ptrace-Zugriffsmodusüberprüfung«).

note: type: Plain text
en: B<ptrace>()  B<PTRACE_TRACEME>.
de: B<ptrace>() B<PTRACE_TRACEME>.

note: type: Plain text
en: A process that has the B<CAP_SYS_PTRACE> capability can update the I</proc/sys/kernel/yama/ptrace_scope> file with one of the following values:
de: Ein Prozess, der über die Capability B<CAP_SYS_PTRACE> verfügt, kann die Datei I</proc/sys/kernel/yama/ptrace_scope> mit einem der folgenden Werte aktualisieren:

note: type: TP
en: 0 ("classic ptrace permissions")
de: 0 (»klassische Ptrace-Berechtigungen«)

note: type: Plain text
en: No additional restrictions on operations that perform B<PTRACE_MODE_ATTACH> checks (beyond those imposed by the commoncap and other LSMs).
de: Keine zusätzlichen Beschränkungen bei Aktionen, die B<PTRACE_MODE_ATTACH>-Überprüfungen durchführen (die über die von Commoncap und anderen LSMs hinausgehen).

note: type: Plain text
en: The use of B<PTRACE_TRACEME> is unchanged.
de: B<PTRACE_TRACEME> wird unverändert verwandt.

note: type: TP
en: 1 ("restricted ptrace") [default value]
de: 1 (»eingeschränkter Ptrace«) [Vorgabewert]

note: type: Plain text
en: When performing an operation that requires a B<PTRACE_MODE_ATTACH> check, the calling process must either have the B<CAP_SYS_PTRACE> capability in the user namespace of the target process or it must have a predefined relationship with the target process.  By default, the predefined relationship is that the target process must be a descendant of the caller.
de: Wenn eine Aktion durchgeführt wird, die eine B<PTRACE_MODE_ATTACH>-Überprüfung benötigt, muss der aufrufende Prozess entweder über die Capability B<CAP_SYS_PTRACE> in dem Benutzernamensraum des Zielprozesses verfügen oder er muss eine vorbestimmte Beziehung zum Zielprozess haben. Standardmäßig ist die vorbestimmte Beziehung, dass der Zielprozess ein Nachkomme des Aufrufenden sein muss.

note: commit 90bb766440f2147486a2acc3e793d7b8348b0c22 type: Plain text
en: A target process can employ the B<prctl>(2)  B<PR_SET_PTRACER> operation to declare an additional PID that is allowed to perform B<PTRACE_MODE_ATTACH> operations on the target.  See the kernel source file I<Documentation/admin-guide/LSM/Yama.rst> (or I<Documentation/security/Yama.txt> before Linux 4.13)  for further details.
de: Ein Zielprozess kann die B<prctl>(2)-Aktion B<PR_SET_PTRACER> einsetzen, um eine zusätzliche PID zu erklären, der es erlaubt ist, B<PTRACE_MODE_ATTACH>-Aktionen auf dem Ziel durchzuführen. Siehe die Kernelquelldatei I<Documentation/admin-guide/LSM/Yama.rst> (oder I<Documentation/security/Yama.txt> vor Linux 4.13) für weitere Details.

note: type: TP
en: 2 ("admin-only attach")
de: 2 (»nur Admin-Anhängung«)

note: type: Plain text
en: Only processes with the B<CAP_SYS_PTRACE> capability in the user namespace of the target process may perform B<PTRACE_MODE_ATTACH> operations or trace children that employ B<PTRACE_TRACEME>.
de: Nur Prozesse mit der Capability B<CAP_SYS_PTRACE> im Benutzernamensraum des Zielprozesses dürfen B<PTRACE_MODE_ATTACH>-Aktionen durchführen oder Kinder, die B<PTRACE_TRACEME> einsetzen, verfolgen.

note: type: TP
en: 3 ("no attach")
de: 3 (»keine Anhängung«)

note: type: Plain text
en: No process may perform B<PTRACE_MODE_ATTACH> operations or trace children that employ B<PTRACE_TRACEME>.
de: Kein Prozess darf B<PTRACE_MODE_ATTACH>-Aktionen durchführen oder Kindprozesse verfolgen, die B<PTRACE_TRACEME> einsetzen.

note: type: Plain text
en: Once this value has been written to the file, it cannot be changed.
de: Sobald dieser Wert in die Datei geschrieben wurde, kann er nicht mehr geändert werden.

note: """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" type: Plain text
en: With respect to values 1 and 2, note that creating a new user namespace effectively removes the protection offered by Yama.  This is because a process in the parent user namespace whose effective UID matches the UID of the creator of a child namespace has all capabilities (including B<CAP_SYS_PTRACE>)  when performing operations within the child user namespace (and further-removed descendants of that namespace).  Consequently, when a process tries to use user namespaces to sandbox itself, it inadvertently weakens the protections offered by the Yama LSM.
de: Beachten Sie im Hinblick auf die Werte 1 und 2, dass die Erstellung eines neuen Benutzernamensraums effektiv den durch Yama bereitgestellten Schutz entfernt. Dies rührt daher, dass der Prozess in dem Elternbenutzerraum, dessen effektive UID auf die UID des Erstellers des Kindnamensraums passt, über alle Capabilitys (einschließlich B<CAP_SYS_PTRACE>) verfügt, wenn er Aktionen innerhalb des Kindnamensraums (und weiter entfernter Nachkommen dieses Namensraums) durchführt. Wenn ein Prozess versucht, einen Benutzernamensraum zu verwenden, um sich in eine Sandbox zu bringen, wird er konsequenterweise den durch das Yama LSM bereitgestellten Schutz schwächen.

note: type: SS
en: C library/kernel differences
de: Unterschiede C-Bibliothek/Kernel

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.
de: Auf der Systemaufrufebene haben die Anfragen B<PTRACE_PEEKTEXT>, B<PTRACE_PEEKDATA> und B<PTRACE_PEEKUSER> eine unterschiedliche Programmierschnittstelle: Sie speichern das Ergebnis an der durch den Parameter I<Daten> angegebenen Adresse und der Rückgabewert ist ein Fehlercode. Die Glibc-Wrapper-Funktion stellt die oben in BESCHREIBUNG angegebene Programmierschnittstelle bereit. Ihr Ergebnis wird über den Rückgabewert der Funktion zurückgegeben.

note: type: SH
en: BUGS
de: FEHLER

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.
de: Auf Rechnern mit 2.6 Kernel-Headern ist B<PTRACE_SETOPTIONS> mit einem anderen Wert deklariert, als auf einem für 2.4. Dies führt dazu, dass Anwendungen, die mit 2.6-Kernel-Headern kompiliert wurden, bei der Ausführung auf 2.4er Kerneln scheitern. Dies kann durch Neudefinieren von B<PTRACE_SETOPTIONS> zu B<PTRACE_OLDSETOPTIONS> umgangen werden, wenn dies definiert ist.

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.
de: Gruppenstoppbenachrichtigungen werden an der Verfolger gesandt, aber nicht an den echten Elternprozess. Zuletzt auf 2.6.38.6 bestätigt.

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.
de: Falls ein führender Thread einer Gruppe verfolgt und durch den Aufruf von B<_exit>(2) beendet wird, wird es für ihn zu einem B<PTRACE_EVENT_EXIT>-Stopp kommen (falls angefordert), aber die nachfolgende B<WIFEXITED>-Benachrichtigung wird nicht gesandt, bis alle anderen Threads beendet sind. Wie oben erklärt, wird der Tod des führenden Prozesses der Gruppe gemeldet, falls einer der anderen Threads B<execve>(2) aufruft. Falls der ausgeführte Thread nicht durch den Verfolger verfolgt wird, wird der Verfolger niemals erfahren, dass B<execve>(2) auftrat. Eine mögliche Notlösung ist ein B<PTRACE_DETACH> für den führenden Thread der Gruppe, anstatt ihn in diesem Fall neu zu starten. Zuletzt auf 2.6.38.6 bestätigt.

note: type: Plain text
en: A B<SIGKILL> signal may still cause a B<PTRACE_EVENT_EXIT> stop before actual signal death.  This may be changed in the future; B<SIGKILL> is meant to always immediately kill tasks even under ptrace.  Last confirmed on Linux 3.13.
de: Ein B<SIGKILL>-Signal kann immer noch einen B<PTRACE_EVENT_EXIT>-Stopp vor dem tatsächlichen Signaltod verursachen. Dies könnte in Zukunft geändert werden; B<SIGKILL> ist dazu gedacht, Aufgaben immer sofort zu killen, sogar unter Ptrace. Zuletzt auf Linux 3.13 bestätigt.

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
de: Einige Systemaufrufe kehren mit B<EINTR> zurück, falls ein Signal an den verfolgten Prozess gesandt, die Auslieferung aber durch den Verfolger unterdrückt wurde. (Dies ist eine ganz typische Aktion: Sie wird normalerweise von Fehlersuchprogrammen bei jedem Anhängen durchgeführt, um kein fingiertes B<SIGSTOP> einzuleiten.) Ab Linux 3.2.9 werden die folgenden Systemaufrufe beeinflusst (diese Liste ist wahrscheinlich nicht vollständig): B<epoll_wait>(2) und B<read>(2) von einem B<inotify>(7)-Dateideskriptor. Das übliche Anzeichen für diesen Fehler ist, falls Sie einen ruhenden Prozess mit dem Befehl

note: type: Plain text
en: strace -p E<lt>process-IDE<gt>
de: strace -p E<lt>ProzesskennungE<gt>

note: type: Plain text
en: then, instead of the usual and expected one-line output such as
de: anhängen, dass Sie statt der erwarteten einzeiligen Ausgabe, wie

note: type: Plain text
en: restart_syscall(E<lt>... resuming interrupted call ...E<gt>_
de: restart_syscall(E<lt>… resuming interrupted call …E<gt>_

note: type: Plain text
en: ('_' denotes the cursor position), you observe more than one line.  For example:
de: ('_' kennzeichnet die Cursor-Position) mehr als eine Zeile beobachten können, zum Beispiel:

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.)
de: Was hier nicht sichtbar ist, ist, dass der Prozess in B<epoll_wait>(2) blockiert wurde, bevor B<strace>(1) an ihn angehängt hat. Das Anhängen verursachte ein B<epoll_wait>(2), um zum Anwendungsraum mit dem Fehler B<EINTR> zurückzukehren. In diesem besonderen Fall reagiert das Programm auf B<EINTR>, indem die aktuelle Zeit geprüft und dann B<epoll_wait>(2) erneut ausgeführt wird. (Programme, die keine derartigen »verirrten« B<EINTR>-Fehler erwarten, können sich bei einem B<strace>(1)-Anhängen in unbeabsichtigter Weise verhalten.)

note: type: Plain text
en: Contrary to the normal rules, the glibc wrapper for B<ptrace>()  can set I<errno> to zero.
de: Entgegen den normalen Regeln kann der Glibc-Wrapper für B<ptrace>() I<errno> auf Null setzen.

note: type: SH
en: SEE ALSO
de: SIEHE AUCH

note: type: SH
en: COLOPHON
de: KOLOPHON

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/.
de: Diese Seite ist Teil der Veröffentlichung 5.03 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2018-04-30
de: 30. April 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/.
de: Diese Seite ist Teil der Veröffentlichung 5.02 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: The caller and the target process are in the same user namespace, and the caller's capabilities are a proper superset of the target process's I<permitted> capabilities.
de: Der aufrufende und der Zielprozess sind im gleichen Benutzernamensraum und die Capabilitys des Aufrufenden sind eine korrekte Obermenge der I<erlaubten> Capabilitys des Zielprozesses.

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/.
de: Diese Seite ist Teil der Veröffentlichung 5.01 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.
