[RFR] man://manpages-de/po/{info.1,clone.2}

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

Hallo,

anbei die neuen und geänderten 33 Zeichenketten der Handbuchseiten 
info.1. und clone.2. mit der Bitte um Korrektur.

Gruß,
Chris

# ----------------------- info.1 ---------------------------------------------

#. type: Plain text
# FIXME s/as-is/as is/
msgid "(for debugging) use Info file pointers as-is."
msgstr "(zur Fehlersuche) verwendet Info-Dateizeiger in der vorliegenden Form."

#. type: Plain text
msgid ""
"should give you access to the complete manual.  (Or, if you have Emacs, M-x "
"info will lead to the manual.)"
msgstr ""
"sollte Ihnen Zugriff auf das vollständige Handbuch gewähren (oder, falls Sie "
"Emacs haben, wird M-x Sie zum Handbuch führen)."

# ----------------------- clone.2 --------------------------------------------

#. type: Plain text
#, no-wrap
msgid "/* Prototype for the glibc wrapper function */\n"
msgstr "/* Prototyp für die Glibc-Wrapper-Funktion */\n"

#. type: Plain text
#, no-wrap
msgid "/* Prototype for the raw system call */\n"
msgstr "/* Prototyp für den reinen Systemaufruf */\n"

#. type: Plain text
msgid ""
"Feature Test Macro Requirements for glibc wrapper function (see "
"B<feature_test_macros>(7)):"
msgstr ""
"Mit der Glibc-Wrapper-Funktion erforderliche Makros (siehe "
"B<feature_test_macros>(7)):"

#. type: Plain text
#, no-wrap
msgid ""
"_BSD_SOURCE || _SVID_SOURCE\n"
"    /* _GNU_SOURCE also suffices */\n"
msgstr ""
"_BSD_SOURCE || _SVID_SOURCE\n"
"    /* _GNU_SOURCE genügt ebenfalls */\n"

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

#. type: Plain text
msgid ""
"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."
msgstr ""
"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 reinen Systemaufruf werden "
"gegen Ende dieser Seite erläutert."

#.  commit 7eafd7c74c3f2e67c27621b987b28397110d643f
#.  https://lwn.net/Articles/312232/
#. type: Plain text
msgid ""
"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."
msgstr ""
"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 normale Merkmal dieser IPC-Mechanismen ist, "
"dass IPC-Objekte durch andere Mechanismen als Dateisystempfadnamen "
"identifiziert werden."

#. type: SS
#, no-wrap
msgid "The raw system call interface"
msgstr "Die reine Systemschnittstelle"

#. type: Plain text
msgid ""
"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.  Furthermore, the argument order changes.  The raw system call "
"interface on x86 and many other architectures is roughly:"
msgstr ""
"Der B<sys_clone>-Systemaufruf entspricht eher B<fork>(2), der 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. Zudem wird die Reihenfolge der Argumente geändert. Die reine "
"Schnittstelle für Systemaufrufe auf x86 und vielen anderen Architekturen "
"sieht ungefähr so aus:"

#. type: Plain text
msgid ""
"Another difference for the raw system call is that the I<child_stack> "
"argument may be zero, in which case 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."
msgstr ""
"Ein weiterer Unterschied für den reinen Systemaufruf besteht darin, dass das "
"Argument I<kind_stack> Null sein könnte, so dass in diesem Fall "
"»copy-on-write«-Semantik sicherstellt, dass der Kindprozess getrennte Kopien "
"des Stapelspeichers erhält, wenn beide Prozesse den Stapelspeicher verändern. "
"In diesem Fall sollte die Option B<CLONE_VM> nicht angegeben werden, damit es "
"korrekt funktioniert."

#. type: Plain text
msgid ""
"For some architectures, the order of the arguments for the system call "
"differs from that shown above.  On the score, microblaze, ARM, ARM 64, PA-"
"RISC, arc, Power PC, xtensa, and MIPS architectures, the order of the fourth "
"and fifth arguments is reversed.  On the cris and s390 architectures, the "
"order of the first and second arguments is reversed."
msgstr ""
"Für einige Architekturen unterscheidet sich die Reihenfolge der Argumente für "
"den Systemaufruf von der oben gezeigten. In der Masse der MicroBlaze-, ARM-, "
"ARM-64-, PA-RISC-, Arc-, Power-PC-, Xtensa- und MIPS-Architekturen ist die "
"Reihenfolge des vierten und fünften Arguments vertauscht. Auf den Cris- und "
"S390-Architekturen ist die Reihenfolge des ersten und zweiten Arguments "
"vertauscht."

#. type: Plain text
msgid ""
"The argument-passing conventions on blackfin, m68k, and sparc are different "
"from descriptions above.  For details, see the kernel (and glibc) source."
msgstr ""
"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."

#. type: Plain text
msgid ""
"The prototype shown above is for the glibc wrapper function; the raw system "
"call interface has no I<fn> or I<arg> argument, and changes the order of the "
"arguments so that I<flags> is the first argument, and I<tls> is the last "
"argument."
msgstr ""
"Der oben gezeigte Prototyp ist für die Glibc-Wrapper-Funktion. Die reine "
"Systemaufrufschnittstelle hat kein I<fn>- oder I<arg>-Argument und ändert die "
"Reihenfolge der Argumente, so dass I<schalter> das erste und I<tls> das "
"letzte Argument ist."

#. type: SS
#, no-wrap
msgid "Create a child that executes in a separate UTS namespace"
msgstr ""
"Einen Kindprozess erzeugen, der in einem separaten UTS-Namensraum ausgeführt "
"wird"

#. type: Plain text
msgid ""
"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)."
msgstr ""
"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 Hostnamen. Dann zeigen "
"sowohl Eltern- als auch Kindprozess den Hostnamen des Systems an, wodurch "
"sichtbar wird, dass der Hostname sich im UTS-Namensraum von Eltern- und "
"Kindprozess unterscheidet. Ein Beispiel für die Verwendung dieses Programms "
"finden Sie in B<setns>(2)."

#. type: Plain text
#, no-wrap
msgid ""
"static int              /* Start function for cloned child */\n"
"childFunc(void *arg)\n"
"{\n"
"    struct utsname uts;\n"
msgstr ""
"static int              /* Startfunktion für geklonten Kindprozess */\n"
"childFunc(void *arg)\n"
"{\n"
"    struct utsname uts;\n"

#. type: Plain text
#, no-wrap
msgid "    /* Change hostname in UTS namespace of child */\n"
msgstr "    /* Hostname im UTS-Namensraum des Kindprozesses ändern */\n"

#. type: Plain text
#, no-wrap
msgid "    /* Retrieve and display hostname */\n"
msgstr "    /* Hostnamen abfragen und anzeigen */\n"

#. type: Plain text
#, no-wrap
msgid ""
"    if (uname(&uts) == -1)\n"
"        errExit(\"uname\");\n"
"    printf(\"uts.nodename in child:  %s\\en\", uts.nodename);\n"
msgstr ""
"    if (uname(&uts) == -1)\n"
"        errExit(\"uname\");\n"
"    printf(\"uts.nodename im Kindprozess:  %s\\en\", uts.nodename);\n"

#. type: Plain text
#, no-wrap
# FIXME s/--/ -- /
msgid ""
"    /* Keep the namespace open for a while, by sleeping.\n"
"       This allows some experimentation--for example, another\n"
"       process might join the namespace. */\n"
msgstr ""
"    /* Der Namensraum wird für eine Weile durch Schlafen offen gehalten.\n"
"       Dies ermöglicht etwas zu experimentieren â??  zum Beispiel\n"
"       kann ein weiterer Prozess dem Namensraum beitreten. */\n"

#. type: Plain text
#, no-wrap
msgid ""
"    return 0;           /* Child terminates now */\n"
"}\n"
msgstr ""
"    return 0;           /* Kindprozess wird nun beendet */\n"
"}\n"

#. type: Plain text
#, no-wrap
msgid "#define STACK_SIZE (1024 * 1024)    /* Stack size for cloned child */\n"
msgstr ""
"#define STACK_SIZE (1024 * 1024)    /* Stapelspeichergrö�e für geklonten\n"
"                                       Kindprozess */\n"

#. type: Plain text
#, no-wrap
msgid ""
"int\n"
"main(int argc, char *argv[])\n"
"{\n"
"    char *stack;                    /* Start of stack buffer */\n"
"    char *stackTop;                 /* End of stack buffer */\n"
"    pid_t pid;\n"
"    struct utsname uts;\n"
msgstr ""
"int\n"
"main(int argc, char *argv[])\n"
"{\n"
"    char *stack;                    /* Start des Stapelspeicherpuffers */\n"
"    char *stackTop;                 /* Ende des Stapelspeicherpuffers */\n"
"    pid_t pid;\n"
"    struct utsname uts;\n"

#. type: Plain text
#, no-wrap
msgid ""
"    stack = malloc(STACK_SIZE);\n"
"    if (stack == NULL)\n"
"        errExit(\"malloc\");\n"
"    stackTop = stack + STACK_SIZE;  /* Assume stack grows downward */\n"
msgstr ""
"    stack = malloc(STACK_SIZE);\n"
"    if (stack == NULL)\n"
"        errExit(\"malloc\");\n"
"    stackTop = stack + STACK_SIZE;  /* Annahme, dass Stapelspeicher nach\n"
"                                       unten wächst */\n"

#. type: Plain text
#, no-wrap
msgid ""
"    /* Create child that has its own UTS namespace;\n"
"       child commences execution in childFunc() */\n"
msgstr ""
"    /* Es wird ein Kindprozess erzeugt, der seinen eigenen Namensraum hat.\n"
"       Der Kindprozess beginnt die Ausführung in childFunc() */\n"

#. type: Plain text
#, no-wrap
msgid ""
"    pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);\n"
"    if (pid == -1)\n"
"        errExit(\"clone\");\n"
"    printf(\"clone() returned %ld\\en\", (long) pid);\n"
msgstr ""
"    pid = clone(childFunc, stackTop, CLONE_NEWUTS | SIGCHLD, argv[1]);\n"
"    if (pid == -1)\n"
"        errExit(\"clone\");\n"
"    printf(\"clone() gab %ld zurück\\en\", (long) pid);\n"

#. type: Plain text
#, no-wrap
msgid "    /* Parent falls through to here */\n"
msgstr "    /* Elternprozess fällt bis hierher durch */\n"

#. type: Plain text
#, no-wrap
msgid "    sleep(1);           /* Give child time to change its hostname */\n"
msgstr ""
"    sleep(1);      /* gibt dem Kindprozess Zeit zum Ã?ndern des Hostnamens */\n"

#. type: Plain text
#, no-wrap
msgid ""
"    /* Display hostname in parent\\(aqs UTS namespace. This will be\n"
"       different from hostname in child\\(aqs UTS namespace. */\n"
msgstr ""
"    /* Den Hostnamen im UTS-Namensraum des Elternprozesses anzeigen. Dieser\n"
"       wird sich vom Hostnamen im UTS-Namensraum des Kindprozesses\n"
"       unterscheiden. */\n"

#. type: Plain text
#, no-wrap
msgid ""
"    if (uname(&uts) == -1)\n"
"        errExit(\"uname\");\n"
"    printf(\"uts.nodename in parent: %s\\en\", uts.nodename);\n"
msgstr ""
"    if (uname(&uts) == -1)\n"
"        errExit(\"uname\");\n"
"    printf(\"uts.nodename im Elternprozess: %s\\en\", uts.nodename);\n"

#. type: Plain text
#, no-wrap
msgid ""
"    if (waitpid(pid, NULL, 0) == -1)    /* Wait for child */\n"
"        errExit(\"waitpid\");\n"
"    printf(\"child has terminated\\en\");\n"
msgstr ""
"    if (waitpid(pid, NULL, 0) == -1)    /* Warten auf Kindprozess */\n"
"        errExit(\"waitpid\");\n"
"    printf(\"Kindprozess wurde beendet\\en\");\n"