/*
   *  linux/mm/memory.c
   *
   *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
   */
  
  /*
   * demand-loading started 01.12.91 - seems it is high on the list of
   * things wanted, and it should be easy to implement. - Linus
   */
  
  /*
   * Ok, demand-loading was easy, shared pages a little bit tricker. Shared
   * pages started 02.12.91, seems to work. - Linus.
   *
   * Tested sharing by executing about 30 /bin/sh: under the old kernel it
   * would have taken more than the 6M I have free, but it worked well as
   * far as I could see.
   *
   * Also corrected some "invalidate()"s - I wasn't doing enough of them.
   */
  
  /*
   * Real VM (paging to/from disk) started 18.12.91. Much more work and
   * thought has to go into this. Oh, well..
   * 19.12.91  -  works, somewhat. Sometimes I get faults, don't know why.
   *		Found it. Everything seems to work now.
   * 20.12.91  -  Ok, making the swap-device changeable like the root.
   */
  
  /*
   * 05.04.94  -  Multi-page memory management added for v1.1.
   * 		Idea by Alex Bligh (alex@cconcepts.co.uk)
   *
   * 16.07.99  -  Support of BIGMEM added by Gerhard Wichert, Siemens AG
   *		(Gerhard.Wichert@pdb.siemens.de)
   *
   * Aug/Sep 2004 Changed to four level page tables (Andi Kleen)
   */
  
  #include <linux/kernel_stat.h>
  #include <linux/mm.h>
  #include <linux/hugetlb.h>
  #include <linux/mman.h>
  #include <linux/swap.h>
  #include <linux/highmem.h>
  #include <linux/pagemap.h>

  #include <linux/ksm.h>

  #include <linux/rmap.h>
  #include <linux/module.h>

  #include <linux/delayacct.h>

  #include <linux/init.h>

  #include <linux/writeback.h>

  #include <linux/memcontrol.h>

  #include <linux/mmu_notifier.h>

  #include <linux/kallsyms.h>
  #include <linux/swapops.h>
  #include <linux/elf.h>

  #include <asm/io.h>

  #include <asm/pgalloc.h>
  #include <asm/uaccess.h>
  #include <asm/tlb.h>
  #include <asm/tlbflush.h>
  #include <asm/pgtable.h>

  #include "internal.h"

  #ifndef CONFIG_NEED_MULTIPLE_NODES

  /* use the per-pgdat data instead for discontigmem - mbligh */
  unsigned long max_mapnr;
  struct page *mem_map;
  
  EXPORT_SYMBOL(max_mapnr);
  EXPORT_SYMBOL(mem_map);
  #endif
  
  unsigned long num_physpages;
  /*
   * A number of key systems in x86 including ioremap() rely on the assumption
   * that high_memory defines the upper bound on direct map memory, then end
   * of ZONE_NORMAL.  Under CONFIG_DISCONTIG this means that max_low_pfn and
   * highstart_pfn must be the same; there must be no gap between ZONE_NORMAL
   * and ZONE_HIGHMEM.
   */
  void * high_memory;

  
  EXPORT_SYMBOL(num_physpages);
  EXPORT_SYMBOL(high_memory);

  /*
   * Randomize the address space (stacks, mmaps, brk, etc.).
   *
   * ( When CONFIG_COMPAT_BRK=y we exclude brk from randomization,
   *   as ancient (libc5 based) binaries can segfault. )
   */
  int randomize_va_space __read_mostly =
  #ifdef CONFIG_COMPAT_BRK
  					1;
  #else
  					2;
  #endif

  
  static int __init disable_randmaps(char *s)
  {
  	randomize_va_space = 0;

  	return 1;

  }
  __setup("norandmaps", disable_randmaps);

  unsigned long zero_pfn __read_mostly;

  unsigned long highest_memmap_pfn __read_mostly;

  
  /*
   * CONFIG_MMU architectures set up ZERO_PAGE in their paging_init()
   */
  static int __init init_zero_pfn(void)
  {
  	zero_pfn = page_to_pfn(ZERO_PAGE(0));
  	return 0;
  }
  core_initcall(init_zero_pfn);

  #if defined(SPLIT_RSS_COUNTING)
  
  void __sync_task_rss_stat(struct task_struct *task, struct mm_struct *mm)
  {
  	int i;
  
  	for (i = 0; i < NR_MM_COUNTERS; i++) {
  		if (task->rss_stat.count[i]) {
  			add_mm_counter(mm, i, task->rss_stat.count[i]);
  			task->rss_stat.count[i] = 0;
  		}
  	}
  	task->rss_stat.events = 0;
  }
  
  static void add_mm_counter_fast(struct mm_struct *mm, int member, int val)
  {
  	struct task_struct *task = current;
  
  	if (likely(task->mm == mm))
  		task->rss_stat.count[member] += val;
  	else
  		add_mm_counter(mm, member, val);
  }
  #define inc_mm_counter_fast(mm, member) add_mm_counter_fast(mm, member, 1)
  #define dec_mm_counter_fast(mm, member) add_mm_counter_fast(mm, member, -1)
  
  /* sync counter once per 64 page faults */
  #define TASK_RSS_EVENTS_THRESH	(64)
  static void check_sync_rss_stat(struct task_struct *task)
  {
  	if (unlikely(task != current))
  		return;
  	if (unlikely(task->rss_stat.events++ > TASK_RSS_EVENTS_THRESH))
  		__sync_task_rss_stat(task, task->mm);
  }
  
  unsigned long get_mm_counter(struct mm_struct *mm, int member)
  {
  	long val = 0;
  
  	/*
  	 * Don't use task->mm here...for avoiding to use task_get_mm()..
  	 * The caller must guarantee task->mm is not invalid.
  	 */
  	val = atomic_long_read(&mm->rss_stat.count[member]);
  	/*
  	 * counter is updated in asynchronous manner and may go to minus.
  	 * But it's never be expected number for users.
  	 */
  	if (val < 0)
  		return 0;
  	return (unsigned long)val;
  }
  
  void sync_mm_rss(struct task_struct *task, struct mm_struct *mm)
  {
  	__sync_task_rss_stat(task, mm);
  }
  #else
  
  #define inc_mm_counter_fast(mm, member) inc_mm_counter(mm, member)
  #define dec_mm_counter_fast(mm, member) dec_mm_counter(mm, member)
  
  static void check_sync_rss_stat(struct task_struct *task)
  {
  }
  
  void sync_mm_rss(struct task_struct *task, struct mm_struct *mm)
  {
  }
  #endif

  /*
   * If a p?d_bad entry is found while walking page tables, report
   * the error, before resetting entry to p?d_none.  Usually (but
   * very seldom) called out from the p?d_none_or_clear_bad macros.
   */
  
  void pgd_clear_bad(pgd_t *pgd)
  {
  	pgd_ERROR(*pgd);
  	pgd_clear(pgd);
  }
  
  void pud_clear_bad(pud_t *pud)
  {
  	pud_ERROR(*pud);
  	pud_clear(pud);
  }
  
  void pmd_clear_bad(pmd_t *pmd)
  {
  	pmd_ERROR(*pmd);
  	pmd_clear(pmd);
  }
  
  /*
   * Note: this doesn't free the actual pages themselves. That
   * has been handled earlier when unmapping all the memory regions.
   */

  static void free_pte_range(struct mmu_gather *tlb, pmd_t *pmd,
  			   unsigned long addr)

  {

  	pgtable_t token = pmd_pgtable(*pmd);

  	pmd_clear(pmd);

  	pte_free_tlb(tlb, token, addr);

  	tlb->mm->nr_ptes--;

  }

  static inline void free_pmd_range(struct mmu_gather *tlb, pud_t *pud,
  				unsigned long addr, unsigned long end,
  				unsigned long floor, unsigned long ceiling)

  {
  	pmd_t *pmd;
  	unsigned long next;

  	unsigned long start;

  	start = addr;

  	pmd = pmd_offset(pud, addr);

  	do {
  		next = pmd_addr_end(addr, end);
  		if (pmd_none_or_clear_bad(pmd))
  			continue;

  		free_pte_range(tlb, pmd, addr);

  	} while (pmd++, addr = next, addr != end);

  	start &= PUD_MASK;
  	if (start < floor)
  		return;
  	if (ceiling) {
  		ceiling &= PUD_MASK;
  		if (!ceiling)
  			return;

  	}

  	if (end - 1 > ceiling - 1)
  		return;
  
  	pmd = pmd_offset(pud, start);
  	pud_clear(pud);

  	pmd_free_tlb(tlb, pmd, start);

  }

  static inline void free_pud_range(struct mmu_gather *tlb, pgd_t *pgd,
  				unsigned long addr, unsigned long end,
  				unsigned long floor, unsigned long ceiling)

  {
  	pud_t *pud;
  	unsigned long next;

  	unsigned long start;

  	start = addr;

  	pud = pud_offset(pgd, addr);

  	do {
  		next = pud_addr_end(addr, end);
  		if (pud_none_or_clear_bad(pud))
  			continue;

  		free_pmd_range(tlb, pud, addr, next, floor, ceiling);

  	} while (pud++, addr = next, addr != end);

  	start &= PGDIR_MASK;
  	if (start < floor)
  		return;
  	if (ceiling) {
  		ceiling &= PGDIR_MASK;
  		if (!ceiling)
  			return;

  	}

  	if (end - 1 > ceiling - 1)
  		return;
  
  	pud = pud_offset(pgd, start);
  	pgd_clear(pgd);

  	pud_free_tlb(tlb, pud, start);

  }
  
  /*

   * This function frees user-level page tables of a process.
   *

   * Must be called with pagetable lock held.
   */

  void free_pgd_range(struct mmu_gather *tlb,

  			unsigned long addr, unsigned long end,
  			unsigned long floor, unsigned long ceiling)

  {
  	pgd_t *pgd;
  	unsigned long next;

  	unsigned long start;
  
  	/*
  	 * The next few lines have given us lots of grief...
  	 *
  	 * Why are we testing PMD* at this top level?  Because often
  	 * there will be no work to do at all, and we'd prefer not to
  	 * go all the way down to the bottom just to discover that.
  	 *
  	 * Why all these "- 1"s?  Because 0 represents both the bottom
  	 * of the address space and the top of it (using -1 for the
  	 * top wouldn't help much: the masks would do the wrong thing).
  	 * The rule is that addr 0 and floor 0 refer to the bottom of
  	 * the address space, but end 0 and ceiling 0 refer to the top
  	 * Comparisons need to use "end - 1" and "ceiling - 1" (though
  	 * that end 0 case should be mythical).
  	 *
  	 * Wherever addr is brought up or ceiling brought down, we must
  	 * be careful to reject "the opposite 0" before it confuses the
  	 * subsequent tests.  But what about where end is brought down
  	 * by PMD_SIZE below? no, end can't go down to 0 there.
  	 *
  	 * Whereas we round start (addr) and ceiling down, by different
  	 * masks at different levels, in order to test whether a table
  	 * now has no other vmas using it, so can be freed, we don't
  	 * bother to round floor or end up - the tests don't need that.
  	 */

  	addr &= PMD_MASK;
  	if (addr < floor) {
  		addr += PMD_SIZE;
  		if (!addr)
  			return;
  	}
  	if (ceiling) {
  		ceiling &= PMD_MASK;
  		if (!ceiling)
  			return;
  	}
  	if (end - 1 > ceiling - 1)
  		end -= PMD_SIZE;
  	if (addr > end - 1)
  		return;
  
  	start = addr;

  	pgd = pgd_offset(tlb->mm, addr);

  	do {
  		next = pgd_addr_end(addr, end);
  		if (pgd_none_or_clear_bad(pgd))
  			continue;

  		free_pud_range(tlb, pgd, addr, next, floor, ceiling);

  	} while (pgd++, addr = next, addr != end);

  }

  void free_pgtables(struct mmu_gather *tlb, struct vm_area_struct *vma,

  		unsigned long floor, unsigned long ceiling)

  {
  	while (vma) {
  		struct vm_area_struct *next = vma->vm_next;
  		unsigned long addr = vma->vm_start;

  		/*

  		 * Hide vma from rmap and truncate_pagecache before freeing
  		 * pgtables

  		 */

  		unlink_anon_vmas(vma);

  		unlink_file_vma(vma);

  		if (is_vm_hugetlb_page(vma)) {

  			hugetlb_free_pgd_range(tlb, addr, vma->vm_end,

  				floor, next? next->vm_start: ceiling);

  		} else {
  			/*
  			 * Optimization: gather nearby vmas into one call down
  			 */
  			while (next && next->vm_start <= vma->vm_end + PMD_SIZE

  			       && !is_vm_hugetlb_page(next)) {

  				vma = next;
  				next = vma->vm_next;

  				unlink_anon_vmas(vma);

  				unlink_file_vma(vma);

  			}
  			free_pgd_range(tlb, addr, vma->vm_end,
  				floor, next? next->vm_start: ceiling);
  		}

  		vma = next;
  	}

  }

  int __pte_alloc(struct mm_struct *mm, pmd_t *pmd, unsigned long address)

  {

  	pgtable_t new = pte_alloc_one(mm, address);

  	if (!new)
  		return -ENOMEM;

  	/*
  	 * Ensure all pte setup (eg. pte page lock and page clearing) are
  	 * visible before the pte is made visible to other CPUs by being
  	 * put into page tables.
  	 *
  	 * The other side of the story is the pointer chasing in the page
  	 * table walking code (when walking the page table without locking;
  	 * ie. most of the time). Fortunately, these data accesses consist
  	 * of a chain of data-dependent loads, meaning most CPUs (alpha
  	 * being the notable exception) will already guarantee loads are
  	 * seen in-order. See the alpha page table accessors for the
  	 * smp_read_barrier_depends() barriers in page table walking code.
  	 */
  	smp_wmb(); /* Could be smp_wmb__xxx(before|after)_spin_lock */

  	spin_lock(&mm->page_table_lock);

  	if (!pmd_present(*pmd)) {	/* Has another populated it ? */

  		mm->nr_ptes++;

  		pmd_populate(mm, pmd, new);

  		new = NULL;

  	}

  	spin_unlock(&mm->page_table_lock);

  	if (new)
  		pte_free(mm, new);

  	return 0;

  }

  int __pte_alloc_kernel(pmd_t *pmd, unsigned long address)

  {

  	pte_t *new = pte_alloc_one_kernel(&init_mm, address);
  	if (!new)
  		return -ENOMEM;

  	smp_wmb(); /* See comment in __pte_alloc */

  	spin_lock(&init_mm.page_table_lock);

  	if (!pmd_present(*pmd)) {	/* Has another populated it ? */

  		pmd_populate_kernel(&init_mm, pmd, new);

  		new = NULL;
  	}

  	spin_unlock(&init_mm.page_table_lock);

  	if (new)
  		pte_free_kernel(&init_mm, new);

  	return 0;

  }

  static inline void init_rss_vec(int *rss)
  {
  	memset(rss, 0, sizeof(int) * NR_MM_COUNTERS);
  }
  
  static inline void add_mm_rss_vec(struct mm_struct *mm, int *rss)

  {

  	int i;

  	if (current->mm == mm)
  		sync_mm_rss(current, mm);

  	for (i = 0; i < NR_MM_COUNTERS; i++)
  		if (rss[i])
  			add_mm_counter(mm, i, rss[i]);

  }

  /*

   * This function is called to print an error when a bad pte
   * is found. For example, we might have a PFN-mapped pte in
   * a region that doesn't allow it.

   *
   * The calling function must still handle the error.
   */

  static void print_bad_pte(struct vm_area_struct *vma, unsigned long addr,
  			  pte_t pte, struct page *page)

  {

  	pgd_t *pgd = pgd_offset(vma->vm_mm, addr);
  	pud_t *pud = pud_offset(pgd, addr);
  	pmd_t *pmd = pmd_offset(pud, addr);
  	struct address_space *mapping;
  	pgoff_t index;

  	static unsigned long resume;
  	static unsigned long nr_shown;
  	static unsigned long nr_unshown;
  
  	/*
  	 * Allow a burst of 60 reports, then keep quiet for that minute;
  	 * or allow a steady drip of one report per second.
  	 */
  	if (nr_shown == 60) {
  		if (time_before(jiffies, resume)) {
  			nr_unshown++;
  			return;
  		}
  		if (nr_unshown) {

  			printk(KERN_ALERT
  				"BUG: Bad page map: %lu messages suppressed
  ",

  				nr_unshown);
  			nr_unshown = 0;
  		}
  		nr_shown = 0;
  	}
  	if (nr_shown++ == 0)
  		resume = jiffies + 60 * HZ;

  
  	mapping = vma->vm_file ? vma->vm_file->f_mapping : NULL;
  	index = linear_page_index(vma, addr);

  	printk(KERN_ALERT
  		"BUG: Bad page map in process %s  pte:%08llx pmd:%08llx
  ",

  		current->comm,
  		(long long)pte_val(pte), (long long)pmd_val(*pmd));
  	if (page) {

  		printk(KERN_ALERT

  		"page:%p flags:%p count:%d mapcount:%d mapping:%p index:%lx
  ",
  		page, (void *)page->flags, page_count(page),
  		page_mapcount(page), page->mapping, page->index);
  	}

  	printk(KERN_ALERT

  		"addr:%p vm_flags:%08lx anon_vma:%p mapping:%p index:%lx
  ",
  		(void *)addr, vma->vm_flags, vma->anon_vma, mapping, index);
  	/*
  	 * Choose text because data symbols depend on CONFIG_KALLSYMS_ALL=y
  	 */
  	if (vma->vm_ops)

  		print_symbol(KERN_ALERT "vma->vm_ops->fault: %s
  ",

  				(unsigned long)vma->vm_ops->fault);
  	if (vma->vm_file && vma->vm_file->f_op)

  		print_symbol(KERN_ALERT "vma->vm_file->f_op->mmap: %s
  ",

  				(unsigned long)vma->vm_file->f_op->mmap);

  	dump_stack();

  	add_taint(TAINT_BAD_PAGE);

  }

  static inline int is_cow_mapping(unsigned int flags)
  {
  	return (flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE;
  }

  #ifndef is_zero_pfn
  static inline int is_zero_pfn(unsigned long pfn)
  {
  	return pfn == zero_pfn;
  }
  #endif
  
  #ifndef my_zero_pfn
  static inline unsigned long my_zero_pfn(unsigned long addr)
  {
  	return zero_pfn;
  }
  #endif

  /*

   * vm_normal_page -- This function gets the "struct page" associated with a pte.

   *

   * "Special" mappings do not wish to be associated with a "struct page" (either
   * it doesn't exist, or it exists but they don't want to touch it). In this
   * case, NULL is returned here. "Normal" mappings do have a struct page.

   *

   * There are 2 broad cases. Firstly, an architecture may define a pte_special()
   * pte bit, in which case this function is trivial. Secondly, an architecture
   * may not have a spare pte bit, which requires a more complicated scheme,
   * described below.
   *
   * A raw VM_PFNMAP mapping (ie. one that is not COWed) is always considered a
   * special mapping (even if there are underlying and valid "struct pages").
   * COWed pages of a VM_PFNMAP are always normal.

   *

   * The way we recognize COWed pages within VM_PFNMAP mappings is through the
   * rules set up by "remap_pfn_range()": the vma will have the VM_PFNMAP bit

   * set, and the vm_pgoff will point to the first PFN mapped: thus every special
   * mapping will always honor the rule

   *
   *	pfn_of_page == vma->vm_pgoff + ((addr - vma->vm_start) >> PAGE_SHIFT)
   *

   * And for normal mappings this is false.
   *
   * This restricts such mappings to be a linear translation from virtual address
   * to pfn. To get around this restriction, we allow arbitrary mappings so long
   * as the vma is not a COW mapping; in that case, we know that all ptes are
   * special (because none can have been COWed).

   *

   *

   * In order to support COW of arbitrary special mappings, we have VM_MIXEDMAP.

   *
   * VM_MIXEDMAP mappings can likewise contain memory with or without "struct
   * page" backing, however the difference is that _all_ pages with a struct
   * page (that is, those where pfn_valid is true) are refcounted and considered
   * normal pages by the VM. The disadvantage is that pages are refcounted
   * (which can be slower and simply not an option for some PFNMAP users). The
   * advantage is that we don't have to follow the strict linearity rule of
   * PFNMAP mappings in order to support COWable mappings.
   *

   */

  #ifdef __HAVE_ARCH_PTE_SPECIAL
  # define HAVE_PTE_SPECIAL 1
  #else
  # define HAVE_PTE_SPECIAL 0
  #endif
  struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
  				pte_t pte)

  {

  	unsigned long pfn = pte_pfn(pte);

  
  	if (HAVE_PTE_SPECIAL) {

  		if (likely(!pte_special(pte)))
  			goto check_pfn;

  		if (vma->vm_flags & (VM_PFNMAP | VM_MIXEDMAP))
  			return NULL;

  		if (!is_zero_pfn(pfn))

  			print_bad_pte(vma, addr, pte, NULL);

  		return NULL;
  	}
  
  	/* !HAVE_PTE_SPECIAL case follows: */

  	if (unlikely(vma->vm_flags & (VM_PFNMAP|VM_MIXEDMAP))) {
  		if (vma->vm_flags & VM_MIXEDMAP) {
  			if (!pfn_valid(pfn))
  				return NULL;
  			goto out;
  		} else {

  			unsigned long off;
  			off = (addr - vma->vm_start) >> PAGE_SHIFT;

  			if (pfn == vma->vm_pgoff + off)
  				return NULL;
  			if (!is_cow_mapping(vma->vm_flags))
  				return NULL;
  		}

  	}

  	if (is_zero_pfn(pfn))
  		return NULL;

  check_pfn:
  	if (unlikely(pfn > highest_memmap_pfn)) {
  		print_bad_pte(vma, addr, pte, NULL);
  		return NULL;
  	}

  
  	/*

  	 * NOTE! We still have PageReserved() pages in the page tables.

  	 * eg. VDSO mappings can cause them to exist.

  	 */

  out:

  	return pfn_to_page(pfn);

  }
  
  /*

   * copy one vm_area from one task to the other. Assumes the page tables
   * already present in the new task to be cleared in the whole range
   * covered by this vma.

   */

  static inline unsigned long

  copy_one_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,

  		pte_t *dst_pte, pte_t *src_pte, struct vm_area_struct *vma,

  		unsigned long addr, int *rss)

  {

  	unsigned long vm_flags = vma->vm_flags;

  	pte_t pte = *src_pte;
  	struct page *page;

  
  	/* pte contains position in swap or file, so copy. */
  	if (unlikely(!pte_present(pte))) {
  		if (!pte_file(pte)) {

  			swp_entry_t entry = pte_to_swp_entry(pte);

  			if (swap_duplicate(entry) < 0)
  				return entry.val;

  			/* make sure dst_mm is on swapoff's mmlist. */
  			if (unlikely(list_empty(&dst_mm->mmlist))) {
  				spin_lock(&mmlist_lock);

  				if (list_empty(&dst_mm->mmlist))
  					list_add(&dst_mm->mmlist,
  						 &src_mm->mmlist);

  				spin_unlock(&mmlist_lock);
  			}

  			if (likely(!non_swap_entry(entry)))
  				rss[MM_SWAPENTS]++;
  			else if (is_write_migration_entry(entry) &&

  					is_cow_mapping(vm_flags)) {
  				/*
  				 * COW mappings require pages in both parent
  				 * and child to be set to read.
  				 */
  				make_migration_entry_read(&entry);
  				pte = swp_entry_to_pte(entry);
  				set_pte_at(src_mm, addr, src_pte, pte);
  			}

  		}

  		goto out_set_pte;

  	}

  	/*
  	 * If it's a COW mapping, write protect it both
  	 * in the parent and the child
  	 */

  	if (is_cow_mapping(vm_flags)) {

  		ptep_set_wrprotect(src_mm, addr, src_pte);

  		pte = pte_wrprotect(pte);

  	}
  
  	/*
  	 * If it's a shared mapping, mark it clean in
  	 * the child
  	 */
  	if (vm_flags & VM_SHARED)
  		pte = pte_mkclean(pte);
  	pte = pte_mkold(pte);

  
  	page = vm_normal_page(vma, addr, pte);
  	if (page) {
  		get_page(page);

  		page_dup_rmap(page);

  		if (PageAnon(page))
  			rss[MM_ANONPAGES]++;
  		else
  			rss[MM_FILEPAGES]++;

  	}

  
  out_set_pte:
  	set_pte_at(dst_mm, addr, dst_pte, pte);

  	return 0;

  }
  
  static int copy_pte_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
  		pmd_t *dst_pmd, pmd_t *src_pmd, struct vm_area_struct *vma,
  		unsigned long addr, unsigned long end)
  {

  	pte_t *orig_src_pte, *orig_dst_pte;

  	pte_t *src_pte, *dst_pte;

  	spinlock_t *src_ptl, *dst_ptl;

  	int progress = 0;

  	int rss[NR_MM_COUNTERS];

  	swp_entry_t entry = (swp_entry_t){0};

  
  again:

  	init_rss_vec(rss);

  	dst_pte = pte_alloc_map_lock(dst_mm, dst_pmd, addr, &dst_ptl);

  	if (!dst_pte)
  		return -ENOMEM;
  	src_pte = pte_offset_map_nested(src_pmd, addr);

  	src_ptl = pte_lockptr(src_mm, src_pmd);

  	spin_lock_nested(src_ptl, SINGLE_DEPTH_NESTING);

  	orig_src_pte = src_pte;
  	orig_dst_pte = dst_pte;

  	arch_enter_lazy_mmu_mode();

  	do {
  		/*
  		 * We are holding two locks at this point - either of them
  		 * could generate latencies in another task on another CPU.
  		 */

  		if (progress >= 32) {
  			progress = 0;
  			if (need_resched() ||

  			    spin_needbreak(src_ptl) || spin_needbreak(dst_ptl))

  				break;
  		}

  		if (pte_none(*src_pte)) {
  			progress++;
  			continue;
  		}

  		entry.val = copy_one_pte(dst_mm, src_mm, dst_pte, src_pte,
  							vma, addr, rss);
  		if (entry.val)
  			break;

  		progress += 8;
  	} while (dst_pte++, src_pte++, addr += PAGE_SIZE, addr != end);

  	arch_leave_lazy_mmu_mode();

  	spin_unlock(src_ptl);

  	pte_unmap_nested(orig_src_pte);

  	add_mm_rss_vec(dst_mm, rss);

  	pte_unmap_unlock(orig_dst_pte, dst_ptl);

  	cond_resched();

  
  	if (entry.val) {
  		if (add_swap_count_continuation(entry, GFP_KERNEL) < 0)
  			return -ENOMEM;
  		progress = 0;
  	}

  	if (addr != end)
  		goto again;
  	return 0;
  }
  
  static inline int copy_pmd_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
  		pud_t *dst_pud, pud_t *src_pud, struct vm_area_struct *vma,
  		unsigned long addr, unsigned long end)
  {
  	pmd_t *src_pmd, *dst_pmd;
  	unsigned long next;
  
  	dst_pmd = pmd_alloc(dst_mm, dst_pud, addr);
  	if (!dst_pmd)
  		return -ENOMEM;
  	src_pmd = pmd_offset(src_pud, addr);
  	do {
  		next = pmd_addr_end(addr, end);
  		if (pmd_none_or_clear_bad(src_pmd))
  			continue;
  		if (copy_pte_range(dst_mm, src_mm, dst_pmd, src_pmd,
  						vma, addr, next))
  			return -ENOMEM;
  	} while (dst_pmd++, src_pmd++, addr = next, addr != end);
  	return 0;
  }
  
  static inline int copy_pud_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
  		pgd_t *dst_pgd, pgd_t *src_pgd, struct vm_area_struct *vma,
  		unsigned long addr, unsigned long end)
  {
  	pud_t *src_pud, *dst_pud;
  	unsigned long next;
  
  	dst_pud = pud_alloc(dst_mm, dst_pgd, addr);
  	if (!dst_pud)
  		return -ENOMEM;
  	src_pud = pud_offset(src_pgd, addr);
  	do {
  		next = pud_addr_end(addr, end);
  		if (pud_none_or_clear_bad(src_pud))
  			continue;
  		if (copy_pmd_range(dst_mm, src_mm, dst_pud, src_pud,
  						vma, addr, next))
  			return -ENOMEM;
  	} while (dst_pud++, src_pud++, addr = next, addr != end);
  	return 0;
  }
  
  int copy_page_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
  		struct vm_area_struct *vma)
  {
  	pgd_t *src_pgd, *dst_pgd;
  	unsigned long next;
  	unsigned long addr = vma->vm_start;
  	unsigned long end = vma->vm_end;

  	int ret;

  	/*
  	 * Don't copy ptes where a page fault will fill them correctly.
  	 * Fork becomes much lighter when there are big shared or private
  	 * readonly mappings. The tradeoff is that copy_page_range is more
  	 * efficient than faulting.
  	 */

  	if (!(vma->vm_flags & (VM_HUGETLB|VM_NONLINEAR|VM_PFNMAP|VM_INSERTPAGE))) {

  		if (!vma->anon_vma)
  			return 0;
  	}

  	if (is_vm_hugetlb_page(vma))
  		return copy_hugetlb_page_range(dst_mm, src_mm, vma);

  	if (unlikely(is_pfn_mapping(vma))) {

  		/*
  		 * We do not free on error cases below as remove_vma
  		 * gets called on error from higher level routine
  		 */
  		ret = track_pfn_vma_copy(vma);
  		if (ret)
  			return ret;
  	}

  	/*
  	 * We need to invalidate the secondary MMU mappings only when
  	 * there could be a permission downgrade on the ptes of the
  	 * parent mm. And a permission downgrade will only happen if
  	 * is_cow_mapping() returns true.
  	 */
  	if (is_cow_mapping(vma->vm_flags))
  		mmu_notifier_invalidate_range_start(src_mm, addr, end);
  
  	ret = 0;

  	dst_pgd = pgd_offset(dst_mm, addr);
  	src_pgd = pgd_offset(src_mm, addr);
  	do {
  		next = pgd_addr_end(addr, end);
  		if (pgd_none_or_clear_bad(src_pgd))
  			continue;

  		if (unlikely(copy_pud_range(dst_mm, src_mm, dst_pgd, src_pgd,
  					    vma, addr, next))) {
  			ret = -ENOMEM;
  			break;
  		}

  	} while (dst_pgd++, src_pgd++, addr = next, addr != end);

  
  	if (is_cow_mapping(vma->vm_flags))
  		mmu_notifier_invalidate_range_end(src_mm,
  						  vma->vm_start, end);
  	return ret;

  }

  static unsigned long zap_pte_range(struct mmu_gather *tlb,

  				struct vm_area_struct *vma, pmd_t *pmd,

  				unsigned long addr, unsigned long end,

  				long *zap_work, struct zap_details *details)

  {

  	struct mm_struct *mm = tlb->mm;

  	pte_t *pte;

  	spinlock_t *ptl;

  	int rss[NR_MM_COUNTERS];
  
  	init_rss_vec(rss);

  	pte = pte_offset_map_lock(mm, pmd, addr, &ptl);

  	arch_enter_lazy_mmu_mode();

  	do {
  		pte_t ptent = *pte;

  		if (pte_none(ptent)) {
  			(*zap_work)--;

  			continue;

  		}

  
  		(*zap_work) -= PAGE_SIZE;

  		if (pte_present(ptent)) {

  			struct page *page;

  			page = vm_normal_page(vma, addr, ptent);

  			if (unlikely(details) && page) {
  				/*
  				 * unmap_shared_mapping_pages() wants to
  				 * invalidate cache without truncating:
  				 * unmap shared but keep private pages.
  				 */
  				if (details->check_mapping &&
  				    details->check_mapping != page->mapping)
  					continue;
  				/*
  				 * Each page->index must be checked when
  				 * invalidating or truncating nonlinear.
  				 */
  				if (details->nonlinear_vma &&
  				    (page->index < details->first_index ||
  				     page->index > details->last_index))
  					continue;
  			}

  			ptent = ptep_get_and_clear_full(mm, addr, pte,

  							tlb->fullmm);

  			tlb_remove_tlb_entry(tlb, pte, addr);
  			if (unlikely(!page))
  				continue;
  			if (unlikely(details) && details->nonlinear_vma
  			    && linear_page_index(details->nonlinear_vma,
  						addr) != page->index)

  				set_pte_at(mm, addr, pte,

  					   pgoff_to_pte(page->index));

  			if (PageAnon(page))

  				rss[MM_ANONPAGES]--;

  			else {
  				if (pte_dirty(ptent))
  					set_page_dirty(page);

  				if (pte_young(ptent) &&
  				    likely(!VM_SequentialReadHint(vma)))

  					mark_page_accessed(page);

  				rss[MM_FILEPAGES]--;

  			}

  			page_remove_rmap(page);

  			if (unlikely(page_mapcount(page) < 0))
  				print_bad_pte(vma, addr, ptent, page);

  			tlb_remove_page(tlb, page);
  			continue;
  		}
  		/*
  		 * If details->check_mapping, we leave swap entries;
  		 * if details->nonlinear_vma, we leave file entries.
  		 */
  		if (unlikely(details))
  			continue;

  		if (pte_file(ptent)) {
  			if (unlikely(!(vma->vm_flags & VM_NONLINEAR)))
  				print_bad_pte(vma, addr, ptent, NULL);

  		} else {
  			swp_entry_t entry = pte_to_swp_entry(ptent);
  
  			if (!non_swap_entry(entry))
  				rss[MM_SWAPENTS]--;
  			if (unlikely(!free_swap_and_cache(entry)))
  				print_bad_pte(vma, addr, ptent, NULL);
  		}

  		pte_clear_not_present_full(mm, addr, pte, tlb->fullmm);

  	} while (pte++, addr += PAGE_SIZE, (addr != end && *zap_work > 0));

  	add_mm_rss_vec(mm, rss);

  	arch_leave_lazy_mmu_mode();

  	pte_unmap_unlock(pte - 1, ptl);

  
  	return addr;

  }

  static inline unsigned long zap_pmd_range(struct mmu_gather *tlb,

  				struct vm_area_struct *vma, pud_t *pud,

  				unsigned long addr, unsigned long end,

  				long *zap_work, struct zap_details *details)

  {
  	pmd_t *pmd;
  	unsigned long next;
  
  	pmd = pmd_offset(pud, addr);
  	do {
  		next = pmd_addr_end(addr, end);

  		if (pmd_none_or_clear_bad(pmd)) {
  			(*zap_work)--;

  			continue;

  		}
  		next = zap_pte_range(tlb, vma, pmd, addr, next,
  						zap_work, details);
  	} while (pmd++, addr = next, (addr != end && *zap_work > 0));
  
  	return addr;

  }

  static inline unsigned long zap_pud_range(struct mmu_gather *tlb,

  				struct vm_area_struct *vma, pgd_t *pgd,

  				unsigned long addr, unsigned long end,

  				long *zap_work, struct zap_details *details)

  {
  	pud_t *pud;
  	unsigned long next;
  
  	pud = pud_offset(pgd, addr);
  	do {
  		next = pud_addr_end(addr, end);

  		if (pud_none_or_clear_bad(pud)) {
  			(*zap_work)--;

  			continue;

  		}
  		next = zap_pmd_range(tlb, vma, pud, addr, next,
  						zap_work, details);
  	} while (pud++, addr = next, (addr != end && *zap_work > 0));
  
  	return addr;

  }

  static unsigned long unmap_page_range(struct mmu_gather *tlb,
  				struct vm_area_struct *vma,

  				unsigned long addr, unsigned long end,

  				long *zap_work, struct zap_details *details)

  {
  	pgd_t *pgd;
  	unsigned long next;
  
  	if (details && !details->check_mapping && !details->nonlinear_vma)
  		details = NULL;
  
  	BUG_ON(addr >= end);

  	mem_cgroup_uncharge_start();

  	tlb_start_vma(tlb, vma);
  	pgd = pgd_offset(vma->vm_mm, addr);
  	do {
  		next = pgd_addr_end(addr, end);

  		if (pgd_none_or_clear_bad(pgd)) {
  			(*zap_work)--;

  			continue;

  		}
  		next = zap_pud_range(tlb, vma, pgd, addr, next,
  						zap_work, details);
  	} while (pgd++, addr = next, (addr != end && *zap_work > 0));

  	tlb_end_vma(tlb, vma);

  	mem_cgroup_uncharge_end();

  
  	return addr;

  }
  
  #ifdef CONFIG_PREEMPT
  # define ZAP_BLOCK_SIZE	(8 * PAGE_SIZE)
  #else
  /* No preempt: go for improved straight-line efficiency */
  # define ZAP_BLOCK_SIZE	(1024 * PAGE_SIZE)
  #endif
  
  /**
   * unmap_vmas - unmap a range of memory covered by a list of vma's
   * @tlbp: address of the caller's struct mmu_gather

   * @vma: the starting vma
   * @start_addr: virtual address at which to start unmapping
   * @end_addr: virtual address at which to end unmapping
   * @nr_accounted: Place number of unmapped pages in vm-accountable vma's here
   * @details: details of nonlinear truncation or shared cache invalidation
   *

   * Returns the end address of the unmapping (restart addr if interrupted).

   *

   * Unmap all pages in the vma list.

   *

   * We aim to not hold locks for too long (for scheduling latency reasons).
   * So zap pages in ZAP_BLOCK_SIZE bytecounts.  This means we need to

   * return the ending mmu_gather to the caller.
   *
   * Only addresses between `start' and `end' will be unmapped.
   *
   * The VMA list must be sorted in ascending virtual address order.
   *
   * unmap_vmas() assumes that the caller will flush the whole unmapped address
   * range after unmap_vmas() returns.  So the only responsibility here is to
   * ensure that any thus-far unmapped pages are flushed before unmap_vmas()
   * drops the lock and schedules.
   */

  unsigned long unmap_vmas(struct mmu_gather **tlbp,

  		struct vm_area_struct *vma, unsigned long start_addr,
  		unsigned long end_addr, unsigned long *nr_accounted,
  		struct zap_details *details)
  {

  	long zap_work = ZAP_BLOCK_SIZE;

  	unsigned long tlb_start = 0;	/* For tlb_finish_mmu */
  	int tlb_start_valid = 0;

  	unsigned long start = start_addr;

  	spinlock_t *i_mmap_lock = details? details->i_mmap_lock: NULL;

  	int fullmm = (*tlbp)->fullmm;

  	struct mm_struct *mm = vma->vm_mm;

  	mmu_notifier_invalidate_range_start(mm, start_addr, end_addr);

  	for ( ; vma && vma->vm_start < end_addr; vma = vma->vm_next) {

  		unsigned long end;
  
  		start = max(vma->vm_start, start_addr);
  		if (start >= vma->vm_end)
  			continue;
  		end = min(vma->vm_end, end_addr);
  		if (end <= vma->vm_start)
  			continue;
  
  		if (vma->vm_flags & VM_ACCOUNT)
  			*nr_accounted += (end - start) >> PAGE_SHIFT;

  		if (unlikely(is_pfn_mapping(vma)))

  			untrack_pfn_vma(vma, 0, 0);

  		while (start != end) {

  			if (!tlb_start_valid) {
  				tlb_start = start;
  				tlb_start_valid = 1;
  			}

  			if (unlikely(is_vm_hugetlb_page(vma))) {

  				/*
  				 * It is undesirable to test vma->vm_file as it
  				 * should be non-null for valid hugetlb area.
  				 * However, vm_file will be NULL in the error
  				 * cleanup path of do_mmap_pgoff. When
  				 * hugetlbfs ->mmap method fails,
  				 * do_mmap_pgoff() nullifies vma->vm_file
  				 * before calling this function to clean up.
  				 * Since no pte has actually been setup, it is
  				 * safe to do nothing in this case.
  				 */
  				if (vma->vm_file) {
  					unmap_hugepage_range(vma, start, end, NULL);
  					zap_work -= (end - start) /

  					pages_per_huge_page(hstate_vma(vma));

  				}

  				start = end;
  			} else
  				start = unmap_page_range(*tlbp, vma,
  						start, end, &zap_work, details);
  
  			if (zap_work > 0) {
  				BUG_ON(start != end);
  				break;

  			}

  			tlb_finish_mmu(*tlbp, tlb_start, start);
  
  			if (need_resched() ||

  				(i_mmap_lock && spin_needbreak(i_mmap_lock))) {

  				if (i_mmap_lock) {

  					*tlbp = NULL;

  					goto out;
  				}

  				cond_resched();

  			}

  			*tlbp = tlb_gather_mmu(vma->vm_mm, fullmm);

  			tlb_start_valid = 0;

  			zap_work = ZAP_BLOCK_SIZE;

  		}
  	}
  out:

  	mmu_notifier_invalidate_range_end(mm, start_addr, end_addr);

  	return start;	/* which is now the end (or restart) address */

  }
  
  /**
   * zap_page_range - remove user pages in a given range
   * @vma: vm_area_struct holding the applicable pages
   * @address: starting address of pages to zap
   * @size: number of bytes to zap
   * @details: details of nonlinear truncation or shared cache invalidation
   */

  unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,

  		unsigned long size, struct zap_details *details)
  {
  	struct mm_struct *mm = vma->vm_mm;
  	struct mmu_gather *tlb;
  	unsigned long end = address + size;
  	unsigned long nr_accounted = 0;

  	lru_add_drain();

  	tlb = tlb_gather_mmu(mm, 0);

  	update_hiwater_rss(mm);

  	end = unmap_vmas(&tlb, vma, address, end, &nr_accounted, details);
  	if (tlb)
  		tlb_finish_mmu(tlb, address, end);

  	return end;

  }

  /**
   * zap_vma_ptes - remove ptes mapping the vma
   * @vma: vm_area_struct holding ptes to be zapped
   * @address: starting address of pages to zap
   * @size: number of bytes to zap
   *
   * This function only unmaps ptes assigned to VM_PFNMAP vmas.
   *
   * The entire address range must be fully contained within the vma.
   *
   * Returns 0 if successful.
   */
  int zap_vma_ptes(struct vm_area_struct *vma, unsigned long address,
  		unsigned long size)
  {
  	if (address < vma->vm_start || address + size > vma->vm_end ||
  	    		!(vma->vm_flags & VM_PFNMAP))
  		return -1;
  	zap_page_range(vma, address, size, NULL);
  	return 0;
  }
  EXPORT_SYMBOL_GPL(zap_vma_ptes);

  /*
   * Do a quick page-table lookup for a single page.

   */

  struct page *follow_page(struct vm_area_struct *vma, unsigned long address,

  			unsigned int flags)

  {
  	pgd_t *pgd;
  	pud_t *pud;
  	pmd_t *pmd;
  	pte_t *ptep, pte;

  	spinlock_t *ptl;

  	struct page *page;

  	struct mm_struct *mm = vma->vm_mm;

  	page = follow_huge_addr(mm, address, flags & FOLL_WRITE);
  	if (!IS_ERR(page)) {
  		BUG_ON(flags & FOLL_GET);
  		goto out;
  	}

  	page = NULL;

  	pgd = pgd_offset(mm, address);
  	if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd)))

  		goto no_page_table;

  
  	pud = pud_offset(pgd, address);

  	if (pud_none(*pud))

  		goto no_page_table;

  	if (pud_huge(*pud)) {
  		BUG_ON(flags & FOLL_GET);
  		page = follow_huge_pud(mm, address, pud, flags & FOLL_WRITE);
  		goto out;
  	}
  	if (unlikely(pud_bad(*pud)))
  		goto no_page_table;

  	pmd = pmd_offset(pud, address);

  	if (pmd_none(*pmd))

  		goto no_page_table;

  	if (pmd_huge(*pmd)) {
  		BUG_ON(flags & FOLL_GET);
  		page = follow_huge_pmd(mm, address, pmd, flags & FOLL_WRITE);

  		goto out;

  	}

  	if (unlikely(pmd_bad(*pmd)))
  		goto no_page_table;

  	ptep = pte_offset_map_lock(mm, pmd, address, &ptl);

  
  	pte = *ptep;

  	if (!pte_present(pte))

  		goto no_page;

  	if ((flags & FOLL_WRITE) && !pte_write(pte))
  		goto unlock;

  	page = vm_normal_page(vma, address, pte);

  	if (unlikely(!page)) {
  		if ((flags & FOLL_DUMP) ||

  		    !is_zero_pfn(pte_pfn(pte)))

  			goto bad_page;
  		page = pte_page(pte);
  	}

  	if (flags & FOLL_GET)
  		get_page(page);
  	if (flags & FOLL_TOUCH) {
  		if ((flags & FOLL_WRITE) &&
  		    !pte_dirty(pte) && !PageDirty(page))
  			set_page_dirty(page);

  		/*
  		 * pte_mkyoung() would be more correct here, but atomic care
  		 * is needed to avoid losing the dirty bit: it is easier to use
  		 * mark_page_accessed().
  		 */

  		mark_page_accessed(page);
  	}
  unlock:
  	pte_unmap_unlock(ptep, ptl);

  out:

  	return page;

  bad_page:
  	pte_unmap_unlock(ptep, ptl);
  	return ERR_PTR(-EFAULT);
  
  no_page:
  	pte_unmap_unlock(ptep, ptl);
  	if (!pte_none(pte))
  		return page;

  no_page_table:
  	/*
  	 * When core dumping an enormous anonymous area that nobody

  	 * has touched so far, we don't want to allocate unnecessary pages or
  	 * page tables.  Return error instead of NULL to skip handle_mm_fault,
  	 * then get_dump_page() will return NULL to leave a hole in the dump.
  	 * But we can only make this optimization where a hole would surely
  	 * be zero-filled if handle_mm_fault() actually did handle it.

  	 */

  	if ((flags & FOLL_DUMP) &&
  	    (!vma->vm_ops || !vma->vm_ops->fault))
  		return ERR_PTR(-EFAULT);

  	return page;

  }

  int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,

  		     unsigned long start, int nr_pages, unsigned int gup_flags,

  		     struct page **pages, struct vm_area_struct **vmas)

  {
  	int i;

  	unsigned long vm_flags;

  	if (nr_pages <= 0)

  		return 0;

  
  	VM_BUG_ON(!!pages != !!(gup_flags & FOLL_GET));

  	/* 
  	 * Require read or write permissions.

  	 * If FOLL_FORCE is set, we only require the "MAY" flags.

  	 */

  	vm_flags  = (gup_flags & FOLL_WRITE) ?
  			(VM_WRITE | VM_MAYWRITE) : (VM_READ | VM_MAYREAD);
  	vm_flags &= (gup_flags & FOLL_FORCE) ?
  			(VM_MAYREAD | VM_MAYWRITE) : (VM_READ | VM_WRITE);

  	i = 0;
  
  	do {

  		struct vm_area_struct *vma;

  
  		vma = find_extend_vma(mm, start);
  		if (!vma && in_gate_area(tsk, start)) {
  			unsigned long pg = start & PAGE_MASK;
  			struct vm_area_struct *gate_vma = get_gate_vma(tsk);
  			pgd_t *pgd;
  			pud_t *pud;
  			pmd_t *pmd;
  			pte_t *pte;

  
  			/* user gate pages are read-only */

  			if (gup_flags & FOLL_WRITE)

  				return i ? : -EFAULT;
  			if (pg > TASK_SIZE)
  				pgd = pgd_offset_k(pg);
  			else
  				pgd = pgd_offset_gate(mm, pg);
  			BUG_ON(pgd_none(*pgd));
  			pud = pud_offset(pgd, pg);
  			BUG_ON(pud_none(*pud));
  			pmd = pmd_offset(pud, pg);

  			if (pmd_none(*pmd))
  				return i ? : -EFAULT;

  			pte = pte_offset_map(pmd, pg);

  			if (pte_none(*pte)) {
  				pte_unmap(pte);
  				return i ? : -EFAULT;
  			}

  			if (pages) {

  				struct page *page = vm_normal_page(gate_vma, start, *pte);

  				pages[i] = page;
  				if (page)
  					get_page(page);

  			}
  			pte_unmap(pte);
  			if (vmas)
  				vmas[i] = gate_vma;
  			i++;
  			start += PAGE_SIZE;

  			nr_pages--;

  			continue;
  		}

  		if (!vma ||
  		    (vma->vm_flags & (VM_IO | VM_PFNMAP)) ||

  		    !(vm_flags & vma->vm_flags))

  			return i ? : -EFAULT;

  		if (is_vm_hugetlb_page(vma)) {
  			i = follow_hugetlb_page(mm, vma, pages, vmas,

  					&start, &nr_pages, i, gup_flags);

  			continue;
  		}

  		do {

  			struct page *page;

  			unsigned int foll_flags = gup_flags;

  			/*

  			 * If we have a pending SIGKILL, don't keep faulting

  			 * pages and potentially allocating memory.

  			 */

  			if (unlikely(fatal_signal_pending(current)))

  				return i ? i : -ERESTARTSYS;

  			cond_resched();

  			while (!(page = follow_page(vma, start, foll_flags))) {

  				int ret;

  				ret = handle_mm_fault(mm, vma, start,
  					(foll_flags & FOLL_WRITE) ?
  					FAULT_FLAG_WRITE : 0);

  				if (ret & VM_FAULT_ERROR) {
  					if (ret & VM_FAULT_OOM)
  						return i ? i : -ENOMEM;

  					if (ret &
  					    (VM_FAULT_HWPOISON|VM_FAULT_SIGBUS))

  						return i ? i : -EFAULT;
  					BUG();
  				}
  				if (ret & VM_FAULT_MAJOR)
  					tsk->maj_flt++;
  				else
  					tsk->min_flt++;

  				/*

  				 * The VM_FAULT_WRITE bit tells us that
  				 * do_wp_page has broken COW when necessary,
  				 * even if maybe_mkwrite decided not to set
  				 * pte_write. We can thus safely do subsequent

  				 * page lookups as if they were reads. But only
  				 * do so when looping for pte_write is futile:
  				 * in some cases userspace may also be wanting
  				 * to write to the gotten user page, which a
  				 * read fault here might prevent (a readonly
  				 * page might get reCOWed by userspace write).

  				 */

  				if ((ret & VM_FAULT_WRITE) &&
  				    !(vma->vm_flags & VM_WRITE))

  					foll_flags &= ~FOLL_WRITE;

  				cond_resched();

  			}

  			if (IS_ERR(page))
  				return i ? i : PTR_ERR(page);

  			if (pages) {

  				pages[i] = page;

  				flush_anon_page(vma, page, start);

  				flush_dcache_page(page);

  			}
  			if (vmas)
  				vmas[i] = vma;
  			i++;
  			start += PAGE_SIZE;

  			nr_pages--;
  		} while (nr_pages && start < vma->vm_end);
  	} while (nr_pages);

  	return i;
  }

  /**
   * get_user_pages() - pin user pages in memory
   * @tsk:	task_struct of target task
   * @mm:		mm_struct of target mm
   * @start:	starting user address

   * @nr_pages:	number of pages from start to pin

   * @write:	whether pages will be written to by the caller
   * @force:	whether to force write access even if user mapping is
   *		readonly. This will result in the page being COWed even
   *		in MAP_SHARED mappings. You do not want this.
   * @pages:	array that receives pointers to the pages pinned.
   *		Should be at least nr_pages long. Or NULL, if caller
   *		only intends to ensure the pages are faulted in.
   * @vmas:	array of pointers to vmas corresponding to each page.
   *		Or NULL if the caller does not require them.
   *
   * Returns number of pages pinned. This may be fewer than the number

   * requested. If nr_pages is 0 or negative, returns 0. If no pages

   * were pinned, returns -errno. Each page returned must be released
   * with a put_page() call when it is finished with. vmas will only
   * remain valid while mmap_sem is held.
   *
   * Must be called with mmap_sem held for read or write.
   *
   * get_user_pages walks a process's page tables and takes a reference to
   * each struct page that each user address corresponds to at a given
   * instant. That is, it takes the page that would be accessed if a user
   * thread accesses the given user virtual address at that instant.
   *
   * This does not guarantee that the page exists in the user mappings when
   * get_user_pages returns, and there may even be a completely different
   * page there in some cases (eg. if mmapped pagecache has been invalidated
   * and subsequently re faulted). However it does guarantee that the page
   * won't be freed completely. And mostly callers simply care that the page
   * contains data that was valid *at some point in time*. Typically, an IO
   * or similar operation cannot guarantee anything stronger anyway because
   * locks can't be held over the syscall boundary.
   *
   * If write=0, the page must not be written to. If the page is written to,
   * set_page_dirty (or set_page_dirty_lock, as appropriate) must be called
   * after the page is finished with, and before put_page is called.
   *
   * get_user_pages is typically used for fewer-copy IO operations, to get a
   * handle on the memory by some means other than accesses via the user virtual
   * addresses. The pages may be submitted for DMA to devices or accessed via
   * their kernel linear mapping (via the kmap APIs). Care should be taken to
   * use the correct cache flushing APIs.
   *
   * See also get_user_pages_fast, for performance critical applications.
   */

  int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,

  		unsigned long start, int nr_pages, int write, int force,

  		struct page **pages, struct vm_area_struct **vmas)
  {

  	int flags = FOLL_TOUCH;

  	if (pages)
  		flags |= FOLL_GET;

  	if (write)

  		flags |= FOLL_WRITE;

  	if (force)

  		flags |= FOLL_FORCE;

  	return __get_user_pages(tsk, mm, start, nr_pages, flags, pages, vmas);

  }

  EXPORT_SYMBOL(get_user_pages);

  /**
   * get_dump_page() - pin user page in memory while writing it to core dump
   * @addr: user address
   *
   * Returns struct page pointer of user page pinned for dump,
   * to be freed afterwards by page_cache_release() or put_page().
   *
   * Returns NULL on any kind of failure - a hole must then be inserted into
   * the corefile, to preserve alignment with its headers; and also returns
   * NULL wherever the ZERO_PAGE, or an anonymous pte_none, has been found -
   * allowing a hole to be left in the corefile to save diskspace.
   *
   * Called without mmap_sem, but after all other threads have been killed.
   */
  #ifdef CONFIG_ELF_CORE
  struct page *get_dump_page(unsigned long addr)
  {
  	struct vm_area_struct *vma;
  	struct page *page;
  
  	if (__get_user_pages(current, current->mm, addr, 1,

  			FOLL_FORCE | FOLL_DUMP | FOLL_GET, &page, &vma) < 1)

  		return NULL;

  	flush_cache_page(vma, addr, page_to_pfn(page));
  	return page;
  }
  #endif /* CONFIG_ELF_CORE */

  pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr,
  			spinlock_t **ptl)

  {
  	pgd_t * pgd = pgd_offset(mm, addr);
  	pud_t * pud = pud_alloc(mm, pgd, addr);
  	if (pud) {

  		pmd_t * pmd = pmd_alloc(mm, pud, addr);

  		if (pmd)
  			return pte_alloc_map_lock(mm, pmd, addr, ptl);
  	}
  	return NULL;
  }

  /*

   * This is the old fallback for page remapping.
   *
   * For historical reasons, it only allows reserved pages. Only
   * old drivers should use this, and they needed to mark their
   * pages reserved for the old functions anyway.
   */

  static int insert_page(struct vm_area_struct *vma, unsigned long addr,
  			struct page *page, pgprot_t prot)

  {

  	struct mm_struct *mm = vma->vm_mm;

  	int retval;

  	pte_t *pte;

  	spinlock_t *ptl;

  	retval = -EINVAL;

  	if (PageAnon(page))

  		goto out;

  	retval = -ENOMEM;
  	flush_dcache_page(page);

  	pte = get_locked_pte(mm, addr, &ptl);

  	if (!pte)

  		goto out;

  	retval = -EBUSY;
  	if (!pte_none(*pte))
  		goto out_unlock;
  
  	/* Ok, finally just insert the thing.. */
  	get_page(page);

  	inc_mm_counter_fast(mm, MM_FILEPAGES);

  	page_add_file_rmap(page);
  	set_pte_at(mm, addr, pte, mk_pte(page, prot));
  
  	retval = 0;

  	pte_unmap_unlock(pte, ptl);
  	return retval;

  out_unlock:
  	pte_unmap_unlock(pte, ptl);
  out:
  	return retval;
  }

  /**
   * vm_insert_page - insert single page into user vma
   * @vma: user vma to map to
   * @addr: target user address of this page
   * @page: source kernel page
   *

   * This allows drivers to insert individual pages they've allocated
   * into a user vma.
   *
   * The page has to be a nice clean _individual_ kernel allocation.
   * If you allocate a compound page, you need to have marked it as
   * such (__GFP_COMP), or manually just split the page up yourself

   * (see split_page()).

   *
   * NOTE! Traditionally this was done with "remap_pfn_range()" which
   * took an arbitrary page protection parameter. This doesn't allow
   * that. Your vma protection will have to be set up correctly, which
   * means that if you want a shared writable mapping, you'd better
   * ask for a shared writable mapping!
   *
   * The page does not need to be reserved.
   */

  int vm_insert_page(struct vm_area_struct *vma, unsigned long addr,
  			struct page *page)

  {
  	if (addr < vma->vm_start || addr >= vma->vm_end)
  		return -EFAULT;
  	if (!page_count(page))
  		return -EINVAL;

  	vma->vm_flags |= VM_INSERTPAGE;

  	return insert_page(vma, addr, page, vma->vm_page_prot);

  }

  EXPORT_SYMBOL(vm_insert_page);

  static int insert_pfn(struct vm_area_struct *vma, unsigned long addr,
  			unsigned long pfn, pgprot_t prot)
  {
  	struct mm_struct *mm = vma->vm_mm;
  	int retval;
  	pte_t *pte, entry;
  	spinlock_t *ptl;
  
  	retval = -ENOMEM;
  	pte = get_locked_pte(mm, addr, &ptl);
  	if (!pte)
  		goto out;
  	retval = -EBUSY;
  	if (!pte_none(*pte))
  		goto out_unlock;
  
  	/* Ok, finally just insert the thing.. */
  	entry = pte_mkspecial(pfn_pte(pfn, prot));
  	set_pte_at(mm, addr, pte, entry);

  	update_mmu_cache(vma, addr, pte); /* XXX: why not for insert_page? */

  
  	retval = 0;
  out_unlock:
  	pte_unmap_unlock(pte, ptl);
  out:
  	return retval;
  }

  /**
   * vm_insert_pfn - insert single pfn into user vma
   * @vma: user vma to map to
   * @addr: target user address of this page
   * @pfn: source kernel pfn
   *
   * Similar to vm_inert_page, this allows drivers to insert individual pages
   * they've allocated into a user vma. Same comments apply.
   *
   * This function should only be called from a vm_ops->fault handler, and
   * in that case the handler should return NULL.

   *
   * vma cannot be a COW mapping.
   *
   * As this is called only for pages that do not currently exist, we
   * do not need to flush old virtual caches or the TLB.

   */
  int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,

  			unsigned long pfn)

  {

  	int ret;

  	pgprot_t pgprot = vma->vm_page_prot;

  	/*
  	 * Technically, architectures with pte_special can avoid all these
  	 * restrictions (same for remap_pfn_range).  However we would like
  	 * consistency in testing and feature parity among all, so we should
  	 * try to keep these invariants in place for everybody.
  	 */

  	BUG_ON(!(vma->vm_flags & (VM_PFNMAP|VM_MIXEDMAP)));
  	BUG_ON((vma->vm_flags & (VM_PFNMAP|VM_MIXEDMAP)) ==
  						(VM_PFNMAP|VM_MIXEDMAP));
  	BUG_ON((vma->vm_flags & VM_PFNMAP) && is_cow_mapping(vma->vm_flags));
  	BUG_ON((vma->vm_flags & VM_MIXEDMAP) && pfn_valid(pfn));

  	if (addr < vma->vm_start || addr >= vma->vm_end)
  		return -EFAULT;

  	if (track_pfn_vma_new(vma, &pgprot, pfn, PAGE_SIZE))

  		return -EINVAL;

  	ret = insert_pfn(vma, addr, pfn, pgprot);

  
  	if (ret)
  		untrack_pfn_vma(vma, pfn, PAGE_SIZE);
  
  	return ret;

  }
  EXPORT_SYMBOL(vm_insert_pfn);

  int vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
  			unsigned long pfn)
  {
  	BUG_ON(!(vma->vm_flags & VM_MIXEDMAP));

  	if (addr < vma->vm_start || addr >= vma->vm_end)
  		return -EFAULT;

  	/*
  	 * If we don't have pte special, then we have to use the pfn_valid()
  	 * based VM_MIXEDMAP scheme (see vm_normal_page), and thus we *must*
  	 * refcount the page if pfn_valid is true (hence insert_page rather

  	 * than insert_pfn).  If a zero_pfn were inserted into a VM_MIXEDMAP
  	 * without pte special, it would there be refcounted as a normal page.

  	 */
  	if (!HAVE_PTE_SPECIAL && pfn_valid(pfn)) {
  		struct page *page;
  
  		page = pfn_to_page(pfn);
  		return insert_page(vma, addr, page, vma->vm_page_prot);
  	}
  	return insert_pfn(vma, addr, pfn, vma->vm_page_prot);

  }

  EXPORT_SYMBOL(vm_insert_mixed);

  /*

   * maps a range of physical memory into the requested pages. the old
   * mappings are removed. any references to nonexistent pages results
   * in null mappings (currently treated as "copy-on-access")
   */
  static int remap_pte_range(struct mm_struct *mm, pmd_t *pmd,
  			unsigned long addr, unsigned long end,
  			unsigned long pfn, pgprot_t prot)
  {
  	pte_t *pte;

  	spinlock_t *ptl;

  	pte = pte_alloc_map_lock(mm, pmd, addr, &ptl);

  	if (!pte)
  		return -ENOMEM;

  	arch_enter_lazy_mmu_mode();

  	do {
  		BUG_ON(!pte_none(*pte));

  		set_pte_at(mm, addr, pte, pte_mkspecial(pfn_pte(pfn, prot)));

  		pfn++;
  	} while (pte++, addr += PAGE_SIZE, addr != end);

  	arch_leave_lazy_mmu_mode();

  	pte_unmap_unlock(pte - 1, ptl);

  	return 0;
  }
  
  static inline int remap_pmd_range(struct mm_struct *mm, pud_t *pud,
  			unsigned long addr, unsigned long end,
  			unsigned long pfn, pgprot_t prot)
  {
  	pmd_t *pmd;
  	unsigned long next;
  
  	pfn -= addr >> PAGE_SHIFT;
  	pmd = pmd_alloc(mm, pud, addr);
  	if (!pmd)
  		return -ENOMEM;
  	do {
  		next = pmd_addr_end(addr, end);
  		if (remap_pte_range(mm, pmd, addr, next,
  				pfn + (addr >> PAGE_SHIFT), prot))
  			return -ENOMEM;
  	} while (pmd++, addr = next, addr != end);
  	return 0;
  }
  
  static inline int remap_pud_range(struct mm_struct *mm, pgd_t *pgd,
  			unsigned long addr, unsigned long end,
  			unsigned long pfn, pgprot_t prot)
  {
  	pud_t *pud;
  	unsigned long next;
  
  	pfn -= addr >> PAGE_SHIFT;
  	pud = pud_alloc(mm, pgd, addr);
  	if (!pud)
  		return -ENOMEM;
  	do {
  		next = pud_addr_end(addr, end);
  		if (remap_pmd_range(mm, pud, addr, next,
  				pfn + (addr >> PAGE_SHIFT), prot))
  			return -ENOMEM;
  	} while (pud++, addr = next, addr != end);
  	return 0;
  }

  /**
   * remap_pfn_range - remap kernel memory to userspace
   * @vma: user vma to map to
   * @addr: target user address to start at
   * @pfn: physical address of kernel memory
   * @size: size of map area
   * @prot: page protection flags for this mapping
   *
   *  Note: this is only safe if the mm semaphore is held when called.
   */

  int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,
  		    unsigned long pfn, unsigned long size, pgprot_t prot)
  {
  	pgd_t *pgd;
  	unsigned long next;

  	unsigned long end = addr + PAGE_ALIGN(size);

  	struct mm_struct *mm = vma->vm_mm;
  	int err;
  
  	/*
  	 * Physically remapped pages are special. Tell the
  	 * rest of the world about it:
  	 *   VM_IO tells people not to look at these pages
  	 *	(accesses can have side effects).

  	 *   VM_RESERVED is specified all over the place, because
  	 *	in 2.4 it kept swapout's vma scan off this vma; but
  	 *	in 2.6 the LRU scan won't even find its pages, so this
  	 *	flag means no more than count its pages in reserved_vm,
  	 * 	and omit it from core dump, even when VM_IO turned off.

  	 *   VM_PFNMAP tells the core MM that the base pages are just
  	 *	raw PFN mappings, and do not have a "struct page" associated
  	 *	with them.

  	 *
  	 * There's a horrible special case to handle copy-on-write
  	 * behaviour that some programs depend on. We mark the "original"
  	 * un-COW'ed pages by matching them up with "vma->vm_pgoff".

  	 */

  	if (addr == vma->vm_start && end == vma->vm_end) {

  		vma->vm_pgoff = pfn;

  		vma->vm_flags |= VM_PFN_AT_MMAP;

  	} else if (is_cow_mapping(vma->vm_flags))

  		return -EINVAL;

  	vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP;

  	err = track_pfn_vma_new(vma, &prot, pfn, PAGE_ALIGN(size));

  	if (err) {
  		/*
  		 * To indicate that track_pfn related cleanup is not
  		 * needed from higher level routine calling unmap_vmas
  		 */
  		vma->vm_flags &= ~(VM_IO | VM_RESERVED | VM_PFNMAP);

  		vma->vm_flags &= ~VM_PFN_AT_MMAP;

  		return -EINVAL;

  	}

  	BUG_ON(addr >= end);
  	pfn -= addr >> PAGE_SHIFT;
  	pgd = pgd_offset(mm, addr);
  	flush_cache_range(vma, addr, end);

  	do {
  		next = pgd_addr_end(addr, end);
  		err = remap_pud_range(mm, pgd, addr, next,
  				pfn + (addr >> PAGE_SHIFT), prot);
  		if (err)
  			break;
  	} while (pgd++, addr = next, addr != end);

  
  	if (err)
  		untrack_pfn_vma(vma, pfn, PAGE_ALIGN(size));

  	return err;
  }
  EXPORT_SYMBOL(remap_pfn_range);

  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 = (mm == &init_mm) ?
  		pte_alloc_kernel(pmd, addr) :
  		pte_alloc_map_lock(mm, pmd, addr, &ptl);
  	if (!pte)
  		return -ENOMEM;
  
  	BUG_ON(pmd_huge(*pmd));

  	arch_enter_lazy_mmu_mode();

  	token = pmd_pgtable(*pmd);

  
  	do {

  		err = fn(pte++, token, addr, data);

  		if (err)
  			break;

  	} while (addr += PAGE_SIZE, addr != end);

  	arch_leave_lazy_mmu_mode();

  	if (mm != &init_mm)
  		pte_unmap_unlock(pte-1, ptl);
  	return err;
  }
  
  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;

  	BUG_ON(pud_huge(*pud));

  	pmd = pmd_alloc(mm, pud, addr);
  	if (!pmd)
  		return -ENOMEM;
  	do {
  		next = pmd_addr_end(addr, end);
  		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 mm_struct *mm, pgd_t *pgd,
  				     unsigned long addr, unsigned long end,
  				     pte_fn_t fn, void *data)
  {
  	pud_t *pud;
  	unsigned long next;
  	int err;
  
  	pud = pud_alloc(mm, pgd, addr);
  	if (!pud)
  		return -ENOMEM;
  	do {
  		next = pud_addr_end(addr, end);
  		err = apply_to_pmd_range(mm, pud, addr, next, fn, data);
  		if (err)
  			break;
  	} while (pud++, addr = next, addr != end);
  	return err;
  }
  
  /*
   * 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_page_range(struct mm_struct *mm, unsigned long addr,
  			unsigned long size, pte_fn_t fn, void *data)
  {
  	pgd_t *pgd;
  	unsigned long next;