当前位置：首页 > news >正文

Linux内存管理-缓存系统中的Major和Minor详解

news 2025/10/15 8:30:30

Linux缓存系统中的Major和Minor详解

概述

在Linux内核的缓存系统中，"Major"和"Minor"是页面回收和缓存管理中的两个核心概念。它们主要用于区分不同类型的页面故障（Page Fault）和缓存操作，对系统性能分析和优化具有重要意义。

1. 页面故障中的Major和Minor

1.1 Minor Page Fault（轻微页面故障）

1.1.1 定义和特征

定义：页面在物理内存中存在，但页表项不存在或权限不足导致的页面故障。

核心特征：

无磁盘I/O操作：页面数据已在内存中
处理速度快：主要涉及页表操作和权限检查
系统开销低：通常在微秒级完成
不阻塞进程：处理过程中很少需要进程调度

1.1.2 典型应用场景

1. COW (Copy-On-Write) 页面

// 父子进程共享只读页面，写入时触发minor fault
static int do_wp_page(struct mm_struct *mm, struct vm_area_struct *vma,unsigned long address, pte_t *page_table, pmd_t *pmd,spinlock_t *ptl, pte_t orig_pte)
{struct page *old_page;old_page = vm_normal_page(vma, address, orig_pte);if (old_page) {// 检查是否可以重用页面if (reuse_swap_page(old_page)) {// 可以重用，只需修改权限 - Minor Faultentry = pte_mkyoung(orig_pte);entry = maybe_mkwrite(pte_mkdirty(entry), vma);set_pte_at(mm, address, page_table, entry);return VM_FAULT_WRITE;}}// 需要复制页面 - 仍然是Minor Fault（页面在内存中）return __do_wp_page(mm, vma, address, page_table, pmd, ptl, orig_pte);
}

2. 匿名页面的延迟分配

static int do_anonymous_page(struct mm_struct *mm, struct vm_area_struct *vma,unsigned long address, pte_t *page_table, pmd_t *pmd,unsigned int flags)
{// 只读访问使用零页面 - Minor Faultif (!(flags & FAULT_FLAG_WRITE) && !mm_forbids_zeropage(mm)) {entry = pte_mkspecial(pfn_pte(my_zero_pfn(address), vma->vm_page_prot));set_pte_at(mm, address, page_table, entry);return 0;}// 写访问需要分配新页面 - Minor Fault（无I/O）page = alloc_zeroed_user_highpage_movable(vma, address);// ... 设置页表项
}

3. 权限检查和页表更新

static int handle_pte_fault(struct mm_struct *mm, struct vm_area_struct *vma,unsigned long address, pte_t *pte, pmd_t *pmd,unsigned int flags)
{pte_t entry = *pte;if (pte_present(entry)) {// 页面存在，检查权限 - Minor Faultif (flags & FAULT_FLAG_WRITE) {if (!pte_write(entry))return do_wp_page(mm, vma, address, pte, pmd, ptl, entry);}return 0;}// 页面不存在，可能需要I/O - 可能是Major Faultreturn do_fault(mm, vma, address, pte, pmd, flags, entry);
}

1.2 Major Page Fault（重大页面故障）

1.2.1 定义和特征

定义：需要从存储设备（磁盘、SSD等）读取数据的页面故障。

核心特征：

涉及磁盘I/O：必须从存储设备读取数据
处理时间长：受存储设备I/O速度限制，通常毫秒级
系统开销大：可能触发进程调度和I/O等待
可能阻塞进程：等待I/O完成期间进程被挂起

1.2.2 典型应用场景

1. 文件页面首次加载

static int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{struct file *file = vma->vm_file;struct address_space *mapping = file->f_mapping;struct inode *inode = mapping->host;pgoff_t offset = vmf->pgoff;struct page *page;int ret = 0;// 在页面缓存中查找page = find_get_page(mapping, offset);if (likely(page) && !(vmf->flags & FAULT_FLAG_TRIED)) {// 页面在缓存中 - Minor Faultgoto got_page;}if (!page) {// 页面不在缓存中，需要从磁盘读取 - Major Faultret = do_sync_mmap_readahead(vma, ra, file, offset);if (ret)return ret;// 分配新页面并从磁盘读取page = __page_cache_alloc(gfp | __GFP_COLD);if (!page)return VM_FAULT_OOM;ret = add_to_page_cache_lru(page, mapping, offset, gfp & GFP_KERNEL);if (ret) {page_cache_release(page);return ret;}// 执行实际的磁盘读取操作ret = mapping->a_ops->readpage(file, page);}got_page:vmf->page = page;return ret | VM_FAULT_LOCKED;
}

2. 交换页面回读

static int do_swap_page(struct mm_struct *mm, struct vm_area_struct *vma,unsigned long address, pte_t *page_table, pmd_t *pmd,unsigned int flags, pte_t orig_pte)
{swp_entry_t entry;struct page *page;struct mem_cgroup *memcg;int ret = 0;entry = pte_to_swp_entry(orig_pte);// 在交换缓存中查找page = lookup_swap_cache(entry);if (!page) {// 不在交换缓存中，需要从交换设备读取 - Major Faultpage = swapin_readahead(entry, GFP_HIGHUSER_MOVABLE, vma, address);if (!page) {// 直接从交换设备读取单个页面page = read_swap_cache_async(entry, GFP_HIGHUSER_MOVABLE,vma, address);if (!page)return VM_FAULT_OOM;}}// 等待I/O完成lock_page(page);if (!PageSwapCache(page)) {// 页面已被其他进程处理unlock_page(page);page_cache_release(page);goto out;}// 设置页表项并完成交换// ...
}

3. 内存映射文件的预读

static void do_sync_mmap_readahead(struct vm_area_struct *vma,struct file_ra_state *ra,struct file *file,pgoff_t offset)
{struct address_space *mapping = file->f_mapping;// 检查是否需要预读if (!ra->ra_pages)return;// 执行同步预读 - Major I/O操作if (PageReadahead(page)) {page_cache_async_readahead(mapping, ra, file, page, offset,ra->ra_pages);}// 执行实际的磁盘读取page_cache_sync_readahead(mapping, ra, file, offset, ra->ra_pages);
}

2. 缓存系统中的Major和Minor操作

2.1 页面缓存架构

// 页面缓存的核心数据结构
struct address_space {struct inode                *host;           // 关联的inodestruct radix_tree_root      page_tree;      // 页面基数树spinlock_t                  tree_lock;      // 保护基数树的锁atomic_t                    i_mmap_writable; // 可写映射计数struct rb_root              i_mmap;         // 内存映射红黑树struct rw_semaphore         i_mmap_rwsem;   // 映射读写信号量unsigned long               nrpages;        // 页面总数unsigned long               nrexceptional;  // 异常项数量pgoff_t                     writeback_index; // 写回起始索引const struct address_space_operations *a_ops; // 操作函数集unsigned long               flags;          // 标志位struct backing_dev_info     *backing_dev_info; // 后备设备信息spinlock_t                  private_lock;   // 私有数据锁struct list_head            private_list;   // 私有页面链表void                        *private_data;  // 私有数据
} __attribute__((aligned(sizeof(long))));

2.2 Minor缓存操作

2.2.1 页面缓存命中

// 快速页面查找 - Minor操作
static struct page *find_get_page(struct address_space *mapping, pgoff_t offset)
{struct page *page;rcu_read_lock();page = radix_tree_lookup(&mapping->page_tree, offset);if (page) {if (!page_cache_get_speculative(page))goto repeat;// 页面在缓存中找到 - Minor操作，无I/Oif (unlikely(page != radix_tree_lookup(&mapping->page_tree, offset))) {page_cache_release(page);goto repeat;}}rcu_read_unlock();return page;
}// 页面缓存快速路径
struct page *find_lock_page(struct address_space *mapping, pgoff_t offset)
{struct page *page;repeat:page = find_get_page(mapping, offset);if (page && !radix_tree_exception(page)) {lock_page(page);// 验证页面仍在缓存中if (unlikely(page->mapping != mapping)) {unlock_page(page);page_cache_release(page);goto repeat;}VM_BUG_ON_PAGE(page->index != offset, page);}return page;
}

2.2.2 预读优化

// 智能预读 - Minor操作优化
static void ondemand_readahead(struct address_space *mapping,struct file_ra_state *ra, struct file *file,bool hit_readahead_marker, pgoff_t offset,unsigned long req_size)
{unsigned long max_pages = ra->ra_pages;pgoff_t prev_offset;// 检查是否命中预读标记if (hit_readahead_marker) {pgoff_t start;rcu_read_lock();start = page_cache_next_hole(mapping, offset + 1, max_pages);rcu_read_unlock();if (!start || start - offset > max_pages)return;ra->start = start;ra->size = start - offset;  // 实际需要预读的页面数ra->size += req_size;ra->size = get_next_ra_size(ra, max_pages);ra->async_size = ra->size;goto readit;}// 基于访问模式调整预读策略if (req_size > max_pages && bdi_read_congested(mapping->backing_dev_info))return;readit:// 执行异步预读ra_submit(ra, mapping, file);
}

2.3 Major缓存操作

2.3.1 页面缓存未命中处理

// 页面缓存未命中 - Major操作
static int page_cache_read(struct file *file, pgoff_t offset, gfp_t gfp_mask)
{struct address_space *mapping = file->f_mapping;struct page *page;int ret;do {// 分配新页面page = __page_cache_alloc(gfp_mask | __GFP_COLD);if (!page)return -ENOMEM;// 添加到页面缓存ret = add_to_page_cache_lru(page, mapping, offset, gfp_mask & GFP_KERNEL);if (ret == 0) {// 从存储设备读取数据 - Major I/O操作ret = mapping->a_ops->readpage(file, page);if (ret != AOP_TRUNCATED_PAGE)break;} else if (ret == -EEXIST) {// 页面已被其他进程添加到缓存ret = 0;break;}page_cache_release(page);} while (ret == AOP_TRUNCATED_PAGE);return ret;
}

2.3.2 批量页面读取

// 批量预读 - Major操作
static int __do_page_cache_readahead(struct address_space *mapping,struct file *filp, pgoff_t offset,unsigned long nr_to_read,unsigned long lookahead_size)
{struct inode *inode = mapping->host;struct page *page;unsigned long end_index;LIST_HEAD(page_pool);int page_idx;int ret = 0;loff_t isize = i_size_read(inode);if (isize == 0)goto out;end_index = ((isize - 1) >> PAGE_CACHE_SHIFT);// 批量分配页面for (page_idx = 0; page_idx < nr_to_read; page_idx++) {pgoff_t page_offset = offset + page_idx;if (page_offset > end_index)break;rcu_read_lock();page = radix_tree_lookup(&mapping->page_tree, page_offset);rcu_read_unlock();if (page && !radix_tree_exceptional_entry(page))continue;page = page_cache_alloc_readahead(mapping);if (!page)break;page->index = page_offset;list_add(&page->lru, &page_pool);if (page_idx == nr_to_read - lookahead_size)SetPageReadahead(page);ret++;}// 批量提交I/O请求 - Major操作if (ret)read_pages(mapping, filp, &page_pool, ret);BUG_ON(!list_empty(&page_pool));
out:return ret;
}

3. 性能监控和统计

3.1 系统级统计

3.1.1 /proc接口统计

# 查看全局页面故障统计
cat /proc/vmstat | grep fault
pgfault 12345678      # 总页面故障数（包含Major和Minor）
pgmajfault 123456     # Major页面故障数# 计算Minor页面故障数
# minor_faults = pgfault - pgmajfault = 12345678 - 123456 = 12222222# 查看内存统计信息
cat /proc/meminfo | grep -E "(Cached|Buffers|SwapCached)"
Buffers:         123456 kB    # 块设备缓冲区
Cached:         1234567 kB    # 页面缓存
SwapCached:       12345 kB    # 交换缓存

3.1.2 进程级统计

# 查看特定进程的页面故障统计
cat /proc/[pid]/stat
# 字段解释：
# 字段10: minor_faults - 进程的Minor页面故障数
# 字段12: major_faults - 进程的Major页面故障数# 查看进程内存映射
cat /proc/[pid]/maps
# 显示进程的虚拟内存映射，包括文件映射和匿名映射# 查看进程内存状态
cat /proc/[pid]/status | grep -E "(VmPeak|VmSize|VmRSS|VmData)"
VmPeak:    123456 kB    # 虚拟内存峰值
VmSize:    123456 kB    # 当前虚拟内存大小
VmRSS:      12345 kB    # 物理内存使用量
VmData:     12345 kB    # 数据段大小

3.2 内核统计实现

3.2.1 统计计数器更新

// 页面故障统计更新
void count_vm_event(enum vm_event_item item)
{this_cpu_inc(vm_event_states.event[item]);
}void count_vm_events(enum vm_event_item item, long delta)
{this_cpu_add(vm_event_states.event[item], delta);
}// 在页面故障处理中更新统计
static int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,unsigned long address, unsigned int flags)
{int ret;__set_current_state(TASK_RUNNING);// 更新minor fault统计count_vm_event(PGFAULT);mem_cgroup_count_vm_event(mm, PGFAULT);// 处理页面故障ret = __handle_mm_fault(mm, vma, address, flags);// 根据处理结果更新major fault统计if (flags & FAULT_FLAG_ALLOW_RETRY) {if (unlikely(ret & VM_FAULT_MAJOR)) {count_vm_event(PGMAJFAULT);mem_cgroup_count_vm_event(mm, PGMAJFAULT);}}return ret;
}

3.2.2 Per-CPU统计优化

// Per-CPU统计结构
struct vm_event_state {unsigned long event[NR_VM_EVENT_ITEMS];
};DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}};// 统计数据聚合
static void sum_vm_events(unsigned long *ret)
{int cpu;int i;memset(ret, 0, NR_VM_EVENT_ITEMS * sizeof(unsigned long));for_each_online_cpu(cpu) {struct vm_event_state *this = &per_cpu(vm_event_states, cpu);for (i = 0; i < NR_VM_EVENT_ITEMS; i++)ret[i] += this->event[i];}
}// 导出统计信息到/proc/vmstat
static int vmstat_show(struct seq_file *m, void *arg)
{unsigned long *l = arg;unsigned long off = l - (unsigned long *)m->private;seq_printf(m, "%s %lu\n", vmstat_text[off], *l);return 0;
}

4. 性能优化策略

4.1 减少Major Fault的策略

4.1.1 应用程序级优化

// 1. 文件预读优化
void optimize_file_access(int fd, off_t offset, size_t len)
{// 告知内核即将访问的数据posix_fadvise(fd, offset, len, POSIX_FADV_WILLNEED);// 设置顺序访问模式posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);// 对于随机访问模式// posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
}// 2. 内存映射预热
void *optimize_mmap(int fd, size_t len, off_t offset)
{void *addr;// 使用MAP_POPULATE预先填充页表addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_POPULATE, fd, offset);if (addr == MAP_FAILED)return NULL;// 可选：使用madvise进一步优化madvise(addr, len, MADV_SEQUENTIAL);return addr;
}// 3. 内存锁定避免交换
int lock_critical_memory(void *addr, size_t len)
{// 锁定内存页面，避免被交换出去if (mlock(addr, len) != 0) {perror("mlock failed");return -1;}// 对于实时应用，可以锁定所有内存// mlockall(MCL_CURRENT | MCL_FUTURE);return 0;
}// 4. 预分配和预热内存
void preallocate_memory(size_t size)
{char *buffer = malloc(size);if (!buffer)return;// 触摸每个页面以确保分配for (size_t i = 0; i < size; i += 4096) {buffer[i] = 0;}// 使用内存...free(buffer);
}

4.1.2 系统级调优

#!/bin/bash
# 系统级内存优化脚本# 1. 调整页面缓存行为
echo 1 > /proc/sys/vm/drop_caches          # 清理页面缓存（测试用）
echo 60 > /proc/sys/vm/swappiness           # 降低交换倾向（默认60）
echo 100 > /proc/sys/vm/vfs_cache_pressure  # 调整VFS缓存压力# 2. 调整预读参数
echo 128 > /sys/block/sda/queue/read_ahead_kb  # 设置预读大小# 3. 内存压缩和回收
echo 1 > /proc/sys/vm/compact_memory        # 触发内存压缩
echo 0 > /proc/sys/vm/oom_kill_allocating_task  # OOM策略调整# 4. 透明大页设置
echo always > /sys/kernel/mm/transparent_hugepage/enabled
echo madvise > /sys/kernel/mm/transparent_hugepage/defrag

4.2 Minor Fault优化

4.2.1 减少权限切换

// 优化COW页面处理
static int optimize_cow_handling(struct mm_struct *mm, struct vm_area_struct *vma,unsigned long address, pte_t *pte, pmd_t *pmd,spinlock_t *ptl, pte_t orig_pte)
{struct page *old_page = vm_normal_page(vma, address, orig_pte);if (old_page && PageAnon(old_page)) {// 检查是否可以直接重用页面if (page_mapcount(old_page) == 1 && page_count(old_page) == 1) {// 页面只有一个引用，可以直接修改权限pte_t entry = pte_mkyoung(orig_pte);entry = maybe_mkwrite(pte_mkdirty(entry), vma);set_pte_at(mm, address, pte, entry);update_mmu_cache(vma, address, pte);return VM_FAULT_WRITE;}}// 需要执行COWreturn __do_wp_page(mm, vma, address, pte, pmd, ptl, orig_pte);
}

4.2.2 页表预分配

// 预分配页表以减少后续的minor fault
static int preallocate_page_tables(struct mm_struct *mm, struct vm_area_struct *vma,unsigned long start, unsigned long end)
{unsigned long addr;pgd_t *pgd;pud_t *pud;pmd_t *pmd;for (addr = start; addr < end; addr += PMD_SIZE) {pgd = pgd_offset(mm, addr);pud = pud_alloc(mm, pgd, addr);if (!pud)return -ENOMEM;pmd = pmd_alloc(mm, pud, addr);if (!pmd)return -ENOMEM;// 对于匿名VMA，可以预分配PTEif (vma_is_anonymous(vma)) {if (pte_alloc(mm, vma, pmd, addr))return -ENOMEM;}}return 0;
}

5. 实际应用案例

5.1 数据库系统优化

// 数据库缓冲池管理
struct db_buffer_pool {void *buffer_area;size_t buffer_size;int *page_table;struct lru_list lru;
};int initialize_db_buffer_pool(struct db_buffer_pool *pool, size_t size)
{// 分配大块连续内存pool->buffer_area = mmap(NULL, size, PROT_READ | PROT_WRITE,MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);if (pool->buffer_area == MAP_FAILED)return -1;// 锁定内存避免交换 - 减少Major Faultif (mlock(pool->buffer_area, size) != 0) {munmap(pool->buffer_area, size);return -1;}// 设置内存访问模式madvise(pool->buffer_area, size, MADV_RANDOM);pool->buffer_size = size;return 0;
}// 预读数据页面
void prefetch_data_pages(int fd, off_t *offsets, int count)
{// 批量预读以减少Major Faultfor (int i = 0; i < count; i++) {posix_fadvise(fd, offsets[i], PAGE_SIZE, POSIX_FADV_WILLNEED);}
}

5.2 高性能Web服务器

// Web服务器静态文件缓存
struct static_file_cache {struct hash_table *file_map;void *mmap_region;size_t total_size;
};int cache_static_file(struct static_file_cache *cache, const char *filename)
{int fd;struct stat st;void *mapped;fd = open(filename, O_RDONLY);if (fd < 0)return -1;if (fstat(fd, &st) < 0) {close(fd);return -1;}// 使用mmap映射文件，利用页面缓存mapped = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);if (mapped == MAP_FAILED) {close(fd);return -1;}// 预读整个文件到页面缓存 - 一次性Major Faultmadvise(mapped, st.st_size, MADV_WILLNEED);// 添加到缓存映射表hash_table_insert(cache->file_map, filename, mapped, st.st_size);close(fd);return 0;
}

5.3 实时系统内存管理

// 实时系统内存预分配
struct rt_memory_pool {void *memory_base;size_t pool_size;struct free_list free_blocks;spinlock_t lock;
};int initialize_rt_memory_pool(struct rt_memory_pool *pool, size_t size)
{// 分配并锁定内存pool->memory_base = mmap(NULL, size, PROT_READ | PROT_WRITE,MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);if (pool->memory_base == MAP_FAILED)return -1;// 锁定所有页面，确保无Major Faultif (mlock(pool->memory_base, size) != 0) {munmap(pool->memory_base, size);return -1;}// 预热所有页面，触发Minor Faultchar *ptr = (char *)pool->memory_base;for (size_t i = 0; i < size; i += PAGE_SIZE) {ptr[i] = 0;  // 触摸每个页面}// 禁用页面交换madvise(pool->memory_base, size, MADV_DONTFORK);pool->pool_size = size;spin_lock_init(&pool->lock);return 0;
}

6. 调试和分析工具

6.1 系统监控工具

# 1. 使用sar监控页面故障
sar -B 1 10  # 每秒显示页面故障统计，持续10次
# 输出包含：
# pgpgin/s    - 每秒从磁盘读入的页面数
# pgpgout/s   - 每秒写入磁盘的页面数  
# fault/s     - 每秒页面故障数（minor + major）
# majflt/s    - 每秒major页面故障数# 2. 使用vmstat监控内存活动
vmstat 1 10  # 每秒显示系统统计，持续10次
# 关注字段：
# si - 每秒从交换区读入的内存量(KB)
# so - 每秒写入交换区的内存量(KB)# 3. 使用iostat监控I/O活动
iostat -x 1 10  # 每秒显示扩展I/O统计# 4. 使用perf分析页面故障
perf record -e page-faults,major-faults -g ./your_program
perf report  # 分析页面故障的调用栈

6.2 应用程序分析

// 应用程序内置监控
struct page_fault_stats {unsigned long minor_faults_start;unsigned long major_faults_start;unsigned long minor_faults_end;unsigned long major_faults_end;
};void get_page_fault_stats(struct page_fault_stats *stats, pid_t pid)
{char stat_file[256];FILE *fp;unsigned long dummy;snprintf(stat_file, sizeof(stat_file), "/proc/%d/stat", pid);fp = fopen(stat_file, "r");if (!fp)return;// 读取/proc/pid/stat的第10和12个字段fscanf(fp, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %lu %*u %lu",&stats->minor_faults_start, &stats->major_faults_start);fclose(fp);
}void benchmark_memory_operation(void)
{struct page_fault_stats stats_before, stats_after;get_page_fault_stats(&stats_before, getpid());// 执行内存操作perform_memory_intensive_task();get_page_fault_stats(&stats_after, getpid());printf("Minor faults: %lu\n", stats_after.minor_faults_end - stats_before.minor_faults_start);printf("Major faults: %lu\n",stats_after.major_faults_end - stats_before.major_faults_start);
}

7. 总结

7.1 核心区别对比

特征	Minor Page Fault	Major Page Fault
I/O需求	无磁盘I/O	需要磁盘I/O
处理时间	微秒级（1-10μs）	毫秒级（1-100ms）
系统开销	低（CPU操作）	高（I/O等待）
进程状态	通常不阻塞	可能阻塞等待I/O
典型场景	COW、权限检查、零页分配	文件加载、交换回读
优化策略	减少权限切换、预分配	预读、缓存、内存锁定
性能影响	轻微	显著