感谢支持
我们一直在努力

Linux缓存机制之页缓存

Linux运用一个功能广泛的缓冲和缓存框架来提高系统的速度。缓冲和缓存利用一部分系统物理内存,确保最重要、最常使用的块设备数据在操作时可直接从主内存获取,而无需从低速设备读取。物理内存还用于存储从快设备读取的数据,使得随后对该数据的访问可直接在物理内存进行,而无需从外部设备再次取用。考虑系统中多种因素然后延迟写回在总体上改进了系统的性能。前面分析的部分,例如内存管理的slab缓存是一个内存到内存的缓存,其目地不是加速对低速设备的操作,而是对现有资源进行更简单、更高效的使用。文件系统的Dentry缓存也用于减少对低速块设备的访问,但他无法推广到通用场合,因为他是专门用于处理单一数据类型的。


内核为块设备提供了两种通用的缓存方案:


1) 页缓存,针对以页为单位的所有操作,并考虑了特定体系结构上的页长度。一个主要的例子是内存映射技术。因为其他类型的文件访问也是基于内核中的这一技术实现的。所以页缓存实际上负责了块设备的大部分缓存工作。


2) 块缓存,以块为操作单位。在进行I/O操作时,存取的单位是设备的各个块,而不是整个内存页。尽管页长度对所有文件系统都是相同的,但块长度取决于特定的文件系统或其设置。因而,块缓存必须能够处理不同长度的块。


目前用于块传输的标准数据结构已经演变为struct bio。用这种方式进行块传输更为高效,因为他可以合并同一请求中后续的块,加速处理的进行。在许多场合下,页缓存和块缓存是联合使用的。例如,一个缓存的页在写操作期间可以划分为不同的缓冲区,这样可以在更细的力度下,识别出页被修改的部分。好处在于,在将数据写回时,只需要回写被修改的部分,无需将这个页面传输回底层的块设备。


页面缓存结构

[cpp]


  1. /*高速缓存的核心数据结构,对块设备的读写操作都放在该结构体里*/  
  2. struct address_space {  
  3.     /*与地址空间所管理的区域之间的关联数据结构之一 
  4.     inode结构指定了后备存储器*/  
  5.     struct inode        *host;      /* owner: inode, block_device */  
  6.     /*与地址空间所管理的区域之间的关联之二 
  7.     ,page_tree列出了地址空间中所有的物理内存页*/  
  8.     struct radix_tree_root  page_tree;  /* radix tree of all pages */  
  9.     spinlock_t      tree_lock;  /* and lock protecting it */  
  10.     /*所有用VM_SHARED属性创建的映射*/  
  11.     unsigned int        i_mmap_writable;/* count VM_SHARED mappings */  
  12.     /*基数根节点,该树包含了与该inode相关的所有 
  13.     普通内存映射。该树的任务在于,支持查找包含了 
  14.     给定区间中至少一页的所有内存区域*/  
  15.     struct prio_tree_root   i_mmap;     /* tree of private and shared mappings */  
  16.     /*包含所有在非线性映射中的页*/  
  17.     struct list_head    i_mmap_nonlinear;/*list VM_NONLINEAR mappings */  
  18.     spinlock_t      i_mmap_lock;    /* protect tree, count, list */  
  19.     unsigned int        truncate_count; /* Cover race condition with truncate */  
  20.     /*缓存页的总数*/  
  21.     unsigned long       nrpages;    /* number of total pages */  
  22.     pgoff_t         writeback_index;/* writeback starts here */  
  23.     const struct address_space_operations *a_ops;   /* methods */  
  24.     /*集主要用于保存映射页所来自的GFP内存区 
  25.     的有关信息*/  
  26.     unsigned long       flags;      /* error bits/gfp mask */  
  27.     /*指向后备存储器结构,该结构包含了与地址空间相关的 
  28.     后备存储器的有关信息,后备存储器是指与地址空间相关 
  29.     的外部设备,用做地址空间中信息的来源。他通常是块设备 
  30.     */  
  31.     struct backing_dev_info *backing_dev_info; /* device readahead, etc */  
  32.     spinlock_t      private_lock;   /* for use by the address_space */  
  33.     /*用于将包含文件系统元数据(通常是间接块)的buffer_head 
  34.     实例彼此连接起来*/  
  35.     struct list_head    private_list;   /* ditto */  
  36.     /*指向相关的地址空间的指针*/  
  37.     struct address_space    *assoc_mapping; /* ditto */  
  38. } __attribute__((aligned(sizeof(long))));  

后备存储信息

[cpp]


  1. struct backing_dev_info {  
  2.     struct list_head bdi_list;  
  3.     struct rcu_head rcu_head;  
  4.     /*最大预读数量,单位为PAGE_CACHE_SIZE*/  
  5.     unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */  
  6.     /*对该成员,总是使用原子操作,指定了后备存储器的状态*/  
  7.     unsigned long state;    /* Always use atomic bitops on this */  
  8.     /*设备能力*/  
  9.     unsigned int capabilities; /* Device capabilities */  
  10.     congested_fn *congested_fn; /* Function pointer if device is md/dm */  
  11.     void *congested_data;   /* Pointer to aux data for congested func */  
  12.     void (*unplug_io_fn)(struct backing_dev_info *, struct page *);  
  13.     void *unplug_io_data;  
  14.   
  15.     char *name;  
  16.   
  17.     struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];  
  18.   
  19.     struct prop_local_percpu completions;  
  20.     int dirty_exceeded;  
  21.   
  22.     unsigned int min_ratio;  
  23.     unsigned int max_ratio, max_prop_frac;  
  24.   
  25.     struct bdi_writeback wb;  /* default writeback info for this bdi */  
  26.     spinlock_t wb_lock;   /* protects update side of wb_list */  
  27.     struct list_head wb_list; /* the flusher threads hanging off this bdi */  
  28.     unsigned long wb_mask;    /* bitmask of registered tasks */  
  29.     unsigned int wb_cnt;      /* number of registered tasks */  
  30.   
  31.     struct list_head work_list;  
  32.   
  33.     struct device *dev;  
  34.   
  35. #ifdef CONFIG_DEBUG_FS   
  36.     struct dentry *debug_dir;  
  37.     struct dentry *debug_stats;  
  38. #endif   
  39. };  

下图为地址空间与内核其他部分的关联。


内核采用一种通用的地址空间方案,来建立缓存数据与其来源之间的关联。


1)  内存中的页分配到每个地址空间。这些页的内容可以由用户进程或内核本身使用各式各样的方法操作。这些数据表示了缓存中的内容;


2)  后备存储器struct backing_dev_info指定了填充地址空间中页的数据的来源。地址空间关联到处理器的虚拟地址空间,是由处理器在虚拟内存中管理的一个区域到设备device上对应位置之间的一个映射。


如果访问了虚拟内存中的某个位置,该位置没有关联到物理内存页,内核可根据地址空间结构来找到读取数据的来源。


为支持数据传输,每个地址空间都提供了一组操作,以容许地址空间所涉及双方面的交互。


地址空间是内核中最关键的数据结构之一,对该数据结构的管理,已经演变为内核面对的最关键的问题之一。 页缓存的任务在于,获得一些物理内存页,以加速在块设备上按页为单位执行的操作。


内核使用了基数树来管理与一个地址空间相关的所有页,以便尽可能降低开销。对于基数树的理解在这里就不分析了,后面有空的时候再做分析。



地址空间操作

[cpp]


  1. struct address_space_operations {  
  2.     /*将地址空间的一页或多页写回到底层设备 
  3.     这是通过向块层发出一个相应的请求来完成的*/  
  4.     int (*writepage)(struct page *page, struct writeback_control *wbc);  
  5.     /*从后备存储器将一页或多个连续的页读入页帧*/  
  6.     int (*readpage)(struct file *, struct page *);  
  7.     /*对尚未回写到后备存储器的数据进行同步*/  
  8.     void (*sync_page)(struct page *);  
  9.   
  10.     /* Write back some dirty pages from this mapping. */  
  11.     int (*writepages)(struct address_space *, struct writeback_control *);  
  12.   
  13.     /* Set a page dirty.  Return true if this dirtied it */  
  14.     int (*set_page_dirty)(struct page *page);  
  15.   
  16.     int (*readpages)(struct file *filp, struct address_space *mapping,  
  17.             struct list_head *pages, unsigned nr_pages);  
  18.     /*执行由write系统调用触发的写操作*/  
  19.     int (*write_begin)(struct file *, struct address_space *mapping,  
  20.                 loff_t pos, unsigned len, unsigned flags,  
  21.                 struct page **pagep, void **fsdata);  
  22.     int (*write_end)(struct file *, struct address_space *mapping,  
  23.                 loff_t pos, unsigned len, unsigned copied,  
  24.                 struct page *page, void *fsdata);  
  25.   
  26.     /* Unfortunately this kludge is needed for FIBMAP. Don’t use it */  
  27.     sector_t (*bmap)(struct address_space *, sector_t);  
  28.     void (*invalidatepage) (struct page *, unsigned long);  
  29.     int (*releasepage) (struct page *, gfp_t);  
  30.     ssize_t (*direct_IO)(intstruct kiocb *, const struct iovec *iov,  
  31.             loff_t offset, unsigned long nr_segs);  
  32.     int (*get_xip_mem)(struct address_space *, pgoff_t, int,  
  33.                         void **, unsigned long *);  
  34.     /* migrate the contents of a page to the specified target */  
  35.     int (*migratepage) (struct address_space *,  
  36.             struct page *, struct page *);  
  37.     int (*launder_page) (struct page *);  
  38.     int (*is_partially_uptodate) (struct page *, read_descriptor_t *,  
  39.                     unsigned long);  
  40.     int (*error_remove_page)(struct address_space *, struct page *);  
  41. };  

页面缓存的实现基于基数树,缓存属于内核中性能要求最苛刻的部分之一,而且广泛用于内核的所有子系统,实现也比较简单。举两个例子,其他的暂时不做分析了。


分配页面用于加入地址空间

[cpp]


  1. /*从伙伴系统中分配页面,页面的标志根据地址空间中的标志进行设置*/  
  2. static inline struct page *page_cache_alloc(struct address_space *x)  
  3. {  
  4.     return __page_cache_alloc(mapping_gfp_mask(x));  
  5. }  

分配完了添加到基数树中

[cpp]


  1. /* 
  2.  * Like add_to_page_cache_locked, but used to add newly allocated pages: 
  3.  * the page is new, so we can just run __set_page_locked() against it. 
  4.  */  
  5. static inline int add_to_page_cache(struct page *page,  
  6.         struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask)  
  7. {  
  8.     int error;  
  9.   
  10.     __set_page_locked(page);  
  11.     /*实际的添加工作*/  
  12.     error = add_to_page_cache_locked(page, mapping, offset, gfp_mask);  
  13.     if (unlikely(error))  
  14.         __clear_page_locked(page);  
  15.     return error;  
  16. }  

[cpp]


  1. /** 
  2.  * add_to_page_cache_locked – add a locked page to the pagecache 
  3.  * @page:   page to add 
  4.  * @mapping:    the page’s address_space 
  5.  * @offset: page index 
  6.  * @gfp_mask:   page allocation mode 
  7.  * 
  8.  * This function is used to add a page to the pagecache. It must be locked. 
  9.  * This function does not add the page to the LRU.  The caller must do that. 
  10.  */  
  11. int add_to_page_cache_locked(struct page *page, struct address_space *mapping,  
  12.         pgoff_t offset, gfp_t gfp_mask)  
  13. {  
  14.     int error;  
  15.   
  16.     VM_BUG_ON(!PageLocked(page));  
  17.   
  18.     error = mem_cgroup_cache_charge(page, current->mm,  
  19.                     gfp_mask & GFP_RECLAIM_MASK);  
  20.     if (error)  
  21.         goto out;  
  22.     /*树的相关结构申请*/  
  23.     error = radix_tree_preload(gfp_mask & ~__GFP_HIGHMEM);  
  24.     if (error == 0) {  
  25.         page_cache_get(page);/*使用计数加一*/  
  26.         page->mapping = mapping;  
  27.         page->index = offset;  
  28.       
  29.         spin_lock_irq(&mapping->tree_lock);  
  30.         /*实际的插入操作*/  
  31.         error = radix_tree_insert(&mapping->page_tree, offset, page);  
  32.         if (likely(!error)) {  
  33.             mapping->nrpages++;  
  34.             __inc_zone_page_state(page, NR_FILE_PAGES);  
  35.             if (PageSwapBacked(page))  
  36.                 __inc_zone_page_state(page, NR_SHMEM);  
  37.             spin_unlock_irq(&mapping->tree_lock);  
  38.         } else {  
  39.             page->mapping = NULL;  
  40.             spin_unlock_irq(&mapping->tree_lock);  
  41.             mem_cgroup_uncharge_cache_page(page);  
  42.             page_cache_release(page);  
  43.         }  
  44.         radix_tree_preload_end();  
  45.     } else  
  46.         mem_cgroup_uncharge_cache_page(page);  
  47. out:  
  48.     return error;  
  49. }  

赞(0) 打赏
转载请注明出处:服务器评测 » Linux缓存机制之页缓存
分享到: 更多 (0)

听说打赏我的人,都进福布斯排行榜啦!

支付宝扫一扫打赏

微信扫一扫打赏