linux cache buffer区别

最新推荐文章于 2025-05-17 14:00:32 发布

原创最新推荐文章于 2025-05-17 14:00:32 发布 · 1.7k 阅读

1 ·

CC 4.0 BY-SA版权

kernel 专栏收录该内容

10 篇文章

订阅专栏

本文详细解析了Linux系统的内存管理机制，重点介绍了/proc/meminfo中buffer与cache的区别及计算方式。通过对内核代码的深入分析，揭示了这两种内存管理机制在实际应用中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/proc/meminfo中有统计buffer和cache，这两个具体代表什么含义，最近分析了一下内核代码，希望可以解释清楚。

[root@rhevm ~]# cat /proc/meminfo
MemTotal:        5845796 kB
MemFree:         3648956 kB
Buffers:           42812 kB
Cached:           677024 kB
SwapCached:            0 kB
Active:          1620200 kB
Inactive:         413544 kB
Active(anon):    1316896 kB
Inactive(anon):    13576 kB
Active(file):     303304 kB
Inactive(file):   399968 kB
Unevictable:           0 kB
Mlocked:               0 kB
SwapTotal:       3071992 kB
SwapFree:        3071992 kB
Dirty:              1828 kB
Writeback:             0 kB
AnonPages:       1313984 kB
Mapped:            84048 kB
Shmem:             16496 kB
Slab:              70456 kB
SReclaimable:      41976 kB
SUnreclaim:        28480 kB
KernelStack:        3792 kB
PageTables:        22216 kB
NFS_Unstable:          0 kB
Bounce:                0 kB
WritebackTmp:          0 kB
CommitLimit:     5994888 kB
Committed_AS:    2613668 kB
VmallocTotal:   34359738367 kB
VmallocUsed:       26560 kB
VmallocChunk:   34359707596 kB
HardwareCorrupted:     0 kB
AnonHugePages:    864256 kB
HugePages_Total:       0
HugePages_Free:        0
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:       2048 kB
DirectMap4k:        8180 kB
DirectMap2M:     6135808 kB

meminfo的内容是通过meminfo_proc_show函数处理的。

static int meminfo_proc_show(struct seq_file *m, void *v) 在/fs/proc/meminfo.c中。

cache的计算如下：

cached = global_page_state(NR_FILE_PAGES) -
total_swapcache_pages - i.bufferram;

buffer的计算如下：

val->bufferram = nr_blockdev_pages();

首先分析buffer的统计：

long nr_blockdev_pages(void)
{
   struct block_device *bdev;
   long ret = 0;
   spin_lock(&bdev_lock);
   list_for_each_entry(bdev, &all_bdevs, bd_list) {
       ret += bdev->bd_inode->i_mapping->nrpages;
   }
   spin_unlock(&bdev_lock);
   return ret;
}

buffer的统计实际上是把所有块设备文件中的mapping进行了汇总。

内核什么实际会进行块设备的mapping处理？

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

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

实际上很多资料提到linux有块缓存和页缓存，块缓存针对的是块设备，根据请求的块设备，偏移量，大小，在缓存中查找，如果存在的话，就不用再想通用块层提交bio了。

页缓存针对的是文件内容的缓存，根据请求的文件inode，偏移量，大小进行查找，和在读文件或者写文件的时候，文件内容保证在内容中，来提供性能。

但是，分析内核的代码发现，块缓存已经基于页缓存机制来实现，只不过定位的文件是设备文件的inode.

因此便利所有块设备的>i_mapping->nrpages;就可以计算出来块缓存的大小。

    list_for_each_entry(bdev, &all_bdevs, bd_list) {
       ret += bdev->bd_inode->i_mapping->nrpages;
   }

cached = global_page_state(NR_FILE_PAGES) -
total_swapcache_pages - i.bufferram;

cache的计算需要减去buffer，是因为buffer块缓存也是基于cache页缓存的，因此也是用的是NR_FILE_PAGES标示，因此需要减掉buffer。

减掉swap获取实际内存中的cache大小。

那么什么情况下会使用cache，什么情况下会使用buffer？

根据前面的分析，如果调用的是__bread，则会统计到buffer上，如果是普通文件内容的缓存会被统计到cache上。

分析内核代码，调用__bread的地方，基本上是文件系统代码中获取元数据的部分。这部分会被统计到buffer上。

vfs在普通文件内容读写流程中，都会使用缓存机制，都会被统计到cache上。

__getblk(struct block_device *bdev, sector_t block, unsigned size)
{
   struct buffer_head *bh = __find_get_block(bdev, block, size);    //首先调用__find_get_block在块缓存中查找是否存在，如果存在直接返回

   might_sleep();
   if (bh == NULL)
       bh = __getblk_slow(bdev, block, size);      //如果不存在，则进行实际的io操作
   return bh;
}

__find_get_block(struct block_device *bdev, sector_t block, unsigned size)
{
   struct buffer_head *bh = lookup_bh_lru(bdev, block, size);   //根据lru，快速查找

   if (bh == NULL) {
       bh = __find_get_block_slow(bdev, block); //如果查找失败，通过页缓存进行查找
       if (bh)
           bh_lru_install(bh);
   }
   if (bh)
       touch_buffer(bh);
   return bh;
}

static struct buffer_head *
__find_get_block_slow(struct block_device *bdev, sector_t block)
{
   struct inode *bd_inode = bdev->bd_inode;
   struct address_space *bd_mapping = bd_inode->i_mapping;      //获取对应块设备的address_space结构
   struct buffer_head *ret = NULL;
   pgoff_t index;
   struct buffer_head *bh;
   struct buffer_head *head;
   struct page *page;
   int all_mapped = 1;

   index = block >> (PAGE_CACHE_SHIFT - bd_inode->i_blkbits);
   page = find_get_page(bd_mapping, index);     //如果查找到，通过page获取buffer_head
   if (!page)
       goto out;

   spin_lock(&bd_mapping->private_lock);
   if (!page_has_buffers(page))
       goto out_unlock;
   head = page_buffers(page);
   bh = head;
   do {
       if (!buffer_mapped(bh))
           all_mapped = 0;
       else if (bh->b_blocknr == block) {
           ret = bh;
           get_bh(bh);
           goto out_unlock;
       }
       bh = bh->b_this_page;
   } while (bh != head);

   /* we might be here because some of the buffers on this page are
   * not mapped. This is due to various races between
   * file io on the block device and getblk. It gets dealt with
   * elsewhere, don't buffer_error if we had some unmapped buffers
   */
   if (all_mapped) {
       printk("__find_get_block_slow() failed. "
           "block=%llu, b_blocknr=%llu\n",
           (unsigned long long)block,
           (unsigned long long)bh->b_blocknr);
       printk("b_state=0x%08lx, b_size=%zu\n",
           bh->b_state, bh->b_size);
       printk("device blocksize: %d\n", 1 << bd_inode->i_blkbits);
   }
out_unlock:
   spin_unlock(&bd_mapping->private_lock);
   page_cache_release(page);
out:
   return ret;
}

/* If we *know* page->private refers to buffer_heads */
#define page_buffers(page)                   \
   ({                           \
       BUG_ON(!PagePrivate(page));           \
       ((struct buffer_head *)page_private(page));   \
   })

buffer_head存在在page的private结构中，通过这个可以反向找到对应的buffer_head数据结构。

查找失败处理：

static struct buffer_head *
__getblk_slow(struct block_device *bdev, sector_t block, int size)
{
   /* Size must be multiple of hard sectorsize */
   if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||
           (size < 512 || size > PAGE_SIZE))) {
       printk(KERN_ERR "getblk(): invalid block size %d requested\n",
                   size);
       printk(KERN_ERR "logical block size: %d\n",
                   bdev_logical_block_size(bdev));

       dump_stack();
       return NULL;
   }

   for (;;) {
       struct buffer_head *bh;
       int ret;

       bh = __find_get_block(bdev, block, size);
       if (bh)
           return bh;

       ret = grow_buffers(bdev, block, size);
       if (ret < 0)
           return NULL;
       if (ret == 0)
           free_more_memory();
   }
}