69天探索操作系统-第50天：虚拟内存管理系统

GoGeekBaird2025-03-12 18:28

1. 介绍

虚拟内存是现代操作系统的关键组成部分，它允许进程通过在RAM和磁盘之间交换数据来使用比物理内存更多的内存。提供的代码定义了虚拟内存管理的基本结构，例如用于页表条目的pte_t和用于物理内存页的struct page。这些结构对于管理内存映射、页表和页面故障至关重要。

struct vm_area_struct 结构体表示一个虚拟内存区域（VMA），它是一个具有特定属性（如权限和后端存储）的连续虚拟内存区域。VMA 用于管理进程的内存映射，确保每个进程都有其独立的地址空间。这种设置是内核中实现虚拟内存管理的基础。

2. 页表管理

页表用于将虚拟地址转换为物理地址。结构体page_table表示一个页表，其中包含条目（PTEs），这些条目将虚拟页映射到物理页。allocate_page_table函数分配并初始化一个新的页表，而walk_page_table函数遍历页表层次结构以查找或创建给定虚拟地址的PTE。

c 复制代码 
struct page_table {
    pte_t *entries;
    unsigned int level;
    spinlock_t lock;
    struct page *page;
};

static inline unsigned long pte_index(virtual_addr_t addr, int level) {
    return (addr >> (PAGE_SHIFT + level * 9)) & 0x1FF;
}

static int allocate_page_table(struct page_table *pt) {
    struct page *page = alloc_page(GFP_KERNEL);
    if (!page)
        return -ENOMEM;

    pt->entries = page_address(page);
    pt->page = page;
    memset(pt->entries, 0, PAGE_SIZE);

    return 0;
}

static pte_t* walk_page_table(struct page_table *pgd,
                            virtual_addr_t addr,
                            bool create) {
    struct page_table *current_pt = pgd;
    pte_t *pte;
    int level;

    for (level = 3; level > 0; level--) {
        unsigned long index = pte_index(addr, level);
        pte = &current_pt->entries[index];

        if (!(*pte & PTE_PRESENT)) {
            if (!create)
                return NULL;

            struct page_table *new_pt;
            int ret = allocate_page_table(new_pt);
            if (ret)
                return NULL;

            *pte = page_to_phys(new_pt->page) | PTE_PRESENT | PTE_USER;
        }

        current_pt = phys_to_virt(PTE_ADDR(*pte));
    }

    return &current_pt->entries[pte_index(addr, 0)];
}

walk_page_table 函数对于地址转换至关重要，因为它遍历页表层次结构以查找或创建适当的页表条目（PTE）。这确保了虚拟地址可以高效地映射到物理地址。

3. 内存映射

内存映射允许进程将文件或匿名内存映射到其地址空间。struct vm_operations_struct 定义了管理内存映射的操作，如打开、关闭和故障处理。map_page_range 函数将虚拟地址范围映射到物理地址，而 find_vma 函数则定位给定虚拟地址的 VMA。

c 复制代码 
struct vm_operations_struct {
    void (*open)(struct vm_area_struct *area);
    void (*close)(struct vm_area_struct *area);
    int (*fault)(struct vm_area_struct *area, struct vm_fault *vmf);
};

static int map_page_range(struct vm_area_struct *vma,
                         virtual_addr_t start,
                         unsigned long size,
                         physical_addr_t phys_addr,
                         pgprot_t prot) {
    unsigned long addr;
    int ret = 0;

    for (addr = start; addr < start + size; addr += PAGE_SIZE) {
        pte_t *pte = walk_page_table(vma->mm->pgd, addr, true);
        if (!pte) {
            ret = -ENOMEM;
            break;
        }

        physical_addr_t pa = phys_addr + (addr - start);
        *pte = pa | pgprot_val(prot);
        flush_tlb_page(vma, addr);
    }

    return ret;
}

static struct vm_area_struct *find_vma(struct mm_struct *mm,
                                     virtual_addr_t addr) {
    struct vm_area_struct *vma;

    if (!mm)
        return NULL;

    for (vma = mm->mmap; vma; vma = vma->vm_next) {
        if (addr >= vma->start && addr < vma->end)
            return vma;
    }

    return NULL;
}

这些函数确保内存映射被正确创建和管理，从而使进程能够高效地访问文件或匿名内存。

4. 页故障处理程序

当进程访问一个未映射到物理内存的虚拟地址时，会发生页错误。handle_page_fault 函数通过将所需的页映射到内存来处理页错误。如果错误是由于缺少页引起的，它会分配一个新的页并更新页表。如果错误是由于权限违规引起的，它会返回一个错误。

c 复制代码 
struct vm_fault {
    virtual_addr_t address;
    unsigned int flags;
    pte_t *pte;
    struct page *page;
};

static int handle_page_fault(struct mm_struct *mm,
                           virtual_addr_t addr,
                           unsigned int flags) {
    struct vm_area_struct *vma;
    struct vm_fault vmf;
    int ret;

    vma = find_vma(mm, addr);
    if (!vma)
        return -EFAULT;

    vmf.address = addr;
    vmf.flags = flags;
    vmf.pte = walk_page_table(mm->pgd, addr, true);

    if (!vmf.pte)
        return -ENOMEM;

    if (vma->vm_ops && vma->vm_ops->fault) {
        ret = vma->vm_ops->fault(vma, &vmf);
        if (ret)
            return ret;
    } else {
        // Anonymous memory - allocate new page
        struct page *page = alloc_page(GFP_KERNEL);
        if (!page)
            return -ENOMEM;

        *vmf.pte = page_to_phys(page) | PTE_PRESENT | PTE_USER;
        if (flags & FAULT_FLAG_WRITE)
            *vmf.pte |= PTE_WRITABLE;
    }

    flush_tlb_page(vma, addr);
    return 0;
}

页故障处理程序确保即使内存最初未映射，进程也能访问内存，从而提供一种大型、连续的地址空间错觉。

5. 页面替换

当物理内存满时，操作系统必须清理页，以腾出空间给新页。struct lru_list 表示一个用于跟踪页使用的最少最近使用（LRU）列表。get_lru_page 函数检索最少最近使用的页面，而 add_to_lru 函数将页面添加到 LRU 列表中。page_out 函数在释放页面之前将脏页面写入交换空间。

c 复制代码 
struct lru_list {
    struct list_head head;
    spinlock_t lock;
    unsigned long nr_pages;
};

static struct page* get_lru_page(struct lru_list *lru) {
    struct page *page = NULL;

    spin_lock(&lru->lock);

    if (!list_empty(&lru->head)) {
        page = list_first_entry(&lru->head, struct page, list);
        list_del(&page->list);
        lru->nr_pages--;
    }

    spin_unlock(&lru->lock);
    return page;
}

static void add_to_lru(struct lru_list *lru, struct page *page) {
    spin_lock(&lru->lock);

    list_add_tail(&page->list, &lru->head);
    lru->nr_pages++;

    spin_unlock(&lru->lock);
}

static int page_out(struct page *page) {
    if (page->flags & PAGE_DIRTY) {
        int ret = write_to_swap(page);
        if (ret)
            return ret;
    }

    free_page(page);
    return 0;
}

LRU算法确保最不常用的页面首先被移除，从而优化内存使用并最小化性能下降。

6. TLB 管理

查找缓冲区（TLB）缓存虚拟到物理地址的转换，以加快内存访问速度。结构体 tlb_entry 表示一个 TLB 条目，而结构体 tlb_manager 管理着 TLB。flush_tlb_entry 函数使单个 TLB 条目无效，而 flush_tlb_range 函数使一系列 TLB 条目无效。

c 复制代码 
struct tlb_entry {
    virtual_addr_t vaddr;
    physical_addr_t paddr;
    unsigned long flags;
    unsigned long timestamp;
};

struct tlb_manager {
    struct tlb_entry *entries;
    unsigned int size;
    unsigned int current;
    spinlock_t lock;
};

static void flush_tlb_entry(virtual_addr_t addr) {
    asm volatile("invlpg (%0)" :: "r"(addr) : "memory");
}

static void flush_tlb_range(struct vm_area_struct *vma,
                          virtual_addr_t start,
                          virtual_addr_t end) {
    virtual_addr_t addr;

    for (addr = start; addr < end; addr += PAGE_SIZE)
        flush_tlb_entry(addr);
}

static struct tlb_entry* find_tlb_entry(struct tlb_manager *tlb,
                                      virtual_addr_t addr) {
    unsigned int i;

    for (i = 0; i < tlb->size; i++) {
        if (tlb->entries[i].vaddr == addr)
            return &tlb->entries[i];
    }

    return NULL;
}

TLB管理确保地址转换高效缓存，减少页表遍历的开销。

7. 内存分配

内存分配器管理物理内存页的分配和释放。结构体page_allocator代表分配器，它使用伙伴系统来管理空闲内存块。alloc_pages函数分配一个页块，而free_pages函数释放一个页块。

c 复制代码 
struct page_allocator {
    struct list_head free_areas[MAX_ORDER];
    spinlock_t lock;
    unsigned long *bitmap;
    unsigned long total_pages;
};

static struct page* alloc_pages(unsigned int order) {
    struct page_allocator *allocator = &global_allocator;
    struct page *page = NULL;
    int current_order;

    spin_lock(&allocator->lock);

    for (current_order = order; current_order < MAX_ORDER; current_order++) {
        if (!list_empty(&allocator->free_areas[current_order])) {
            page = list_first_entry(&allocator->free_areas[current_order],
                                  struct page, list);
            list_del(&page->list);
            break;
        }
    }

    if (page && current_order > order) {
        // Split the block
        split_page_block(allocator, page, current_order, order);
    }

    spin_unlock(&allocator->lock);
    return page;
}

static void free_pages(struct page *page, unsigned int order) {
    struct page_allocator *allocator = &global_allocator;

    spin_lock(&allocator->lock);

    // Try to merge with buddies
    while (order < MAX_ORDER - 1) {
        struct page *buddy = get_buddy_page(page, order);
        if (!page_is_buddy(buddy, order))
            break;

        list_del(&buddy->list);
        page = merge_pages(page, buddy, order);
        order++;
    }

    list_add(&page->list, &allocator->free_areas[order]);

    spin_unlock(&allocator->lock);
}

伙伴系统确保内存分配和释放高效，从而最小化碎片。

c 复制代码 
struct swap_info {
    struct file *swap_file;
    unsigned long *bitmap;
    unsigned long max_pages;
    spinlock_t lock;
    atomic_t usage;
};

static int write_to_swap(struct page *page) {
    struct swap_info *si = &swap_info_struct;
    unsigned long offset;
    int ret;

    spin_lock(&si->lock);
    offset = find_first_zero_bit(si->bitmap, si->max_pages);
    if (offset >= si->max_pages) {
        spin_unlock(&si->lock);
        return -ENOSPC;
    }

    set_bit(offset, si->bitmap);
    spin_unlock(&si->lock);

    ret = write_page_to_swap_file(si->swap_file, page, offset);
    if (ret) {
        clear_bit(offset, si->bitmap);
        return ret;
    }

    page->swap_entry = swp_entry(si->type, offset);
    return 0;
}

static int read_from_swap(struct page *page, swp_entry_t entry) {
    struct swap_info *si = &swap_info_struct;
    unsigned long offset = swp_offset(entry);
    int ret;

    if (offset >= si->max_pages)
        return -EINVAL;

    ret = read_page_from_swap_file(si->swap_file, page, offset);
    if (!ret) {
        spin_lock(&si->lock);
        clear_bit(offset, si->bitmap);
        spin_unlock(&si->lock);
    }

    return ret;
}

交换系统确保操作系统可以通过将较少使用的页面移动到磁盘来处理内存压力。

9. 性能监控

结构体vm_stats跟踪关键性能指标，如页面错误、交换活动以及内存分配成功/失败率。update_vm_stats函数更新这些指标，而print_vm_stats函数则显示它们。

c 复制代码 
struct vm_stats {
    atomic_t page_faults;
    atomic_t major_faults;
    atomic_t minor_faults;
    atomic_t swap_ins;
    atomic_t swap_outs;
    atomic_t alloc_success;
    atomic_t alloc_fail;
};

static struct vm_stats vm_stats;

static void update_vm_stats(enum vm_stat_type type) {
    switch (type) {
        case VM_STAT_PAGE_FAULT:
            atomic_inc(&vm_stats.page_faults);
            break;
        case VM_STAT_MAJOR_FAULT:
            atomic_inc(&vm_stats.major_faults);
            break;
        case VM_STAT_MINOR_FAULT:
            atomic_inc(&vm_stats.minor_faults);
            break;
        case VM_STAT_SWAP_IN:
            atomic_inc(&vm_stats.swap_ins);
            break;
        case VM_STAT_SWAP_OUT:
            atomic_inc(&vm_stats.swap_outs);
            break;
    }
}

static void print_vm_stats(void) {
    printf("Virtual Memory Statistics:\n");
    printf("Page Faults: %d\n", atomic_read(&vm_stats.page_faults));
    printf("Major Faults: %d\n", atomic_read(&vm_stats.major_faults));
    printf("Minor Faults: %d\n", atomic_read(&vm_stats.minor_faults));
    printf("Swap Ins: %d\n", atomic_read(&vm_stats.swap_ins));
    printf("Swap Outs: %d\n", atomic_read(&vm_stats.swap_outs));
    printf("Allocation Success: %d\n", atomic_read(&vm_stats.alloc_success));
    printf("Allocation Failures: %d\n", atomic_read(&vm_stats.alloc_fail));
}

这些指标为虚拟内存系统的性能提供了宝贵的见解，帮助管理员识别和解决瓶颈。

10. 总结

虚拟内存管理是现代操作系统的复杂但关键组成部分。提供的代码展示了关键组件，如页表管理、内存映射、页面故障处理和交换。通过精心设计和实现这些机制，开发人员可以创建高效且健壮的虚拟内存系统，以满足现代应用的需求。

相关推荐
Seven977 分钟前
SpringCloud带你走进微服务的世界
java·后端·spring cloud
charlie11451419137 分钟前
从0开始的操作系统手搓教程27：下一步，实现我们的用户进程
学习·架构·系统架构·操作系统·教程·手搓教程·用户线程
夕颜1111 小时前
排查问题的知识记录
后端
zhuyasen1 小时前
Go语言Viper配置详解：conf库优雅解析实战
后端·golang
佳佳_1 小时前
Spring Boot SSE 示例
spring boot·后端
Seven972 小时前
【设计模式】使用解释器模式简化复杂的语法规则
java·后端·设计模式
李长渊哦3 小时前
Spring Boot 接口延迟响应的实现与应用场景
spring boot·后端·php
Seven973 小时前
【设计模式】通过访问者模式实现分离算法与对象结构
java·后端·设计模式
Seven973 小时前
【设计模式】遍历集合的艺术：深入探索迭代器模式的无限可能
java·后端·设计模式
小杨4043 小时前
springboot框架项目应用实践五（websocket实践）
spring boot·后端·websocket
热门推荐
01如何在WPS和Word/Excel中直接使用DeepSeek功能02DeepSeek各版本说明与优缺点分析03本地部署DeepSeek教程（Mac版本）04从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑05如何本地部署AI智能体平台，带你手搓一个AI Agent06DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具07DeepSeek RAGFlow构建本地知识库系统08Windows 11 安装 Dify 完整指南 非docker环境09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10组基轨迹建模 GBTM的介绍与实现（Stata 或 R）