`_locking`

Article
10/12/2023

Verrouille ou déverrouille les octets d’un fichier.

Syntaxe

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

Paramètres

fd
Descripteur de fichier.

mode
Action de verrouillage à exécuter.

nbytes
Nombre d’octets à verrouiller.

Valeur retournée

_locking retourne 0 en cas de réussite. Une valeur de retour de -1 indique l’échec, auquel cas errno est défini sur l’une des valeurs suivantes.

Valeur `errno`	Condition
`EACCES`	Violation de verrouillage (fichier déjà verrouillé ou déverrouillé).
`EBADF`	Descripteur de fichier non valide.
`EDEADLOCK`	Violation de verrouillage. Retourné lorsque le ou `_LK_RLCK` l’indicateur `_LK_LOCK` est spécifié et que le fichier ne peut pas être verrouillé après 10 tentatives.
`EINVAL`	Un argument non valide a été donné à `_locking`.

Si l’échec est dû à un paramètre incorrect, tel qu’un descripteur de fichier non valide, le gestionnaire de paramètres non valide est appelé, comme décrit dans la validation des paramètres.

Notes

La _locking fonction verrouille ou déverrouille les octets nbytes du fichier spécifié par fd. Le verrouillage d’octets dans un fichier empêche l’accès à ces octets par d’autres processus. Tout verrouillage ou déverrouillage commence à la position actuelle du pointeur de fichier et se poursuit pour les octets suivants nbytes . Il est possible de verrouiller les octets après la fin du fichier.

mode doit être l’une des constantes de manifeste suivantes, qui sont définies dans Locking.h.

Valeur `mode`	Effet
`_LK_LOCK`	Verrouille les octets spécifiés. Si les octets ne peuvent pas être verrouillés, le programme tente immédiatement après 1 seconde. Si les octets ne peuvent pas être verrouillés après 10 tentatives, la constante retourne une erreur.
`_LK_NBLCK`	Verrouille les octets spécifiés. Si les octets ne peuvent pas être verrouillés, la constante retourne une erreur.
`_LK_NBRLCK`	Comme pour `_LK_NBLCK`.
`_LK_RLCK`	Comme pour `_LK_LOCK`.
`_LK_UNLCK`	Déverrouille les octets spécifiés, qui doivent avoir été verrouillés auparavant.

Plusieurs régions d’un fichier qui ne se chevauchent pas peuvent être verrouillées. Une zone ne peut être déverrouillée que si elle a été verrouillée. _locking ne fusionne pas les régions adjacentes ; si deux régions verrouillées sont adjacentes, chaque région doit être déverrouillée séparément. Le verrouillage des zones doit être de courte durée et celles-ci doivent être déverrouillées avant de fermer un fichier ou de quitter le programme.

Par défaut, l’état global de cette fonction est limité à l’application. Pour modifier ce comportement, consultez État global dans le CRT.

Spécifications

Routine	En-tête requis	En-tête facultatif
`_locking`	<io.h> et <sys/locking.h>	<errno.h>

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Bibliothèques

Toutes les versions des bibliothèques Runtime C.

Exemple

// 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 );
}

Entrée : crt_locking.txt

The first thirty bytes of this file will be locked.

Exemple de sortie

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

Voir aussi

Gestion des fichiers
_creat, _wcreat
_open, _wopen

Partager via