文件系统读写--文件读过程代码分析
2017-10-12 10:04
309 查看
10.4 文件读过程代码分析
为了便于理解文件的读写过程，图10-1给出一个例子文件的内容分布图
a
文件总长度4096字节 * 7 = 28672 字节。从
内核处理读文件从sys_read函数开始，从这个函数开始读过程分析：
sys_read函数首先根据文件ID获得文件结构的指针。每个进程都有一个files_struct结构指针，保存了进程所有打开的文件，因此以文件ID为索引，可以获得文件结构指针。其次获取文件的当前位置，这个参数是文件系统的内部保存，每次执行函数调用，都要记录读操作的最后位置，以备下次使用。
最后调用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：
generic_file_read函数主要解决文件 同步操作 和 异步操作 的问题，这是通过一个同步控制结构kiocb实现。函数开始调用init_sync_kiocb初始化一个同步控制块kiocb，然后将读操作异步提交，如果读操作返回 EIOCBQUEUED ，进程置为睡眠态，等待kiocb的成员ki_user变为0。kiocb结构的定义在文件
\include\aio.h中，而它的控制逻辑主要在内核的异步I/O实现文件aio.h中。
wait_on_sync_kiocb函数：
前面的章节分析过，真正的异步操作是很难实现。使用page_cache的buffer I/O时因为要等待读I/O完成才能返回，这个过程有可能阻塞进程，所以buffer I/O的实现过程本身就不能保证异步，等buffer I/O读过程返回，实际上已经完成读操作。
2、__generic_file_aio_read函数
__generic_file_aio_read，输入参数iov包含用户传入的用户态地址和希望读的字节数：
a
a
a
3、do_generic_file_read函数
内核提供的通用读函数：
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
为了便于理解文件的读写过程，图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
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 文件系统读写--文件写过程代码分析
- 分析Android 根文件系统启动过程（init守护进程分析）
- 分析Android 根文件系统启动过程（init守护进程分析）
- 分析Android 根文件系统启动过程（init守护进程分析）
- 分析Android 根文件系统启动过程（init守护进程分析）
- 分析Android 根文件系统启动过程（init守护进程分析）
- 分析Android 根文件系统启动过程（init守护进程分析）
- 分析Android 根文件系统启动过程（init守护进程分析）
- Android 根文件系统启动过程(init进程 详细分析)
- 分析Android 根文件系统启动过程（init守护进程分析）
- Linux--根文件系统的挂载过程分析
- 分析Android 根文件系统启动过程（init守护进程分析）
- Linux--根文件系统的挂载过程分析
- qtopia 文件系统启动过程分析
- 分析Android 根文件系统启动过程（init守护进程分析）
- Linux 内核启动挂载android根文件系统过程分析
- read write 调用过程 文件读写 分析
- 分析Android 根文件系统启动过程（init守护进程分析）
- 分析Android 根文件系统启动过程（init守护进程分析
- 分析Android 根文件系统启动过程（init守护进程分析）