1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define PTE_COW (1L << 8)


#define COWCOUNTSZ   ((PHYSTOP - KERNBASE) / PGSIZE)
#define COWCOUNT(pa) (((uint64)(pa)-KERNBASE) / PGSIZE)


struct {
  struct spinlock lock;
  unsigned char count[COWCOUNTSZ];
} cowcounts;

char cowcount(uint64 pa, int flag) {
  char count = 0;

  acquire(&cowcounts.lock);
  if (flag > 0) {
    cowcounts.count[COWCOUNT(pa)]++;
  } else if (flag < 0) {
    cowcounts.count[COWCOUNT(pa)]--;
  }
  count = cowcounts.count[COWCOUNT(pa)];
  release(&cowcounts.lock);

  return count;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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);
    cowcount((uint64)r, 1);
  }

  return (void *)r;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

int uvmcopy(pagetable_t old, pagetable_t new, uint64 sz) {
  pte_t *pte;
  uint64 pa, i;
  uint flags;

  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);
    if (*pte & PTE_W) {
      *pte &= ~PTE_W;
      *pte |= PTE_COW;
    }
    cowcount(pa, 1);
    flags = PTE_FLAGS(*pte);
    if (mappages(new, i, PGSIZE, (uint64)pa, flags) != 0) {
      
      kfree((void *)pa);
      goto err;
    }
  }
  return 0;

err:
  uvmunmap(new, 0, i / PGSIZE, 1);
  return -1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void usertrap(void) {
  
  if (r_scause() == 8) {
    
  } else if (r_scause() == 15) {
    
    uint64 va = r_stval();

    if (va > p->sz) {
      printf("Error: The virtual address greater then this process's size\n");
      p->killed = 1;
    } else if (writecowpage(p->pagetable, va) != 0) {
      printf("Error: This page is not a cow-page or xv6 don't have enouth page, so not allow to write\n");
      p->killed = 1;
    }
  }
  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

int writecowpage(pagetable_t pagetable, uint64 va) {
  va = PGROUNDDOWN(va);
  pte_t *pte = walk(pagetable, va, 0);
  if (pte == 0) {
    panic("COW: fail to get pte");
  }

  uint flags = PTE_FLAGS(*pte);
  if (!(flags & PTE_COW)) {
    
    printf("COW: This page from %p is not a cow page\n", va);
    return -1;
  }

  uint64 pa = PTE2PA(*pte);
  if (cowcount(pa, 0) > 1) {
    char *mem = 0;
    flags |= PTE_W;
    flags &= ~PTE_COW;

    if ((mem = kalloc()) == 0) {
      printf("COW: fail to kalloc, kill current process\n");
      
      return -1;
    }

    memmove(mem, (char *)pa, PGSIZE);
    uvmunmap(pagetable, va, 1, 1);
    if (mappages(pagetable, va, PGSIZE, (uint64)mem, flags) != 0) {
      printf("COW: fail to mappages\n");
      kfree(mem);
      return -1;
    }
  } else {
    *pte |= PTE_W;
    *pte &= ~PTE_COW;
  }

  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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;
    }

    if (cowcount(pa0, 0) > 1) {
      writecowpage(pagetable, va0);
      pa0 = walkaddr(pagetable, va0);
    }

    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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

void kfree(void *pa) {
  struct run *r;

  if (((uint64)pa % PGSIZE) != 0 || (char *)pa < end || (uint64)pa >= PHYSTOP) {
    panic("kfree");
  }

  
  
  if (cowcount((uint64)pa, -1) != 0) {
    return;
  }

  
  memset(pa, 1, PGSIZE);

  r = (struct run *)pa;

  acquire(&kmem.lock);
  r->next = kmem.freelist;
  kmem.freelist = r;
  release(&kmem.lock);
}