task

cow的目标就是延迟分配，并且直到必须要复制的时候才会分配物理内存

cow的fork只为child创造了一个页表，其中的PTE指向了父进程的物理页面cow的fork将父进程和孩子进程的用户态的PTE都标记为不可写
当某个进程想要去写一个cow的页面时，cpu会执行一个页错误
1. 内核的页错误处理函数会检测到
2. 然后为错误的进程分配一个物理页面
3. 将原始的页面拷贝的新的页面，
4. 修改错误进程的PTE指向新的页面，并在PTE中标记为可写
5. 当页面处理函数返回的时候，用户进程能够正常地写了
一个物理页面只有在所有的引用都消失时，才会被free掉

如果能够通过cowtest和usertest，则通过这个lab

hints

用PTE中的RSWbits来标记这个页面是否是cow
一个对页表的标志有帮助的宏和定义在kernel/riscv.h
如果一个cow的页错误发生了，并且没有多余的内存，这个进程应该被杀死

思路

按照实验文档推荐的路线来即可，但是还是有一些小坑的

页引用计数

这一部分实验文档没有给出非常具体的指导~~没有直接把饭喂到我这种菜鸡嘴里~~，所以有许多具体实现的方式

我是将这一部分的代码全部放在了kalloc.c文件中。可以想一下，我们什么时候会用到这个页引用计数呢？

当我们free一个页面的时候，会使用
当我们kalloc一个页面的时候，我们需要给它初始化为1
当我们遇到某个cow的页面被写的时候，需要重新分配并更改引用计数
当我们fork的时候，需要增加这个引用计数

前2点已经足够让我们把相关的定义放到kalloc.c文件里，这里用到了一些宏，主要是为了后面使用其他方便

这里我们的count数组的大小，是由PHYSTOP和KERNBASE计算出来的，一个是可以分配的物理内存的最大值，一个是最小值。因此将它们相减，再除以页面的大小，就可以得到页数，也就是数组的大小。

通过PA2INDEX可以快速得出当前地址位于数组的哪个下标

下面的四个宏分别是求出这个地址对应的页面的引用计数值，以及初始化，减1和加1的操作

在对这个数组操作时，要用lock将其夹住

// KERNBASE 不是 end
#define PA2INDEX(pa) ((((uint64)pa) - KERNBASE) / PGSIZE)struct {struct spinlock lock;int count[PA2INDEX(PHYSTOP)];
} ref_count;#define PA2REFCOUNT(pa) (ref_count.count[PA2INDEX(pa)])
#define PAINITRC(pa) (ref_count.count[PA2INDEX(pa)] = 1)
#define PADEC(pa) (ref_count.count[PA2INDEX(pa)]--)
#define PAINC(pa) (ref_count.count[PA2INDEX(pa)]++)

接下来分别在kinit，kfree和kalloc时将引用计数的逻辑加入

kinit比较简单，初始化这个锁就行了

void kinit() {initlock(&kmem.lock, "kmem");// 初始化计数数组的锁initlock(&ref_count.lock, "ref_count");freerange(end, (void *)PHYSTOP);
}

kfree只在这个页面引用计数为0时才真的free它。按理说，应该是用==0去判断，可是这样的话xv6都启动不起来。找出问题了，因为最开始freerange的时候，引用计数没有值，你走来就给它减1，就是负数了，结果导致所有的页面都没有放到freelist中。

void kfree(void *pa) {struct run *r;if (((uint64)pa % PGSIZE) != 0 || (char *)pa < end || (uint64)pa >= PHYSTOP)panic("kfree");acquire(&ref_count.lock);PADEC(pa);if (PA2REFCOUNT(pa) <= 0) {// Fill with junk to catch dangling refs.memset(pa, 1, PGSIZE);r = (struct run *)pa;acquire(&kmem.lock);r->next = kmem.freelist;kmem.freelist = r;release(&kmem.lock);}// 必须放在最后，防止被释放两次release(&ref_count.lock);
}

kalloc只需要一行，将对应的值初始化为1即可

void *
kalloc(void) {struct run *r;acquire(&kmem.lock);r = kmem.freelist;if (r)kmem.freelist = r->next;release(&kmem.lock);if (r) {memset((char *)r, 5, PGSIZE); // fill with junk// 初始化这个物理地址的引用数PAINITRC((char *)r);}return (void *)r;
}

同时，我们还需要两个函数，一个是在cow被写时用来分配一个物理页面并将原来的页面拷贝过去，一个是在fork的时候增加引用计数，分别叫做kcopy和kinc

// 发生了对cow页面的写操作，必须要分配一个物理页面了
void *kcopy(void *pa) {acquire(&ref_count.lock);// 如果自己就是唯一的拥有者了，那么就不用申请页面，直接用就完事了if (PA2REFCOUNT(pa) == 1) {release(&ref_count.lock);return pa;}void *npa = kalloc();// 没有可用页面，返回0if (npa == 0) {release(&ref_count.lock);return NULL;}// 将当前页面的计数减1，并复制新的页面PADEC(pa);memmove(npa, pa, PGSIZE);release(&ref_count.lock);return npa;
}

// 给某个页面增加一个计数
void kinc(void *pa) {acquire(&ref_count.lock);PAINC(pa);release(&ref_count.lock);
}

uvmcopy

fork时，不真正分配，只增加引用计数，并修改标志位

int uvmcopy(pagetable_t old, pagetable_t new, uint64 sz) {pte_t *pte;uint64 pa, i;uint flags;// char *mem;for (i = 0; i < sz; i += PGSIZE) {if ((pte = walk(old, i, 0)) == 0)panic("uvmcopy: pte should exist");if ((*pte & PTE_V) == 0)panic("uvmcopy: page not present");pa = PTE2PA(*pte);flags = PTE_FLAGS(*pte);// 如果这个页面可写，才需要设置成cow，因为后面会直接给其write的权利，所以如果只读，那就不用cow了if (*pte & PTE_W) {*pte |= PTE_C;*pte &= ~PTE_W;}// 更新flags，下面mappages要用flags = PTE_FLAGS(*pte);// 将父进程的物理地址映射到子进程的页表上if (mappages(new, i, PGSIZE, (uint64)pa, flags) != 0) {goto err;}// 增加引用计数kinc((void *)pa);}return 0;err:uvmunmap(new, 0, i / PGSIZE, 1);return -1;
}

usertrap

对页错误的trap进行捕获，然后排除以下情况

地址本来就不合法，超出了最大范围，这可能引起页错误
如果这一页的W权限位为1，说明不是因为不能写导致的trap，那我们也处理不了
如果这一页的V标志位为0，那也不是我们能处理的
同样，如果这一页不是COW页，那我们也处理不了

第2，3,4在xv6里面其实是有点重复的判断，但是小心点反正不会出bug

还有一个细节就是在uvmunmap的时候，dofree必须是0，因为我们在kcopy的时候已经给这个页面的引用减1了，如果dofree=1，待会还得减1，就会出bug

    } else if ((which_dev = devintr()) != 0) {// ok} else if (r_scause() == 12 || r_scause() == 13 || r_scause() == 15) {// 地址越界if (r_stval() >= p->sz) {p->killed = 1;} else {// 分配新的一页pte_t *pte = walk(p->pagetable, r_stval(), 0);// 不存在，或者不是cow页if ((*pte & PTE_W) != 0 || ((*pte) & PTE_V) == 0 || ((*pte) & PTE_C) == 0) {p->killed = 1;} else {void *pa = (void *)PTE2PA(*pte);void *npa = kcopy(pa);// 申请内存失败if (npa == 0) {p->killed = 1;} else {// 已经获得了一块属于自己的物理内存，将地址和标志位更新到页表中int flag = PTE_FLAGS(*pte);flag |= PTE_W;flag &= ~PTE_C;uvmunmap(p->pagetable, PGROUNDDOWN(r_stval()), 1, 0);mappages(p->pagetable, PGROUNDDOWN(r_stval()), PGSIZE, (uint64)npa, flag);}}}}

copyout

整体逻辑和trap捕获差不多

int copyout(pagetable_t pagetable, uint64 dstva, char *src, uint64 len) {uint64 n, va0, pa0;while (len > 0) {va0 = PGROUNDDOWN(dstva);pa0 = walkaddr(pagetable, va0);if (pa0 == 0)return -1;// 到了这里，肯定是一个合法的值了，但是不一定可以写啊pte_t *pte = walk(pagetable, va0, 0);// 如果是cow并且不可以写if (*pte & PTE_C && !(*pte & PTE_W)) {// 请求获得一块物理内存void *npa = kcopy((void *)pa0);if (npa == 0) {return -1;}// 这个物理内存可用int flag = PTE_FLAGS(*pte);flag &= ~PTE_C;flag |= PTE_W;uvmunmap(pagetable, va0, 1, 0);mappages(pagetable, va0, PGSIZE, (uint64)npa, flag);pa0 = (uint64)npa;}n = PGSIZE - (dstva - va0);if (n > len)n = len;memmove((void *)(pa0 + (dstva - va0)), src, n);len -= n;src += n;dstva = va0 + PGSIZE;}return 0;
}