arch/x86/mm/pgtable_32.c

   1 #include <linux/sched.h>
   2 #include <linux/kernel.h>
   3 #include <linux/errno.h>
   4 #include <linux/mm.h>
   5 #include <linux/nmi.h>
   6 #include <linux/swap.h>
   7 #include <linux/smp.h>
   8 #include <linux/highmem.h>
   9 #include <linux/pagemap.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/module.h>
  12
  13 #include <asm/pgtable.h>
  14 #include <asm/pgalloc.h>
  15 #include <asm/fixmap.h>
  16 #include <asm/e820.h>
  17 #include <asm/tlb.h>
  18 #include <asm/tlbflush.h>
  19 #include <asm/io.h>
  20
  21 unsigned int __VMALLOC_RESERVE = 128 << 20;
  22
  23 /*
  24  * Associate a virtual page frame with a given physical page frame
  25  * and protection flags for that frame.
  26  */
  27 void set_pte_vaddr(unsigned long vaddr, pte_t pteval)
  28 {
  29         pgd_t *pgd;
  30         pud_t *pud;
  31         pmd_t *pmd;
  32         pte_t *pte;
  33
  34         pgd = swapper_pg_dir + pgd_index(vaddr);
  35         if (pgd_none(*pgd)) {
  36                 BUG();
  37                 return;
  38         }
  39         pud = pud_offset(pgd, vaddr);
  40         if (pud_none(*pud)) {
  41                 BUG();
  42                 return;
  43         }
  44         pmd = pmd_offset(pud, vaddr);
  45         if (pmd_none(*pmd)) {
  46                 BUG();
  47                 return;
  48         }
  49         pte = pte_offset_kernel(pmd, vaddr);
  50         if (pte_val(pteval))
  51                 set_pte_at(&init_mm, vaddr, pte, pteval);
  52         else
  53                 pte_clear(&init_mm, vaddr, pte);
  54
  55         /*
  56          * It's enough to flush this one mapping.
  57          * (PGE mappings get flushed as well)
  58          */
  59         __flush_tlb_one(vaddr);
  60 }
  61
  62 /*
  63  * Associate a large virtual page frame with a given physical page frame
  64  * and protection flags for that frame. pfn is for the base of the page,
  65  * vaddr is what the page gets mapped to - both must be properly aligned.
  66  * The pmd must already be instantiated. Assumes PAE mode.
  67  */
  68 void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags)
  69 {
  70         pgd_t *pgd;
  71         pud_t *pud;
  72         pmd_t *pmd;
  73
  74         if (vaddr & (PMD_SIZE-1)) {             /* vaddr is misaligned */
  75                 printk(KERN_WARNING "set_pmd_pfn: vaddr misaligned\n");
  76                 return; /* BUG(); */
  77         }
  78         if (pfn & (PTRS_PER_PTE-1)) {           /* pfn is misaligned */
  79                 printk(KERN_WARNING "set_pmd_pfn: pfn misaligned\n");
  80                 return; /* BUG(); */
  81         }
  82         pgd = swapper_pg_dir + pgd_index(vaddr);
  83         if (pgd_none(*pgd)) {
  84                 printk(KERN_WARNING "set_pmd_pfn: pgd_none\n");
  85                 return; /* BUG(); */
  86         }
  87         pud = pud_offset(pgd, vaddr);
  88         pmd = pmd_offset(pud, vaddr);
  89         set_pmd(pmd, pfn_pmd(pfn, flags));
  90         /*
  91          * It's enough to flush this one mapping.
  92          * (PGE mappings get flushed as well)
  93          */
  94         __flush_tlb_one(vaddr);
  95 }
  96
  97 unsigned long __FIXADDR_TOP = 0xfffff000;
  98 EXPORT_SYMBOL(__FIXADDR_TOP);
  99
 100 /*
 101  * vmalloc=size forces the vmalloc area to be exactly 'size'
 102  * bytes. This can be used to increase (or decrease) the
 103  * vmalloc area - the default is 128m.
 104  */
 105 static int __init parse_vmalloc(char *arg)
 106 {
 107         if (!arg)
 108                 return -EINVAL;
 109
 110         /* Add VMALLOC_OFFSET to the parsed value due to vm area guard hole*/
 111         __VMALLOC_RESERVE = memparse(arg, &arg) + VMALLOC_OFFSET;
 112         return 0;
 113 }
 114 early_param("vmalloc", parse_vmalloc);
 115
 116 /*
 117  * reservetop=size reserves a hole at the top of the kernel address space which
 118  * a hypervisor can load into later.  Needed for dynamically loaded hypervisors,
 119  * so relocating the fixmap can be done before paging initialization.
 120  */
 121 static int __init parse_reservetop(char *arg)
 122 {
 123         unsigned long address;
 124
 125         if (!arg)
 126                 return -EINVAL;
 127
 128         address = memparse(arg, &arg);
 129         reserve_top_address(address);
 130         early_ioremap_init();
 131         return 0;
 132 }
 133 early_param("reservetop", parse_reservetop);