}
EXPORT_SYMBOL(vm_iomap_memory);
-static int apply_to_pte_range(struct pfn_range_apply *closure, pmd_t *pmd,
- unsigned long addr, unsigned long end)
+static int apply_to_pte_range(struct mm_struct *mm, pmd_t *pmd,
+ unsigned long addr, unsigned long end,
+ pte_fn_t fn, void *data)
{
pte_t *pte;
int err;
pgtable_t token;
spinlock_t *uninitialized_var(ptl);
- pte = (closure->mm == &init_mm) ?
+ pte = (mm == &init_mm) ?
pte_alloc_kernel(pmd, addr) :
- pte_alloc_map_lock(closure->mm, pmd, addr, &ptl);
+ pte_alloc_map_lock(mm, pmd, addr, &ptl);
if (!pte)
return -ENOMEM;
token = pmd_pgtable(*pmd);
do {
- err = closure->ptefn(pte++, token, addr, closure);
+ err = fn(pte++, token, addr, data);
if (err)
break;
} while (addr += PAGE_SIZE, addr != end);
arch_leave_lazy_mmu_mode();
- if (closure->mm != &init_mm)
+ if (mm != &init_mm)
pte_unmap_unlock(pte-1, ptl);
return err;
}
-static int apply_to_pmd_range(struct pfn_range_apply *closure, pud_t *pud,
- unsigned long addr, unsigned long end)
+static int apply_to_pmd_range(struct mm_struct *mm, pud_t *pud,
+ unsigned long addr, unsigned long end,
+ pte_fn_t fn, void *data)
{
pmd_t *pmd;
unsigned long next;
- int err = 0;
+ int err;
BUG_ON(pud_huge(*pud));
- pmd = pmd_alloc(closure->mm, pud, addr);
+ pmd = pmd_alloc(mm, pud, addr);
if (!pmd)
return -ENOMEM;
-
do {
next = pmd_addr_end(addr, end);
- if (!closure->alloc && pmd_none_or_clear_bad(pmd))
- continue;
- err = apply_to_pte_range(closure, pmd, addr, next);
+ err = apply_to_pte_range(mm, pmd, addr, next, fn, data);
if (err)
break;
} while (pmd++, addr = next, addr != end);
return err;
}
-static int apply_to_pud_range(struct pfn_range_apply *closure, p4d_t *p4d,
- unsigned long addr, unsigned long end)
+static int apply_to_pud_range(struct mm_struct *mm, p4d_t *p4d,
+ unsigned long addr, unsigned long end,
+ pte_fn_t fn, void *data)
{
pud_t *pud;
unsigned long next;
- int err = 0;
+ int err;
- pud = pud_alloc(closure->mm, p4d, addr);
+ pud = pud_alloc(mm, p4d, addr);
if (!pud)
return -ENOMEM;
-
do {
next = pud_addr_end(addr, end);
- if (!closure->alloc && pud_none_or_clear_bad(pud))
- continue;
- err = apply_to_pmd_range(closure, pud, addr, next);
+ err = apply_to_pmd_range(mm, pud, addr, next, fn, data);
if (err)
break;
} while (pud++, addr = next, addr != end);
return err;
}
-static int apply_to_p4d_range(struct pfn_range_apply *closure, pgd_t *pgd,
- unsigned long addr, unsigned long end)
+static int apply_to_p4d_range(struct mm_struct *mm, pgd_t *pgd,
+ unsigned long addr, unsigned long end,
+ pte_fn_t fn, void *data)
{
p4d_t *p4d;
unsigned long next;
- int err = 0;
+ int err;
- p4d = p4d_alloc(closure->mm, pgd, addr);
+ p4d = p4d_alloc(mm, pgd, addr);
if (!p4d)
return -ENOMEM;
-
do {
next = p4d_addr_end(addr, end);
- if (!closure->alloc && p4d_none_or_clear_bad(p4d))
- continue;
- err = apply_to_pud_range(closure, p4d, addr, next);
+ err = apply_to_pud_range(mm, p4d, addr, next, fn, data);
if (err)
break;
} while (p4d++, addr = next, addr != end);
return err;
}
-/**
- * apply_to_pfn_range - Scan a region of virtual memory, calling a provided
- * function on each leaf page table entry
- * @closure: Details about how to scan and what function to apply
- * @addr: Start virtual address
- * @size: Size of the region
- *
- * If @closure->alloc is set to 1, the function will fill in the page table
- * as necessary. Otherwise it will skip non-present parts.
- * Note: The caller must ensure that the range does not contain huge pages.
- * The caller must also assure that the proper mmu_notifier functions are
- * called before and after the call to apply_to_pfn_range.
- *
- * WARNING: Do not use this function unless you know exactly what you are
- * doing. It is lacking support for huge pages and transparent huge pages.
- *
- * Return: Zero on success. If the provided function returns a non-zero status,
- * the page table walk will terminate and that status will be returned.
- * If @closure->alloc is set to 1, then this function may also return memory
- * allocation errors arising from allocating page table memory.
+/*
+ * Scan a region of virtual memory, filling in page tables as necessary
+ * and calling a provided function on each leaf page table.
*/
-int apply_to_pfn_range(struct pfn_range_apply *closure,
- unsigned long addr, unsigned long size)
+int apply_to_page_range(struct mm_struct *mm, unsigned long addr,
+ unsigned long size, pte_fn_t fn, void *data)
{
pgd_t *pgd;
unsigned long next;
if (WARN_ON(addr >= end))
return -EINVAL;
- pgd = pgd_offset(closure->mm, addr);
+ pgd = pgd_offset(mm, addr);
do {
next = pgd_addr_end(addr, end);
- if (!closure->alloc && pgd_none_or_clear_bad(pgd))
- continue;
- err = apply_to_p4d_range(closure, pgd, addr, next);
+ err = apply_to_p4d_range(mm, pgd, addr, next, fn, data);
if (err)
break;
} while (pgd++, addr = next, addr != end);
return err;
}
-
-/**
- * struct page_range_apply - Closure structure for apply_to_page_range()
- * @pter: The base closure structure we derive from
- * @fn: The leaf pte function to call
- * @data: The leaf pte function closure
- */
-struct page_range_apply {
- struct pfn_range_apply pter;
- pte_fn_t fn;
- void *data;
-};
-
-/*
- * Callback wrapper to enable use of apply_to_pfn_range for
- * the apply_to_page_range interface
- */
-static int apply_to_page_range_wrapper(pte_t *pte, pgtable_t token,
- unsigned long addr,
- struct pfn_range_apply *pter)
-{
- struct page_range_apply *pra =
- container_of(pter, typeof(*pra), pter);
-
- return pra->fn(pte, token, addr, pra->data);
-}
-
-/*
- * Scan a region of virtual memory, filling in page tables as necessary
- * and calling a provided function on each leaf page table.
- *
- * WARNING: Do not use this function unless you know exactly what you are
- * doing. It is lacking support for huge pages and transparent huge pages.
- */
-int apply_to_page_range(struct mm_struct *mm, unsigned long addr,
- unsigned long size, pte_fn_t fn, void *data)
-{
- struct page_range_apply pra = {
- .pter = {.mm = mm,
- .alloc = 1,
- .ptefn = apply_to_page_range_wrapper },
- .fn = fn,
- .data = data
- };
-
- return apply_to_pfn_range(&pra.pter, addr, size);
-}
EXPORT_SYMBOL_GPL(apply_to_page_range);
/*
ret = vmf->vma->vm_ops->page_mkwrite(vmf);
/* Restore original flags so that caller is not surprised */
vmf->flags = old_flags;
- if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE | VM_FAULT_RETRY)))
+ if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE)))
return ret;
if (unlikely(!(ret & VM_FAULT_LOCKED))) {
lock_page(page);
pte_unmap_unlock(vmf->pte, vmf->ptl);
vmf->flags |= FAULT_FLAG_MKWRITE;
ret = vma->vm_ops->pfn_mkwrite(vmf);
- if (ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE | VM_FAULT_RETRY))
+ if (ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE))
return ret;
return finish_mkwrite_fault(vmf);
}
pte_unmap_unlock(vmf->pte, vmf->ptl);
tmp = do_page_mkwrite(vmf);
if (unlikely(!tmp || (tmp &
- (VM_FAULT_ERROR | VM_FAULT_NOPAGE |
- VM_FAULT_RETRY)))) {
+ (VM_FAULT_ERROR | VM_FAULT_NOPAGE)))) {
put_page(vmf->page);
return tmp;
}
unlock_page(vmf->page);
tmp = do_page_mkwrite(vmf);
if (unlikely(!tmp ||
- (tmp & (VM_FAULT_ERROR | VM_FAULT_NOPAGE |
- VM_FAULT_RETRY)))) {
+ (tmp & (VM_FAULT_ERROR | VM_FAULT_NOPAGE)))) {
put_page(vmf->page);
return tmp;
}
git.samba.org / sfrench / cifs-2.6.git / blobdiff