22 KiB
Lab 3 Report
实验目的
- 了解虚拟内存的Page Fault异常处理实现
- 了解页替换算法在操作系统中的实现
实验内容
本次实验是在实验二的基础上，借助于页表机制和实验一中涉及的中断异常处理机制，完成Page Fault异常处理和FIFO页替换算法的实现，结合磁盘提供的缓存空间，从而能够支持虚存管理，提供一个比实际物理内存空间“更大”的虚拟内存空间给系统使用。这个实验与实际操作系统中的实现比较起来要简单，不过需要了解实验一和实验二的具体实现。实际操作系统系统中的虚拟内存管理设计与实现是相当复杂的，涉及到与进程管理系统、文件系统等的交叉访问。如果大家有余力，可以尝试完成扩展练习，实现extended clock页替换算法。
练习
对实验报告的要求：
- 基于markdown格式来完成，以文本方式为主
- 填写各个基本练习中要求完成的报告内容
- 完成实验后，请分析ucore_lab中提供的参考答案，并请在实验报告中说明你的实现与参考答案的区别
- 列出你认为本实验中重要的知识点，以及与对应的OS原理中的知识点，并简要说明你对二者的含义，关系，差异等方面的理解（也可能出现实验中的知识点没有对应的原理知识点）
- 列出你认为OS原理中很重要，但在实验中没有对应上的知识点
新增加的文件概述
lab3相对于前面的lab2，增加了虚拟内存的管理，为此lab3中增加了一些关键文件。首先对这些文件的功能做一个简单的说明，后面还会有更详细的分析。
为了进行对虚拟内存的管理，需要有相关数据结构的支持，其中的两个关键数据结构struct mm_struct， struct vma_struct以及相关的函数定义在mm/vmm.c(h)当中。通过这两个结构体，ucore模拟了一个用户进程的虚拟地址空间，并对其进行相关的测试工作。
在mm/swap.c(h)中，定义了页面置换算法的框架struct smap_manager，以及为了完成页面换入换出所需要的一些必要函数，还有相关的测试代码。
在mm/swap_fifo.c(h)中，利用struct swap_manager框架实现了先进先出置换算法FIFO（其实没有实现，需要自己编程实现）。
此外，为了将页面换入换出到外存上，需要支持对外存的读写操作，这些函数定义在了driver/ide.c当中。
虚拟内存管理
lab3中需要完成对虚拟内存的管理工作。上面已经说到，虚拟内存的管理是通过两个结构体mm_struct以及vmm_struct来实现的，下面主要阐述这两个结构体如何实现对虚拟内存的管理。
vma_struct
vma_struct是用于描述一个进程的连续虚拟内存空间的，如果一个进程有若干个相互之间不连续的虚拟内存空间，则每个虚拟内存空间都需要维护一个vma_struct结构体。vma_struct的结构如下：
// the virtual continuous memory area(vma), [vm_start, vm_end),
// addr belong to a vma means vma.vm_start<= addr <vma.vm_end
struct vma_struct {
struct mm_struct *vm_mm; // the set of vma using the same PDT
uintptr_t vm_start; // start addr of vma
uintptr_t vm_end; // end addr of vma, not include the vm_end itself
uint32_t vm_flags; // flags of vma
list_entry_t list_link; // linear list link which sorted by start addr of vma
};
可以看到，其中的vm_start以及vm_end分别描述该连续虚拟内存空间的起始虚拟地址和结束虚拟地址，一个进程的各个vma_struct之间通过vma_struct::list_link连接起来，构成了整个进程的虚拟内存空间。
mm_struct
mm_struct可以被认为是进程控制块(PCB, Process Control Block)之类的结构，一个mm_struct代表了一个进程。mm_struct的结构如下：
// the control struct for a set of vma using the same PDT
struct mm_struct {
list_entry_t mmap_list; // linear list link which sorted by start addr of vma
struct vma_struct *mmap_cache; // current accessed vma, used for speed purpose
pde_t *pgdir; // the PDT of these vma
int map_count; // the count of these vma
void *sm_priv; // the private data for swap manager
};
可以看到，mm_struct维护了一个页目录表mm_struct::pgdir，它是当前进程的页目录表，将当前进程的虚拟地址映射到物理地址上。此外，mm_struct::mmap_list其实是vma_struct的链表的头节点，通过这个mmap_list可以将当前进程的各个虚拟地址空间连接起来，并且用map_count来指示这些虚拟地址空间的数量。通过这两个数据结构，就可以实现进程的虚拟地址空间向物理地址空间的映射，如图所示：
此外，需要注意的是，mm_struct还维护了一个mmap_cache变量，这其实保存的是当前进程上一次访问的连续虚拟地址空间。根据局部性原理，该进程接下来极有可能再次访问该虚拟地址空间，从而可以在下次访问它时，可以直接获得对应的vma_struct，而不需要遍历vma_struct链表来找到它。
通过对虚拟地址空间的管理，操作系统可以完成一系列的工作，例如检查当前进程所要访问的虚拟地址是否合法。检查的方法是在该进程的虚拟地址空间查找要访问的虚拟地址，如果的确在其中，则说明该地址是一个合法的访问地址，否则就会触发页访问异常。相关的代码如下：
// find_vma - find a vma (vma->vm_start <= addr <= vma_vm_end)
struct vma_struct *
find_vma(struct mm_struct *mm, uintptr_t addr) {
struct vma_struct *vma = NULL;
if (mm != NULL) {
vma = mm->mmap_cache;
if (!(vma != NULL && vma->vm_start <= addr && vma->vm_end > addr)) {
bool found = 0;
list_entry_t *list = &(mm->mmap_list), *le = list;
while ((le = list_next(le)) != list) {
vma = le2vma(le, list_link);
if (vma->vm_start<=addr && addr < vma->vm_end) {
found = 1;
break;
}
}
if (!found) {
vma = NULL;
}
}
if (vma != NULL) {
mm->mmap_cache = vma;
}
}
return vma;
}
查找的方法就是从mm_struct::mmap_cache开始遍历整个vma_struct链表，直到找到一个对应的虚拟地址空间，或者始终没有找到。
练习一：给未被映射的地址映射上物理页（需要编程）
完成do_pgfault（mm/vmm.c）函数，给未被映射的地址映射上物理页。设置访问权限的时候需要参考页面所在VMA 的权限，同时需要注意映射物理页时需要操作内存控制结构所指定的页表，而不是内核的页表。注意：在LAB2 EXERCISE 1处填写代码。执行
make qemu
后，如果通过check_pgfault函数的测试后，会有“check_pgfault() succeeded!”的输出，表示练习1基本正确。
请在实验报告中简要说明你的设计实现过程。请回答如下问题：
- 请描述页目录项（Pag Director Entry）和页表（Page Table Entry）中组成部分对ucore实现页替换算法的潜在用处。
- 如果ucore的缺页服务例程在执行过程中访问内存，出现了页访问异常，请问硬件要做哪些事情？
页访问异常的处理
产生页访问异常的原因有很多，比如
- 目标页帧不存在，即页表项全为零，表示没有给虚拟页分配物理页帧。
- 相应的物理页帧不在内存当中，而是在磁盘的
swap分区。此时页表项的PTE_P标志位为零。 - 访问权限出错，比如试图写只读的页，或者用户进程试图访问内核的地址空间。
所有这些情况都会产生页访问异常(Page Fault, PF)，因此页访问异常的处理函数首先需要解决的问题，就是如何来分辨当前页访问异常产生的原因，从而根据不同的情况采取不同的解决方法。
如何辨别不同原因产生的页访问异常？
在发生页访问异常时，CPU会将产生异常的线性地址存储在CR2寄存器中，并且把页访问异常类型的值（简称页访问异常错误码，errorCode）保存在中断栈中。因此，可以通过这两个信息来追溯页访问异常的原因。
lab3中采用的方法是将这两个信息接合起来考虑，首先根据错误码来定位某些原因引起的页访问异常，再利用CR2寄存器中的线性地址，通过手动查当前进程的页目录表，来进一步对页访问异常进行定位。页访问异常错误的结构如下所示：
我们这里只用到了第零位和第一位，毕竟目前还没有用户态，第二位的内核访问/用户访问也无从说起。根据错误码来对页访问异常进行辨别的代码如下所示：
int
do_pgfault(struct mm_struct *mm, uint32_t error_code, uintptr_t addr) {
int ret = -E_INVAL;
//try to find a vma which include addr
struct vma_struct *vma = find_vma(mm, addr);
pgfault_num++;
//If the addr is in the range of a mm's vma?
if (vma == NULL || vma->vm_start > addr) {
cprintf("not valid addr %x, and can not find it in vma\n", addr);
goto failed;
}
//check the error_code
switch (error_code & 3) {
default:
/* error code flag : default is 3 ( W/R=1, P=1): write, present */
case 2: /* error code flag : (W/R=1, P=0): write, not present */
if (!(vma->vm_flags & VM_WRITE)) {
cprintf("do_pgfault failed: error code flag = write AND not present, but the addr's vma cannot write\n");
goto failed;
}
break;
case 1: /* error code flag : (W/R=0, P=1): read, present */
cprintf("do_pgfault failed: error code flag = read AND present\n");
goto failed;
case 0: /* error code flag : (W/R=0, P=0): read, not present */
if (!(vma->vm_flags & (VM_READ | VM_EXEC))) {
cprintf("do_pgfault failed: error code flag = read AND not present, but the addr's vma cannot read or exec\n");
goto failed;
}
}
// other operations
//......
可以看到，根据异常错误码，主要是对一些权限信息进行检查。例如当前进程是否在试图写一个不可写的页面，或者被访问的页面是否是不可读也是不可执行的，如果的确出现了权限的越界，操作系统应该终止这些操作的进行，并且直接返回错误信息。而如果所有权限信息都是正确的，发生页访问异常的原因只是当前页面不存在(P = 0)，则需要进行后续的操作，以判断是进行内存分配，还是页面置换。此时，就需要结合存储在CR2寄存器中的线性地址来进行进一步的判断了。
前面已经提到过，具体的方法就是查询当前进程的页目录表(mm_struct::pgdir)，通过得到的页表项来进行判断--如果页表项全为零，则表示不存在当前虚拟地址的映射关系，此时应该给当前的虚拟页分配一个新的页面；而如果页表项不为零，只是PTE_P为零，则表示要访问的页不在内存中，需要进行页面置换，这部分将在练习二中讨论。
给未被映射的地址映射上物理页
如果访问的地址尚未被映射到物理页，则在页访问异常的处理函数do_pgfault中，需要给该页也分配一个新的物理页帧，并且将分配的物理页的地址以及相关的权限信息填入到页表项中，这和我们前面的内容是一致的。
但是这里需要考虑特殊的情况，假如当前内存中已经没有空闲的页面了，又应该如何操作呢？在lab2中我们是直接返回错误码，然后就退出了，但是这在引入了虚拟内存地址的现在显然是不合适的。因此，此时是需要调用页面置换算法，从当前进程的页面中，选择一个置换到外存中，随后再进行存储空间的分配。然后这一系列的操作，老师都已经封装成的一个函数，见下面的代码：
uint32_t perm = PTE_U;
if (vma->vm_flags & VM_WRITE) {
perm |= PTE_W;
}
addr = ROUNDDOWN(addr, PGSIZE);
ret = -E_NO_MEM;
pte_t *ptep=NULL;
/*LAB3 EXERCISE 1: YOUR CODE*/
ptep = get_pte(mm->pgdir, addr, 1); //(1) try to find a pte, if pte's PT(Page Table) isn't existed, then create a PT.
if (*ptep == 0) {
pgdir_alloc_page(mm->pgdir, addr, perm | PTE_P); //(2) if the phy addr isn't exist, then alloc a page & map the phy addr with logical addr
}
这里的pgdir_alloc_page函数，已经实现了上面我所描述的功能。在它的内部，是调用了alloc_pages函数，其实现如下：
//alloc_pages - call pmm->alloc_pages to allocate a continuous n*PAGESIZE memory
struct Page *
alloc_pages(size_t n) {
struct Page *page=NULL;
bool intr_flag;
while (1)
{
local_intr_save(intr_flag);
{
page = pmm_manager->alloc_pages(n);
}
local_intr_restore(intr_flag);
if (page != NULL || n > 1 || swap_init_ok == 0) break;
extern struct mm_struct *check_mm_struct;
swap_out(check_mm_struct, n, 0);
}
return page;
}
可以看到，在alloc_pages函数内部，已经包含了页面置换的功能。
我的exercise1的实现，和老师的大体相同吧，但是我的肯定还是有问题的，老师的代码主要是多了很多异常的检查工作，比我的代码健壮多了，见下：
// try to find a pte, if pte's PT(Page Table) isn't existed, then create a PT.
// (notice the 3th parameter '1')
if ((ptep = get_pte(mm->pgdir, addr, 1)) == NULL) {
cprintf("get_pte in do_pgfault failed\n");
goto failed;
}
if (*ptep == 0) { // if the phy addr isn't exist, then alloc a page & map the phy addr with logical addr
if (pgdir_alloc_page(mm->pgdir, addr, perm) == NULL) {
cprintf("pgdir_alloc_page in do_pgfault failed\n");
goto failed;
}
}
练习2：补充完成基于FIFO的页面替换算法（需要编程）
完成vmm.c中的do_pgfault函数，并且在实现FIFO算法的swap_fifo.c中完成map_swappable和swap_out_victim函数。通过对swap的测试。注意：在LAB2 EXERCISE 2处填写代码。执行
make qemu
后，如果通过check_swap函数的测试后，会有check_swap() succeeded!的输出，表示练习2基本正确。
请在实验报告中简要说明你的设计实现过程。
请在实验报告中回答如下问题：
- 如果要在ucore上实现"extended clock页替换算法"请给你的设计方案，现有的
swap_manager框架是否足以支持在ucore中实现此算法？如果是，请给你的设计方案。如果不是，请给出你的新的扩展和基此扩展的设计方案。并需要回答如下问题- 需要被换出的页的特征是什么？
- 在ucore中如何判断具有这样特征的页？
- 何时进行换入和换出操作？
FIFO算法的实现
FIFO算法其实就维护一个按页面在内存中的驻留时间排序的队列。在未出现缺页异常的页面访问时，FIFO算法不需要做任何操作，因为此时访问的页面必然早就进入了内存，并且早就被添加到页面队列了。因此，只有在产生页面异常时，FIFO算法才具有实质性的操作，包括首先将队列头取出，它代表了驻留内存时间最长的页面，对应于swap_out_victim函数，将其换出到外存当中；继而将新进入的页面添加到队列尾，对应于map_swappable函数。
为了实现FIFO算法，对于每一个进程，我们都需要维护这样的一个驻留页面队列，事实上，mm_struct::sm_priv就是为了页面置换算法而预留的，由于它是一个void*类型的指针，即它可以指向任何类型，因此这个变量不只是可以用来维护FIFO的驻留页面队列，对于其他的页面置换算法，该变量也可以用来指向它们所需要维护的数据结构。
除此以外，还需要扩展struct Page结构体，需要给它增加一个新的字段，将这些驻留在内存中的页面链接起来，并且使mm_struct::sm_priv作为这个链表的头节点。这样，通过对进程进行描述的mm_struct结构体，就还可以获得该进程的页面访问信息了。
但是目前为止还存在一个问题--struct Page是对物理页帧进行描述的结构体，通过物理页帧并不能直接找到与之映射的虚拟页面，从而找不到对应于该物理页帧的页表项，而将页面换出是需要修改页表项的。为了解决这个问题，还需要给struct Page增加一个字段，指出当前映射到它的虚拟地址。这样，struct Page的结构如下所示：
/* *
* struct Page - Page descriptor structures. Each Page describes one
* physical page. In kern/mm/pmm.h, you can find lots of useful functions
* that convert Page to other data types, such as phyical address.
* */
struct Page {
int ref; // page frame's reference counter
uint32_t flags; // array of flags that describe the status of the page frame
unsigned int property; // the num of free block, used in first fit pm manager
list_entry_t page_link; // free list link
list_entry_t pra_page_link; // used for pra (page replace algorithm)
uintptr_t pra_vaddr; // used for pra (page replace algorithm)
};
到目前为止，终于可以实现FIFO算法了，对于map_swappable函数，主要功能就是将刚进入内存的页面，添加到页面队列的队尾，即页面链表的最后。而swap_out_victim函数，主要功能就是取出页面队列的队首，并且将该被置换的页面返回。具体的实现如下：
/*
* (3)_fifo_map_swappable: According FIFO PRA, we should link the most recent arrival page at the back of pra_list_head qeueue
*/
static int
_fifo_map_swappable(struct mm_struct *mm, uintptr_t addr, struct Page *page, int swap_in)
{
list_entry_t *head=(list_entry_t*) mm->sm_priv;
list_entry_t *entry=&(page->pra_page_link);
assert(entry != NULL && head != NULL);
//record the page access situlation
/*LAB3 EXERCISE 2: YOUR CODE*/
//(1)link the most recent arrival page at the back of the pra_list_head qeueue.
list_add_before(head, entry);
return 0;
}
/*
* (4)_fifo_swap_out_victim: According FIFO PRA, we should unlink the earliest arrival page in front of pra_list_head qeueue,
* then set the addr of addr of this page to ptr_page.
*/
static int
_fifo_swap_out_victim(struct mm_struct *mm, struct Page ** ptr_page, int in_tick)
{
list_entry_t *head=(list_entry_t*) mm->sm_priv;
assert(head != NULL);
assert(in_tick==0);
/* Select the victim */
/*LAB3 EXERCISE 2: YOUR CODE*/
//(1) unlink the earliest arrival page in front of pra_list_head qeueue
//(2) set the addr of addr of this page to ptr_page
list_entry_t *victim = list_next(head);
list_del(victim);
struct Page* p = le2page(victim, pra_page_link);
*ptr_page = p;
return 0;
}
相关的实现都非常简单啊，我就不多说了。
缺页异常的处理
接下来是应该补全do_pgfault函数，前面已经处理了页面不存在的情况，还剩下页面不在内存中，而是驻留在外存的情况没有处理。
这里首先需要解决一个问题，如果页面在外存中，那么又应该如何在外存中找到该页面呢？我们这里的方法是利用了“交换表项”(swap_entry)，它的结构如图所示：
它的高24位，是当前页面所驻留的磁盘扇区号，这样只要读对应的磁盘扇区，就可以将该页面从外存中换入内存了。需要说明的是，这里我们并没有利用额外的空间来存储这个“交换表项”，而是继续沿用页表项来存储这样的磁盘扇区号的。可以这样做是因为，可以通过PTE_P位的值来将页表项与“交换表项”区别开，当PTE_P位的值是1时，当前页表项就是存储内存中某个页面的起始地址以及相关的权限；当PTE_P位的值是0时，当前的页表项就成了“交换表项”，用来保存被交换到磁盘上的该页的磁盘扇区号。
这样，为了处理缺页异常，只需要调用swap_out_victim，将某一页置换出内存，再将被访问的页换入到该物理页帧的空间中，然后将其添加到页面队列的队尾，并且修改对应的页表项就可以了。对应的代码如下：
else { // if this pte is a swap entry, then load data from disk to a page with phy addr
// and call page_insert to map the phy addr with logical addr
if(swap_init_ok) {
struct Page *page=NULL;
swap_in(mm, addr, &page);
page->pra_vaddr = addr;
page_insert(mm->pgdir, page, addr, perm | PTE_P);
swap_map_swappable(mm, addr, page, 0);
}
else {
cprintf("no swap_init_ok but ptep is %x, failed\n",*ptep);
goto failed;
}
}
...
这里并没有显式地调用swap_out函数来将某一页面换出，这是因为在swap_in函数的实现中，是首先调用了前面提到的alloc_pages函数，在物理内存不够时，通过这个函数来调用swap_out以将某个页面换出。由此也可以看出，我们采用的是消极的页面换出机制，即只有在内存空间不足时，才执行页面的换出；在还有剩余的内存空间时，直接给要换入的页面分配新的内存空间，并不执行换出操作。