页高速缓存和页回写［1］

   有种欲哭无泪的感觉。又是一时失手，把原本写的内容刷掉了。呜呜～～
  重新开始！！
  页高速缓存(cache)是Linux内核实现的一种主要磁盘缓存。它主要用来减少对磁盘的IO操作。具体地讲，就是通过把磁盘中的数据缓存到物理内存中，把对磁盘的访问变为对物理内存的访问。
  磁盘缓存的优点在于：1，访问磁盘的速度远远低于访问内存的速度，因此从内存访问数据要比从磁盘访问速度快。2，数据一旦被访问，就很有可能在短期内被再 次访问到。这种在短期内集中访问同一片数据的原理被称作临时局部原理temporal locality。临时局部原理保证：如果在第一次访问数据时缓存它，那就极有可能在短期内再次被高速缓存命中。
   页高速缓存是由RAM中的物理页组成，缓存中每一页都对应着磁盘中的多个块。每当内核开始执行一个页IO操作时（通常对普通文件中页大小的块进行磁盘操作），首先会检查需要的数据是否在高速缓存中，如果在，那么内核就直接使用高速缓存中的数据，从而避免访问磁盘。
   通过块IO缓冲区把独立的磁盘块与页高速缓存联系在一起。在块IO层中，一个缓冲(buffer)就是一个单独物理磁盘块在内存中的表示，缓冲就是内存到 磁盘块的映射描述符。因此通过磁盘块以及缓冲块IO操作，页高速缓存同一可以减少块IO操作期间的磁盘访问量。这种缓存经常被称为“缓冲区高速缓存”，它 实际上并不是一个独立的缓存，而是页高速缓存的一部分。
  每次页IO操作都要处理数据的全部页面，就需要对一个以上的磁盘块进行操作，所以页高速缓存实际缓存的是页面大小的文件块。
  块IO操作每次操作一个单独的磁盘块，比如读写索引节点就是一个典型的IO操作。内核提供bread()底层函数从磁盘读单个块，通过缓冲，这些磁盘块被映射到内存中相应的页面上，这样就被缓存到页高速缓存里了。

• 页高速缓存

  页高速缓存缓存的是页面。缓存中的页来自对正规文件、块设备文件和内存映射文件的读写。这样，页高速缓存内就包含了最近被访问的文件的全部页面。
  一个物理页可能由多个不连续的物理磁盘块组成。因为文件本身可能分布在磁盘各个位置，所以页面中映射的块也不需要连续。这样的话，在页高速缓存中检测特定数据是否已被缓存是件非常困难的事。因此不能用设备名称和块号来作页高速缓存中数据的索引。
  Linux页高速缓存的目标是缓存任何基于页的对象，这包含各种类型的文件和各种类型的内存映射。Linux页高速缓存使用address_space结构体描述页高速缓存中的页面。

1. 在include/fs.h中：
2. struct backing_dev_info;
3. struct address_space {
4.     struct inode        *host;      /* owner: inode, block_device */
5.     struct radix_tree_root  page_tree;  /* radix tree of all pages */
6.     rwlock_t        tree_lock;  /* and rwlock protecting it */
7.     unsigned int        i_mmap_writable;/* count VM_SHARED mappings */
8.     struct prio_tree_root   i_mmap;     /* tree of private and shared mappings */
9.     struct list_head    i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
10.     spinlock_t      i_mmap_lock;    /* protect tree, count, list */
11.     unsigned int        truncate_count; /* Cover race condition with truncate */
12.     unsigned long       nrpages;    /* number of total pages */
13.     pgoff_t         writeback_index;/* writeback starts here */
14.     const struct address_space_operations *a_ops;   /* methods */
15.     unsigned long       flags;      /* error bits/gfp mask */
16.     struct backing_dev_info *backing_dev_info; /* device readahead, etc */
17.     spinlock_t      private_lock;   /* for use by the address_space */
18.     struct list_head    private_list;   /* ditto */
19.     struct address_space    *assoc_mapping; /* ditto */
20. } __attribute__((aligned(sizeof(long))));
21. 
    

  其中i_mmap字段是一个优先搜索树，它的搜索范围包含了在address_space中所有共享的与私有的映射页面。优先搜索树是一种巧妙的将堆和radix树结合的快速检索树。

1. 在linux/prio_tree.h中
2. struct prio_tree_node {
3.     struct prio_tree_node   *left;
4.     struct prio_tree_node   *right;
5.     struct prio_tree_node   *parent;
6.     unsigned long       start;
7.     unsigned long       last;   /* last location _in_ interval */
8. };
10. struct prio_tree_root {
11.     struct prio_tree_node   *prio_tree_node;
12.     unsigned short      index_bits;
13.     unsigned short      raw;
14.         /*
15.          * 0: nodes are of type struct prio_tree_node
16.          * 1: nodes are of type raw_prio_tree_node
17.          */
18. };

  优先搜索树的具体实现在lib/prio.c中：

2. static unsigned long index_bits_to_maxindex[BITS_PER_LONG];
4. void __init prio_tree_init(void)
5. {
6.     unsigned int i;
8.     for (i = 0; i < ARRAY_SIZE(index_bits_to_maxindex) - 1; i++)
9.         index_bits_to_maxindex[i] = (1UL << (i + 1)) - 1;
10.     index_bits_to_maxindex[ARRAY_SIZE(index_bits_to_maxindex) - 1] = ~0UL;
11. }
13. /*
14.  * Insert a prio_tree_node @node into a radix priority search tree @root. The
15.  * algorithm typically takes O(log n) time where 'log n' is the number of bits
16.  * required to represent the maximum heap_index. In the worst case, the algo
17.  * can take O((log n)^2) - check prio_tree_expand.
18.  *
19.  * If a prior node with same radix_index and heap_index is already found in
20.  * the tree, then returns the address of the prior node. Otherwise, inserts
21.  * @node into the tree and returns @node.
22.  */
23. struct prio_tree_node *prio_tree_insert(struct prio_tree_root *root,
24.         struct prio_tree_node *node)
25. {
26.     struct prio_tree_node *cur, *res = node;
27.     unsigned long radix_index, heap_index;
28.     unsigned long r_index, h_index, index, mask;
29.     int size_flag = 0;
31.     get_index(root, node, &radix_index, &heap_index);
33.     if (prio_tree_empty(root) ||
34.             heap_index > prio_tree_maxindex(root->index_bits))
35.         return prio_tree_expand(root, node, heap_index);
37.     cur = root->prio_tree_node;
38.     mask = 1UL << (root->index_bits - 1);
40.     while (mask) {
41.         get_index(root, cur, &r_index, &h_index);
43.         if (r_index == radix_index && h_index == heap_index)
44.             return cur;
46.                 if (h_index < heap_index ||
47.             (h_index == heap_index && r_index > radix_index)) {
48.             struct prio_tree_node *tmp = node;
49.             node = prio_tree_replace(root, cur, node);
50.             cur = tmp;
51.             /* swap indices */
52.             index = r_index;
53.             r_index = radix_index;
54.             radix_index = index;
55.             index = h_index;
56.             h_index = heap_index;
57.             heap_index = index;
58.         }
60.         if (size_flag)
61.             index = heap_index - radix_index;
62.         else
63.             index = radix_index;
65.         if (index & mask) {
66.             if (prio_tree_right_empty(cur)) {
67.                 INIT_PRIO_TREE_NODE(node);
68.                 cur->right = node;
69.                 node->parent = cur;
70.                 return res;
71.             } else
72.                 cur = cur->right;
73.         } else {
74.             if (prio_tree_left_empty(cur)) {
75.                 INIT_PRIO_TREE_NODE(node);
76.                 cur->left = node;
77.                 node->parent = cur;
78.                 return res;
79.             } else
80.                 cur = cur->left;
81.         }
83.         mask >>= 1;
85.         if (!mask) {
86.             mask = 1UL << (BITS_PER_LONG - 1);
87.             size_flag = 1;
88.         }
89.     }
90.     /* Should not reach here */
91.     BUG();
92.     return NULL;
93. }

  address_space结构体往往会和某些内核对象关联。通常会与一个索引节点inode关联，这时host字段就会指向该索引节点，如果关联对象不是索引节点，host就会被设置为NULL。
   a_ops字段指向地址空间对象中的操作函数表，这与VFS对象及其操作表关系类似：

1. 在include/fs.h中
2. 
   
3. /*
4.  * oh the beauties of C type declarations.
5.  */
6. struct page;
7. struct address_space;
8. struct writeback_control;
9. 
   
10. struct address_space_operations {
11.     int (*writepage)(struct page *page, struct writeback_control *wbc);
12.     int (*readpage)(struct file *, struct page *);
13.     void (*sync_page)(struct page *);
14. 
    
15.     /* Write back some dirty pages from this mapping. */
16.     int (*writepages)(struct address_space *, struct writeback_control *);
17. 
    
18.     /* Set a page dirty.  Return true if this dirtied it */
19.     int (*set_page_dirty)(struct page *page);
20. 
    
21.     int (*readpages)(struct file *filp, struct address_space *mapping,
22.             struct list_head *pages, unsigned nr_pages);
23. 
    
24.     /*
25.      * ext3 requires that a successful prepare_write() call be followed
26.      * by a commit_write() call - they must be balanced
27.      */
28.     int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
29.     int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
30.     /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
31.     sector_t (*bmap)(struct address_space *, sector_t);
32.     void (*invalidatepage) (struct page *, unsigned long);
33.     int (*releasepage) (struct page *, gfp_t);
34.     ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
35.             loff_t offset, unsigned long nr_segs);
36.     struct page* (*get_xip_page)(struct address_space *, sector_t,
37.             int);
38.     /* migrate the contents of a page to the specified target */
39.     int (*migratepage) (struct address_space *,
40.             struct page *, struct page *);
41.     int (*launder_page) (struct page *);
42. };
43. 
    

  readpage()和writerpage()两个方法最主要。
  先看读操作中包含的步骤：
1. 一个address_space对象和一个偏移量会被传给readpage()方法，这两个参数用来在页高速缓存中搜索需要的数据，调用find_get_page()方法，
2. 如果搜索的页面并没有在高速缓存中，那么内核将分配一个新的页面，调用page_cache_alloc_cold()方法；然后将其加入到页高速缓存中，调用add_to_page_lru()方法
3. 需要的数据从磁盘被读入，在被加入到页高速缓存中，然后返回给用户：调用a_ops->readpage()方法
  写操作和读操作有少许不同。对于文件映射来说，当页被修改了，VM仅仅需要调用

SetPageDirty(page);

  内核会在晚些时候通过writepage()方法把页写出。
  对特定文件的写操作比较复杂，实现在mm/filemap.c中，包含以下步骤：
1. 调用__grab_cache_page()方法，在页高速缓存中搜索需要的页，如果需要的页不在告诉缓存中，那么内核在高速缓存分配一个空闲项
2. 调用a_ops->prepare_write()方法创建一个写请求。
3. 调用filemap_copy_from_user()方法将数据从用户空间拷贝到内核缓冲
4. 通过a_ops->commit_write()函数将数据写入磁盘

• 基树

  在任何页IO操作之前内核都要检查页是否已经在页高速缓存中了，主要通过两个参数（address_space对象和一个偏移量）进行查找。每个address_space对象都有惟一的基树(radix tree)，它保存在page_tree结构体中。
  基树是一个二叉树，只要指定了文件偏移量，就可以在基树中迅速检索到希望的数据。页高速缓存的搜索函数find_get_page()要调用radix_tree_lookup()函数，该函数会在指定基树中搜索到指定的页面。
  基树核心代码的通用形式可在文件lib/radix-tree.c中找到。

1. struct radix_tree_node {
2.     unsigned int    height;     /* Height from the bottom */
3.     unsigned int    count;
4.     struct rcu_head rcu_head;
5.     void        *slots[RADIX_TREE_MAP_SIZE];
6.     unsigned long   tags[RADIX_TREE_MAX_TAGS][RADIX_TREE_TAG_LONGS];
7. };
8. 
   
9. struct radix_tree_path {
10.     struct radix_tree_node *node;
11.     int offset;
12. };
13. 
    
14. 
    
15. /*
16.  * Radix tree node cache.
17.  */
18. static struct kmem_cache *radix_tree_node_cachep;
19. 
    
20. 
    
21. void __init radix_tree_init(void)
22. {
23.     radix_tree_node_cachep = kmem_cache_create("radix_tree_node",
24.             sizeof(struct radix_tree_node), 0,
25.             SLAB_PANIC, radix_tree_node_ctor, NULL);
26.     radix_tree_init_maxindex();
27.     hotcpu_notifier(radix_tree_callback, 0);
28. }
29. 
    
30. 
    
31. /**
32.  *  radix_tree_lookup    -    perform lookup operation on a radix tree
33.  *  @root:      radix tree root
34.  *  @index:     index key
35.  *
36.  *  Lookup the item at the position @index in the radix tree @root.
37.  *
38.  *  This function can be called under rcu_read_lock, however the caller
39.  *  must manage lifetimes of leaf nodes (eg. RCU may also be used to free
40.  *  them safely). No RCU barriers are required to access or modify the
41.  *  returned item, however.
42.  */
43. void *radix_tree_lookup(struct radix_tree_root *root, unsigned long index)
44. {
45.     unsigned int height, shift;
46.     struct radix_tree_node *node, **slot;
47. 
    
48.     node = rcu_dereference(root->rnode);
49.     if (node == NULL)
50.         return NULL;
51. 
    
52.     if (radix_tree_is_direct_ptr(node)) {
53.         if (index > 0)
54.             return NULL;
55.         return radix_tree_direct_to_ptr(node);
56.     }
57. 
    
58.     height = node->height;
59.     if (index > radix_tree_maxindex(height))
60.         return NULL;
61. 
    
62.     shift = (height-1) * RADIX_TREE_MAP_SHIFT;
63. 
    
64.     do {
65.         slot = (struct radix_tree_node **)
66.             (node->slots + ((index>>shift) & RADIX_TREE_MAP_MASK));
67.         node = rcu_dereference(*slot);
68.         if (node == NULL)
69.             return NULL;
70. 
    
71.         shift -= RADIX_TREE_MAP_SHIFT;
72.         height--;
73.     } while (height > 0);
74. 
    
75.     return node;
76. }
77. 
    

  要想使用基树，需要包含头文件linux/radix_tree.h。

1. /*** radix-tree API starts here ***/
2. 
   
3. #define RADIX_TREE_MAX_TAGS 2
4. 
   
5. /* root tags are stored in gfp_mask, shifted by __GFP_BITS_SHIFT */
6. struct radix_tree_root {
7.     unsigned int        height;
8.     gfp_t           gfp_mask;
9.     struct radix_tree_node  *rnode;
10. };
11. 
    
12. #define RADIX_TREE_INIT(mask)   {                   /
13.     .height = 0,                            /
14.     .gfp_mask = (mask),                     /
15.     .rnode = NULL,                          /
16. }
17. 
    
18. #define RADIX_TREE(name, mask) /
19.     struct radix_tree_root name = RADIX_TREE_INIT(mask)
20. 
    
21. #define INIT_RADIX_TREE(root, mask)                 /
22. do {                                    /
23.     (root)->height = 0;                     /
24.     (root)->gfp_mask = (mask);                  /
25.     (root)->rnode = NULL;                       /
26. } while (0)

  在2.6版本之前，内核页高速缓存不是通过基树检索，而是通过一个维护了系统中所有页的全局散列表进行检索。对于给定的同一个键值，该散列表会返回一个双 向链表。如果需要的页驻留在缓存中，那么链表中的一项会与其对于。否则，页就不在页高速缓存中，散链函数返回NULL。

• 缓冲区高速缓存

  在2.2版本的内核中，存在两个独立的磁盘缓存：页高速缓存和缓冲区高速缓存。前者缓存页，后者缓冲缓冲。一个磁盘块可以在两种缓存中同时存在，因此需要对两个缓存中的同一拷贝进行很麻烦的同步操作。
  现在Linux中已经不再有独立的缓冲区高速缓存了，只有唯一的磁盘缓存－－－页高速缓存。内核仍然需要在内存中使用缓冲区来表示磁盘块，缓冲是用页映射块的，它正好在页高速缓存中。