manpages-de 3.51 - en to de translation catalogue (207 entries)

note: type: TH
en: 2019-08-02
de: 2. August 2019

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

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: clone, __clone2 - create a child process
de: clone, __clone2 - erzeugt einen Kindprozess

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

note: type: Plain text
en: /* Prototype for the glibc wrapper function */
de: /* Prototyp für die Glibc-Wrapper-Funktion */

note: type: Plain text
en: B<int clone(int (*>I<fn>B<)(void *), void *>I<child_stack>B<,>
    B<          int >I<flags>B<, void *>I<arg>B<, ... >
    B<          /* pid_t *>I<ptid>B<, void *>I<newtls>B<, pid_t *>I<ctid>B< */ );>
de: B<int clone(int (*>I<fn>B<)(void *), void *>I<child_stack>B<,>
    B<          int >I<flags>B<, void *>I<arg>B<, … >
    B<          /* pid_t *>I<ptid>B<, void *>I<newtls>B<, pid_t *>I<ctid>B< */ );>

note: type: Plain text
en: /* For the prototype of the raw system call, see NOTES */
de: /* Für den Prototyp des den rohen Systemaufrufs siehe ANMERKUNGEN */

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Plain text
en: B<clone>()  creates a new process, in a manner similar to B<fork>(2).
de: B<clone>() erzeugt auf eine ähnliche Weise wie B<fork>(2) einen neuen Prozess.

note: type: Plain text
en: This page describes both the glibc B<clone>()  wrapper function and the underlying system call on which it is based.  The main text describes the wrapper function; the differences for the raw system call are described toward the end of this page.
de: Diese Seite beschreibt sowohl die B<clone>()-Wrapper-Funktion von Glibc als auch den darunterliegenden Systemaufruf, auf dem sie basiert. Der Haupttext erklärt die Wrapper-Funktion. Die Unterschiede zum rohen Systemaufruf werden gegen Ende dieser Seite erläutert.

note: type: Plain text
en: Unlike B<fork>(2), B<clone>()  allows the child process to share parts of its execution context with the calling process, such as the virtual address space, the table of file descriptors, and the table of signal handlers.  (Note that on this manual page, "calling process" normally corresponds to "parent process".  But see the description of B<CLONE_PARENT> below.)
de: Im Gegensatz zu B<fork>(2) erlaubt B<clone>(), dass der Kindprozess Teile seines Kontextes mit dem aufrufenden Prozess teilt. Dazu zählen der virtuelle Adressraum, die Tabelle der Dateideskriptoren und die Tabelle der Signal-Handler. (Beachten Sie, dass »aufrufender Prozess« auf dieser Handbuchseite »Elternprozess« entspricht. Aber lesen Sie im Folgenden die Beschreibung von B<CLONE_PARENT>.)

note: type: Plain text
en: One use of B<clone>()  is to implement threads: multiple flows of control in a program that run concurrently in a shared address space.
de: B<clone>() wird benutzt, um Threads zu implementieren: mehrere Steuerflüsse in einem Programm, die gleichzeitig in einem gemeinsamen Speicherbereich ausgeführt werden.

note: type: Plain text
en: When the child process is created with B<clone>(), it commences execution by calling the function pointed to by the argument I<fn>.  (This differs from B<fork>(2), where execution continues in the child from the point of the B<fork>(2)  call.)  The I<arg> argument is passed as the argument of the function I<fn>.
de: Wird mit B<clone>() ein Kindprozess erzeugt, beginnt es die Ausführung durch Aufruf der Funktion, auf die das Argument I<fn> zeigt. (Dies ist ein Unterschied zu B<fork>(2), wo die Ausführung im Kindprozess vom Punkt des B<fork>(2)-Aufrufs fortfährt.) Das Argument I<arg> wird als Argument der Funktion I<fn> übergeben.

note: type: Plain text
en: When the I<fn>(I<arg>)  function returns, the child process terminates.  The integer returned by I<fn> is the exit status for the child process.  The child process may also terminate explicitly by calling B<exit>(2)  or after receiving a fatal signal.
de: Kehrt die Funktion I<fn>(I<arg>) zurück, so beendet sich der Kindprozess. Der Ganzzahlwert, der von I<fn> zurückgeliefert wird, entspricht dem Exit-Status des Kindprozesses. Der Kindprozess kann auch durch den expliziten Aufruf von B<exit>(2) oder durch den Empfang eines fatalen Signals beendet werden.

note: type: Plain text
en: The I<child_stack> argument specifies the location of the stack used by the child process.  Since the child and calling process may share memory, it is not possible for the child process to execute in the same stack as the calling process.  The calling process must therefore set up memory space for the child stack and pass a pointer to this space to B<clone>().  Stacks grow downward on all processors that run Linux (except the HP PA processors), so I<child_stack> usually points to the topmost address of the memory space set up for the child stack.
de: Das Argument I<child_stack> bestimmt den Ort des Stapelspeichers, der vom Kindprozess verwendet wird. Da der aufrufende und der Kindprozess sich Speicherbereiche teilen können, kann der Kindprozess nicht auf dem selben Stapelspeicher wie der aufrufende Prozess laufen. Der aufrufende Prozess muss daher einen Speicherbereich als Stapelspeicher für den Kindprozess bereithalten und per B<clone> einen Zeiger darauf an den Kindprozess übergeben. Der Stapelspeicher wächst (mit Ausnahme der PA-Prozessoren von HP) auf allen von Linux unterstützten Prozessoren nach unten, so dass I<child_stack> für gewöhnlich auf die oberste Adresse im bereitgehaltenen Speicherbereich zeigt.

note: type: Plain text
en: The low byte of I<flags> contains the number of the I<termination signal> sent to the parent when the child dies.  If this signal is specified as anything other than B<SIGCHLD>, then the parent process must specify the B<__WALL> or B<__WCLONE> options when waiting for the child with B<wait>(2).  If no signal is specified, then the parent process is not signaled when the child terminates.
de: Das niederwertige Byte von I<flags> enthält die Nummer des I<Beendigungssignals>, das an den Elternprozess gesandt wird, wenn der Kindprozess endet. Falls dieses Signal als etwas anderes als B<SIGCHLD> angegeben wurde, dann muss der Elternprozess die Optionen B<__WALL> oder B<__WCLONE> angeben, wenn er mit B<wait>(2) auf den Kindprozess wartet. Falls kein Signal angegeben wurde, wird dem Elternprozess nicht signalisiert, wenn der Kindprozess endet.

note: type: Plain text
en: I<flags> may also be bitwise-ORed with zero or more of the following constants, in order to specify what is shared between the calling process and the child process:
de: I<flags> kann darüber hinaus noch durch bitweises »ODER« mit keiner oder mehreren der folgenden Konstanten verknüpft werden. Dadurch wird festgelegt, welche Ressourcen sich Eltern- und Kindprozess teilen:

note: type: TP
en: B<CLONE_CHILD_CLEARTID> (since Linux 2.5.49)
de: B<CLONE_CHILD_CLEARTID> (seit Linux 2.5.49)

note: type: Plain text
en: Clear (zero) the child thread ID at the location I<ctid> in child memory when the child exits, and do a wakeup on the futex at that address.  The address involved may be changed by the B<set_tid_address>(2)  system call.  This is used by threading libraries.
de: Die Kind-Thread-Kennung an der Stelle I<ctid> im Kindspeicher bereinigen (nullen), wenn das Kind existiert und beim Futex (»fast userspace mutual exclusion«/schneller gegenseitiger Ausschluss im Userspace) an dieser Adresse aufwachen lassen. Die betroffene Adresse könnte durch den Systemaufruf B<set_tid_address>(2) geändert werden. Dies wird von Threading-Bibliotheken benutzt.

note: type: TP
en: B<CLONE_CHILD_SETTID> (since Linux 2.5.49)
de: B<CLONE_CHILD_SETTID> (seit Linux 2.5.49)

note: type: Plain text
en: Store the child thread ID at the location I<ctid> in the child's memory.  The store operation completes before B<clone>()  returns control to user space in the child process.  (Note that the store operation may not have completed before B<clone>()  returns in the parent process, which will be relevant if the B<CLONE_VM> flag is also employed.)
de: Speichert die Kind-Thread-Kennung an der Stelle I<ctid> im Kindspeicher. Die Speicheraktion wird abgeschlossen, bevor B<clone>() die Steuerung an den Benutzerraum im Kindprozess zurückgibt. (Beachten Sie, dass die Speicheraktion noch nicht abgeschlossen sein könnte, bevor B<clone>() den Elternprozess zurückliefert, was relevant wird, wenn auch der Schalter B<CLONE_VM> eingesetzt wird.)

note: type: Plain text
en: If B<CLONE_FILES> is set, the calling process and the child process share the same file descriptor table.  Any file descriptor created by the calling process or by the child process is also valid in the other process.  Similarly, if one of the processes closes a file descriptor, or changes its associated flags (using the B<fcntl>(2)  B<F_SETFD> operation), the other process is also affected.  If a process sharing a file descriptor table calls B<execve>(2), its file descriptor table is duplicated (unshared).
de: Ist B<CLONE_FILES> gesetzt, teilen sich der aufrufende und der Kindprozess ihre Dateideskriptor-Tabellen. Jeder Dateideskriptor, der im aufrufenden Prozess oder vom Kindprozess erzeugt wird, ist auch im anderen Prozess gültig. Ebenso wirkt sich das Schließen eines Dateideskriptors oder das Ändern der zugehörigen Schalter (benutzen der B<F_SETFD>-Operation von B<fcntl>(2)) auf den anderen Prozess aus. Falls sich ein Prozess eine Dateideskriptor-Tabelle teilt und B<execve>(2) aufruft, wird seine Dateideskriptor-Tabelle dupliziert (nicht länger geteilt).

note: type: Plain text
en: If B<CLONE_FILES> is not set, the child process inherits a copy of all file descriptors opened in the calling process at the time of B<clone>().  Subsequent operations that open or close file descriptors, or change file descriptor flags, performed by either the calling process or the child process do not affect the other process.  Note, however, that the duplicated file descriptors in the child refer to the same open file descriptions as the corresponding file descriptors in the calling process, and thus share file offsets and file status flags (see B<open>(2)).
de: Ist B<CLONE_FILES> nicht gesetzt, erbt der Kindprozess zur Ausführungszeit von B<clone>() eine Kopie der aktuell geöffneten Dateideskriptoren. Anschließende Aktionen, die Dateideskriptoren öffnen oder schließen bzw. deren Schalter ändern, werden entweder vom aufrufenden Prozess oder dem Kindprozess durchgeführt und betreffen nicht den jeweils anderen Prozess. Beachten Sie aber, dass sich die duplizierten Dateideskriptoren im Kind auf die gleiche offene Dateideskription wie der korrespondierende Dateideskriptor im aufrufenden Prozess bezieht und sich daher den Dateiversatz und die Dateistatusschalter mit diesem teilt (siehe B<open>(2)).

note: type: TP
en: B<CLONE_FS> (since Linux 2.0)
de: B<CLONE_FS> (seit Linux 2.0)

note: type: Plain text
en: If B<CLONE_FS> is set, the caller and the child process share the same filesystem information.  This includes the root of the filesystem, the current working directory, and the umask.  Any call to B<chroot>(2), B<chdir>(2), or B<umask>(2)  performed by the calling process or the child process also affects the other process.
de: Ist B<CLONE_FS> gesetzt, teilen sich aufrufender Prozess und Kindprozess ihre Informationen über das Dateisystem. Dazu zählen der Ort des Wurzelverzeichnisses, das aktuelle Arbeitsverzeichnis und die Maske der Dateizugriffsrechte (umask). Jeder Aufruf von B<chroot>(2), B<chdir>(2) oder B<umask>(2), entweder durch den aufrufenden Prozess oder den Kindprozess, beeinflusst auch den jeweils anderen Prozess.

note: type: Plain text
en: If B<CLONE_FS> is not set, the child process works on a copy of the filesystem information of the calling process at the time of the B<clone>()  call.  Calls to B<chroot>(2), B<chdir>(2), or B<umask>(2)  performed later by one of the processes do not affect the other process.
de: Ist B<CLONE_FS> nicht gesetzt, arbeitet der Kindprozess von B<clone>() mit einer Kopie der Dateisysteminformationen des aufrufenden Prozesses zur Zeit des B<clone>()-Aufrufs. Spätere Aufrufe von B<chroot>(2), B<chdir>(2) oder B<umask>(2) beeinflussen den anderen Prozess nicht.

note: type: TP
en: B<CLONE_IO> (since Linux 2.6.25)
de: B<CLONE_IO> (seit Linux 2.6.25)

note: type: Plain text
en: If B<CLONE_IO> is set, then the new process shares an I/O context with the calling process.  If this flag is not set, then (as with B<fork>(2))  the new process has its own I/O context.
de: Ist B<CLONE_FS> gesetzt, teilt sich der neue Prozess einen E/A-Kontext mit dem aufrufenden Prozess. Falls dieser Schalter nicht gesetzt ist (wie bei B<fork>(2)), hat der neue Prozess seinen eigenen E/A-Kontext.

note: The following based on text from Jens Axboe the anticipatory and CFQ scheduler with CFQ and AS. type: Plain text
en: The I/O context is the I/O scope of the disk scheduler (i.e., what the I/O scheduler uses to model scheduling of a process's I/O).  If processes share the same I/O context, they are treated as one by the I/O scheduler.  As a consequence, they get to share disk time.  For some I/O schedulers, if two processes share an I/O context, they will be allowed to interleave their disk access.  If several threads are doing I/O on behalf of the same process (B<aio_read>(3), for instance), they should employ B<CLONE_IO> to get better I/O performance.
de: Der E/A-Kontext entspricht dem E/A-Gültigkeitsbereich des Platten-Steuerprogramms, d.h. welches das E/A-Steuerprogramm zur Modellplanung für E/As des Prozesses benutzt. Falls sich Prozesse den gleichen E/A-Kontext teilen, werden sie vom E/A-Steuerprogramm als ein einziger betrachtet. Als Konsequenz daraus müssen sie sich die gleiche Plattenzeitzugriffzeit teilen. Einige E/A-Steuerprogramme ermöglichen zwei Prozessen, die einen E/A-Kontext teilen, ihren Plattenzugriff zu verzahnen. Falls mehrere Prozesse E/A im Auftrag des gleichen Prozesses durchführen (B<aio_read>(3) zum Beispiel), sollten sie für eine bessere E/A-Leistung B<CLONE_IO> verwenden.

note: type: Plain text
en: If the kernel is not configured with the B<CONFIG_BLOCK> option, this flag is a no-op.
de: Falls der Kernel nicht mit der Option B<CONFIG_BLOCK> konfiguriert wurde, bewirkt dieser Schalter nichts.

note: type: TP
en: B<CLONE_NEWCGROUP> (since Linux 4.6)
de: B<CLONE_NEWCGROUP> (seit Linux 4.6)

note: type: Plain text
en: Create the process in a new cgroup namespace.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same cgroup namespaces as the calling process.  This flag is intended for the implementation of containers.
de: Erstellt den Prozess in einem neuen cgroup-Namensraum. Falls dieser Schalter nicht gesetzt ist, dann wird (wie mit B<fork>(2)) der Prozess in den gleichen cgroup-Namensräumen wie der aufrufende Prozess erstellt. Der Schalter ist für die Implementierung von Containern gedacht.

note: type: Plain text
en: For further information on cgroup namespaces, see B<cgroup_namespaces>(7).
de: Weitere Informationen über cgroup-Namensräume finden Sie unter B<cgroup_namespaces>(7).

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWCGROUP>.
de: Nur ein privilegierter Prozess (B<CAP_SYS_ADMIN>) kann B<CLONE_NEWCGROUP> angeben.

note: type: TP
en: B<CLONE_NEWIPC> (since Linux 2.6.19)
de: B<CLONE_NEWIPC> (seit Linux 2.6.19)

note: type: Plain text
en: If B<CLONE_NEWIPC> is set, then create the process in a new IPC namespace.  If this flag is not set, then (as with B<fork>(2)), the process is created in the same IPC namespace as the calling process.  This flag is intended for the implementation of containers.
de: Ist B<CLONE_NEWIPC> gesetzt, dann wird der Prozess in einem neuen IPC-Namensraum erstellt. Falls dieser Schalter nicht gesetzt ist, dann wird der Prozess (wie bei B<fork>(2)) im gleichen IPC-Namensraum wie der aufrufende Prozess erstellt. Dieser Schalter ist für die Implementierung von Containern gedacht.

note: commit 7eafd7c74c3f2e67c27621b987b28397110d643f https://lwn.net/Articles/312232/ type: Plain text
en: An IPC namespace provides an isolated view of System\ V IPC objects (see B<sysvipc>(7))  and (since Linux 2.6.30)  POSIX message queues (see B<mq_overview>(7)).  The common characteristic of these IPC mechanisms is that IPC objects are identified by mechanisms other than filesystem pathnames.
de: Ein IPC-Namensraum stellt eine isolierte Ansicht von System-V-IPC-Objekten (siehe B<sysvipc>(7)) und (seit 2.6.30) POSIX-Nachrichtenwarteschlangen (siehe B<mq_overview>(7)) bereit. Das gemeinsame Merkmal dieser IPC-Mechanismen ist, dass IPC-Objekte durch andere Mechanismen als Dateisystempfadnamen identifiziert werden.

note: type: Plain text
en: Objects created in an IPC namespace are visible to all other processes that are members of that namespace, but are not visible to processes in other IPC namespaces.
de: Objekte, die in einem IPC-Namensraum erstellt wurden, sind für alle anderen Prozesse sichtbar, die Mitglieder des Namensraums sind. Die Objekte sind jedoch nicht für Prozesse in anderen Namensräumen sichtbar.

note: type: Plain text
en: When an IPC namespace is destroyed (i.e., when the last process that is a member of the namespace terminates), all IPC objects in the namespace are automatically destroyed.
de: Wenn ein IPC-Namensraum zerstört wird, d.h. wenn der letzte Prozess im Namensraum beendet wird, werden alle IPC-Objekte im Namensraum automatisch zerstört.

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWIPC>.  This flag can't be specified in conjunction with B<CLONE_SYSVSEM>.
de: Nur ein privilegierter Prozess (B<CAP_SYS_ADMIN>) kann B<CLONE_NEWIPC> angeben. Dieser Schalter darf nicht zusammen mit B<CLONE_SYSVSEM> angegeben werden.

note: type: Plain text
en: For further information on IPC namespaces, see B<namespaces>(7).
de: Weitere Informationen zu IPC-Namensräumen finden Sie in B<namespaces>(7).

note: type: TP
en: B<CLONE_NEWNET> (since Linux 2.6.24)
de: B<CLONE_NEWNET> (seit Linux 2.6.24)

note: type: Plain text
en: (The implementation of this flag was completed only by about kernel version 2.6.29.)
de: (Die Implementierung dieses Schalters wurde erst ungefähr mit der Kernel-Version 2.6.29 abgeschlossen.)

note: type: Plain text
en: If B<CLONE_NEWNET> is set, then create the process in a new network namespace.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same network namespace as the calling process.  This flag is intended for the implementation of containers.
de: Wenn B<CLONE_NEWNET> gesetzt ist, dann wird der Prozess in einem neuen Netzwerk-Namensraum erstellt. Falls dieser Schalter nicht gesetzt ist, dann wird der Prozess (wie mit B<fork>(2)) im gleichen Netzwerk-Namensraum wie der aufrufende Prozess erstellt. Dieser Schalter ist für die Implementierung von Containern gedacht.

note: type: Plain text
en: A network namespace provides an isolated view of the networking stack (network device interfaces, IPv4 and IPv6 protocol stacks, IP routing tables, firewall rules, the I</proc/net> and I</sys/class/net> directory trees, sockets, etc.).  A physical network device can live in exactly one network namespace.  A virtual network (B<veth>(4))  device pair provides a pipe-like abstraction that can be used to create tunnels between network namespaces, and can be used to create a bridge to a physical network device in another namespace.
de: Ein Netzwerk-Namensraum stellt eine isolierte Ansicht des Netzwerk-Stapelspeichers (Netzwerkgeräteschnittstellen, IPv4- und IPv6-Protokoll-Stapelspeicher, IP-Routing-Tabellen, Firewall-Regeln, die Verzeichnisbäume I</proc/net> und I</sys/class/net>, Sockets, etc.) bereit. Ein physisches Netzwerkgerät kann in genau einem Netzwerknamensraum bestehen. Ein virtuelles Netzwerkgerätepaar (B<veth>(4)) stellt eine einer Pipe ähnliche Abstraktion bereit, die benutzt werden kann, um Tunnel zwischen Netzwerk-Namensräumen aufzubauen und eine Brücke in ein physisches Netzwerkgerät in einem anderen Namensraum zu erstellen.

note: type: Plain text
en: When a network namespace is freed (i.e., when the last process in the namespace terminates), its physical network devices are moved back to the initial network namespace (not to the parent of the process).  For further information on network namespaces, see B<namespaces>(7).
de: Wenn ein Netzwerk-Namensraum freigegeben wird, d.h. wenn der letzte Prozess im Namensraum beendet wird, werden seine physischen Netzwerkgeräte zurück in den ursprünglichen Namensraum verschoben (nicht zum Elternprozess). Weitere Informationen zu Netzwerk-Namensräumen finden Sie in B<namespaces>(7).

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWNET>.
de: Nur ein privilegierter Prozess (B<CAP_SYS_ADMIN>) kann B<CLONE_NEWNET> angeben.

note: type: TP
en: B<CLONE_NEWNS> (since Linux 2.4.19)
de: B<CLONE_NEWNS> (seit Linux 2.4.19)

note: type: Plain text
en: If B<CLONE_NEWNS> is set, the cloned child is started in a new mount namespace, initialized with a copy of the namespace of the parent.  If B<CLONE_NEWNS> is not set, the child lives in the same mount namespace as the parent.
de: Wenn der Schalter B<CLONE_NEWNS> gesetzt ist, wird der geklonte Kindprozess in einem neuen, eingehängten Namensraum gestartet, der mit einer Kopie des Namensraums des Elternprozesses initialisiert wurde. Wenn B<CLONE_NEWNS> nicht gesetzt ist, bleibt der Kindprozess im gleichen Namensraum wie der Elternprozess.

note: See https://lwn.net/Articles/543273/ type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWNS>.  It is not permitted to specify both B<CLONE_NEWNS> and B<CLONE_FS> in the same B<clone>()  call.
de: Nur ein privilegierter Prozess (einer der die Fähigkeit B<CAP_SYS_ADMIN> hat) kann den Schalter B<CLONE_NEWNS> angeben. Es ist nicht erlaubt, sowohl B<CLONE_NEWNS> als auch B<CLONE_FS> im gleichen Aufruf von B<clone>() anzugeben.

note: type: Plain text
en: For further information on mount namespaces, see B<namespaces>(7)  and B<mount_namespaces>(7).
de: Für weitere Informationen über Einhängenamensräume lesen Sie B<namespaces>(7) und B<mount_namespaces>(7)

note: type: TP
en: B<CLONE_NEWPID> (since Linux 2.6.24)
de: B<CLONE_NEWPID> (seit Linux 2.6.24)

note: This explanation draws a lot of details from http://lwn.net/Articles/259217/ Authors: Pavel Emelyanov <xemul@openvz.org> and Kir Kolyshkin <kir@openvz.org> The primary kernel commit is 30e49c263e36341b60b735cbef5ca37912549264 Author: Pavel Emelyanov <xemul@openvz.org> type: Plain text
en: If B<CLONE_NEWPID> is set, then create the process in a new PID namespace.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same PID namespace as the calling process.  This flag is intended for the implementation of containers.
de: Wenn B<CLONE_NEWPID> gesetzt ist, dann wird der Prozess in einem neuen PID-Namensraum erstellt. Falls dieser Schalter nicht gesetzt ist (wie mit B<fork>(2)), dann wird der Prozess in dem gleichen PID-Namensraum wie der aufrufende Prozess erstellt. Der Schalter ist für die Implementierung von Containern gedacht.

note: type: Plain text
en: For further information on PID namespaces, see B<namespaces>(7)  and B<pid_namespaces>(7).
de: Weitere Informationen zu PID-Namensräumen finden Sie in B<namespaces>(7) und B<pid_namespaces>(7).

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWPID>.  This flag can't be specified in conjunction with B<CLONE_THREAD> or B<CLONE_PARENT>.
de: Nur ein privilegierter Prozess (B<CAP_SYS_ADMIN>) kann B<CLONE_NEWPID> angeben. Dieser Schalter darf nicht zusammen mit B<CLONE_THREAD> oder B<CLONE_PARENT> angegeben werden.

note: type: Plain text
en: (This flag first became meaningful for B<clone>()  in Linux 2.6.23, the current B<clone>()  semantics were merged in Linux 3.5, and the final pieces to make the user namespaces completely usable were merged in Linux 3.8.)
de: (Dieser Schalter hatte für B<clone>() erstmals in Linux 2.6.23 eine Bedeutung, die aktuelle B<clone>()-Semantik wurde in Linux 3.5 aufgenommen und die letzten Anteile, um Benutzernamensräume komplett nutzbar zu bekommen, wurden in Linux 3.8 aufgenommen.)

note: type: Plain text
en: If B<CLONE_NEWUSER> is set, then create the process in a new user namespace.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same user namespace as the calling process.
de: Wenn B<CLONE_NEWUSER> gesetzt ist, dann wird der Prozess in einem neuen Benutzer-Namensraum erstellt. Falls dieser Schalter nicht gesetzt ist, dann wird der Prozess (wie mit B<fork>(2)) im gleichen Benutzer-Namensraum wie der aufrufende Prozess erstellt.

note: Before Linux 2.6.29, it appears that only CAP_SYS_ADMIN was needed type: Plain text
en: Before Linux 3.8, use of B<CLONE_NEWUSER> required that the caller have three capabilities: B<CAP_SYS_ADMIN>, B<CAP_SETUID>, and B<CAP_SETGID>.  Starting with Linux 3.8, no privileges are needed to create a user namespace.
de: Vor Linux 3.8 verlangte die Verwendung von B<CLONE_NEWUSER>, dass der Aufrufende drei Capabilities hatte: B<CAP_SYS_ADMIN>, B<CAP_SETUID> und B<CAP_SETGID>. Seit Linux 3.8 werden für die Erstellung eines Benutzernamensraums keine Privilegien benötigt.

note: commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71 https://lwn.net/Articles/543273/ The fix actually went into 3.9 and into 3.8.3. However, user namespaces were, for practical purposes, unusable in earlier 3.8.x because of the various filesystems that didn't support userns. type: Plain text
en: This flag can't be specified in conjunction with B<CLONE_THREAD> or B<CLONE_PARENT>.  For security reasons, B<CLONE_NEWUSER> cannot be specified in conjunction with B<CLONE_FS>.
de: Dieser Schalter kann nicht zusammen mit B<CLONE_THREAD> oder B<CLONE_PARENT> angegeben werden. Aus Sicherheitsgründen darf B<CLONE_NEWUSER> nicht zusammen mit B<CLONE_FS> angegeben werden.

note: type: Plain text
en: For further information on user namespaces, see B<namespaces>(7)  and B<user_namespaces>(7).
de: Für weitere Informationen über Benutzernamensräume lesen Sie B<namespaces>(7) und B<user_namespaces>(7).

note: type: TP
en: B<CLONE_NEWUTS> (since Linux 2.6.19)
de: B<CLONE_NEWUTS> (seit Linux 2.6.19)

note: type: Plain text
en: If B<CLONE_NEWUTS> is set, then create the process in a new UTS namespace, whose identifiers are initialized by duplicating the identifiers from the UTS namespace of the calling process.  If this flag is not set, then (as with B<fork>(2))  the process is created in the same UTS namespace as the calling process.  This flag is intended for the implementation of containers.
de: Falls B<CLONE_NEWUTS> gesetzt ist, erzeugt der Prozess einen neuen UTS-Namensraum, dessen Bezeichner durch Duplizieren der Bezeichner aus dem UTS-Namensraum des aufrufenden Prozesses initialisiert werden. Wenn dieser Schalter nicht gesetzt ist (wie mit B<fork>(2)), dann wird der Prozess im gleichen UTS-Namensraum wie der aufrufende Prozess erzeugt. Dieser Schalter ist für die Implementierung von Containern gedacht.

note: type: Plain text
en: A UTS namespace is the set of identifiers returned by B<uname>(2); among these, the domain name and the hostname can be modified by B<setdomainname>(2)  and B<sethostname>(2), respectively.  Changes made to the identifiers in a UTS namespace are visible to all other processes in the same namespace, but are not visible to processes in other UTS namespaces.
de: Ein UTS-Namensraum ist eine Zusammenstellung von Bezeichnern, die von B<uname>(2) zurückgegeben werden; von denen können der Domain-Name und der Rechnername durch B<setdomainname>(2) beziehungsweise B<sethostname>(2) geändert werden. Änderungen, die an Bezeichnern in einem UTS-Namensraum vorgenommen werden, sind für alle anderen Prozesse im gleichen Namensraum sichtbar, nicht jedoch für Prozesse in anderen UTS-Namensräumen.

note: type: Plain text
en: Only a privileged process (B<CAP_SYS_ADMIN>)  can employ B<CLONE_NEWUTS>.
de: Nur ein privilegierter Prozess (B<CAP_SYS_ADMIN>) kann B<CLONE_NEWUTS> angeben.

note: type: Plain text
en: For further information on UTS namespaces, see B<namespaces>(7).
de: Weitere Informationen zu UTS-Namensräumen finden Sie in B<namespaces>(7).

note: type: TP
en: B<CLONE_PARENT> (since Linux 2.3.12)
de: B<CLONE_PARENT> (seit Linux 2.3.12)

note: type: Plain text
en: If B<CLONE_PARENT> is set, then the parent of the new child (as returned by B<getppid>(2))  will be the same as that of the calling process.
de: Falls B<CLONE_PARENT> gesetzt ist, dann wird der Elternprozess des neuen Kindprozesses (wie er von B<getppid>(2) zurückgegeben wird) der gleiche wie der aufrufende Prozess sein.

note: type: Plain text
en: If B<CLONE_PARENT> is not set, then (as with B<fork>(2))  the child's parent is the calling process.
de: Falls B<CLONE_PARENT> nicht gesetzt ist (wie bei B<fork>(2)), dann ist der Elternprozess des Kindprozesses der aufrufende Prozess.

note: type: Plain text
en: Note that it is the parent process, as returned by B<getppid>(2), which is signaled when the child terminates, so that if B<CLONE_PARENT> is set, then the parent of the calling process, rather than the calling process itself, will be signaled.
de: Beachten Sie, dass dem Elternprozess, wie er von B<getppid>(2) zurückgegeben wird, signalisiert wird wenn der Kindprozess endet. Wenn also B<CLONE_PARENT> gesetzt ist, wird dem Elternprozess des aufrufenden Prozesses anstatt dem aufrufenden Prozess selbst das Signal gesandt.

note: type: TP
en: B<CLONE_PARENT_SETTID> (since Linux 2.5.49)
de: B<CLONE_PARENT_SETTID> (seit Linux 2.5.49)

note: type: Plain text
en: Store the child thread ID at the location I<ptid> in the parent's memory.  (In Linux 2.5.32-2.5.48 there was a flag B<CLONE_SETTID> that did this.)  The store operation completes before B<clone>()  returns control to user space.
de: Die Kindprozess-Thread-Kennung an der Stelle I<ptid> im Elternspeicher ablegen. (In Linux 2.5.32-2.5.48 gab es einen Schalter B<CLONE_SETTID>, der das tat.) Die Speicheraktion wird abgeschlossen, bevor B<clone>() die Steuerung an den Benutzerraum zurückgibt.

note: type: TP
en: B<CLONE_PID> (Linux 2.0 to 2.5.15)
de: B<CLONE_PID> (Linux 2.0 bis 2.5.15)

note: type: Plain text
en: If B<CLONE_PID> is set, the child process is created with the same process ID as the calling process.  This is good for hacking the system, but otherwise of not much use.  From Linux 2.3.21 onward, this flag could be specified only by the system boot process (PID 0).  The flag disappeared completely from the kernel sources in Linux 2.5.16.  Since then, the kernel silently ignores this bit if it is specified in I<flags>.
de: Falls B<CLONE_PID> gesetzt ist, wird der Kindprozess mit der gleichen Prozesskennung wie der aufrufende Prozess erstellt. Dies ist gut, um das System zu hacken, aber andererseits zu nicht viel mehr zu gebrauchen. Seit Linux 2.3.21 konnte dieser Schalter nur durch den Boot-Prozess angegeben werden (PID 0). Dieser Schalter verschwand in Linux 2.5.16 komplett aus den Kernelquellen. Seitdem ignoriert der Kernel dieses Bit, falls es in I<flags> festgelegt ist.

note: type: TP
en: B<CLONE_PTRACE> (since Linux 2.2)
de: B<CLONE_PTRACE> (seit Linux 2.2)

note: type: Plain text
en: If B<CLONE_PTRACE> is specified, and the calling process is being traced, then trace the child also (see B<ptrace>(2)).
de: Falls B<CLONE_PTRACE> angegeben ist und der aufrufende Prozess verfolgt wird, dann wird der Kindprozess ebenfalls verfolgt (siehe B<ptrace>(2)).

note: type: TP
en: B<CLONE_SETTLS> (since Linux 2.5.32)
de: B<CLONE_SETTLS> (seit Linux 2.5.32)

note: type: Plain text
en: The TLS (Thread Local Storage) descriptor is set to I<newtls>.
de: Der TLS (Thread Local Storage)-Deskriptor ist auf I<newtls> gesetzt.

note: type: Plain text
en: The interpretation of I<newtls> and the resulting effect is architecture dependent.  On x86, I<newtls> is interpreted as a I<struct user_desc\ *> (see B<set_thread_area>(2)).  On x86-64 it is the new value to be set for the %fs base register (see the B<ARCH_SET_FS> argument to B<arch_prctl>(2)).  On architectures with a dedicated TLS register, it is the new value of that register.
de: Die Interpretation von I<newtls> und der resultierende Effekt ist architekturabhängig. Auf X86 ist I<newtls> als ein I<struct user_desc\ *> interpretiert (siehe B<set_thread_area>(2)). Auf X86-64 ist es der neue für das Basisregister %fs zu setzende Wert (siehe das Argument B<ARCH_SET_FS> von B<arch_prctl>(2)). Auf Architekturen mit einem dedizierten TLS-Register ist es der neue Wert dieses Registers.

note: type: TP
en: B<CLONE_SIGHAND> (since Linux 2.0)
de: B<CLONE_SIGHAND> (seit Linux 2.0)

note: type: Plain text
en: If B<CLONE_SIGHAND> is set, the calling process and the child process share the same table of signal handlers.  If the calling process or child process calls B<sigaction>(2)  to change the behavior associated with a signal, the behavior is changed in the other process as well.  However, the calling process and child processes still have distinct signal masks and sets of pending signals.  So, one of them may block or unblock signals using B<sigprocmask>(2)  without affecting the other process.
de: Ist B<CLONE_SIGHAND> gesetzt, teilen sich der aufrufende Prozess und der Kindprozess die Tabelle der Signal-Handler. Ruft einer der beiden Prozesse B<sigaction>(2) auf, um das Antwortverhalten auf ein Signal zu verändern, so betrifft dies auch den anderen Prozess. Jedoch besitzen aufrufender Prozess und Kindprozess nach wie vor getrennte Signalmasken und getrennte Listen der noch ausstehenden Signale. Daher könnten Signale durch Aufruf von B<sigprocmask>(2) für einen Prozess geblockt oder zugelassen werden ohne den anderen Prozess zu beeinflussen.

note: type: Plain text
en: If B<CLONE_SIGHAND> is not set, the child process inherits a copy of the signal handlers of the calling process at the time B<clone>()  is called.  Calls to B<sigaction>(2)  performed later by one of the processes have no effect on the other process.
de: Ist B<CLONE_SIGHAND> nicht gesetzt, erbt der Kindprozess durch den B<clone>-Aufruf eine Kopie des Signal-Handlers vom aufrufenden Prozess. Spätere Aufrufe von B<sigaction>(2) durch einen der Prozesse hat dann keine Auswirkung auf den anderen Prozess.

note: Precisely: Linux 2.6.0-test6 type: Plain text
en: Since Linux 2.6.0, I<flags> must also include B<CLONE_VM> if B<CLONE_SIGHAND> is specified
de: Seit Linux 2.6.0 müssen die I<flags> außerdem B<CLONE_VM> enthalten, falls B<CLONE_SIGHAND> angegeben wurde.

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

note: Precisely: Linux 2.6.0-test2 type: Plain text
en: If B<CLONE_STOPPED> is set, then the child is initially stopped (as though it was sent a B<SIGSTOP> signal), and must be resumed by sending it a B<SIGCONT> signal.
de: Falls B<CLONE_STOPPED> gesetzt ist, ist der Kindprozess anfangs gestoppt (als ob ein B<SIGSTOP>-Signal gesendet worden wäre) und muss durch Senden eines B<SIGCONT>-Signals wieder aufgenommen werden.

note: glibc 2.8 removed this defn from bits/sched.h type: Plain text
en: This flag was I<deprecated> from Linux 2.6.25 onward, and was I<removed> altogether in Linux 2.6.38.  Since then, the kernel silently ignores it without error.  Starting with Linux 4.6, the same bit was reused for the B<CLONE_NEWCGROUP> flag.
de: Dieser Schalter war ab Linux 2.6.25 I<missbilligt> und wurde in Linux 2.6.38 vollständig I<entfernt>. Seitdem ignoriert der Kernel ihn ohne Fehler. Seit Linux 4.6 wird dasselbe Bit für den Schalter B<CLONE_NEWCGROUP> wiederverwendet.

note: type: TP
en: B<CLONE_SYSVSEM> (since Linux 2.5.10)
de: B<CLONE_SYSVSEM> (seit Linux 2.5.10)

note: type: Plain text
en: If B<CLONE_SYSVSEM> is set, then the child and the calling process share a single list of System V semaphore adjustment (I<semadj>)  values (see B<semop>(2)).  In this case, the shared list accumulates I<semadj> values across all processes sharing the list, and semaphore adjustments are performed only when the last process that is sharing the list terminates (or ceases sharing the list using B<unshare>(2)).  If this flag is not set, then the child has a separate I<semadj> list that is initially empty.
de: Wenn B<CLONE_SYSVSEM> gesetzt ist, dann teilen sich der Kindprozess und der aufrufende Prozess eine einzige Liste von System-V-Semaphore-Anpassungswerten, (siehe B<semop>(2)). In diesem Fall sammelt die gemeinsame Liste I<semadj> Werte über alle Prozesse, die die Liste gemeinsam nutzen und Semaphore-Anpassungen werden nur durchgeführt, wenn der letzte Prozess, der die Liste gemeinsam nutzt, sich beendet (oder mittels B<unshare>(2) aufhört, die Liste mitzunutzen). Falls dieser Schalter nicht gesetzt ist, besitzt der Kindprozess eine separate I<semadj>-Liste, die anfangs leer ist.

note: type: TP
en: B<CLONE_THREAD> (since Linux 2.4.0)
de: B<CLONE_THREAD> (seit Linux 2.4.0)

note: Precisely: Linux 2.6.0-test8 type: Plain text
en: If B<CLONE_THREAD> is set, the child is placed in the same thread group as the calling process.  To make the remainder of the discussion of B<CLONE_THREAD> more readable, the term "thread" is used to refer to the processes within a thread group.
de: Falls B<CLONE_THREAD> gesetzt ist, wird der Kindprozess in die gleiche Thread-Gruppe wie der aufrufende Prozess platziert. Um den Rest der Diskussion von B<CLONE_THREAD> leserlicher zu machen, wird der Begriff »Thread« benutzt, um Bezug auf Prozesse innerhalb einer Thread-Gruppe zu nehmen.

note: type: Plain text
en: Thread groups were a feature added in Linux 2.4 to support the POSIX threads notion of a set of threads that share a single PID.  Internally, this shared PID is the so-called thread group identifier (TGID) for the thread group.  Since Linux 2.4, calls to B<getpid>(2)  return the TGID of the caller.
de: Thread-Gruppen waren ein Leistungsmerkmal, das in Linux 2.4 hinzugefügt wurde, um den POSIX-Thread-Gedanken von einer Thread-Zusammenstellung zu unterstützen, die sich eine einzelne PID teilt. Intern ist diese gemeinsame PID ein sogenannter Thread-Gruppen-Bezeichner (TGID) für die Thread-Gruppe. Seit Linux 2.4 geben Aufrufe von B<getpid>(2) die TGID des Aufrufers zurück.

note: type: Plain text
en: The threads within a group can be distinguished by their (system-wide)  unique thread IDs (TID).  A new thread's TID is available as the function result returned to the caller of B<clone>(), and a thread can obtain its own TID using B<gettid>(2).
de: Die Threads innerhalb einer Gruppe können durch ihre (systemweit) einheitliche Thread-Kennung (TID) unterschieden werden. Die TID eines neuen Threads ist als Funktionsergebnis verfügbar, das an den Aufrufenden von B<clone>() zurückgegeben wird. Ein Thread kann durch Benutzen von B<gettid>(2) seine eigene TID erhalten.

note: type: Plain text
en: When a call is made to B<clone>()  without specifying B<CLONE_THREAD>, then the resulting thread is placed in a new thread group whose TGID is the same as the thread's TID.  This thread is the I<leader> of the new thread group.
de: Wenn B<clone>() ohne Angabe von B<CLONE_THREAD> aufgerufen wurde, dann wird der resultierende Thread in eine neue Thread-Gruppe platziert, deren TGID der TID des Threads entspricht. Dieser Thread ist der I<Führer> der neuen Thread-Gruppe.

note: type: Plain text
en: A new thread created with B<CLONE_THREAD> has the same parent process as the caller of B<clone>()  (i.e., like B<CLONE_PARENT>), so that calls to B<getppid>(2)  return the same value for all of the threads in a thread group.  When a B<CLONE_THREAD> thread terminates, the thread that created it using B<clone>()  is not sent a B<SIGCHLD> (or other termination) signal; nor can the status of such a thread be obtained using B<wait>(2).  (The thread is said to be I<detached>.)
de: Ein neuer mit B<CLONE_THREAD> erzeugter Thread hat den gleichen Elternprozess wie der, der B<clone>() aufruft (d.h. wie B<CLONE_PARENT>), so dass Aufrufe von B<getppid>(2) den gleichen Wert für alle Threads in der Thread-Gruppe zurückliefern. Wenn ein B<CLONE_THREAD>-Thread endet, wird dem Thread, der ihn per B<clone>() erstellt hat, weder ein B<SIGCHLD>-Signal (oder ein anderes Ende-Signal) gesandt, noch kann der Status eines solchen Threads per B<wait>(2) abgefragt werden. (Der Thread wird als I<losgelöst> bezeichnet.)

note: type: Plain text
en: After all of the threads in a thread group terminate the parent process of the thread group is sent a B<SIGCHLD> (or other termination) signal.
de: Nachdem alle Threads in einer Thread-Gruppe beendet sind, wird dem Elternprozess ein B<SIGCHLD>-Signal (oder ein anderes Ende-Signal) gesandt.

note: type: Plain text
en: If any of the threads in a thread group performs an B<execve>(2), then all threads other than the thread group leader are terminated, and the new program is executed in the thread group leader.
de: Falls einige der Threads in einer Thread-Gruppe ein B<execve>(2) durchführen, dann werden alle Threads außer dem Thread-Führer beendet und das neue Programm wird im Thread-Gruppenführer ausgeführt.

note: type: Plain text
en: If one of the threads in a thread group creates a child using B<fork>(2), then any thread in the group can B<wait>(2)  for that child.
de: Falls einer der Threads in einer Thread-Gruppe per B<fork>(2) einen Kindprozess erzeugt, dann kann jeder Thread in der Gruppe B<wait>(2) für diesen Kindprozess ausführen.

note: Precisely: Linux 2.6.0-test6 type: Plain text
en: Since Linux 2.5.35, I<flags> must also include B<CLONE_SIGHAND> if B<CLONE_THREAD> is specified (and note that, since Linux 2.6.0, B<CLONE_SIGHAND> also requires B<CLONE_VM> to be included).
de: Seit Linux 2.5.35 müssen die I<flags> auch B<CLONE_SIGHAND> enthalten, wenn B<CLONE_THREAD> angegeben wurde. Beachten Sie auch, dass seit Linux 2.6.0 B<CLONE_SIGHAND> auch B<CLONE_VM> enthalten muss.

note: type: Plain text
en: Signal dispositions and actions are process-wide: if an unhandled signal is delivered to a thread, then it will affect (terminate, stop, continue, be ignored in)  all members of the thread group.
de: Signalzuordnungen und -aktionen sind prozessweit: Falls ein nicht abgefangenes Signal an den Thread geschickt wird, dann wird es alle Mitglieder in der Thread-Gruppe beeinflussen (beenden, stoppen, fortfahren, darin ignoriert werden).

note: type: Plain text
en: Each thread has its own signal mask, as set by B<sigprocmask>(2).
de: Jeder Thread hat seine eigene Signalmaske, wie von B<sigprocmask>(2) gesetzt.

note: type: Plain text
en: A call to B<sigpending>(2)  returns a signal set that is the union of the pending process-directed signals and the signals that are pending for the calling thread.
de: Ein Aufruf von B<sigpending>(2) liefert eine Signalmenge zurück, die die Vereinigung der anhängigen Prozess-orientierten Signale und der Signale, die für den aufrufenden Thread anhängig sind, ist.

note: type: Plain text
en: If a process-directed signal is delivered to a thread group, and the thread group has installed a handler for the signal, then the handler will be invoked in exactly one, arbitrarily selected member of the thread group that has not blocked the signal.  If multiple threads in a group are waiting to accept the same signal using B<sigwaitinfo>(2), the kernel will arbitrarily select one of these threads to receive the signal.
de: Falls ein Prozess-orientiertes Signal an eine Thread-Gruppe ausgeliefert wird und die Thread-Gruppe einen Handler für dieses Signal installiert hat, dann dann wird der Handler in exakt einem willkürlich ausgewählten Mitglied der Thread-Gruppe aufrufen, das das Signal nicht blockiert hat. Falls mehrere Threads in einer Gruppe darauf warten das gleiche Signal per B<sigwaitinfo>(2) zu akzeptieren, wird der Kernel einen dieser Threads willkürlich auswählen, um das Signal zu empfangen.

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

note: type: Plain text
en: If B<CLONE_UNTRACED> is specified, then a tracing process cannot force B<CLONE_PTRACE> on this child process.
de: Falls B<CLONE_UNTRACED> angegeben ist, kann ein verfolgender Prozess kein B<CLONE_PTRACE> auf diesem Kindprozess erzwingen.

note: type: TP
en: B<CLONE_VFORK> (since Linux 2.2)
de: B<CLONE_VFORK> (seit Linux 2.2)

note: type: Plain text
en: If B<CLONE_VFORK> is set, the execution of the calling process is suspended until the child releases its virtual memory resources via a call to B<execve>(2)  or B<_exit>(2)  (as with B<vfork>(2)).
de: Falls B<CLONE_VFORK> gesetzt ist, wird die Ausführung des aufrufenden Prozesses aufgeschoben bis der Kindprozess seine virtuellen Speicherressourcen durch Aufrufen von B<execve>(2) oder B<_exit>(2) (wie bei B<vfork>(2)) freigibt.

note: type: Plain text
en: If B<CLONE_VFORK> is not set, then both the calling process and the child are schedulable after the call, and an application should not rely on execution occurring in any particular order.
de: Falls B<CLONE_VFORK> nicht gesetzt ist, dann werden sowohl der aufrufende Prozess, als auch der Kindprozess nach dem Aufruf planbar und eine Anwendung sollte sich nicht darauf verlassen, dass die Ausführung in einer speziellen Reihenfolge erfolgt.

note: type: TP
en: B<CLONE_VM> (since Linux 2.0)
de: B<CLONE_VM> (seit Linux 2.0)

note: type: Plain text
en: If B<CLONE_VM> is set, the calling process and the child process run in the same memory space.  In particular, memory writes performed by the calling process or by the child process are also visible in the other process.  Moreover, any memory mapping or unmapping performed with B<mmap>(2)  or B<munmap>(2)  by the child or calling process also affects the other process.
de: Ist B<CLONE_VM> gesetzt, laufen aufrufender Prozess und Kindprozess im selben Speicherbereich. Insbesondere sind Schreibzugriffe des aufrufenden Prozesses oder des Kindprozesses in den gemeinsamen Speicher auch vom anderen Prozess aus sichtbar. Zudem beeinflusst jede Veränderung der Speicher-Mappings mit B<mmap>(2) oder B<munmap>(2) durch den Kindprozess oder den aufrufenden Prozess auch den jeweils anderen Prozess.

note: type: Plain text
en: If B<CLONE_VM> is not set, the child process runs in a separate copy of the memory space of the calling process at the time of B<clone>().  Memory writes or file mappings/unmappings performed by one of the processes do not affect the other, as with B<fork>(2).
de: Ist B<CLONE_VM> nicht gesetzt, erhält der Kindprozess eine eigene Kopie des Speicherbereichs des aufrufenden Prozesses zur Zeit des B<clone>()-Aufrufs. Führt ein Prozess Schreibzugriffe auf den Speicher oder Änderungen am Dateispeicher-Mapping aus, beeinflussen diese Operationen nicht den jeweils anderen, wie bei B<fork>(2).

note: type: SH
en: NOTES
de: ANMERKUNGEN

note: type: Plain text
en: Note that the glibc B<clone>()  wrapper function makes some changes in the memory pointed to by I<child_stack> (changes required to set the stack up correctly for the child)  I<before> invoking the B<clone>()  system call.  So, in cases where B<clone>()  is used to recursively create children, do not use the buffer employed for the parent's stack as the stack of the child.
de: Beachten Sie, dass die Glibc-Wrapperfunktion B<clone>() einige Änderungen am Speicher, auf den I<child_stack> zeigt, vornimmt (Änderungen, um den Stack korrekt für das Kind einzurichten), I<bevor> der Systemaufruf B<clone>() ausgelöst wird. Verwenden Sie daher in Fällen, in denen B<clone>() zur rekursiven Erstellung von Kindern verwandt wird, nicht den Puffer, der für den Stack der Eltern eingesetzt wird, als Stack der Kinder.

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

note: type: Plain text
en: The raw B<clone>()  system call corresponds more closely to B<fork>(2)  in that execution in the child continues from the point of the call.  As such, the I<fn> and I<arg> arguments of the B<clone>()  wrapper function are omitted.
de: Der rohe B<sys_clone>-Systemaufruf entspricht eher B<fork>(2), da er mit der Ausführung des Kindprozesses am Zeitpunkt des Aufrufs fortfährt. Von daher werden die Argumente I<fn> und I<arg> der B<clone>()-Wrapper-Funktion weggelassen.

note: type: Plain text
en: Another difference for the raw B<clone>()  system call is that the I<child_stack> argument may be NULL, in which case the child uses a duplicate of the parent's stack.  (Copy-on-write semantics ensure that the child gets separate copies of stack pages when either process modifies the stack.)  In this case, for correct operation, the B<CLONE_VM> option should not be specified.  (If the child I<shares> the parent's memory because of the use of the B<CLONE_VM> flag, then no copy-on-write duplication occurs and chaos is likely to result.)
de: Ein weiterer Unterschied für den rohen Systemaufruf B<clone>() besteht darin, dass das Argument I<child_stack> NULL sein könnte, so dass in diesem Fall das Kind eine Dublette des Stacks des Elternprozesses verwendet. (»Copy-on-write«-Semantik stellt sicher, dass der Kindprozess getrennte Kopien des Stapelspeichers erhält, wenn einer der beiden Prozesse den Stapelspeicher verändert.) In diesem Fall sollte die Option B<CLONE_VM> nicht angegeben werden, damit es korrekt funktioniert. (Falls das Kind sich aufgrund des Schalters B<CLONE_VM> mit dem Elternprozess den Speicher I<teilt>, dann tritt keine copy-on-write-Duplizierung auf und wahrscheinlich tritt Chaos ein.

note: type: Plain text
en: The order of the arguments also differs in the raw system call, and there are variations in the arguments across architectures, as detailed in the following paragraphs.
de: Die Reihenfolge der Argumente unterscheidet sich auch im rohen Systemaufruf und es gibt über die Architekturen hinweg Variationen in den Argumenten, wie dies in den folgenden Absätzen dargestellt wird.

note: type: Plain text
en: The raw system call interface on x86-64 and some other architectures (including sh, tile, ia-64, and alpha) is:
de: Die rohe Schnittstelle für Systemaufrufe auf x86-64 und einigen anderen Architekturen (darunter Sh, Tile, Ia-64 und Alpha) sieht so aus:

note: CONFIG_CLONE_BACKWARDS type: Plain text
en: On x86-32, and several other common architectures (including score, ARM, ARM 64, PA-RISC, arc, Power PC, xtensa, and MIPS), the order of the last two arguments is reversed:
de: Auf x86-32 und mehreren anderen häufigen Architekturen (darunter Score, ARM, ARM 64, PA-RISC, Arc, Power PC, Xtensa und MIPS) ist die Reihenfolge der letzten zwei Argumente gedreht:

note: CONFIG_CLONE_BACKWARDS2 type: Plain text
en: On the cris and s390 architectures, the order of the first two arguments is reversed:
de: Auf der Cris- und S30-Architektur ist die Reihenfolge der ersten zwei Argumente gedreht:

note: CONFIG_CLONE_BACKWARDS3 type: Plain text
en: On the microblaze architecture, an additional argument is supplied:
de: Auf der Microblaze-Architektur wird ein zusätzliches Argument übergeben:

note: type: Plain text
en: B<long clone(unsigned long >I<flags>B<, void *>I<child_stack>B<,>
    B<           int >I<stack_size>B<,>         /* Size of stack */
    B<           int *>I<ptid>B<, int *>I<ctid>B<,>
    B<           unsigned long >I<newtls>B<);>
de: B<long clone(unsigned long >I<flags>B<, void *>I<child_stack>B<,>
    B<           int >I<stack_size>B<,>         /* Größe des Stacks */
    B<           int *>I<ptid>B<, int *>I<ctid>B<,>
    B<           unsigned long >I<newtls>B<);>

note: type: SS
en: blackfin, m68k, and sparc
de: Blackfin, M68k und Sparc

note: Mike Frysinger noted in a 2013 mail: these arches don't define __ARCH_WANT_SYS_CLONE: blackfin ia64 m68k sparc type: Plain text
en: The argument-passing conventions on blackfin, m68k, and sparc are different from the descriptions above.  For details, see the kernel (and glibc) source.
de: Die Konventionen der Argumentübergabe weichen auf Blackfin, M68k und Sparc von der obigen Beschreibung ab. Einzelheiten finden Sie in der Kernel- (und Glibc-) Quelle.

note: type: SS
en: ia64
de: Ia64

note: type: Plain text
en: On ia64, a different interface is used:
de: Auf ia64 wird eine andere Schnittstelle benutzt:

note: type: Plain text
en: B<int __clone2(int (*>I<fn>B<)(void *), >
    B<             void *>I<child_stack_base>B<, size_t >I<stack_size>B<,>
    B<             int >I<flags>B<, void *>I<arg>B<, ... >
    B<          /* pid_t *>I<ptid>B<, struct user_desc *>I<tls>B<, pid_t *>I<ctid>B< */ );>
de: B<int __clone2(int (*>I<fn>B<)(void *), >
    B<             void *>I<child_stack_base>B<, size_t >I<stack_size>B<,>
    B<             int >I<flags>B<, void *>I<arg>B<, … >
    B<          /* pid_t *>I<ptid>B<, struct user_desc *>I<tls>B<,>
    B<             pid_t *>I<ctid>B< */ );>

note: type: Plain text
en: The prototype shown above is for the glibc wrapper function; for the system call itself, the prototype can be described as follows (it is identical to the B<clone>()  prototype on microblaze):
de: Der oben gezeigte Prototyp ist für die Glibc-Wrapper-Funktion; für den Systemaufruf selbst wird der Prototyp wie folgt beschrieben (er ist identisch zum B<clone>()-Prototyp auf Microblaze):

note: type: Plain text
en: B<long clone2(unsigned long >I<flags>B<, void *>I<child_stack_base>B<,>
    B<            int >I<stack_size>B<,>         /* Size of stack */
    B<            int *>I<ptid>B<, int *>I<ctid>B<,>
    B<            unsigned long >I<tls>B<);>
de: B<long clone2(unsigned long >I<flags>B<, void *>I<child_stack_base>B<,>
    B<            int >I<stack_size>B<,>         /* Größe des Stacks */
    B<            int *>I<ptid>B<, int *>I<ctid>B<,>
    B<            unsigned long >I<tls>B<);>

note: type: Plain text
en: B<__clone2>()  operates in the same way as B<clone>(), except that I<child_stack_base> points to the lowest address of the child's stack area, and I<stack_size> specifies the size of the stack pointed to by I<child_stack_base>.
de: B<__clone2>() arbeitet auf die gleiche Weise wie B<clone>(), außer dass I<child_stack_base> auf die niedrigste Adresse im Stapelspeicherbereich des Kindprozesses zeigt und I<stack_size> die Größe des Stapelspeichers angibt, auf die I<child_stack_base> zeigt.

note: type: SS
en: Linux 2.4 and earlier
de: Linux 2.4 und älter

note: type: Plain text
en: In Linux 2.4 and earlier, B<clone>()  does not take arguments I<ptid>, I<tls>, and I<ctid>.
de: Unter Linux 2.4 und früher gab es die Argumente I<ptid>, I<tls> und I<ctid> noch nicht.

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

note: gettid(2) returns current->pid; getpid(2) returns current->tgid; type: Plain text
en: On success, the thread ID of the child process is returned in the caller's thread of execution.  On failure, -1 is returned in the caller's context, no child process will be created, and I<errno> will be set appropriately.
de: Bei Erfolg wird im ausgeführten Thread des Aufrufenden die Thread-Kennung des Kindprozesses zurückgegeben. Im Fehlerfall wird im Kontext des Aufrufenden -1 zurückgegeben, kein Kindprozess erzeugt und I<errno> entsprechend gesetzt.

note: type: SH
en: ERRORS
de: FEHLER

note: type: Plain text
en: Too many processes are already running; see B<fork>(2).
de: Es laufen bereits zu viele Prozesse; siehe B<fork>(2).

note: Precisely: Linux 2.6.0-test6 type: Plain text
en: B<CLONE_SIGHAND> was specified, but B<CLONE_VM> was not.  (Since Linux 2.6.0.)
de: B<CLONE_SIGHAND> wurde angegeben, aber nicht B<CLONE_VM>. (Seit Linux 2.6.0.)

note: .TP .B EINVAL Precisely one of .B CLONE_DETACHED and .B CLONE_THREAD was specified. (Since Linux 2.6.0-test6.) type: Plain text
en: B<CLONE_THREAD> was specified, but B<CLONE_SIGHAND> was not.  (Since Linux 2.5.35.)
de: B<CLONE_THREAD> wurde angegeben, aber nicht B<CLONE_SIGHAND>. (Seit Linux 2.5.35.)

note: type: Plain text
en: B<CLONE_THREAD> was specified, but the current process previously called B<unshare>(2)  with the B<CLONE_NEWPID> flag or used B<setns>(2)  to reassociate itself with a PID namespace.
de: B<CLONE_THREAD> wurde festgelegt, aber der aktuelle Prozess hatte vorher B<unshare>(2) mit dem Schalter B<CLONE_NEWPID> aufgerufen oder B<setns>(2) verwandt, um sich wieder einem PID-Namensraum zuzuordnen.

note: commit e66eded8309ebf679d3d3c1f5820d1f2ca332c71 type: Plain text
en: Both B<CLONE_FS> and B<CLONE_NEWNS> were specified in I<flags>.
de: In I<flags> wurden sowohl B<CLONE_FS> als auch B<CLONE_NEWNS> angegeben.

note: type: TP
en: B<EINVAL> (since Linux 3.9)
de: B<EINVAL> (seit Linux 3.9)

note: type: Plain text
en: Both B<CLONE_NEWUSER> and B<CLONE_FS> were specified in I<flags>.
de: In I<flags> wurden sowohl B<CLONE_NEWUSER> als auch B<CLONE_FS> angegeben.

note: type: Plain text
en: Both B<CLONE_NEWIPC> and B<CLONE_SYSVSEM> were specified in I<flags>.
de: In I<flags> wurden sowohl B<CLONE_NEWIPC> als auch B<CLONE_SYSVSEM> angegeben.

note: type: Plain text
en: One (or both) of B<CLONE_NEWPID> or B<CLONE_NEWUSER> and one (or both) of B<CLONE_THREAD> or B<CLONE_PARENT> were specified in I<flags>.
de: Eines (oder beides) von B<CLONE_NEWPID> oder B<CLONE_NEWUSER> und eines (oder beides) von B<CLONE_THREAD> oder B<CLONE_PARENT> wurde in I<flags> angegeben.

note: type: Plain text
en: Returned by the glibc B<clone>()  wrapper function when I<fn> or I<child_stack> is specified as NULL.
de: Wird von der Glibc-Wrapper-Funktion B<clone>() zurückgegeben, wenn ein Wert von Null für I<fn> oder I<child_stack> angegeben wurde.

note: type: Plain text
en: B<CLONE_NEWIPC> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_SYSVIPC> and B<CONFIG_IPC_NS> options.
de: B<CLONE_NEWIPC> wurde in I<flags> festgelegt, aber der Kernel ist nicht mit den Optionen B<CONFIG_SYSVIPC> und B<CONFIG_IPC_NS> konfiguriert.

note: type: Plain text
en: B<CLONE_NEWNET> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_NET_NS> option.
de: B<CLONE_NEWNET> wurde in I<flags> festgelegt, aber der Kernel ist nicht mit der Option B<CONFIG_NET_NS> konfiguriert.

note: type: Plain text
en: B<CLONE_NEWPID> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_PID_NS> option.
de: B<CLONE_NEWPID> wurde in I<flags> angegeben, aber der Kernel ist nicht mit der Option B<CONFIG_PID_NS> konfiguriert.

note: type: Plain text
en: B<CLONE_NEWUSER> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_USER_NS> option.
de: B<CLONE_NEWUSER> wurde in I<flags> festgelegt, aber der Kernel ist nicht mit der Option B<CONFIG_USER_NS> konfiguriert.

note: type: Plain text
en: B<CLONE_NEWUTS> was specified in I<flags>, but the kernel was not configured with the B<CONFIG_UTS_NS> option.
de: B<CLONE_NEWUTS> wurde in I<flags> festgelegt, aber der Kernel ist nicht mit der Option B<CONFIG_UTS_NS> konfiguriert.

note: type: Plain text
en: I<child_stack> is not aligned to a suitable boundary for this architecture.  For example, on aarch64, I<child_stack> must be a multiple of 16.
de: I<child_stack> ist nicht an einer geeigneten Grenze für diese Architektur ausgerichtet. Beispielsweise muss I<child_stack> auf Aarch64 ein Vielfaches von 16 sein.

note: type: Plain text
en: Cannot allocate sufficient memory to allocate a task structure for the child, or to copy those parts of the caller's context that need to be copied.
de: Es kann nicht ausreichend Speicher für eine Aufgabenstruktur des Kindprozesses reserviert werden oder um benötigte Teile vom Kontext des Aufrufenden zu kopieren.

note: type: TP
en: B<ENOSPC> (since Linux 3.7)
de: B<ENOSPC> (seit Linux 3.7)

note: commit f2302505775fd13ba93f034206f1e2a587017929 type: Plain text
en: B<CLONE_NEWPID> was specified in flags, but the limit on the nesting depth of PID namespaces would have been exceeded; see B<pid_namespaces>(7).
de: B<CLONE_NEWPID> wurde in den Schalter angegeben, aber die Begrenzung der Verschachtelungstiefe von PID-Namensräumen würde überschritten; siehe B<pid_namespaces>(7).

note: type: TP
en: B<ENOSPC> (since Linux 4.9; beforehand B<EUSERS>)
de: B<ENOSPC> (seit Linux 4.9; vorher B<EUSERS>)

note: type: Plain text
en: B<CLONE_NEWUSER> was specified in I<flags>, and the call would cause the limit on the number of nested user namespaces to be exceeded.  See B<user_namespaces>(7).
de: B<CLONE_NEWUSER> wurde in I<flags> festgelegt und der Aufruf würde zu einer Überschreitung der Begrenzung für die Anzahl von verschachtelten Benutzernamensräumen führen. Siehe B<user_namespaces>(7).

note: type: Plain text
en: From Linux 3.11 to Linux 4.8, the error diagnosed in this case was B<EUSERS>.
de: Von Linux 3.11 bis Linux 4.8 war der in diesem Fall diagnostizierte Fehler B<EUSERS>.

note: type: TP
en: B<ENOSPC> (since Linux 4.9)
de: B<ENOSPC> (seit Linux 4.9)

note: type: Plain text
en: One of the values in I<flags> specified the creation of a new user namespace, but doing so would have caused the limit defined by the corresponding file in I</proc/sys/user> to be exceeded.  For further details, see B<namespaces>(7).
de: Einer der Werte in I<flags> legte die Erstellung eines neuen Benutzer-Namensraums fest, dadurch würde aber die in der enstprechenden Datei in I</proc/sys/user> festgelegte Begrenzung überschritten. Für weitere Details siehe B<namespaces>(7).

note: type: Plain text
en: B<CLONE_NEWCGROUP>, B<CLONE_NEWIPC>, B<CLONE_NEWNET>, B<CLONE_NEWNS>, B<CLONE_NEWPID>, or B<CLONE_NEWUTS> was specified by an unprivileged process (process without B<CAP_SYS_ADMIN>).
de: B<CLONE_NEWCGROUP>, B<CLONE_NEWIPC>, B<CLONE_NEWNET>, B<CLONE_NEWNS>, B<CLONE_NEWPID> oder B<CLONE_NEWUTS> wurde von einem nicht privilegierten Prozess angegeben (Prozess ohne B<CAP_SYS_ADMIN>).

note: type: Plain text
en: B<CLONE_PID> was specified by a process other than process 0.  (This error occurs only on Linux 2.5.15 and earlier.)
de: B<CLONE_PID> wurde von einem anderen Prozess als Prozess 0 angegeben. (Dieser Fehler tritt nur unter Linux 2.5.15 und früheren Versionen auf.)

note: type: Plain text
en: B<CLONE_NEWUSER> was specified in I<flags>, but either the effective user ID or the effective group ID of the caller does not have a mapping in the parent namespace (see B<user_namespaces>(7)).
de: B<CLONE_NEWUSER> wurde in I<flags> festgelegt, aber weder die effektive Benutzerkennung noch die effektive Gruppenkennung des Aufrufenden hat eine Abbildung in den Namensraum der Eltern (siehe B<user_namespaces>(7)).

note: type: TP
en: B<EPERM> (since Linux 3.9)
de: B<EPERM> (seit Linux 3.9)

note: commit 3151527ee007b73a0ebd296010f1c0454a919c7d FIXME What is the rationale for this restriction? type: Plain text
en: B<CLONE_NEWUSER> was specified in I<flags> and the caller is in a chroot environment (i.e., the caller's root directory does not match the root directory of the mount namespace in which it resides).
de: B<CLONE_NEWUSER> wurde in I<flags> festgelegt und der Aufrufende ist in einer Chroot-Umgebung (d.h. das Wurzelverzeichnis des Aufrufenden passt nicht zum Wurzelverzeichnis des Einhängenamensraums, in dem er sich befindet).

note: type: TP
en: B<ERESTARTNOINTR> (since Linux 2.6.17)
de: B<ERESTARTNOINTR> (seit Linux 2.6.17)

note: commit 4a2c7a7837da1b91468e50426066d988050e4d56 type: Plain text
en: System call was interrupted by a signal and will be restarted.  (This can be seen only during a trace.)
de: Ein Systemaufruf wurde durch ein Signal unterbrochen und wird neu gestartet. (Dies wird nur während einer Verfolgung sichtbar sein.)

note: type: TP
en: B<EUSERS> (Linux 3.11 to Linux 4.8)
de: B<EUSERS> (Linux 3.11 bis Linux 4.8)

note: .SH VERSIONS There is no entry for .BR clone () in libc5. glibc2 provides as described in this manual page. type: Plain text
en: B<CLONE_NEWUSER> was specified in I<flags>, and the limit on the number of nested user namespaces would be exceeded.  See the discussion of the B<ENOSPC> error above.
de: B<CLONE_NEWUSER> wurde in I<flags> festgelegt und die Begrenzung für die Anzahl von verschachtelten Benutzernamensräumen würde überschritten. Siehe die Diskussion des Fehlers B<ENOSPC> oben.

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

note: type: Plain text
en: B<clone>()  is Linux-specific and should not be used in programs intended to be portable.
de: B<clone>() ist Linux-spezifisch und sollte nicht in portierbaren Programmen benutzt werden.

note: type: Plain text
en: The B<kcmp>(2)  system call can be used to test whether two processes share various resources such as a file descriptor table, System V semaphore undo operations, or a virtual address space.
de: Der Systemaufruf B<kcmp>(2) kann zum Testen, ob zwei Prozesse sich verschiedene Ressourcen, wie die Dateideskriptortabelle, die Rücksetz-Aktionen der System-V-Semaphoren oder einen virtuellen Adressraum, teilen, verwandt werden.

note: type: Plain text
en: Handlers registered using B<pthread_atfork>(3)  are not executed during a call to B<clone>().
de: Handler, die mittels B<pthread_atfork>(3) registriert sind, werden während eines Aufrufs von B<clone>() nicht ausgeführt.

note: type: Plain text
en: In the Linux 2.4.x series, B<CLONE_THREAD> generally does not make the parent of the new thread the same as the parent of the calling process.  However, for kernel versions 2.4.7 to 2.4.18 the B<CLONE_THREAD> flag implied the B<CLONE_PARENT> flag (as in Linux 2.6.0 and later).
de: In der Linux 2.4.x-Serie gibt B<CLONE_THREAD> generell dem neuen Prozess nicht den gleichen Elternprozess, wie dem aufrufenden Prozess. Für die Kernel-Versionen 2.4.7 bis 2.4.18 implizierte der Schalter B<CLONE_THREAD> jedoch den Schalter B<CLONE_PARENT> (wie in Kernel 2.6.0 und neuer).

note: type: Plain text
en: For a while there was B<CLONE_DETACHED> (introduced in 2.5.32): parent wants no child-exit signal.  In Linux 2.6.2, the need to give this flag together with B<CLONE_THREAD> disappeared.  This flag is still defined, but has no effect.
de: Für eine Weile gab es B<CLONE_DETACHED> (eingeführt in 2.5.32): Elternprozesse wollen kein Ende-Signal des Kindprozesses. In Linux 2.6.2 verschwand die Notwendigkeit, dies zusammen mit B<CLONE_THREAD> zu übergeben. Dieser Schalter ist immer noch definiert, hat aber keine Auswirkungen.

note: type: Plain text
en: On i386, B<clone>()  should not be called through vsyscall, but directly through I<int $0x80>.
de: Auf i386-Architekturen sollte B<clone>() nicht durch vsyscall aufgerufen werden, sondern direkt durch I<int $0x80>.

note: type: SH
en: BUGS
de: FEHLER

note: type: Plain text
en: GNU C library versions 2.3.4 up to and including 2.24 contained a wrapper function for B<getpid>(2)  that performed caching of PIDs.  This caching relied on support in the glibc wrapper for B<clone>(), but limitations in the implementation meant that the cache was not up to date in some circumstances.  In particular, if a signal was delivered to the child immediately after the B<clone>()  call, then a call to B<getpid>(2)  in a handler for the signal could return the PID of the calling process ("the parent"), if the clone wrapper had not yet had a chance to update the PID cache in the child.  (This discussion ignores the case where the child was created using B<CLONE_THREAD>, when B<getpid>(2)  I<should> return the same value in the child and in the process that called B<clone>(), since the caller and the child are in the same thread group.  The stale-cache problem also does not occur if the I<flags> argument includes B<CLONE_VM>.)  To get the truth, it was sometimes necessary to use code such as the following:
de: GNU-C-Bibliotheksversionen 2.3.4 bis einschließlich 2.24 enthielten eine Wrapper-Funktion für B<getpid>(2), die Zwischenspeichern von PIDs vornahm. Dieses Zwischenspeichern beruhte auf der Unterstützung in dem Glibc-Wrapper von B<clone>(), aber Einschränkungen in der Implementierung bedeuteten, dass unter einigen Umständen der Zwischenspeicher nicht aktuell war. Insbesondere wenn ein Signal sofort nach dem B<clone>()-Aufruf an den Kindprozess gesandt wurde, konnte ein Aufruf von B<getpid>(2) in einem Signal-Handler die PID des aufrufenden Prozesses (des »Elternprozesses«) zurückgeben, falls der Clone-Wrapper noch keine Chance hatte den PID-Zwischenspeicher im Kindprozess zu aktualisieren. (Diese Diskussion ignoriert den Fall, dass der Kindprozess mit B<CLONE_THREAD> erstellt wurde, in dem B<getpid>(2) den gleichen Wert im Kindprozess zurückgeben I<sollte> und im Prozess, der B<clone>() aufrief, wie sich der Aufrufende und der Kindprozess in der gleichen Thread-Gruppe befinden. Das Problem des nicht mehr frischen Zwischenspeichers tritt auch auf, wenn das Argument I<flags> B<CLONE_VM> enthält.) Um die Wahrheit zu erfahren, war es manchmal notwendig gewesen, Code wie den folgenden zu verwenden:

note: type: Plain text
en: Because of the stale-cache problem, as well as other problems noted in B<getpid>(2), the PID caching feature was removed in glibc 2.25.
de: Aufgrund des Problems mit dem nicht mehr frischem Zwischenspeicher sowie anderen in B<getpid>(2) bemerkten Problemen, wurde die Funktionalität des PID-Zwischenspeicherns in Glibc 2.25 entfernt.

note: type: SH
en: EXAMPLE
de: BEISPIEL

note: type: Plain text
en: The following program demonstrates the use of B<clone>()  to create a child process that executes in a separate UTS namespace.  The child changes the hostname in its UTS namespace.  Both parent and child then display the system hostname, making it possible to see that the hostname differs in the UTS namespaces of the parent and child.  For an example of the use of this program, see B<setns>(2).
de: Das folgende Programm demonstriert die Benutzung von B<clone>() zum Erzeugen eines Kindprozesses, der in einem separaten UTS-Namensraum ausgeführt wird. Der Kindprozess ändert in seinem UTS-Namensraum den Rechnernamen. Dann zeigen sowohl Eltern- als auch Kindprozess den Rechnernamen des Systems an, wodurch sichtbar wird, dass der Rechnername sich im UTS-Namensraum von Eltern- und Kindprozess unterscheidet. Ein Beispiel für die Verwendung dieses Programms finden Sie in B<setns>(2).

note: type: SS
en: Program source
de: Programmquelltext

note: type: Plain text
en: #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \e
                            } while (0)
de: #define errExit(Nachricht)    do { perror(Nachricht); exit(EXIT_FAILURE); \e
                            } while (0)

note: type: Plain text
en: static int              /* Start function for cloned child */
    childFunc(void *arg)
    {
        struct utsname uts;
de: static int              /* Startfunktion für geklonten Kindprozess */
    childFunc(void *arg)
    {
        struct utsname uts;

note: type: Plain text
en:     /* Change hostname in UTS namespace of child */
de:     /* Rechnername im UTS-Namensraum des Kindprozesses ändern */

note: type: Plain text
en:     /* Retrieve and display hostname */
de:     /* Rechnernamen abfragen und anzeigen */

note: type: Plain text
en:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename in child:  %s\en", uts.nodename);
de:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename im Kindprozess:  %s\en", uts.nodename);

note: type: Plain text
en:     /* Keep the namespace open for a while, by sleeping.
           This allows some experimentation--for example, another
           process might join the namespace. */
de:     /* Der Namensraum wird für eine Weile durch Schlafen offen gehalten.
           Dies ermöglicht etwas zu experimentieren –  zum Beispiel
           kann ein weiterer Prozess dem Namensraum beitreten. */

note: type: Plain text
en:     return 0;           /* Child terminates now */
    }
de:     return 0;           /* Kindprozess wird nun beendet */
    }

note: type: Plain text
en: #define STACK_SIZE (1024 * 1024)    /* Stack size for cloned child */
de: #define STACK_SIZE (1024 * 1024)    /* Stapelspeichergröße für geklonten
                                           Kindprozess */

note: type: Plain text
en: int
    main(int argc, char *argv[])
    {
        char *stack;                    /* Start of stack buffer */
        char *stackTop;                 /* End of stack buffer */
        pid_t pid;
        struct utsname uts;
de: int
    main(int argc, char *argv[])
    {
        char *stack;                    /* Start des Stapelspeicherpuffers */
        char *stackTop;                 /* Ende des Stapelspeicherpuffers */
        pid_t pid;
        struct utsname uts;

note: type: Plain text
en:     if (argc E<lt> 2) {
            fprintf(stderr, "Usage: %s E<lt>child-hostnameE<gt>\en", argv[0]);
            exit(EXIT_SUCCESS);
        }
de:     if (argc E<lt> 2) {
            fprintf(stderr, "Aufruf: %s E<lt>Kindprozess-RechnernameE<gt>\en", argv[0]);
            exit(EXIT_SUCCESS);
        }

note: type: Plain text
en:     /* Allocate stack for child */
de:     /* Stapelspeicher für Kindprozess reservieren */

note: type: Plain text
en:     stack = malloc(STACK_SIZE);
        if (stack == NULL)
            errExit("malloc");
        stackTop = stack + STACK_SIZE;  /* Assume stack grows downward */
de:     stack = malloc(STACK_SIZE);
        if (stack == NULL)
            errExit("malloc");
        stackTop = stack + STACK_SIZE;  /* Annahme, dass Stapelspeicher nach
                                           unten wächst */

note: type: Plain text
en:     /* Create child that has its own UTS namespace;
           child commences execution in childFunc() */
de:     /* Es wird ein Kindprozess erzeugt, der seinen eigenen Namensraum hat.
           Der Kindprozess beginnt die Ausführung in childFunc() */

note: type: Plain text
en:     pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);
        if (pid == -1)
            errExit("clone");
        printf("clone() returned %ld\en", (long) pid);
de:     pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);
        if (pid == -1)
            errExit("clone");
        printf("clone() gab %ld zurück\en", (long) pid);

note: type: Plain text
en:     /* Parent falls through to here */
de:     /* Elternprozess fällt bis hierher durch */

note: type: Plain text
en:     sleep(1);           /* Give child time to change its hostname */
de:     sleep(1);   /* gibt dem Kindprozess Zeit zum Ändern des Rechnernamens */

note: type: Plain text
en:     /* Display hostname in parent\(aqs UTS namespace. This will be
           different from hostname in child\(aqs UTS namespace. */
de:     /* Den Rechnernamen im UTS-Namensraum des Elternprozesses anzeigen.
           Dieser wird sich vom Rechnernamen im UTS-Namensraum des Kindprozesses
           unterscheiden. */

note: type: Plain text
en:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename in parent: %s\en", uts.nodename);
de:     if (uname(&uts) == -1)
            errExit("uname");
        printf("uts.nodename im Elternprozess: %s\en", uts.nodename);

note: type: Plain text
en:     if (waitpid(pid, NULL, 0) == -1)    /* Wait for child */
            errExit("waitpid");
        printf("child has terminated\en");
de:     if (waitpid(pid, NULL, 0) == -1)    /* Warten auf Kindprozess */
            errExit("waitpid");
        printf("Kindprozess wurde beendet\en");

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

note: type: SH
en: COLOPHON
de: KOLOPHON

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.03 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: A signal may be process-directed or thread-directed.  A process-directed signal is targeted at a thread group (i.e., a TGID), and is delivered to an arbitrarily selected thread from among those that are not blocking the signal.  A signal may be process directed because it was generated by the kernel for reasons other than a hardware exception, or because it was sent using B<kill>(2)  or B<sigqueue>(3).  A thread-directed signal is targeted at (i.e., delivered to)  a specific thread.  A signal may be thread directed because it was sent using B<tgkill>(2)  or B<pthread_sigqueue>(3), or because the thread executed a machine language instruction that triggered a hardware exception (e.g., invalid memory access triggering B<SIGSEGV> or a floating-point exception triggering B<SIGFPE>).
de: Ein Signal kann Prozess-orientiert oder Thread-orientiert sein. Ein Prozess-orientiertes Signal kann auf eine Thread-Gruppe (d.h. einer TGID) abzielen und wird an einen beliebig ausgewählten Thread innerhalb dieser, der das Signal nicht blockiert, ausgeliefert. Ein Signal kann Prozess-orientiert sein, da es vom Kernel aus anderen Gründen (neben Hardware-Ausnahmebehandlungen) erstellt wurde oder da mittels B<kill>(2) oder B<sigqueue>(3) gesandt wurde\&. Ein Thread-orientiertes Signal zielt auf ein bestimmten Thread (d.h. wird an ihn ausgeliefert). Ein Signal kann Thread-orientiert sein, da es mittels B<tgkill>(2) oder B<pthread_sigqueue>(3) gesandt wurde oder da der Thread einen Maschinensprachenbefehl ausführte, der eine Hardware-Ausnahmebehandlung auslöste (z.B. löst ein ungültiger Speicherzugriff B<SIGSEGV> oder eine Fließkommaausnahmebehandlung B<SIGFPE> aus).

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.02 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2019-03-06
de: 6. März 2019

note: commit 7eafd7c74c3f2e67c27621b987b28397110d643f https://lwn.net/Articles/312232/ type: Plain text
en: An IPC namespace provides an isolated view of System\ V IPC objects (see B<svipc>(7))  and (since Linux 2.6.30)  POSIX message queues (see B<mq_overview>(7)).  The common characteristic of these IPC mechanisms is that IPC objects are identified by mechanisms other than filesystem pathnames.
de: Ein IPC-Namensraum stellt eine isolierte Ansicht von System-V-IPC-Objekten (siehe B<svipc>(7)) und (seit 2.6.30) POSIX-Nachrichtenwarteschlangen (siehe B<mq_overview>(7)) bereit. Das gemeinsame Merkmal dieser IPC-Mechanismen ist, dass IPC-Objekte durch andere Mechanismen als Dateisystempfadnamen identifiziert werden.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.01 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.
