内核级别,设计文件很底层的操作

作者: 操作系统  发布:2019-09-06

linux低级文件编程中也讲到
    多用户多任务操作系统中非常重要的一个内容就是文件锁。用户在更新文件时,期望可以使用某种机制,防止两种进程同时更新文件同一区域而造成丢失,或者防止文件内容在未更新完毕时被读取等并发引起的问题,这种机制就是文件锁。
     进程在操作文件期间,可以使用文件锁,锁定文件中的敏感部分,防止其他进程越权操作该部分数据。函数fcntl提供了对文件任意区域置锁的能力,既可以锁住全部文件,又可以锁住文件的部分记录,故文件锁又成为"记录锁".
     根据文件锁的访问方式,可以区分读锁和写锁两种。读锁又名共享锁,它用来防止进程读取的文件记录被更改。文件记录可以同时设置多个读锁,但当有一个读锁存在时,就不能在该记录出设置写锁。
     写锁又名互斥锁,它用来保证文件更改记录时不被干扰,确保文件一致性和完整性,防止写丢失或读"脏"数据。文件记录一旦设置了写锁,就不能再设置任意锁,除非写锁接触。
    文件记录在同一时刻,可以设置多个读锁,单仅能设置一个写锁,并且读、写不能不能同时存在。
    当函数fntl专用于锁操作时,其原型为:
    int fcntl(int fildes,int cmd,struct flock *arg);
    其中,结构flock用于描述文件锁的信息,定义于"fcntl.h"中,如下表示:  

   与高级文件编程使用FILE描述符不同的是,低级文件编程的文件描述符是一个非负整数。
1.文件的打开与创建
  #include<fcntl.h>
  int open(const char * filename,int oflag,.../*mode_t mode*/);
  --filename指定了打开或创建文件的路径名;
  --oflag制定了打开或创建文件的方式
  --mode是可选参数,决定新文件的模式,仅当创建文件时有效。
  当函数调用成功时,将为文件filename创建一个文件描述符并返回之,否则返回-1;
  参数oflag控制打开文件的读写方式{1.O_RDONLY、O_WRONLY、O_RDWR}、常规方式和同步方式;
2.文件的关闭与删除
  函数close关闭一个已经打开的文件,函数unlink删除文件,它们的原型为:
  #include<unistd.h>
  int close(int fildes);
  int unlink(char *path);
  注:只是用一次的临时文件,可以先删除再是用,这样子不必担心忘记删除文件而造成磁盘垃圾文件了。
/*-----临时文件使用模板unlink.c-----*/
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
void main()
{
  int fno;
  if((fno=open("./tmpfile",O_RDWR|O_CREAT|O_EXCL,0755))<0)
  {
     fprintf(stderr,"open file error!/n");
     return ;
  }
  unlink("./tmpfile");
  sleep(60);
  printf("end./n");
}
3.文件读写
#include<unistd.h>
ssize_t read(int fildes,void *buff,size_t nbytes);
ssize_t write(int fildes,const void *buff,size_t nbytes);
/*read函数从文件描述符fildes所指向的文件中读取nbytes个字节的数据到buff所指向的内存中去。如果read成功,函数返回实际读取的字节数;如果文件结束或参数nbytes值为0,函数返回为0;若调用出错,函数返回-1,并将错误码写入errno中。*/
/*write把buff所指向的内存数据向文件描述符fildes所指向的文件中写入nbytes个字节。如write成功,函数返回实际写入的字节数。否则返回-1,并将错误写入errno中*/
/*--------read.c------*/
#include<unistd.h>
void main()/
{
  char buff[11];
  printf("%d",read(0,buf,sizeof(buf)));
}
/*---------write.c-----*/
#include<unistd.h>
void main()
{
  char buf[10]="abcchina";
  printf("%d",write(1,buf,sizeof(buf)));
}
4.文件定位
#include<unistd.h>
off_t lseek(int fildes,off_t offset,int whence);
实例:函数lseek允许定位到当前文件最大位置之后,倘若定位成功并且写入数据,则文件将自动延长到写入位置,中间部分以0填充。但是若定位位置大大超过了当前文件长度,则UNIX操作系统只虚增文件长度,实际并不分配磁盘块。以下设计虚增文件的实例:
#include<unistd.h>
#include<fcntl.h>
void main()
{
  int fno;
  if((fno=open("hole.dat",O_WRONLY|O_CREAT,0755))<0)
  {
    printf("open file hole.dat failed./n");
    return ;
  }
  lseek(fno,1000000000,SEEK_SET);
  write(fno,"eee",3);
  close(fno);
}
5.文件缓冲
  函数fsync将缓冲信息写入文件中,它的原型为:
  #include<unistd.h>
  int fsync(int fildes);
  系统调用fsync将所有已写入文件描述符fildes的数据真正写到磁盘或其它设备中,类似于标准文件变成库fflush,当系统调用成功时返回0,否则返回-1。
 
6.复制文件描述符
  低级文件编程库中复制文件描述符的函数如下:
  #include<unistd.h>
  int dup(int fildes);
  int dup2(int fildes,int fildes2);
  函数dup复制文件描述符fildes到当前未使用的最小可用描述符中。函数dup2复制文件描述符fildes到描述符fildes2中,如果 fildes2已经打开,则关闭;如果fildes2与fildes值相等,则直接返回。这两个函数在调用成功时都返回新的文件描述符,否则返回-1。
7.文件控制
  1)文件锁
     多用户多任务操作系统中非常重要的一个内容就是文件锁。用户在更新文件时,期望可以使用某种机制,防止两种进程同时更新文件同一区域而造成丢失,或者防止文件内容在未更新完毕时被读取等并发引起的问题,这种机制就是文件锁。
     进程在操作文件期间,可以使用文件锁,锁定文件中的敏感部分,防止其他进程越权操作该部分数据。函数fcntl提供了对文件任意区域置锁的能力,既可以锁住全部文件,又可以锁住文件的部分记录,故文件锁又成为"记录锁".
     根据文件锁的访问方式,可以区分读锁和写锁两种。读锁又名共享锁,它用来防止进程读取的文件记录被更改。文件记录可以同时设置多个读锁,但当有一个读锁存在时,就不能在该记录出设置写锁。
     写锁又名互斥锁,它用来保证文件更改记录时不被干扰,确保文件一致性和完整性,防止写丢失或读"脏"数据。文件记录一旦设置了写锁,就不能再设置任意锁,除非写锁接触。
    文件记录在同一时刻,可以设置多个读锁,单仅能设置一个写锁,并且读、写不能不能同时存在。
    当函数fntl专用于锁操作时,其原型为:
    int fcntl(int fildes,int cmd,struct flock *arg);
    其中,结构flock用于描述文件锁的信息,定义于"fcntl.h"中,如下表示:
struct flock
{
   short l_type;/*锁类型,取值为F_RDLCK、F_WRLCK、或F_UNLCK之一,分别代表申请读锁、申请写锁和释放锁*/
   short l_whence;/*锁区域开始地址的相对位置,类似于lseek中whence参数,取值是SEEK_SET SEEK_CUR SEEK_END之一,分别表示相对文件起始位置、文件当前位置、文件结束位置*/
   long l_start;/*锁区域开始地址偏移量,同l_whence共同确定锁区域*/
   long l_len;/*锁的长度,0表示锁至文件末*/
   long l_pid;/*拥有锁的进程ID号*/
};
当函数fcntl专用于锁时,参数cmd的三种取值:
     F_GETLK
     F_SETLK
     F_SETLKW
     {文件锁最典型的应用于两个方面:一个锁定文件中的临界数据,比如并发投票时文件记录的投票数;二是利用具有互斥性质的写锁,实现进程的并发控制}
   2)文件锁操作
     在锁机制的使用中,最常见的操作有锁的请求、释放和测试等,这些操作代买基本类似
   (1)测试锁
   设计函数SeeLock,它查询文件描述符fd对应文件的锁信息,其原型为:
   void SeeLock(int fd,int start,int len);
   函数查询描述符fd对应文件从偏移start出开始的len字节中的锁信息
/*----测试所源码----lock1.c----*/
void SeekLock(int fd,int start,int len)
{
  struct flock arg;
  arg.l_type=F_WRLCK;
  arg.l_whence=SEEK_SET;
  arg.l_start=start;
  arg.l_len=len;
  if(fcntl(fd,F_GETLK,&arg)==-1) 
     fprintf(stderr,"See Lock failed./n");
  else if(arg.l_type==F_UNLCK)
     fprintf(stderr,"NO LOCK FROM %d TO %d,n",start, len);
  else if(arg.l_type==F_WRLCK)
     fprintf(stderr,"WRITE LOCK FROM %d TO %d ,id=%d/n",start,len,arg.l_pid);
  else if(arg.l_type==F_RDLCK)
     fprintf(stderr,"READ LOCK FROM %d To %d,id=%d/n",start,len,arg.l_pid);
}
(2)申请读锁
    共享锁申请函数GetReadLock,原型为:
    void GetReadLock(int fd,int start,int len);
    以阻塞模式在文件描述符fd相应的文件中申请共享读锁,锁定的区域从偏移start处开始的len字节
/*---阻塞申请共享读锁源码---lockl.c*/
void GetReadLock(int fd,int start,int len)
{
  struct flock arg;
  arg.l_type=F_RDLCK;
  arg.l_whence=SEEK_SET;
  arg.l_start=start;
  arg.l_len=len;
  if(fcntl(fd,F_SETLKW,&arg)==-1)
    fprintf(stderr,"[%d] Set Read Lock failed./n",getpid());
  else 
    fprintf(stderr,"[%d] Set Read Lock From %d To %d",getpid(),start,len);
}
(3)申请写锁
    void GetWriteLock(int fd,int start,int len);
/*---阻塞申请共享写锁源码---lockl.c*/
void GetReadLock(int fd,int start,int len)
{
  struct flock arg;
  arg.l_type=F_WRLCK;
  arg.l_whence=SEEK_SET;
  arg.l_start=start;
  arg.l_len=len;
  if(fcntl(fd,F_SETLKW,&arg)==-1)
    fprintf(stderr,"[%d] Set Write Lock failed./n",getpid());
  else 
    fprintf(stderr,"[%d] Set Write Lock From %d To %d",getpid(),start,len);
}
   (4)释放锁
    设计文件锁释放函数ReleaseLock,原型为:
    void ReleaseLock(int fd,int start,int len);
/*---释放锁源码---lockl.c*/
void GetReadLock(int fd,int start,int len)
{
  struct flock arg;
  arg.l_type=F_UNLCK;
  arg.l_whence=SEEK_SET;
  arg.l_start=start;
  arg.l_len=len;
  if(fcntl(fd,F_SETLKW,&arg)==-1)
    fprintf(stderr,"[%d] UnLock failed./n",getpid());
  else 
    fprintf(stderr,"[%d] UnLock From %d To %d",getpid(),start,len);
}
以下是一个文件锁控制进程的实例,如下:
#include<stdio.h>
#include<fcntl.h>
void main()
{
  int fd;
  struct flock arg;
  if((fd=open("/tmp/tlockl",O_RDWR|O_CREAT,0755))<0)
  {
    fprintf(stderr,"open file failed./n");
    retrun;
  }
  SeeLock(fd,0,10);
  GetReadLock(fd,0,10);/*申请读锁*/
  SeeLock(fd,11,20);
  GetWriteLock(fd,11,20);/*申请写锁*/
  sleep(30);
  ReleaseLock(fd,0,10);
  ReleaseLock(fd,11,20);
}
8.通过函数库之读写功能库封装
     本类函数包括阻塞读写和定时读写两种
   1)阻塞读写函数库
   (1)ReadFile
    控制read的读取文件字节数函数,其原型为:
    int ReadFile(int nFile,void *pData,int *pSize);
    函数从文件描述符nFile所指向的文件中读取nSize个字节的数据到内存pData中,仅当错误发生,或者全部数据读取完毕时,函数返回。
   (2)WriteFile
     控制write的写入文件字节数函数,原型为:
     int WriteFile(int nFile,void *pData,int nSize);
/*-----------file.c----------*/
int ReadFile(int nFile,void *pData,int *pSize)
{
  int nLeft,nRead;
  char *pcData=pData;
  ASSERT(pData !=NULL && pSize !=NULL);
  nLeft= *pSize;
  while(nLeft>0)
  {
    if((nRead=read(nFile,pcData,nLeft))<0)
    {
      if(errno !=EINTR) ASSERT(0);
      nRead=0;
    }
    else if(nRead==0) break;
    nLeft -=nRead;
    pcData +=nRead;
  }
  *pSize=*pSIze-nLeft;
  return 0;
}
/*程序中错误代码EINTR表示在读取数据之前,系统调用read被一个信号singal中断,可以继续执行读取操作*/
2)阻塞读写函数库应用实例
      程序读取键盘输入,当且仅当读入了一定量的字符数后函数才返回,如下:
#include<comlib.h>
void main()
{
  char buf[11];
  int size=sizeof(buf);
  ReadFile(0,buf,&size);
  printf("%d",size);
}

  1. struct flock 

  2. 3.    short l_type;/*锁类型,取值为F_RDLCK、F_WRLCK、或F_UNLCK之一,分别代表申请读锁、申请写锁和释放锁*/ 
    4.    short l_whence;/*锁区域开始地址的相对位置,类似于lseek中whence参数,取值是SEEK_SET SEEK_CUR SEEK_END之一,分别表示相对文件起始位置、文件当前位置、文件结束位置*/ 
    5.    long l_start;/*锁区域开始地址偏移量,同l_whence共同确定锁区域*/ 
    6.    long l_len;/*锁的长度,0表示锁至文件末*/ 
    7.    long l_pid;/*拥有锁的进程ID号*/ 
  3. }; 
    当函数fcntl专用于锁时,参数cmd的三种取值:
         F_GETLK
         F_SETLK
         F_SETLKW
         {文件锁最典型的应用于两个方面:一个锁定文件中的临界数据,比如并发投票时文件记录的投票数;二是利用具有互斥性质的写锁,实现进程的并发控制}
       2)文件锁操作
         在锁机制的使用中,最常见的操作有锁的请求、释放和测试等,这些操作代买基本类似
    以下函数都是作者自己做的封装:
       (1)测试锁
       设计函数SeeLock,它查询文件描述符fd对应文件的锁信息,其原型为:
       void SeeLock(int fd,int start,int len);
       函数查询描述符fd对应文件从偏移start出开始的len字节中的锁信息
     1. /*----测试所源码----lock1.c----*/ 
     2. void SeekLock(int fd,int start,int len) 
     3. { 
     4.   struct flock arg; 
     5.   arg.l_type=F_WRLCK; 
     6.   arg.l_whence=SEEK_SET; 
     7.   arg.l_start=start; 
     8.   arg.l_len=len; 
     9.   if(fcntl(fd,F_GETLK,&arg)==-1)  
    10.      fprintf(stderr,"See Lock failed./n"); 
    11.   else if(arg.l_type==F_UNLCK) 
    12.      fprintf(stderr,"NO LOCK FROM %d TO %d,n",start, len); 
    13.   else if(arg.l_type==F_WRLCK) 
    14.      fprintf(stderr,"WRITE LOCK FROM %d TO %d ,id=%d/n",start,len,arg.l_pid); 
    15.   else if(arg.l_type==F_RDLCK) 
    16.      fprintf(stderr,"READ LOCK FROM %d To %d,id=%d/n",start,len,arg.l_pid); 

  4. (2)申请读锁
        共享锁申请函数GetReadLock,原型为:
        void GetReadLock(int fd,int start,int len);
        以阻塞模式在文件描述符fd相应的文件中申请共享读锁,锁定的区域从偏移start处开始的len字节
     1. /*---阻塞申请共享读锁源码---lockl.c*/ 
     2. void GetReadLock(int fd,int start,int len) 
     3. { 
     4.   struct flock arg; 
     5.   arg.l_type=F_RDLCK; 
     6.   arg.l_whence=SEEK_SET; 
     7.   arg.l_start=start; 
     8.   arg.l_len=len; 
     9.   if(fcntl(fd,F_SETLKW,&arg)==-1) 
    10.     fprintf(stderr,"[%d] Set Read Lock failed./n",getpid()); 
    11.   else  
    12.     fprintf(stderr,"[%d] Set Read Lock From %d To %d",getpid(),start,len); 

  5. (3)申请写锁
        void GetWriteLock(int fd,int start,int len);
     1. /*---阻塞申请共享写锁源码---lockl.c*/ 
     2. void GetReadLock(int fd,int start,int len) 
     3. { 
     4.   struct flock arg; 
     5.   arg.l_type=F_WRLCK; 
     6.   arg.l_whence=SEEK_SET; 
     7.   arg.l_start=start; 
     8.   arg.l_len=len; 
     9.   if(fcntl(fd,F_SETLKW,&arg)==-1) 
    10.     fprintf(stderr,"[%d] Set Write Lock failed./n",getpid()); 
    11.   else  
    12.     fprintf(stderr,"[%d] Set Write Lock From %d To %d",getpid(),start,len); 

  6. (4)释放锁
        设计文件锁释放函数ReleaseLock,原型为:
        void ReleaseLock(int fd,int start,int len);
     1. /*---释放锁源码---lockl.c*/ 
     2. void GetReadLock(int fd,int start,int len) 
     3. { 
     4.   struct flock arg; 
     5.   arg.l_type=F_UNLCK; 
     6.   arg.l_whence=SEEK_SET; 
     7.   arg.l_start=start; 
     8.   arg.l_len=len; 
     9.   if(fcntl(fd,F_SETLKW,&arg)==-1) 
    10.     fprintf(stderr,"[%d] UnLock failed./n",getpid()); 
    11.   else  
    12.     fprintf(stderr,"[%d] UnLock From %d To %d",getpid(),start,len); 

  7. 以下是一个文件锁控制进程的实例,如下:
     1. #include<stdio.h> 
     2. #include<fcntl.h> 
     3. void main() 
     4. { 
     5.   int fd; 
     6.   struct flock arg; 
     7.   if((fd=open("/tmp/tlockl",O_RDWR|O_CREAT,0755))<0) 
     8.   { 
     9.     fprintf(stderr,"open file failed./n"); 
    10.     retrun; 
    11.   } 
    12.   SeeLock(fd,0,10); 
    13.   GetReadLock(fd,0,10);/*申请读锁*/ 
    14.   SeeLock(fd,11,20); 
    15.   GetWriteLock(fd,11,20);/*申请写锁*/ 
    16.   sleep(30); 
    17.   ReleaseLock(fd,0,10); 
    18.   ReleaseLock(fd,11,20); 

  8.  
    作者“pstary”

作者“pstary”

多用户多任务操作系统中非常重要的一个内容就是文件锁。用户在更新文件时,期望可以使用某种机制,防止两...

1.文件的打开与创建 #includefcntl.h int open(const char *...

本文由今晚开什么码发布于操作系统,转载请注明出处:内核级别,设计文件很底层的操作

关键词:

上一篇:没有了
下一篇:没有了