/*
   *  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/export.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 <linux/gfp.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)

  static 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 /* SPLIT_RSS_COUNTING */

  
  #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)
  {
  }

  #endif /* SPLIT_RSS_COUNTING */
  
  #ifdef HAVE_GENERIC_MMU_GATHER
  
  static int tlb_next_batch(struct mmu_gather *tlb)
  {
  	struct mmu_gather_batch *batch;
  
  	batch = tlb->active;
  	if (batch->next) {
  		tlb->active = batch->next;
  		return 1;
  	}
  
  	batch = (void *)__get_free_pages(GFP_NOWAIT | __GFP_NOWARN, 0);
  	if (!batch)
  		return 0;
  
  	batch->next = NULL;
  	batch->nr   = 0;
  	batch->max  = MAX_GATHER_BATCH;
  
  	tlb->active->next = batch;
  	tlb->active = batch;
  
  	return 1;
  }
  
  /* tlb_gather_mmu
   *	Called to initialize an (on-stack) mmu_gather structure for page-table
   *	tear-down from @mm. The @fullmm argument is used when @mm is without
   *	users and we're going to destroy the full address space (exit/execve).
   */
  void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, bool fullmm)
  {
  	tlb->mm = mm;
  
  	tlb->fullmm     = fullmm;
  	tlb->need_flush = 0;
  	tlb->fast_mode  = (num_possible_cpus() == 1);
  	tlb->local.next = NULL;
  	tlb->local.nr   = 0;
  	tlb->local.max  = ARRAY_SIZE(tlb->__pages);
  	tlb->active     = &tlb->local;
  
  #ifdef CONFIG_HAVE_RCU_TABLE_FREE
  	tlb->batch = NULL;
  #endif
  }
  
  void tlb_flush_mmu(struct mmu_gather *tlb)
  {
  	struct mmu_gather_batch *batch;
  
  	if (!tlb->need_flush)
  		return;
  	tlb->need_flush = 0;
  	tlb_flush(tlb);
  #ifdef CONFIG_HAVE_RCU_TABLE_FREE
  	tlb_table_flush(tlb);

  #endif

  	if (tlb_fast_mode(tlb))
  		return;
  
  	for (batch = &tlb->local; batch; batch = batch->next) {
  		free_pages_and_swap_cache(batch->pages, batch->nr);
  		batch->nr = 0;
  	}
  	tlb->active = &tlb->local;
  }
  
  /* tlb_finish_mmu
   *	Called at the end of the shootdown operation to free up any resources
   *	that were required.
   */
  void tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
  {
  	struct mmu_gather_batch *batch, *next;
  
  	tlb_flush_mmu(tlb);
  
  	/* keep the page table cache within bounds */
  	check_pgt_cache();
  
  	for (batch = tlb->local.next; batch; batch = next) {
  		next = batch->next;
  		free_pages((unsigned long)batch, 0);
  	}
  	tlb->local.next = NULL;
  }
  
  /* __tlb_remove_page
   *	Must perform the equivalent to __free_pte(pte_get_and_clear(ptep)), while
   *	handling the additional races in SMP caused by other CPUs caching valid
   *	mappings in their TLBs. Returns the number of free page slots left.
   *	When out of page slots we must call tlb_flush_mmu().
   */
  int __tlb_remove_page(struct mmu_gather *tlb, struct page *page)
  {
  	struct mmu_gather_batch *batch;

  	VM_BUG_ON(!tlb->need_flush);

  
  	if (tlb_fast_mode(tlb)) {
  		free_page_and_swap_cache(page);
  		return 1; /* avoid calling tlb_flush_mmu() */
  	}
  
  	batch = tlb->active;
  	batch->pages[batch->nr++] = page;
  	if (batch->nr == batch->max) {
  		if (!tlb_next_batch(tlb))
  			return 0;

  		batch = tlb->active;

  	}
  	VM_BUG_ON(batch->nr > batch->max);
  
  	return batch->max - batch->nr;
  }
  
  #endif /* HAVE_GENERIC_MMU_GATHER */

  #ifdef CONFIG_HAVE_RCU_TABLE_FREE
  
  /*
   * See the comment near struct mmu_table_batch.
   */
  
  static void tlb_remove_table_smp_sync(void *arg)
  {
  	/* Simply deliver the interrupt */
  }
  
  static void tlb_remove_table_one(void *table)
  {
  	/*
  	 * This isn't an RCU grace period and hence the page-tables cannot be
  	 * assumed to be actually RCU-freed.
  	 *
  	 * It is however sufficient for software page-table walkers that rely on
  	 * IRQ disabling. See the comment near struct mmu_table_batch.
  	 */
  	smp_call_function(tlb_remove_table_smp_sync, NULL, 1);
  	__tlb_remove_table(table);
  }
  
  static void tlb_remove_table_rcu(struct rcu_head *head)
  {
  	struct mmu_table_batch *batch;
  	int i;
  
  	batch = container_of(head, struct mmu_table_batch, rcu);
  
  	for (i = 0; i < batch->nr; i++)
  		__tlb_remove_table(batch->tables[i]);
  
  	free_page((unsigned long)batch);
  }
  
  void tlb_table_flush(struct mmu_gather *tlb)
  {
  	struct mmu_table_batch **batch = &tlb->batch;
  
  	if (*batch) {
  		call_rcu_sched(&(*batch)->rcu, tlb_remove_table_rcu);
  		*batch = NULL;
  	}
  }
  
  void tlb_remove_table(struct mmu_gather *tlb, void *table)
  {
  	struct mmu_table_batch **batch = &tlb->batch;
  
  	tlb->need_flush = 1;
  
  	/*
  	 * When there's less then two users of this mm there cannot be a
  	 * concurrent page-table walk.
  	 */
  	if (atomic_read(&tlb->mm->mm_users) < 2) {
  		__tlb_remove_table(table);
  		return;
  	}
  
  	if (*batch == NULL) {
  		*batch = (struct mmu_table_batch *)__get_free_page(GFP_NOWAIT | __GFP_NOWARN);
  		if (*batch == NULL) {
  			tlb_remove_table_one(table);
  			return;
  		}
  		(*batch)->nr = 0;
  	}
  	(*batch)->tables[(*batch)->nr++] = table;
  	if ((*batch)->nr == MAX_TABLE_BATCH)
  		tlb_table_flush(tlb);
  }

  #endif /* CONFIG_HAVE_RCU_TABLE_FREE */

  /*
   * 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;

  
  	/*
  	 * 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;

  	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, struct vm_area_struct *vma,
  		pmd_t *pmd, unsigned long address)

  {

  	pgtable_t new = pte_alloc_one(mm, address);

  	int wait_split_huge_page;

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

  	wait_split_huge_page = 0;
  	if (likely(pmd_none(*pmd))) {	/* Has another populated it ? */

  		mm->nr_ptes++;

  		pmd_populate(mm, pmd, new);

  		new = NULL;

  	} else if (unlikely(pmd_trans_splitting(*pmd)))
  		wait_split_huge_page = 1;

  	spin_unlock(&mm->page_table_lock);

  	if (new)
  		pte_free(mm, new);

  	if (wait_split_huge_page)
  		wait_split_huge_page(vma->anon_vma, pmd);

  	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 (likely(pmd_none(*pmd))) {	/* Has another populated it ? */

  		pmd_populate_kernel(&init_mm, pmd, new);

  		new = NULL;

  	} else
  		VM_BUG_ON(pmd_trans_splitting(*pmd));

  	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)
  		dump_page(page);

  	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(vm_flags_t 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;

  }

  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(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(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_trans_huge(*src_pmd)) {
  			int err;

  			VM_BUG_ON(next-addr != HPAGE_PMD_SIZE);

  			err = copy_huge_pmd(dst_mm, src_mm,
  					    dst_pmd, src_pmd, addr, vma);
  			if (err == -ENOMEM)
  				return -ENOMEM;
  			if (!err)
  				continue;
  			/* fall through */
  		}

  		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,

  				struct zap_details *details)

  {

  	struct mm_struct *mm = tlb->mm;

  	int force_flush = 0;

  	int rss[NR_MM_COUNTERS];

  	spinlock_t *ptl;

  	pte_t *start_pte;

  	pte_t *pte;

  again:

  	init_rss_vec(rss);

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

  	arch_enter_lazy_mmu_mode();

  	do {
  		pte_t ptent = *pte;

  		if (pte_none(ptent)) {

  			continue;

  		}

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

  			force_flush = !__tlb_remove_page(tlb, page);
  			if (force_flush)
  				break;

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

  	add_mm_rss_vec(mm, rss);

  	arch_leave_lazy_mmu_mode();

  	pte_unmap_unlock(start_pte, ptl);

  	/*
  	 * mmu_gather ran out of room to batch pages, we break out of
  	 * the PTE lock to avoid doing the potential expensive TLB invalidate
  	 * and page-free while holding it.
  	 */
  	if (force_flush) {
  		force_flush = 0;
  		tlb_flush_mmu(tlb);
  		if (addr != end)
  			goto again;
  	}

  	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,

  				struct zap_details *details)

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

  		if (pmd_trans_huge(*pmd)) {

  			if (next-addr != HPAGE_PMD_SIZE) {
  				VM_BUG_ON(!rwsem_is_locked(&tlb->mm->mmap_sem));

  				split_huge_page_pmd(vma->vm_mm, pmd);

  			} else if (zap_huge_pmd(tlb, vma, pmd, addr))

  				continue;

  			/* fall through */
  		}

  		if (pmd_none_or_clear_bad(pmd))

  			continue;

  		next = zap_pte_range(tlb, vma, pmd, addr, next, details);
  		cond_resched();
  	} while (pmd++, addr = next, addr != end);

  
  	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,

  				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))

  			continue;

  		next = zap_pmd_range(tlb, vma, pud, addr, next, details);
  	} while (pud++, addr = next, addr != end);

  
  	return addr;

  }

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

  				unsigned long addr, unsigned long end,

  				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))

  			continue;

  		next = zap_pud_range(tlb, vma, pgd, addr, next, details);
  	} while (pgd++, addr = next, addr != end);

  	tlb_end_vma(tlb, vma);

  	mem_cgroup_uncharge_end();

  
  	return addr;

  }

  /**
   * unmap_vmas - unmap a range of memory covered by a list of vma's

   * @tlb: 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.

   *

   * 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 *tlb,

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

  	unsigned long start = start_addr;

  	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 (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);

  				start = end;
  			} else

  				start = unmap_page_range(tlb, vma, start, end, details);

  		}
  	}

  	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_gather_mmu(&tlb, mm, 0);

  	update_hiwater_rss(mm);

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

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

  /**
   * follow_page - look up a page descriptor from a user-virtual address
   * @vma: vm_area_struct mapping @address
   * @address: virtual address to look up
   * @flags: flags modifying lookup behaviour
   *
   * @flags can have FOLL_ flags set, defined in <linux/mm.h>
   *
   * Returns the mapped (struct page *), %NULL if no mapping exists, or
   * an error pointer if there is a mapping to something not represented
   * by a page descriptor (see also vm_normal_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) && vma->vm_flags & VM_HUGETLB) {

  		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) && vma->vm_flags & VM_HUGETLB) {

  		BUG_ON(flags & FOLL_GET);
  		page = follow_huge_pmd(mm, address, pmd, flags & FOLL_WRITE);

  		goto out;

  	}

  	if (pmd_trans_huge(*pmd)) {

  		if (flags & FOLL_SPLIT) {
  			split_huge_page_pmd(mm, pmd);
  			goto split_fallthrough;
  		}

  		spin_lock(&mm->page_table_lock);
  		if (likely(pmd_trans_huge(*pmd))) {
  			if (unlikely(pmd_trans_splitting(*pmd))) {
  				spin_unlock(&mm->page_table_lock);
  				wait_split_huge_page(vma->anon_vma, pmd);
  			} else {
  				page = follow_trans_huge_pmd(mm, address,
  							     pmd, flags);
  				spin_unlock(&mm->page_table_lock);
  				goto out;
  			}
  		} else
  			spin_unlock(&mm->page_table_lock);
  		/* fall through */
  	}

  split_fallthrough:

  	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_foll(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);
  	}

  	if ((flags & FOLL_MLOCK) && (vma->vm_flags & VM_LOCKED)) {

  		/*
  		 * The preliminary mapping check is mainly to avoid the
  		 * pointless overhead of lock_page on the ZERO_PAGE
  		 * which might bounce very badly if there is contention.
  		 *
  		 * If the page is already locked, we don't need to
  		 * handle it now - vmscan will handle it later if and
  		 * when it attempts to reclaim the page.
  		 */
  		if (page->mapping && trylock_page(page)) {
  			lru_add_drain();  /* push cached pages to LRU */
  			/*
  			 * Because we lock page here and migration is
  			 * blocked by the pte's page reference, we need
  			 * only check for file-cache page truncation.
  			 */
  			if (page->mapping)
  				mlock_vma_page(page);
  			unlock_page(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;

  }

  static inline int stack_guard_page(struct vm_area_struct *vma, unsigned long addr)
  {

  	return stack_guard_page_start(vma, addr) ||
  	       stack_guard_page_end(vma, addr+PAGE_SIZE);

  }

  /**
   * __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
   * @gup_flags:	flags modifying pin behaviour
   * @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.
   * @nonblocking: whether waiting for disk IO or mmap_sem contention
   *
   * 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 @gup_flags & FOLL_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.
   *
   * If @nonblocking != NULL, __get_user_pages will not wait for disk IO
   * or mmap_sem contention, and if waiting is needed to pin all pages,
   * *@nonblocking will be set to 0.
   *
   * In most cases, get_user_pages or get_user_pages_fast should be used
   * instead of __get_user_pages. __get_user_pages should be used only if
   * you need some special @gup_flags.
   */

  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 *nonblocking)

  {
  	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(mm, start)) {

  			unsigned long pg = start & PAGE_MASK;

  			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;

  			VM_BUG_ON(pmd_trans_huge(*pmd));

  			pte = pte_offset_map(pmd, pg);

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

  			vma = get_gate_vma(mm);

  			if (pages) {

  				struct page *page;

  				page = vm_normal_page(vma, start, *pte);

  				if (!page) {
  					if (!(gup_flags & FOLL_DUMP) &&
  					     is_zero_pfn(pte_pfn(*pte)))
  						page = pte_page(*pte);
  					else {
  						pte_unmap(pte);
  						return i ? : -EFAULT;
  					}
  				}

  				pages[i] = page;

  				get_page(page);

  			}
  			pte_unmap(pte);

  			goto next_page;

  		}

  		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;

  				unsigned int fault_flags = 0;

  				/* For mlock, just skip the stack guard page. */
  				if (foll_flags & FOLL_MLOCK) {
  					if (stack_guard_page(vma, start))
  						goto next_page;
  				}

  				if (foll_flags & FOLL_WRITE)
  					fault_flags |= FAULT_FLAG_WRITE;
  				if (nonblocking)
  					fault_flags |= FAULT_FLAG_ALLOW_RETRY;

  				if (foll_flags & FOLL_NOWAIT)
  					fault_flags |= (FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT);

  				ret = handle_mm_fault(mm, vma, start,

  							fault_flags);

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

  					if (ret & (VM_FAULT_HWPOISON |
  						   VM_FAULT_HWPOISON_LARGE)) {
  						if (i)
  							return i;
  						else if (gup_flags & FOLL_HWPOISON)
  							return -EHWPOISON;
  						else
  							return -EFAULT;
  					}
  					if (ret & VM_FAULT_SIGBUS)

  						return i ? i : -EFAULT;
  					BUG();
  				}

  
  				if (tsk) {
  					if (ret & VM_FAULT_MAJOR)
  						tsk->maj_flt++;
  					else
  						tsk->min_flt++;
  				}

  				if (ret & VM_FAULT_RETRY) {

  					if (nonblocking)
  						*nonblocking = 0;

  					return i;
  				}

  				/*

  				 * 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);

  			}

  next_page:

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

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

  	return i;
  }

  EXPORT_SYMBOL(__get_user_pages);

  /*
   * fixup_user_fault() - manually resolve a user page fault
   * @tsk:	the task_struct to use for page fault accounting, or
   *		NULL if faults are not to be recorded.
   * @mm:		mm_struct of target mm
   * @address:	user address
   * @fault_flags:flags to pass down to handle_mm_fault()
   *
   * This is meant to be called in the specific scenario where for locking reasons
   * we try to access user memory in atomic context (within a pagefault_disable()
   * section), this returns -EFAULT, and we want to resolve the user fault before
   * trying again.
   *
   * Typically this is meant to be used by the futex code.
   *
   * The main difference with get_user_pages() is that this function will
   * unconditionally call handle_mm_fault() which will in turn perform all the
   * necessary SW fixup of the dirty and young bits in the PTE, while
   * handle_mm_fault() only guarantees to update these in the struct page.
   *
   * This is important for some architectures where those bits also gate the
   * access permission to the page because they are maintained in software.  On
   * such architectures, gup() will not be enough to make a subsequent access
   * succeed.
   *
   * This should be called with the mm_sem held for read.
   */
  int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
  		     unsigned long address, unsigned int fault_flags)
  {
  	struct vm_area_struct *vma;
  	int ret;
  
  	vma = find_extend_vma(mm, address);
  	if (!vma || address < vma->vm_start)
  		return -EFAULT;
  
  	ret = handle_mm_fault(mm, vma, address, fault_flags);
  	if (ret & VM_FAULT_ERROR) {
  		if (ret & VM_FAULT_OOM)
  			return -ENOMEM;
  		if (ret & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE))
  			return -EHWPOISON;
  		if (ret & VM_FAULT_SIGBUS)
  			return -EFAULT;
  		BUG();
  	}
  	if (tsk) {
  		if (ret & VM_FAULT_MAJOR)
  			tsk->maj_flt++;
  		else
  			tsk->min_flt++;
  	}
  	return 0;
  }
  
  /*

   * get_user_pages() - pin user pages in memory

   * @tsk:	the task_struct to use for page fault accounting, or
   *		NULL if faults are not to be recorded.

   * @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,
  				NULL);

  }

  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,
  			     NULL) < 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) {
  			VM_BUG_ON(pmd_trans_huge(*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)

  {