当我们在C程序中用到某些库函数进行文件读取操作时，后续的整个过程都是透明的，为了了解文件系统在其中起到了什么作用，又是如何和内核的其他部分进行协作的，我们可以对Read()函数进行追踪，下面的代码均来自linux2.6.11.10版本的内核。
首先，我们写下如下的测试程序，test.c，其中1.txt里只有一句Hello,World。
#include <stdio.h>
#include <stdlib.h>
int main() {
char word[20];
FILE *fp;
if((fp = fopen("1.txt","a+")) == NULL) {
fprintf(stdout, "ERROR!");
exit(EXIT_FAILURE);
} fscanf(fp,"%s",word);
printf("%s\n",word);
return 0;
} 然后进行编译，并通过strace 工具查看函数运行时用到了哪些系统调用函数，并将结果输出到hello.txt中。
~/test$ gcc hello.c -o hello~/test$ strace -o hello.txt ./hello 查看hello.txt中的主要内容如下
……
openat(AT_FDCWD, "x86_64/libc.so.6", O_RDONLY|O_CLOEXEC) = -1 ENOENT
……
openat(AT_FDCWD, "1.txt", O_RDWR|O_CREAT|O_APPEND, 0666) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=13, ...}) = 0
read(3, "Hello,World!\n", 4096) = 13
fstat(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 1), ...}) = 0
write(1, "Hello,World!\n", 13) = 13
lseek(3, -1, SEEK_CUR) = 12
exit_group(0) = ? 可以看到首先打开了libc.so，这里面封装了我们需要的库函数，而后调用了write、read、lseek等库函数。
我们知道，系统调用有两种方式实现，一种是老旧的int$0x80方式，还有一种是sysenter，具体细节不纠结，但过程总是先将系统调用号存入$eax，然后进行系统调用，这部分实现已经完全放进库函数了，进行系统调用后，会查系统调用表，比如read的系统调用就是3，那么查表就能查到这个函数。
比如i386处理器的系统调用号局部如下所示
/linux-2.6.11.10/include/asm-i386/unistd.h
#define __NR_restart_syscall 0
#define __NR_exit 1
#define __NR_fork 2
#define __NR_read 3
#define __NR_write 4
#define __NR_open 5
#define __NR_close 6
#define __NR_waitpid 7
#define __NR_creat 8
#define __NR_link 9
#define __NR_unlink 10
#define __NR_execve 11
#define __NR_chdir 12
#define __NR_time 13
#define __NR_mknod 14
#define __NR_chmod 15
#define __NR_lchown 16
#define __NR_break 17 由上我们看到，调用read的系统调用号为3，在这个文件的下面我们还能看到比较老旧的系统调用实现代码，现在这个功能好像已经放到库中去实现了，不在内核中实现，这里内核版本较老，所以在内核中还能看到，这里用的是通过系统调用需要的参数个数来进行区分的。
/linux-2.6.11.10/include/asm-i386/unistd.h
#define __syscall_return(type, res) \
do { \
if ((unsigned long)(res) >= (unsigned long)(-(128 + 1))) { \
errno = -(res); \
res = -1; \
} \
return (type) (res); \
} while (0)
/* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
#define _syscall0(type,name) \
type name(void) \
{ \
long __res; \
__asm__ volatile ("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##name)); \
__syscall_return(type,__res); \
} 而之后，read会调用相应的服务例程sys_read，此函数定义如下。
/linux-2.6.11.10/fs/read_write.c
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); //buf为用户态缓冲区，count为读取长度
file_pos_write(file, pos); //将新的偏移地址写回文件
fput_light(file, fput_needed); //释放文件
}
return ret;
}
EXPORT_SYMBOL_GPL(sys_read);该函数首先通过fget_light（light表示轻量级的）通过文件描述符，来返回一个文件地址，类型为虚拟文件系统层的struct file，然后获取文件偏移地址，并调用vfs_read即虚拟文件系统的读操作，从这里我们可以看到，无论底层是什么文件系统，由于有VFS这个中间层存在，对文件进行操作都可以把事情交给VFS来处理，这是抽象的好处。
我们可以在sys_read所在的文件里找到vfs_read。
/linux-2.6.11.10/fs/read_write.c
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) {
ret = security_file_permission (file, MAY_READ); //检查是否有读的权限
if (!ret) {
if (file->f_op->read)
ret = file->f_op->read(file, buf, count, pos); //如有则调用相应文件系统的read函数
else
ret = do_sync_read(file, buf, count, pos); //否则调用这个函数
if (ret > 0) {
dnotify_parent(file->f_dentry, DN_ACCESS); //通知父目录文件已获取
current->rchar += ret;
}
current->syscr++; //一些I/O次数的统计
}
}
return ret;
}
EXPORT_SYMBOL(vfs_read);我们可以看到，vfs_read函数只是检查了一些状态，就使用回调函数 file->f_op->read，使用相应文件系统的read函数继续进行操作，这个file_operations应该是open file的时候就已经填好的，我们可以/linux-2.6.11.10/fs/ext2/file.c里找到ext2所有的文件操作，如下，其实在新内核里，read和write之类的操作已经改了。
/linux-2.6.11.10/fs/ext2/file.c
struct file_operations ext2_file_operations = {
.llseek = generic_file_llseek,
.read = generic_file_read,
.write = generic_file_write,
.aio_read = generic_file_aio_read,
.aio_write = generic_file_aio_write,
.ioctl = ext2_ioctl,
.mmap = generic_file_mmap,
.open = generic_file_open,
.release = ext2_release_file,
.fsync = ext2_sync_file,
.readv = generic_file_readv,
.writev = generic_file_writev,
.sendfile = generic_file_sendfile,
};可以看到，ext2的read操作并没有额外定义，而是使用了一个通用文件读函数，在/linux-2.6.11.10/mm/filemap.c文件里可以找到这个函数，因为读写是基于页操作的。
/linux-2.6.11.10/mm/filemap.c
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 }; //用local_iov存用户缓区和读取长度
struct kiocb kiocb; //同步和异步I/O操作描述符
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_aio_read，字面理解就是异步I/O读，它不是立即读取，而是会先在一个链表里排队，如果在排队就需要继续等。
/linux-2.6.11.10/mm/filemap.c
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; //与正在进行的read操作相关的文件对象指针
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)) //检查ivoec描述符所描述的用户态缓冲区是否有效
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) { //直接I/O模式
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; //如果不是直接I/O模式的话，就用页高速缓存
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 (!retval) {
retval = desc.error;
break;
}
}
}
out:
return retval;
}
EXPORT_SYMBOL(__generic_file_aio_read);我们可以将上面这个函数粗略划分为三部分，检查部分，以及直接I/O读取，和页高速缓存读取，如果设置了O_DIRECT标志，则直接读取调用generic_file_direct_IO()，否则要使用页高速缓存，调用do_generic_file_read，，我们主要关注页高速缓存读取。
/linux-2.6.11.10/include/linux/fs.h
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，这个调用表示对文件的读操作转换为对页高速缓存的读操作。
之所以要在I/O过程中加入页高速缓存这么一个缓冲层，是为了提高读取的效率，我们希望能尽量减少对磁盘的读取，而将读取放到内存中进行，所以引入页高速缓存这么一个中间层。
上面的参数中有一个filp->f_mapping，这个是一个地址空间变量，其定义如下。
/linux-2.6.11.10/include/linux/fs.h
struct address_space {
struct inode *host; /* owner: inode, block_device */
struct radix_tree_root page_tree; /* radix tree of all pages */
spinlock_t tree_lock; /* and spinlock protecting it */
unsigned int i_mmap_writable;/* count VM_SHARED mappings */
struct prio_tree_root i_mmap; /* tree of private and shared mappings */
struct list_head i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
spinlock_t i_mmap_lock; /* protect tree, count, list */
unsigned int truncate_count; /* Cover race condition with truncate */
unsigned long nrpages; /* number of total pages */
pgoff_t writeback_index;/* writeback starts here */
struct address_space_operations *a_ops; /* methods */
unsigned long flags; /* error bits/gfp mask */
struct backing_dev_info *backing_dev_info; /* device readahead, etc */
spinlock_t private_lock; /* for use by the address_space */
struct list_head private_list; /* ditto */
struct address_space *assoc_mapping; /* ditto */
} __attribute__((aligned(sizeof(long))));通过host和page_tree两个属性，一个adrees_space结构体可以将一个文件和属于它的缓存页联系起来，page_tree是struct radix_tree_root类型的，就是一颗树的根，它指向一颗基树，相应的页都存在叶子节点上，这样找页就很简单了。
在do_generic_mapping_read里，检查完基础数据后，会建立一个循环，这个循环每次读一页内容，直到读完所有内容。
首先是find_page，它会通过关联有页的基树找到相应的页，如果没找到，就跳到no_cached_page重新分配一个页插入到基树里去，如果为脏页则需要更新，如果既能找到，又不需要更新，那么直接page_ok将数据拷贝到用户态即可。
/linux-2.6.11.10/mm/filemap.c——do_generic_mapping_read
find_page:
page = find_get_page(mapping, index); //首先在页高速缓存里寻找页描述符
if (unlikely(page == NULL)) {
handle_ra_miss(mapping, &ra, index);
goto no_cached_page;
}
if (!PageUptodate(page)) //检查是否为脏页
goto page_not_up_to_date;找到页以后开始读页，主要的重点语句是这一句
linux-2.6.11.10/mm/filemap.c——do_generic_mapping_read
readpage:
/* Start the actual read. The read will unlock the page. */
error = mapping->a_ops->readpage(filp, page);
if (unlikely(error))
goto readpage_error;
if (!PageUptodate(page)) {
lock_page(page);
if (!PageUptodate(page)) {
if (page->mapping == NULL) {
/*
* invalidate_inode_pages got it
*/
unlock_page(page);
page_cache_release(page);
goto find_page;
}
unlock_page(page);
error = -EIO;
goto readpage_error;
}
unlock_page(page);
}
/*
* i_size must be checked after we have done ->readpage.
*
* Checking i_size after the readpage allows us to calculate
* the correct value for "nr", which means the zero-filled
* part of the page is not copied back to userspace (unless
* another truncate extends the file - this is desired though).
*/
isize = i_size_read(inode);
end_index = (isize - 1) >> PAGE_CACHE_SHIFT;
if (unlikely(!isize || index > end_index)) {
page_cache_release(page);
goto out;
}
/* nr is the maximum number of bytes to copy from this page */
nr = PAGE_CACHE_SIZE;
if (index == end_index) {
nr = ((isize - 1) & ~PAGE_CACHE_MASK) + 1;
if (nr <= offset) {
page_cache_release(page);
goto out;
}
}
nr = nr - offset;
goto page_ok;这里又出现了一个回调函数，又调用了相关文件系统的相关函数，我们可以找到ext2的a_ops定义如下：
/linux-2.6.11.10/fs/ext2/inode.c
struct address_space_operations ext2_aops = {
.readpage = ext2_readpage,
.readpages = ext2_readpages,
.writepage = ext2_writepage,
.sync_page = block_sync_page,
.prepare_write = ext2_prepare_write,
.commit_write = generic_commit_write,
.bmap = ext2_bmap,
.direct_IO = ext2_direct_IO,
.writepages = ext2_writepages,
};再找到ext2_readpage开始我们的读页操作。
/linux-2.6.11.10/fs/ext2/inode.c
static int ext2_readpage(struct file *file, struct page *page)
{
return mpage_readpage(page, ext2_get_block);
}这里它又继续调用了一个通用例程mapge_readpage，导入了页地址以及ext2的数据块寻址函数。
/linux-2.6.11.10/fs/mpage.c
int mpage_readpage(struct page *page, get_block_t get_block)
{
struct bio *bio = NULL;
sector_t last_block_in_bio = 0;
bio = do_mpage_readpage(bio, page, 1,
&last_block_in_bio, get_block);
if (bio)
mpage_bio_submit(READ, bio);
return 0;
}
EXPORT_SYMBOL(mpage_readpage);这里就两步操作，申请一个struct bio对象，然后提交这个任务。bio是通用块层用来管理传输数据的，他把一个磁盘存储区和一块内存区域联系起来。
然后提交这个任务，这里面其实还有一个调度过程，所有的bio请求都在一个队列里，它可以重排读写数据块的请求，在重复访问文件同一个部分或多进程访问同一数据，可以大大提高读取效率。
最终，这件读操作会交给磁盘的设备驱动程序来进行真正的数据操作。
读完以后，再回到do_generic_mapping_read，跳到page_ok，它会调用__copy_to_user()函数将数据拷贝到用户态缓冲区，
linux-2.6.11.10/mm/filemap.c——do_generic_mapping_read
page_ok:
/* If users can be writing to this page using arbitrary
* virtual addresses, take care about potential aliasing
* before reading the page on the kernel side.
*/
if (mapping_writably_mapped(mapping))
flush_dcache_page(page);
/*
* When (part of) the same page is read multiple times
* in succession, only mark it as accessed the first time.
*/
if (prev_index != index)
mark_page_accessed(page);
prev_index = index;
/*
* Ok, we have the page, and it's up-to-date, so
* now we can copy it to user space...
*
* The actor routine returns how many bytes were actually used..
* NOTE! This may not be the same as how much of a user buffer
* we filled up (we may be padding etc), so we can only update
* "pos" here (the actor routine has to update the user buffer
* pointers and the remaining count).
*/
ret = actor(desc, page, offset, nr);
offset += ret;
index += offset >> PAGE_CACHE_SHIFT;
offset &= ~PAGE_CACHE_MASK;
page_cache_release(page);
if (ret == nr && desc->count)
continue;
goto out;linux-2.6.11.10/mm/filemap.c
int file_read_actor(read_descriptor_t *desc, struct page *page,
unsigned long offset, unsigned long size)
{
char *kaddr;
unsigned long left, count = desc->count;
if (size > count)
size = count;
/*
* Faults on the destination of a read are common, so do it before
* taking the kmap.
*/
if (!fault_in_pages_writeable(desc->arg.buf, size)) {
kaddr = kmap_atomic(page, KM_USER0);
left = __copy_to_user_inatomic(desc->arg.buf,
kaddr + offset, size);
kunmap_atomic(kaddr, KM_USER0);
if (left == 0)
goto success;
}
/* Do it the slow way */
kaddr = kmap(page);
left = __copy_to_user(desc->arg.buf, kaddr + offset, size);
kunmap(page);
if (left) {
size -= left;
desc->error = -EFAULT;
}
success:
desc->count = count - size;
desc->written += size;
desc->arg.buf += size;
return size;
}然后更新一些计数，再一步步往上返回到最开始的read()系统调用，调用就结束了。
