/* ucore use copy-on-write when forking a new process,
* thus copy_range only copy pdt/pte and set their permission to
* READONLY, a write will be handled in pgfault
*/
int
copy_range(pgd_t *to, pgd_t *from, uintptr_t start, uintptr_t end, bool share) {
assert(start % PGSIZE == 0 && end % PGSIZE == 0);
assert(USER_ACCESS(start, end));
do {
pte_t *ptep = get_pte(from, start, 0), *nptep;
if (ptep == NULL) {
if (get_pud(from, start, 0) == NULL) {
start = ROUNDDOWN(start + PUSIZE, PUSIZE);
}
else if (get_pmd(from, start, 0) == NULL) {
start = ROUNDDOWN(start + PMSIZE, PMSIZE);
}
else {
start = ROUNDDOWN(start + PTSIZE, PTSIZE);
}
continue ;
}
if (*ptep != 0) {
if ((nptep = get_pte(to, start, 1)) == NULL) {
return -E_NO_MEM;
}
int ret;
//kprintf("%08x %08x %08x\n", nptep, *nptep, start);
assert(*ptep != 0 && *nptep == 0);
#ifdef ARCH_ARM
//TODO add code to handle swap
if (ptep_present(ptep)){
//no body should be able to write this page
//before a W-pgfault
pte_perm_t perm = PTE_P;
if(ptep_u_read(ptep))
perm |= PTE_U;
if(!share){
//Original page should be set to readonly!
//because Copy-on-write may happen
//after the current proccess modifies its page
ptep_set_perm(ptep, perm);
}else{
if(ptep_u_write(ptep)){
perm |= PTE_W;
}
}
struct Page *page = pte2page(*ptep);
ret = page_insert(to, page, start, perm);
}
#else /* ARCH_ARM */
if (ptep_present(ptep)) {
pte_perm_t perm = ptep_get_perm(ptep, PTE_USER);
struct Page *page = pte2page(*ptep);
if (!share && ptep_s_write(ptep)) {
ptep_unset_s_write(&perm);
pte_perm_t perm_with_swap_stat = ptep_get_perm(ptep, PTE_SWAP);
ptep_set_perm(&perm_with_swap_stat, perm);
page_insert(from, page, start, perm_with_swap_stat);
}
ret = page_insert(to, page, start, perm);
assert(ret == 0);
}
#endif /* ARCH_ARM */
else {
#ifdef CONFIG_NO_SWAP
assert(0);
#endif
swap_entry_t entry;
ptep_copy(&entry, ptep);
swap_duplicate(entry);
ptep_copy(nptep, &entry);
}
}
start += PGSIZE;
} while (start != 0 && start < end);
#ifdef ARCH_ARM
/* we have modified the PTE of the original
* process, so invalidate TLB */
tlb_invalidate_all();
#endif
return 0;
}
int do_pgfault(struct mm_struct *mm, machine_word_t error_code, uintptr_t addr)
{
if (mm == NULL) {
assert(current != NULL);
/* Chen Yuheng
* give handler a chance to deal with it
*/
kprintf
("page fault in kernel thread: pid = %d, name = %s, %d %08x.\n",
current->pid, current->name, error_code, addr);
return -E_KILLED;
}
bool need_unlock = 1;
if (!try_lock_mm(mm)) {
if (current != NULL && mm->locked_by == current->pid) {
need_unlock = 0;
} else {
lock_mm(mm);
}
}
int ret = -E_INVAL;
struct vma_struct *vma = find_vma(mm, addr);
if (vma == NULL || vma->vm_start > addr) {
goto failed;
}
if (vma->vm_flags & VM_STACK) {
if (addr < vma->vm_start + PGSIZE) {
goto failed;
}
}
//kprintf("@ %x %08x\n", vma->vm_flags, vma->vm_start);
//assert((vma->vm_flags & VM_IO)==0);
if (vma->vm_flags & VM_IO) {
ret = -E_INVAL;
goto failed;
}
switch (error_code & 3) {
default:
/* default is 3: write, present */
case 2: /* write, not present */
if (!(vma->vm_flags & VM_WRITE)) {
goto failed;
}
break;
case 1: /* read, present */
goto failed;
case 0: /* read, not present */
if (!(vma->vm_flags & (VM_READ | VM_EXEC))) {
goto failed;
}
}
pte_perm_t perm, nperm;
#ifdef ARCH_ARM
/* ARM9 software emulated PTE_xxx */
perm = PTE_P | PTE_U;
if (vma->vm_flags & VM_WRITE) {
perm |= PTE_W;
}
#else
ptep_unmap(&perm);
ptep_set_u_read(&perm);
if (vma->vm_flags & VM_WRITE) {
ptep_set_u_write(&perm);
}
#endif
addr = ROUNDDOWN(addr, PGSIZE);
ret = -E_NO_MEM;
pte_t *ptep;
if ((ptep = get_pte(mm->pgdir, addr, 1)) == NULL) {
goto failed;
}
if (ptep_invalid(ptep)) {
#ifdef UCONFIG_BIONIC_LIBC
if (vma->mfile.file != NULL) {
struct file *file = vma->mfile.file;
off_t old_pos = file->pos, new_pos =
vma->mfile.offset + addr - vma->vm_start;
#ifdef SHARE_MAPPED_FILE
struct mapped_addr *maddr =
find_maddr(file, new_pos, NULL);
if (maddr == NULL) {
#endif // SHARE_MAPPED_FILE
struct Page *page;
if ((page = alloc_page()) == NULL) {
assert(false);
goto failed;
}
nperm = perm;
#ifdef ARCH_ARM
/* ARM9 software emulated PTE_xxx */
nperm &= ~PTE_W;
#else
ptep_unset_s_write(&nperm);
#endif
page_insert_pte(mm->pgdir, page, ptep, addr,
nperm);
if ((ret =
filestruct_setpos(file, new_pos)) != 0) {
assert(false);
goto failed;
}
filestruct_read(file, page2kva(page), PGSIZE);
if ((ret =
filestruct_setpos(file, old_pos)) != 0) {
assert(false);
goto failed;
}
#ifdef SHARE_MAPPED_FILE
if ((maddr = (struct mapped_addr *)
kmalloc(sizeof(struct mapped_addr))) !=
NULL) {
maddr->page = page;
maddr->offset = new_pos;
page->maddr = maddr;
list_add(&
(file->node->mapped_addr_list),
&(maddr->list));
} else {
assert(false);
}
} else {
nperm = perm;
#ifdef ARCH_ARM
/* ARM9 software emulated PTE_xxx */
nperm &= ~PTE_W;
#else
ptep_unset_s_write(&nperm);
#endif
page_insert_pte(mm->pgdir, maddr->page, ptep,
addr, nperm);
}
#endif //SHARE_MAPPED_FILE
} else
#endif //UCONFIG_BIONIC_LIBC
if (!(vma->vm_flags & VM_SHARE)) {
if (pgdir_alloc_page(mm->pgdir, addr, perm) == NULL) {
goto failed;
}
#ifdef UCONFIG_BIONIC_LIBC
if (vma->vm_flags & VM_ANONYMOUS) {
memset((void *)addr, 0, PGSIZE);
}
#endif //UCONFIG_BIONIC_LIBC
} else { //shared mem
lock_shmem(vma->shmem);
uintptr_t shmem_addr =
addr - vma->vm_start + vma->shmem_off;
pte_t *sh_ptep =
shmem_get_entry(vma->shmem, shmem_addr, 1);
if (sh_ptep == NULL || ptep_invalid(sh_ptep)) {
unlock_shmem(vma->shmem);
goto failed;
}
unlock_shmem(vma->shmem);
if (ptep_present(sh_ptep)) {
page_insert(mm->pgdir, pa2page(*sh_ptep), addr,
perm);
} else {
#ifdef UCONFIG_SWAP
swap_duplicate(*ptep);
ptep_copy(ptep, sh_ptep);
#else
panic("NO SWAP\n");
#endif
}
}
} else { //a present page, handle copy-on-write (cow)
struct Page *page, *newpage = NULL;
bool cow =
((vma->vm_flags & (VM_SHARE | VM_WRITE)) == VM_WRITE),
may_copy = 1;
#if 1
if (!(!ptep_present(ptep)
|| ((error_code & 2) && !ptep_u_write(ptep) && cow))) {
//assert(PADDR(mm->pgdir) == rcr3());
kprintf("%p %p %d %d %x\n", *ptep, addr, error_code,
cow, vma->vm_flags);
assert(0);
}
#endif
if (cow) {
newpage = alloc_page();
}
if (ptep_present(ptep)) {
page = pte2page(*ptep);
} else {
#ifdef UCONFIG_SWAP
if ((ret = swap_in_page(*ptep, &page)) != 0) {
if (newpage != NULL) {
free_page(newpage);
}
goto failed;
}
#else
assert(0);
#endif
if (!(error_code & 2) && cow) {
#ifdef ARCH_ARM
//#warning ARM9 software emulated PTE_xxx
perm &= ~PTE_W;
#else
ptep_unset_s_write(&perm);
#endif
may_copy = 0;
}
}
if (cow && may_copy) {
#ifdef UCONFIG_SWAP
if (page_ref(page) + swap_page_count(page) > 1) {
#else
if (page_ref(page) > 1) {
#endif
if (newpage == NULL) {
goto failed;
}
memcpy(page2kva(newpage), page2kva(page),
PGSIZE);
//kprintf("COW!\n");
page = newpage, newpage = NULL;
}
}
#ifdef UCONFIG_BIONIC_LIBC
else if (vma->mfile.file != NULL) {
#ifdef UCONFIG_SWAP
assert(page_reg(page) + swap_page_count(page) == 1);
#else
assert(page_ref(page) == 1);
#endif
#ifdef SHARE_MAPPED_FILE
off_t offset = vma->mfile.offset + addr - vma->vm_start;
struct mapped_addr *maddr =
find_maddr(vma->mfile.file, offset, page);
if (maddr != NULL) {
list_del(&(maddr->list));
kfree(maddr);
page->maddr = NULL;
assert(find_maddr(vma->mfile.file, offset, page)
== NULL);
} else {
}
#endif //SHARE_MAPPED_FILE
}
#endif //UCONFIG_BIONIC_LIBC
else {
}
page_insert(mm->pgdir, page, addr, perm);
if (newpage != NULL) {
free_page(newpage);
}
}
ret = 0;
failed:
if (need_unlock) {
unlock_mm(mm);
}
return ret;
}
