第五章：内存虚拟化 - 内核重映射实现之二：MemorySet - 《rCore 手册（rCore tutorial doc）》

内核重映射实现之二：MemorySet

内核重映射实现之二：MemorySet

代码

我们实现了页表，但是好像还不足以应对内核重映射的需求。我们要对多个段分别进行不同的映射，而页表只允许我们每次插入一对从虚拟页到物理页帧的映射。

总体抽象

为此，我们另设计几种数据结构来抽象这个过程：

在虚拟内存中，每个 MemoryArea 描述一个段，每个段单独映射到物理内存；MemorySet 中则存储所有的 MemoryArea 段，相比巨大的虚拟内存空间，由于它含有的各个段都已经映射到物理内存，它可表示一个程序独自拥有的实际可用的虚拟内存空间。PageTable 相当于一个底层接口，仅是管理映射，事实上它管理了 MemorySet 中所有 MemoryArea 的所有映射。

MemoryArea

我们刻意将不同的段分为不同的 MemoryArea ，说明它们映射到物理内存的方式可以是不同的：

我们则使用 MemoryHandler 来描述映射行为的不同。不同的类型的 MemoryArea，会使用不同的 MemoryHandler ，而他们会用不同的方式调用 PageTable 提供的底层接口进行映射，因此导致了最终映射行为的不同。

下面我们看一下这些类是如何实现的。

MemoryAttr

首先是用来修改 PageEntry (我们的页表映射默认将权限设为 R|W|X ，需要修改) 的类 MemoryAttr：

// src/memory/memory_set/attr.rs
......
pub struct MemoryAttr {
    user : bool,    // 用户态是否可访问
    readonly : bool,    // 是否只读
    execute : bool,      // 是否可执行
}
impl MemoryAttr {
    // 默认 用户态不可访问；可写；不可执行；
    pub fn new() -> Self{
        MemoryAttr {
            user : false,
            readonly : false,
            execute : false,
        }
    }
    // 根据要求修改所需权限
    pub fn set_user(mut self) -> Self {
        self.user = true;  self
    }
    pub fn set_readonly(mut self) -> Self {
        self.readonly = true;  self
    }
    pub fn set_execute(mut self) -> Self {
        self.execute = true;   self
    }
    // 根据设置的权限要求修改页表项
    pub fn apply(&self, entry : &mut PageEntry) {
        entry.set_present(true);    // 设置页表项存在
        entry.set_user(self.user);  // 设置用户态访问权限
        entry.set_writable(!self.readonly); //设置写权限
        entry.set_execute(self.execute); //设置可执行权限
    }
}

MemoryHandler

然后是会以不同方式调用 PageTable 接口的 MemoryHandler：

// src/memory/memory_set/handler.rs
......
// 定义 MemoryHandler trait
pub trait MemoryHandler: Debug + 'static {
    fn box_clone(&self) -> Box<dyn MemoryHandler>;
    // 需要实现 map, unmap 两函数,不同的接口实现者会有不同的行为
    // 注意 map 并没有 pa 作为参数，因此接口实现者要给出该虚拟页要映射到哪个物理页
    fn map(&self, pt: &mut PageTableImpl, va: usize, attr: &MemoryAttr);
    fn unmap(&self, pt: &mut PageTableImpl, va: usize);
}
......
// 下面给出两种实现 Linear, ByFrame
// 线性映射 Linear: 也就是我们一直在用的带一个偏移量的形式
// 有了偏移量，我们就知道虚拟页要映射到哪个物理页了
pub struct Linear { offset: usize }
impl Linear {
    pub fn new(off: usize) -> Self { Linear { offset: off, }  }
}
impl MemoryHandler for Linear {
    fn box_clone(&self) -> Box<dyn MemoryHandler> { Box::new(self.clone()) }
    fn map(&self, pt: &mut PageTableImpl, va: usize, attr: &MemoryAttr) {
        // 映射到 pa = va - self.offset
        // 同时还使用 attr.apply 修改了原先默认为 R|W|X 的权限
        attr.apply(pt.map(va, va - self.offset));
    }
    fn unmap(&self, pt: &mut PageTableImpl, va: usize) { pt.unmap(va); }
}
// ByFrame: 不知道映射到哪个物理页帧
// 那我们就分配一个新的物理页帧，可以保证不会产生冲突
pub struct ByFrame;
impl ByFrame {
    pub fn new() -> Self { ByFrame {} }
}
impl MemoryHandler for ByFrame {
    fn box_clone(&self) -> Box<dyn MemoryHandler> {
        Box::new(self.clone())
    }
    fn map(&self, pt: &mut PageTableImpl, va: usize, attr: &MemoryAttr) {
        // 分配一个物理页帧作为映射目标
        let frame = alloc_frame().expect("alloc_frame failed!");
        let pa = frame.start_address().as_usize();
        attr.apply(pt.map(va, pa));
    }
    fn unmap(&self, pt: &mut PageTableImpl, va: usize) {
        pt.unmap(va);
    }
}

接着，是描述一个段的 MemoryArea。

// src/memory/memory_set/area.rs
// 声明中给出所在的虚拟地址区间: [start, end)
// 使用的 MemoryHandler： handler
// 页表项的权限： attr
pub struct MemoryArea {
    start : usize,
    end : usize,
    handler : Box<dyn MemoryHandler>,
    attr : MemoryAttr,
}
impl MemoryArea {
    // 同样是插入、删除映射
    // 遍历虚拟地址区间包含的所有虚拟页，依次利用 handler 完成映射插入/删除
    pub fn map(&self, pt : &mut PageTableImpl) {
        // 使用自己定义的迭代器进行遍历，实现在 src/memory/paging.rs 中
        // 放在下面
        for page in PageRange::new(self.start, self.end) {
            self.handler.map(pt, page, &self.attr);
        }
    }
    fn unmap(&self, pt : &mut PageTableImpl) {
        for page in PageRange::new(self.start, self.end) {
            self.handler.unmap(pt, page);
        }
    }
    // 是否与另一虚拟地址区间相交
    pub fn is_overlap_with(&self, start_addr : usize, end_addr : usize) -> bool {
        let p1 = self.start / PAGE_SIZE;
        let p2 = (self.end - 1) / PAGE_SIZE + 1;
        let p3 = start_addr / PAGE_SIZE;
        let p4 = (end_addr - 1) / PAGE_SIZE + 1;
        !((p1 >= p4) || (p2 <= p3))
    }
    // 初始化
    pub fn new(start_addr : usize, end_addr : usize, handler : Box<dyn MemoryHandler>, attr : MemoryAttr) -> Self {
        MemoryArea{
            start : start_addr,
            end : end_addr,
            handler : handler,
            attr : attr,
        }
    }
}

MemorySet

最后，则是最高层的 MemorySet ，它描述一个实际可用的虚拟地址空间以供程序使用。

// src/memory/memory_set/mod.rs
pub struct MemorySet {
    // 管理有哪些 MemoryArea
    areas: Vec<MemoryArea>,
    // 使用页表来管理其所有的映射
    page_table: PageTableImpl,
}
impl MemorySet {
    pub fn push(&mut self, start: usize, end: usize, attr: MemoryAttr, handler: impl MemoryHandler) {
        // 加入一个新的给定了 handler 以及 attr 的 MemoryArea
        // 合法性测试
        assert!(start <= end, "invalid memory area!");
        // 整段虚拟地址空间均未被占据
        assert!(self.test_free_area(start, end), "memory area overlap!");
        // 构造 MemoryArea
        let area = MemoryArea::new(start, end, Box::new(handler), attr);
        // 更新本 MemorySet 的映射
        area.map(&mut self.page_table);
        // 更新本 MemorySet 的 MemoryArea 集合
        self.areas.push(area);
    }
    fn test_free_area(&self, start: usize, end: usize) -> bool {
        // 迭代器的基本应用
        self.areas
            .iter()
            .find(|area| area.is_overlap_with(start, end))
            .is_none()
    }
    // 将 CPU 所在的虚拟地址空间切换为本 MemorySet
    pub unsafe fn activate(&self) {
        // 这和切换到存储其全部映射的页表是一码事
        self.page_table.activate();
    }
}

事实上，在内核中运行的所有程序都离不开内核的支持，所以必须要能够访问内核的代码和数据；同时，为了保证任何时候我们都可以修改页表，我们需要物理内存的映射一直存在。因此，在一个 MemorySet 初始化时，我们就要将上述这些段加入进去。

// src/memory/memory_set/mod.rs
impl MemorySet {
    ...
    pub fn new() -> Self {
        let mut memory_set = MemorySet {
            areas: Vec::new(),
            page_table: PageTableImpl::new_bare(),
        };
        // 插入内核各段以及物理内存段
        memory_set.map_kernel_and_physical_memory();
        memory_set
    }
    pub fn map_kernel_and_physical_memory(&mut self) {
        extern "C" {
            fn stext();
            fn etext();
            fn srodata();
            fn erodata();
            fn sdata();
            fn edata();
            fn sbss();
            fn ebss();
            fn end();
        }
        let offset = PHYSICAL_MEMORY_OFFSET;
        // 各段全部采用偏移量固定的线性映射
        // .text R|X
        self.push(
            stext as usize,
            etext as usize,
            MemoryAttr::new().set_readonly().set_execute(),
            Linear::new(offset),
        );
        // .rodata R
        self.push(
            srodata as usize,
            erodata as usize,
            MemoryAttr::new().set_readonly(),
            Linear::new(offset),
        );
        // .data R|W
        self.push(
            sdata as usize,
            edata as usize,
            MemoryAttr::new(),
            Linear::new(offset)
        );
        // .bss R|W
        self.push(
            sbss as usize,
            ebss as usize,
            MemoryAttr::new(),
            Linear::new(offset)
        );
        // 物理内存 R|W
        self.push(
            (end as usize / PAGE_SIZE + 1) * PAGE_SIZE,
            access_pa_via_va(PHYSICAL_MEMORY_END),
            MemoryAttr::new(),
            Linear::new(offset),
        );
    }
}

这样，有了上面的抽象和对应实现，我们就可以根据 OS kernel 这个程序中不同段的属性建立不同属性的页表项，更加精确地体系了 OS kernel 各个部分的被访问特征。具体如何建立，请看下一节。