fcntl F_GETLK gibt immer F_UNLCK zurück

Question

Ich versuche, POSIX-Datei-Region-Sperren in C zu verstehen. Das folgende Programm ist wirklich einfach, setzt die Sperre auf F_WRLCK und erhält dann Sperren. Es gibt keine Fehler beim Öffnen/Einstellen der Sperre. Unglücklicherweise gibt es immer F_UNLCK zurück. Wo ist der Fehler? Ist es möglich, dass OSX nicht richtig funktioniert?

#include <stdio.h> 
#include <stdlib.h> 
#include <errno.h> 
#include <fcntl.h> 
#include <unistd.h> 
#include <string.h> 
void printLockType(int lock) { 
    if (lock == F_RDLCK) { 
      printf("readlock %i \n", lock); 
    }else if (lock == F_WRLCK) { 
      printf("writelock %i \n", lock); 
    }else if (lock == F_UNLCK) { 
      printf("unlock %i \n", lock); 
    } else { 
      printf("other %i\n", lock); 
    } 
} 
int main(int argc, char *argv[]) 
{  
    int fd; 
    struct flock fl ,fl2; 

    fl2.l_type = F_RDLCK; /* read/write lock */ 
    fl2.l_whence = 0; /* beginning of file */ 
    fl2.l_start = 0;  /* offset from l_whence */ 
    fl2.l_len = 100;  /* length, 0 = to EOF */ 
    fl2.l_pid = getpid(); 

    fl.l_type = F_WRLCK; /* read/write lock */ 
    fl.l_whence = 0; /* beginning of file */ 
    fl.l_start = 0;  /* offset from l_whence */ 
    fl.l_len = 1000;  /* length, 0 = to EOF */ 
    fl.l_pid = getpid(); 

    if ((fd = open("xxx", O_RDWR)) == -1) { 
     perror("open"); 
     exit(1); 
    } 


    if (fcntl(fd, F_SETLK, &fl) == -1) { 
     perror("fcntl"); 
     exit(1); 
    } 

    if(fcntl(fd, F_GETLK, &fl2) == -1) { 
     printf("%s \n", strerror(errno)); 
    } else { 
     printLockType(fl2.l_type); 
    } 

    return 0; 
} 

Answer 1

Sie missverstehen die F_GETLK Abfrage. Es gibt F_UNLCK zurück, wenn nichts den aufrufenden Prozess blockiert, eine Sperre des gegebenen Typs an der gegebenen Position zu platzieren.

Da der aufrufende Prozess derjenige ist, der diese vorhandenen Sperren erstellt hat, kann er auch diese neue Sperre erstellen.

---

Die Mac OS X manuals sagen

F_GETLK 

das erste Schloss Holen blockiert, dass die Sperre Beschreibung durch das dritte Argument hingewiesen, Arg, als Zeiger auf eine struct flock genommen (siehe oben) . Die abgerufenen Informationen überschreiben die Informationen, die an fcntl in der Flockstruktur übergeben werden. Wenn keine Sperre gefunden wird, die verhindern würde, dass diese Sperre erstellt wird, wird die Struktur durch diesen Funktionsaufruf unverändert gelassen, mit Ausnahme von für den Sperrtyp, der auf F_UNLCK gesetzt ist.