Linux1.0虚拟文件系统(VFS)

Linux1.0虚拟文件系统(VFS)

在linux1.0操作系统当中文件系统是非常重要的一环，Linux操作系统当中支持的文件系统众多，如ext，ext2,minix,iosfs等等。当我们在使用操作系统提供的文件读写api来操作系统中的文件的时候，操作系统内部是怎么去完成我们想要的功能呢？在操作系统当中设计了一种虚拟文件系统，就是将所有的文件系统都给抽象出来，形成不同的文件系统使用相同的api来完成相同功能。Linux1.0中的文件系统结构可以用下面的结构来表示: 



在实现这种VFS结构当中，操作系统当中定义了几个非常重要的结构：

struct file {
mode_t f_mode;
dev_t f_rdev;			/* needed for /dev/tty */
off_t f_pos;
unsigned short f_flags;
unsigned short f_count;  /*文件的引用计数*/
unsigned short f_reada;
struct file *f_next, *f_prev;
struct inode * f_inode;
struct file_operations * f_op;
};

struct file_operations {
int (*lseek) (struct inode *, struct file *, off_t, int);
int (*read) (struct inode *, struct file *, char *, int);
int (*write) (struct inode *, struct file *, char *, int);
int (*readdir) (struct inode *, struct file *, struct dirent *, int);
int (*select) (struct inode *, struct file *, int, select_table *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
int (*mmap) (struct inode *, struct file *, unsigned long, size_t, int, unsigned long);
int (*open) (struct inode *, struct file *);
void (*release) (struct inode *, struct file *);
int (*fsync) (struct inode *, struct file *);
};

struct inode {
dev_t		i_dev;			/* 设备号 */
unsigned long	i_ino;		/* i节点号 */
umode_t		i_mode;
nlink_t		i_nlink;
uid_t		i_uid;           /*创建文件的用户ID*/
gid_t		i_gid;			 /*创建文件的用户组ID*/
dev_t		i_rdev;
off_t		i_size;
time_t		i_atime;
time_t		i_mtime;
time_t		i_ctime;
unsigned long	i_blksize;
unsigned long	i_blocks;
struct semaphore i_sem;
struct inode_operations * i_op;
struct super_block * i_sb;      /*对应的超级块*/
struct wait_queue * i_wait;
struct file_lock * i_flock;
struct vm_area_struct * i_mmap; /* 该文件映射到的虚拟地址段的地址 */
struct inode * i_next, * i_prev;     /*空闲双向链表*/
struct inode * i_hash_next, * i_hash_prev; /*hash双向链表*/
struct inode * i_bound_to, * i_bound_by;
struct inode * i_mount;
struct socket * i_socket;  /*如果是网络inode，则指向网络数据*/
unsigned short i_count;
unsigned short i_flags;
unsigned char i_lock;
unsigned char i_dirt;
unsigned char i_pipe;
unsigned char i_seek;
unsigned char i_update;
/* 因为Linux采用的时VFS文件系统，上面数据是所有文件系统都需要使用的数据
* 下面的数据是相应文件系统对应的特定inode的信息
*/
union {
struct pipe_inode_info pipe_i;
struct minix_inode_info minix_i;
struct ext_inode_info ext_i;
struct ext2_inode_info ext2_i;
struct hpfs_inode_info hpfs_i;
struct msdos_inode_info msdos_i;
struct iso_inode_info isofs_i;
struct nfs_inode_info nfs_i;
struct xiafs_inode_info xiafs_i;
struct sysv_inode_info sysv_i;
} u;
};

struct inode_operations {
struct file_operations * default_file_ops;
int (*create) (struct inode *,const char *,int,int,struct inode **);
int (*lookup) (struct inode *,const char *,int,struct inode **);
int (*link) (struct inode *,struct inode *,const char *,int);
int (*unlink) (struct inode *,const char *,int);
int (*symlink) (struct inode *,const char *,int,const char *);
int (*mkdir) (struct inode *,const char *,int,int);
int (*rmdir) (struct inode *,const char *,int);
int (*mknod) (struct inode *,const char *,int,int,int);
int (*rename) (struct inode *,const char *,int,struct inode *,const char *,int);
int (*readlink) (struct inode *,char *,int);
int (*follow_link) (struct inode *,struct inode *,int,int,struct inode **);
int (*bmap) (struct inode *,int);
void (*truncate) (struct inode *);
int (*permission) (struct inode *, int);
};

就是以上四种结构体 struct file、struct file_operations、struct inode、struct inode_operations。struct file结构体是系统中对所有文件系统的文件的描述，包含文件的基本信息，但是虽然包含了文件的基本信息，但是你需要对文件进行操作啊，所以这里就是问题的重点来了。所有的文件系统都需要有open、close、read、write操作，但是不同的文件系统的具体实现是不一样的，也就是同样打开一个文件，不同的文件系统中具有不同的操作，在VFS中将这些需要去操作具体文件系统的函数给抽象出来，形成一个struct
file_operations，此时你回来去看看struct file_operations这个结构体，你会发现这个结构体当中有lseek、read、wirte、open等函数，当你调用一个open系统调用时，最后其实是struct file_operations中的open函数去完成的。同样的道理struct inode是描述文件在磁盘上信息的一个结构体，里面信息非常多。在struct inode中除了一些inode的基本信息之外，还有一个很特别的联合体，该联合体是用来描述不同文件系统的特定inode的信息。有兴趣的话，可以自己去看看，我这里就不贴上代码了。struct
inode记录了文件磁盘的基本信息，同样的一个问题就是这些信息也是需要被操作和修改的啊，所以也有一个struct inode_operations结构，你可以回头去看看这些结构的信息。

下面就以系统当中open函数为例来说明VFS的一个基本实现过程

int do_open(const char * filename,int flags,int mode)
{
struct inode * inode;
struct file * f;
int flag,error,fd;

for(fd=0 ; fd<NR_OPEN ; fd++)
if (!current->filp[fd])
break;
if (fd>=NR_OPEN)
return -EMFILE;
FD_CLR(fd,¤t->close_on_exec);
f = get_empty_filp();
if (!f)
return -ENFILE;
current->filp[fd] = f;
f->f_flags = flag = flags;
f->f_mode = (flag+1) & O_ACCMODE;
if (f->f_mode)
flag++;
if (flag & (O_TRUNC | O_CREAT))
flag |= 2;
/* 通过一个路径filename来打开一个文件，并获取文件的inode
*/
error = open_namei(filename,flag,mode,&inode,NULL);
if (error) {
current->filp[fd]=NULL;
f->f_count--;
return error;
}

/* 在open函数当中，先通过open_namei函数获取对应路径文件的inode
* 在获取的inode当中会有f_op的操作符，Linux的文件系统是根据所要
* 操作文件的类型来确定文件操作的f_op和i_op，因为Linux支持的文件系统众多
* 每种文件系统的f_op和i_op都有特定的实现，文件系统具体函数的实现在相应的
* 文件夹当中，如ext2文件系统的实现在/fs/ext2/当中
*/
f->f_inode = inode;
f->f_pos = 0;
f->f_reada = 0;
f->f_op = NULL;
if (inode->i_op)
f->f_op = inode->i_op->default_file_ops;
if (f->f_op && f->f_op->open) {
error = f->f_op->open(inode,f);
if (error) {
iput(inode);
f->f_count--;
current->filp[fd]=NULL;
return error;
}
}
f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
return (fd);
}

/* flag为打开文件方式，如可读，可写，可读写，
* 如果文件没有则会去创建一个新的文件
* mode中有在创建新的文件时候才起作用，也就是确定新建文件的权限
*/
asmlinkage int sys_open(const char * filename,int flags,int mode)
{
char * tmp;
int error;

error = getname(filename, &tmp);
4000
if (error)
return error;
error = do_open(tmp,flags,mode);
putname(tmp);
return error;
}
在sys_open函数当中先是做了数据的拷贝，这个现在可以不用管，然后就直接调用了do_open函数，在do_open函数当中首先给分配了一个struct file结构，然后根据函数当中给定的路径来获取相应文件的struct inode，open_namei这个函数我这里来简单介绍一下它的基本过程，首先它会根据路径来查找相应文件的struct inode，依次处理目录中的每一个struct inode，直到找到最后路径给出的那个文件的struct
inode，如现在给出下面一个路径/etc/demo.txt，首先会获取/路径的struct inode，然后再该inode下面查找一个叫做etc目录的struct inode，找到了之后再去查找etc这个目录的inode下面的一个叫做demo.txt的struct inode，注意在这个查找的过程当中有一个非常重要的动作，就是给struct inode的i_op赋值，因为在查找的过程当中就知道demo.txt是一个什么文件系统的什么类型的文件了，这个读取inode的函数如下：

void ext2_read_inode (struct inode * inode)
{
struct buffer_head * bh;
struct ext2_inode * raw_inode;
unsigned long block_group;
unsigned long group_desc;
unsigned long desc;
unsigned long block;
struct ext2_group_desc * gdp;

if ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino != EXT2_ACL_IDX_INO &&
inode->i_ino != EXT2_ACL_DATA_INO && inode->i_ino < EXT2_FIRST_INO) ||
inode->i_ino > inode->i_sb->u.ext2_sb.s_es->s_inodes_count) {
ext2_error (inode->i_sb, "ext2_read_inode",
"bad inode number: %lu", inode->i_ino);
return;
}
block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
if (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
ext2_panic (inode->i_sb, "ext2_read_inode",
"group >= groups count");
group_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
desc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
bh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
if (!bh)
ext2_panic (inode->i_sb, "ext2_read_inode",
"Descriptor not loaded");
gdp = (struct ext2_group_desc *) bh->b_data;
block = gdp[desc].bg_inode_table +
(((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
/ EXT2_INODES_PER_BLOCK(inode->i_sb));
if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
ext2_panic (inode->i_sb, "ext2_read_inode",
"unable to read i-node block\n"
"inode=%lu, block=%lu", inode->i_ino, block);
raw_inode = ((struct ext2_inode *) bh->b_data) +
(inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
/* 浠庣鐩樹腑璇诲彇鐨別xt2鏂囦欢绯荤粺涓枃浠剁殑inode鐨勬暟鎹?
* 骞惰祴鍊?
*/
inode->i_mode = raw_inode->i_mode;
inode->i_uid = raw_inode->i_uid;
inode->i_gid = raw_inode->i_gid;
inode->i_nlink = raw_inode->i_links_count;
inode->i_size = raw_inode->i_size;
inode->i_atime = raw_inode->i_atime;
inode->i_ctime = raw_inode->i_ctime;
inode->i_mtime = raw_inode->i_mtime;
inode->u.ext2_i.i_dtime = raw_inode->i_dtime;
inode->i_blksize = inode->i_sb->s_blocksize;
inode->i_blocks = raw_inode->i_blocks;
inode->u.ext2_i.i_flags = raw_inode->i_flags;
inode->u.ext2_i.i_faddr = raw_inode->i_faddr;
inode->u.ext2_i.i_frag = raw_inode->i_frag;
inode->u.ext2_i.i_fsize = raw_inode->i_fsize;
inode->u.ext2_i.i_file_acl = raw_inode->i_file_acl;
inode->u.ext2_i.i_dir_acl = raw_inode->i_dir_acl;
inode->u.ext2_i.i_version = raw_inode->i_version;
inode->u.ext2_i.i_block_group = block_group;
inode->u.ext2_i.i_next_alloc_block = 0;
inode->u.ext2_i.i_next_alloc_goal = 0;
if (inode->u.ext2_i.i_prealloc_count)
ext2_error (inode->i_sb, "ext2_read_inode",
"New inode has non-zero prealloc count!");
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode->i_rdev = raw_inode->i_block[0];
else for (block = 0; block < EXT2_N_BLOCKS; block++)
inode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
brelse (bh);
inode->i_op = NULL;
/* 閫氳繃鍒ゆ柇鏂囦欢绫诲瀷鏉ヨ缃枃浠剁殑璇诲啓鍑芥暟
*/
if (inode->i_ino == EXT2_ACL_IDX_INO ||
inode->i_ino == EXT2_ACL_DATA_INO)
/* Nothing to do */ ;
else if (S_ISREG(inode->i_mode))
inode->i_op = &ext2_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &ext2_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &ext2_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
if (inode->u.ext2_i.i_flags & EXT2_SYNC_FL)
inode->i_flags |= MS_SYNC;
}

在知道了struct file的f_op和struct inode的i_op之后，当你需要去调用某个系统调用的时候，其实最后的关键操作都交给相应的f_op和i_op去操作了。