void
kmm_pgfault(struct trapframe *tf)
{
// uint64_t err = tf->tf_err;
uintptr_t addr = rcr2();
if (addr >= PBASE && addr < PBASE + PSIZE)
{
pgd_t *pgd = KADDR_DIRECT(PTE_ADDR(rcr3()));
pud_t *pud;
pmd_t *pmd;
pte_t *ptd;
/* PHYSICAL ADDRRESS ACCESSING */
if (last_pgd != NULL)
{
pud = KADDR_DIRECT(PGD_ADDR(last_pgd[PGX(last_addr)]));
pmd = KADDR_DIRECT(PUD_ADDR(pud[PUX(last_addr)]));
ptd = KADDR_DIRECT(PMD_ADDR(pmd[PMX(last_addr)]));
ptd[PTX(last_addr)] = 0;
if (ptd == temp_ptd)
{
pmd[PUX(last_addr)] = 0;
if (pmd == temp_pmd)
{
pud[PUX(last_addr)] = 0;
if (pud == temp_pud)
last_pgd[PGX(last_addr)] = 0;
}
if (last_pgd == pgd)
{
invlpg((void *)last_addr);
}
}
}
if (pgd[PGX(last_addr)] == 0)
pgd[PGX(last_addr)] = PADDR_DIRECT(temp_pud) | PTE_W | PTE_P;
pud = KADDR_DIRECT(PGD_ADDR(pgd[PGX(last_addr)]));
if (pud[PUX(last_addr)] == 0)
pud[PUX(last_addr)] = PADDR_DIRECT(temp_pmd) | PTE_W | PTE_P;
pmd = KADDR_DIRECT(PUD_ADDR(pud[PUX(last_addr)]));
if (pmd[PMX(last_addr)] == 0)
pmd[PMX(last_addr)] = PADDR_DIRECT(temp_ptd) | PTE_W | PTE_P;
ptd = KADDR_DIRECT(PMD_ADDR(pmd[PMX(last_addr)]));
ptd[PTX(last_addr)] = PADDR_DIRECT(addr) | PTE_W | PTE_P;
last_pgd = pgd;
last_addr = addr;
/* XXX? */
// invlpg((void *)addr);
}
}
// check_pgfault - check correctness of pgfault handler
static void check_pgfault(void)
{
#ifdef UCONFIG_CHECK_PGFAULT
kprintf("starting check_pgfault()\n");
size_t nr_used_pages_store = nr_used_pages();
size_t slab_allocated_store = slab_allocated();
check_mm_struct = mm_create();
assert(check_mm_struct != NULL);
struct mm_struct *mm = check_mm_struct;
pgd_t *pgdir = mm->pgdir = init_pgdir_get();
assert(pgdir[PGX(TEST_PAGE)] == 0);
struct vma_struct *vma =
vma_create(TEST_PAGE, TEST_PAGE + PTSIZE, VM_WRITE);
assert(vma != NULL);
insert_vma_struct(mm, vma);
uintptr_t addr = TEST_PAGE + 0x100;
assert(find_vma(mm, addr) == vma);
int i, sum = 0;
for (i = 0; i < 100; i++) {
*(char *)(addr + i) = i;
sum += i;
}
for (i = 0; i < 100; i++) {
sum -= *(char *)(addr + i);
}
assert(sum == 0);
page_remove(pgdir, ROUNDDOWN(addr, PGSIZE));
#if PMXSHIFT != PUXSHIFT
free_page(pa2page(PMD_ADDR(*get_pmd(pgdir, addr, 0))));
#endif
#if PUXSHIFT != PGXSHIFT
free_page(pa2page(PUD_ADDR(*get_pud(pgdir, addr, 0))));
#endif
free_page(pa2page(PGD_ADDR(*get_pgd(pgdir, addr, 0))));
pgdir[PGX(TEST_PAGE)] = 0;
mm->pgdir = NULL;
mm_destroy(mm);
check_mm_struct = NULL;
assert(nr_used_pages_store == nr_used_pages());
assert(slab_allocated_store == slab_allocated());
kprintf("check_pgfault() succeeded!\n");
#endif
}
int
set_page_data(struct DataTable *tbl, void *va, data_t id)
{
int i;
pge_t *pge = &(tbl->table)[PGX(va)];
if(! *pge) {
pthread_mutex_lock(&tbl->lock);
*pge = malloc(sizeof(pue_t) * TBLENTRIES);
memset(*pge, 0, sizeof(pue_t) * TBLENTRIES);
pthread_mutex_unlock(&tbl->lock);
}
pue_t *pue = &(*pge)[PUX(va)];
if(! *pue) {
pthread_mutex_lock(&tbl->lock);
*pue = malloc(sizeof(pme_t) * TBLENTRIES);
memset(*pue, 0, sizeof(pme_t) * TBLENTRIES);
pthread_mutex_unlock(&tbl->lock);
}
pme_t *pme = &(*pue)[PMX(va)];
if(! *pme) {
pthread_mutex_lock(&tbl->lock);
*pme = malloc(sizeof(data_t) * TBLENTRIES);
memset(*pme, 0, sizeof(data_t) * TBLENTRIES);
pthread_mutex_unlock(&tbl->lock);
}
DEBUG_LOG("set_page_data of %p from %lu to %lu", va, (*pme)[PTX(va)], id);
(*pme)[PTX(va)] = id;
return 0;
}
static void
exit_range_pgd(pgd_t *pgd, uintptr_t start, uintptr_t end) {
start = ROUNDDOWN(start, PUSIZE);
do {
pgd_t *pgdp = &pgd[PGX(start)];
if (ptep_present(pgdp)) {
exit_range_pud(KADDR(PGD_ADDR(*pgdp)));
free_page(pgd2page(*pgdp)), *pgdp = 0;
}
start += PUSIZE;
} while (start != 0 && start < end);
}
static void
unmap_range_pgd(pgd_t *pgd, uintptr_t start, uintptr_t end) {
size_t off, size;
uintptr_t la = ROUNDDOWN(start, PUSIZE);
do {
off = start - la, size = PUSIZE - off;
if (size > end - start) {
size = end - start;
}
pgd_t *pgdp = &pgd[PGX(la)];
if (ptep_present(pgdp)) {
unmap_range_pud(pgd, KADDR(PGD_ADDR(*pgdp)), la, off, off + size);
}
start += size, la += PUSIZE;
} while (start != 0 && start < end);
}
int
get_page_data(struct DataTable *tbl, void *va, data_t *id_out)
{
pge_t *pge = &(tbl->table)[PGX(va)];
if(! *pge) goto get_fault;
pue_t *pue = &(*pge)[PUX(va)];
if(! *pue) goto get_fault;
pme_t *pme = &(*pue)[PMX(va)];
if(! *pme) goto get_fault;
*id_out = (*pme)[PTX(va)];
return 0;
get_fault:
if (tbl->do_get_faults)
return -E_NO_ENTRY;
*id_out = 0;
return 0;
}
// check_swap - check the correctness of swap & page replacement algorithm
static void
check_swap(void) {
size_t nr_used_pages_store = nr_used_pages();
size_t slab_allocated_store = slab_allocated();
size_t offset;
for (offset = 2; offset < max_swap_offset; offset ++) {
mem_map[offset] = 1;
}
struct mm_struct *mm = mm_create();
assert(mm != NULL);
extern struct mm_struct *check_mm_struct;
assert(check_mm_struct == NULL);
check_mm_struct = mm;
pgd_t *pgdir = mm->pgdir = init_pgdir_get();
assert(pgdir[PGX(TEST_PAGE)] == 0);
struct vma_struct *vma = vma_create(TEST_PAGE, TEST_PAGE + PTSIZE, VM_WRITE | VM_READ);
assert(vma != NULL);
insert_vma_struct(mm, vma);
struct Page *rp0 = alloc_page(), *rp1 = alloc_page();
assert(rp0 != NULL && rp1 != NULL);
pte_perm_t perm;
ptep_unmap (&perm);
ptep_set_u_write(&perm);
int ret = page_insert(pgdir, rp1, TEST_PAGE, perm);
assert(ret == 0 && page_ref(rp1) == 1);
page_ref_inc(rp1);
ret = page_insert(pgdir, rp0, TEST_PAGE, perm);
assert(ret == 0 && page_ref(rp1) == 1 && page_ref(rp0) == 1);
// check try_alloc_swap_entry
swap_entry_t entry = try_alloc_swap_entry();
assert(swap_offset(entry) == 1);
mem_map[1] = 1;
assert(try_alloc_swap_entry() == 0);
// set rp1, Swap, Active, add to hash_list, active_list
swap_page_add(rp1, entry);
swap_active_list_add(rp1);
assert(PageSwap(rp1));
mem_map[1] = 0;
entry = try_alloc_swap_entry();
assert(swap_offset(entry) == 1);
assert(!PageSwap(rp1));
// check swap_remove_entry
assert(swap_hash_find(entry) == NULL);
mem_map[1] = 2;
swap_remove_entry(entry);
assert(mem_map[1] == 1);
swap_page_add(rp1, entry);
swap_inactive_list_add(rp1);
swap_remove_entry(entry);
assert(PageSwap(rp1));
assert(rp1->index == entry && mem_map[1] == 0);
// check page_launder, move page from inactive_list to active_list
assert(page_ref(rp1) == 1);
assert(nr_active_pages == 0 && nr_inactive_pages == 1);
assert(list_next(&(inactive_list.swap_list)) == &(rp1->swap_link));
page_launder();
assert(nr_active_pages == 1 && nr_inactive_pages == 0);
assert(PageSwap(rp1) && PageActive(rp1));
entry = try_alloc_swap_entry();
assert(swap_offset(entry) == 1);
assert(!PageSwap(rp1) && nr_active_pages == 0);
assert(list_empty(&(active_list.swap_list)));
// set rp1 inactive again
assert(page_ref(rp1) == 1);
swap_page_add(rp1, 0);
assert(PageSwap(rp1) && swap_offset(rp1->index) == 1);
swap_inactive_list_add(rp1);
mem_map[1] = 1;
assert(nr_inactive_pages == 1);
page_ref_dec(rp1);
size_t count = nr_used_pages();
swap_remove_entry(entry);
assert(nr_inactive_pages == 0 && nr_used_pages() == count - 1);
// check swap_out_mm
pte_t *ptep0 = get_pte(pgdir, TEST_PAGE, 0), *ptep1;
assert(ptep0 != NULL && pte2page(*ptep0) == rp0);
ret = swap_out_mm(mm, 0);
assert(ret == 0);
ret = swap_out_mm(mm, 10);
assert(ret == 1 && mm->swap_address == TEST_PAGE + PGSIZE);
ret = swap_out_mm(mm, 10);
assert(ret == 0 && *ptep0 == entry && mem_map[1] == 1);
assert(PageDirty(rp0) && PageActive(rp0) && page_ref(rp0) == 0);
assert(nr_active_pages == 1 && list_next(&(active_list.swap_list)) == &(rp0->swap_link));
// check refill_inactive_scan()
refill_inactive_scan();
assert(!PageActive(rp0) && page_ref(rp0) == 0);
assert(nr_inactive_pages == 1 && list_next(&(inactive_list.swap_list)) == &(rp0->swap_link));
page_ref_inc(rp0);
page_launder();
assert(PageActive(rp0) && page_ref(rp0) == 1);
assert(nr_active_pages == 1 && list_next(&(active_list.swap_list)) == &(rp0->swap_link));
page_ref_dec(rp0);
refill_inactive_scan();
assert(!PageActive(rp0));
// save data in rp0
int i;
for (i = 0; i < PGSIZE; i ++) {
((char *)page2kva(rp0))[i] = (char)i;
}
page_launder();
assert(nr_inactive_pages == 0 && list_empty(&(inactive_list.swap_list)));
assert(mem_map[1] == 1);
rp1 = alloc_page();
assert(rp1 != NULL);
ret = swapfs_read(entry, rp1);
assert(ret == 0);
for (i = 0; i < PGSIZE; i ++) {
assert(((char *)page2kva(rp1))[i] == (char)i);
}
// page fault now
*(char *)(TEST_PAGE) = 0xEF;
rp0 = pte2page(*ptep0);
assert(page_ref(rp0) == 1);
assert(PageSwap(rp0) && PageActive(rp0));
entry = try_alloc_swap_entry();
assert(swap_offset(entry) == 1 && mem_map[1] == SWAP_UNUSED);
assert(!PageSwap(rp0) && nr_active_pages == 0 && nr_inactive_pages == 0);
// clear accessed flag
assert(rp0 == pte2page(*ptep0));
assert(!PageSwap(rp0));
ret = swap_out_mm(mm, 10);
assert(ret == 0);
assert(!PageSwap(rp0) && ptep_present(ptep0));
// change page table
ret = swap_out_mm(mm, 10);
assert(ret == 1);
assert(*ptep0 == entry && page_ref(rp0) == 0 && mem_map[1] == 1);
count = nr_used_pages();
refill_inactive_scan();
page_launder();
assert(count - 1 == nr_used_pages());
ret = swapfs_read(entry, rp1);
assert(ret == 0 && *(char *)(page2kva(rp1)) == (char)0xEF);
free_page(rp1);
// duplictate *ptep0
ptep1 = get_pte(pgdir, TEST_PAGE + PGSIZE, 0);
assert(ptep1 != NULL && ptep_invalid(ptep1));
swap_duplicate(*ptep0);
ptep_copy(ptep1, ptep0);
mp_tlb_invalidate (pgdir, TEST_PAGE + PGSIZE);
// page fault again
// update for copy on write
*(char *)(TEST_PAGE + 1) = 0x88;
*(char *)(TEST_PAGE + PGSIZE) = 0x8F;
*(char *)(TEST_PAGE + PGSIZE + 1) = 0xFF;
assert(pte2page(*ptep0) != pte2page(*ptep1));
assert(*(char *)(TEST_PAGE) == (char)0xEF);
assert(*(char *)(TEST_PAGE + 1) == (char)0x88);
assert(*(char *)(TEST_PAGE + PGSIZE) == (char)0x8F);
assert(*(char *)(TEST_PAGE + PGSIZE + 1) == (char)0xFF);
rp0 = pte2page(*ptep0);
rp1 = pte2page(*ptep1);
assert(!PageSwap(rp0) && PageSwap(rp1) && PageActive(rp1));
entry = try_alloc_swap_entry();
assert(!PageSwap(rp0) && !PageSwap(rp1));
assert(swap_offset(entry) == 1 && mem_map[1] == SWAP_UNUSED);
assert(list_empty(&(active_list.swap_list)));
assert(list_empty(&(inactive_list.swap_list)));
ptep_set_accessed(&perm);
page_insert(pgdir, rp0, TEST_PAGE + PGSIZE, perm);
// check swap_out_mm
*(char *)(TEST_PAGE) = *(char *)(TEST_PAGE + PGSIZE) = 0xEE;
mm->swap_address = TEST_PAGE + PGSIZE * 2;
ret = swap_out_mm(mm, 2);
assert(ret == 0);
assert(ptep_present(ptep0) && ! ptep_accessed(ptep0));
assert(ptep_present(ptep1) && ! ptep_accessed(ptep1));
ret = swap_out_mm(mm, 2);
assert(ret == 2);
assert(mem_map[1] == 2 && page_ref(rp0) == 0);
refill_inactive_scan();
page_launder();
assert(mem_map[1] == 2 && swap_hash_find(entry) == NULL);
// check copy entry
swap_remove_entry(entry);
ptep_unmap(ptep1);
assert(mem_map[1] == 1);
swap_entry_t store;
ret = swap_copy_entry(entry, &store);
assert(ret == -E_NO_MEM);
mem_map[2] = SWAP_UNUSED;
ret = swap_copy_entry(entry, &store);
assert(ret == 0 && swap_offset(store) == 2 && mem_map[2] == 0);
mem_map[2] = 1;
ptep_copy(ptep1, &store);
assert(*(char *)(TEST_PAGE + PGSIZE) == (char)0xEE && *(char *)(TEST_PAGE + PGSIZE + 1)== (char)0x88);
*(char *)(TEST_PAGE + PGSIZE) = 1, *(char *)(TEST_PAGE + PGSIZE + 1) = 2;
assert(*(char *)TEST_PAGE == (char)0xEE && *(char *)(TEST_PAGE + 1) == (char)0x88);
ret = swap_in_page(entry, &rp0);
assert(ret == 0);
ret = swap_in_page(store, &rp1);
assert(ret == 0);
assert(rp1 != rp0);
// free memory
swap_list_del(rp0), swap_list_del(rp1);
swap_page_del(rp0), swap_page_del(rp1);
assert(page_ref(rp0) == 1 && page_ref(rp1) == 1);
assert(nr_active_pages == 0 && list_empty(&(active_list.swap_list)));
assert(nr_inactive_pages == 0 && list_empty(&(inactive_list.swap_list)));
for (i = 0; i < HASH_LIST_SIZE; i ++) {
assert(list_empty(hash_list + i));
}
page_remove(pgdir, TEST_PAGE);
page_remove(pgdir, (TEST_PAGE + PGSIZE));
#if PMXSHIFT != PUXSHIFT
free_page(pa2page(PMD_ADDR(*get_pmd(pgdir, TEST_PAGE, 0))));
#endif
#if PUXSHIFT != PGXSHIFT
free_page(pa2page(PUD_ADDR(*get_pud(pgdir, TEST_PAGE, 0))));
#endif
free_page(pa2page(PGD_ADDR(*get_pgd(pgdir, TEST_PAGE, 0))));
pgdir[PGX(TEST_PAGE)] = 0;
mm->pgdir = NULL;
mm_destroy(mm);
check_mm_struct = NULL;
assert(nr_active_pages == 0 && nr_inactive_pages == 0);
for (offset = 0; offset < max_swap_offset; offset ++) {
mem_map[offset] = SWAP_UNUSED;
}
assert(nr_used_pages_store == nr_used_pages());
assert(slab_allocated_store == slab_allocated());
kprintf("check_swap() succeeded.\n");
}
pgd_t *
get_pgd(pgd_t *pgdir, uintptr_t la, bool create) {
return &pgdir[PGX(la)];
}
static void
check_mm_swap(void) {
size_t nr_free_pages_store = nr_free_pages();
size_t slab_allocated_store = slab_allocated();
int ret, i, j;
for (i = 0; i < max_swap_offset; i ++) {
assert(mem_map[i] == SWAP_UNUSED);
}
extern struct mm_struct *check_mm_struct;
assert(check_mm_struct == NULL);
// step1: check mm_map
struct mm_struct *mm0 = mm_create(), *mm1;
assert(mm0 != NULL && list_empty(&(mm0->mmap_list)));
uintptr_t addr0, addr1;
addr0 = 0;
do {
ret = mm_map(mm0, addr0, PUSIZE, 0, NULL);
assert(ret == (USER_ACCESS(addr0, addr0 + PUSIZE)) ? 0 : -E_INVAL);
addr0 += PUSIZE;
} while (!((addr0 >> 48) & 0xFFFF));
addr0 = 0;
for (i = 0; i < 1024; i ++, addr0 += PUSIZE) {
ret = mm_map(mm0, addr0, PGSIZE, 0, NULL);
assert(ret == -E_INVAL);
}
mm_destroy(mm0);
mm0 = mm_create();
assert(mm0 != NULL && list_empty(&(mm0->mmap_list)));
addr0 = 0, i = 0;
do {
ret = mm_map(mm0, addr0, PUSIZE - PGSIZE, 0, NULL);
assert(ret == (USER_ACCESS(addr0, addr0 + PUSIZE)) ? 0 : -E_INVAL);
if (ret == 0) {
i ++;
}
addr0 += PUSIZE;
} while (!((addr0 >> 48) & 0xFFFF));
addr0 = 0, j = 0;
do {
addr0 += PUSIZE - PGSIZE;
ret = mm_map(mm0, addr0, PGSIZE, 0, NULL);
assert(ret == (USER_ACCESS(addr0, addr0 + PGSIZE)) ? 0 : -E_INVAL);
if (ret == 0) {
j ++;
}
addr0 += PGSIZE;
} while (!((addr0 >> 48) & 0xFFFF));
assert(j + 1 >= i);
mm_destroy(mm0);
assert(nr_free_pages_store == nr_free_pages());
assert(slab_allocated_store == slab_allocated());
cprintf("check_mm_swap: step1, mm_map ok.\n");
// step2: check page fault
mm0 = mm_create();
assert(mm0 != NULL && list_empty(&(mm0->mmap_list)));
// setup page table
struct Page *page = alloc_page();
assert(page != NULL);
pgd_t *pgdir = page2kva(page);
memcpy(pgdir, boot_pgdir, PGSIZE);
pgdir[PGX(VPT)] = PADDR(pgdir) | PTE_P | PTE_W;
// prepare for page fault
mm0->pgdir = pgdir;
check_mm_struct = mm0;
lcr3(PADDR(mm0->pgdir));
uint32_t vm_flags = VM_WRITE | VM_READ;
struct vma_struct *vma;
addr0 = 0;
do {
if ((ret = mm_map(mm0, addr0, PTSIZE, vm_flags, &vma)) == 0) {
break;
}
addr0 += PUSIZE;
} while (!((addr0 >> 48) & 0xFFFF));
assert(ret == 0 && addr0 != 0 && mm0->map_count == 1);
assert(vma->vm_start == addr0 && vma->vm_end == addr0 + PTSIZE);
// check pte entry
pte_t *ptep;
for (addr1 = addr0; addr1 < addr0 + PTSIZE; addr1 += PGSIZE) {
ptep = get_pte(pgdir, addr1, 0);
assert(ptep == NULL);
}
memset((void *)addr0, 0xEF, PGSIZE * 2);
ptep = get_pte(pgdir, addr0, 0);
assert(ptep != NULL && (*ptep & PTE_P));
ptep = get_pte(pgdir, addr0 + PGSIZE, 0);
assert(ptep != NULL && (*ptep & PTE_P));
ret = mm_unmap(mm0, - PTSIZE, PTSIZE);
assert(ret == -E_INVAL);
ret = mm_unmap(mm0, addr0 + PTSIZE, PGSIZE);
assert(ret == 0);
addr1 = addr0 + PTSIZE / 2;
ret = mm_unmap(mm0, addr1, PGSIZE);
assert(ret == 0 && mm0->map_count == 2);
ret = mm_unmap(mm0, addr1 + 2 * PGSIZE, PGSIZE * 4);
assert(ret == 0 && mm0->map_count == 3);
ret = mm_map(mm0, addr1, PGSIZE * 6, 0, NULL);
assert(ret == -E_INVAL);
ret = mm_map(mm0, addr1, PGSIZE, 0, NULL);
assert(ret == 0 && mm0->map_count == 4);
ret = mm_map(mm0, addr1 + 2 * PGSIZE, PGSIZE * 4, 0, NULL);
assert(ret == 0 && mm0->map_count == 5);
ret = mm_unmap(mm0, addr1 + PGSIZE / 2, PTSIZE / 2 - PGSIZE);
assert(ret == 0 && mm0->map_count == 1);
addr1 = addr0 + PGSIZE;
for (i = 0; i < PGSIZE; i ++) {
assert(*(char *)(addr1 + i) == (char)0xEF);
}
ret = mm_unmap(mm0, addr1 + PGSIZE / 2, PGSIZE / 4);
assert(ret == 0 && mm0->map_count == 2);
ptep = get_pte(pgdir, addr0, 0);
assert(ptep != NULL && (*ptep & PTE_P));
ptep = get_pte(pgdir, addr0 + PGSIZE, 0);
assert(ptep != NULL && *ptep == 0);
ret = mm_map(mm0, addr1, PGSIZE, vm_flags, NULL);
memset((void *)addr1, 0x88, PGSIZE);
assert(*(char *)addr1 == (char)0x88 && mm0->map_count == 3);
for (i = 1; i < 16; i += 2) {
ret = mm_unmap(mm0, addr0 + PGSIZE * i, PGSIZE);
assert(ret == 0);
if (i < 8) {
ret = mm_map(mm0, addr0 + PGSIZE * i, PGSIZE, 0, NULL);
assert(ret == 0);
}
}
assert(mm0->map_count == 13);
ret = mm_unmap(mm0, addr0 + PGSIZE * 2, PTSIZE - PGSIZE * 2);
assert(ret == 0 && mm0->map_count == 2);
ret = mm_unmap(mm0, addr0, PGSIZE * 2);
assert(ret == 0 && mm0->map_count == 0);
cprintf("check_mm_swap: step2, mm_unmap ok.\n");
// step3: check exit_mmap
ret = mm_map(mm0, addr0, PTSIZE, vm_flags, NULL);
assert(ret == 0);
for (i = 0, addr1 = addr0; i < 4; i ++, addr1 += PGSIZE) {
*(char *)addr1 = (char)0xFF;
}
exit_mmap(mm0);
for (i = 0; i < PGX(KERNBASE); i ++) {
assert(pgdir[i] == 0);
}
cprintf("check_mm_swap: step3, exit_mmap ok.\n");
// step4: check dup_mmap
for (i = 0; i < max_swap_offset; i ++) {
assert(mem_map[i] == SWAP_UNUSED);
}
ret = mm_map(mm0, addr0, PTSIZE, vm_flags, NULL);
assert(ret != 0);
addr1 = addr0;
for (i = 0; i < 4; i ++, addr1 += PGSIZE) {
*(char *)addr1 = (char)(i * i);
}
ret = 0;
ret += swap_out_mm(mm0, 10);
ret += swap_out_mm(mm0, 10);
assert(ret == 4);
for (; i < 8; i ++, addr1 += PGSIZE) {
*(char *)addr1 = (char)(i * i);
}
// setup mm1
mm1 = mm_create();
assert(mm1 != NULL);
page = alloc_page();
assert(page != NULL);
pgdir = page2kva(page);
memcpy(pgdir, boot_pgdir, PGSIZE);
pgdir[PGX(VPT)] = PADDR(pgdir) | PTE_P | PTE_W;
mm1->pgdir = pgdir;
ret = dup_mmap(mm1, mm0);
assert(ret == 0);
// switch to mm1
check_mm_struct = mm1;
lcr3(PADDR(mm1->pgdir));
addr1 = addr0;
for (i = 0; i < 8; i ++, addr1 += PGSIZE) {
assert(*(char *)addr1 == (char)(i * i));
*(char *)addr1 = (char)0x88;
}
// switch to mm0
check_mm_struct = mm0;
lcr3(PADDR(mm0->pgdir));
addr1 = addr0;
for (i = 0; i < 8; i ++, addr1 += PGSIZE) {
assert(*(char *)addr1 == (char)(i * i));
}
// switch to boot_cr3
check_mm_struct = NULL;
lcr3(boot_cr3);
// free memory
exit_mmap(mm0);
exit_mmap(mm1);
free_page(kva2page(mm0->pgdir));
mm_destroy(mm0);
free_page(kva2page(mm1->pgdir));
mm_destroy(mm1);
cprintf("check_mm_swap: step4, dup_mmap ok.\n");
refill_inactive_scan();
page_launder();
for (i = 0; i < max_swap_offset; i ++) {
assert(mem_map[i] == SWAP_UNUSED);
}
assert(nr_free_pages_store == nr_free_pages());
assert(slab_allocated_store == slab_allocated());
cprintf("check_mm_swap() succeeded.\n");
}
static void
check_mm_shm_swap(void) {
size_t nr_free_pages_store = nr_free_pages();
size_t slab_allocated_store = slab_allocated();
int ret, i;
for (i = 0; i < max_swap_offset; i ++) {
assert(mem_map[i] == SWAP_UNUSED);
}
extern struct mm_struct *check_mm_struct;
assert(check_mm_struct == NULL);
struct mm_struct *mm0 = mm_create(), *mm1;
assert(mm0 != NULL && list_empty(&(mm0->mmap_list)));
struct Page *page = alloc_page();
assert(page != NULL);
pgd_t *pgdir = page2kva(page);
memcpy(pgdir, boot_pgdir, PGSIZE);
pgdir[PGX(VPT)] = PADDR(pgdir) | PTE_P | PTE_W;
mm0->pgdir = pgdir;
check_mm_struct = mm0;
lcr3(PADDR(mm0->pgdir));
uint32_t vm_flags = VM_WRITE | VM_READ;
uintptr_t addr0, addr1;
addr0 = 0;
do {
if ((ret = mm_map(mm0, addr0, PTSIZE * 4, vm_flags, NULL)) == 0) {
break;
}
addr0 += PTSIZE;
} while (addr0 != 0);
assert(ret == 0 && addr0 != 0 && mm0->map_count == 1);
ret = mm_unmap(mm0, addr0, PTSIZE * 4);
assert(ret == 0 && mm0->map_count == 0);
struct shmem_struct *shmem = shmem_create(PTSIZE * 2);
assert(shmem != NULL && shmem_ref(shmem) == 0);
// step1: check share memory
struct vma_struct *vma;
addr1 = addr0 + PTSIZE * 2;
ret = mm_map_shmem(mm0, addr0, vm_flags, shmem, &vma);
assert(ret == 0);
assert((vma->vm_flags & VM_SHARE) && vma->shmem == shmem && shmem_ref(shmem) == 1);
ret = mm_map_shmem(mm0, addr1, vm_flags, shmem, &vma);
assert(ret == 0);
assert((vma->vm_flags & VM_SHARE) && vma->shmem == shmem && shmem_ref(shmem) == 2);
// page fault
for (i = 0; i < 4; i ++) {
*(char *)(addr0 + i * PGSIZE) = (char)(i * i);
}
for (i = 0; i < 4; i ++) {
assert(*(char *)(addr1 + i * PGSIZE) == (char)(i * i));
}
for (i = 0; i < 4; i ++) {
*(char *)(addr1 + i * PGSIZE) = (char)(- i * i);
}
for (i = 0; i < 4; i ++) {
assert(*(char *)(addr1 + i * PGSIZE) == (char)(- i * i));
}
// check swap
ret = swap_out_mm(mm0, 8) + swap_out_mm(mm0, 8);
assert(ret == 8 && nr_active_pages == 4 && nr_inactive_pages == 0);
refill_inactive_scan();
assert(nr_active_pages == 0 && nr_inactive_pages == 4);
// write & read again
memset((void *)addr0, 0x77, PGSIZE);
for (i = 0; i < PGSIZE; i ++) {
assert(*(char *)(addr1 + i) == (char)0x77);
}
// check unmap
ret = mm_unmap(mm0, addr1, PGSIZE * 4);
assert(ret == 0);
addr0 += 4 * PGSIZE, addr1 += 4 * PGSIZE;
*(char *)(addr0) = (char)(0xDC);
assert(*(char *)(addr1) == (char)(0xDC));
*(char *)(addr1 + PTSIZE) = (char)(0xDC);
assert(*(char *)(addr0 + PTSIZE) == (char)(0xDC));
cprintf("check_mm_shm_swap: step1, share memory ok.\n");
// setup mm1
mm1 = mm_create();
assert(mm1 != NULL);
page = alloc_page();
assert(page != NULL);
pgdir = page2kva(page);
memcpy(pgdir, boot_pgdir, PGSIZE);
pgdir[PGX(VPT)] = PADDR(pgdir) | PTE_P | PTE_W;
mm1->pgdir = pgdir;
ret = dup_mmap(mm1, mm0);
assert(ret == 0 && shmem_ref(shmem) == 4);
// switch to mm1
check_mm_struct = mm1;
lcr3(PADDR(mm1->pgdir));
for (i = 0; i < 4; i ++) {
*(char *)(addr0 + i * PGSIZE) = (char)(0x57 + i);
}
for (i = 0; i < 4; i ++) {
assert(*(char *)(addr1 + i * PGSIZE) == (char)(0x57 + i));
}
check_mm_struct = mm0;
lcr3(PADDR(mm0->pgdir));
for (i = 0; i < 4; i ++) {
assert(*(char *)(addr0 + i * PGSIZE) == (char)(0x57 + i));
assert(*(char *)(addr1 + i * PGSIZE) == (char)(0x57 + i));
}
swap_out_mm(mm1, 4);
exit_mmap(mm1);
free_page(kva2page(mm1->pgdir));
mm_destroy(mm1);
assert(shmem_ref(shmem) == 2);
cprintf("check_mm_shm_swap: step2, dup_mmap ok.\n");
// free memory
check_mm_struct = NULL;
lcr3(boot_cr3);
exit_mmap(mm0);
free_page(kva2page(mm0->pgdir));
mm_destroy(mm0);
refill_inactive_scan();
page_launder();
for (i = 0; i < max_swap_offset; i ++) {
assert(mem_map[i] == SWAP_UNUSED);
}
assert(nr_free_pages_store == nr_free_pages());
assert(slab_allocated_store == slab_allocated());
cprintf("check_mm_shm_swap() succeeded.\n");
}
