File lock:
File lock using fcntl()
NAME
fcntl - manipulate file descriptor
SYNOPSIS
#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );
DESCRIPTION
- fcntl() performs one of the operations described below on the open file descriptor fd. The operation is determined by cmd.
- fcntl() can take an optional third argument. Whether or not this argument is required is determined by cmd. The required argument type is indicated in parentheses after each cmd name (in most cases, the required type is int, and we identify the argument using the name arg), or void is specified if the argument is not required.
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
(F_GETLK only) */
...
};
- The l_whence, l_start, and 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.
- F_SETLK (struct flock *)
- Acquire a lock (when l_type is F_RDLCK or F_WRLCK) or release a lock (when l_type is F_UNLCK) on the bytes specified by the l_whence, l_start, and l_len fields of lock.
- If a conflicting lock is held by another process, this call returns -1 and sets errno to EACCES or EAGAIN.
- F_SETLKW (struct flock *)
- As for 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 errno set to EINTR;
- Note: currently we are using F_SETLKW
- F_GETLK (struct flock *)
- On input to this call, lock describes a lock we would like to place on the file. If the lock could be placed, fcntl() does not actually place it, but returns F_UNLCK in the l_type field of lock and leaves the other fields of the structure unchanged.
- If one or more incompatible locks would prevent this lock being placed, then fcntl() returns details about one of these locks in the l_type, l_whence, l_start, and l_len fields of lock and sets l_pid to be the PID of the process holding that lock.
Note: In order to place a read lock, fd must be open for reading. In order to place a write lock, fd must be open for writing. To place both types of lock, open a file read-write.
RETURN VALUE
On Success return 0, otherwise retun -1 and errno is set appropriately.
My Understand:
- Read lock:
- Read lock will be blocked if already this file is locked.
- After unlock it won't reeceive value, but next call it will get
- Write lock:
- Write lock will be blocked if already this file is locked with write lock on another process.
- After unlock, it exeepcted to overwrite the old value, but reality it won't overwrite the value the output file file contain both value, need to handle this if 2 differect process take the write lock.
Program:
/* File lock using fcntl()
* Check : http://velrajcoding.blogspot.in
*/
#include <stdio.h>
#include <unistd.h> // For fcntl
#include <fcntl.h> // For struct flock, F_WRLCK & F_SETLKW
#include <errno.h> // For errno
enum {
FILE_LOCK,
FILE_UNLOCK,
};
int file_lock_and_ulock(int fd, const char *path, int is_lock, char ch)
{
char str[128] = {0};
struct flock lock;
lock.l_type = (is_lock == FILE_LOCK) ? ((ch == 'r') ? F_RDLCK : F_WRLCK) : F_UNLCK;
lock.l_start = 0;
lock.l_whence = SEEK_SET;
lock.l_len = 0;
lock.l_pid = getpid();
/*
* Read lock: read lock will be blocked if already this file is locked.
* After unlock it won't reeceive value, but next call it will get
* Write lock: Write lock will be blocked if already this file is locked with write lock on another process.
* After unlock, it exeepcted to overwrite the old value, but reality it won't overwrite the value
* the output file file contain both value, need to handle this if 2 differect process take the write lock
*/
if (fcntl(fd, F_SETLKW, &lock) < 0) {
strerror_r(errno, str, sizeof(str));
printf("Error to lock the file errno:%d err des:%s \n", errno, str);
return 0;
}
printf("File %s is %s \n", path, (is_lock == FILE_LOCK) ? "Locked" : "Unlocked");
return 1;
}
int file_read()
{
FILE *fp = NULL;
int ret = 0, value = 0;
unsigned long value_l = 0;
char str[128] = {0};
char str_2[128] = {0};
fp = fopen("test.txt", "r");
if (!fp) {
printf("File open is failed errno:%d ENOENT:<%d>\n", errno, ENOENT);
return 1;
}
ret = file_lock_and_ulock(fileno(fp), "test.txt", FILE_LOCK, 'r');
if (ret == 0) {
printf("Error in locking \n");
return 1;
}
fgets(str, sizeof(str), fp);
fseek(fp, 0, SEEK_SET);
fscanf(fp, "%s %d", str, &value);
file_lock_and_ulock(fileno(fp), "test.txt", FILE_UNLOCK, 'r');
printf("File content on filst line:<%s> & fscan read:%d \n", str, value);
fseek(fp, 0, SEEK_SET);
if (fgets(str, sizeof(str), fp) == NULL) {
printf("Error in retrienve \n");
}
memset(str_2, 0, sizeof(str));
value_l = 0;
if ((ret = sscanf(str, "%s %lu", str_2, &value_l)) != 2) {
printf("Error in sscanf: %d \n", ret);
}
printf("File content using fgets & sscanf line:<%s> & fscan read:%d ret:%d \n", str, value_l, ret);
return 0;
}
int main()
{
FILE *fp = NULL;
int ret = 0, choose = 0;
printf("Option for file operation: \n\t\t 1. Read \n\t\t 2.Write \n Choose your option: ");
scanf("%d", &choose);
switch (choose) {
case 1:
file_read();
break;
case 2:
fp = fopen("test.txt", "w");
ret = file_lock_and_ulock(fileno(fp), "test.txt", FILE_LOCK, 'w');
#if defined (AVOID_OVERRIGHT)
fflush(fp);
fsync(fileno(fp));
#endif
if (ret == 0) {
printf("Error in locking \n");
return 1;
}
//sleep(5);
fprintf(fp, "file_w_lock_b.c 2nd\n");
fflush(fp);
fsync(fileno(fp));
file_lock_and_ulock(fileno(fp), "test.txt", FILE_UNLOCK, 'w');
fclose(fp);
break;
default:
printf("Wrong option \n");
}
return 0;
}
Program 2:
/* File lock using fcntl()
* Check : http://velrajcoding.blogspot.in
*/
#include <stdio.h>
#include <unistd.h> // For fcntl
#include <fcntl.h> // For struct flock, F_WRLCK & F_SETLKW
#include <errno.h> // For errno
enum {
FILE_LOCK,
FILE_UNLOCK,
};
int file_lock_and_ulock(int fd, const char *path, int is_lock)
{
char str[128] = {0};
struct flock lock;
lock.l_type = (is_lock == FILE_LOCK) ? F_WRLCK : F_UNLCK;
lock.l_start = 0;
lock.l_whence = SEEK_SET;
lock.l_len = 0;
lock.l_pid = getpid();
if (fcntl(fd, F_SETLKW, &lock) < 0) {
strerror_r(errno, str, sizeof(str));
printf("Error to lock the file errno:%d err des:%s \n", errno, str);
return 0;
}
printf("File %s is %s \n", path, (is_lock == FILE_LOCK) ? "Locked" : "Unlocked");
return 1;
}
int file_check_back_slan_n()
{
FILE *fp = NULL;
int temp = 0;
char str[128] = {0};
if (!(fp = fopen("test_2.txt", "w+"))) {
printf("Error in open a file \n");
return 1;
}
fprintf(fp, "velraj \n serte %d", 100);
fflush(fp);
fsync(fileno(fp));
fseek(fp, 0, SEEK_SET);
fscanf(fp, "%d", &temp);
fseek(fp, 0, SEEK_SET);
fgets(str, sizeof(str), fp);
printf("Vel fscanf int:<%d> fgets:<%s> \n", temp, str);
fclose(fp);
return 0;
}
int main()
{
FILE *fp;
char str[128] = {0};
/*
* w Truncate file to zero length or create text file for writing. The stream is positioned at the beginning of the file.
* w+ Open for reading and writing. The file is created if it does not exist, otherwise it is truncated. The stream is positioned at the beginning of the file.
*/
if ((fp = fopen("test.txt", "w"))) {
file_lock_and_ulock(fileno(fp), "test.txt", FILE_LOCK);
} else {
strerror_r(errno, str, sizeof(str));
printf("Error to open a file errno:%d err des:%s \n", errno, str);
return 1;
}
fprintf(fp, "file_w_lock.c: 1 This is testing for fprintf...\n");
// fputs("This is testing for fputs...\n", fp);
#if defined (FLUSH_SYNC_AFTER_SLEEP)
printf("Going to sleep and flush flush & sync after sleep");
sleep(10);
#endif
fflush(fp);
fsync(fileno(fp));
#if !defined (FLUSH_SYNC_AFTER_SLEEP)
printf("flush & sync donw now gonig to sleep ");
/* After flush & sync the file */
sleep(10);
#endif
file_lock_and_ulock(fileno(fp), "test.txt", FILE_UNLOCK);
fclose(fp);
return 0;
if ((fp = fopen("test.txt", "w"))) {
file_lock_and_ulock(fileno(fp), "test.txt", FILE_LOCK);
} else {
strerror_r(errno, str, sizeof(str));
printf("Error to open a file errno:%d err des:%s \n", errno, str);
return 1;
}
fflush(fp);
fsync(fileno(fp));
file_lock_and_ulock(fileno(fp), "test.txt", FILE_UNLOCK);
fclose(fp);
file_check_back_slan_n();
return 0;
}
Output:
Lock & lock from first terminal 1st terminal:
abuser@labuser-virtual-machine:~/velrajk/sample$ ./a.out
File test.txt is Locked
File test.txt is Unlocked
labuser@labuser-virtual-machine:~/velrajk/sample$
labuser@labuser-virtual-machine:~/velrajk/sample$
Not using lock on second file 2nd terminal:
abuser@labuser-virtual-machine:~/velrajk/sample$
labuser@labuser-virtual-machine:~/velrajk/sample$
labuser@labuser-virtual-machine:~/velrajk/sample$ cat test.txt
from_2
labuser@labuser-virtual-machine:~/velrajk/sample$ === now antoher progr is still inlocking ======
===: command not found
labuser@labuser-virtual-machine:~/velrajk/sample$
labuser@labuser-virtual-machine:~/velrajk/sample$
labuser@labuser-virtual-machine:~/velrajk/sample$ ==== that is over unlcoked here not used lock ====
====: command not found
labuser@labuser-virtual-machine:~/velrajk/sample$ cat test.txt
This is testing for fprintf...
This is testing for fputs...
labuser@labuser-virtual-machine:~/velrajk/sample$
issue:
------
Lock on process 1 process 2 is got hanged due to process 1 lock, after process 1 release, process 2 write on first still process 1 data also present.
labuser@labuser-virtual-machine:~/velrajk/sample$ cat test.txt
from_2
testing for fprintf...
This is testing for fputs...
labuser@labuser-virtual-machine:~/velrajk/sample$
