文件的readpage方法

1.3.3 普通文件的readpage方法

回到do_mpage_readpage中，从mpage_readpage传进来的buffer_head类型的map_bh参数的b_bdev、b_blocknr和b_size字段就被赋上值了，然后245~271行对这个map_bh进行一系列的检查，检查可能发生的异常条件。具体有这几种情况：当一些块在磁盘上不相邻时，或某块落如“文件洞”内时，或一个块缓冲区已经由get_block函数写入时。那么跳到confused标号处，用一次读一块的方式读该页。有关“文件的洞”的相关内容，请查阅ULK-3的相关章节。

 

273-282行，很重要，为内部变量blocks[MAX_BUF_PER_PAGE]赋值。由于一页面包含4个块，所以blocks[0]~ blocks[3]就存放着磁盘上是相邻连续4个块的逻辑块号。page_block内部变量也从0变成3了。

 

如果函数运行至286行，说明页中的所有块在磁盘上是相邻的。然而，它可能是文件中的最后一页，因此页中的一些块可能在磁盘上没有映像。如果这样的话，288行将页中相应的块缓冲区填上0；如果不是这样，298行将页描述符的标志PG_mappedtodisk置位。

 

继续走，前面看到，我们传递进来的bio是NULL的，所以来到308行的条件分支。309行调用调用mpage_alloc触发bio_alloc()函数分配包含单一段的一个新bio描述符，并且分别用块设备描述符地址和页中第一个块的逻辑块号blocks[0]来初始化bi_bdev字段和bi_sector字段。这两个信息已在上面的get_block函数中得到。

 

通常，bio结构是由slab分配器分配的，但是，当内存不足时，内核也会使用一个备用的bio小内存池。内核也为bio_vec结构分配内存池——毕竟，分配一个bio结构而不能分配其中的段描述符也是没有什么意义的。bio_alloc就通过bio_alloc_bioset函数在bs->bvec_pool中给他的bio_vec分配。相应地，bio_put()函数减少bio中引用计数器(bi_cnt)的值，如果该值等于0，则释放bio结构以及相关的bio_vec结构。

 

这个bio的bdev来自buffer_head的b_bdev字段；bi_destructor被设置为bio_fs_destructor函数，作为当bio上的I/O操作完成时所执行的完成程序的地址；bi_io_vec通过bvec_alloc_bs函数初始化成数组，表示若干个bio待传输的段；同时bi_flags和bi_max_vecs字段也被设置了；bi_sector是blocks[0]左移(blkbits - 9)位，得到该块对应磁盘扇区号，因为BIO更关心的是扇区号而不是块号，后面谈通用块处理的时候会重点讨论它。另外min_t(int, nr_pages, bio_get_nr_vecs(bdev))表示这个bio中的iovec个数，后面讲到通用块层的时候再来详细说这些东西，很重要的。

 

 

最后，bio初始化成功了，do_mpage_readpage成功返回这个bio，mpage_readpage就调用mpage_bio_submit(READ, bio)处理请求。

 

static struct bio *mpage_bio_submit(int rw, struct bio *bio) {        bio->bi_end_io = mpage_end_io_read;        if (rw == WRITE)               bio->bi_end_io = mpage_end_io_write;        submit_bio(rw, bio);        return NULL; }

 

我们看到mpage_bio_submit 函数将bio的bi_end_io字段赋值成 mpage_end_io_read函数，随后调用 submit_bio 函数处理该请求：

 

void submit_bio(int rw, struct bio *bio) {        int count = bio_sectors(bio);          BIO_BUG_ON(!bio->bi_size);        BIO_BUG_ON(!bio->bi_io_vec);        bio->bi_rw |= rw;        if (rw & WRITE)               count_vm_events(PGPGOUT, count);        else               count_vm_events(PGPGIN, count);          if (unlikely(block_dump)) {               char b[BDEVNAME_SIZE];               printk(KERN_DEBUG "%s(%d): %s block %Lu on %s/n",                      current->comm, current->pid,                      (rw & WRITE) ? "WRITE" : "READ",                      (unsigned long long)bio->bi_sector,                      bdevname(bio->bi_bdev,b));        }          generic_make_request(bio); }

 

函数最终将请求传递给函数 generic_make_request ，并由 generic_make_request 函数将请求

提交给通用块层处理，到此为止，页高速缓存层的处理结束。

 

1.3.4 块设备文件的readpage方法

看到do_mpage_readpage函数的confused标号处，如果页中含有的块在磁盘上不连续，则函数跳到这里。如果页是最新的，调用block_read_full_page函数，这里牵涉到块设备文件的readpage方法。

 

在前面ext2_read_inode函数中，我们看到init_special_inode函数用来建立设备的索引节点。该函数把索引节点对象的i_rdev字段初始化为设备文件的主设备号和次设备号，而把索引节点对象的i_fop字段设置为def_blk_fops或者def_chr_fops文件操作表的地址（根据设备文件的类型）；把索引节点的i_data对应的a_ops字段设置为def_blk_aops（字符驱动不需要页高速缓存）操作表地址。因此，open()系统调用的服务例程也调用dentry_open()函数，后者分配一个新的文件对象并把其f_op字段设置为i_fop中存放的地址，即再一次指向def_blk_fops或def_chr_fops的地址。正是这两个表的引入，才使得在设备文件上所发出的任何系统调用都将激活设备驱动程序的函数而不是基本文件系统的函数。

 

我们这里是块设备文件，所以关注的是def_blk_fops全局变量，来自fs/block_dev.c：

 

const struct file_operations def_blk_fops = {        .open             = blkdev_open,        .release    = blkdev_close,        .llseek            = block_llseek,        .read              = generic_file_read,        .write             = blkdev_file_write,       .aio_read = generic_file_aio_read,       .aio_write       = blkdev_file_aio_write,        .mmap           = generic_file_mmap,        .fsync             = block_fsync,        .unlocked_ioctl      = block_ioctl, #ifdef CONFIG_COMPAT        .compat_ioctl  = compat_blkdev_ioctl, #endif        .readv            = generic_file_readv,        .writev           = generic_file_write_nolock,        .sendfile  = generic_file_sendfile,        .splice_read    = generic_file_splice_read,        .splice_write   = generic_file_splice_write, };

 

块设备文件对应页高速缓存的函数来自def_blk_aops全局变量，也位于同一文件中：

 

const struct address_space_operations def_blk_aops = {        .readpage = blkdev_readpage,        .writepage      = blkdev_writepage,        .sync_page      = block_sync_page,        .prepare_write = blkdev_prepare_write,        .commit_write       = blkdev_commit_write,        .writepages     = generic_writepages,        .direct_IO       = blkdev_direct_IO, };

 

在bdev特殊文件系统中，块设备使用address_space对象，该对象存放在对应块设备索引节点的i_data字段。不像普通文件（在address_space对象中它的readpage方法依赖于文件所属的文件系统的类型），块设备文件的readpage方法总是相同的。它是由blkdev_readpage()函数实现的，该函数调用block_read_full_page()：

int blkdev_readpage(struct file * file, struct * page page)

{

    return block_read_full_page(page, blkdev_get_block);

}

 

正如你看到的，这个函数又是一个封装函数，这里是block_read_full_page()函数的封装函数。block_read_full_page函数，来自fs/buffer.c：

 

2063int block_read_full_page(struct page *page, get_block_t *get_block) 2064{ 2065        struct inode *inode = page->mapping->host; 2066        sector_t iblock, lblock; 2067        struct buffer_head *bh, *head, *arr[MAX_BUF_PER_PAGE]; 2068        unsigned int blocksize; 2069        int nr, i; 2070        int fully_mapped = 1; 2071 2072        BUG_ON(!PageLocked(page)); 2073        blocksize = 1 << inode->i_blkbits; 2074        if (!page_has_buffers(page)) 2075                create_empty_buffers(page, blocksize, 0); 2076        head = page_buffers(page); 2077 2078        iblock = (sector_t)page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits); 2079        lblock = (i_size_read(inode)+blocksize-1) >> inode->i_blkbits; 2080        bh = head; 2081        nr = 0; 2082        i = 0; 2083 2084        do { 2085                if (buffer_uptodate(bh)) 2086                        continue; 2087 2088                if (!buffer_mapped(bh)) { 2089                        int err = 0; 2090 2091                        fully_mapped = 0; 2092                        if (iblock < lblock) { 2093                                WARN_ON(bh->b_size != blocksize); 2094                                err = get_block(inode, iblock, bh, 0); 2095                                if (err) 2096                                        SetPageError(page); 2097                        } 2098                        if (!buffer_mapped(bh)) { 2099                                void *kaddr = kmap_atomic(page, KM_USER0); 2100                                memset(kaddr + i * blocksize, 0, blocksize); 2101                                flush_dcache_page(page); 2102                                kunmap_atomic(kaddr, KM_USER0); 2103                                if (!err) 2104                                        set_buffer_uptodate(bh); 2105                                continue; 2106                        } 2107                        /* 2108                         * get_block() might have updated the buffer 2109                         * synchronously 2110                         */ 2111                        if (buffer_uptodate(bh)) 2112                                continue; 2113                } 2114                arr[nr++] = bh; 2115        } while (i++, iblock++, (bh = bh->b_this_page) != head); 2116 2117        if (fully_mapped) 2118                SetPageMappedToDisk(page); 2119 2120        if (!nr) { 2121                /* 2122                 * All buffers are uptodate - we can set the page uptodate 2123                 * as well. But not if get_block() returned an error. 2124                 */ 2125                if (!PageError(page)) 2126                        SetPageUptodate(page); 2127                unlock_page(page); 2128                return 0; 2129        } 2130 2131        /* Stage two: lock the buffers */ 2132        for (i = 0; i < nr; i++) { 2133                bh = arr[i]; 2134                lock_buffer(bh); 2135                mark_buffer_async_read(bh); 2136        } 2137 2138        /* 2139         * Stage 3: start the IO.  Check for uptodateness 2140         * inside the buffer lock in case another process reading 2141         * the underlying blockdev brought it uptodate (the sct fix). 2142         */ 2143        for (i = 0; i < nr; i++) { 2144                bh = arr[i]; 2145                if (buffer_uptodate(bh)) 2146                        end_buffer_async_read(bh, 1); 2147                else 2148                        submit_bh(READ, bh); 2149        } 2150        return 0; 2151}

 

block_read_full_page函数的第二个参数也指向一个函数，该函数把相对于文件开始处的文件块号转换为相对于块设备开始处的逻辑块号。不过，对于块设备文件来说，这两个数是一致的；因此，blkdev_get_block()函数就比较简单了，来自：

 

109blkdev_get_block(struct inode *inode, sector_t iblock,  110                struct buffer_head *bh, int create)  111{  112        if (iblock >= max_block(I_BDEV(inode))) {  113                if (create)  114                        return -EIO;  115  116                /*  117                 * for reads, we're just trying to fill a partial page.  118                 * return a hole, they will have to call get_block again  119                 * before they can fill it, and they will get -EIO at that  120                 * time  121                 */  122                return 0;  123        }  124        bh->b_bdev = I_BDEV(inode);  125        bh->b_blocknr = iblock;  126        set_buffer_mapped(bh);  127        return 0;  128}

 

blkdev_get_block函数112行检查页中第一个块的块号是否超过块设备的最后一块的索引值（通过max_block函数将存放在bdev->bd_inode->i_size中的块设备大小除以存放在bdev->bd_block_size中的块大小得到该索引值；bdev指向块设备描述符）。如果超过，那么对于写操作它返-EIO，而对于读操作它返回0。（超出块设备读也是不允许的，但不返回错误代码，内核可以对块设备的最后数据试着发出读请求，而得到的缓冲区页只被部分映射）。

 

124行设置缓冲区首部的b_dev字段为b_dev。125行设置缓冲区首部的b_blocknr字段为文件块号，它将被作为参数传给本函数。最后126行把缓冲区首部的BH_Mapped标志置位，以表明缓冲区首部的b_dev和b_blocknr字段是有效的。

 

回到函数block_read_full_page()，这个函数以一次读一块的方式读一页数据。正如我们已看到的当读块设备文件或磁盘上块不相邻的普通文件时都使用该函数。它执行如下步骤：

 

首先2074行通过检查页描述符的标志PG_private，如果置位，则说明该页与描述组成该页的块的缓冲区首部链表相关；否则，调用create_empty_buffers()来为该页所含所有块缓冲区分配缓冲区首部。页中第一个缓冲区的缓冲区首部地址存放在page->private字段中。每个缓冲区首部的b_this_page字段指向该页中下一个缓冲区的缓冲区首部：

 

void create_empty_buffers(struct page *page,                      unsigned long blocksize, unsigned long b_state) {        struct buffer_head *bh, *head, *tail;          head = alloc_page_buffers(page, blocksize, 1);        bh = head;        do {               bh->b_state |= b_state;               tail = bh;               bh = bh->b_this_page;        } while (bh);        tail->b_this_page = head;          spin_lock(&page->mapping->private_lock);        if (PageUptodate(page) || PageDirty(page)) {               bh = head;               do {                      if (PageDirty(page))                             set_buffer_dirty(bh);                      if (PageUptodate(page))                             set_buffer_uptodate(bh);                      bh = bh->b_this_page;               } while (bh != head);        }        attach_page_buffers(page, head);        spin_unlock(&page->mapping->private_lock); }

 

2078行，从相对于页的文件偏移量（page->index字段）计算出页中第一块的文件块号。2084行进入一个循环，对该页中每个缓冲区的缓冲区首部，执行如下子步骤：

a) 2085行如果标志BH_Uptodate置位，则跳过该缓冲区继续处理该页的下一个缓冲区。

b) 2088行如果标志BH_Mapped未置位，并且该块未超出文件尾，则调用作为参数传递进来的blkdev_get_block函数。对于块设备文件，不同的是blkdev_get_block函数把文件块号当作逻辑块号。不管是普通文件还是块设备文件，函数都将逻辑块号存放在相应缓冲区首部的b_blocknr字段中，并将标志BH_Mapped置位（访问普通文件时，如果一个数据块处于“文件洞”中，get_block函数就可能找不到这个块。此时，函数用0填充这个块缓冲区并设置缓冲区首部的BH_Uptodate标志。）。

c) 2098行再检查标志BH_Uptodate，因为依赖于文件系统的get_block函数可能已触发块I/O操作而更新了缓冲区。如果BH_Uptodate置位，则继续处理该页的下一个缓冲区。

d) 2114行将缓冲区首部的地址存放在局部数组arr中，继续该页的下一个缓冲区。

 

2117行假如上一步中没遇到“文件洞”，则2118行将该页的标志PG_mappedtodisk置位。

 

现在局部变量arr中存放了一些缓冲区首部的地址，与其对应的缓冲区的内容不是最新的。如果数组，即2120行判断nr为0为空，那么页中的所有缓冲区都是有效的，因此，该函数设置页描述符的PG_uptodate标志，调用unlock_page()对该页解锁并返回。

 

局部数组arr非空。对数组中的每个缓冲区首部，block_read_full_page()再执行下列子步骤：

a) 2134行将BH_Lock标志置位。该标志一旦置位，函数将一直等到该缓冲区释放。

b) 2135行将缓冲区首部的b_end_io字段设为end_buffer_async_read()函数的地址（见下面），并将缓冲区首部的BH_Async_Read标志置位。

 

2143-2149行对局部数组arr中的每个缓冲区首部调用submit_bh()，将操作类型设为READ。就像我们在前面看到的那样，该函数触发了相应块的I/O数据传输。

 

函数end_buffer_async_read()是缓冲区首部的完成方法。对块缓冲区的I/O数据传输一结束，它就执行。假定没有I/O错误，函数将缓冲区首部的BH_Uptodate标志置位而将BH_Async_Read标志清0。那么，函数就得到包含块缓冲区的缓冲区页描述符（它的地址存放在缓冲区首部的b_page字段中），同时检查是否页中所有块是最新的；如果是，函数将该页的PG_uptodate标志置位并调用unlock_page()：

 

static void end_buffer_async_read(struct buffer_head *bh, int uptodate) {        unsigned long flags;        struct buffer_head *first;        struct buffer_head *tmp;        struct page *page;        int page_uptodate = 1;          BUG_ON(!buffer_async_read(bh));          page = bh->b_page;        if (uptodate) {               set_buffer_uptodate(bh);        } else {               clear_buffer_uptodate(bh);               if (printk_ratelimit())                      buffer_io_error(bh);               SetPageError(page);        }          /*         * Be _very_ careful from here on. Bad things can happen if         * two buffer heads end IO at almost the same time and both         * decide that the page is now completely done.         */        first = page_buffers(page);        local_irq_save(flags);        bit_spin_lock(BH_Uptodate_Lock, &first->b_state);        clear_buffer_async_read(bh);        unlock_buffer(bh);        tmp = bh;        do {               if (!buffer_uptodate(tmp))                      page_uptodate = 0;               if (buffer_async_read(tmp)) {                      BUG_ON(!buffer_locked(tmp));                      goto still_busy;               }               tmp = tmp->b_this_page;        } while (tmp != bh);        bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);        local_irq_restore(flags);          /*         * If none of the buffers had errors and they are all         * uptodate then we can set the page uptodate.         */        if (page_uptodate && !PageError(page))               SetPageUptodate(page);        unlock_page(page);        return;   still_busy:        bit_spin_unlock(BH_Uptodate_Lock, &first->b_state);        local_irq_restore(flags);        return; }