Problem - Kevin Tafuro

int spc_lock_file(const char *lfpath) {
int attempt, fd, result;
pid_t pid;
/* Try three times, if we fail that many times, we lose */
for (attempt = 0; attempt < 3; attempt++) {
if ((fd = open(lfpath, O_RDWR | O_CREAT | O_EXCL, S_IRWXU)) = = -1) {
if (errno != EEXIST) return -1;
if ((fd = open(lfpath, O_RDONLY)) = = -1) return -1;
result = read_data(fd, &pid, sizeof(pid));
close(fd);
if (result) {
if (pid = = getpid( )) return 1;
if (kill(pid, 0) = = -1) {
if (errno != ESRCH) return -1;
attempt--;
unlink(lfpath);
continue;
}
}
sleep(1);
continue;
}
pid = getpid( );
if (!write_data(fd, &pid, sizeof(pid))) {
close(fd);
return -1;
}
close(fd);
attempt--;
}
/* If we've made it to here, three attempts have been made and the lock could
* not be obtained. Return an error code indicating failure to obtain the
* requested lock.
*/
return 0;
}
The first step in attempting to obtain the lock is to try to create the lock file. If this
succeeds, the caller’s process ID is written to the file, the file is closed, and the loop is
executed again. The loop counter is decremented first to ensure that at least one
more iteration will always occur. The next time through the loop, creating the file
should fail but won’t necessarily do so, because another process was attempting to
get the lock at the same time from a stale process and deleted the lock file out from
under this process. If this happens, the whole process begins again.
If the lock file cannot be created, the lock file is opened for reading, and the ID of the
process holding the lock is read from the file. The read is blocking, so if another process
has begun to write out its ID, the read will block until the other process is done.
Another race condition here could be avoided by performing a non-blocking read in
62 | Chapter 2: Access Control
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.