【讨论】简析文件操作

   文件操作在程序设计中使用较多，常见操作有打开、读、写、关闭等。本文将讨论文件操作涉及的相关内容，以Linux平台为例。

1.  结构

   文件操作是应用程序访问文件系统的过程。下面简要讨论文件系统的结构，如图1所示。

图1       文件系统结构示意图

     应用程序通过文件描述符int fd访问文件，执行文件操作（如系统调用read）时，先从描述符表中找到文件对象，然后再找到索引节点（在open时，从磁盘的索引节点表中读取初始数据），索引节点记录了文件信息（时间、大小等）和文件数据对应的逻辑块号表。

由块号表和文件对象中的偏移量，可得到目标逻辑块号，接着访问磁盘缓冲池（如图2所示），查找该块号对应的缓冲块。若没找到，则要通过磁盘驱动读取磁盘数据到空闲缓冲块，最后将缓冲块的相关数据拷贝到用户空间。

       文件系统将数据块部分以逻辑块为单位进行组织（逻辑空间），逻辑块的大小是扇区大小的整数倍，可为512、1024、2048、4096字节等。访问磁盘时，磁盘驱动将块号转换为柱面号、磁道号、扇区号等参数，来访问磁盘。

图2       磁盘缓冲示意图

以如下代码为例，

//读取文件"/tmp/a.dat"偏移100字节处的20字节数据到buf中。

void fun1()

{

char buf[20];

int fd = open( "/tmp/a.dat", O_RDONLY );

lseek( fd, 100, SEEK_SET );

read( fd, buf, sizeof(buf));

close(fd);

}

1—open：从文件系统根目录”/”开始，逐级查找”/tmp/a.dat”的索引节点号。因为目录文件与普通文件不同，保存的是一组子文件名和索引节点号，如图3所示，因此根据文件名，很方便查找到对应的索引节点号。

       然后根据节点号，在索引节点缓冲池中查找目标索引节点，若没找到，则将节点数据从索引节点表读到内存（索引节点对象），再新建文件对象，来保存该索引节点指针，最后找到描述符表中的空表项，记录文件对象指针，并返回对应的数组下标值。

2—lseek：根据描述符fd，找到文件对象，调整“文件偏移量”字段的值。

3—read：先找到描述符对应的文件对象和索引节点，然后查找逻辑块号，再从磁盘缓冲池中查找目标缓冲块，并拷贝数据到用户空间。

4—close：释放fd对应的文件对象和索引节点，清空fd对应的描述符表项。

图3       目录文件结构示意图

2.      共享 

文件系统中的文件对象和索引节点对象，可以通过引用计数在同一进程或不同进程间共享。

以如下代码为例，对应的数据结构如图4所示。

int fd[6];

void main()

{

fd[0] = open( "a1.dat", O_RDONLY );

fd[1] = open( "a1.dat", O_RDONLY );

fd[2] = dup( fd[1] );

CreateThread( fun );           //创建线程

}

void fun()

{

fd[3] = open( "a1.dat", O_RDONLY );

fd[4] = open( "a2.dat", O_RDONLY );

       fd[5] = dup(fd[0]);

}

//调用fork创建子进程时，父进程的描述符表拷贝到子进程，对应文件对象的引用计数全部加1，相当于执行了dup操作。

图4       文件系统相关数据结构示意图

3.      模拟

接下来给出文件操作（open、lseek、read、write、close等）的简化模拟示意程序。

类型定义：

  #define SIZE_BLK (1024) //逻辑块大小 #define SIZE_DIRECT (SIZE_BLK*8) //假设直接映射区大小为8个逻辑块 #define LEN_FDS (512) //描述符表长度 #define LEN_BLKNOS (12) //逻辑块号表长度 #define LEN_HASHS (37) //哈希表大小 #define OFFSETOF( TYPE, MEMBER ) ( (unsigned int)( &( (TYPE*)NULL )->MEMBER ) ) //从成员指针得到所在对象指针 #define GetEntryFromMember(ptr, type, member) / ( (type *)( (char *)(ptr) - OFFSETOF(type, member) ) ) #define GetDskHashItem(ptr) GetEntryFromMember( (ptr), disk, node[0] ) //返回哈希表节点所在的磁盘缓冲块 #define GetDskLruItem(ptr) GetEntryFromMember( (ptr), disk, node[1] ) //返回LRU表节点所在的磁盘缓冲块 struct list //双向链表节点 { list *prev; list *next; }; struct inode //索引节点 { int cnt; //引用计数 //时间信息等 int sz; //文件长度 int blkNos[LEN_BLKNOS]; //逻辑块号表 //........... }; struct file //文件对象 { int cnt; //引用计数 int flag; //文件属性(可读可写等) int offset; //当前偏移 inode *i; //........... }; struct process //进程结构 { file *fds[LEN_FDS]; //进程描述符表 //........... }; struct disk //磁盘缓冲块 { list node[2]; //0为hash表节点,1为lru表节点 int no; //逻辑块号 int flag; //属性(脏标记等) void *buf; //缓冲数据 //........... }; struct diskPool //磁盘缓冲池 { list hashs[LEN_HASHS]; list lru; //........... }; diskPool pool;

函数定义：

 //全局函数/// void * memalloc( unsigned int sz ) { //申请sz个字节 void * p = NULL; //................... return p; } void memfree( void *p ) { //释放p } void memcopy( void *d, const void *s, unsigned int sz ) { //从s拷贝sz个字节到d } process * current() { //返回当前进程结构指针 } int name2ino( const char *name ) { //将文件名转换为索引节点号(从根目录开始，逐级查找目录项) } inode * getINode( int n ) { //先在索引节点缓冲池查找。 //若找到，则增加引用计数，并返回。 //若没找到，就申请一个新节点，并从磁盘读入索引节点内容，然后返回。 } void delINode( inode *i ) { if ( i && --i->cnt<= 0 ) { //将索引节点数据写回磁盘 //将索引节点加入缓冲池的空闲表中 } } file * newFile( int flag, inode * i ) { //新建文件对象 file * f = (file *)memalloc( sizeof(file) ); f->cnt = 1; f->offset = 0; f->flag = flag; f->i = i; return f; } void delFile( file * f ) { //释放文件对象 if ( f && --f->cnt<= 0 ) { delINode( f->i ); //释放索引节点 memfree( f ); } } disk成员函数/ void diskRead( disk* dsk, int no ) { //将块号no转换为柱面号、磁道号、扇区号等参数，调用磁盘驱动。 //然后进程被阻塞等待磁盘操作完成。 } //inode成员函数/// int calBlkNo( inode *i, int off ) { //由文件偏移量得到逻辑块号 int no; if ( off < SIZE_DIRECT ) //直接区 { no = i->blkNos[off/SIZE_BLK]; } else { //间接映射区要先找到间接块，然后在间接块上得到目标逻辑块号 } return no; } ///diskPool成员函数/ disk * findDisk( diskPool *p, int no ) { //在哈希表中查找磁盘缓冲块(根据逻辑块号) disk * dsk = NULL; list *head = &p->hashs[no%LEN_HASHS]; //得到哈希表头 list *lst = head->next; while ( lst != head ) { disk * d = GetDskHashItem( lst ); if ( d->no == no ) { dsk = d; //调整dsk在LRU表中的位置(放到最前端) break; } lst = lst->next; } return dsk; } disk * allocDisk( diskPool *p ) { //在LRU表中取下最近最少使用的缓冲块。 //如果是脏缓冲块，要先将数据写入磁盘。 //................. } disk * getDisk( diskPool *p, int no ) { //返回块号为no的磁盘缓冲块 disk * dsk = findDisk( p, no ); if ( !dsk ) { dsk = allocDisk( p ); if ( dsk ) { dsk->no = no; diskRead( dsk, no ); //再将d加入哈希表和LRU表中 } } return dsk; } 系统调用// int open( const char*name, int flag ) { int fd = -1; int ino = name2ino( name ); //转换成索引节点号 if ( ino >= 0 ) { inode * i = getINode( ino ); //得到索引节点 if ( i ) { file * f = newFile( flag, i ); process *p = current(); for ( int n = 0; n < LEN_FDS; ++n ) { if ( !p->fds[n] ) { p->fds[n] = f; fd = n; //得到描述符 break; } } } } return fd; } int close( int fd ) { int ret = 0; if ( fd >= 0 ) { process *p = current(); file *f = p->fds[fd]; if ( f ) { delFile( f ); //释放文件对象 ret = 1; } } return ret; } int lseek( int fd, int step, int flag ) { int pos = -1; if ( fd >= 0 ) { process *p = current(); //当前进程结构 file *f = p->fds[fd]; //fd对应的文件对象 if ( f ) { inode *i = f->i; if ( 0 <= flag && flag <= 2 ) { if ( flag == 0 ) { pos = step; } else if ( flag == 1 ) { pos = f->offset + step; } else if ( flag == 2 ) { pos = i->sz - step; } if ( pos > i->sz ) { pos = i->sz; } if ( pos < 0 ) { pos = 0; } f->offset = pos; } } } return pos; } int read( int fd, void *buf, unsigned int sz ) { if ( fd < 0 ) //无效描述符 { return -1; } int nRead = 0; process *p = current(); //当前进程结构 file *f = p->fds[fd]; //fd对应的文件对象 if ( !f ) //无效文件对象 { return -1; } while ( sz > 0 ) { int blkNo = calBlkNo( f->i, f->offset ); if ( blkNo == 0 ) //0不是有效逻辑块 { break; } disk * dsk = getDisk( &pool, blkNo ); //获取磁盘缓冲块 if ( !dsk ) { break; } int nCpy = SIZE_BLK - f->offset%SIZE_BLK; if ( nCpy > sz ) { nCpy = sz; } int left = f->i->sz - f->offset; //文件剩余字节数 if ( nCpy > left ) { nCpy = left; } if ( nCpy <= 0 ) { break; } memcopy( (char*)buf+nRead, (char*)dsk->buf+f->offset%SIZE_BLK, nCpy ); //从磁盘缓冲拷贝到用户缓冲 nRead += nCpy; sz -= nCpy; f->offset += nCpy; } return nRead; } int write( int fd, void *buf, unsigned int sz ) { if ( fd < 0 ) //无效描述符 { return -1; } int nWrite = 0; process *p = current(); //当前进程结构 file *f = p->fds[fd]; //fd对应的文件对象 if ( !f ) //无效文件对象 { return -1; } while ( sz > 0 ) { int blkNo = calBlkNo( f->i, f->offset ); if ( blkNo == 0 ) //0不是有效逻辑块 { break; } disk * dsk = getDisk( &pool, blkNo ); //获取磁盘缓冲块 if ( !dsk ) { break; } int nCpy = SIZE_BLK - f->offset%SIZE_BLK; if ( nCpy > sz ) { nCpy = sz; } int left = f->i->sz - f->offset; //文件剩余字节数 if ( nCpy > left ) { nCpy = left; } if ( nCpy <= 0 ) { break; } memcopy( (char*)dsk->buf+f->offset%SIZE_BLK, (char*)buf+nWrite, nCpy ); //从用户缓冲拷贝到磁盘缓冲 nWrite += nCpy; sz -= nCpy; f->offset += nCpy; } return nWrite; }

 4.      缓冲

 除了以上讨论的，直接通过系统调用来访问文件，C标准库还提供了缓冲访问方式。

以相同功能的代码为例，

void fun2()

{

char buf[20];

FILE* fp = fopen( "/tmp/a.dat", “r” );

fseek(fp, 100, SEEK_SET );

fread(buf, 1, sizeof(buf), fp);

fclose(fp);

}

fopen、fread等库函数，使得应用程序与文件系统之间多了个中间层，如图5所示，库函数操作对象是FILE* fp，其中记录了对应的文件描述符。FILE结构的定义如下，

struct _iobuf {

        char *_ptr;                //缓冲区当前指针

        int   _cnt;                //缓冲区中的字符数

        char *_base;              //流缓冲区

        int   _flag;

        int   _file;                //文件描述符

        int   _charbuf;

        int   _bufsiz;            //缓冲区大小

        char *_tmpfname;

        };

typedef struct _iobuf FILE;

图5       缓冲访问方式示意图 

在缓冲方式下，应用程序跟流缓冲区交互，后者再与磁盘缓冲块交互，如图6所示。

流缓冲区的一个作用是，减少进程陷入内核的次数，从而节省了上下文切换的相关开销。

同样道理，磁盘缓冲块的作用是，减少访问磁盘设备的次数，从而节省访问磁盘的相关开销。

 

图6       文件操作交互示意图