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