fcntl函数详解

最新推荐文章于 2024-08-30 08:06:39 发布
最新推荐文章于 2024-08-30 08:06:39 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： linux 文章标签： path file cmd struct byte action

表头文件 #include
#include

定义函数 int fcntl(int fd , int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock * lock);

fcntl()用来操作文件描述词的一些特性。参数fd代表欲设置的文件描述词，参数cmd代表欲操作的指令。
有以下几种情况:
F_DUPFD用来查找大于或等于参数arg的最小且仍未使用的文件描述词，并且复制参数fd的文件描述词。执行成功则返回新复制的文件描述词。请参考dup2()。F_GETFD取得close-on-exec旗标。若此旗标的FD_CLOEXEC位为0，代表在调用exec()相关函数时文件将不会关闭。
F_SETFD 设置close-on-exec 旗标。该旗标以参数arg 的FD_CLOEXEC位决定。
F_GETFL 取得文件描述词状态旗标，此旗标为open（）的参数flags。
F_SETFL 设置文件描述词状态旗标，参数arg为新旗标，但只允许O_APPEND、O_NONBLOCK和O_ASYNC位的改变，其他位的改变将不受影响。
F_GETLK 取得文件锁定的状态。
F_SETLK 设置文件锁定的状态。此时flcok 结构的l_type 值必须是F_RDLCK、F_WRLCK或F_UNLCK。如果无法建立锁定，则返回-1，错误代码为EACCES 或EAGAIN。
F_SETLKW F_SETLK 作用相同，但是无法建立锁定时，此调用会一直等到锁定动作成功为止。若在等待锁定的过程中被信号中断时，会立即返回-1，错误代码为EINTR。参数lock指针为flock 结构指针，定义如下
struct flcok
{
short int l_type; 
short int l_whence;
off_t l_start; 
off_t l_len; 
pid_t l_pid; 
};
l_type 有三种状态:
F_RDLCK 建立一个供读取用的锁定
F_WRLCK 建立一个供写入用的锁定
F_UNLCK 删除之前建立的锁定
l_whence 也有三种方式:
SEEK_SET 以文件开头为锁定的起始位置。
SEEK_CUR 以目前文件读写位置为锁定的起始位置
SEEK_END 以文件结尾为锁定的起始位置。
 
返回值  成功则返回0，若有错误则返回-1，错误原因存于errno.

 

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

#include <fcntl.h>

int     lock_reg(int, int, int, off_t, int, off_t); 
#define read_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
#define readw_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLKW, F_RDLCK, (offset), (whence), (len))
#define write_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
#define writew_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLKW, F_WRLCK, (offset), (whence), (len))
#define un_lock(fd, offset, whence, len) \
	lock_reg((fd), F_SETLK, F_UNLCK, (offset), (whence), (len))

pid_t   lock_test(int, int, off_t, int, off_t); 

#define is_read_lockable(fd, offset, whence, len) \
	(lock_test((fd), F_RDLCK, (offset), (whence), (len)) == 0)
#define is_write_lockable(fd, offset, whence, len) \
	(lock_test((fd), F_WRLCK, (offset), (whence), (len)) == 0)


int lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
	struct flock    lock;

	lock.l_type = type;     /* F_RDLCK, F_WRLCK, F_UNLCK */
	lock.l_start = offset;  /* byte offset, relative to l_whence */
	lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */
	lock.l_len = len;       /* #bytes (0 means to EOF) */

	return(fcntl(fd, cmd, &lock));
}

/* Note: lock_test always success with the obtained lock process */
pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len)
{
	struct flock    lock;

	lock.l_type = type;     /* F_RDLCK or F_WRLCK */
	lock.l_start = offset;  /* byte offset, relative to l_whence */
	lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */
	lock.l_len = len;       /* #bytes (0 means to EOF) */

	if (fcntl(fd, F_GETLK, &lock) < 0)
		perror("fcntl error");

	/* printf("F_RDLCK=%d, F_WRLCK=%d, F_UNLCK=%d\n", F_RDLCK, F_WRLCK, F_UNLCK); */
	printf("    l_type=%d, l_start=%lu, l_where=%d, l_len=%lu, l_pid=%d\n"
		, lock.l_type, lock.l_start, lock.l_whence, lock.l_len, lock.l_type);

	if (lock.l_type == F_UNLCK)
		return(0);      /* false, region isn't locked by another proc */
	return(lock.l_pid); /* true, return pid of lock owner */
}

/* ========================================================  */

void Usage(const char* program)
{
	fprintf(stderr, "Usage: %s read/read2/write/rd-wr/wr-rd/fork/dup file time\n", program);
	exit(-1);
}

int main(int argc, char *argv[])
{
	if(argc < 3){
		Usage(argv[0]);
	}
	int interval = 10;
	if(argc > 3) {
		interval = atoi(argv[3]);
	}
	printf("PID=%d\n", getpid());

	char* path = argv[2];
	if( strcmp(argv[1], "read") == 0 ) {
		int fd = fileno(fopen(path,"r"));
		if(fd == -1) {
			perror("open");
			exit(0);
		}
		printf("read lock try\n");
		/*  read lock entire file */
		if( read_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("read_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		} 
		printf("read lock success.\n");
		printf("Read Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		sleep(interval);

		exit(0);
	}
	else if( strcmp(argv[1], "read2") == 0 ){
		int fd = open(path, O_RDONLY);
		if(fd == -1) {
			perror("open");
			exit(0);
		}
		printf("read lock try\n");
		/*  read lock entire file */
		if( read_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("read_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		} 
		printf("read lock success.\n");
		printf("Read Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		if( read_lock(fd, 0, SEEK_SET, 1) < 0){
			perror("read_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		}
		printf("read lock 2 success.\n");
		sleep(interval);

		exit(0);
	}
	else if( strcmp(argv[1], "write") == 0) {
		int fd = open(path, O_WRONLY );
		printf("file: %s, fd=%d\n", path, fd);
		if(fd == -1) {
			perror("open");
			exit(0);
		}
		printf("write lock try\n");
		/*  write lock entire file */
		if( write_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("write_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			printf("Read Lock by pid=%d\n", lock_test(fd, F_RDLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		}
		printf("write lock success.\n"); 
		printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		int ret = write(fd, path, strlen(path) );
		if(ret != strlen(path)){
			perror("write");
		} 
		sleep(interval);

		close(fd);
		exit(0);
	}
	else if( strcmp(argv[1], "rd-wr") == 0){
		int fd = open(path, O_RDWR);   /* O_RDWR  */
		if(fd == -1) {
			perror("open");
			exit(0);
		}
		/*  read lock entire file */
		if( read_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("read_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		} 
		printf("read lock success.\n");
		printf("Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		/* if( un_lock(fd, 0, SEEK_SET, 0) < 0){
		perror("un-lock:");
		}                                        */

		if( write_lock(fd, 0, SEEK_SET, 1) < 0){
			perror("write_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		}
		printf("write lock success.\n");
		printf("Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
		sleep(interval);

		exit(0);

	} 
	else if( strcmp(argv[1], "wr-rd") == 0){
		int fd = open(path, O_RDWR);   /* O_RDWR */
		if(fd == -1) {
			perror("open");
			exit(0);
		}
		/*  write lock entire file */
		if( write_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("write_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		}
		printf("write lock success.\n");
		printf("Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		/* if( un_lock(fd, 0, SEEK_SET, 0) < 0){
		perror("un-lock:");
		}                                        */

		if( read_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("read_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		} 
		printf("read lock success.\n");
		printf("Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		sleep(interval);

		exit(0);
	}
	else if( strcmp(argv[1], "fork") == 0){
		int fd = open(path, O_RDWR);   /* O_RDWR */
		if(fd == -1) {
			perror("open");
			exit(0);
		}
		/*  write lock entire file */
		if( write_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("write_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		}
		printf("write lock success.\n");
		printf("Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		pid_t pid;
		if ((pid = fork()) < 0) {
			perror("un-lock:");
			exit(1);
		}
		else if(pid == 0){
			sleep(1);
			printf("New PID=%d\n", getpid());
			if( read_lock(fd, 0, SEEK_SET, 0) < 0){
				perror("read_lock: ");
				printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
				exit(0); 
			} 
			printf("read lock success.\n");
			printf("Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

			sleep(interval);

			exit(0);
		}
		else{
			exit(1);
		}
	}
	else if( strcmp(argv[1], "dup") == 0) {
		int fd = open(path, O_RDWR);   /* O_RDWR */
		if(fd == -1) {
			perror("open");
			exit(0);
		}
		/*  write lock entire file */
		if( write_lock(fd, 0, SEEK_SET, 0) < 0){
			perror("write_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		}
		printf("write lock success.\n");
		printf("Lock by pid=%d\n", lock_test(fd, F_WRLCK, 0, SEEK_SET, 0 ));

		int fd2 = 0;
		if( (fd2=dup(fd)) < 0){
			perror("dup:");
			exit(1);
		}
		close(fd);

		if( read_lock(fd2, 0, SEEK_SET, 0) < 0){
			perror("read_lock: ");
			printf("Write Lock by pid=%d\n", lock_test(fd2, F_WRLCK, 0, SEEK_SET, 0 ));
			exit(0); 
		} 
		printf("read lock success.\n");
		printf("Lock by pid=%d\n", lock_test(fd2, F_WRLCK, 0, SEEK_SET, 0 ));

		sleep(interval);

		exit(0);
	} else {
		printf("Unknown action!\n");
	}
	return 0;
}

Phoenix_FuliMa
关注
专栏目录
fcntl函数的使用详解
12-25
（1）fcntl函数说明 前面的这5个基本函数实现了文件的打开、读写等基本操作，这一节将讨论的是，在文 件已经共享的情况下如何操作，也就是当多个用户共同使用、操作一个文件的情况，这时，Linux 通常采用的方法是给文件上锁，来避免共享的资源产生竞争的状态。 文件锁包括建议性锁和强制性锁。 建议性锁要求每个上锁文件的进程都要检查是否有锁存，并且尊重已有的锁。在一般情况下，内核和系统都不使用建议性锁。强制性锁是由内 核执行的锁，当一个文件被上锁进行写入操作的时候，内核将阻止其他任何文件对其进行读写操作。采用强制性锁对性能的影响很大，每次读写操作都必须检查是否有锁存在。 在 Linux 中，实现文件
fcntl（）系统函数调用
scofiy的专栏
04-03 543
功能描述：   根据文件描述词来操作文件的特性。   用法：   int fcntl(int fd, int cmd); int fcntl(int fd, int cmd, long arg); int fcntl(int fd, int cmd, struct flock *lock);     参数：   fd：文件描述词。 cmd：操作命令。 arg：供命令使用的参数。 lock：同上。
Linux C 学习之 - fcntl 函数
socay 的专栏
12-25 962
小编在这片文章中就不说 fcntl 如何使用了，如果有不明白的地方，请转到去问度娘：“ Linux fcntl”， 她会告诉我们一大堆。 在这里我把我今天用这个函数遇到的一些问题列举下,如有写的不对的地方,还望各位高手指正,不甚感激! include #include #include int main() { int fd; int ret; struct flock
fcntl 函数
weixin_30337157的博客
05-16 129
设置文件的flags,阻塞设置成非阻塞，非阻塞设置成阻塞(这连个在server开发中可以封装为基本函数) 线程引入pthread_self和pthread_equal原因——解决不同平台的问题！ Mysql索引__索引的分类_索引的创建_使用alter建立索引(也可以在创建表时设定)、索引的分类 fcntl即F_SETFL,F_GETFL的使...
fcntl函数
最新发布
清风
08-30 373
fcntl函数是一个系统调用，用于控制打开文件的属性，他可以实现文件的锁定、修改文件的状态标志、获取/设置文件描述符等操作。其中，fd是文件描述符，cmd是控制命令，arg是可选参数，具体取决于cmd参数。fcntl函数返回值根据cmd的不同而有所不同。fcntl函数的使用非常灵活，可以通过不同的命令实现不同的功能。例如，可以通过F_SETFL命令设置文件为非阻塞模式，以便在读写文件时不会被阻塞。另外，可以通过F_GETLK/F_SETLK命令实现文件的共享锁和独占锁，以保证文件的安全性。
fcntl函数详解：文件描述符控制与文件特性操作
"fcntl函数是Linux系统中用于文件描述符控制的重要函数，它可以用来复制文件描述符、获取或设置文件描述符标记、获取或设置文件状态标记、获取或设置异步I/O所有权以及进行文件记录锁操作。" fcntl函数允许程序员对...
fcntl函数详解：Linux C核心编程必备
"fcntl函数是Linux C核心编程中的一个重要组成部分，用于操作文件描述符的特性。这个函数在头文件<fcntl.h>中定义，并接受三个参数：文件描述符`fd`，操作命令`cmd`，以及根据命令可能需要的额外参数如`long arg`或`...
fcntl函数详解：文件描述符操作与锁管理
"fcntl函数是Unix/Linux系统中用于操作文件描述符的重要函数，它可以用于设置或查询文件的各种属性，如文件锁、文件描述符标志等。本文将深入讲解fcntl的调用方法及其在不同场景下的应用，通过示例代码帮助读者理解...
fcntl函数详解：Unix文件描述符操作入门
本资源是一份关于fcntl函数的入门教程，主要针对的是Unix/Linux环境下的编程。fcntl函数是一个系统调用，用于改变已经打开文件的属性，包括复制文件描述符、获取/设置文件描述符标记、文件状态标志、异步I/O控制以及...
fcntl函数详解：文件描述符管理与控制
"fcntl函数是Unix/Linux系统中用于改变或查询文件描述符属性的重要函数，广泛应用于文件控制操作。它可以从已打开的文件描述符中获取或设置多种特性，包括复制文件描述符、设置文件描述符标志、文件状态标志以及进行...
Fcntl函数
b711183612的专栏
10-16 851
Fcntl函数 函数用来对以打开的文件描述符进行各种控制操作以改变已打开文件的各种属性 Int fcntl(int fd, int cmd); Int fcntl(int fd, int cmd, long arg); Int fcntl(int fd, int cmd, struct flock*lock); Cmd: F_DUPFD:此时，fcntl的功能与dup一样，可以复制由f
fcntl()函数
飞翔的大象
09-30 1238
fcntl 表头文件 #include fcntl.h> 函数定义 int fcntl(int fd , int cmd); int fcntl(int fd,int cmd,long arg); int fcntl(int fd,int cmd,struct
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值