Linux块设备IO子系统(二) _页高速缓存

磁盘驱动就是实现磁盘空间和内存空间数据上的交互，在上一篇中我们讨论了内存端的Page Segment Block Sector相关的概念，本文以3.14内核为例，讨论这部分内存是如何被组织管理的。我们知道，为了解决CPU和内存的速度不匹配，计算机系统引入了Cache缓存机制，这种硬件Cache的速度接近CPU内部寄存器的速度，可以提高系统效率，同样的思路也适用于解决内存和磁盘的速度不匹配问题，此外，磁盘多是机械式的，从寿命的角度考虑也不适合频繁读写，所以内核就将一部分内存作为缓存，提高磁盘访问速度的同时延长磁盘寿命，这种缓存就是磁盘高速缓存。包括页高速缓存(Page Cache，对完整数据页进行操作的磁盘高速缓存) + 目录项高速缓存(Dentry Cache，描述文件系统路径名的目录项对象) + 索引节点高速缓存(Buffer Cache，存放的是描述磁盘索引节点的索引节点对象)，本文主要讨论页高速缓存，有了页高速缓存，内核的代码和数据结构不必从磁盘读，也不必写入磁盘。页高速缓存可以看作特定文件系统层的一部分。

SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)

   └── vfs_read(f.file, buf, count, &pos);

            └──file->f_op->read(file, buf, count, pos);

            └──do_sync_read(file, buf, count, pos);

                      └──filp->f_op->aio_read(&kiocb, &iov, 1, kiocb.ki_pos);

                                 ├──generic_file_aio_read(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos)

                                 └──filemap_write_and_wait_range(mapping, pos, pos + iov_length(iov, nr_segs) - 1);

-----------------------------------Page Cache----------------------------------------------------

int mpage_readpage(struct page *page, get_block_t get_block)

           └──wait_on_sync_kiocb(&kiocb);

                      ├──do_mpage_readpage(bio, page, 1, &last_block_in_bio, &map_bh, &first_logical_block, get_block);

                       └──mpage_bio_submit(READ, bio);

                                 └──submit_bio(rw, bio);

绝大多数情况下，内核在读写磁盘时都引用页高速缓存。新页被追加到页高速缓存以满足用户态进程的读请求。如果页不再高速缓存中，新页就被加到高速缓存中，然后用从磁盘读出的数据填充它，如果内存有足够的空闲空间，就让该页在高速缓存中长期保留，使其他进程再使用该页时不再访问磁盘。

同样，在把一页数据写到块设备之前，内核首先检查对应的页是否已经在高速缓存中，如果不在，就要先在其中增加一个新项，并用要写到磁盘中的数据填充该项。IO数据的传送不是马上开始，而是延迟几秒才对磁盘进行更新，从而使进程有机会队要写入磁盘的数据做进一步的修改。

页高速缓存肯可能是下面几种之一：

1. 含有普通文件数据的页(上篇中的一个Page)
2. 含有目录的页
3. 含有直接从块设备文件(跳过文件系统)读出的数据的页。
4. 含有用户态进程数据的页
5. 属于特殊文件系统文件的页，如shm

从inode到page

既然是建立一块磁盘空间和一块内存空间之间的关系，那么就要通过相关的结构表示这种关系，在磁盘端，存储空间本质上都是属于一个文件，Linux中用inode结构表示一个文件，内存端，Linux内核用address_space来组织一组内存页，所以，我们可以在inode结构中找到相应的address_space对象域，而这个文件就成为该页的所有者(owner)。简单的追一下代码，我们可以画出下面这张关系图，本节主要围绕这张图讨论

inode

inode是内核中描述一个文件的结构，更多关于inode的讨论，可以参考Linux设备文件三大结构：inode,file,file_operations，本文中我们主要关心i_mapping和i_data两个成员。

//3.14/include/linux/fs.h
 527 struct inode {
 541         struct address_space    *i_mapping;
 594         struct address_space    i_data;
 616 };

struct inode

--541-->指向这个inode拥有的address_space对象

--594-->这个inode拥有的address_space对象

address_space

页高速缓存的核心结构就address_space对象，他是一个嵌入在页所有者的索引节点对象中的数据结构。高速缓存中的许多页都可能属于一个所有者，从而可能被链接到同一个address_space对象。该对象还在所有者的页和对这些页的操作之间建立起链接关系。

 412 struct address_space {
 413         struct inode            *host;          /* owner: inode, block_device */
 414         struct radix_tree_root  page_tree;      /* radix tree of all pages */
 415         spinlock_t              tree_lock;      /* and lock protecting it */
 416         unsigned int            i_mmap_writable;/* count VM_SHARED mappings */
 417         struct rb_root          i_mmap;         /* tree of private and shared mappings */
 418         struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
 419         struct mutex            i_mmap_mutex;   /* protect tree, count, list */
 420         /* Protected by tree_lock together with the radix tree */
 421         unsigned long           nrpages;        /* number of total pages */
 422         pgoff_t                 writeback_index;/* writeback starts here */
 423         const struct address_space_operations *a_ops;   /* methods */
 424         unsigned long           flags;          /* error bits/gfp mask */
 425         struct backing_dev_info *backing_dev_info; /* device readahead, etc */
 426         spinlock_t              private_lock;   /* for use by the address_space */
 427         struct list_head        private_list;   /* ditto */
 428         void                    *private_data;  /* ditto */
 429 } __attribute__((aligned(sizeof(long))));

struct address_space

--413-->这个address_space对象所属的inode对象

--414-->这个address_space对象拥有的radix_tree_root对象

--425-->指向backing_dev_info对象，这个对象描述了所有者的数据所在的块设备，通常嵌入在块设备的请求队列描述符中。

radix_tree_root

描述一个radix树的根，内核使用这个数据结构快速的查找增删一个inode拥有的页高速缓存页

 64 struct radix_tree_root {
 65         unsigned int            height;
 66         gfp_t                   gfp_mask;
 67         struct radix_tree_node  __rcu *rnode;
 68 };

  50 struct radix_tree_node {
  51         unsigned int    height;         /* Height from the bottom */
  52         unsigned int    count;
  53         union {
  54                 struct radix_tree_node *parent; /* Used when ascending tree */
  55                 struct rcu_head rcu_head;       /* Used when freeing node */
  56         };
  57         void __rcu      *slots[RADIX_TREE_MAP_SIZE];
  58         unsigned long   tags[RADIX_TREE_MAX_TAGS][RADIX_TREE_TAG_LONGS];
  59 };

struct radix_tree_node

--51-->当前树的深度，不包括叶子节点的层数

--52-->记录节点中非空指针数量的计数器

--57-->slot是包含64个指针的数组，每个元素可以指向其他节点（struct radix_tree_node）或者页描述符（struct page），上层节点指向其他节点，底层节点指向页描述符(叶子节点)

--58-->tag二维数组用于对radix_tree_node基树进行标记，下面就是一个页可能的标志

 74 enum pageflags {
 75         PG_locked,              /* Page is locked. Don't touch. */
 76         PG_error,
 77         PG_referenced,
 78         PG_uptodate,
 79         PG_dirty,
 80         PG_lru,
 81         PG_active,
 82         PG_slab,
 83         PG_owner_priv_1,        /* Owner use. If pagecache, fs may use*/
 84         PG_arch_1,
 85         PG_reserved,
 86         PG_private,             /* If pagecache, has fs-private data */
 87         PG_private_2,           /* If pagecache, has fs aux data */
 88         PG_writeback,           /* Page is under writeback */
 93         PG_compound,            /* A compound page */
 95         PG_swapcache,           /* Swap page: swp_entry_t in private */
 96         PG_mappedtodisk,        /* Has blocks allocated on-disk */
 97         PG_reclaim,             /* To be reclaimed asap */
 98         PG_swapbacked,          /* Page is backed by RAM/swap */
 99         PG_unevictable,         /* Page is "unevictable"  */
112         __NR_PAGEFLAGS,
113
114         /* Filesystems */
115         PG_checked = PG_owner_priv_1,
116
117         /* Two page bits are conscripted by FS-Cache to maintain local caching
118          * state.  These bits are set on pages belonging to the netfs's inodes
119          * when those inodes are being locally cached.
120          */
121         PG_fscache = PG_private_2,      /* page backed by cache */
122
123         /* XEN */
124         PG_pinned = PG_owner_priv_1,
125         PG_savepinned = PG_dirty,
126
127         /* SLOB */
128         PG_slob_free = PG_private,
129 };

page

page就是内核中页描述符，通过radix树的操作，我们最终可以找到一组page，这组page归属于一个inode。我们可以看到其中的pgoff_t index成员，用来表示当前页在整组高速缓存页中的索引。至此，我们就通过一个文件的inode找到了它拥有的页高速缓存，接接下来就是使用块设备驱动实现相应的页缓存和磁盘的数据交互。

 44 struct page {
 48         union {
 49                 struct address_space *mapping;  /* If low bit clear, points to
 57         };
 59         /* Second double word */
 60         struct {
 61                 union {
 62                         pgoff_t index;          /* Our offset within mapping. */
 73                 };
 121         };
 198 }

页高速缓存的基本操作是增删查更，在此基础上可以封装更高级的API

增加page

static inline int add_to_page_cache(struct page *page, struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask)

删除page

void delete_from_page_cache(struct page *page)

查找page

struct page *find_get_page(struct address_space *mapping, pgoff_t offset)
unsigned find_get_pages(struct address_space *mapping, pgoff_t start,unsigned int nr_pages, struct page **pages)

//抢不到锁会阻塞
struct page *find_lock_page(struct address_space *mapping, pgoff_t offset)
//抢不到锁立即返回try???

//抢不到锁会阻塞，但是如果页不存在就创建新的
struct page *find_or_create_page(struct address_space *mapping,pgoff_t index, gfp_t gfp_mask)

更新page

truct page *read_cache_page(struct address_space *mapping,pgoff_t index,int (*filler)(void *, struct page *),void *data)

从page 到 block

block即是那个VFS或文件系统中的最小逻辑操作单位，一个页高速缓存可以由几个block构成，他们之间的关系如下：

buffer_head

每个块缓冲区都有相应的buffer_head对象描述，该描述符包含内核必须了解的，有关如何处理块的所有信息，

 62 struct buffer_head {
 63         unsigned long b_state;          /* buffer state bitmap (see above) */
 64         struct buffer_head *b_this_page;/* circular list of page's buffers */
 65         struct page *b_page;            /* the page this bh is mapped to */
 66
 67         sector_t b_blocknr;             /* start block number */
 68         size_t b_size;                  /* size of mapping */
 69         char *b_data;                   /* pointer to data within the page */
 70
 71         struct block_device *b_bdev;
 72         bh_end_io_t *b_end_io;          /* I/O completion */
 73         void *b_private;                /* reserved for b_end_io */
 74         struct list_head b_assoc_buffers; /* associated with another mapping */
 75         struct address_space *b_assoc_map;      /* mapping this buffer is
 76                                                    associated with */
 77         atomic_t b_count;               /* users using this buffer_head */
 78 };

struct buffer_head

--63-->缓冲区状态标志

--64-->指向缓冲区的链表中的下一个元素的指针

--65-->指向拥有该块的缓冲区页的描述符的指针

--67-->块引用计数

--68-->块大小

--69-->表示块缓冲区在缓冲区页中的位置，实际上，这个位置的编号依赖于页是否在高端内存，如果在高端内存，则b_data字段存放的是块缓冲区相对于页的起始位置的偏移量，否则，b_data存放的是块缓冲区的线性地址

--71-->指向IO完成方法数据的指针

--72-->IO完成方法

--73-->指向IO完成方法数据的指针

--74-->为与某个索引节点相关的间接块的链表提供的指针

下面是b_state可能的取值

//include/linux/buffer_head.h
 19 enum bh_state_bits {
 20         BH_Uptodate,    /* Contains valid data */
 21         BH_Dirty,       /* Is dirty */
 22         BH_Lock,        /* Is locked */
 23         BH_Req,         /* Has been submitted for I/O */
 24         BH_Uptodate_Lock,/* Used by the first bh in a page, to serialise
 25                           * IO completion of other buffers in the page
 26                           */
 27
 28         BH_Mapped,      /* Has a disk mapping */
 29         BH_New,         /* Disk mapping was newly created by get_block */
 30         BH_Async_Read,  /* Is under end_buffer_async_read I/O */
 31         BH_Async_Write, /* Is under end_buffer_async_write I/O */
 32         BH_Delay,       /* Buffer is not yet allocated on disk */
 33         BH_Boundary,    /* Block is followed by a discontiguity */
 34         BH_Write_EIO,   /* I/O error on write */
 35         BH_Unwritten,   /* Buffer is allocated on disk but not written */
 36         BH_Quiet,       /* Buffer Error Prinks to be quiet */
 37         BH_Meta,        /* Buffer contains metadata */
 38         BH_Prio,        /* Buffer should be submitted with REQ_PRIO */
 39         BH_Defer_Completion, /* Defer AIO completion to workqueue */
 40
 41         BH_PrivateStart,/* not a state bit, but the first bit available
 42                          * for private allocation by other entities
 43                          */
 44 };

增

将块设备缓冲区所在的页添加到页高速缓存中

static int grow_buffers(struct block_device *bdev, sector_t block, int size)

删

将块设备缓冲区所在的页从页高速缓存中剔除

int try_to_free_buffers(struct page *page)
int try_to_release_page(struct page *page, gfp_t gfp_mask)

查

在页高速缓存中搜索块

当内核需要读写一个单独的物理设备块时(例如一个超级块)，必须检查所有请求的块，缓冲区是否已经在页高速缓存中。在页高速缓存中搜索执行的块缓冲区(由块设备描述符的地址bdev和逻辑块号nr表示)的过程可以分成3个步骤

1. 获取一个指针，让它指向包含指定的块设备的address_space对象(bdev->bd_inode->imapping)
2. 获取块设备的大小(bdev->bd_block_size)，并计算包含指定块的页索引。这需要在逻辑块号上进行移位操作，eg，如果块的大小是1024字节，每个缓冲区页包含4个块缓冲区，那么页的索引是nr/4
3. 在块设备的基树中搜索缓冲区页，获得页描述符后，内核访问缓冲区首部，它描述了页中块缓冲区的状态

__find_get_block(struct block_device *bdev, sector_t block, unsigned size)
__getblk(struct block_device *bdev, sector_t block, unsigned size)
__bread(struct block_device *bdev, sector_t block, unsigned size)

交

块缓冲区最终要提交到通用块层进行IO操作，相关的API如下

int submit_bh(int rw, struct buffer_head *bh)
void ll_rw_block(int rw, int nr, struct buffer_head *bhs[])

脏页回写

在脏页回写机制中，首先，内核使用一个backing_dev_info对象来描述一个bdi设备，即backing device info——非易失存储设备，这些backing_dev_info都会挂接到bdi_list链表中，我们可以从其注册函数bdi_register()中看出。由于bdi的低速，所以也就有了本文讨论的页缓冲机制以及脏页回写问题，当一个高速缓存页被修改时，内核就会将相应的page对象中的相应的tag置为PG_dirty，即"脏页"，脏页需要在合适的时候回写到磁盘对于脏页回写，2.6.2x/3x以前的内核通过动态的创建/删除pdflush线程来实现脏页回写，但是2.6.2x/3x之后的内核对这个方面进行的改进，采用writeback机制进行回写，writeback机制需要的核心结构和方法的关系如下。

可以看出，一个逻辑磁盘--一个gendisk对象--一个request_queue对象--一个backing_dev_info对象，这个backing_dev_info对象就是脏页回写的核心结构

 64 struct backing_dev_info {
 65         struct list_head bdi_list;
 97         struct bdi_writeback wb;  /* default writeback info for this bdi */
100         struct list_head work_list;
102         struct device *dev;
110 };

struct backing_dev_info

--65-->将所有的backing_dev_info链接起来的链表节点

--97-->bdi_writeback对象，使用延迟工作进行脏页回写

--100-->这个bdi设备中等待被处理的页的描述

--102-->表示这是一个device

  37 /*
  38  * Passed into wb_writeback(), essentially a subset of writeback_control
  39  */
  40 struct wb_writeback_work {
  41         long nr_pages;
  42         struct super_block *sb;
  43         unsigned long *older_than_this;
  44         enum writeback_sync_modes sync_mode;
  45         unsigned int tagged_writepages:1;
  46         unsigned int for_kupdate:1;
  47         unsigned int range_cyclic:1;
  48         unsigned int for_background:1;
  49         unsigned int for_sync:1;        /* sync(2) WB_SYNC_ALL writeback */
  50         enum wb_reason reason;          /* why was writeback initiated? */
  51
  52         struct list_head list;          /* pending work list */
  53         struct completion *done;        /* set if the caller waits */
  54 };

 51 struct bdi_writeback {
 52         struct backing_dev_info *bdi;   /* our parent bdi */
 53         unsigned int nr;
 54
 55         unsigned long last_old_flush;   /* last old data flush */
 56
 57         struct delayed_work dwork;      /* work item used for writeback */
 58         struct list_head b_dirty;       /* dirty inodes */
 59         struct list_head b_io;          /* parked for writeback */
 60         struct list_head b_more_io;     /* parked for more writeback */
 61         spinlock_t list_lock;           /* protects the b_* lists */
 62 };

struct bdi_writeback

--57-->延迟工作对象，最终会调用下面的函数处理脏页

 778 /*
 779  * Explicit flushing or periodic writeback of "old" data.
 780  *
 781  * Define "old": the first time one of an inode's pages is dirtied, we mark the
 782  * dirtying-time in the inode's address_space.  So this periodic writeback code
 783  * just walks the superblock inode list, writing back any inodes which are
 784  * older than a specific point in time.
 785  *
 786  * Try to run once per dirty_writeback_interval.  But if a writeback event
 787  * takes longer than a dirty_writeback_interval interval, then leave a
 788  * one-second gap.
 789  *
 790  * older_than_this takes precedence over nr_to_write.  So we'll only write back
 791  * all dirty pages if they are all attached to "old" mappings.
 792  */
 793 static long wb_writeback(struct bdi_writeback *wb,
 794                          struct wb_writeback_work *work)