文件控制--fcntl()

在介绍文件控制函数之前，先看看linux系统是如何管理进程中打开的文件。

1.每个进程在进程表项中都有一个记录项，记录项中包含有一张打开文件描述符表，可将其视为一个矢量，每个描述符占用一项。与每个文件描述符相关联的是：

(a)文件描述符标志（close_on_exec).

(b)指向一个文件表项的指针。

2.内核为所有打开文件维持一张文件表，每个文件表项包含：

(a)文件状态标志（读、写、同步、非阻塞等）。

(b)当前文件偏移量。

(c)指向该文件i结点表项的指针。

3.每个打开文件（或设备）都有一个i结点结构。i结点包含了文件类型、文件所有者、文件长度、文件所在的设备、指向文件实际数据块在磁盘上所在位置的指针等等。

文件控制函数：

         fcntl -- file control
         #include <fcntl.h>;
         int fcntl(int fd, int cmd, .../*  int   arg */);
[描述]
            fcntl()针对(文件)描述符提供控制.参数fd 是被参数cmd操作(如下面的描述)的描述符.
            针对cmd的值,fcntl能够接受第三个参数int arg
fcntl函数有5种功能：
1.复制一个现有的描述符（cmd=F_DUPFD）.
2.获得／设置文件描述符标记(cmd=F_GETFD或F_SETFD).
3.获得／设置文件状态标志(cmd=F_GETFL或F_SETFL).
4.获得／设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).

5.获得／设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW).

  Cmd：F_DUPFD：复制文件描述符

F_GETFD：获得fd的close-on-exec标志，若标志未设置，则文件经过exec函数之后仍保持打开状态。

F_SETFD：设置close-on-exec标志，该标志以参数arg的FD_CLOEXEC位决定。

F_GETFL：得到open设置的标志

F_SETFL：改变open设置的标志

F_GETLK：根据lock描述，决定是否上文件锁

F_SETLK：设置lock描述的文件锁

F_SETLKW：这是F_SETLK的阻塞版本（命令名中的W表示等待（wait））。如果存在其它锁，则调用进程睡眠；如果捕捉到信号则睡眠中断

F_GETOWN：检索将收到SIGIO和SIGURG信号的进程号或进程组号

F_SETOWN：设置进程号或进程组号

fcntl的返回值与命令有关。如果出错，所有命令都返回－1，如果成功则返回某个其他值。下列三个命令有特定返回值：F_DUPFD,F_GETFD,F_GETFL以及F_GETOWN。第一个返回新

的文件描述符，第二、三个返回相应标志，最后一个返回一个正的进程ID或负的进程组ID。

下面给出一个控制fd的实例：

#include <stdio.h> 
#include <fcntl.h>

void set_fl(int fd, int flags);
void clr_fl(int fd, int flags);
  
int main(int argc,char* argv[])  
{  
	int var,fd;
  
	if (argc!=2){  
		printf("usage :a.out <descriptor>");
		return -1;
	}
   
	fd=atoi(argv[1]);
	if((var = fcntl(fd, F_GETFL, 0)) < 0){
		printf("fcntl F_GETFL error.\n");
		return -1;
	}

/**  三个存取方式标志(O_RDONLY,O_WRONLY,以及O_RDWR)并不各占1位。(这三种标志的值各是0、1和2，由于历 
史原因。这三种值互斥—一个文件只能有这三种值之一。)因此首先必须用屏蔽字O_ACCMODE取得存取方式位，然后将结果与这三种值相比较。 
****/  
	switch(var & O_ACCMODE) {  
		case O_RDONLY :
			printf("read only\n");  
			break;  
		case O_WRONLY :
			printf("write only\n");  
			break;  
		case O_RDWR : 
			printf("read and write\n");
			break;  
		default :
			printf("unkown access mode\n");
			break;  
	} 

	if (var & O_APPEND ){
		printf("append\n");
		clr_fl(fd,O_APPEND); 
	}
	if (var & O_NONBLOCK) {
		printf("nonblocking\n"); 
	}
	return 0;
}

void set_fl(int fd, int flags)
{
	int val;

	if((val = fcntl(fd, F_GETFL, 0)) < 0 ){
		printf("fcntl F_GETFL error.\n");
		return;
	}

	flags |= val;
	if(fcntl(fd, F_SETFL, flags) < 0 ){
		printf("fcntl F_SETFL error.\n");
		return;
	}
}

void clr_fl(int fd, int flags)
{
	int val;

	if((val = fcntl(fd, F_GETFL, 0)) < 0 ){
		printf("fcntl F_GETFL error.\n");
		return;
	}

	flags &= ~val;
	if(fcntl(fd, F_SETFL, flags) < 0 ){
		printf("fcntl F_SETFL error.\n");
		return;
	}
}

实现文件的加锁解锁

当多个用户共同使用、操作一个文件的情况下，这时，Linux通常采用的方法是给文件上锁，来避免共享的资源产生竞争的状态。

文件锁包括建议性锁和强制性锁。

建议性锁要求每个上锁文件的进程都要检查是否有锁存在，并且尊重已有的锁。在一般情况下，内核和系统都不使用建议性锁。

强制性锁是由内核执行的锁，当一个文件被上锁进行写入操作的时候，内核将阻止其它任何文件对其进行读写操作。采用强制性锁对性能的影响很大，每次读写操作都必须检查是否有锁存在。

在Linux中，实现文件上锁的函数有flock和fcntl，其中flock用于对文件施加建议性锁，而fcntl不仅可以施加建议性锁，还可以施加强制性锁，还能对文件的某一记录进行上锁，也就是记录锁。

记录锁又分为读取锁和写入锁。

读取锁又称共享锁，能使多个进程都在文件的同一部分建立读取锁。

写入锁又称为排斥锁，在任何时刻只能有一个进程在文件的某个部分建立写入锁。

在文件的同一部分不能同时建立读取锁和写入锁。

（2）fcntl函数格式

Fcntl函数语法要点：

所需头文件：#include<sys/types.h>

                     #include<unistd.h>

                     #include<fcntl.h>

函数原型：int fcntl(int fd,cmd,struct flock *lock)  

                     Lock：结构为flock，设置记录锁的具体状态

函数返回值：成功：0

                     -1：出错

Struct flock{

Short l_type;

Off_t l_start;

Short l_whence;

Off_t l_len;

Pid_t l_pid;

}

Lock结构变量取值：

L_type：F_RDLCK：读取锁（共享锁）

              F_WRLCK：写入锁（排斥锁）

              F_UNLCK：解锁

L_stat：相对位移量（字节）

L_whence：相对位移量的起点（同lseek的whence）：SEEK_SET：当前位置为文件开头，新位置为偏移量的大小

                                    SEEK_CUR：当前位置为文件指针位置，新位置为当前位置加上偏移量

                                    SEEK_END：当前位置为文件的结尾，新位置为文件的大小加上偏移量大小

L_len：加锁区域长度。

#include<unistd.h>  
#include<fcntl.h>  
#include<sys/types.h>  
#include<sys/stat.h>  
#include<stdio.h>  
#include<stdlib.h>

void lock_set(int, int);
  
int main(int argc ,char *argv)  
{  
	int fd;

    	if((fd = open("test.c",O_RDWR|O_CREAT,0666)) < 0 ){  
              printf("open error.\n");  
              exit(1);  
       	}  

	lock_set(fd,F_WRLCK);  
    	getchar();  
    	lock_set(fd,F_UNLCK);  
    	getchar();  
    	close(fd);  
    	exit(0);  
}  

void lock_set(int fd,int type)  
{  
       struct flock lock;  

       lock.l_whence=SEEK_SET;  
       lock.l_start=0;  
       lock.l_len=0;	//表示锁到文件结尾；  
       while(1){  
		lock.l_type=type;  /*根据不同的type值给文件上锁或解锁*/  
           	if((fcntl(fd,F_SETLK,&lock)) == 0){  
               		if(lock.l_type == F_RDLCK)  
                            	printf("read lock set by %d\n",getpid());  
                     	else if(lock.l_type == F_WRLCK)  
                            	printf("write lock set by %d\n",getpid());  
                     	else if(lock.l_type == F_UNLCK)  
                            	printf("release lock set by %d\n",getpid());  
                     	return;  
		}  
		   
		fcntl(fd,F_GETLK,&lock);		 /*判断文件是否可以上锁*/   
		if(lock.l_type != F_UNLCK){      /*判断文件不能上锁原因*/ 
			if(lock.l_type == F_RDLCK)   /*该文件已有读取锁*/
				printf("read lock already set by %d\n",lock.l_pid);  
			else if(lock.l_type == F_WRLCK)  /*该文件已有写入锁*/
                    		printf("write already lock set by %d\n", lock.l_pid); 
		}  
	}  
}