Linux中文件描述符的理解(文件描述符、文件表项、i-node)

目录

前言 

打开文件描述符表

文件表项

inode节点

总结


前言 

      本文中涉及到的Linux源码来源于linux 2.6.39.4。

       就像windows中的句柄一样,学习linux经常会碰到文件描述符,我们都知道文件描述符是一个非负整数,每一个文件描述符都唯一对应了一个打开的文件,那么文件描述符在内核中到底是以什么形式存在的呢?

       这个问题是我在读《UNIX环境高级编程》的时候感到疑惑的,在该书的3.10章节中,关于文件共享有以下一段描述:

Linux中文件描述符的理解(文件描述符、文件表项、i-node)_第1张图片

        从这段文字中,可以得出一个结论:在内核中每一个打开的文件都需要由3种数据结构来进行维护

        根据文中内容,这三种数据结构分别为:

1.每个进程对应一张打开文件描述符表,这是进程级数据结构,也就是每一个进程都各自有这样一个数据结构;

2.内核维持一张打开文件表,文件表由多个文件表项组成,这是系统级数据结构,也就是说这样的数据结构是针对于整个内核而言的,每个进程都可共享的;

3.每个打开的文件对应一个i节点(i-node)数据结构(Linux下只有i节点没有v节点),由于这是每一个打开的文件与之对应的,因此这也是一个系统级数据结构,存在于内核中,非进程所独有。

       那么,这三种数据结构到底是什么呢?

打开文件描述符表

       首先来看第一个数据结构—— 打开文件描述符表。

       在Linux中,对于每一个进程,都会分配一个PCB数据结构,它其中包含了该进程的所有信息,而在代码实现上,这个数据结构名为task_struct,在linux源码的include/linux/sched.h中可以找到其定义,它是一个很庞大的结构体,部分定义如下:

struct task_struct {
	......
/* CPU-specific state of this task */
	struct thread_struct thread;
/* filesystem information */
	struct fs_struct *fs;
/* open file information */
	struct files_struct *files;
/* namespaces */
	struct nsproxy *nsproxy;
/* signal handlers */
	struct signal_struct *signal;
	struct sighand_struct *sighand;
	......
};

        在task_struct中,有一个成员变量名为files,注释中提到这是一个描述打开文件信息的变量,其类型为struct files_struct *,那么现在再接着看files_struct,在linux源码的include/linux/fdtable.h中可以找到其定义,定义如下:

struct files_struct {
  /*
   * read mostly part
   */
	atomic_t count;
	struct fdtable __rcu *fdt;
	struct fdtable fdtab;
  /*
   * written part on a separate cache line in SMP
   */
	spinlock_t file_lock ____cacheline_aligned_in_smp;
	int next_fd;
	struct embedded_fd_set close_on_exec_init;
	struct embedded_fd_set open_fds_init;
	struct file __rcu * fd_array[NR_OPEN_DEFAULT]; //进程级打开文件描述符表
};

       而这里所要找到的打开文件描述符表,实际上就是files_struct 中的成员struct file * fd_array[NR_OPEN_DEFAULT]它是一个指针数组,数组每一个元素都是一个指向file类型的指针,可想而知,这些指针都会指向一个打开的文件,并且file这一数据结构就是用来描述一个打开的文件的,而我们所说的文件描述符,实际上就是这个指针数组的索引。这也是为什么文件描述符是非负整数。

       再来看第二种数据结构——文件表项

文件表项

       前面说了,每一个打开文件实际上就是用一个file结构体进行描述的,在linux源码的include/linux/fs.h中可以找到其定义,定义如下:

struct file {
	/*
	 * fu_list becomes invalid after file_free is called and queued via
	 * fu_rcuhead for RCU freeing
	 */
	union {
		struct list_head	fu_list;
		struct rcu_head 	fu_rcuhead;
	} f_u;
	struct path		f_path;     //文件路径,包括目录项以及i-node
#define f_dentry	f_path.dentry
#define f_vfsmnt	f_path.mnt
	const struct file_operations	*f_op;
	spinlock_t		f_lock;  /* f_ep_links, f_flags, no IRQ */
#ifdef CONFIG_SMP
	int			f_sb_list_cpu;
#endif
	atomic_long_t		f_count;  //文件打开次数
	unsigned int 		f_flags;  //文件打开时的flag,对应于open函数的flag参数
	fmode_t			f_mode;   //文件打开时的mode,对应于open函数的mode参数
	loff_t			f_pos;    //文件偏移位置
	struct fown_struct	f_owner;  
	const struct cred	*f_cred;
	struct file_ra_state	f_ra;

	u64			f_version;
#ifdef CONFIG_SECURITY
	void			*f_security;
#endif
	/* needed for tty driver, and maybe others */
	void			*private_data;

#ifdef CONFIG_EPOLL
	/* Used by fs/eventpoll.c to link all the hooks to this file */
	struct list_head	f_ep_links;
#endif /* #ifdef CONFIG_EPOLL */
	struct address_space	*f_mapping;
#ifdef CONFIG_DEBUG_WRITECOUNT
	unsigned long f_mnt_write_state;
#endif
};

       在file结构体中,不得不再说一下它的f_path成员,这是一个struct path类型的变量,该类型定义于include/linux/path.h:

struct path {
	struct vfsmount *mnt;
	struct dentry *dentry;
};

        这里的dentry实际上就指向文件所在的目录项了,struct dentry的类型定义于include/linux/dcache.h:

struct dentry {
	/* RCU lookup touched fields */
	unsigned int d_flags;		/* protected by d_lock */
	seqcount_t d_seq;		/* per dentry seqlock */
	struct hlist_bl_node d_hash;	/* lookup hash list */
	struct dentry *d_parent;	/* parent directory */
	struct qstr d_name;
	struct inode *d_inode;		/* Where the name belongs to - NULL is
					 * negative */
	unsigned char d_iname[DNAME_INLINE_LEN];	/* small names */

	/* Ref lookup also touches following */
	unsigned int d_count;		/* protected by d_lock */
	spinlock_t d_lock;		/* per dentry lock */
	const struct dentry_operations *d_op;
	struct super_block *d_sb;	/* The root of the dentry tree */
	unsigned long d_time;		/* used by d_revalidate */
	void *d_fsdata;			/* fs-specific data */

	struct list_head d_lru;		/* LRU list */
	/*
	 * d_child and d_rcu can share memory
	 */
	union {
		struct list_head d_child;	/* child of parent list */
	 	struct rcu_head d_rcu;
	} d_u;
	struct list_head d_subdirs;	/* our children */
	struct list_head d_alias;	/* inode alias list */
};

       在dentry结构体中,描述了根结点、父节点等等信息,尤其还要注意的是struct inode *d_inode这一变量,它则是指向了一个i-node结点。

      再回到file结构体中,有一个struct file_operations *f_op变量,其类型定义在include/linux/fs.h中:

struct file_operations {
	struct module *owner;
	loff_t (*llseek) (struct file *, loff_t, int);
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	int (*readdir) (struct file *, void *, filldir_t);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	int (*mmap) (struct file *, struct vm_area_struct *);
	int (*open) (struct inode *, struct file *);
	int (*flush) (struct file *, fl_owner_t id);
	int (*release) (struct inode *, struct file *);
	int (*fsync) (struct file *, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
	int (*check_flags)(int);
	int (*flock) (struct file *, int, struct file_lock *);
	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
	int (*setlease)(struct file *, long, struct file_lock **);
	long (*fallocate)(struct file *file, int mode, loff_t offset,
			  loff_t len);
};

      可见,在该成员中包含了所有文件操作相关的函数指针。

      每一个打开的文件都对应于一个file结构体,在该结构体中,f_flags描述了文件标志,f_pos描述了文件的偏移位置,而在f_path中有含有一个指向一个inode结点的指针,这也符合了《UNIX环境高级编程》中的以下描述:

       因此可以知道,文件表项的数据结构就是file结构体,而在实际上内核中也并不存在这样一张文件表,只是每个打开的文件都对应一个file结构体,也就是一个文件表项,打开文件描述符表struct file * fd_array[NR_OPEN_DEFAULT]数组中的每一项都会指向这样一个文件表项,如下图所示:

Linux中文件描述符的理解(文件描述符、文件表项、i-node)_第2张图片

inode节点

       第三种数据结构就是inode节点,在include/linux/fs.h中找到其定义如下:

struct inode {
	/* RCU path lookup touches following: */
	umode_t			i_mode;     //权限
	uid_t			i_uid;      //用户id
	gid_t			i_gid;      //组id
	const struct inode_operations	*i_op;
	struct super_block	*i_sb;

	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
	unsigned int		i_flags;
	struct mutex		i_mutex;

	unsigned long		i_state;
	unsigned long		dirtied_when;	/* jiffies of first dirtying */

	struct hlist_node	i_hash;
	struct list_head	i_wb_list;	/* backing dev IO list */
	struct list_head	i_lru;		/* inode LRU list */
	struct list_head	i_sb_list;
	union {
		struct list_head	i_dentry;
		struct rcu_head		i_rcu;
	};
	unsigned long		i_ino;   //inode节点号
	atomic_t		i_count;
	unsigned int		i_nlink;
	dev_t			i_rdev;
	unsigned int		i_blkbits;
	u64			i_version;
	loff_t			i_size;   //文件大小
#ifdef __NEED_I_SIZE_ORDERED
	seqcount_t		i_size_seqcount;
#endif
	struct timespec		i_atime;  //最后一次访问(access)的时间
	struct timespec		i_mtime;  //最后一次修改(modify)的时间
	struct timespec		i_ctime;  //最后一次改变(change)的时间
	blkcnt_t		i_blocks;    //块数
	unsigned short          i_bytes;
	struct rw_semaphore	i_alloc_sem;
	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
	struct file_lock	*i_flock;
	struct address_space	*i_mapping;   //块地址映射
	struct address_space	i_data;
#ifdef CONFIG_QUOTA
	struct dquot		*i_dquot[MAXQUOTAS];
#endif
	struct list_head	i_devices;
	union {
		struct pipe_inode_info	*i_pipe;
		struct block_device	*i_bdev;
		struct cdev		*i_cdev;
	};

	__u32			i_generation;

#ifdef CONFIG_FSNOTIFY
	__u32			i_fsnotify_mask; /* all events this inode cares about */
	struct hlist_head	i_fsnotify_marks;
#endif

#ifdef CONFIG_IMA
	atomic_t		i_readcount; /* struct files open RO */
#endif
	atomic_t		i_writecount;
#ifdef CONFIG_SECURITY
	void			*i_security;
#endif
#ifdef CONFIG_FS_POSIX_ACL
	struct posix_acl	*i_acl;
	struct posix_acl	*i_default_acl;
#endif
	void			*i_private; /* fs or device private pointer */
};

       代码中只注释了一部分,通过inode结构,可以知道文件数据块的在磁盘上的位置以及文件大小等信息,这样才能使得进程能够通过file结构体来找到磁盘上相应文件的位置来进行文件读写。

       另外补充一点,关于inode结构体中的struct inode_operations *i_op成员,其数据结构定义在include/linux/fs.h中:

struct inode_operations {
	struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
	void * (*follow_link) (struct dentry *, struct nameidata *);
	int (*permission) (struct inode *, int, unsigned int);
	int (*check_acl)(struct inode *, int, unsigned int);

	int (*readlink) (struct dentry *, char __user *,int);
	void (*put_link) (struct dentry *, struct nameidata *, void *);

	int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
	int (*link) (struct dentry *,struct inode *,struct dentry *);
	int (*unlink) (struct inode *,struct dentry *);
	int (*symlink) (struct inode *,struct dentry *,const char *);
	int (*mkdir) (struct inode *,struct dentry *,int);
	int (*rmdir) (struct inode *,struct dentry *);
	int (*mknod) (struct inode *,struct dentry *,int,dev_t);
	int (*rename) (struct inode *, struct dentry *,
			struct inode *, struct dentry *);
	void (*truncate) (struct inode *);
	int (*setattr) (struct dentry *, struct iattr *);
	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
	int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
	ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
	ssize_t (*listxattr) (struct dentry *, char *, size_t);
	int (*removexattr) (struct dentry *, const char *);
	void (*truncate_range)(struct inode *, loff_t, loff_t);
	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
		      u64 len);
} ____cacheline_aligned;

        可见,在该成员变量所指向的数据结构中,包含了许多函数指针,这些函数指针大多针对于目录、文件操作。

总结

       进程、打开文件描述符表、文件表项和i-node结点关系如图所示。(暂时忽略进程中0、1和2号文件描述符分别默认为标准输入、标准输出和标准错误的情况)

Linux中文件描述符的理解(文件描述符、文件表项、i-node)_第3张图片

通过以上分析,我们可以得出以下结论:

1.每启动一个进程都会为其分配一个task_struct结构体,在task_struct结构体中含有一个file_struct结构体指针,其所指向的file_struct结构体中,含有一个file*的指针数组fd_array,它就是打开文件描述符表,其中每一个元素都指向一个文件表项,这个数组的索引就是文件描述符。此外,file_struct结构体中的next_fd保存的是下一个分配的文件描述符,它会在调用open和close改变,最终使得每次open返回的都是当前可用的最小文件描述符

2.每次调用open或者create(内部实际上还是调用的open),都会对新打开的文件分配一个file结构体,并且将打开文件的标志、状态、权限等信息填入这个file结构体中。这个file结构体也叫文件表项;

3.磁盘中的每个文件都对应一个i-node,每一个文件表项都会指向一个文件的i-node,但是同一文件的i-node可以对应多个文件表项(当多次调用open打开同一个文件时就会出现这种情况,不管是同一进程多次打开同一文件如图中A进程的0号和2号文件描述符对应两个文件表项,但是最终指向同一i-node即同一文件)还是不同进程多次打开同一文件如图中A进程3号文件描述符和B进程的3号文件描述符);

4.同一进程下的不同文件描述符是可以指向同一文件表项,即最终指向同一文件(如图中A进程的0号文件描述符和1号文件描述符,使用dup函数即可实现)。

5.子进程在创建时会拷贝父进程的打开文件描述符表,因此父子进程是共享文件表项的,如图所示:

Linux中文件描述符的理解(文件描述符、文件表项、i-node)_第4张图片

       而相互独立的不同进程的打开文件描述符表是相互独立的,因此相互独立的多个进程之间的文件描述符可以相同,但是不同进程的文件描述符是不能指向同一文件表项的(除非这个文件描述符是从同一个祖先进程中继承得来的),但是这并不妨碍不同进程访问同一文件(如第3点结论);

6.指向同一文件表项的不同文件描述符(不同进程相同数值的文件描述符也看做不同)共享文件标志、文件偏移等信息;

7.每一个文件表项对应的file结构体中的f_count会记录通过该文件表项打开文件的次数,当f_count计数归0时这个文件表项才会被删除,因此,对于指向同一文件表项的两个不同文件描述符(如子进程所继承的父进程的文件描述符,或同一进程中dup的两个文件描述符指向同一个文件表项),即使其中一个文件描述符关闭了,只要仍然有文件描述符指向这个文件表项,那么就依然能通过这个文件表项访问文件,直到所有指向该文件表项的文件描述符都关闭了才不能再进行访问;

最后再加一张图加以理解:

Linux中文件描述符的理解(文件描述符、文件表项、i-node)_第5张图片

你可能感兴趣的:(Linux)