文件系统读写--文件读过程代码分析

10.4 文件读过程代码分析

        为了便于理解文件的读写过程，图10-1给出一个例子文件的内容分布图

        a

        文件总长度4096字节 * 7 = 28672 字节。从

        内核处理读文件从sys_read函数开始，从这个函数开始读过程分析：

asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
{
	struct file *file;
	ssize_t ret = -EBADF;
	int fput_needed;

	file = fget_light(fd, &fput_needed);
	if (file) {
		loff_t pos = file_pos_read(file);
		ret = vfs_read(file, buf, count, &pos);
		file_pos_write(file, pos);
		fput_light(file, fput_needed);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(sys_read);

        sys_read函数首先根据文件ID获得文件结构的指针。每个进程都有一个files_struct结构指针，保存了进程所有打开的文件，因此以文件ID为索引，可以获得文件结构指针。其次获取文件的当前位置，这个参数是文件系统的内部保存，每次执行函数调用，都要记录读操作的最后位置，以备下次使用。

        最后调用vfs_read函数执行文件读，读完之后，把更新的文件当前位置写入文件指针：

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
	ssize_t ret;

	if (!(file->f_mode & FMODE_READ))
		return -EBADF;
	if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
		return -EINVAL;
	if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
		return -EFAULT;
//------校验文件的锁------------------------
	ret = rw_verify_area(READ, file, pos, count);
	if (ret >= 0) {
		count = ret;
		ret = security_file_permission (file, MAY_READ);
		if (!ret) {
			if (file->f_op->read)
				ret = file->f_op->read(file, buf, count, pos);
			else
				ret = do_sync_read(file, buf, count, pos);
			if (ret > 0) {
				fsnotify_access(file->f_dentry);
				current->rchar += ret;
			}
			current->syscr++;
		}
	}

	return ret;
}

EXPORT_SYMBOL(vfs_read);

         vfs_read函数首先检查读写锁的权限。如果文件不支持强制锁，这个检查直接通过；如果支持强制锁，就按照前一节的描述检查锁是否冲突。

        如果文件定义的read函数，调用文件自身的读函数，否则的话，系统提供了一个函数do_sync_read作为读函数。 文件系统的函数是如何注册到文件的f_op指针？这是文件初始化区间生成inode结构是赋予的。数据文件、目录文件或者设备文件各有不同的读写函数，第2章分析过。

        a

--linux-2.6.18\fs\Read_write.h

rw_verify_area函数使用------此函数不使用过大的计数。限制为int型

/*
 * rw_verify_area doesn't like huge counts. We limit
 * them to something that fits in "int" so that others
 * won't have to do range checks all the time.
 */
#define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK)

int rw_verify_area(int read_write, struct file *file, loff_t *ppos, size_t count)
{
	struct inode *inode;
	loff_t pos;

	if (unlikely((ssize_t) count < 0))
		goto Einval;
	pos = *ppos;
	if (unlikely((pos < 0) || (loff_t) (pos + count) < 0))
		goto Einval;

	inode = file->f_dentry->d_inode;
	if (unlikely(inode->i_flock && MANDATORY_LOCK(inode))) {
		int retval = locks_mandatory_area(
			read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
			inode, file, pos, count);
		if (retval < 0)
			return retval;
	}
	return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;

Einval:
	return -EINVAL;
}

        a

--linux-2.6.18\include\linux\Security.h

static inline int security_file_permission (struct file *file, int mask)
{
	return security_ops->file_permission (file, mask);
}

        a

下面是一个函数的调用处理结构

struct security_operations{*;* }

        a

        a

不同文件系统的定义了不同的读写函数，我们选择一个广泛使用的文件系统--exit2文件系统作为例子：

generic_file_read函数

1、generic_file_read函数

        exit2文件系统的读函数使用了generic_file_read：

ssize_t
generic_file_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
	struct iovec local_iov = { .iov_base = buf, .iov_len = count };
	struct kiocb kiocb;
	ssize_t ret;

	init_sync_kiocb(&kiocb, filp);
	ret = __generic_file_aio_read(&kiocb, &local_iov, 1, ppos);
	if (-EIOCBQUEUED == ret)
		ret = wait_on_sync_kiocb(&kiocb);
	return ret;
}
EXPORT_SYMBOL(generic_file_read);

        generic_file_read函数主要解决文件 同步操作 和 异步操作 的问题，这是通过一个同步控制结构kiocb实现。函数开始调用init_sync_kiocb初始化一个同步控制块kiocb，然后将读操作异步提交，如果读操作返回 EIOCBQUEUED ，进程置为睡眠态，等待kiocb的成员ki_user变为0。kiocb结构的定义在文件 \include\aio.h中，而它的控制逻辑主要在内核的异步I/O实现文件aio.h中。

#define init_sync_kiocb(x, filp)			\
	do {						\
		struct task_struct *tsk = current;	\
		(x)->ki_flags = 0;			\
		(x)->ki_users = 1;			\
		(x)->ki_key = KIOCB_SYNC_KEY;		\
		(x)->ki_filp = (filp);			\
		(x)->ki_ctx = NULL;			\
		(x)->ki_cancel = NULL;			\
		(x)->ki_retry = NULL;			\
		(x)->ki_dtor = NULL;			\
		(x)->ki_obj.tsk = tsk;			\
		(x)->ki_user_data = 0;                  \
		init_wait((&(x)->ki_wait));             \
	} while (0)

wait_on_sync_kiocb函数：

/* wait_on_sync_kiocb:
 *	Waits on the given sync kiocb to complete.
 */
ssize_t fastcall wait_on_sync_kiocb(struct kiocb *iocb)
{
	while (iocb->ki_users) {
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (!iocb->ki_users)
			break;
		schedule();
	}
	__set_current_state(TASK_RUNNING);
	return iocb->ki_user_data;
}

        前面的章节分析过，真正的异步操作是很难实现。使用page_cache的buffer I/O时因为要等待读I/O完成才能返回，这个过程有可能阻塞进程，所以buffer I/O的实现过程本身就不能保证异步，等buffer I/O读过程返回，实际上已经完成读操作。

2、__generic_file_aio_read函数

        __generic_file_aio_read，输入参数iov包含用户传入的用户态地址和希望读的字节数：

/**
 * __generic_file_aio_read - generic filesystem read routine
 * @iocb:	kernel I/O control block
 * @iov:	io vector request
 * @nr_segs:	number of segments in the iovec
 * @ppos:	current file position
 *
 * This is the "read()" routine for all filesystems
 * that can use the page cache directly.
 */
ssize_t
__generic_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
		unsigned long nr_segs, loff_t *ppos)
{
	struct file *filp = iocb->ki_filp;
	ssize_t retval;
	unsigned long seg;
	size_t count;

	count = 0;
	for (seg = 0; seg < nr_segs; seg++) {
		const struct iovec *iv = &iov[seg];

		/*
		 * If any segment has a negative length, or the cumulative
		 * length ever wraps negative then return -EINVAL.
		 */
		count += iv->iov_len;
		if (unlikely((ssize_t)(count|iv->iov_len) < 0))
			return -EINVAL;
		if (access_ok(VERIFY_WRITE, iv->iov_base, iv->iov_len))
			continue;
		if (seg == 0)
			return -EFAULT;
		nr_segs = seg;
		count -= iv->iov_len;	/* This segment is no good */
		break;
	}

	/* coalesce the iovecs and go direct-to-BIO for O_DIRECT */
	if (filp->f_flags & O_DIRECT) {
		loff_t pos = *ppos, size;
		struct address_space *mapping;
		struct inode *inode;

		mapping = filp->f_mapping;
		inode = mapping->host;
		retval = 0;
		if (!count)
			goto out; /* skip atime */
		size = i_size_read(inode);
		if (pos < size) {
			retval = generic_file_direct_IO(READ, iocb,
						iov, pos, nr_segs);
			if (retval > 0 && !is_sync_kiocb(iocb))
				retval = -EIOCBQUEUED;
			if (retval > 0)
				*ppos = pos + retval;
		}
		file_accessed(filp);
		goto out;
	}

	retval = 0;
	if (count) {
		for (seg = 0; seg < nr_segs; seg++) {
			read_descriptor_t desc;

			desc.written = 0;
			desc.arg.buf = iov[seg].iov_base;
			desc.count = iov[seg].iov_len;
			if (desc.count == 0)
				continue;
			desc.error = 0;
			do_generic_file_read(filp,ppos,&desc,file_read_actor);
			retval += desc.written;
			if (desc.error) {
				retval = retval ?: desc.error;
				break;
			}
		}
	}
out:
	return retval;
}
EXPORT_SYMBOL(__generic_file_aio_read);

        a

        a

        a

3、do_generic_file_read函数

        内核提供的通用读函数：

static inline void do_generic_file_read(struct file * filp, loff_t *ppos,
					read_descriptor_t * desc,
					read_actor_t actor)
{
	do_generic_mapping_read(filp->f_mapping,
				&filp->f_ra,
				filp,
				ppos,
				desc,
				actor);
}

        do_generic_file_read函数封装了do_generic_mapping_read。输入参数f_mapping封装了块设备的读页面和写页面函数。对于ext2文件系统，它在文件inode初始化的时候设置了读写页面函数结构ext2_aops，打开文件的时候，设置文件的f_mapping等于inode结构提供结构指针。

        a

4、do_generic_mapping_read函数

        a

        a

5、do_mpage_readpage函数

        a

        a

6、block_read_full_page函数

        a

        a