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. 总结

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

相关推荐
程序员爱钓鱼2 小时前
Python编程实战 · 基础入门篇 | 元组（tuple）
后端·python·ipython
程序员爱钓鱼2 小时前
Python编程实战 · 基础入门篇 | 列表（list）
后端·python·ipython
掘金码甲哥6 小时前
两张大图一次性讲清楚k8s调度器工作原理
后端
间彧6 小时前
Stream flatMap详解与应用实战
后端
间彧7 小时前
Java Stream流两大实战陷阱:并行流Parallel误用、List转Map时重复键异常
后端
wu～9708 小时前
Kafka底层解析：可靠性与高性能原理
分布式·kafka·操作系统
tan180°8 小时前
Linux网络UDP(10)
linux·网络·后端·udp·1024程序员节
正经教主9 小时前
【Trae+AI】和Trae学习搭建App_03：后端API开发原理与实践（已了解相关知识的可跳过）
后端·express
shepherd1269 小时前
破局延时任务(上)：为什么选择Spring Boot + DelayQueue来自研分布式延时队列组件？
java·spring boot·后端·1024程序员节
开心-开心急了9 小时前
Flask入门教程——李辉 第5章: 数据库 关键知识梳理
笔记·后端·python·flask·1024程序员节
热门推荐
01BongoCat - 跨平台键盘猫动画工具02GitHub 镜像站点03UV安装并设置国内源04Linux下V2Ray安装配置指南05jdk21下载、安装（Windows、Linux、macOS）06GitLab 零基础入门指南：从安装到项目管理全流程07NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南08KGG转MP3工具|非KGM文件|解密音频09Labelme从安装到标注：零基础完整指南10在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）