1 #include <linux/mm.h> 2 #include <asm/pgalloc.h> 3 #include <asm/pgtable.h> 4 #include <asm/tlb.h> 5 #include <asm/fixmap.h> 6 7 #define PGALLOC_GFP GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO 8 9 #ifdef CONFIG_HIGHPTE 10 #define PGALLOC_USER_GFP __GFP_HIGHMEM 11 #else 12 #define PGALLOC_USER_GFP 0 13 #endif 14 15 gfp_t __userpte_alloc_gfp = PGALLOC_GFP | PGALLOC_USER_GFP; 16 17 pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address) 18 { 19 return (pte_t *)__get_free_page(PGALLOC_GFP); 20 } 21 22 pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address) 23 { 24 struct page *pte; 25 26 pte = alloc_pages(__userpte_alloc_gfp, 0); 27 if (pte) 28 pgtable_page_ctor(pte); 29 return pte; 30 } 31 32 static int __init setup_userpte(char *arg) 33 { 34 if (!arg) 35 return -EINVAL; 36 37 /* 38 * "userpte=nohigh" disables allocation of user pagetables in 39 * high memory. 40 */ 41 if (strcmp(arg, "nohigh") == 0) 42 __userpte_alloc_gfp &= ~__GFP_HIGHMEM; 43 else 44 return -EINVAL; 45 return 0; 46 } 47 early_param("userpte", setup_userpte); 48 49 void ___pte_free_tlb(struct mmu_gather *tlb, struct page *pte) 50 { 51 pgtable_page_dtor(pte); 52 paravirt_release_pte(page_to_pfn(pte)); 53 tlb_remove_page(tlb, pte); 54 } 55 56 #if PAGETABLE_LEVELS > 2 57 void ___pmd_free_tlb(struct mmu_gather *tlb, pmd_t *pmd) 58 { 59 paravirt_release_pmd(__pa(pmd) >> PAGE_SHIFT); 60 tlb_remove_page(tlb, virt_to_page(pmd)); 61 } 62 63 #if PAGETABLE_LEVELS > 3 64 void ___pud_free_tlb(struct mmu_gather *tlb, pud_t *pud) 65 { 66 paravirt_release_pud(__pa(pud) >> PAGE_SHIFT); 67 tlb_remove_page(tlb, virt_to_page(pud)); 68 } 69 #endif /* PAGETABLE_LEVELS > 3 */ 70 #endif /* PAGETABLE_LEVELS > 2 */ 71 72 static inline void pgd_list_add(pgd_t *pgd) 73 { 74 struct page *page = virt_to_page(pgd); 75 76 list_add(&page->lru, &pgd_list); 77 } 78 79 static inline void pgd_list_del(pgd_t *pgd) 80 { 81 struct page *page = virt_to_page(pgd); 82 83 list_del(&page->lru); 84 } 85 86 #define UNSHARED_PTRS_PER_PGD \ 87 (SHARED_KERNEL_PMD ? KERNEL_PGD_BOUNDARY : PTRS_PER_PGD) 88 89 static void pgd_ctor(pgd_t *pgd) 90 { 91 /* If the pgd points to a shared pagetable level (either the 92 ptes in non-PAE, or shared PMD in PAE), then just copy the 93 references from swapper_pg_dir. */ 94 if (PAGETABLE_LEVELS == 2 || 95 (PAGETABLE_LEVELS == 3 && SHARED_KERNEL_PMD) || 96 PAGETABLE_LEVELS == 4) { 97 clone_pgd_range(pgd + KERNEL_PGD_BOUNDARY, 98 swapper_pg_dir + KERNEL_PGD_BOUNDARY, 99 KERNEL_PGD_PTRS); 100 paravirt_alloc_pmd_clone(__pa(pgd) >> PAGE_SHIFT, 101 __pa(swapper_pg_dir) >> PAGE_SHIFT, 102 KERNEL_PGD_BOUNDARY, 103 KERNEL_PGD_PTRS); 104 } 105 106 /* list required to sync kernel mapping updates */ 107 if (!SHARED_KERNEL_PMD) 108 pgd_list_add(pgd); 109 } 110 111 static void pgd_dtor(pgd_t *pgd) 112 { 113 unsigned long flags; /* can be called from interrupt context */ 114 115 if (SHARED_KERNEL_PMD) 116 return; 117 118 spin_lock_irqsave(&pgd_lock, flags); 119 pgd_list_del(pgd); 120 spin_unlock_irqrestore(&pgd_lock, flags); 121 } 122 123 /* 124 * List of all pgd's needed for non-PAE so it can invalidate entries 125 * in both cached and uncached pgd's; not needed for PAE since the 126 * kernel pmd is shared. If PAE were not to share the pmd a similar 127 * tactic would be needed. This is essentially codepath-based locking 128 * against pageattr.c; it is the unique case in which a valid change 129 * of kernel pagetables can't be lazily synchronized by vmalloc faults. 130 * vmalloc faults work because attached pagetables are never freed. 131 * -- wli 132 */ 133 134 #ifdef CONFIG_X86_PAE 135 /* 136 * In PAE mode, we need to do a cr3 reload (=tlb flush) when 137 * updating the top-level pagetable entries to guarantee the 138 * processor notices the update. Since this is expensive, and 139 * all 4 top-level entries are used almost immediately in a 140 * new process's life, we just pre-populate them here. 141 * 142 * Also, if we're in a paravirt environment where the kernel pmd is 143 * not shared between pagetables (!SHARED_KERNEL_PMDS), we allocate 144 * and initialize the kernel pmds here. 145 */ 146 #define PREALLOCATED_PMDS UNSHARED_PTRS_PER_PGD 147 148 void pud_populate(struct mm_struct *mm, pud_t *pudp, pmd_t *pmd) 149 { 150 paravirt_alloc_pmd(mm, __pa(pmd) >> PAGE_SHIFT); 151 152 /* Note: almost everything apart from _PAGE_PRESENT is 153 reserved at the pmd (PDPT) level. */ 154 set_pud(pudp, __pud(__pa(pmd) | _PAGE_PRESENT)); 155 156 /* 157 * According to Intel App note "TLBs, Paging-Structure Caches, 158 * and Their Invalidation", April 2007, document 317080-001, 159 * section 8.1: in PAE mode we explicitly have to flush the 160 * TLB via cr3 if the top-level pgd is changed... 161 */ 162 if (mm == current->active_mm) 163 write_cr3(read_cr3()); 164 } 165 #else /* !CONFIG_X86_PAE */ 166 167 /* No need to prepopulate any pagetable entries in non-PAE modes. */ 168 #define PREALLOCATED_PMDS 0 169 170 #endif /* CONFIG_X86_PAE */ 171 172 static void free_pmds(pmd_t *pmds[]) 173 { 174 int i; 175 176 for(i = 0; i < PREALLOCATED_PMDS; i++) 177 if (pmds[i]) 178 free_page((unsigned long)pmds[i]); 179 } 180 181 static int preallocate_pmds(pmd_t *pmds[]) 182 { 183 int i; 184 bool failed = false; 185 186 for(i = 0; i < PREALLOCATED_PMDS; i++) { 187 pmd_t *pmd = (pmd_t *)__get_free_page(PGALLOC_GFP); 188 if (pmd == NULL) 189 failed = true; 190 pmds[i] = pmd; 191 } 192 193 if (failed) { 194 free_pmds(pmds); 195 return -ENOMEM; 196 } 197 198 return 0; 199 } 200 201 /* 202 * Mop up any pmd pages which may still be attached to the pgd. 203 * Normally they will be freed by munmap/exit_mmap, but any pmd we 204 * preallocate which never got a corresponding vma will need to be 205 * freed manually. 206 */ 207 static void pgd_mop_up_pmds(struct mm_struct *mm, pgd_t *pgdp) 208 { 209 int i; 210 211 for(i = 0; i < PREALLOCATED_PMDS; i++) { 212 pgd_t pgd = pgdp[i]; 213 214 if (pgd_val(pgd) != 0) { 215 pmd_t *pmd = (pmd_t *)pgd_page_vaddr(pgd); 216 217 pgdp[i] = native_make_pgd(0); 218 219 paravirt_release_pmd(pgd_val(pgd) >> PAGE_SHIFT); 220 pmd_free(mm, pmd); 221 } 222 } 223 } 224 225 static void pgd_prepopulate_pmd(struct mm_struct *mm, pgd_t *pgd, pmd_t *pmds[]) 226 { 227 pud_t *pud; 228 unsigned long addr; 229 int i; 230 231 if (PREALLOCATED_PMDS == 0) /* Work around gcc-3.4.x bug */ 232 return; 233 234 pud = pud_offset(pgd, 0); 235 236 for (addr = i = 0; i < PREALLOCATED_PMDS; 237 i++, pud++, addr += PUD_SIZE) { 238 pmd_t *pmd = pmds[i]; 239 240 if (i >= KERNEL_PGD_BOUNDARY) 241 memcpy(pmd, (pmd_t *)pgd_page_vaddr(swapper_pg_dir[i]), 242 sizeof(pmd_t) * PTRS_PER_PMD); 243 244 pud_populate(mm, pud, pmd); 245 } 246 } 247 248 pgd_t *pgd_alloc(struct mm_struct *mm) 249 { 250 pgd_t *pgd; 251 pmd_t *pmds[PREALLOCATED_PMDS]; 252 unsigned long flags; 253 254 pgd = (pgd_t *)__get_free_page(PGALLOC_GFP); 255 256 if (pgd == NULL) 257 goto out; 258 259 mm->pgd = pgd; 260 261 if (preallocate_pmds(pmds) != 0) 262 goto out_free_pgd; 263 264 if (paravirt_pgd_alloc(mm) != 0) 265 goto out_free_pmds; 266 267 /* 268 * Make sure that pre-populating the pmds is atomic with 269 * respect to anything walking the pgd_list, so that they 270 * never see a partially populated pgd. 271 */ 272 spin_lock_irqsave(&pgd_lock, flags); 273 274 pgd_ctor(pgd); 275 pgd_prepopulate_pmd(mm, pgd, pmds); 276 277 spin_unlock_irqrestore(&pgd_lock, flags); 278 279 return pgd; 280 281 out_free_pmds: 282 free_pmds(pmds); 283 out_free_pgd: 284 free_page((unsigned long)pgd); 285 out: 286 return NULL; 287 } 288 289 void pgd_free(struct mm_struct *mm, pgd_t *pgd) 290 { 291 pgd_mop_up_pmds(mm, pgd); 292 pgd_dtor(pgd); 293 paravirt_pgd_free(mm, pgd); 294 free_page((unsigned long)pgd); 295 } 296 297 int ptep_set_access_flags(struct vm_area_struct *vma, 298 unsigned long address, pte_t *ptep, 299 pte_t entry, int dirty) 300 { 301 int changed = !pte_same(*ptep, entry); 302 303 if (changed && dirty) { 304 *ptep = entry; 305 pte_update_defer(vma->vm_mm, address, ptep); 306 flush_tlb_page(vma, address); 307 } 308 309 return changed; 310 } 311 312 int ptep_test_and_clear_young(struct vm_area_struct *vma, 313 unsigned long addr, pte_t *ptep) 314 { 315 int ret = 0; 316 317 if (pte_young(*ptep)) 318 ret = test_and_clear_bit(_PAGE_BIT_ACCESSED, 319 (unsigned long *) &ptep->pte); 320 321 if (ret) 322 pte_update(vma->vm_mm, addr, ptep); 323 324 return ret; 325 } 326 327 int ptep_clear_flush_young(struct vm_area_struct *vma, 328 unsigned long address, pte_t *ptep) 329 { 330 int young; 331 332 young = ptep_test_and_clear_young(vma, address, ptep); 333 if (young) 334 flush_tlb_page(vma, address); 335 336 return young; 337 } 338 339 /** 340 * reserve_top_address - reserves a hole in the top of kernel address space 341 * @reserve - size of hole to reserve 342 * 343 * Can be used to relocate the fixmap area and poke a hole in the top 344 * of kernel address space to make room for a hypervisor. 345 */ 346 void __init reserve_top_address(unsigned long reserve) 347 { 348 #ifdef CONFIG_X86_32 349 BUG_ON(fixmaps_set > 0); 350 printk(KERN_INFO "Reserving virtual address space above 0x%08x\n", 351 (int)-reserve); 352 __FIXADDR_TOP = -reserve - PAGE_SIZE; 353 #endif 354 } 355 356 int fixmaps_set; 357 358 void __native_set_fixmap(enum fixed_addresses idx, pte_t pte) 359 { 360 unsigned long address = __fix_to_virt(idx); 361 362 if (idx >= __end_of_fixed_addresses) { 363 BUG(); 364 return; 365 } 366 set_pte_vaddr(address, pte); 367 fixmaps_set++; 368 } 369 370 void native_set_fixmap(enum fixed_addresses idx, phys_addr_t phys, 371 pgprot_t flags) 372 { 373 __native_set_fixmap(idx, pfn_pte(phys >> PAGE_SHIFT, flags)); 374 } 375