[RFR] man://manpages-de/ptrace.2

[Chris Leick <c.leick@vollbio.de>]

Hallo,

anbei die völlig überarbeitete Version der Handbuchseite von Ptrace.
Es sind 246 Zeichenketten.
Bitte um Korrektur.

Gruß,
Chris

# German translation of manpages
# This file is distributed under the same license as the manpages-de package.
# Copyright © Patrick Rother <krd@gulu.net>
# Copyright © of this file Chris Leick <c.leick@vollbio.de>, 2010, 2012.
#
msgid ""
msgstr ""
"Project-Id-Version: manpages-de\n"
"POT-Creation-Date: 2012-05-09 21:48+0300\n"
"PO-Revision-Date: 2012-05-31 19:14+0100\n"
"Last-Translator: Chris Leick <c.leick@vollbio.de>\n"
"Language-Team: German <debian-l10n-german@lists.debian.org>\n"
"Language: de\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. type: TH
#, no-wrap
msgid "PTRACE"
msgstr "PTRACE"

#. type: TH
#, no-wrap
msgid "2012-04-26"
msgstr "26. April 2012"

#. type: TH
#, no-wrap
msgid "Linux"
msgstr "Linux"

#. type: TH
#, no-wrap
msgid "Linux Programmer's Manual"
msgstr "Linux-Programmierhandbuch"

#. type: SH
#, no-wrap
msgid "NAME"
msgstr "BEZEICHNUNG"

#. type: Plain text
msgid "ptrace - process trace"
msgstr "ptrace - Prozessverfolgung"

#. type: SH
#, no-wrap
msgid "SYNOPSIS"
msgstr "Ã?BERSICHT"

#. type: Plain text
#, no-wrap
msgid "B<#include E<lt>sys/ptrace.hE<gt>>\n"
msgstr "B<#include E<lt>sys/ptrace.hE<gt>>\n"

#. type: Plain text
#, no-wrap
msgid ""
"B<long ptrace(enum __ptrace_request >I<request>B<, pid_t >I<pid>B<, >\n"
"B<            void *>I<addr>B<, void *>I<data>B<);>\n"
msgstr ""
"B<long ptrace(enum __ptrace_request >I<Anfrage>B<, pid_t >I<Pid>B<, >\n"
"B<            void *>I<Adresse>B<, void *>I<Daten>B<);>\n"

#. type: SH
#, no-wrap
msgid "DESCRIPTION"
msgstr "BESCHREIBUNG"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"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"
msgstr ""
"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:"

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_foo, pid, ...)\n"
msgstr "    ptrace(PTRACE_foo, PID, â?¦)\n"

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

#. type: Plain text
msgid ""
"(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.)"
msgstr ""
"(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.)"

#. type: Plain text
msgid ""
"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>."
msgstr ""
"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> "
"beginnen."

#. type: Plain text
msgid ""
"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)."
msgstr ""
"Während der verfolgte 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)."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"When the tracer is finished tracing, it can cause the tracee to continue "
"executing in a normal, untraced mode via B<PTRACE_DETACH>."
msgstr ""
"Wenn der Verfolger die Verfolgung beendet hat, kann er veranlassenden, das "
"der verfolgte Prozess mit B<PTRACE_DETACH> in einem normal Modus ohne "
"Verfolgung fortfährt."

#. type: Plain text
msgid "The value of I<request> determines the action to be performed:"
msgstr ""
"Der Wert des Arguments I<Anfrage> legt die Aktion des Systemaufrufs fest:"

#. type: TP
#, no-wrap
msgid "B<PTRACE_TRACEME>"
msgstr "B<PTRACE_TRACEME>"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: Plain text
msgid ""
"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> and B<PTRACE_KILL>, the tracee must be stopped."
msgstr ""
"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> und "
"B<PTRACE_KILL> muss der verfolgte Prozess gestoppt werden."

#. type: TP
#, no-wrap
msgid "B<PTRACE_PEEKTEXT>, B<PTRACE_PEEKDATA>"
msgstr "B<PTRACE_PEEKTEXT>, B<PTRACE_PEEKDATA>"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_PEEKUSER>"
msgstr "B<PTRACE_PEEKUSER>"

#.  PTRACE_PEEKUSR in kernel source, but glibc uses PTRACE_PEEKUSER,
#.  and that is the name that seems common on other systems.
#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_POKETEXT>, B<PTRACE_POKEDATA>"
msgstr "B<PTRACE_POKETEXT>, B<PTRACE_POKEDATA>"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 Abfragen derzeit gleichwertig."

#. type: TP
#, no-wrap
msgid "B<PTRACE_POKEUSER>"
msgstr "B<PTRACE_POKEUSER>"

#.  PTRACE_POKEUSR in kernel source, but glibc uses PTRACE_POKEUSER,
#.  and that is the name that seems common on other systems.
#.  FIXME In the preceding sentence, which modifications are disallowed,
#.  and when they are disallowed, how does userspace discover that fact?
#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_GETREGS>, B<PTRACE_GETFPREGS>"
msgstr "B<PTRACE_GETREGS>, B<PTRACE_GETFPREGS>"

#. type: Plain text
msgid ""
"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>."
msgstr ""
"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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_GETSIGINFO> (since Linux 2.3.99-pre6)"
msgstr "B<PTRACE_GETSIGINFO> (seit Linux 2.3.99-pre6)"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_SETREGS>, B<PTRACE_SETFPREGS>"
msgstr "B<PTRACE_SETREGS>, B<PTRACE_SETFPREGS>"

#.  FIXME In the preceding sentence, which modifications are disallowed,
#.  and when they are disallowed, how does userspace discover that fact?
#. type: Plain text
msgid ""
"Copy the tracee's general-purpose or floating-point registers, respectively, "
"from the address I<data> in the tracer.  As for B<PTRACE_POKEUSER>, some "
"general-purpose register modifications may be disallowed.  (I<addr> is "
"ignored.)  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>."
msgstr ""
"kopiert 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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_SETSIGINFO> (since Linux 2.3.99-pre6)"
msgstr "B<PTRACE_SETSIGINFO> (seit Linux 2.3.99-pre6)"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_SETOPTIONS> (since Linux 2.4.6; see BUGS for caveats)"
msgstr ""
"B<PTRACE_SETOPTIONS> (seit Linux 2.4.6; siehe FEHLER für Vorsichtsma�nahmen)"

#. type: Plain text
msgid ""
"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:"
msgstr ""
"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:"

#. type: TP
#, no-wrap
msgid "B<PTRACE_O_TRACESYSGOOD> (since Linux 2.4.6)"
msgstr "B<PTRACE_O_TRACESYSGOOD> (seit Linux 2.4.6)"

#. type: Plain text
msgid ""
"When delivering system call traps, set bit 7 in the signal number (i.e., "
"deliver I<SIGTRAP|0x80>).  This makes it easy for the tracer to distinguish "
"normal traps from those caused by a system call.  (B<PTRACE_O_TRACESYSGOOD> "
"may not work on all architectures.)"
msgstr ""
"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. (B<PTRACE_O_TRACESYSGOOD> "
"funktioniert möglicherweise nicht auf allen Architekturen.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_O_TRACEFORK> (since Linux 2.5.46)"
msgstr "B<PTRACE_O_TRACEFORK> (seit Linux 2.5.46)"

#. type: Plain text
msgid ""
"Stop the tracee at the next B<fork>(2)  and automatically start tracing the "
"newly forked process, which will start with a B<SIGSTOP>.  A B<waitpid>(2)  "
"by the tracer will return a I<status> value such that"
msgstr ""
"stoppt den verfolgten Prozess beim nächsten Aufruf von B<fork>(2) und startet "
"die Verfolgung des neuen Prozesszweiges, der mit einem B<SIGSTOP> starten "
"wird. Ein B<waitpid>(2) durch den Verfolger wird einen I<Status>wert wie "
"diesen zurückgeben:"

#. type: Plain text
#, no-wrap
msgid "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_FORKE<lt>E<lt>8))\n"
msgstr "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_FORKE<lt>E<lt>8))\n"

#. type: Plain text
msgid "The PID of the new process can be retrieved with B<PTRACE_GETEVENTMSG>."
msgstr ""
"Die PID des neuen Prozesses kann mit B<PTRACE_GETEVENTMSG> abgefragt werden."

#. type: TP
#, no-wrap
msgid "B<PTRACE_O_TRACEVFORK> (since Linux 2.5.46)"
msgstr "B<PTRACE_O_TRACEVFORK> (seit Linux 2.5.46)"

#. type: Plain text
msgid ""
"Stop the tracee at the next B<vfork>(2)  and automatically start tracing the "
"newly vforked process, which will start with a B<SIGSTOP>.  A B<waitpid>(2)  "
"by the tracer will return a I<status> value such that"
msgstr ""
"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> starten wird. Ein B<waitpid>(2) durch den Verfolger wird "
"einen I<Status>wert wie diesen zurückgeben:"

#. type: Plain text
#, no-wrap
msgid "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_VFORKE<lt>E<lt>8))\n"
msgstr "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_VFORKE<lt>E<lt>8))\n"

#. type: TP
#, no-wrap
msgid "B<PTRACE_O_TRACECLONE> (since Linux 2.5.46)"
msgstr "B<PTRACE_O_TRACECLONE> (seit Linux 2.5.46)"

#. type: Plain text
msgid ""
"Stop the tracee at the next B<clone>(2)  and automatically start tracing the "
"newly cloned process, which will start with a B<SIGSTOP>.  A B<waitpid>(2)  "
"by the tracer will return a I<status> value such that"
msgstr ""
"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> starten wird. Ein B<waitpid>(2) durch den Verfolger wird einen "
"I<Status>wert wie diesen zurückgeben:"

#. type: Plain text
#, no-wrap
msgid "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_CLONEE<lt>E<lt>8))\n"
msgstr "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_CLONEE<lt>E<lt>8))\n"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_O_TRACEEXEC> (since Linux 2.5.46)"
msgstr "B<PTRACE_O_TRACEEXEC> (seit Linux 2.5.46)"

#. type: Plain text
msgid ""
"Stop the tracee at the next B<execve>(2).  A B<waitpid>(2)  by the tracer "
"will return a I<status> value such that"
msgstr ""
"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:"

#. type: Plain text
#, no-wrap
msgid "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_EXECE<lt>E<lt>8))\n"
msgstr "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_EXECE<lt>E<lt>8))\n"

#. type: Plain text
msgid ""
"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>."
msgstr ""
"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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_O_TRACEVFORKDONE> (since Linux 2.5.60)"
msgstr "B<PTRACE_O_TRACEVFORKDONE> (seit Linux 2.5.60)"

#. type: Plain text
msgid ""
"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"
msgstr ""
"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:"

#. type: Plain text
#, no-wrap
msgid "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_VFORK_DONEE<lt>E<lt>8))\n"
msgstr ""
"  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_VFORK_DONEE<lt>E<lt>8))\n"

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

#. type: TP
#, no-wrap
msgid "B<PTRACE_O_TRACEEXIT> (since Linux 2.5.60)"
msgstr "B<PTRACE_O_TRACEEXIT> (seit Linux 2.5.60)"

#. type: Plain text
msgid ""
"Stop the tracee at exit.  A B<waitpid>(2)  by the tracer will return a "
"I<status> value such that"
msgstr ""
"stoppt den verfolgten Prozess beim Beenden. Ein B<waitpid>(2) durch den "
"Verfolger wird einen I<Status>wert wie diesen zurückgeben:"

#. type: Plain text
#, no-wrap
msgid "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_EXITE<lt>E<lt>8))\n"
msgstr "  statusE<gt>E<gt>8 == (SIGTRAP | (PTRACE_EVENT_EXITE<lt>E<lt>8))\n"

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

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_GETEVENTMSG> (since Linux 2.5.46)"
msgstr "B<PTRACE_GETEVENTMSG> (seit Linux 2.5.46)"

#. type: Plain text
msgid ""
"Retrieve a message (as an I<unsigned long>)  about the ptrace event that "
"just happened, placing it at the address I<data> in the tracer.  For "
"B<PTRACE_EVENT_EXIT>, this is the tracee's exit status.  For "
"B<PTRACE_EVENT_FORK>, B<PTRACE_EVENT_VFORK>, B<PTRACE_EVENT_VFORK_DONE>, and "
"B<PTRACE_EVENT_CLONE>, this is the PID of the new process.  (I<addr> is "
"ignored.)"
msgstr ""
"eine Nachricht (als I<unsigned long>) über das Ptrace-Ereignis abfragen, das "
"einfach so auftrat und es an die Adresse I<Daten> im Verfolger platzieren. "
"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. (I<Adresse> wird ignoriert.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_CONT>"
msgstr "B<PTRACE_CONT>"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_SYSCALL>, B<PTRACE_SINGLESTEP>"
msgstr "B<PTRACE_SYSCALL>, B<PTRACE_SINGLESTEP>"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_SYSEMU>, B<PTRACE_SYSEMU_SINGLESTEP> (since Linux 2.6.14)"
msgstr "B<PTRACE_SYSEMU>, B<PTRACE_SYSEMU_SINGLESTEP> (seit Linux 2.6.14)"

#. type: Plain text
msgid ""
"For B<PTRACE_SYSEMU>, continue and stop on entry to the next system call, "
"which will not be executed.  For B<PTRACE_SYSEMU_SINGLESTEP>, do the same "
"but also singlestep if not a system call.  This call is used by programs "
"like User Mode Linux that want to emulate all the tracee's system calls.  "
"The I<data> argument is treated as for B<PTRACE_CONT>.  (I<addr> is ignored; "
"not supported on all architectures.)"
msgstr ""
"für B<PTRACE_SYSEMU> beim nächsten Eintritt für den Systemaufruf, der nicht "
"ausgeführt wird, fortfahren und stoppen; 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. "
"(I<Adresse> wird ignoriert; nicht auf allen Architekturen unterstützt)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_KILL>"
msgstr "B<PTRACE_KILL>"

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

#.  [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
msgid ""
"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."
msgstr ""
"I<Diese Transaktion 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 eine 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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_ATTACH>"
msgstr "B<PTRACE_ATTACH>"

#.  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 the tracee
#.  process for most purposes (e.g., it will receive
#.  notification of tracee events and appears in
#.  .BR ps (1)
#.  output as the tracee's parent), but a
#.  .BR getppid (2)
#.  by the tracee will still return the PID of the original parent.
#. type: Plain text
msgid ""
"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.)"
msgstr ""
"hängt an den Prozess, der durch I<PID> angegeben wird, an, 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.)"

#. type: TP
#, no-wrap
msgid "B<PTRACE_DETACH>"
msgstr "B<PTRACE_DETACH>"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: SS
#, no-wrap
msgid "Death under ptrace"
msgstr "Tod unter Ptrace"

#. type: Plain text
msgid ""
"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)."
msgstr ""
"Wenn ein Prozess (der möglicherweise aus mehreren Threads besteht) ein "
"killendes Signal erhält (eines, dessen Einstellung auf B<SIG_DFL> gesetzt ist "
"und dessen Standardaktion das Killen 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."

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: Plain text
msgid ""
"B<SIGKILL> operates similarly, with exceptions.  No signal-delivery-stop is "
"generated for B<SIGKILL> and therefore the tracer can't suppress it.  "
"B<SIGKILL> kills even within system calls (syscall-exit-stop is not "
"generated prior to death by B<SIGKILL>).  The net effect is that B<SIGKILL> "
"always kills the process (all its threads), even if some threads of the "
"process are ptraced."
msgstr ""
"B<SIGKILL> funktioniert mit Ausnahmen ähnlich. Für B<SIGKILL> wird kein "
"»Signallieferstopp« erzeugt und 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."

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

#. type: Plain text
msgid ""
"When any thread executes B<exit_group>(2), every tracee in its thread group "
"reports its death to its tracer."
msgstr ""
"Wenn irgendein Thread B<exit_group>(2) ausführt, meldet jeder verfolgte "
"Prozess in dessen Gruppe seinen Tod an den Verfolger."

#. type: Plain text
msgid ""
"If the B<PTRACE_O_TRACEEXIT> option is on, B<PTRACE_EVENT_EXIT> will happen "
"before actual death.  This applies to exits via B<exit>(2), B<exit_group>"
"(2), and signal deaths (except B<SIGKILL>), and when threads are torn down "
"on B<execve>(2)  in a multithreaded process."
msgstr ""
"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>) zu "
"beenden und wenn Threads bei B<execve>(2) in einem Prozess mit mehreren "
"Threads zerrissen werden."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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-Transaktionen 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-Transaktion 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."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: SS
#, no-wrap
msgid "Stopped states"
msgstr "Gestoppt-Status"

#. type: Plain text
msgid "A tracee can be in two states: running or stopped."
msgstr "Ein verfolgter Prozess kann zwei Status haben: laufend oder gestoppt."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"In this manual page, any stopped state in which the tracee is ready to "
"accept ptrace commands from the tracer is called I<ptrace-stop>.  Ptrace-"
"stops can be further subdivided into I<signal-delivery-stop>, I<group-stop>, "
"I<syscall-stop>, and so on.  These stopped states are described in detail "
"below."
msgstr ""
"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> und so fort unterteilt werden. Diese gestoppten Status werden "
"nachfolgend im Detail beschrieben."

#. type: Plain text
msgid ""
"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:"
msgstr ""
"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:"

#. type: Plain text
#, no-wrap
msgid "    pid = waitpid(pid_or_minus_1, &status, __WALL);\n"
msgstr "    PID = waitpid(pid_or_minus_1, &status, __WALL);\n"

#.  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
msgid ""
"Ptrace-stopped tracees are reported as returns with I<pid> greater than 0 "
"and I<WIFSTOPPED(status)> true."
msgstr ""
"Mit Ptrace-Stopp angehaltene, verfolgte Prozesse werden als Rückgaben mit "
"I<PID> grö�er als 0 und »I<WIFSTOPPED(status)> true« gemeldet."

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

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"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:"
msgstr ""
"Die Benutzung des Schalters B<WNOHANG> könnte B<waitpid>(2) veranlassen, 0 "
"zurückzugeben (»nocht keine Warteergebnisse verfügbar«), sogar dann, wenn der "
"Verfolger weiÃ?, dass dort eine Benachrichtigung sein soll. Beispiel:"

#. type: Plain text
#, no-wrap
msgid ""
"    kill(tracee, SIGKILL);\n"
"    waitpid(tracee, &status, __WALL | WNOHANG);\n"
msgstr ""
"    kill(tracee, SIGKILL);\n"
"    waitpid(tracee, &status, __WALL | WNOHANG);\n"

#. type: Plain text
msgid ""
"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<(status\\E<gt>E<gt>8)\\ &\\ 0xff>.)"
msgstr ""
"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<(status\\E<gt>E<gt>8)\\ "
"&\\ 0xff> zurückgibt.)"

#. type: SS
#, no-wrap
msgid "Signal-delivery-stop"
msgstr "Signallieferstopp"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: SS
#, no-wrap
msgid "Signal injection and suppression"
msgstr "Signaleinspeisung und -unterdrückung"

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

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_restart, pid, 0, sig)\n"
msgstr "    ptrace(PTRACE_restart, PID, 0, Signal)\n"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 Transaktion wird in dieser "
"Handbuchseite I<Signaleinspeisung> genannt, um sie vom Signallieferstopp zu "
"unterscheiden."

#. type: Plain text
msgid ""
"The I<sig> value may be different from the I<WSTOPSIG(status)> value: the "
"tracer can cause a different signal to be injected."
msgstr ""
"Der I<Signal>wert kann sich vom Wert I<WSTOPSIG(status)> unterschieden: Der "
"Verfolger kann veranlassen, dass ein anderes Signal eingespeist wird."

#. type: Plain text
msgid ""
"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 syscalls 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 syscalls to fail with B<EINTR> even though no observable signal is "
"injected to the tracee."
msgstr ""
"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 Sygnal in den verfolgten Prozess eingespeist wurde."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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)."

#. type: Plain text
msgid ""
"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"
msgstr ""
"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"

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_rest, pid, 0, stopsig)\n"
msgstr "    ptrace(PTRACE_rest, PID, 0, Stoppsignal)\n"

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

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"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."
msgstr ""
"Stoppen von Signalen führt dazu, das ein Prozess (alle Treads davon) in einen "
"Gruppenstopp eintreten. Dieser Seiteneffekt tritt nach der Signaleinspeisung "
"auf und kann daher durch den Verfolger unterdrückt werden."

#
#.  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
msgid "In Linux 2.4 and earlier, the B<SIGSTOP> signal can't be injected."
msgstr ""
"In Linux 2.4 und älter kann das Signal B<SIGSTOP> nicht eingespeist werden."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: SS
#, no-wrap
msgid "Group-stop"
msgstr "Gruppenstopp"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"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"
msgstr ""
"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:"

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_GETSIGINFO, pid, 0, &siginfo)\n"
msgstr "    ptrace(PTRACE_GETSIGINFO, PID, 0, &siginfo)\n"

#. type: Plain text
msgid ""
"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.)"
msgstr ""
"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."

#. type: Plain text
msgid ""
"As of kernel 2.6.38, after the tracer sees the tracee ptrace-stop and until "
"it restarts or kills it, the tracee will not run, and will not send "
"notifications (except B<SIGKILL> death) to the tracer, even if the tracer "
"enters into another B<waitpid>(2)  call."
msgstr ""
"Ab Kernel 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."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 \\(emder 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."

#. type: SS
#, no-wrap
msgid "PTRACE_EVENT stops"
msgstr "PTRACE_EVENT-Stopps"

#. type: Plain text
msgid ""
"If the tracer sets B<PTRACE_O_TRACE_*> options, the tracee will enter ptrace-"
"stops called B<PTRACE_EVENT> stops."
msgstr ""
"Falls der Verfolger B<PTRACE_O_TRACE_*>-Optionen setzt, wird der verfolgte "
"Prozess in B<PTRACE_EVENT>-Stopps genannte Stopps gelangen."

#. type: Plain text
msgid ""
"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"
msgstr ""
"B<PTRACE_EVENT>-Stopps werden durch den Verfolger als 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:"

#. type: Plain text
#, no-wrap
msgid "    (SIGTRAP | PTRACE_EVENT_foo E<lt>E<lt> 8).\n"
msgstr "    (SIGTRAP | PTRACE_EVENT_foo E<lt>E<lt> 8).\n"

#. type: Plain text
msgid "The following events exist:"
msgstr "Es gibt die folgenden Ereignisse:"

#. type: TP
#, no-wrap
msgid "B<PTRACE_EVENT_VFORK>"
msgstr "B<PTRACE_EVENT_VFORK>"

#. type: Plain text
msgid ""
"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))."
msgstr ""
"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))."

#. type: TP
#, no-wrap
msgid "B<PTRACE_EVENT_FORK>"
msgstr "B<PTRACE_EVENT_FORK>"

#. type: Plain text
msgid ""
"Stop before return from B<fork>(2)  or B<clone>(2)  with the exit signal set "
"to B<SIGCHLD>."
msgstr ""
"stoppt vor dem Zurückkehren von B<fork>(2) oder B<clone>(2) mit dem auf "
"B<SIGCHLD> gesetzten Beendigungssignal."

#. type: TP
#, no-wrap
msgid "B<PTRACE_EVENT_CLONE>"
msgstr "B<PTRACE_EVENT_CLONE>"

#. type: Plain text
msgid "Stop before return from B<clone>(2)."
msgstr "stoppt vor dem Zurückkehren von B<clone>(2)."

#. type: TP
#, no-wrap
msgid "B<PTRACE_EVENT_VFORK_DONE>"
msgstr "B<PTRACE_EVENT_VFORK_DONE>"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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." 

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: TP
#, no-wrap
msgid "B<PTRACE_EVENT_EXEC>"
msgstr "B<PTRACE_EVENT_EXEC>"

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

#. type: TP
#, no-wrap
msgid "B<PTRACE_EVENT_EXIT>"
msgstr "B<PTRACE_EVENT_EXIT>"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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>."

#. type: Plain text
msgid ""
"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>."
msgstr ""
"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."

#. type: SS
#, no-wrap
msgid "Syscall-stops"
msgstr "Systemaufrufstopps"

#. type: Plain text
msgid ""
"If the tracee was restarted by B<PTRACE_SYSCALL>, the tracee enters syscall-"
"enter-stop just prior to entering any system call.  If the tracer restarts "
"the tracee with B<PTRACE_SYSCALL>, the tracee enters syscall-exit-stop when "
"the system call is finished, or if it is interrupted by a signal.  (That is, "
"signal-delivery-stop never happens between syscall-enter-stop and syscall-"
"exit-stop; it happens I<after> syscall-exit-stop.)"
msgstr ""
"Falls der verfolgte Prozess durch B<PTRACE_SYSCALL> neu gestartet wurde, "
"gerät der verfolgte Prozess in einen Systemaufrufeintrittsstopp kurz vor dem "
"Eintritt in irgendeinen Systemaufruf. 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 nach dem "
"Systemaufrufbeendigungsstopp statt.)"

#. type: Plain text
msgid ""
"Other possibilities are that the tracee may stop in a B<PTRACE_EVENT> stop, "
"exit (if it entered B<_exit>(2)  or B<exit_group>(2)), be killed by "
"B<SIGKILL>, or die silently (if it is a thread group leader, the B<execve>"
"(2)  happened in another thread, and that thread is not traced by the same "
"tracer; this situation is discussed later)."
msgstr ""
"Andere Möglichkeiten sind, dass der verfolgte Prozess in einem "
"B<PTRACE_EVENT>-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)."

#. type: Plain text
msgid ""
"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)>."
msgstr ""
"Systemaufrufeintrittsstopp und Systemaufrufbeendigungsstopp werden vom "
"Verfolger als 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."

#. type: Plain text
msgid ""
"Syscall-stops can be distinguished from signal-delivery-stop with B<SIGTRAP> "
"by querying B<PTRACE_GETSIGINFO> for the following cases:"
msgstr ""
"Systemaufrufstopps können von Signallieferstopps mit B<SIGTRAP> durch Abfrage "
"von B<PTRACE_GETSIGINFO> für die folgenden Fälle unterschieden werden:"

#. type: TP
#, no-wrap
msgid "I<si_code> E<lt>= 0"
msgstr "I<si_code> E<lt>= 0"

#. type: Plain text
msgid ""
"B<SIGTRAP> was delivered as a result of a userspace action, for example, a "
"system call (B<tgkill>(2), B<kill>(2), B<sigqueue>(3), etc.), expiration of "
"a POSIX timer, change of state on a POSIX message queue, or completion of an "
"asynchronous I/O request."
msgstr ""
"B<SIGTRAP> wurde mit einem Ergebnis einer Userspace-Aktion, zum Beispiel "
"einem Systemaufruf ((B<tgkill>(2), B<kill>(2), B<sigqueue>(3), etc.), Ablauf "
"eines POSIX-Zeitnehmers, Statusänderung einer POSIX-Nachrichtenwarteschlange "
"oder Vervollständigung einer asynchronen E/A-Anfrage geliefert."

#. type: TP
#, no-wrap
msgid "I<si_code> == SI_KERNEL (0x80)"
msgstr "I<si_code> == SI_KERNEL (0x80)"

#. type: Plain text
msgid "B<SIGTRAP> was sent by the kernel."
msgstr "B<SIGTRAP> wurde vom Kernel gesandt."

#. type: TP
#, no-wrap
msgid "I<si_code> == SIGTRAP or I<si_code> == (SIGTRAP|0x80)"
msgstr "I<si_code> == SIGTRAP or I<si_code> == (SIGTRAP|0x80)"

#. type: Plain text
msgid "This is a syscall-stop."
msgstr "Dies ist ein Systemaufrufstopp."

#. type: Plain text
msgid ""
"However, syscall-stops happen very often (twice per system call), and "
"performing B<PTRACE_GETSIGINFO> for every syscall-stop may be somewhat "
"expensive."
msgstr ""
"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."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 entdeckt werden. Aber eine solche Entdeckung ist fragil "
"und wird am besten vermieden."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"Syscall-enter-stop and syscall-exit-stop are indistinguishable from each "
"other by the tracer.  The tracer needs to keep track of the sequence of "
"ptrace-stops in order to not misinterpret syscall-enter-stop as syscall-exit-"
"stop or vice versa.  The rule is that syscall-enter-stop is always followed "
"by syscall-exit-stop, B<PTRACE_EVENT> stop or the tracee's death; no other "
"kinds of ptrace-stop can occur in between."
msgstr ""
"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. Die Regel besagt, dass diesem "
"Systemaufrufeintrittsstopp immer ein Systemaufrufbeendigungsstopp, "
"B<PTRACE_EVENT>-Stopp oder der Tod des verfolgten Prozesses folgt; dazwischen "
"können keine anderen Arten von Ptrace-Stopps auftreten."

#. type: Plain text
msgid ""
"If after syscall-enter-stop, the tracer uses a restarting command other than "
"B<PTRACE_SYSCALL>, syscall-exit-stop is not generated."
msgstr ""
"Falls der Verfolger nach dem Systemaufrufeintrittsstopp einen anderen Befehl "
"zum Neustarten als B<PTRACE_SYSCALL> verwendet, wird der "
"Systemaufrufbeendigungsstopp nicht erzeugt."

#. type: Plain text
msgid ""
"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)>."
msgstr ""
"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."

#. type: SS
#, no-wrap
msgid "PTRACE_SINGLESTEP, PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP stops"
msgstr "PTRACE_SINGLESTEP-, PTRACE_SYSEMU-, PTRACE_SYSEMU_SINGLESTEP-Stopps"

#
#.  FIXME
#.  document stops occurring with PTRACE_SINGLESTEP, PTRACE_SYSEMU,
#.  PTRACE_SYSEMU_SINGLESTEP
#. type: Plain text
msgid "[Details of these kinds of stops are yet to be documented.]"
msgstr "[Einzelheiten dieser Arten von Stopps sind noch nicht dokumentiert.]"

#. type: SS
#, no-wrap
msgid "Informational and restarting ptrace commands"
msgstr "Benachrichtigende und neustartende Ptrace-Befehle"

#. type: Plain text
msgid ""
"Most ptrace commands (all except B<PTRACE_ATTACH>, B<PTRACE_TRACEME>, and "
"B<PTRACE_KILL>)  require the tracee to be in a ptrace-stop, otherwise they "
"fail with B<ESRCH>."
msgstr ""
"Die meisten Ptrace-Befehle (alle auÃ?er B<PTRACE_ATTACH>, B<PTRACE_TRACEME> "
"und B<PTRACE_KILL>) erfordern, dass der verfolgte Prozess in einem "
"Ptrace-Stopp ist, andernfalls scheitern sie mit B<ESRCH>."

#. type: Plain text
msgid ""
"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:"
msgstr ""
"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:"

#. type: Plain text
#, no-wrap
msgid ""
"    ptrace(PTRACE_PEEKTEXT/PEEKDATA/PEEKUSER, pid, addr, 0);\n"
"    ptrace(PTRACE_POKETEXT/POKEDATA/POKEUSER, pid, addr, long_val);\n"
"    ptrace(PTRACE_GETREGS/GETFPREGS, pid, 0, &struct);\n"
"    ptrace(PTRACE_SETREGS/SETFPREGS, pid, 0, &struct);\n"
"    ptrace(PTRACE_GETSIGINFO, pid, 0, &siginfo);\n"
"    ptrace(PTRACE_SETSIGINFO, pid, 0, &siginfo);\n"
"    ptrace(PTRACE_GETEVENTMSG, pid, 0, &long_var);\n"
"    ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_flags);\n"
msgstr ""
"    ptrace(PTRACE_PEEKTEXT/PEEKDATA/PEEKUSER, PID, Adresse, 0);\n"
"    ptrace(PTRACE_POKETEXT/POKEDATA/POKEUSER, PID, Adresse, long_val);\n"
"    ptrace(PTRACE_GETREGS/GETFPREGS, PID, 0, &struct);\n"
"    ptrace(PTRACE_SETREGS/SETFPREGS, PID, 0, &struct);\n"
"    ptrace(PTRACE_GETSIGINFO, PID, 0, &siginfo);\n"
"    ptrace(PTRACE_SETSIGINFO, PID, 0, &siginfo);\n"
"    ptrace(PTRACE_GETEVENTMSG, PID, 0, &long_var);\n"
"    ptrace(PTRACE_SETOPTIONS, PID, 0, PTRACE_O_flags);\n"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 zuückzugeben."

#. type: Plain text
msgid "The call"
msgstr "Der Aufruf"

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_flags);\n"
msgstr "    ptrace(PTRACE_SETOPTIONS, PID, 0, PTRACE_O_flags);\n"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

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

#. type: Plain text
#, no-wrap
msgid "    ptrace(cmd, pid, 0, sig);\n"
msgstr "    ptrace(Befehl, PID, 0, Signal);\n"

#. type: Plain text
msgid ""
"where I<cmd> is B<PTRACE_CONT>, B<PTRACE_DETACH>, B<PTRACE_SYSCALL>, "
"B<PTRACE_SINGLESTEP>, B<PTRACE_SYSEMU>, or B<PTRACE_SYSEMU_SINGLESTEP>.  If "
"the tracee is in signal-delivery-stop, I<sig> is the signal to be injected "
"(if it is nonzero).  Otherwise, I<sig> may be ignored.  (When restarting a "
"tracee from a ptrace-stop other than signal-delivery-stop, recommended "
"practice is to always pass 0 in I<sig>.)"
msgstr ""
"wobei I<Befehl> B<PTRACE_CONT>, 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.)"

#. type: SS
#, no-wrap
msgid "Attaching and detaching"
msgstr "Anhängen und Loslösen"

#. type: Plain text
msgid "A thread can be attached to the tracer using the call"
msgstr "Ein Thread kann an den Verfolger angehängt werden mit dem Aufruf"

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_ATTACH, pid, 0, 0);\n"
msgstr "    ptrace(PTRACE_ATTACH, PID, 0, 0);\n"

#
#.  FIXME: Describe how to attach to a thread which is already
#.         group-stopped.
#. type: Plain text
msgid ""
"This also sends B<SIGSTOP> to this thread.  If the tracer wants this "
"B<SIGSTOP> to have no effect, it needs to suppress it.  Note that if other "
"signals are concurrently sent to this thread during attach, the tracer may "
"see the tracee enter signal-delivery-stop with other signal(s) first! The "
"usual practice is to reinject these signals until B<SIGSTOP> is seen, then "
"suppress B<SIGSTOP> injection.  The design bug here is that a ptrace attach "
"and a concurrently delivered B<SIGSTOP> may race and the concurrent "
"B<SIGSTOP> may be lost."
msgstr ""
"Dies 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."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid "The request"
msgstr "Die Anfrage"

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_TRACEME, 0, 0, 0);\n"
msgstr "    ptrace(PTRACE_TRACEME, 0, 0, 0);\n"

#. type: Plain text
msgid ""
"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"
msgstr ""
"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"

#. type: Plain text
#, no-wrap
msgid "    raise(SIGSTOP);\n"
msgstr "    raise(SIGSTOP);\n"

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

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid "Detaching of the tracee is performed by:"
msgstr "Loslösen des verfolgten Prozesses wird erreicht durch:"

#. type: Plain text
#, no-wrap
msgid "    ptrace(PTRACE_DETACH, pid, 0, sig);\n"
msgstr "    ptrace(PTRACE_DETACH, PID, 0, Signal);\n"

#. type: Plain text
msgid ""
"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."
msgstr ""
"B<PTRACE_DETACH> ist eine Neustartoperation; 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."

#.  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
msgid ""
"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>."
msgstr ""
"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 ist, dass sich dies mit gleichzeitigen B<SIGSTOP>s Rennen "
"liefern kann. Eine weitere Komplikation besteht darin, dass der verfolgte "
"Prozess in andere Ptrace-Stopps geraten kann und neu gestartet werden muss "
"und nochmals wartet, bis B<SIGSTOP> gesehen wird. Noch eine weitere "
"Komplikation ist, dass nicht sicher ist, ob der verfolgte Prozess nicht "
"bereits mit Ptrace gestoppt wurde, da keine Signallieferung stattfindet, "
"obwohl es \\(emnicht gerade B<SIGSTOP> ist."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: SS
#, no-wrap
msgid "execve(2) under ptrace"
msgstr "execve(2) unter Ptrace"

#
#.  clone(2) THREAD_CLONE says:
#.      If  any  of the threads in a thread group performs an execve(2),
#.      then all threads other than the thread group leader are terminated,
#.      and the new program is executed in the thread group leader.
#.  In kernel 3.1 sources, see fs/exec.c::de_thread()
#. type: Plain text
msgid ""
"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:"
msgstr ""
"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:"

#. type: IP
#, no-wrap
msgid "*"
msgstr "*"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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-Kode 0 beendet worden wären."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

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

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

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

#. type: Plain text
msgid ""
"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)."
msgstr ""
"Die Option B<PTRACE_O_TRACEEXEC> ist das emfpohlene 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)."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"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"
msgstr ""
"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, \\(emeine, die "
"den einzelnen, laufenden, verfolgten Prozess beschreibt mit" 

#. type: Plain text
#, no-wrap
msgid "    thread ID == thread group ID == process ID.\n"
msgstr "    Thread-Kennung == Thread-Gruppenkennung == Prozesskennung.\n"

#. type: Plain text
msgid "Example: two threads call B<execve>(2)  at the same time:"
msgstr "Beispiel: Zwei Thread rufen zur gleichen Zeit B<execve>(2) auf:"

#. type: Plain text
#, no-wrap
msgid ""
"*** we get syscall-enter-stop in thread 1: **\n"
"PID1 execve(\"/bin/foo\", \"foo\" E<lt>unfinished ...E<gt>\n"
"*** we issue PTRACE_SYSCALL for thread 1 **\n"
"*** we get syscall-enter-stop in thread 2: **\n"
"PID2 execve(\"/bin/bar\", \"bar\" E<lt>unfinished ...E<gt>\n"
"*** we issue PTRACE_SYSCALL for thread 2 **\n"
"*** we get PTRACE_EVENT_EXEC for PID0, we issue PTRACE_SYSCALL **\n"
"*** we get syscall-exit-stop for PID0: **\n"
"PID0 E<lt>... execve resumedE<gt> )             = 0\n"
msgstr ""
"*** wir bekommen einen Systemaufrufeintrittsstopp in Thread 1: **\n"
"PID1 execve(\"/bin/foo\", \"foo\" E<lt>nicht abgeschlossen â?¦E<gt>\n"
"*** wir liefern PTRACE_SYSCALL für Thread 1 **\n"
"*** wir bekommen einen Systemaufrufeintrittsstopp in Thread 2: **\n"
"PID2 execve(\"/bin/bar\", \"bar\" E<lt>nicht abgeschlossen â?¦E<gt>\n"
"*** wir liefern PTRACE_SYSCALL für Thread 2 **\n"
"*** wir bekommen PTRACE_EVENT_EXEC für PID0, wir liefern  PTRACE_SYSCALL **\n"
"*** wir bekommen Systemaufrufbeendigungsstopp für PID0: **\n"
"PID0 E<lt>â?¦ execve wieder aufgenommenE<gt> )             = 0\n"

#. type: Plain text
msgid ""
"If the B<PTRACE_O_TRACEEXEC> option is I<not> in effect for the execing "
"tracee, the kernel delivers an extra B<SIGTRAP> to the tracee after B<execve>"
"(2)  returns.  This is an ordinary signal (similar to one which can be "
"generated by I<kill -TRAP>), not a special kind of ptrace-stop.  Employing "
"B<PTRACE_GETSIGINFO> for this signal returns I<si_code> set to 0 "
"(I<SI_USER>).  This signal may be blocked by signal mask, and thus may be "
"delivered (much) later."
msgstr ""
"Falls die Option B<PTRACE_O_TRACEEXEC> für den ausführenden, verfolgten "
"Prozess I<nicht> in Kraft ist, 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."

#. type: Plain text
msgid ""
"Usually, the tracer (for example, B<strace>(1))  would not want to show this "
"extra post-execve B<SIGTRAP> signal to the user, and would suppress its "
"delivery to the tracee (if B<SIGTRAP> is set to B<SIG_DFL>, it is a killing "
"signal).  However, determining I<which> B<SIGTRAP> to suppress is not easy.  "
"Setting the B<PTRACE_O_TRACEEXEC> option and thus suppressing this extra "
"B<SIGTRAP> is the recommended approach."
msgstr ""
"�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 und daher dieses zusätzliche "
"B<SIGTRAP> zu unterdrücken."

#. type: SS
#, no-wrap
msgid "Real parent"
msgstr "Echter Elternprozess"

#. type: Plain text
msgid ""
"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."
msgstr ""
"Die Ptrace-API (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."

#. type: Plain text
msgid ""
"Many of these bugs have been fixed, but as of Linux 2.6.38 several still "
"exist; see BUGS below."
msgstr ""
"Viele dieser Fehler wurden behoben, aber ab Linux 2.6.38 existieren etliche "
"immer noch; siehe FEHLER oberhalb."

#. type: Plain text
msgid "As of Linux 2.6.38, the following is believed to work correctly:"
msgstr ""
"Ab Linux 2.6.38 wird davon ausgegangen, dass das folgende korrekt "
"funktioniert:"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: SH
#, no-wrap
msgid "RETURN VALUE"
msgstr "RÃ?CKGABEWERT"

#. type: Plain text
msgid ""
"On success, B<PTRACE_PEEK*> requests return the requested data, while other "
"requests return zero.  On error, all requests return -1, and I<errno> is set "
"appropriately.  Since the value returned by a successful B<PTRACE_PEEK*> "
"request may be -1, the caller must clear I<errno> before the call, and then "
"check it afterward to determine whether or not an error occurred."
msgstr ""
"Bei Erfolg geben B<PTRACE_PEEK*>-Anfragen die angefragten Daten zurück, "
"während andere Anfragen Null zurückgeben. 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."

#. type: SH
#, no-wrap
msgid "ERRORS"
msgstr "FEHLER"

#. type: TP
#, no-wrap
msgid "B<EBUSY>"
msgstr "B<EBUSY>"

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

#. type: TP
#, no-wrap
msgid "B<EFAULT>"
msgstr "B<EFAULT>"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 Störung mehr "
"oder weniger willkürlich B<EIO> oder B<EFAULT> zurück."

#. type: TP
#, no-wrap
msgid "B<EINVAL>"
msgstr "B<EINVAL>"

#. type: Plain text
msgid "An attempt was made to set an invalid option."
msgstr "Es wurde versucht, eine ungültige Option zu setzen."

#. type: TP
#, no-wrap
msgid "B<EIO>"
msgstr "B<EIO>"

#. type: Plain text
msgid ""
"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."
msgstr ""
"I<Abfrage> 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."

#. type: TP
#, no-wrap
msgid "B<EPERM>"
msgstr "B<EPERM>"

#. type: Plain text
msgid ""
"The specified process cannot be traced.  This could be because the tracer "
"has insufficient privileges (the required capability is B<CAP_SYS_PTRACE>); "
"unprivileged processes cannot trace processes that they cannot send signals "
"to or those running set-user-ID/set-group-ID programs, for obvious reasons.  "
"Alternatively, the process may already be being traced, or (on kernels "
"before 2.6.26) be B<init>(8)  (PID 1)."
msgstr ""
"Der angegebene Prozess kann nicht verfolgt werden. Dies könnte daher rühren, "
"dass der Verfolger über unzureichende Privilegien verfügt (die Fähigkeit "
"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>(8) (PID 1) sein."

#. type: TP
#, no-wrap
msgid "B<ESRCH>"
msgstr "B<ESRCH>"

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

#. type: SH
#, no-wrap
msgid "CONFORMING TO"
msgstr "KONFORM ZU"

#. type: Plain text
msgid "SVr4, 4.3BSD."
msgstr "SVr4, 4.3BSD."

#. type: SH
#, no-wrap
msgid "NOTES"
msgstr "ANMERKUNGEN"

#. type: Plain text
msgid ""
"Although arguments to B<ptrace>()  are interpreted according to the "
"prototype given, glibc currently declares B<ptrace>()  as a variadic "
"function with only the I<request> argument fixed.  This means that unneeded "
"trailing arguments may be omitted, though doing so makes use of undocumented "
"B<gcc>(1)  behavior."
msgstr ""
"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. Dies bedeutet, dass nicht "
"gewollte anhängende Argumente weggelassen werden könnten, obwohl dies "
"Gebrauch vom nicht dokumentierten B<gcc>(1)-Verhalten macht."

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

#.  See http://lkml.org/lkml/2008/5/8/375
#. type: Plain text
msgid ""
"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>."
msgstr ""
"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>."

#. type: Plain text
msgid ""
"The size of a \"word\" is determined by the operating-system variant (e.g., "
"for 32-bit Linux it is 32 bits, etc.)."
msgstr ""
"Die Grö�e eines »word« wird durch die Betriebsystemvariante festgelegt (z.B. "
"ist es für ein 32-Bit-Linux 32 Bit, etc.)."

#. type: Plain text
msgid ""
"This page documents the way the B<ptrace>()  call works currently in Linux.  "
"Its behavior differs noticeably on other flavors of UNIX.  In any case, use "
"of B<ptrace>()  is highly specific to the operating system and architecture."
msgstr ""
"Diese Seite dokumentiert die Möglichkeit, wie der B<ptrace>()-Aufruf derzeit "
"in Linux arbeitet. Sein Verhalten unterscheidet sich auf anderen UNIX-"
"Geschmacksrichtungen deutlich. Auf jeden Fall ist die Benutzung von B<ptrace>"
"() in hohem Grad abhängig vom Betriebssystem und der Architektur."

#. type: SH
#, no-wrap
msgid "BUGS"
msgstr "FEHLER"

#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"Group-stop notifications are sent to the tracer, but not to real parent.  "
"Last confirmed on 2.6.38.6."
msgstr ""
"Gruppenstoppbenachrichtigungen werden an der Verfolger gesandt, aber nicht an "
"den echten Elternprozess. Zuletzt auf 2.6.38.6 bestätigt."

#.  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, only _exit presents observably
#.      puzzling behavior to ptrace users: thread leader _exit's,
#.      but WIFEXITED isn't reported! We are trying to explain here
#.      why it is so.
#.   FIXME: ^^^ need to test/verify this scenario
#. type: Plain text
msgid ""
"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."
msgstr ""
"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."

#. type: Plain text
msgid ""
"A B<SIGKILL> signal may still cause a B<PTRACE_EVENT_EXIT> stop before "
"actual signal death.  This may be changed in the future; B<SIGKILL> is meant "
"to always immediately kill tasks even under ptrace.  Last confirmed on "
"2.6.38.6."
msgstr ""
"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 2.6.38.6 bestätigt."

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 Operation: Sie wird "
"normalerweise von Fehlersuchprogrammen bei jedem Anhängen durchgeführt, um "
"ein 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."

#. type: SH
#, no-wrap
msgid "SEE ALSO"
msgstr "SIEHE AUCH"

#. type: Plain text
msgid ""
"B<gdb>(1), B<strace>(1), B<clone>(2), B<execve>(2), B<fork>(2), B<gettid>"
"(2), B<sigaction>(2), B<tgkill>(2), B<vfork>(2), B<waitpid>(2), B<exec>(3), "
"B<capabilities>(7), B<signal>(7)"
msgstr ""
"B<gdb>(1), B<strace>(1), B<clone>(2), B<execve>(2), B<fork>(2), B<gettid>"
"(2), B<sigaction>(2), B<tgkill>(2), B<vfork>(2), B<waitpid>(2), B<exec>(3), "
"B<capabilities>(7), B<signal>(7)"

#. type: SH
#, no-wrap
msgid "COLOPHON"
msgstr "KOLOPHON"

#. type: Plain text
msgid ""
"This page is part of release 3.40 of the Linux I<man-pages> project.  A "
"description of the project, and information about reporting bugs, can be "
"found at http://www.kernel.org/doc/man-pages/.";
msgstr ""
"Diese Seite ist Teil der Veröffentlichung 3.40 des Projekts Linux-I<man-"
"pages>. Eine Beschreibung des Projekts und Informationen, wie Fehler "
"gemeldet werden können, finden sich unter http://www.kernel.org/doc/man-";
"pages/."