`_locking`

Artikel
08/03/2024

Sperrt oder entsperrt Bytes einer Datei.

Syntax

int _locking(
   int fd,
   int mode,
   long nbytes
);

Parameter

fd
Dateideskriptor.

mode
Die auszuführende Sperraktion

nbytes
Die Anzahl der zu sperrenden Bytes.

Rückgabewert

_locking gibt bei Erfolg 0 zurück. Ein Rückgabewert von -1 gibt einen Fehler an, in diesem Fall errno wird auf einen der folgenden Werte festgelegt.

Wert vom Typ `errno`	Bedingung
`EACCES`	Sperrverletzung (Datei bereits gesperrt oder entsperrt).
`EBADF`	Ungültiger Dateideskriptor.
`EDEADLOCK`	Sperrverletzung. Wird zurückgegeben, wenn das `_LK_LOCK` `_LK_RLCK` Attribut angegeben ist und die Datei nach 10 Versuchen nicht gesperrt werden kann.
`EINVAL`	Ein ungültiges Argument wurde an `_locking` übergeben.

Wenn der Fehler auf einen ungültigen Parameter zurückzuführen ist, z. B. ein ungültiger Dateideskriptor, wird der ungültige Parameterhandler aufgerufen, wie in der Parameterüberprüfung beschrieben.

Hinweise

Die _locking Funktion sperrt nbytes Bytes der durch fd. Das Sperren von Bytes in einer Datei verhindert den Zugriff auf diese Bytes durch andere Prozesse. Alle Sperren oder Entsperrungen beginnen an der aktuellen Position des Dateizeigers und fahren mit den nächsten nbytes Bytes fort. Es ist möglich, Bytes am Ende der Datei zu sperren.

mode muss eine der folgenden Manifestkonstanten sein, die in Locking.h definiert sind.

Wert vom Typ `mode`	Auswirkung
`_LK_LOCK`	Sperrt die angegebenen Bytes. Wenn die Bytes nicht gesperrt werden können, wird das Programm sofort nach 1 Sekunde erneut versucht. Wenn die Bytes nach 10 Versuchen nicht gesperrt werden können, gibt die Konstante einen Fehler zurück.
`_LK_NBLCK`	Sperrt die angegebenen Bytes. Wenn die Bytes nicht gesperrt werden können, gibt die Konstante einen Fehler zurück.
`_LK_NBRLCK`	Wie in `_LK_NBLCK`.
`_LK_RLCK`	Wie in `_LK_LOCK`.
`_LK_UNLCK`	Entsperrt die angegebenen Bytes, die zuvor gesperrt sein mussten.

Mehrere Bereiche einer Datei, die sich nicht überlappen, können gesperrt werden. Ein Bereich, der entsperrt wird, muss zuvor gesperrt worden sein. _locking verbindet keine angrenzenden Regionen; Wenn zwei gesperrte Bereiche nebeneinander liegen, muss jede Region separat entsperrt werden. Bereichen sollten nur über einen kurzen Zeitraum gesperrt sein und sollten entsperrt werden, bevor eine Datei geschlossen oder das Programm beendet wird.

Standardmäßig gilt der globale Zustand dieser Funktion für die Anwendung. Wie Sie dieses Verhalten ändern, erfahren Sie unter Globaler Status in der CRT.

Anforderungen

Routine	Erforderlicher Header	Optionaler Header
`_locking`	<io.h> und <sys/locking.h>	<errno.h>

Weitere Informationen zur Kompatibilität finden Sie unter Kompatibilität.

Libraries

Alle Versionen der C-Laufzeitbibliotheken.

Beispiel

// crt_locking.c
/* This program opens a file with sharing. It locks
* some bytes before reading them, then unlocks them. Note that the
* program works correctly only if the file exists.
*/

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/locking.h>
#include <share.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>

int main( void )
{
   int  fh, numread;
   char buffer[40];

   /* Quit if can't open file or system doesn't
    * support sharing.
    */
   errno_t err = _sopen_s( &fh, "crt_locking.txt", _O_RDONLY, _SH_DENYNO,
                          _S_IREAD | _S_IWRITE );
   printf( "%d %d\n", err, fh );
   if( err != 0 )
      exit( 1 );

   /* Lock some bytes and read them. Then unlock. */
   if( _locking( fh, LK_NBLCK, 30L ) != -1 )
   {
      long lseek_ret;
      printf( "No one can change these bytes while I'm reading them\n" );
      numread = _read( fh, buffer, 30 );
      buffer[30] = '\0';
      printf( "%d bytes read: %.30s\n", numread, buffer );
      lseek_ret = _lseek( fh, 0L, SEEK_SET );
      _locking( fh, LK_UNLCK, 30L );
      printf( "Now I'm done. Do what you will with them\n" );
   }
   else
      perror( "Locking failed\n" );

   _close( fh );
}

Eingabe: crt_locking.txt

The first thirty bytes of this file will be locked.

Beispielausgabe

No one can change these bytes while I'm reading them
30 bytes read: The first thirty bytes of this
Now I'm done. Do what you will with them

Siehe auch

Dateibehandlung
_creat, _wcreat
_open, _wopen

Freigeben über