manpages-de - en to de translation catalogue (231 entries)

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

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

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: fcntl - manipulate file descriptor
de: fcntl - Dateideskriptoren manipulieren

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

note: type: Plain text
en: B<int fcntl(int >I<fd>B<, int >I<cmd>B<, ... /* >I<arg>B< */ );>
de: B<int fcntl(int >I<fd>B<, int >I<cmd>B<, … /* >I<arg>B< */ );>

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Plain text
en: B<fcntl>()  performs one of the operations described below on the open file descriptor I<fd>.  The operation is determined by I<cmd>.
de: B<fcntl>() führt eine der unten beschriebenen Aktionen auf dem offenen Dateideskriptor I<fd> aus. Die Aktion wird durch I<cmd> festgelegt.

note: type: Plain text
en: B<fcntl>()  can take an optional third argument.  Whether or not this argument is required is determined by I<cmd>.  The required argument type is indicated in parentheses after each I<cmd> name (in most cases, the required type is I<int>, and we identify the argument using the name I<arg>), or I<void> is specified if the argument is not required.
de: B<fcntl>() kann ein optionales drittes Argument akzeptieren. Ob dieses Argument notwendig ist, ergibt sich durch I<cmd>. Der benötigte Argumenttyp wird nach jedem I<cmd>-Namen in Klammern angedeutet (in den meisten Fällen ist der benötigte Typ I<int> und der Argumenttyp wird mit dem Namen I<arg> identifiziert). Falls das Argument nicht notwendig ist, wird I<void> angegeben.

note: type: Plain text
en: Certain of the operations below are supported only since a particular Linux kernel version.  The preferred method of checking whether the host kernel supports a particular operation is to invoke B<fcntl>()  with the desired I<cmd> value and then test whether the call failed with B<EINVAL>, indicating that the kernel does not recognize this value.
de: Bestimmte der unten aufgeführten Aktionen werden nur seit einer bestimmten Linux-Kernelversion unterstützt. Die bevorzugte Methode, um herauszufinden, ob der Gastkernel eine bestimmte Aktion unterstützt, ist der Aufruf von B<fcntl>() mit dem gewünschten Wert von I<cmd> und dem anschließenden Test, ob der Aufruf mit B<EINVAL> fehlschlug, wodurch angezeigt wird, dass der Kernel diesen Wert nicht unterstützt.

note: type: SS
en: Duplicating a file descriptor
de: Duplizieren eines Dateideskriptors

note: type: Plain text
en: Duplicate the file descriptor I<fd> using the lowest-numbered available file descriptor greater than or equal to I<arg>.  This is different from B<dup2>(2), which uses exactly the file descriptor specified.
de: verdoppelt den Dateideskriptor I<fd> unter Verwendung des Dateideskriptors mit der kleinsten Nummer, die identisch zu oder größer als I<arg> ist. Dies unterscheidet sich von B<dup2>(2), das exakt den angegebenen Dateideskriptor verwendet.

note: type: Plain text
en: On success, the new file descriptor is returned.
de: Bei Erfolg wird der neue Dateideskriptor zurückgegeben.

note: type: Plain text
en: See B<dup>(2)  for further details.
de: Lesen Sie B<dup>(2) für weitere Details.

note: type: TP
en: B<F_DUPFD_CLOEXEC> (I<int>; since Linux 2.6.24)
de: B<F_DUPFD_CLOEXEC> (I<int>; seit Linux 2.6.24)

note: type: Plain text
en: As for B<F_DUPFD>, but additionally set the close-on-exec flag for the duplicate file descriptor.  Specifying this flag permits a program to avoid an additional B<fcntl>()  B<F_SETFD> operation to set the B<FD_CLOEXEC> flag.  For an explanation of why this flag is useful, see the description of B<O_CLOEXEC> in B<open>(2).
de: Wie für B<F_DUPFD>, setzt aber zusätzlich den Schalter »close-on-exec« für den duplizierten Dateideskriptor. Die Angabe dieses Schalters ermöglicht es einem Programm, eine zusätzliche B<fcntl>()-B<F_SETFD>-Aktion zu vermeiden, um den Schalter B<FD_CLOEXEC> zu setzen. Für eine Erläuterung, warum dieser Schalter nützlich ist, lesen Sie die Beschreibung von B<O_CLOEXEC> in B<open>(2).

note: type: SS
en: File descriptor flags
de: Datei-Deskriptor-Schalter

note: type: Plain text
en: The following commands manipulate the flags associated with a file descriptor.  Currently, only one such flag is defined: B<FD_CLOEXEC>, the close-on-exec flag.  If the B<FD_CLOEXEC> bit is set, the file descriptor will automatically be closed during a successful B<execve>(2).  (If the B<execve>(2)  fails, the file descriptor is left open.)  If the B<FD_CLOEXEC> bit is not set, the file descriptor will remain open across an B<execve>(2).
de: Die folgenden Befehle verändern die einem Dateideskriptor zugeordneten Schalter. Derzeit ist nur ein solcher Schalter definiert: B<FD_CLOEXEC>, der »close-on-exec«-Schalter. Falls das B<FD_CLOEXEC>-Bit gesetzt ist, wird der Dateideskriptor automatisch bei einem erfolgreichen B<execve>(2) geschlossen. (Falls der B<execve>(2) fehlschlägt, bleibt der Dateideskriptor offen.) Falls das Bit B<FD_CLOEXEC> nicht gesetzt ist, wird der Dateideskriptor über ein B<execve>(2) hinweg offen bleiben.

note: type: Plain text
en: Return (as the function result) the file descriptor flags; I<arg> is ignored.
de: Liefert (als Ergebnis der Funktion) die Dateideskriptorschalter; I<arg> wird ignoriert.

note: type: Plain text
en: Set the file descriptor flags to the value specified by I<arg>.
de: Setzt den Dateideskriptorschalter auf den durch I<arg> angegebenenen Wert.

note: type: Plain text
en: In multithreaded programs, using B<fcntl>()  B<F_SETFD> to set the close-on-exec flag at the same time as another thread performs a B<fork>(2)  plus B<execve>(2)  is vulnerable to a race condition that may unintentionally leak the file descriptor to the program executed in the child process.  See the discussion of the B<O_CLOEXEC> flag in B<open>(2)  for details and a remedy to the problem.
de: In Programmen mit mehreren Threads ist die Verwendung von B<fcntl>() B<F_SETFD>, um den Schalter »close-on-exec« zum gleichen Zeitpunkt zu setzen, zu dem ein anderer Thread ein B<fork>(2) mit einem B<execve>(2) ausführt, anfällig für einen Ressourcenwettlauf, der unbeabsichtigterweise den Dateideskriptor an das Programm, das im Kindprozess läuft, durchsickern lässt. Siehe die Diskussion des Schalters B<O_CLOEXEC> in B<open>(2) für Details und wie dem Problem abgeholfen werden kann.

note: type: SS
en: File status flags
de: Dateistatusschalter

note: or .BR creat (2), type: Plain text
en: Each open file description has certain associated status flags, initialized by B<open>(2)  and possibly modified by B<fcntl>().  Duplicated file descriptors (made with B<dup>(2), B<fcntl>(F_DUPFD), B<fork>(2), etc.) refer to the same open file description, and thus share the same file status flags.
de: Jede offene Dateideskription hat bestimmte zugeordnete Statusschalter, die durch B<open>(2) initialisiert und möglicherweise durch B<fcntl>() verändert werden. Duplizierte Dateideskriptoren (mit B<dup>(2), B<fcntl>(F_DUPFD), B<fork>(2) usw. erstellte) beziehen sich auf die gleiche offene Dateideskription und teilen sich daher die gleichen Dateistatusschalter.

note: type: Plain text
en: The file status flags and their semantics are described in B<open>(2).
de: Die Dateistatusschalter und deren Bedeutung sind in B<open>(2) beschrieben.

note: type: Plain text
en: Return (as the function result)  the file access mode and the file status flags; I<arg> is ignored.
de: Liefert (als Ergebnis der Funktion) den Dateizugriffsmodus und die Dateistatusschalter; I<arg> wird ignoriert.

note: type: Plain text
en: Set the file status flags to the value specified by I<arg>.  File access mode (B<O_RDONLY>, B<O_WRONLY>, B<O_RDWR>)  and file creation flags (i.e., B<O_CREAT>, B<O_EXCL>, B<O_NOCTTY>, B<O_TRUNC>)  in I<arg> are ignored.  On Linux, this command can change only the B<O_APPEND>, B<O_ASYNC>, B<O_DIRECT>, B<O_NOATIME>, and B<O_NONBLOCK> flags.  It is not possible to change the B<O_DSYNC> and B<O_SYNC> flags; see BUGS, below.
de: Setzt die Dateistatusschalter auf den durch I<arg> festgelegten Wert. Dateizugriffsmodus (B<O_RDONLY>, B<O_WRONLY>, B<O_RDWR>) und Dateierzeugungsschalter (d.h. B<O_CREAT>, B<O_EXCL>, B<O_NOCTTY>, B<O_TRUNC>) werden in I<arg> ignoriert. Unter Linux kann dieser Befehl nur die Schalter B<O_APPEND>, B<O_ASYNC>, B<O_DIRECT>, B<O_NOATIME> und B<O_NONBLOCK> ändern. Es ist nicht möglich, die Schalter B<O_DSYNC> und B<O_SYNC> zu ändern, siehe FEHLER weiter unten.

note: type: SS
en: Advisory record locking
de: Empfohlene Datensatzsperren

note: type: Plain text
en: Linux implements traditional ("process-associated") UNIX record locks, as standardized by POSIX.  For a Linux-specific alternative with better semantics, see the discussion of open file description locks below.
de: Linux implementiert traditionelle (»Prozess-orientierte«) UNIX-Datensatz-Sperren, wie durch POSIX standardisiert. Für eine Linux-spezifische Alternative mit besserer Semantik lesen Sie die Diskussion über offene Dateideskriptions-Sperren unten.

note: type: Plain text
en: B<F_SETLK>, B<F_SETLKW>, and B<F_GETLK> are used to acquire, release, and test for the existence of record locks (also known as byte-range, file-segment, or file-region locks).  The third argument, I<lock>, is a pointer to a structure that has at least the following fields (in unspecified order).
de: B<F_SETLK>, B<F_SETLKW> und B<F_GETLK> werden dazu verwandt, Datensatzsperren (auch bekannt als Byte-Bereichs-, Dateisegment- oder Dateiregionsperren) zu erlangen, abzugeben oder auf deren Existenz zu prüfen. Das dritte Argument, I<lock>, ist ein Zeiger auf eine Struktur, die mindestens die folgende Felder (in einer nicht festgelegten Reihenfolge) enthält:

note: type: Plain text
en: struct flock {
        ...
        short l_type;    /* Type of lock: F_RDLCK,
                            F_WRLCK, F_UNLCK */
        short l_whence;  /* How to interpret l_start:
                            SEEK_SET, SEEK_CUR, SEEK_END */
        off_t l_start;   /* Starting offset for lock */
        off_t l_len;     /* Number of bytes to lock */
        pid_t l_pid;     /* PID of process blocking our lock
                            (set by F_GETLK and F_OFD_GETLK) */
        ...
    };
de: struct flock {
        …
        short l_type;    /* Art der Sperre: F_RDLCK,
                            F_WRLCK, F_UNLCK */
        short l_whence;  /* Wie l_start interpretiert wird:
                            SEEK_SET, SEEK_CUR, SEEK_END */
        off_t l_start;   /* Anfangsversatz für Sperre */
        off_t l_len;     /* Anzahl von zu sperrenden Bytes */
        pid_t l_pid;     /* PID des Prozesses, der unsere Sperre blockiert
                            (gesetzt durch F_GETLK und F_OFD_GETLK) */
        …
    };

note: type: Plain text
en: The I<l_whence>, I<l_start>, and I<l_len> fields of this structure specify the range of bytes we wish to lock.  Bytes past the end of the file may be locked, but not bytes before the start of the file.
de: Die Felder I<l_whence>, I<l_start> und I<l_len> dieser Struktur legen den Bereich der Bytes, die gesperrt werden sollen, fest. Bytes hinter dem Ende der Datei können gesperrt sein, aber Bytes vor dem Anfang der Datei sind es nicht.

note: type: Plain text
en: I<l_start> is the starting offset for the lock, and is interpreted relative to either: the start of the file (if I<l_whence> is B<SEEK_SET>); the current file offset (if I<l_whence> is B<SEEK_CUR>); or the end of the file (if I<l_whence> is B<SEEK_END>).  In the final two cases, I<l_start> can be a negative number provided the offset does not lie before the start of the file.
de: I<l_start> ist der Startversatz für die Sperre und wird relativ zu einem der folgenden interpretiert: Dem Anfang der Datei (falls I<l_whence> B<SEEK_SET> ist) oder dem Ende der Datei (falls I<l_whence> B<SEEK_END> ist). In den abschließenden zwei Fällen kann I<l_start> eine negative Zahl sein, vorausgesetzt, der Versatz liegt nicht vor dem Anfang der Datei.

note: type: Plain text
en: I<l_len> specifies the number of bytes to be locked.  If I<l_len> is positive, then the range to be locked covers bytes I<l_start> up to and including I<l_start>+I<l_len>-1.  Specifying 0 for I<l_len> has the special meaning: lock all bytes starting at the location specified by I<l_whence> and I<l_start> through to the end of file, no matter how large the file grows.
de: I<l_len> legt die Anzahl der zu sperrenden Bytes fest. Falls I<l_len> positiv ist, wird der zu sperrende Bereich die Bytes I<l_start> bis einschließlich I<l_start>+I<l_len>-1 umfassen. Die Angabe von 0 für I<l_len> hat eine besondere Bedeutung: Alle Bytes beginnend bei I<l_whence> und I<l_start> bis zum Ende der Datei sperren, unabhängig davon, wie groß die Datei anwächst.

note: type: Plain text
en: POSIX.1-2001 allows (but does not require)  an implementation to support a negative I<l_len> value; if I<l_len> is negative, the interval described by I<lock> covers bytes I<l_start>+I<l_len> up to and including I<l_start>-1.  This is supported by Linux since kernel versions 2.4.21 and 2.5.49.
de: POSIX.1-2001 erlaubt (verlangt es aber nicht), dass eine Implementierung einen negativen Wert für I<l_len> unterstützt. Falls I<l_len> negativ ist, deckt das durch I<lock> beschriebene Intervall die Bytes I<l_start>+I<l_len> bis zu einschließlich I<l_start>-1 ab. Dies wird durch Linux seit Kernelversion 2.4.21 and 2.5.49 unterstützt.

note: type: Plain text
en: The I<l_type> field can be used to place a read (B<F_RDLCK>)  or a write (B<F_WRLCK>)  lock on a file.  Any number of processes may hold a read lock (shared lock)  on a file region, but only one process may hold a write lock (exclusive lock).  An exclusive lock excludes all other locks, both shared and exclusive.  A single process can hold only one type of lock on a file region; if a new lock is applied to an already-locked region, then the existing lock is converted to the new lock type.  (Such conversions may involve splitting, shrinking, or coalescing with an existing lock if the byte range specified by the new lock does not precisely coincide with the range of the existing lock.)
de: Das Feld I<l_type> kann dazu verwandt werden, eine Lese- (B<F_RDLCK>) oder Schreibsperre (B<F_WRLCK>) auf eine Datei zu setzen. Eine beliebige Anzahl an Prozessen kann eine Lesesperre auf eine Dateiregion halten (gemeinsame Sperre), aber nur ein Prozess kann eine Schreibsperre (exklusive Sperre) halten. Eine exklusive Sperre sperrt alle anderen Sperren aus, sowohl exklusive als auch gemeinsame. Ein einzelner Prozess kann nur eine Art von Sperre auf eine Dateiregion halten. Falls eine neue Sperre auf eine bereits gesperrte Region angewandt wird, wird die existierende Sperre in den Typ der neuen Sperre umgewandelt. (Solche Umwandlungen können das Teilen, Verkleinern, Vereinigen mit bestehenden Sperren beinhalten, falls der durch die neue Sperre festgelegte Byte-Bereiche nicht genau mit dem Bereich der bereits existierenden Sperre zusammenfällt.)

note: type: Plain text
en: Acquire a lock (when I<l_type> is B<F_RDLCK> or B<F_WRLCK>)  or release a lock (when I<l_type> is B<F_UNLCK>)  on the bytes specified by the I<l_whence>, I<l_start>, and I<l_len> fields of I<lock>.  If a conflicting lock is held by another process, this call returns -1 and sets I<errno> to B<EACCES> or B<EAGAIN>.  (The error returned in this case differs across implementations, so POSIX requires a portable application to check for both errors.)
de: Erlangt (wenn I<l_type> B<F_RDLCK> oder B<F_WRLCK> ist) oder gibt eine Sperre (wenn I<l_type> B<F_UNLCK> ist) für die durch die Felder I<l_whence>, I<l_start> und I<l_len> von I<lock> festgelegten Bytes ab. Falls durch einen anderen Prozess eine im Konflikt stehende Sperre gehalten wird, liefert dieser Aufruf -1 zurück und setzt I<errno> auf B<EACCES> oder B<EAGAIN>. (Der in diesem Fall zurückgelieferte Fehler unterscheidet sich zwischen Implementierungen, daher verlangt POSIX, dass portable Anwendungen auf beide Fehler prüfen.)

note: type: Plain text
en: As for B<F_SETLK>, but if a conflicting lock is held on the file, then wait for that lock to be released.  If a signal is caught while waiting, then the call is interrupted and (after the signal handler has returned)  returns immediately (with return value -1 and I<errno> set to B<EINTR>; see B<signal>(7)).
de: Wie für B<F_SETLK>, aber bei Konflikten um eine Sperre auf die Datei wird auf die Freigabe der Sperre gewartet. Falls während des Wartens ein Signal abgefangen wird, dann wird der Aufruf unterbrochen und (nachdem der Signalbearbeiter zurückgekehrt ist) sofort zurückgekehrt (mit dem Rückgabewert -1 und I<errno> auf B<EINTR> gesetzt; siehe B<signal>(7)).

note: type: Plain text
en: On input to this call, I<lock> describes a lock we would like to place on the file.  If the lock could be placed, B<fcntl>()  does not actually place it, but returns B<F_UNLCK> in the I<l_type> field of I<lock> and leaves the other fields of the structure unchanged.
de: Als Eingabe zu diesem Aufruf beschreibt I<lock> eine Sperre, die auf diese Datei angewandt werden soll. Falls die Sperre angewandt werden könnte, setzt B<fcntl>() diese nicht wirklich, sondern liefert B<F_UNLCK> in dem Feld I<l_type> von I<lock> und lässt die anderen Felder dieser Struktur unverändert.

note: type: Plain text
en: If one or more incompatible locks would prevent this lock being placed, then B<fcntl>()  returns details about one of those locks in the I<l_type>, I<l_whence>, I<l_start>, and I<l_len> fields of I<lock>.  If the conflicting lock is a traditional (process-associated) record lock, then the I<l_pid> field is set to the PID of the process holding that lock.  If the conflicting lock is an open file description lock, then I<l_pid> is set to -1.  Note that the returned information may already be out of date by the time the caller inspects it.
de: Falls eine oder mehrere inkompatible Sperren das Setzen dieser Sperre verhinderten, dann liefert B<fcntl>() Details über eine dieser Sperren in den Feldern I<l_type>, I<l_whence>, I<l_start> und I<l_len> von I<lock> zurück. Falls die im Konflikt stehende Sperre eine traditionelle (Prozess-orientierte) Datensatzsperre ist, dann wird das Feld I<l_pid> auf die PID des Prozesses gesetzt, der die Sperre hält. Falls die in Konflikt stehende Sperre eine offene Dateideskriptionssperre ist, dann wird I<l_pid> auf -1 gesetzt. Beachten Sie, dass die zurückgelieferte Information zum Zeitpunkt der Analyse durch den Aufrufenden bereits veraltet sein kann.

note: type: Plain text
en: In order to place a read lock, I<fd> must be open for reading.  In order to place a write lock, I<fd> must be open for writing.  To place both types of lock, open a file read-write.
de: Um eine Lesesperre zu setzen, muss I<fd> zum Lesen offen sein. Um eine Schreibsperre zu setzen, muss I<fd> zum Schreiben offen sein. Um beide Typen setzen zu können, öffnen Sie eine Datei lese- und schreibbar.

note: type: Plain text
en: When placing locks with B<F_SETLKW>, the kernel detects I<deadlocks>, whereby two or more processes have their lock requests mutually blocked by locks held by the other processes.  For example, suppose process A holds a write lock on byte 100 of a file, and process B holds a write lock on byte 200.  If each process then attempts to lock the byte already locked by the other process using B<F_SETLKW>, then, without deadlock detection, both processes would remain blocked indefinitely.  When the kernel detects such deadlocks, it causes one of the blocking lock requests to immediately fail with the error B<EDEADLK>; an application that encounters such an error should release some of its locks to allow other applications to proceed before attempting regain the locks that it requires.  Circular deadlocks involving more than two processes are also detected.  Note, however, that there are limitations to the kernel's deadlock-detection algorithm; see BUGS.
de: Wenn Sperren mit B<F_SETLKW> gesetzt werden, erkennt der Kernel I<Verklemmungen>, bei denen zwei oder mehr Prozesse ihre Sperr-Anfragen gegenseitig durch Sperren, die von anderen Prozessen gehalten werden, blockieren. Nehmen Sie beispielsweise an, Prozess A hält eine Schreibsperre auf Byte 100 einer Datei und Prozess B hält eine Schreibsperre auf Byte 200. Falls jeder Prozess dann versucht, mit B<F_SETLKW> die vom anderen Prozess bereits gesperrten Bytes zu sperren, würden ohne Erkennung von Verklemmungen beide Prozesse unbegrenzt blockiert bleiben. Wenn der Kernel solche Verklemmungen erkennt, sorgt er dafür, dass eine der blockierenden Sperranfragen sofort mit dem Fehler B<EDEADLK> fehlschlägt. Eine Anwendung, die auf einen solchen Fehler trifft, sollte einige ihrer Sperren freigeben, um anderen Anwendungen das Fortfahren zu erlauben, bevor sie erneut versucht, die von ihr benötigten Sperren zu erlangen. Zirkuläre Verklemmungen mit mehr als zwei Prozessen werden auch erkannt. Beachten Sie aber, dass es eine Begrenzung der Erkennung von Verklemmungen im Kernel gibt; siehe FEHLER.

note: type: Plain text
en: As well as being removed by an explicit B<F_UNLCK>, record locks are automatically released when the process terminates.
de: Datensatzsperren werden durch ein explizites B<F_UNLCK> entfernt und auch freigegeben, wenn der Prozess sich beendet.

note: type: Plain text
en: Record locks are not inherited by a child created via B<fork>(2), but are preserved across an B<execve>(2).
de: Datensatzsperren werden nicht von einem durch B<fork>(2) erstellten Kind geerbt, aber über ein B<execve>(2) hinweg erhalten.

note: type: Plain text
en: Because of the buffering performed by the B<stdio>(3)  library, the use of record locking with routines in that package should be avoided; use B<read>(2)  and B<write>(2)  instead.
de: Aufgrund des durch die B<stdio>(3)-Bibliothek durchgeführten Pufferns sollte die Verwendung von Datensatzsperren mit Routinen aus diesem Paket vermieden werden; verwenden Sie stattdessen B<read>(2) und B<write>(2).

note: type: Plain text
en: The record locks described above are associated with the process (unlike the open file description locks described below).  This has some unfortunate consequences:
de: Die weiter oben beschriebenen Datensatzsperren werden dem Prozess zugeordnet (anders als die weiter unten beschriebenen Dateideskriptionssperren). Dies hat einige unglückliche Konsequenzen:

note: (Additional file descriptors referring to the same file may have been obtained by calls to .BR open "(2), " dup "(2), " dup2 "(2), or " fcntl ().) type: Plain text
en: If a process closes I<any> file descriptor referring to a file, then all of the process's locks on that file are released, regardless of the file descriptor(s) on which the locks were obtained.  This is bad: it means that a process can lose its locks on a file such as I</etc/passwd> or I</etc/mtab> when for some reason a library function decides to open, read, and close the same file.
de: Falls ein Prozess I<irgendeinen> Dateideskriptor mit Bezug zu einer Datei schließt, dann werden alle Sperren des Prozesses für diese Datei aufgehoben, unabhängig von den Dateideskriptor(en), mit denen diese Sperren erworben wurden. Das ist schlecht: Es bedeutet, dass ein Prozess seine Sperren auf eine Datei wie I</etc/passwd> oder I</etc/mtab> verlieren kann, wenn aus irgendeinem Grund eine Bibliotheksfunktion sich entscheidet, die gleiche Datei zu öffnen, zu lesen und zu schließen.

note: type: Plain text
en: The threads in a process share locks.  In other words, a multithreaded program can't use record locking to ensure that threads don't simultaneously access the same region of a file.
de: Die Threads in einem Prozess nutzen die Sperren gemeinsam. Mit anderen Worten, ein Programm mit mehreren Threads kann Datensatzsperren nicht benutzen, um sicherzustellen, dass die Threads nicht simultan auf die gleichen Regionen einer Datei zugreifen.

note: type: Plain text
en: Open file description locks solve both of these problems.
de: Offene Dateideskriptionssperren lösen beide Probleme.

note: type: SS
en: Open file description locks (non-POSIX)
de: Offene Dateideskriptionssperren (nicht POSIX)

note: FIXME . Review progress into POSIX http://austingroupbugs.net/view.php?id=768 type: Plain text
en: Open file description locks are advisory byte-range locks whose operation is in most respects identical to the traditional record locks described above.  This lock type is Linux-specific, and available since Linux 3.15.  (There is a proposal with the Austin Group to include this lock type in the next revision of POSIX.1.)  For an explanation of open file descriptions, see B<open>(2).
de: Offene Dateideskriptionsperren sind empfohlene Byte-Bereichssperren, deren Funktionsweise in den meisten Aspekten den herkömmlichen, oben beschriebenen Datensatzsperren entspricht. Dieser Sperrtyp ist Linux-spezifisch und seit Linux 3.15 verfügbar. (Es gibt einen Vorschlag der Austin-Gruppe, diesen Sperrtyp in die nächste Überarbeitung von POSIX.1 aufzunehmen.) Eine Erklärung offener Dateideskriptionen finden Sie in B<open>(2).

note: type: Plain text
en: The principal difference between the two lock types is that whereas traditional record locks are associated with a process, open file description locks are associated with the open file description on which they are acquired, much like locks acquired with B<flock>(2).  Consequently (and unlike traditional advisory record locks), open file description locks are inherited across B<fork>(2)  (and B<clone>(2)  with B<CLONE_FILES>), and are only automatically released on the last close of the open file description, instead of being released on any close of the file.
de: Der Hauptunterschied zwischen den beiden Sperrtypen besteht darin, dass die herkömmlichen Datensatzsperren mit einem Prozess verbunden sind, während Sperren offener Dateideskriptionen mit der offenen Dateideskription verbunden sind, für die sie erlangt wurden, ähnlich wie Sperren, die mit B<flock>(2) erlangt wurden. Konsequenterweise (und anders als herkömmliche empfohlene Datensatzsperren) werden Sperren offener Dateideskriptionen über B<fork>(2) (und B<clone>(2) mit B<CLONE_FILES>) geerbt und werden nur automatisch durch das Schließen der letzten offenen Dateideskription freigegeben, statt bei jedem Schließen der Datei.

note: type: Plain text
en: Conflicting lock combinations (i.e., a read lock and a write lock or two write locks)  where one lock is an open file description lock and the other is a traditional record lock conflict even when they are acquired by the same process on the same file descriptor.
de: Im Konflikt stehende Kombinationen von Sperren (d.h. eine Lese-Sperre und eine Schreib-Sperre oder zwei Schreib-Sperren), wobei eine Sperre eine offene Dateideskriptionssperre und die andere eine traditionelle Datensatzsperre ist, sind selbst dann im Konflikt, wenn sie vom gleichen Prozess auf dem gleichen Dateideskriptor aufgenommen wurden.

note: type: Plain text
en: Open file description locks placed via the same open file description (i.e., via the same file descriptor, or via a duplicate of the file descriptor created by B<fork>(2), B<dup>(2), B<fcntl>()  B<F_DUPFD>, and so on) are always compatible: if a new lock is placed on an already locked region, then the existing lock is converted to the new lock type.  (Such conversions may result in splitting, shrinking, or coalescing with an existing lock as discussed above.)
de: Offene Dateideskriptionssperren, die über die gleichen offenen Dateideskriptionen (d.h. über den gleichen Dateideskriptor oder über durch B<fork>(2), B<dup>(2), B<fcntl>() B<F_DUPFD> und so weiter erstellte Duplikate des Dateideskriptors) gesetzt werden, sind immer kompatibel: Falls auf einen bereits gesperrten Bereich eine neue Sperre gesetzt wird, wird die existierende Sperre in den neuen Sperrtyp umgewandelt. (Solche Umwandlungen können wie oben beschrieben zum Teilen, Verkleinern oder Verschmelzen mit einer existierenden Sperre führen.)

note: type: Plain text
en: On the other hand, open file description locks may conflict with each other when they are acquired via different open file descriptions.  Thus, the threads in a multithreaded program can use open file description locks to synchronize access to a file region by having each thread perform its own B<open>(2)  on the file and applying locks via the resulting file descriptor.
de: Auf der anderen Seite können offene Dateideskriptionssperren zueinander im Konflikt stehen, wenn sie über verschiedene offene Dateideskriptionen erlangt wurden. Daher können die Threads in einem Programm mit mehreren Threads offene Dateideskriptionssperren dazu verwenden, um den Zugriff auf Dateiregionen zu koordinieren, indem jeder Thread sein eigenes B<open>(2) auf der Datei durchführt und die Sperren über den entstehenden Dateideskriptor anwendet.

note: type: Plain text
en: As with traditional advisory locks, the third argument to B<fcntl>(), I<lock>, is a pointer to an I<flock> structure.  By contrast with traditional record locks, the I<l_pid> field of that structure must be set to zero when using the commands described below.
de: Wie bei herkömmlichen empfohlenen Sperren ist das dritte Argument für B<fcntl>(), I<lock>, ein Zeiger auf eine I<flock>-Struktur. Im Gegensatz zu herkömmlichen Datensatzsperren muss das Feld I<l_pid> dieser Struktur bei Verwendung der unterhalb beschriebenen Befehle auf Null gesetzt werden.

note: type: Plain text
en: The commands for working with open file description locks are analogous to those used with traditional locks:
de: Die Befehle für den Umgang mit offenen Dateideskriptionssperren sind analog zu denen, die mit traditionellen Sperren verwandt werden:

note: type: Plain text
en: Acquire an open file description lock (when I<l_type> is B<F_RDLCK> or B<F_WRLCK>)  or release an open file description lock (when I<l_type> is B<F_UNLCK>)  on the bytes specified by the I<l_whence>, I<l_start>, and I<l_len> fields of I<lock>.  If a conflicting lock is held by another process, this call returns -1 and sets I<errno> to B<EAGAIN>.
de: Erlangt eine offene Dateideskriptionssperre (wenn I<l_type> B<F_RDLCK> oder B<F_WRLCK> ist) oder gibt eine offene Dateideskriptionssperre frei (wenn I<l_type> B<F_UNLCK> ist), für die Bytes, die durch die Felder I<l_whence>, I<l_start> und I<l_len> festgelegt sind. Falls durch einen anderen Prozess eine im Konflikt stehende Sperre gehalten wird, liefert der Aufruf -1 zurück und setzt I<errno> auf B<EAGAIN>.

note: type: Plain text
en: As for B<F_OFD_SETLK>, but if a conflicting lock is held on the file, then wait for that lock to be released.  If a signal is caught while waiting, then the call is interrupted and (after the signal handler has returned) returns immediately (with return value -1 and I<errno> set to B<EINTR>; see B<signal>(7)).
de: Wie bei B<F_OFD_SETLK>, aber falls eine im Konflikt stehende Sperre auf der Datei gehalten wird, dann wird auf die Freigabe dieser Sperre gewartet. Falls beim Warten ein Signal gefangen wird, dann wird der Aufruf unterbrochen und (nachdem der Signal-Handler zurückgekehrt ist) sofort zurückgekehrt (mit einem Rückgabewert -1 und I<errno> auf B<EINTR> gesetzt, siehe B<signal>(7)).

note: type: Plain text
en: On input to this call, I<lock> describes an open file description lock we would like to place on the file.  If the lock could be placed, B<fcntl>()  does not actually place it, but returns B<F_UNLCK> in the I<l_type> field of I<lock> and leaves the other fields of the structure unchanged.  If one or more incompatible locks would prevent this lock being placed, then details about one of these locks are returned via I<lock>, as described above for B<F_GETLK>.
de: Bei der Eingabe zu diesem Aufruf beschreibt I<lock> eine offene Dateideskriptionssperre, die auf der Datei gesetzt werden soll. Falls die Sperre gesetzt werden könnte, setzt sie B<fcntl>() nicht wirklich, sondern liefert im Feld I<l_type> von I<lock> B<F_UNLCK> zurück und lässt die anderen Felder der Struktur unverändert. Falls eine oder mehrere inkompatible Sperren das Setzen dieser Sperre behinderten, werden die Details über eine dieser Sperren mittels I<lock>, wie oben für B<F_GETLK> beschrieben, zurückgeliefert.

note: commit 57b65325fe34ec4c917bc4e555144b4a94d9e1f7 type: Plain text
en: In the current implementation, no deadlock detection is performed for open file description locks.  (This contrasts with process-associated record locks, for which the kernel does perform deadlock detection.)
de: In der aktuellen Implementierung wird nicht auf Verklemmungen für offene Dateideskriptionssperren geprüft. (Dies steht im Gegensatz zu den prozessorientierten Datensatzsperren, bei denen der Kernel eine Erkennung von Verklemmungen durchführt.)

note: type: SS
en: Mandatory locking
de: Pflichtsperren

note: type: Plain text
en: I<Warning>: the Linux implementation of mandatory locking is unreliable.  See BUGS below.  Because of these bugs, and the fact that the feature is believed to be little used, since Linux 4.5, mandatory locking has been made an optional feature, governed by a configuration option (B<CONFIG_MANDATORY_FILE_LOCKING>).  This is an initial step toward removing this feature completely.
de: I<Warnung>: Die Linux-Implementierung der Pflichtsperren ist unzuverlässig. Siehe FEHLER unten. Aufgrund dieser Fehler und der Tatsache, dass davon ausgegangen wird, dass diese Funktionalität wenig genutzt wird, sind die Pflichtsperren seit Linux 4.5 eine optionale Funktionalität, die durch eine Konfigurationsoption (B<CONFIG_MANDATORY_FILE_LOCKING>) gesteuert werden. Dies ist der erste Schritt hin zur kompletten Entfernung dieser Funktionalität.

note: type: Plain text
en: By default, both traditional (process-associated) and open file description record locks are advisory.  Advisory locks are not enforced and are useful only between cooperating processes.
de: Standardmäßig sind herkömmliche (prozessorientierte) und Sperren offener Dateideskriptionsdatensätze empfohlene Sperren. Empfohlene Sperren werden nicht erzwungen und sind nur bei der Zusammenarbeit von Prozessen nützlich.

note: type: Plain text
en: Both lock types can also be mandatory.  Mandatory locks are enforced for all processes.  If a process tries to perform an incompatible access (e.g., B<read>(2)  or B<write>(2))  on a file region that has an incompatible mandatory lock, then the result depends upon whether the B<O_NONBLOCK> flag is enabled for its open file description.  If the B<O_NONBLOCK> flag is not enabled, then the system call is blocked until the lock is removed or converted to a mode that is compatible with the access.  If the B<O_NONBLOCK> flag is enabled, then the system call fails with the error B<EAGAIN>.
de: Beide Sperrtypen können auch verpflichtend sein. Verpflichtende Sperren werden für alle Prozesse durchgesetzt. Falls ein Prozess einen inkompatiblen Zugriff auf einen Dateibereich versucht (z.B. B<read>(2) oder B<write>(2)), der eine inkompatible verpflichtende Sperre hat, dann hängt das Ergebnis davon ab, ob der Schalter B<O_NONBLOCK> für seine offene Dateideskription aktiviert ist. Falls der Schalter B<O_NONBLOCK> nicht aktiviert ist, wird der Systemaufruf blockiert, bis die Sperre entfernt oder in einen Modus umgewandelt wurde, der mit dem Zugriff kompatibel ist. Falls der Schalter B<O_NONBLOCK> aktiviert ist, wird der Systemaufruf mit dem Fehler B<EAGAIN> fehlschlagen.

note: type: Plain text
en: To make use of mandatory locks, mandatory locking must be enabled both on the filesystem that contains the file to be locked, and on the file itself.  Mandatory locking is enabled on a filesystem using the "-o mand" option to B<mount>(8), or the B<MS_MANDLOCK> flag for B<mount>(2).  Mandatory locking is enabled on a file by disabling group execute permission on the file and enabling the set-group-ID permission bit (see B<chmod>(1)  and B<chmod>(2)).
de: Um verpflichtende Sperren zu verwenden, müssen verpflichtende Sperren sowohl auf dem Dateisystem, das die zu sperrende Datei enthält, aktiviert werden als auch auf der Datei selbst. Verpflichtende Sperren werden auf Dateisystemen mit der Option »-o mand« von B<mount>(8) oder dem Schalter B<MS_MANDLOCK> für B<mount>(2) aktiviert. Verpflichtende Sperren werden für eine Datei aktiviert, indem das Ausführrecht für die Datei entfernt und das »set-group-ID«-Rechte-Bit aktiviert wird (siehe B<chmod>(1) und B<chmod>(2)).

note: type: Plain text
en: Mandatory locking is not specified by POSIX.  Some other systems also support mandatory locking, although the details of how to enable it vary across systems.
de: Verpflichtende Sperren werden nicht durch POSIX spezifiziert. Einige andere Systeme unterstützen auch verpflichtende Sperren, allerdings unterscheiden sich die Details zur Aktivierung zwischen den Systemen.

note: type: SS
en: Lost locks
de: Verlorene Sperren

note: type: Plain text
en: When an advisory lock is obtained on a networked filesystem such as NFS it is possible that the lock might get lost.  This may happen due to administrative action on the server, or due to a network partition (i.e., loss of network connectivity with the server)  which lasts long enough for the server to assume that the client is no longer functioning.
de: Wenn eine empfohlene Sperre auf einem Netzwerkdateisystem wie NFS erlangt wird, ist es möglich, dass die Sperre verloren geht. Die kann aufgrund administrativer Aktionen auf dem Server oder aufgrund einer Netzwerkeinteilung (d.h. einem Verlust der Netzverbindung mit dem Server) passieren, die so lange dauert, dass der Server annimmt, dass der Client nicht mehr funktioniert.

note: commit ef1820f9be27b6ad158f433ab38002ab8131db4d type: Plain text
en: When the filesystem determines that a lock has been lost, future B<read>(2)  or B<write>(2)  requests may fail with the error B<EIO>.  This error will persist until the lock is removed or the file descriptor is closed.  Since Linux 3.12, this happens at least for NFSv4 (including all minor versions).
de: Wenn das Dateisystem ermittelt, dass eine Sperre verloren gegangen ist, können zukünftige B<read>(2)- oder B<write>(2)-Anfragen mit dem Fehler B<EIO> fehlschlagen. Dieser Fehler wird beibehalten, bis die Sperre entfernt oder der Dateideskriptor geschlossen wird. Seit Linux 3.12 passiert dies zumindest auf NFSv4 (einschließlich aller Unterversionen).

note: type: Plain text
en: Some versions of UNIX send a signal (B<SIGLOST>)  in this circumstance.  Linux does not define this signal, and does not provide any asynchronous notification of lost locks.
de: Einige UNIX-Versionen senden in diesen Fällen ein Signal (B<SIGLOST>). Linux definiert dieses Signal nicht und stellt keine asynchrone Benachrichtigung über verlorene Sperren bereit.

note: type: SS
en: Managing signals
de: Signale verwalten

note: type: Plain text
en: B<F_GETOWN>, B<F_SETOWN>, B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_GETSIG> and B<F_SETSIG> are used to manage I/O availability signals:
de: B<F_GETOWN>, B<F_SETOWN>, B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_GETSIG> und B<F_SETSIG> werden zur Verwaltung der E/A-Verfügbarkeitssignale verwandt:

note: type: Plain text
en: Return (as the function result)  the process ID or process group currently receiving B<SIGIO> and B<SIGURG> signals for events on file descriptor I<fd>.  Process IDs are returned as positive values; process group IDs are returned as negative values (but see BUGS below).  I<arg> is ignored.
de: Liefert (als Funktionsergebnis) die Prozesskennung oder Prozessgruppe zurück, die derzeit B<SIGIO>- und B<SIGURG>-Signale für Ereignisse auf Dateideskriptor I<fd> erhält. Prozesskennungen werden als positive Werte, Prozessgruppenkennungen als negative Werte zurückgeliefert (siehe aber auch FEHLER unten). I<arg> wird ignoriert.

note: type: Plain text
en: Set the process ID or process group ID that will receive B<SIGIO> and B<SIGURG> signals for events on the file descriptor I<fd>.  The target process or process group ID is specified in I<arg>.  A process ID is specified as a positive value; a process group ID is specified as a negative value.  Most commonly, the calling process specifies itself as the owner (that is, I<arg> is specified as B<getpid>(2)).
de: Setzt die Prozesskennung oder Prozessgruppenkennung, die B<SIGIO>- und B<SIGURG>-Signale für Ereignisse auf dem Dateideskriptor I<fd> erhalten wird. Der Zielprozess oder die Zielprozessgruppe wird in I<arg> festgelegt. Eine Prozesskennung wird als positiver, eine Prozessgruppenkennung wird als negativer Wert festgelegt. Häufig legt sich der aufrufende Prozess als der Eigentümer fest (d.h. I<arg> wird als B<getpid>(2) festgelegt).

note: type: Plain text
en: As well as setting the file descriptor owner, one must also enable generation of signals on the file descriptor.  This is done by using the B<fcntl>()  B<F_SETFL> command to set the B<O_ASYNC> file status flag on the file descriptor.  Subsequently, a B<SIGIO> signal is sent whenever input or output becomes possible on the file descriptor.  The B<fcntl>()  B<F_SETSIG> command can be used to obtain delivery of a signal other than B<SIGIO>.
de: Neben dem Setzen des Dateideskriptoreigentümers muss auch die Erzeugung von Signalen auf dem Dateideskriptor aktiviert werden. Dies erfolgt durch den Befehl B<fcntl>() B<F_SETFL>, um den Dateistatusschalter B<SIGIO> zu setzen, immer wenn Ein- oder Ausgabe auf dem Dateideskriptor möglich wird. Der Befehl B<fcntl>() B<F_SETSIG> kann zum Erhalt des Empfangs von Signalen neben B<SIGIO> verwandt werden.

note: type: Plain text
en: Sending a signal to the owner process (group) specified by B<F_SETOWN> is subject to the same permissions checks as are described for B<kill>(2), where the sending process is the one that employs B<F_SETOWN> (but see BUGS below).  If this permission check fails, then the signal is silently discarded.  I<Note>: The B<F_SETOWN> operation records the caller's credentials at the time of the B<fcntl>()  call, and it is these saved credentials that are used for the permission checks.
de: Senden von Signalen an den durch B<F_SETOWN> festgelegten Prozesseigner (Gruppe) unterliegt den gleichen Rechteprüfungen wie sie in B<kill>(2) beschrieben sind, wobei der sendende Prozess derjenige ist, der B<F_SETOWN> einsetzt (siehe aber FEHLER unten). Falls diese Rechteprüfung fehlschlägt, wird das Signal ohne Rückmeldung verworfen. I<Hinweis>: Die Aktion B<F_SETOWN> notiert die Berechtigungen des Aufrufenden zum Zeitpunkt des Aufrufs von B<fcntl>() und es sind diese gespeicherten Berechtigungen, die für die Rechteüberprüfung verwandt werden.

note: The following appears to be rubbish.  It doesn't seem to be true according to the kernel source, and I can write a program that gets a terminal-generated SIGIO even though it is not the foreground process group of the terminal. -- MTK, 8 Apr 05 If the file descriptor .I fd refers to a terminal devic
en: If the file descriptor I<fd> refers to a socket, B<F_SETOWN> also selects the recipient of B<SIGURG> signals that are delivered when out-of-band data arrives on that socket.  (B<SIGURG> is sent in any situation where B<select>(2)  would report the socket as having an "exceptional condition".)
de: Falls der Dateideskriptor I<fd> sich auf ein Socket bezieht, wählt B<F_SETOWN> auch den Empfänger des Signals B<SIGURG>, das ausgeliefert wird, wenn Außerbanddaten beim Socket eintreffen, aus. (B<SIGURG> wird in jeder Situation gesandt, in der B<select>(2) berichtete, dass das Socket eine »außergewöhnliche Bedingung« habe.)

note: type: Plain text
en: The following was true in 2.6.x kernels up to and including kernel 2.6.11:
de: Das Folgende stimmte in 2.6.x-Kerneln bis einschließlich 2.6.11:

note: The relevant place in the (2.6) kernel source is the 'switch' in fs/fcntl.c::send_sigio_to_task() -- MTK, Apr 2005 send_sigurg()/send_sigurg_to_task() bypasses kill_fasync()/send_sigio()/send_sigio_to_task() to directly call send_group_sig_info() -- MTK, Apr 2005 (kernel 2.6.11) type: Plain text
en: If a nonzero value is given to B<F_SETSIG> in a multithreaded process running with a threading library that supports thread groups (e.g., NPTL), then a positive value given to B<F_SETOWN> has a different meaning: instead of being a process ID identifying a whole process, it is a thread ID identifying a specific thread within a process.  Consequently, it may be necessary to pass B<F_SETOWN> the result of B<gettid>(2)  instead of B<getpid>(2)  to get sensible results when B<F_SETSIG> is used.  (In current Linux threading implementations, a main thread's thread ID is the same as its process ID.  This means that a single-threaded program can equally use B<gettid>(2)  or B<getpid>(2)  in this scenario.)  Note, however, that the statements in this paragraph do not apply to the B<SIGURG> signal generated for out-of-band data on a socket: this signal is always sent to either a process or a process group, depending on the value given to B<F_SETOWN>.
de: Falls in einem Prozess mit mehreren Threads, der mit einer Threading-Bibliothek läuft, die Thread-Gruppen unterstützt (z.B. NPTL), ein von Null verschiedener Wert an B<F_SETSIG> übergeben wird, dann hat ein an B<F_SETOWN> übergebener positiver Wert eine andere Bedeutung: Statt eine Prozesskennung zu sein, die einen gesamten Prozess identifiziert, ist es eine Thread-Kennung, die einen bestimmten Prozess innerhalb des Threads identifiziert. Konsequenterweise kann es notwendig sein, B<F_SETOWN> das Ergebnis von B<gettid>(2) statt von B<getpid>(2) zu übergeben, um vernünftige Ergebnisse zu erhalten, wenn B<F_SETSIG> benutzt wird. (In aktuellen Linux-Threading-Implementierungen ist die Kennung des Haupt-Threads identisch zu seiner Prozesskennung. Das bedeutet, dass ein Programm mit nur einem einzigen Thread in diesem Szenario genauso B<gettid>(2) oder B<getpid>(2) verwenden kann.) Beachten Sie allerdings, dass die Aussage in diesem Absatz nicht auf das Signal B<SIGURG> für Außerbanddaten für ein Socket zutrifft: Dieses Signal wird immer zu einem Prozess oder einer Prozessgruppe gesandt, abhängig vom in B<F_SETOWN> übergebenen Wert.

note: type: Plain text
en: The above behavior was accidentally dropped in Linux 2.6.12, and won't be restored.  From Linux 2.6.32 onward, use B<F_SETOWN_EX> to target B<SIGIO> and B<SIGURG> signals at a particular thread.
de: Das obige Verhalten wurde in Linux 2.6.12 versehentlich deaktivert und wird nicht mehr wiederhergestellt. Seit Linux 2.6.32 verwenden Sie B<F_SETOWN_EX>, um die Signale B<SIGIO> und B<SIGURG> auf einen bestimmten Thread anzuwenden.

note: type: TP
en: B<F_GETOWN_EX> (I<struct f_owner_ex *>) (since Linux 2.6.32)
de: B<F_GETOWN_EX> (I<struct f_owner_ex *>) (seit Linux 2.6.32)

note: type: Plain text
en: Return the current file descriptor owner settings as defined by a previous B<F_SETOWN_EX> operation.  The information is returned in the structure pointed to by I<arg>, which has the following form:
de: Liefert die aktuellen Eigenschaften des Dateideskriptoreigentümers, wie sie von einer vorherigen B<F_SETOWN_EX>-Aktion definiert wurden, zurück. Die Information wird in der Struktur, auf die I<arg> zeigt, zurückgeliefert. Sie hat die folgende Form:

note: type: Plain text
en: The I<type> field will have one of the values B<F_OWNER_TID>, B<F_OWNER_PID>, or B<F_OWNER_PGRP>.  The I<pid> field is a positive integer representing a thread ID, process ID, or process group ID.  See B<F_SETOWN_EX> for more details.
de: Das Feld I<type> wird einen der Werte B<F_OWNER_TID>, B<F_OWNER_PID> oder B<F_OWNER_PGRP> enthalten. Das Feld I<pid> ist eine positive Ganzzahl, die die Thread-Kennung, Prozesskennung oder Prozessgruppenkennung darstellt. Siehe B<F_SETOWN_EX> für weitere Details.

note: type: TP
en: B<F_SETOWN_EX> (I<struct f_owner_ex *>) (since Linux 2.6.32)
de: B<F_SETOWN_EX> (I<struct f_owner_ex *>) (seit Linux 2.6.32)

note: type: Plain text
en: This operation performs a similar task to B<F_SETOWN>.  It allows the caller to direct I/O availability signals to a specific thread, process, or process group.  The caller specifies the target of signals via I<arg>, which is a pointer to a I<f_owner_ex> structure.  The I<type> field has one of the following values, which define how I<pid> is interpreted:
de: Diese Aktion führt eine ähnliche Aufgabe wie B<F_SETOWN> aus. Sie erlaubt dem Aufrufenden, E/A-Verfügbarkeitssignale zu einem bestimmten Thread, Prozess oder einer Prozessgruppe zu dirigieren. Der Aufrufende bestimmt das Ziel der Signale mittels I<arg>, der ein Zeiger auf eine Struktur I<f_owner_ex> ist. Das Feld I<type> hat einen der folgenden Werte, der definiert, wie I<pid> interpretiert wird:

note: type: Plain text
en: Send the signal to the thread whose thread ID (the value returned by a call to B<clone>(2)  or B<gettid>(2))  is specified in I<pid>.
de: Sendet das Signal an den Thread, dessen Thread-Kennung (der von den Aufrufen B<clone>(2) oder B<gettid>(2) zurückgelieferte Wert) in I<pid> festgelegt ist.

note: type: Plain text
en: Send the signal to the process whose ID is specified in I<pid>.
de: Sendet das Signal an den Prozess dessen ID in I<pid> angegeben ist.

note: type: Plain text
en: Send the signal to the process group whose ID is specified in I<pid>.  (Note that, unlike with B<F_SETOWN>, a process group ID is specified as a positive value here.)
de: Sendet das Signal zu der Prozessgruppe, deren Kennung in I<pid> festgelegt ist. (Beachten Sie, dass anders als bei B<F_SETOWN>, eine Prozessgruppenkennung hier als positiver Wert festgelegt ist.)

note: type: Plain text
en: Return (as the function result)  the signal sent when input or output becomes possible.  A value of zero means B<SIGIO> is sent.  Any other value (including B<SIGIO>)  is the signal sent instead, and in this case additional info is available to the signal handler if installed with B<SA_SIGINFO>.  I<arg> is ignored.
de: Liefert (als Funktionsergebnis) das Signal zurück, das gesendet wird, wenn Ein- oder Ausgabe möglich wird. Ein Wert von Null bedeutet, dass B<SIGIO> gesandt wird. Jeder andere Wert (einschließlich B<SIGIO>) ist stattdessen das gesandt Signal. In diesem Fall sind zusätzliche Informationen im Signal-Handler verfügbar, falls er mit B<SA_SIGINFO> installiert wurde. I<arg> wird ignoriert.

note: The following was true only up until 2.6.11: Additionally, passing a nonzero value to .B F_SETSIG changes the signal recipient from a whole process to a specific thread within a process. See the description of .B F_SETOWN for more details. type: Plain text
en: Set the signal sent when input or output becomes possible to the value given in I<arg>.  A value of zero means to send the default B<SIGIO> signal.  Any other value (including B<SIGIO>)  is the signal to send instead, and in this case additional info is available to the signal handler if installed with B<SA_SIGINFO>.
de: Setzt das gesandte Signal, wenn Ein- oder Ausgabe möglich wird, auf den in I<arg> angegebenen Wert. Ein Wert von Null bedeutet, das Vorgabesignal B<SIGIO> zu senden. Jeder andere Wert (einschließlich B<SIGIO>) ist das stattdessen zu sendende Signal und in diesem Fall sind zusätzliche Informationen im Signal-Handler verfügbar, falls dieser mit B<SA_SIGINFO> installiert wurde.

note: type: Plain text
en: By using B<F_SETSIG> with a nonzero value, and setting B<SA_SIGINFO> for the signal handler (see B<sigaction>(2)), extra information about I/O events is passed to the handler in a I<siginfo_t> structure.  If the I<si_code> field indicates the source is B<SI_SIGIO>, the I<si_fd> field gives the file descriptor associated with the event.  Otherwise, there is no indication which file descriptors are pending, and you should use the usual mechanisms (B<select>(2), B<poll>(2), B<read>(2)  with B<O_NONBLOCK> set etc.) to determine which file descriptors are available for I/O.
de: Durch Verwendung von B<F_SETSIG> mit einem von Null verschiedenen Wert und Setzen von B<SA_SIGINFO> für den Signal-Handler (siehe B<sigaction>(2)) werden Zusatzinformationen über E/A-Ereignisse an den Handler in einer Struktur I<siginfo_t> übergeben. Falls das Feld I<si_code> anzeigt, dass die Quelle B<SI_SIGIO> ist, gibt das Feld I<si_fd> den mit diesem Ereignis korrelierten Dateideskriptor zurück. Andernfalls gibt es keine Anzeichen, welche Dateideskriptoren wartend sind und Sie sollten die normalen Mechanismen (B<select>(2), B<poll>(2), B<read>(2) mit gesetztem B<O_NONBLOCK> usw.) verwenden, um herauszufinden, welche Dateideskriptoren für E/A verfügbar sind.

note: type: Plain text
en: Note that the file descriptor provided in I<si_fd> is the one that was specified during the B<F_SETSIG> operation.  This can lead to an unusual corner case.  If the file descriptor is duplicated (B<dup>(2)  or similar), and the original file descriptor is closed, then I/O events will continue to be generated, but the I<si_fd> field will contain the number of the now closed file descriptor.
de: Beachten Sie, dass der in I<si_fd> bereitgestellte Dateideskriptor derjenige ist, der in der Aktion B<F_SETSIG> festgelegt wurde. Dies kann zu ungewöhnlichen Grenzfällen führen. Falls der Dateideskriptor dupliziert wird (B<dup>(2) oder ähnlich) und der ursprüngliche Dateideskriptor geschlossen wird, dann werden E/A-Ereignisse weiterhin generiert aber das Feld I<si_fd> wird die Anzahl der jetzt geschlossenen Dateideskriptoren enthalten.

note: type: Plain text
en: By selecting a real time signal (value E<gt>= B<SIGRTMIN>), multiple I/O events may be queued using the same signal numbers.  (Queuing is dependent on available memory.)  Extra information is available if B<SA_SIGINFO> is set for the signal handler, as above.
de: Durch Auswahl von Echtzeitsignalen (Wert E<gt>= B<SIGRTMIN>), können mehrere E/A-Ereignisse unter Verwendung der gleichen Signalnummer in eine Warteschlange eingereiht werden. (Einreihung in Warteschlangen hängt vom verfügbaren Speicher ab). Falls wie oben B<SA_SIGINFO> für den Signal-Handler gesetzt ist, sind zusätzliche Informationen verfügbar.

note: See fs/fcntl.c::send_sigio_to_task() (2.4/2.6) sources -- MTK, Apr 05 type: Plain text
en: Note that Linux imposes a limit on the number of real-time signals that may be queued to a process (see B<getrlimit>(2)  and B<signal>(7))  and if this limit is reached, then the kernel reverts to delivering B<SIGIO>, and this signal is delivered to the entire process rather than to a specific thread.
de: Beachten Sie, dass Linux eine Begrenzung für die Anzahl der Echtzeitsignale erzwingt, die für einen Prozess in eine Warteschlange eingereiht werden (siehe B<getrlimit>(2) und B<signal>(7)). Falls diese Begrenzung erreicht ist, kehrt der Kernel zur Auslieferung von B<SIGIO> zurück und dieses Signal wird dem gesamten Prozess statt nur einem bestimmten Thread ausgeliefert.

note: type: Plain text
en: Using these mechanisms, a program can implement fully asynchronous I/O without using B<select>(2)  or B<poll>(2)  most of the time.
de: Mittels dieser Mechanismen kann ein Programm eine komplett asynchrone E/A implementieren, ohne (in den meisten Fällen) B<select>(2) oder B<poll>(2) zu verwenden.

note: type: Plain text
en: The use of B<O_ASYNC> is specific to BSD and Linux.  The only use of B<F_GETOWN> and B<F_SETOWN> specified in POSIX.1 is in conjunction with the use of the B<SIGURG> signal on sockets.  (POSIX does not specify the B<SIGIO> signal.)  B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_GETSIG>, and B<F_SETSIG> are Linux-specific.  POSIX has asynchronous I/O and the I<aio_sigevent> structure to achieve similar things; these are also available in Linux as part of the GNU C Library (Glibc).
de: Die Verwendung von B<O_ASYNC> ist für BSD und Linux spezifisch. Die einzige in POSIX.1 spezifizierte Verwendung von B<F_GETOWN> and B<F_SETOWN> ist im Zusammenhang mit der Verwendung des Signals B<SIGURG> bei Sockets. (POSIX spezifiziert das Signal B<SIGIO> nicht). POSIX enthält asynchrone E/A und auch die Struktur I<aio_sigevent>, um ähnliche Dinge zu erreichen; diese sind unter Linux auch als Teil der GNU-C-Bibliothek (Glibc) verfügbar.

note: type: SS
en: Leases
de: Ausleihe

note: type: Plain text
en: B<F_SETLEASE> and B<F_GETLEASE> (Linux 2.4 onward) are used to establish a new lease, and retrieve the current lease, on the open file description referred to by the file descriptor I<fd>.  A file lease provides a mechanism whereby the process holding the lease (the "lease holder") is notified (via delivery of a signal)  when a process (the "lease breaker") tries to B<open>(2)  or B<truncate>(2)  the file referred to by that file descriptor.
de: B<F_SETLEASE> und B<F_GETLEASE> (Linux 2.4 und neuer) werden dazu verwandt, für die offene Dateideskription, auf den der Dateideskriptor I<fd> verweist, eine Ausleihe (»lease«) zu etablieren und die aktuelle Ausleihe zu ermitteln. Ein Datei-Ausleihe stellt einen Mechanismus bereit, durch den ein Prozess, der die Ausleihe hält (der »Ausleiher«) über die Auslieferung eines Signals benachrichtigt wird, wenn ein Prozess (der »Ausleihe-Brecher«) versucht, die von diesem Dateideskriptor referenzierte Datei mit B<open>(2) zu öffen oder mit B<truncate>(2) zu verkleinern/vergrößern.

note: type: Plain text
en: Set or remove a file lease according to which of the following values is specified in the integer I<arg>:
de: Setzt oder entfernt eine Datei-Ausleihe, abhängig davon, welcher der folgenden Wert in der Ganzzahl I<arg> angegeben ist:

note: The following became true in kernel 2.6.10: See the man-pages-2.09 Changelog for further info. type: Plain text
en: Take out a read lease.  This will cause the calling process to be notified when the file is opened for writing or is truncated.  A read lease can be placed only on a file descriptor that is opened read-only.
de: Nimmt eine Lese-Ausleihe heraus. Dies führt dazu, dass der aufrufende Prozess informiert wird, wenn die Datei zum Schreiben geöffnet oder abgeschnitten wird. Eine Lese-Ausleihe kann nur auf einen Dateideskriptor gelegt werden, der nur-lesbar geöffnet ist.

note: type: Plain text
en: Take out a write lease.  This will cause the caller to be notified when the file is opened for reading or writing or is truncated.  A write lease may be placed on a file only if there are no other open file descriptors for the file.
de: Nimmt eine Schreibe-Ausleihe heraus. Dies führt dazu, dass der aufrufende Prozess informiert wird, wenn die Datei zum Lesen oder Schreiben geöffnet oder abgeschnitten wird. Eine Schreibe-Ausleihe kann nur auf eine Datei gelegt werden, falls es keine anderen offenen Dateideskriptoren für diese Datei gibt.

note: type: Plain text
en: Remove our lease from the file.
de: Unsere Ausleihe von einer Datei entfernen.

note: type: Plain text
en: Leases are associated with an open file description (see B<open>(2)).  This means that duplicate file descriptors (created by, for example, B<fork>(2)  or B<dup>(2))  refer to the same lease, and this lease may be modified or released using any of these descriptors.  Furthermore, the lease is released by either an explicit B<F_UNLCK> operation on any of these duplicate file descriptors, or when all such file descriptors have been closed.
de: Ausleihen sind einem offenen Dateideskriptor zugeordnet (siehe B<open>(2)). Das bedeutet, dass ein duplizierter Dateideskriptor (zum Beispiel durch B<fork>(2) oder B<dup>(2) erstellt) sich auf die gleiche Ausleihe bezieht und dass diese Ausleihe durch jeden dieser Deskriptoren verändert oder freigegeben werden kann. Desweiteren werden Ausleihen durch eine explizite Aktion B<F_UNLCK> auf einem dieser duplizierten Dateideskriptoren freigegeben oder wenn alle solchen Dateideskriptoren geschlossen wurden.

note: type: Plain text
en: Leases may be taken out only on regular files.  An unprivileged process may take out a lease only on a file whose UID (owner) matches the filesystem UID of the process.  A process with the B<CAP_LEASE> capability may take out leases on arbitrary files.
de: Ausleihen dürfen nur für reguläre Dateien herausgenommen werden. Ein nicht privilegierter Prozess darf eine Ausleihe nur für Dateien herausnehmen, deren UID (Eigentümer) auf die Dateisystem-UID des Prozesses passt. Ein Prozess mit der Capability B<CAP_LEASE> darf Ausleihen für beliebige Dateien herausnehmen.

note: type: Plain text
en: Indicates what type of lease is associated with the file descriptor I<fd> by returning either B<F_RDLCK>, B<F_WRLCK>, or B<F_UNLCK>, indicating, respectively, a read lease , a write lease, or no lease.  I<arg> is ignored.
de: Zeigt den Typ der Ausleihe, der dem Dateideskriptor I<fd> zugeordnet ist, an, indem entweder B<F_RDLCK>, B<F_WRLCK> oder B<F_UNLCK> zurückgeliefert wird, das respektive eine Lese-, Schreib- oder keine Ausleihe anzeigt. I<arg> wird ignoriert.

note: type: Plain text
en: When a process (the "lease breaker") performs an B<open>(2)  or B<truncate>(2)  that conflicts with a lease established via B<F_SETLEASE>, the system call is blocked by the kernel and the kernel notifies the lease holder by sending it a signal (B<SIGIO> by default).  The lease holder should respond to receipt of this signal by doing whatever cleanup is required in preparation for the file to be accessed by another process (e.g., flushing cached buffers) and then either remove or downgrade its lease.  A lease is removed by performing an B<F_SETLEASE> command specifying I<arg> as B<F_UNLCK>.  If the lease holder currently holds a write lease on the file, and the lease breaker is opening the file for reading, then it is sufficient for the lease holder to downgrade the lease to a read lease.  This is done by performing an B<F_SETLEASE> command specifying I<arg> as B<F_RDLCK>.
de: Wenn ein Prozess (der »Ausleihe-Brecher«) ein B<open>(2) oder B<truncate>(2) durchführt, der mit einer mittels B<F_SETLEASE> etablierten Ausleihe in Konflikt steht, wird der Systemaufruf durch den Kernel blockiert und der Kernel informiert den Ausleihenden, indem er ihm ein Signal (standardmäßig B<SIGIO>) sendet. Der Ausleihende sollte reagieren, indem er alle notwendigen Aufräumarbeiten durchführt, um den Zugriff des anderen Prozesses auf die Datei vorzubereiten (z.B. das Rausschreiben von zwischengespeicherten Puffern). Danach sollte er entweder seine Ausleihe entfernen oder runterstufen. Eine Ausleihe wird durch Ausführung des Befehls B<F_SETLEASE> mit der Angabe von I<arg> als B<F_UNLCK> entfernt. Falls der Ausleihende derzeit eine Schreib-Ausleihe auf die Datei hält und der Ausleih-Brecher die Datei zum Lesen öffnet, dann reicht es aus, wenn der Ausleihende seine Ausleihe auf eine Lese-Ausleihe herunterstuft. Dies erfolgt durch Ausführung des Befehls B<F_SETLEASE> mit der Angabe von I<arg> als B<F_RDLCK>.

note: type: Plain text
en: If the lease holder fails to downgrade or remove the lease within the number of seconds specified in I</proc/sys/fs/lease-break-time>, then the kernel forcibly removes or downgrades the lease holder's lease.
de: Falls der Ausleihende nicht innerhalb der in I</proc/sys/fs/lease-break-time> festgelegten Anzahl von Sekunden seine Ausleihe herunterstuft oder entfernt, entfernt der Kernel die Ausleihe des Ausleihenden zwangsweise oder stuft sie zwangsweise herunter.

note: type: Plain text
en: Once a lease break has been initiated, B<F_GETLEASE> returns the target lease type (either B<F_RDLCK> or B<F_UNLCK>, depending on what would be compatible with the lease breaker)  until the lease holder voluntarily downgrades or removes the lease or the kernel forcibly does so after the lease break timer expires.
de: Sobald ein Ausleih-Brechen eingeleitet wurde, liefert B<F_GETLEASE> den Ziel-Ausleihtyp (entweder B<F_RDLCK> oder B<F_UNLCK>, abhängig davon, was zum Ausleih-Brecher kompatibel wäre) zurück, bis der Ausleihende freiwillig seine Ausleihe herunterstuft oder entfernt oder der Kernel dies zwangsweise tut, nachdem der Ausleih-Brech-Timer abgelaufen ist.

note: type: Plain text
en: Once the lease has been voluntarily or forcibly removed or downgraded, and assuming the lease breaker has not unblocked its system call, the kernel permits the lease breaker's system call to proceed.
de: Sobald die Ausleihe freiwillig oder zwangsweise entfernt oder heruntergestuft wurde und unter der Annahme, dass der Ausleih-Brecher nicht den Systemaufruf entblockiert hat, erlaubt der Kernel dem Systemaufruf des Ausleih-Brechers fortzufahren.

note: type: Plain text
en: If the lease breaker's blocked B<open>(2)  or B<truncate>(2)  is interrupted by a signal handler, then the system call fails with the error B<EINTR>, but the other steps still occur as described above.  If the lease breaker is killed by a signal while blocked in B<open>(2)  or B<truncate>(2), then the other steps still occur as described above.  If the lease breaker specifies the B<O_NONBLOCK> flag when calling B<open>(2), then the call immediately fails with the error B<EWOULDBLOCK>, but the other steps still occur as described above.
de: Falls das vom Ausleih-Brecher blockierte B<open>(2) oder B<truncate>(2) durch einen Signal-Handler unterbrochen wird, schlägt der Systemaufruf mit dem Fehler B<EINTR> fehl, aber die anderen Schritte erfolgen dennoch wie oben beschrieben. Falls der Ausleih-Brecher durch ein Signal getötet wird, während er in B<open>(2) oder B<truncate>(2) blockiert ist, erfolgen die anderen Schritte dennoch wie oben beschrieben. Falls der Ausleih-Brecher den Schalter B<O_NONBLOCK> beim Aufruf von B<open>(2) festgelegt hat, schlägt der Aufruf sofort mit dem Fehler B<EWOULDBLOCK> fehl, aber die anderen Schritte erfolgen dennoch wie oben beschrieben.

note: type: Plain text
en: The default signal used to notify the lease holder is B<SIGIO>, but this can be changed using the B<F_SETSIG> command to B<fcntl>().  If a B<F_SETSIG> command is performed (even one specifying B<SIGIO>), and the signal handler is established using B<SA_SIGINFO>, then the handler will receive a I<siginfo_t> structure as its second argument, and the I<si_fd> field of this argument will hold the file descriptor of the leased file that has been accessed by another process.  (This is useful if the caller holds leases against multiple files.)
de: Standardmäßig wird das Signal B<SIGIO> zur Information des Ausleihenden verwandt, dies kann aber mit dem Befehl B<F_SETSIG> von B<fcntl>() geändert werden. Falls ein Befehl B<F_SETSIG> ausgeführt wird (selbst einer, der B<SIGIO> festlegt) und der Singal-Handler mittels B<SA_SIGINFO> etabliert wurde, dann wird der Handler eine Struktur I<siginfo_t> als sein zweites Argument erhalten und das Feld I<si_fd> dieses Argumentes wird den Dateideskriptor der Datei mit der Ausleihe, auf die ein anderer Prozess zugegriffen hat, enthalten. (Dies ist nützlich, falls der Aufrufende Ausleihen für mehrere Dateien hält.)

note: type: SS
en: File and directory change notification (dnotify)
de: Datei- und Verzeichnis-Änderungsbenachrichtigung (dnotify)

note: type: Plain text
en: (Linux 2.4 onward)  Provide notification when the directory referred to by I<fd> or any of the files that it contains is changed.  The events to be notified are specified in I<arg>, which is a bit mask specified by ORing together zero or more of the following bits:
de: (Seit Linux 2.4) Stellt Benachrichtigungen bereit, wenn das durch I<fd> referenzierte Verzeichnis oder eine der darin enthaltenen Dateien geändert wird. Die Ereignisse, für die benachrichtigt wird, werden in I<arg> festgelegt. Dies ist eine Bitmaske, in der mittels ODER eines oder mehrere der folgenden Bits festgelegt sind:

note: type: Plain text
en: A file was accessed (B<read>(2), B<pread>(2), B<readv>(2), and similar)
de: Ein Dateizugriff erfolgte (B<read>(2), B<pread>(2), B<readv>(2) und ähnliche)

note: type: Plain text
en: A file was modified (B<write>(2), B<pwrite>(2), B<writev>(2), B<truncate>(2), B<ftruncate>(2), and similar).
de: Eine Datei wurde verändert (B<write>(2), B<pwrite>(2), B<writev>(2), B<truncate>(2), B<ftruncate>(2) und ähnliche).

note: type: Plain text
en: A file was created (B<open>(2), B<creat>(2), B<mknod>(2), B<mkdir>(2), B<link>(2), B<symlink>(2), B<rename>(2)  into this directory).
de: Eine Datei wurde erstellt (B<open>(2), B<creat>(2), B<mknod>(2), B<mkdir>(2), B<link>(2), B<symlink>(2), B<rename>(2) in dieses Verzeichnis).

note: type: Plain text
en: A file was unlinked (B<unlink>(2), B<rename>(2)  to another directory, B<rmdir>(2)).
de: Der Link auf eine Datei wurde entfernt (B<unlink>(2), B<rename>(2) in ein anderes Verzeichnis, B<rmdir>(2)).

note: type: Plain text
en: A file was renamed within this directory (B<rename>(2)).
de: Eine Datei wurde innerhalb dieses Verzeichnis umbenannt (B<rename>(2)).

note: type: Plain text
en: The attributes of a file were changed (B<chown>(2), B<chmod>(2), B<utime>(2), B<utimensat>(2), and similar).
de: Die Attribute einer Datei wurden geändert (B<chown>(2), B<chmod>(2), B<utime>(2), B<utimensat>(2) und ähnliche).

note: type: Plain text
en: (In order to obtain these definitions, the B<_GNU_SOURCE> feature test macro must be defined before including I<any> header files.)
de: (Um diese Definitionen zu erhalten, muss das Feature-Test-Makro B<_GNU_SOURCE> vor der Einbindung I<irgendeiner> Header-Datei definiert werden.)

note: type: Plain text
en: Directory notifications are normally "one-shot", and the application must reregister to receive further notifications.  Alternatively, if B<DN_MULTISHOT> is included in I<arg>, then notification will remain in effect until explicitly removed.
de: Verzeichnisbenachrichtigungen sind normalerweise »einmalig« und die Anwendung muss sich erneut registrieren, um weitere Benachrichtigungen zu erhalten. Wird alternativ B<DN_MULTISHOT> in I<arg> aufgenommen, bleiben die Benachrichtigungen aktiv, bis sie explizit entfernt werden.

note: The following does seem a poor API-design choice... type: Plain text
en: A series of B<F_NOTIFY> requests is cumulative, with the events in I<arg> being added to the set already monitored.  To disable notification of all events, make an B<F_NOTIFY> call specifying I<arg> as 0.
de: Eine Reihe von B<F_NOTIFY>-Anfragen ist kumulativ, bei der die Ereignisse in I<arg> zu der Menge der bereits beobachteten hinzugefügt werden. Um Benachrichtigungen für alle Ereignisse zu deaktivieren, führen Sie einen Aufruf B<F_NOTIFY> mit I<arg> als 0 durch.

note: type: Plain text
en: Notification occurs via delivery of a signal.  The default signal is B<SIGIO>, but this can be changed using the B<F_SETSIG> command to B<fcntl>().  (Note that B<SIGIO> is one of the nonqueuing standard signals; switching to the use of a real-time signal means that multiple notifications can be queued to the process.)  In the latter case, the signal handler receives a I<siginfo_t> structure as its second argument (if the handler was established using B<SA_SIGINFO>)  and the I<si_fd> field of this structure contains the file descriptor which generated the notification (useful when establishing notification on multiple directories).
de: Benachrichtigungen erfolgen über die Zustellung eines Signals. Das Standardsignal ist B<SIGIO>, dies kann aber mittels des Befehls B<F_SETSIG> von B<fcntl>() geändert werden. (Beachten Sie, dass B<SIGIO> eines der nichtwarteschlangenfähigen Standardsignale ist; wird auf Echtzeitsignale umgestellt, können mehrere Benachrichtigungen für den Prozess in die Warteschlange gestellt werden). Im letzteren Falle erhält der Signal-Handler eine Struktur I<siginfo_t> als zweites Argument (falls der Hanndler mittels B<SA_SIGINFO> etabliert wurde) und das Feld I<si_fd> dieser Struktur enthält einen Dateideskriptor, der die Benachrichtigung erstellte (nützlich, falls Benachrichtigungen für mehrere Verzeichnisse eingerichtet werden).

note: type: Plain text
en: Especially when using B<DN_MULTISHOT>, a real time signal should be used for notification, so that multiple notifications can be queued.
de: Insbesondere bei der Verwendung von B<DN_MULTISHOT> sollte ein Echtzeitsignal für die Benachrichtigung verwandt werden, so dass mehrere Benachrichtigungen in die Warteschlange aufgenommen werden können.

note: type: Plain text
en: B<NOTE:> New applications should use the I<inotify> interface (available since kernel 2.6.13), which provides a much superior interface for obtaining notifications of filesystem events.  See B<inotify>(7).
de: B<HINWEIS>: Neue Anwendungen sollten die Schnittstelle I<inotify> (verfügbar seit Kernel 2.6.13) verwenden, die eine deutlich überlegene Schnittstelle zur Ermittlung von Benachrichtigungen über Dateisystemereignisse bietet. Siehe B<inotify>(7).

note: type: SS
en: Changing the capacity of a pipe
de: Ändern der Kapazität einer Pipe

note: type: TP
en: B<F_SETPIPE_SZ> (I<int>; since Linux 2.6.35)
de: B<F_SETPIPE_SZ> (I<int>; seit Linux 2.6.35)

note: type: Plain text
en: Change the capacity of the pipe referred to by I<fd> to be at least I<arg> bytes.  An unprivileged process can adjust the pipe capacity to any value between the system page size and the limit defined in I</proc/sys/fs/pipe-max-size> (see B<proc>(5)).  Attempts to set the pipe capacity below the page size are silently rounded up to the page size.  Attempts by an unprivileged process to set the pipe capacity above the limit in I</proc/sys/fs/pipe-max-size> yield the error B<EPERM>; a privileged process (B<CAP_SYS_RESOURCE>)  can override the limit.
de: Ändert die Kapazität der durch I<fd> referenzierten Pipe auf mindestens I<arg> Byte. Ein unprivilegierter Prozess kann die Pipe-Kapazität auf jeden Wert zwischen der Systemseitengröße und der durch I</proc/sys/fs/pipe-max-size> (siehe B<proc>(5)) definierten Grenze anpassen. Wird versucht, die Pipe-Kapazität unter die Seitengröße zu setzen, dann wird diese ohne Rückmeldung auf die Seitengröße gerundet. Versucht ein unprivilegierter Prozess, die Pipe-Kapazität über die in I</proc/sys/fs/pipe-max-size> definierte Grenze zu setzen, führt dies zu dem Fehler B<EPERM>; ein privilegierter Prozess (B<CAP_SYS_RESOURCE>) kann die Grenze außer Kraft setzen.

note: type: Plain text
en: When allocating the buffer for the pipe, the kernel may use a capacity larger than I<arg>, if that is convenient for the implementation.  (In the current implementation, the allocation is the next higher power-of-two page-size multiple of the requested size.)  The actual capacity (in bytes) that is set is returned as the function result.
de: Beim Reservieren des Puffers für die Pipe darf der Kernel eine größere Kapazität als I<arg> verwenden, falls das für die Implementierung passend ist. (In der aktuellen Implementierung ist die Allokation die nächst-größere Zweierpotenz des Vielfachen der Seitengröße der angeforderten Größe.) Die tatsächliche gesetzte Kapazität (in Byte) wird als Ergebnis der Funktion zurückgeliefert.

note: type: Plain text
en: Attempting to set the pipe capacity smaller than the amount of buffer space currently used to store data produces the error B<EBUSY>.
de: Wird versucht, die Pipe-Kapazität auf einen Wert zu setzen, der kleiner als der derzeit zum Speichern von Daten verwandte Pufferbereich ist, dann wird der Fehler B<EBUSY> erzeugt.

note: type: Plain text
en: Note that because of the way the pages of the pipe buffer are employed when data is written to the pipe, the number of bytes that can be written may be less than the nominal size, depending on the size of the writes.
de: Beachten Sie, dass aufgrund der Art, wie die Seiten des Pipe-Puffers eingesetzt werden, wenn Daten in die Pipe geschrieben werden, die Anzahl der Bytes geringer als die nominale Größe sein kann, abhängig von der Größe der Schreibvorgänge.

note: type: TP
en: B<F_GETPIPE_SZ> (I<void>; since Linux 2.6.35)
de: B<F_GETPIPE_SZ> (I<void>; seit Linux 2.6.35)

note: type: Plain text
en: Return (as the function result) the capacity of the pipe referred to by I<fd>.
de: Liefert (als Ergebnis der Funktion) die Kapazität der durch I<fd> referenzierten Pipe zurück.

note: type: SS
en: File Sealing
de: Versiegelung von Dateien

note: type: Plain text
en: File seals limit the set of allowed operations on a given file.  For each seal that is set on a file, a specific set of operations will fail with B<EPERM> on this file from now on.  The file is said to be sealed.  The default set of seals depends on the type of the underlying file and filesystem.  For an overview of file sealing, a discussion of its purpose, and some code examples, see B<memfd_create>(2).
de: Dateisiegel begrenzen die Menge der erlaubten Aktionen für eine bestimmte Datei. Für jedes auf eine Datei angebrachte Siegel wird von jetzt an eine bestimmte Gruppe an Aktionen auf dieser Datei mit dem Fehler B<EPERM> fehlschlagen. Die Datei wird als versiegelt bezeichnet. Die Vorgabemenge der Siegel hängt von der Art der unterliegenden Datei und dem Dateisystem ab. Für einen Überblick über Dateiversiegelung, einer Diskussion ihres Zwecks und Code-Beispiele siehe B<memfd_create>(2).

note: type: Plain text
en: Currently, file seals can be applied only to a file descriptor returned by B<memfd_create>(2)  (if the B<MFD_ALLOW_SEALING> was employed).  On other filesystems, all B<fcntl>()  operations that operate on seals will return B<EINVAL>.
de: Derzeit können Dateisiegel nur auf durch B<memfd_create>(2) zurückgelieferte Dateideskriptoren angewandt werden (falls B<MFD_ALLOW_SEALING> eingesetzt wurde). Auf anderen Dateisystemen werden alle B<fcntl>()-Aktionen zur Versiegelung B<EINVAL> zurückliefern.

note: type: Plain text
en: Seals are a property of an inode.  Thus, all open file descriptors referring to the same inode share the same set of seals.  Furthermore, seals can never be removed, only added.
de: Siegel sind eine Eigenschaft eines Inodes. Daher verfügen alle offenen Dateideskriptoren, die auf den gleichen Inode verweisen, über die gleiche Gruppe an Siegeln. Desweiteren können Siegel nie entfernt, nur hinzugefügt werden.

note: type: TP
en: B<F_ADD_SEALS> (I<int>; since Linux 3.17)
de: B<F_ADD_SEALS> (I<int>; seit Linux 3.17)

note: type: Plain text
en: Add the seals given in the bit-mask argument I<arg> to the set of seals of the inode referred to by the file descriptor I<fd>.  Seals cannot be removed again.  Once this call succeeds, the seals are enforced by the kernel immediately.  If the current set of seals includes B<F_SEAL_SEAL> (see below), then this call will be rejected with B<EPERM>.  Adding a seal that is already set is a no-op, in case B<F_SEAL_SEAL> is not set already.  In order to place a seal, the file descriptor I<fd> must be writable.
de: Fügt die im Bitmasken-Argument I<arg> übergebenen Siegel zu der Gruppe der Siegel des Inodes, der vom Dateideskriptor I<fd> referenziert wird, hinzu. Siegel können nicht mehr entfernt werden. Sobald dieser Aufruf gelingt, werden die Siegel sofort vom Kernel durchgesetzt. Falls die derzeitige Gruppe der Siegel B<F_SEAL_SEAL> enthält (siehe unten) wird dieser Aufruf mit B<EPERM> abgelehnt. Hinzufügen eines bereits gesetzten Siegels ist eine Nullaktion, falls B<F_SEAL_SEAL> nicht bereits gesetzt ist. Um ein Siegel zu setzen, muss der Dateideskriptor I<fd> schreibbar sein.

note: type: TP
en: B<F_GET_SEALS> (I<void>; since Linux 3.17)
de: B<F_GET_SEALS> (I<void>; seit Linux 3.17)

note: type: Plain text
en: Return (as the function result) the current set of seals of the inode referred to by I<fd>.  If no seals are set, 0 is returned.  If the file does not support sealing, -1 is returned and I<errno> is set to B<EINVAL>.
de: Liefert (als Funktionsergebnis) die aktuelle Menge der Siegel des durch I<fd> referenzierten Inodes zurück. Falls keine Siegel gesetzt sind, wird 0 zurückgeliefert. Falls die Datei Versiegelung nicht unterstützt, wird -1 zurückgeliefert und I<errno> auf B<EINVAL> gesetzt.

note: type: Plain text
en: The following seals are available:
de: Die folgenden Versiegelungen sind verfügbar:

note: type: Plain text
en: If this seal is set, any further call to B<fcntl>()  with B<F_ADD_SEALS> fails with the error B<EPERM>.  Therefore, this seal prevents any modifications to the set of seals itself.  If the initial set of seals of a file includes B<F_SEAL_SEAL>, then this effectively causes the set of seals to be constant and locked.
de: Falls dieses Siegel gesetzt ist, wird jeder zukünftige Aufruf von B<fcntl>() mit B<F_ADD_SEALS> mit dem Fehler B<EPERM> fehlschlagen. Daher verhindert dieses Siegel jede Änderung an der Siegelmenge selbst. Falls die ursprüngliche Siegelmenge einer Datei B<F_SEAL_SEAL> enthält, dann führt dies effektiv dazu, dass die Siegelmenge konstant und gesperrt ist.

note: type: Plain text
en: If this seal is set, the file in question cannot be reduced in size.  This affects B<open>(2)  with the B<O_TRUNC> flag as well as B<truncate>(2)  and B<ftruncate>(2).  Those calls fail with B<EPERM> if you try to shrink the file in question.  Increasing the file size is still possible.
de: Falls dieses Siegel gesetzt ist, kann die in Frage kommende Datei nicht verkleinert werden. Dies betrifft B<open>(2) mit dem Schalter B<O_TRUNC> sowie B<truncate>(2) und B<ftruncate>(2). Diese Aufrufe schlagen mit B<EPERM> fehl, falls Sie versuchen, die in Frage kommende Datei zu verkleinern. Vergrößern der Datei ist weiterhin möglich.

note: type: Plain text
en: If this seal is set, the size of the file in question cannot be increased.  This affects B<write>(2)  beyond the end of the file, B<truncate>(2), B<ftruncate>(2), and B<fallocate>(2).  These calls fail with B<EPERM> if you use them to increase the file size.  If you keep the size or shrink it, those calls still work as expected.
de: Falls dieses Siegel gesetzt ist, kann die in Frage kommende Datei nicht vergrößert werden. Dies betrifft B<write>(2) über das Ende der Datei hinaus, B<truncate>(2), B<ftruncate>(2) und B<fallocate>(2). Diese Aufrufe schlagen mit B<EPERM> fehl, falls Sie versuchen, diese zum Vergrößern der Datei zu verwenden. Falls Sie die Dateigröße beibehalten oder verkleinern, werden diese Aufrufe weiterhin wie erwartet funktionieren.

note: type: SS
en: File read/write hints
de: Datei Lese-/Schreibehinweise

note: type: Plain text
en: Write lifetime hints can be used to inform the kernel about the relative expected lifetime of writes on a given inode or via a particular open file description.  (See B<open>(2)  for an explanation of open file descriptions.)  In this context, the term "write lifetime" means the expected time the data will live on media, before being overwritten or erased.
de: Der Kernel kann mit Schreib-Lebenszeithinweisen über die erwartete relative Lebenszeit von Schreibaktionen an einer benannten Inode oder über eine bestimmte offene Dateideskription informiert werden (Siehe B<open>(2) für eine Erläuterung von offenen Dateideskriptoren.). In diesem Kontext bedeutet der Ausdruck »Schreib-Lebenszeit«, die erwartete Zeit, die die Daten auf dem Medium verbleiben, bevor sie überschrieben oder gelöscht werden.

note: type: Plain text
en: An application may use the different hint values specified below to separate writes into different write classes, so that multiple users or applications running on a single storage back-end can aggregate their I/O patterns in a consistent manner.  However, there are no functional semantics implied by these flags, and different I/O classes can use the write lifetime hints in arbitrary ways, so long as the hints are used consistently.
de: Eine Anwendung darf die unten festgelegten verschiedenen Hinweisewerte verwenden, um die Schreibaktionen in verschiedene Schreibklassen zu trennen, so dass mehrere Benutzer oder Anwendungen, die mit dem gleichen Speicher-Backend arbeiten, ihre E/A-Muster in einer konsistenten Art zusammenfassen können. Allerdings implizieren diese Schalter keine funktionalen Semantiken und verschiedene E/A-Klassen können die Schreib-Lebenszeithinweise in beliebigen Arten benutzen, so lange die Hinweise konsistent benutzt werden.

note: type: Plain text
en: The following operations can be applied to the file descriptor, I<fd>:
de: Die folgenden Aktionen könen auf den Dateideskriptor I<fd> angewandt werden:

note: type: TP
en: B<F_GET_RW_HINT> (I<uint64_t *>; since Linux 4.13)
de: B<F_GET_RW_HINT> (I<uint64_t *>; seit Linux 4.13)

note: type: Plain text
en: Returns the value of the read/write hint associated with the underlying inode referred to by I<fd>.
de: Liefert den Wert des Lese-/Schreibhinweises, der der durch I<fd> referenzierten unterliegenden Inode zugeordnet ist.

note: type: TP
en: B<F_SET_RW_HINT> (I<uint64_t *>; since Linux 4.13)
de: B<F_SET_RW_HINT> (I<uint64_t *>; seit Linux 4.13)

note: type: Plain text
en: Sets the read/write hint value associated with the underlying inode referred to by I<fd>.  This hint persists until either it is explicitly modified or the underlying filesystem is unmounted.
de: Setzt den Wert des Lese-/Schreibhinweises, der der durch I<fd> referenzierten unterliegenden Inode zugeordnet ist. Dieser Hinweis verbleibt, bis er entweder explizit geändert oder das unterliegende Dateisystem ausgehängt wird.

note: type: TP
en: B<F_GET_FILE_RW_HINT> (I<uint64_t *>; since Linux 4.13)
de: B<F_GET_FILE_RW_HINT> (I<uint64_t *>; seit Linux 4.13)

note: type: Plain text
en: Returns the value of the read/write hint associated with the open file description referred to by I<fd>.
de: Liefert den Wert des Lese-/Schreibhinweises, der der durch I<fd> referenzierten offenen Dateideskription zugeordnet ist.

note: type: TP
en: B<F_SET_FILE_RW_HINT> (I<uint64_t *>; since Linux 4.13)
de: B<F_SET_FILE_RW_HINT> (I<uint64_t *>; seit Linux 4.13)

note: type: Plain text
en: Sets the read/write hint value associated with the open file description referred to by I<fd>.
de: Setzt den Wert des Lese-/Schreibhinweises, der der durch I<fd> referenzierten offenen Dateideskription zugeordnet ist.

note: type: Plain text
en: If an open file description has not been assigned a read/write hint, then it shall use the value assigned to the inode, if any.
de: Falls einer offenen Dateideskription noch kein Lese-/Schreibhinweis zugeordnet wurde, dann soll der der Inode zugeordnete Wert verwandt werden, falls vorhanden.

note: type: Plain text
en: The following read/write hints are valid since Linux 4.13:
de: Die folgenden Lese-/Schreibhinweise sind seit Linux 4.13 gültig:

note: type: Plain text
en: No specific hint has been set.  This is the default value.
de: Es  wurde kein spezieller Hinweis gesetzt. Dies ist der Vorgabewert.

note: type: Plain text
en: No specific write lifetime is associated with this file or inode.
de: Kein spezielle Schreib-Lebenszeit ist dieser Datei oder diesem Inode zugeordnet.

note: type: Plain text
en: Data written to this inode or via this open file description is expected to have a short lifetime.
de: Es wird erwartet, dass Daten, die in diese Inode oder über diesen offenen Dateideskriptor geschrieben werden, eine kurze Lebenszeit haben werden.

note: type: Plain text
en: Data written to this inode or via this open file description is expected to have a lifetime longer than data written with B<RWH_WRITE_LIFE_SHORT>.
de: Es wird erwartet, dass Daten, die in diese Inode oder über diesen offenen Dateideskriptor geschrieben werden, eine längere Lebenszeit als Daten, die mit B<RWH_WRITE_LIFE_SHORT> geschrieben wurden, haben werden.

note: type: Plain text
en: Data written to this inode or via this open file description is expected to have a lifetime longer than data written with B<RWH_WRITE_LIFE_MEDIUM>.
de: Es wird erwartet, dass Daten, die in diese Inode oder über diesen offenen Dateideskriptor geschrieben werden, eine längere Lebenszeit als Daten, die mit B<RWH_WRITE_LIFE_MEDIUM> geschrieben wurden, haben werden.

note: type: Plain text
en: Data written to this inode or via this open file description is expected to have a lifetime longer than data written with B<RWH_WRITE_LIFE_LONG>.
de: Es wird erwartet, dass Daten, die in diese Inode oder über diesen offenen Dateideskriptor geschrieben werden, eine längere Lebenszeit als Daten, die mit B<RWH_WRITE_LIFE_LONG> geschrieben wurden, haben werden.

note: type: Plain text
en: All the write-specific hints are relative to each other, and no individual absolute meaning should be attributed to them.
de: Alle schreibspezifischen Hinweise sind relativ zueinander und ihnen sollte keine individuelle absolute Bedeutung beigemessen werden.

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

note: type: Plain text
en: For a successful call, the return value depends on the operation:
de: Für einen erfolgreichen Aufruf hängt der Rückgabewert von der Aktion ab:

note: type: Plain text
en: The new file descriptor.
de: Der neue Dateideskriptor.

note: type: Plain text
en: Value of file descriptor flags.
de: Wert des File-Deskriptor-Schalters.

note: type: Plain text
en: Value of file status flags.
de: Wert der Dateistatusschalter.

note: type: Plain text
en: Type of lease held on file descriptor.
de: Art der Ausleihe, die auf dem Dateideskriptor gehalten wird.

note: type: Plain text
en: Value of file descriptor owner.
de: Wert des Dateideskriptor-Eigentümers.

note: type: Plain text
en: Value of signal sent when read or write becomes possible, or zero for traditional B<SIGIO> behavior.
de: Wert des Signals, wenn Lesen oder Schreiben möglich wird, oder Null für traditionelles B<SIGIO>-Verhalten.

note: type: Plain text
en: The pipe capacity.
de: Die Kapazität der Pipe.

note: type: Plain text
en: A bit mask identifying the seals that have been set for the inode referred to by I<fd>.
de: Eine Bitmaske, die die Siegel identifiziert, die für den durch I<fd> referenzierten Inode gesetzt wurden.

note: type: TP
en: All other commands
de: Alle anderen Befehle

note: type: Plain text
en: Zero.
de: Null

note: type: Plain text
en: On error, -1 is returned, and I<errno> is set appropriately.
de: Bei einem Fehler wird -1 zurückgegeben und I<errno> entsprechend gesetzt.

note: type: SH
en: ERRORS
de: FEHLER

note: type: TP
en: B<EACCES> or B<EAGAIN>
de: B<EACCES> oder B<EAGAIN>

note: type: Plain text
en: Operation is prohibited by locks held by other processes.
de: Aktion wird durch von anderen Prozessen gehaltene Sperren verhindert.

note: type: Plain text
en: I<fd> is not an open file descriptor
de: I<fd> ist kein offener Dateideskriptor.

note: type: Plain text
en: I<cmd> is B<F_SETLK> or B<F_SETLKW> and the file descriptor open mode doesn't match with the type of lock requested.
de: I<cmd> ist B<F_SETLK> oder B<F_SETLKW> und der Öffnungsmodus des Dateideskriptors passt nicht auf die angeforderte Art der Sperre.

note: type: Plain text
en: I<cmd> is B<F_SETPIPE_SZ> and the new pipe capacity specified in I<arg> is smaller than the amount of buffer space currently used to store data in the pipe.
de: I<cmd> ist B<F_SETPIPE_SZ> und die in I<arg> festgelegte neue Kapazität der Pipe ist kleiner als die Größe des derzeit zur Speicherung von Daten in der Pipe verwandten Pufferspeichers.

note: type: Plain text
en: It was detected that the specified B<F_SETLKW> command would cause a deadlock.
de: Es wurde erkannt, dass der angegebene Befehl B<F_SETLKW> zu einer Verklemmung führen würde.

note: type: Plain text
en: I<lock> is outside your accessible address space.
de: I<lock> befindet sich außerhalb Ihres adressierbaren Adressraums.

note: type: Plain text
en: I<cmd> is B<F_SETLKW> or B<F_OFD_SETLKW> and the operation was interrupted by a signal; see B<signal>(7).
de: I<cmd> ist B<F_SETLKW> oder B<F_OFD_SETLKW> und die Aktion wurde durch ein Signal unterbrochen; siehe B<signal>(7).

note: type: Plain text
en: I<cmd> is B<F_GETLK>, B<F_SETLK>, B<F_OFD_GETLK>, or B<F_OFD_SETLK>, and the operation was interrupted by a signal before the lock was checked or acquired.  Most likely when locking a remote file (e.g., locking over NFS), but can sometimes happen locally.
de: I<cmd> ist B<F_GETLK>, B<F_SETLK>, B<F_OFD_GETLK> oder B<F_OFD_SETLK> und die Aktion wurde durch ein Signal unterbrochen, bevor die Sperre geprüft oder erworben werden konnte. Passiert am wahrscheinlichsten beim Sperren von Dateien in der Ferne (d.h. Sperren über NFS), kann aber manchmal auch lokal auftreten.

note: type: Plain text
en: The value specified in I<cmd> is not recognized by this kernel.
de: Der in I<cmd> angegebene Wert wird von diesem Kernel nicht erkannt.

note: type: Plain text
en: I<cmd> is B<F_ADD_SEALS> and I<arg> includes an unrecognized sealing bit.
de: I<cmd> ist B<F_ADD_SEALS> und I<arg> enthält ein nicht erkanntes Versiegelungs-Bit.

note: type: Plain text
en: I<cmd> is B<F_ADD_SEALS> or B<F_GET_SEALS> and the filesystem containing the inode referred to by I<fd> does not support sealing.
de: I<cmd> ist B<F_ADD_SEALS> oder B<F_GET_SEALS> und das Dateisystem, das den durch I<fd> referenzierten Inode enthält, unterstützt kein Versiegeln.

note: type: Plain text
en: I<cmd> is B<F_DUPFD> and I<arg> is negative or is greater than the maximum allowable value (see the discussion of B<RLIMIT_NOFILE> in B<getrlimit>(2)).
de: I<cmd> ist B<F_DUPFD> und I<arg> ist negativ oder ist größer als der maximal zulässige Wert (siehe die Diskussion von B<RLIMIT_NOFILE> in B<getrlimit>(2)).

note: type: Plain text
en: I<cmd> is B<F_SETSIG> and I<arg> is not an allowable signal number.
de: I<cmd> ist B<F_SETSIG> und I<arg> ist keine erlaubbare Signalnummer.

note: type: Plain text
en: I<cmd> is B<F_OFD_SETLK>, B<F_OFD_SETLKW>, or B<F_OFD_GETLK>, and I<l_pid> was not specified as zero.
de: I<cmd> ist B<F_OFD_SETLK>, B<F_OFD_SETLKW> oder B<F_OFD_GETLK> und I<l_pid> wurde nicht als Null angegeben.

note: type: Plain text
en: I<cmd> is B<F_DUPFD> and the per-process limit on the number of open file descriptors has been reached.
de: I<cmd> ist B<F_DUPFD> und die Beschränkung pro Prozess für die Anzahl offener Dateideskriptoren wurde erreicht.

note: type: Plain text
en: Too many segment locks open, lock table is full, or a remote locking protocol failed (e.g., locking over NFS).
de: Zu viele Segment-Sperren offen, die Sperr-Tabelle ist voll oder ein Sperrprotokoll aus der Ferne schlug fehl (z.B. Sperren über NFS).

note: type: Plain text
en: B<F_NOTIFY> was specified in I<cmd>, but I<fd> does not refer to a directory.
de: B<F_NOTIFY> wurde in I<cmd> angegeben, aber I<fd> zeigt nicht auf ein Verzeichnis.

note: type: Plain text
en: I<cmd> is B<F_SETPIPE_SZ> and the soft or hard user pipe limit has been reached; see B<pipe>(7).
de: I<cmd> ist B<F_SETPIPE_SZ> und die weiche oder harte Benutzer-Pipe-Beschränkung wurde erreicht; siehe B<pipe>(7).

note: type: Plain text
en: Attempted to clear the B<O_APPEND> flag on a file that has the append-only attribute set.
de: Es wurde versucht, den Schalter B<O_APPEND> auf einer Datei zurückzusetzen, bei der das Attribut »nur anhängen« gesetzt ist.

note: type: Plain text
en: I<cmd> was B<F_ADD_SEALS>, but I<fd> was not open for writing or the current set of seals on the file already includes B<F_SEAL_SEAL>.
de: I<cmd> war B<F_ADD_SEALS> aber I<fd> war nicht zum Schreiben offen oder die aktuelle Menge der Siegel der Datei enthält bereits B<F_SEAL_SEAL>.

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

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.  Only the operations B<F_DUPFD>, B<F_GETFD>, B<F_SETFD>, B<F_GETFL>, B<F_SETFL>, B<F_GETLK>, B<F_SETLK>, and B<F_SETLKW> are specified in POSIX.1-2001.
de: SVr4, 4.3BSD, POSIX.1-2001. Nur die Aktionen B<F_DUPFD>, B<F_GETFD>, B<F_SETFD>, B<F_GETFL>, B<F_SETFL>, B<F_GETLK>, B<F_SETLK> und B<F_SETLKW> sind in POSIX.1-2001 spezifiziert.

note: .BR _BSD_SOURCE , or type: Plain text
en: B<F_GETOWN> and B<F_SETOWN> are specified in POSIX.1-2001.  (To get their definitions, define either B<_XOPEN_SOURCE> with the value 500 or greater, or B<_POSIX_C_SOURCE> with the value 200809L or greater.)
de: B<F_GETOWN> und B<F_SETOWN> sind in POSIX.1-2001 spezifiziert. (Um Ihre Definitionen zu erhalten, definieren Sie entweder B<_XOPEN_SOURCE> mit einem Wert größer oder gleich 500 oder definieren Sie B<_POSIX_C_SOURCE> mit einem Wert größer oder gleich 200809L.)

note: type: Plain text
en: B<F_DUPFD_CLOEXEC> is specified in POSIX.1-2008.  (To get this definition, define B<_POSIX_C_SOURCE> with the value 200809L or greater, or B<_XOPEN_SOURCE> with the value 700 or greater.)
de: B<F_DUPFD_CLOEXEC> ist in POSIX.1-2001 spezifiziert. (Um diese Definitionen zu erhalten, definieren Sie B<_POSIX_C_SOURCE> mit einem Wert größer oder gleich 200809L oder B<_XOPEN_SOURCE> mit einem Wert größer oder gleich 700.)

note: .PP SVr4 documents additional EIO, ENOLINK and EOVERFLOW error conditions. type: Plain text
en: B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_SETPIPE_SZ>, B<F_GETPIPE_SZ>, B<F_GETSIG>, B<F_SETSIG>, B<F_NOTIFY>, B<F_GETLEASE>, and B<F_SETLEASE> are Linux-specific.  (Define the B<_GNU_SOURCE> macro to obtain these definitions.)
de: B<F_GETOWN_EX>, B<F_SETOWN_EX>, B<F_SETPIPE_SZ>, B<F_GETPIPE_SZ>, B<F_GETSIG>, B<F_SETSIG>, B<F_NOTIFY>, B<F_GETLEASE> und B<F_SETLEASE> sind Linux-spezifisch. (Definieren Sie das Makro B<_GNU_SOURCE>, um diese Definitionen zu erhalten.)

note: type: Plain text
en: B<F_OFD_SETLK>, B<F_OFD_SETLKW>, and B<F_OFD_GETLK> are Linux-specific (and one must define B<_GNU_SOURCE> to obtain their definitions), but work is being done to have them included in the next version of POSIX.1.
de: B<F_OFD_SETLK>, B<F_OFD_SETLKW> und B<F_OFD_GETLK> sind Linux-spezifisch (und B<_GNU_SOURCE> muss definiert werden, um ihre Definitionen zu erhalten). Es wird aber daran gearbeitet, dass sie in der nächsten Version von POSIX.1 enthalten sind.

note: FIXME . Once glibc adds support, add a note about FTM requirements type: Plain text
en: B<F_ADD_SEALS> and B<F_GET_SEALS> are Linux-specific.
de: B<F_ADD_SEALS> und B<F_GET_SEALS> sind Linux-spezifisch.

note: type: SH
en: NOTES
de: ANMERKUNGEN

note: type: Plain text
en: The errors returned by B<dup2>(2)  are different from those returned by B<F_DUPFD>.
de: Die Fehler, die von B<dup2>(2) zurückgegeben werden, sind anders als die von B<F_DUPFD>.

note: type: SS
en: File locking
de: Sperrung von Dateien

note: type: Plain text
en: The original Linux B<fcntl>()  system call was not designed to handle large file offsets (in the I<flock> structure).  Consequently, an B<fcntl64>()  system call was added in Linux 2.4.  The newer system call employs a different structure for file locking, I<flock64>, and corresponding commands, B<F_GETLK64>, B<F_SETLK64>, and B<F_SETLKW64>.  However, these details can be ignored by applications using glibc, whose B<fcntl>()  wrapper function transparently employs the more recent system call where it is available.
de: Der ursprüngliche Systemaufruf B<fcntl>() von Linux war nicht dafür konstruiert, große Dateiversätze (in der Struktur I<flock>) zu handhaben. Konsequenterweise wurde ein Systemaufruf B<fcntl64>() in Linux 2.4 hinzugefügt. Dieser neuere Systemaufruf setzt eine andere Struktur zum Sperren von Dateien ein, I<flock64>, und entsprechende Befehle B<F_GETLK64>, B<F_SETLK64> und B<F_SETLKW64>. Diese Details können allerdings von Anwendungen, die Glibc einsetzen, ignoriert werden, da dessen Wrapperfunktion B<fcntl>() transparent den neueren Systemaufruf einsetzt, wo er verfügbar ist.

note: type: SS
en: Record locks
de: Datensatzsperren

note: type: Plain text
en: Since kernel 2.0, there is no interaction between the types of lock placed by B<flock>(2)  and B<fcntl>().
de: Seit Kernel 2.0 gibt es keine Wechselwirkung zwischen den durch B<flock>(2) und B<fcntl>() gesetzten Sperrtypen.

note: e.g., Solaris 8 documents this field in fcntl(2), and Irix 6.5 documents it in fcntl(5).  mtk, May 2007 Also, FreeBSD documents it (Apr 2014). type: Plain text
en: Several systems have more fields in I<struct flock> such as, for example, I<l_sysid> (to identify the machine where the lock is held).  Clearly, I<l_pid> alone is not going to be very useful if the process holding the lock may live on a different machine; on Linux, while present on some architectures (such as MIPS32), this field is not used.
de: Bei einer Reihe von Systemen gibt es in I<struct flock> weitere Felder wie z.B. I<l_sysid> (zur Identifizierung der Maschine, auf der die Sperre gehalten wird). Es ist klar, dass I<l_pid> alleine nicht sehr nützlich ist, falls der Prozess, der die Sperre hält, auf einer anderen Maschine existiert. Unter Linux wird dieses Feld, auch wenn es auf einigen Architekturen (wie MIPS32) vorhanden ist, nicht verwandt.

note: type: SS
en: Record locking and NFS
de: Datensatzsperren und NFS

note: Neil Brown: With NFSv3 the failure mode is the reverse.  If the server loses contact with a client then any lock stays in place indefinitely ("why can't I read my mail"... I remember it well). Jeff Layton: Note that this is not a firm timeout. The server runs a job periodically to clean out expired 
en: Before Linux 3.12, if an NFSv4 client loses contact with the server for a period of time (defined as more than 90 seconds with no communication), it might lose and regain a lock without ever being aware of the fact.  (The period of time after which contact is assumed lost is known as the NFSv4 leasetime.  On a Linux NFS server, this can be determined by looking at I</proc/fs/nfsd/nfsv4leasetime>, which expresses the period in seconds.  The default value for this file is 90.)  This scenario potentially risks data corruption, since another process might acquire a lock in the intervening period and perform file I/O.
de: Falls ein NFSv4-Client vor Linux 3.12 den Kontakt mit dem Server für eine bestimmte Zeitperiode (definiert als mehr als 90 Sekunden ohne Kommunikation) verlor, konnte er eine Sperre verlieren und wieder erlangen, ohne von dieser Tatsache Kenntnis zu erhalten. (Die Zeitperiode, nach der der Kontakt als verloren angesehen wird, ist als NFSv4-Ausleihzeit bekannt. Auf einem Linux-NFS-Server kann diese durch einen Blick in I</proc/fs/nfsd/nfsv4leasetime>, die diese Periode in Sekunden ausdrückt, bestimmt werden. Der Vorgabewert für diese Datei ist 90.) In diesem Szenario sind potenziell Datenbeschädigungen möglich, da ein anderer Prozess in der Zwischenzeit eine Sperre erlangen und Datei-E/A durchführen könnte.

note: commit ef1820f9be27b6ad158f433ab38002ab8131db4d commit f6de7a39c181dfb8a2c534661a53c73afb3081cd type: Plain text
en: Since Linux 3.12, if an NFSv4 client loses contact with the server, any I/O to the file by a process which "thinks" it holds a lock will fail until that process closes and reopens the file.  A kernel parameter, I<nfs.recover_lost_locks>, can be set to 1 to obtain the pre-3.12 behavior, whereby the client will attempt to recover lost locks when contact is reestablished with the server.  Because of the attendant risk of data corruption, this parameter defaults to 0 (disabled).
de: Wenn seit Linux 3.12 ein NFSv4-Client den Kontakt mit dem Server verliert, wird jede E/A des Prozesses, der »glaubt«, er halte eine Sperre, fehlschlagen, bis dieser Prozess die Datei schließt und erneut öffnet. Ein Kernelparameter (I<nfs.recover_lost_locks>) kann auf 1 gesetzt werden, um das pre-3.12-Verhalten zu erreichen, bei dem ein Client versuchen wird, verloren gegangene Sperren wiederherzustellen, wenn der Kontakt mit dem Server wieder etabliert ist. Aufgrund des vorhandenen Risikos der Datenverfälschung ist die Vorgabe für diesen Parameter 0 (deaktiviert).

note: type: SH
en: BUGS
de: FEHLER

note: FIXME . According to POSIX.1-2001, O_SYNC should also be modifiable via fcntl(2), but currently Linux does not permit this See http://bugzilla.kernel.org/show_bug.cgi?id=5994 type: Plain text
en: It is not possible to use B<F_SETFL> to change the state of the B<O_DSYNC> and B<O_SYNC> flags.  Attempts to change the state of these flags are silently ignored.
de: Es ist nicht möglich, B<F_SETFL> zum Ändern des Zustands der Schalter B<O_DSYNC> und B<O_SYNC> zu verwenden. Versuche, den Zustand dieser Schalter zu ändern, werden ohne Meldung ignoriert.

note: glibc source: sysdeps/unix/sysv/linux/i386/sysdep.h mtk, Dec 04: some limited testing on alpha and ia64 seems to indicate that ANY negative PGID value will cause F_GETOWN to misinterpret the return as an error. Some other architectures seem to have the same range check as i386. type: Plain text
en: A limitation of the Linux system call conventions on some architectures (notably i386) means that if a (negative)  process group ID to be returned by B<F_GETOWN> falls in the range -1 to -4095, then the return value is wrongly interpreted by glibc as an error in the system call; that is, the return value of B<fcntl>()  will be -1, and I<errno> will contain the (positive) process group ID.  The Linux-specific B<F_GETOWN_EX> operation avoids this problem.  Since glibc version 2.11, glibc makes the kernel B<F_GETOWN> problem invisible by implementing B<F_GETOWN> using B<F_GETOWN_EX>.
de: Eine Begrenzung der Linux-Systemaufrufkonventionen auf einigen Architekturen (insbesondere i386) bedeutet, dass, falls eine von B<F_GETOWN> zurückgelieferte (negative) Prozessgruppenkennung in den Bereich -1 bis -4095 fällt, dies von Glibc fälschlicherweise als Fehler im Systemaufruf interpretiert wird. Dann wird der Rückgabewert von B<fcntl>() -1 sein und I<errno> wird die (positive) Prozessgruppenkennung enthalten. Die Linux-spezifische Aktion B<F_GETOWN_EX> vermeidet dieses Problem. Seit Glibc Version 2.11 versteckt Glibc das Kernelproblem B<F_GETOWN>, indem B<F_GETOWN> mittels B<F_GETOWN_EX> implementiert wird.

note: type: Plain text
en: In Linux 2.4 and earlier, there is bug that can occur when an unprivileged process uses B<F_SETOWN> to specify the owner of a socket file descriptor as a process (group) other than the caller.  In this case, B<fcntl>()  can return -1 with I<errno> set to B<EPERM>, even when the owner process (group) is one that the caller has permission to send signals to.  Despite this error return, the file descriptor owner is set, and signals will be sent to the owner.
de: Unter Linux 2.4 und älter gibt es einen Fehler, der auftreten kann, wenn ein unprivilegierter Prozess statt einem Aufrufenden B<F_SETOWN> verwendet, um den Eigentümer eines Socket-Dateideskriptors als Prozess(gruppe) festzulegen. In diesem Fall kann B<fcntl>() -1 mit I<errno> auf B<EPERM> gesetzt zurückliefern, selbst wenn der/die Eigentümerprozess(gruppe) dergestalt ist, dass der Aufrufende Rechte hat, ihr/ihm Signale zu senden. Trotz dieses zurückgelieferten Fehlers wird der Dateieigentümer gesetzt und Signale werden zum Eigentümer gesandt.

note: type: SS
en: Deadlock detection
de: Erkennung von Verklemmungen

note: type: Plain text
en: The deadlock-detection algorithm employed by the kernel when dealing with B<F_SETLKW> requests can yield both false negatives (failures to detect deadlocks, leaving a set of deadlocked processes blocked indefinitely)  and false positives (B<EDEADLK> errors when there is no deadlock).  For example, the kernel limits the lock depth of its dependency search to 10 steps, meaning that circular deadlock chains that exceed that size will not be detected.  In addition, the kernel may falsely indicate a deadlock when two or more processes created using the B<clone>(2)  B<CLONE_FILES> flag place locks that appear (to the kernel) to conflict.
de: Der vom Kernel eingesetzte Algorithmus zur Erkennung von Verklemmungen beim Umgang mit B<F_SETLKW> kann sowohl falsch-negative (keine Erkennung von Verklemmungen, eine Gruppe von verklemmten Prozessen bleibt unbegrenzt blockiert) als auch falsch-positive (B<EDEADLK>-Fehler obwohl keine Verklemmung vorliegt) liefern. Beispielsweise begrenzt der Kernel die Sperrtiefe seiner Abhängigkeitssuche auf 10 Schritte, was bedeutet, dass zirkulare Verklemmungsketten, die diese Größe überschreiten, nicht erkannt werden. Zusätzlich kann der Kernel fälschlicherweise eine Verklemmung erkennen, wenn zwei oder mehr Prozesse, die mit dem Schalter B<CLONE_FILES> von B<clone>(2) Sperren setzen, die (dem Kernel) als im Konflikt stehend erscheinen.

note: http://marc.info/?l=linux-kernel&m=119013491707153&w=2 Reconfirmed by Jeff Layton From: Jeff Layton <jlayton <at> redhat.com> Subject: Re: Status of fcntl() mandatory locking Newsgroups: gmane.linux.file-systems Date: 2014-04-28 10:07:57 GMT http://thread.gmane.org/gmane.linux.file-systems/84481/foc
en: The Linux implementation of mandatory locking is subject to race conditions which render it unreliable: a B<write>(2)  call that overlaps with a lock may modify data after the mandatory lock is acquired; a B<read>(2)  call that overlaps with a lock may detect changes to data that were made only after a write lock was acquired.  Similar races exist between mandatory locks and B<mmap>(2).  It is therefore inadvisable to rely on mandatory locking.
de: Die Linux-Implementierung von Pflichtsperren ist Gegenstand von Ressourcenwettläufen, die sie unzuverlässig machen: Ein B<write>(2)-Aufruf, der sich mit einer Sperre überschneidet, kann Daten verändern, nachdem die Pflichtsperre erlangt wurde. Ein B<read>(2)-Aufruf, der sich mit einer Sperre überschneidet, kann Änderungen an Daten entdecken, die nur vorgenommen wurden, nachdem eine Schreibsperre erlangt wurde. Ähnliche Wettläufe gibt es zwischen Pflichtsperren und B<mmap>(2). Daher ist es nicht zu empfehlen, sich auf Pflichtsperren zu verlassen.

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

note: type: Plain text
en: I<locks.txt>, I<mandatory-locking.txt>, and I<dnotify.txt> in the Linux kernel source directory I<Documentation/filesystems/> (on older kernels, these files are directly under the I<Documentation/> directory, and I<mandatory-locking.txt> is called I<mandatory.txt>)
de: I<locks.txt>, I<mandatory-locking.txt> und I<dnotify.txt> in dem Linux-Kernelquelldateiverzeichnis I<Documentation/filesystems/>. (Bei älteren Kerneln befinden sich diese Dateien direkt unter dem Verzeichnis I<Documentation/> und I<mandatory-locking.txt> heißt I<mandatory.txt>.)

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

note: type: Plain text
en: 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/.
