arch/x86/mm/pgtable.c

   1 #include <linux/mm.h>
   2 #include <linux/gfp.h>
   3 #include <linux/hugetlb.h>
   4 #include <asm/pgalloc.h>
   5 #include <asm/pgtable.h>
   6 #include <asm/tlb.h>
   7 #include <asm/fixmap.h>
   8 #include <asm/mtrr.h>
   9
  10 #define PGALLOC_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO)
  11
  12 #ifdef CONFIG_HIGHPTE
  13 #define PGALLOC_USER_GFP __GFP_HIGHMEM
  14 #else
  15 #define PGALLOC_USER_GFP 0
  16 #endif
  17
  18 gfp_t __userpte_alloc_gfp = PGALLOC_GFP | PGALLOC_USER_GFP;
  19
  20 pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
  21 {
  22         return (pte_t *)__get_free_page(PGALLOC_GFP);
  23 }
  24
  25 pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
  26 {
  27         struct page *pte;
  28
  29         pte = alloc_pages(__userpte_alloc_gfp, 0);
  30         if (!pte)
  31                 return NULL;
  32         if (!pgtable_page_ctor(pte)) {
  33                 __free_page(pte);
  34                 return NULL;
  35         }
  36         return pte;
  37 }
  38
  39 static int __init setup_userpte(char *arg)
  40 {
  41         if (!arg)
  42                 return -EINVAL;
  43
  44         /*
  45          * "userpte=nohigh" disables allocation of user pagetables in
  46          * high memory.
  47          */
  48         if (strcmp(arg, "nohigh") == 0)
  49                 __userpte_alloc_gfp &= ~__GFP_HIGHMEM;
  50         else
  51                 return -EINVAL;
  52         return 0;
  53 }
  54 early_param("userpte", setup_userpte);
  55
  56 void ___pte_free_tlb(struct mmu_gather *tlb, struct page *pte)
  57 {
  58         pgtable_page_dtor(pte);
  59         paravirt_release_pte(page_to_pfn(pte));
  60         tlb_remove_page(tlb, pte);
  61 }
  62
  63 #if CONFIG_PGTABLE_LEVELS > 2
  64 void ___pmd_free_tlb(struct mmu_gather *tlb, pmd_t *pmd)
  65 {
  66         struct page *page = virt_to_page(pmd);
  67         paravirt_release_pmd(__pa(pmd) >> PAGE_SHIFT);
  68         /*
  69          * NOTE! For PAE, any changes to the top page-directory-pointer-table
  70          * entries need a full cr3 reload to flush.
  71          */
  72 #ifdef CONFIG_X86_PAE
  73         tlb->need_flush_all = 1;
  74 #endif
  75         pgtable_pmd_page_dtor(page);
  76         tlb_remove_page(tlb, page);
  77 }
  78
  79 #if CONFIG_PGTABLE_LEVELS > 3
  80 void ___pud_free_tlb(struct mmu_gather *tlb, pud_t *pud)
  81 {
  82         paravirt_release_pud(__pa(pud) >> PAGE_SHIFT);
  83         tlb_remove_page(tlb, virt_to_page(pud));
  84 }
  85 #endif  /* CONFIG_PGTABLE_LEVELS > 3 */
  86 #endif  /* CONFIG_PGTABLE_LEVELS > 2 */
  87
  88 static inline void pgd_list_add(pgd_t *pgd)
  89 {
  90         struct page *page = virt_to_page(pgd);
  91
  92         list_add(&page->lru, &pgd_list);
  93 }
  94
  95 static inline void pgd_list_del(pgd_t *pgd)
  96 {
  97         struct page *page = virt_to_page(pgd);
  98
  99         list_del(&page->lru);
 100 }
 101
 102 #define UNSHARED_PTRS_PER_PGD                           \
 103         (SHARED_KERNEL_PMD ? KERNEL_PGD_BOUNDARY : PTRS_PER_PGD)
 104
 105
 106 static void pgd_set_mm(pgd_t *pgd, struct mm_struct *mm)
 107 {
 108         BUILD_BUG_ON(sizeof(virt_to_page(pgd)->index) < sizeof(mm));
 109         virt_to_page(pgd)->index = (pgoff_t)mm;
 110 }
 111
 112 struct mm_struct *pgd_page_get_mm(struct page *page)
 113 {
 114         return (struct mm_struct *)page->index;
 115 }
 116
 117 static void pgd_ctor(struct mm_struct *mm, pgd_t *pgd)
 118 {
 119         /* If the pgd points to a shared pagetable level (either the
 120            ptes in non-PAE, or shared PMD in PAE), then just copy the
 121            references from swapper_pg_dir. */
 122         if (CONFIG_PGTABLE_LEVELS == 2 ||
 123             (CONFIG_PGTABLE_LEVELS == 3 && SHARED_KERNEL_PMD) ||
 124             CONFIG_PGTABLE_LEVELS == 4) {
 125                 clone_pgd_range(pgd + KERNEL_PGD_BOUNDARY,
 126                                 swapper_pg_dir + KERNEL_PGD_BOUNDARY,
 127                                 KERNEL_PGD_PTRS);
 128         }
 129
 130         /* list required to sync kernel mapping updates */
 131         if (!SHARED_KERNEL_PMD) {
 132                 pgd_set_mm(pgd, mm);
 133                 pgd_list_add(pgd);
 134         }
 135 }
 136
 137 static void pgd_dtor(pgd_t *pgd)
 138 {
 139         if (SHARED_KERNEL_PMD)
 140                 return;
 141
 142         spin_lock(&pgd_lock);
 143         pgd_list_del(pgd);
 144         spin_unlock(&pgd_lock);
 145 }
 146
 147 /*
 148  * List of all pgd's needed for non-PAE so it can invalidate entries
 149  * in both cached and uncached pgd's; not needed for PAE since the
 150  * kernel pmd is shared. If PAE were not to share the pmd a similar
 151  * tactic would be needed. This is essentially codepath-based locking
 152  * against pageattr.c; it is the unique case in which a valid change
 153  * of kernel pagetables can't be lazily synchronized by vmalloc faults.
 154  * vmalloc faults work because attached pagetables are never freed.
 155  * -- nyc
 156  */
 157
 158 #ifdef CONFIG_X86_PAE
 159 /*
 160  * In PAE mode, we need to do a cr3 reload (=tlb flush) when
 161  * updating the top-level pagetable entries to guarantee the
 162  * processor notices the update.  Since this is expensive, and
 163  * all 4 top-level entries are used almost immediately in a
 164  * new process's life, we just pre-populate them here.
 165  *
 166  * Also, if we're in a paravirt environment where the kernel pmd is
 167  * not shared between pagetables (!SHARED_KERNEL_PMDS), we allocate
 168  * and initialize the kernel pmds here.
 169  */
 170 #define PREALLOCATED_PMDS       UNSHARED_PTRS_PER_PGD
 171
 172 void pud_populate(struct mm_struct *mm, pud_t *pudp, pmd_t *pmd)
 173 {
 174         paravirt_alloc_pmd(mm, __pa(pmd) >> PAGE_SHIFT);
 175
 176         /* Note: almost everything apart from _PAGE_PRESENT is
 177            reserved at the pmd (PDPT) level. */
 178         set_pud(pudp, __pud(__pa(pmd) | _PAGE_PRESENT));
 179
 180         /*
 181          * According to Intel App note "TLBs, Paging-Structure Caches,
 182          * and Their Invalidation", April 2007, document 317080-001,
 183          * section 8.1: in PAE mode we explicitly have to flush the
 184          * TLB via cr3 if the top-level pgd is changed...
 185          */
 186         flush_tlb_mm(mm);
 187 }
 188 #else  /* !CONFIG_X86_PAE */
 189
 190 /* No need to prepopulate any pagetable entries in non-PAE modes. */
 191 #define PREALLOCATED_PMDS       0
 192
 193 #endif  /* CONFIG_X86_PAE */
 194
 195 static void free_pmds(struct mm_struct *mm, pmd_t *pmds[])
 196 {
 197         int i;
 198
 199         for(i = 0; i < PREALLOCATED_PMDS; i++)
 200                 if (pmds[i]) {
 201                         pgtable_pmd_page_dtor(virt_to_page(pmds[i]));
 202                         free_page((unsigned long)pmds[i]);
 203                         mm_dec_nr_pmds(mm);
 204                 }
 205 }
 206
 207 static int preallocate_pmds(struct mm_struct *mm, pmd_t *pmds[])
 208 {
 209         int i;
 210         bool failed = false;
 211
 212         for(i = 0; i < PREALLOCATED_PMDS; i++) {
 213                 pmd_t *pmd = (pmd_t *)__get_free_page(PGALLOC_GFP);
 214                 if (!pmd)
 215                         failed = true;
 216                 if (pmd && !pgtable_pmd_page_ctor(virt_to_page(pmd))) {
 217                         free_page((unsigned long)pmd);
 218                         pmd = NULL;
 219                         failed = true;
 220                 }
 221                 if (pmd)
 222                         mm_inc_nr_pmds(mm);
 223                 pmds[i] = pmd;
 224         }
 225
 226         if (failed) {
 227                 free_pmds(mm, pmds);
 228                 return -ENOMEM;
 229         }
 230
 231         return 0;
 232 }
 233
 234 /*
 235  * Mop up any pmd pages which may still be attached to the pgd.
 236  * Normally they will be freed by munmap/exit_mmap, but any pmd we
 237  * preallocate which never got a corresponding vma will need to be
 238  * freed manually.
 239  */
 240 static void pgd_mop_up_pmds(struct mm_struct *mm, pgd_t *pgdp)
 241 {
 242         int i;
 243
 244         for(i = 0; i < PREALLOCATED_PMDS; i++) {
 245                 pgd_t pgd = pgdp[i];
 246
 247                 if (pgd_val(pgd) != 0) {
 248                         pmd_t *pmd = (pmd_t *)pgd_page_vaddr(pgd);
 249
 250                         pgd_clear(&pgdp[i]);
 251
 252                         paravirt_release_pmd(pgd_val(pgd) >> PAGE_SHIFT);
 253                         pmd_free(mm, pmd);
 254                         mm_dec_nr_pmds(mm);
 255                 }
 256         }
 257 }
 258
 259 static void pgd_prepopulate_pmd(struct mm_struct *mm, pgd_t *pgd, pmd_t *pmds[])
 260 {
 261         pud_t *pud;
 262         int i;
 263
 264         if (PREALLOCATED_PMDS == 0) /* Work around gcc-3.4.x bug */
 265                 return;
 266
 267         pud = pud_offset(pgd, 0);
 268
 269         for (i = 0; i < PREALLOCATED_PMDS; i++, pud++) {
 270                 pmd_t *pmd = pmds[i];
 271
 272                 if (i >= KERNEL_PGD_BOUNDARY)
 273                         memcpy(pmd, (pmd_t *)pgd_page_vaddr(swapper_pg_dir[i]),
 274                                sizeof(pmd_t) * PTRS_PER_PMD);
 275
 276                 pud_populate(mm, pud, pmd);
 277         }
 278 }
 279
 280 /*
 281  * Xen paravirt assumes pgd table should be in one page. 64 bit kernel also
 282  * assumes that pgd should be in one page.
 283  *
 284  * But kernel with PAE paging that is not running as a Xen domain
 285  * only needs to allocate 32 bytes for pgd instead of one page.
 286  */
 287 #ifdef CONFIG_X86_PAE
 288
 289 #include <linux/slab.h>
 290
 291 #define PGD_SIZE        (PTRS_PER_PGD * sizeof(pgd_t))
 292 #define PGD_ALIGN       32
 293
 294 static struct kmem_cache *pgd_cache;
 295
 296 static int __init pgd_cache_init(void)
 297 {
 298         /*
 299          * When PAE kernel is running as a Xen domain, it does not use
 300          * shared kernel pmd. And this requires a whole page for pgd.
 301          */
 302         if (!SHARED_KERNEL_PMD)
 303                 return 0;
 304
 305         /*
 306          * when PAE kernel is not running as a Xen domain, it uses
 307          * shared kernel pmd. Shared kernel pmd does not require a whole
 308          * page for pgd. We are able to just allocate a 32-byte for pgd.
 309          * During boot time, we create a 32-byte slab for pgd table allocation.
 310          */
 311         pgd_cache = kmem_cache_create("pgd_cache", PGD_SIZE, PGD_ALIGN,
 312                                       SLAB_PANIC, NULL);
 313         if (!pgd_cache)
 314                 return -ENOMEM;
 315
 316         return 0;
 317 }
 318 core_initcall(pgd_cache_init);
 319
 320 static inline pgd_t *_pgd_alloc(void)
 321 {
 322         /*
 323          * If no SHARED_KERNEL_PMD, PAE kernel is running as a Xen domain.
 324          * We allocate one page for pgd.
 325          */
 326         if (!SHARED_KERNEL_PMD)
 327                 return (pgd_t *)__get_free_page(PGALLOC_GFP);
 328
 329         /*
 330          * Now PAE kernel is not running as a Xen domain. We can allocate
 331          * a 32-byte slab for pgd to save memory space.
 332          */
 333         return kmem_cache_alloc(pgd_cache, PGALLOC_GFP);
 334 }
 335
 336 static inline void _pgd_free(pgd_t *pgd)
 337 {
 338         if (!SHARED_KERNEL_PMD)
 339                 free_page((unsigned long)pgd);
 340         else
 341                 kmem_cache_free(pgd_cache, pgd);
 342 }
 343 #else
 344
 345 /*
 346  * Instead of one pgd, Kaiser acquires two pgds.  Being order-1, it is
 347  * both 8k in size and 8k-aligned.  That lets us just flip bit 12
 348  * in a pointer to swap between the two 4k halves.
 349  */
 350 #define PGD_ALLOCATION_ORDER    kaiser_enabled
 351
 352 static inline pgd_t *_pgd_alloc(void)
 353 {
 354         /* No __GFP_REPEAT: to avoid page allocation stalls in order-1 case */
 355         return (pgd_t *)__get_free_pages(PGALLOC_GFP & ~__GFP_REPEAT,
 356                                          PGD_ALLOCATION_ORDER);
 357 }
 358
 359 static inline void _pgd_free(pgd_t *pgd)
 360 {
 361         free_pages((unsigned long)pgd, PGD_ALLOCATION_ORDER);
 362 }
 363 #endif /* CONFIG_X86_PAE */
 364
 365 pgd_t *pgd_alloc(struct mm_struct *mm)
 366 {
 367         pgd_t *pgd;
 368         pmd_t *pmds[PREALLOCATED_PMDS];
 369
 370         pgd = _pgd_alloc();
 371
 372         if (pgd == NULL)
 373                 goto out;
 374
 375         mm->pgd = pgd;
 376
 377         if (preallocate_pmds(mm, pmds) != 0)
 378                 goto out_free_pgd;
 379
 380         if (paravirt_pgd_alloc(mm) != 0)
 381                 goto out_free_pmds;
 382
 383         /*
 384          * Make sure that pre-populating the pmds is atomic with
 385          * respect to anything walking the pgd_list, so that they
 386          * never see a partially populated pgd.
 387          */
 388         spin_lock(&pgd_lock);
 389
 390         pgd_ctor(mm, pgd);
 391         pgd_prepopulate_pmd(mm, pgd, pmds);
 392
 393         spin_unlock(&pgd_lock);
 394
 395         return pgd;
 396
 397 out_free_pmds:
 398         free_pmds(mm, pmds);
 399 out_free_pgd:
 400         _pgd_free(pgd);
 401 out:
 402         return NULL;
 403 }
 404
 405 void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 406 {
 407         pgd_mop_up_pmds(mm, pgd);
 408         pgd_dtor(pgd);
 409         paravirt_pgd_free(mm, pgd);
 410         _pgd_free(pgd);
 411 }
 412
 413 /*
 414  * Used to set accessed or dirty bits in the page table entries
 415  * on other architectures. On x86, the accessed and dirty bits
 416  * are tracked by hardware. However, do_wp_page calls this function
 417  * to also make the pte writeable at the same time the dirty bit is
 418  * set. In that case we do actually need to write the PTE.
 419  */
 420 int ptep_set_access_flags(struct vm_area_struct *vma,
 421                           unsigned long address, pte_t *ptep,
 422                           pte_t entry, int dirty)
 423 {
 424         int changed = !pte_same(*ptep, entry);
 425
 426         if (changed && dirty) {
 427                 set_pte(ptep, entry);
 428                 pte_update_defer(vma->vm_mm, address, ptep);
 429         }
 430
 431         return changed;
 432 }
 433
 434 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 435 int pmdp_set_access_flags(struct vm_area_struct *vma,
 436                           unsigned long address, pmd_t *pmdp,
 437                           pmd_t entry, int dirty)
 438 {
 439         int changed = !pmd_same(*pmdp, entry);
 440
 441         VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 442
 443         if (changed && dirty) {
 444                 set_pmd(pmdp, entry);
 445                 pmd_update_defer(vma->vm_mm, address, pmdp);
 446                 /*
 447                  * We had a write-protection fault here and changed the pmd
 448                  * to to more permissive. No need to flush the TLB for that,
 449                  * #PF is architecturally guaranteed to do that and in the
 450                  * worst-case we'll generate a spurious fault.
 451                  */
 452         }
 453
 454         return changed;
 455 }
 456 #endif
 457
 458 int ptep_test_and_clear_young(struct vm_area_struct *vma,
 459                               unsigned long addr, pte_t *ptep)
 460 {
 461         int ret = 0;
 462
 463         if (pte_young(*ptep))
 464                 ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
 465                                          (unsigned long *) &ptep->pte);
 466
 467         if (ret)
 468                 pte_update(vma->vm_mm, addr, ptep);
 469
 470         return ret;
 471 }
 472
 473 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 474 int pmdp_test_and_clear_young(struct vm_area_struct *vma,
 475                               unsigned long addr, pmd_t *pmdp)
 476 {
 477         int ret = 0;
 478
 479         if (pmd_young(*pmdp))
 480                 ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
 481                                          (unsigned long *)pmdp);
 482
 483         if (ret)
 484                 pmd_update(vma->vm_mm, addr, pmdp);
 485
 486         return ret;
 487 }
 488 #endif
 489
 490 int ptep_clear_flush_young(struct vm_area_struct *vma,
 491                            unsigned long address, pte_t *ptep)
 492 {
 493         /*
 494          * On x86 CPUs, clearing the accessed bit without a TLB flush
 495          * doesn't cause data corruption. [ It could cause incorrect
 496          * page aging and the (mistaken) reclaim of hot pages, but the
 497          * chance of that should be relatively low. ]
 498          *
 499          * So as a performance optimization don't flush the TLB when
 500          * clearing the accessed bit, it will eventually be flushed by
 501          * a context switch or a VM operation anyway. [ In the rare
 502          * event of it not getting flushed for a long time the delay
 503          * shouldn't really matter because there's no real memory
 504          * pressure for swapout to react to. ]
 505          */
 506         return ptep_test_and_clear_young(vma, address, ptep);
 507 }
 508
 509 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 510 int pmdp_clear_flush_young(struct vm_area_struct *vma,
 511                            unsigned long address, pmd_t *pmdp)
 512 {
 513         int young;
 514
 515         VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 516
 517         young = pmdp_test_and_clear_young(vma, address, pmdp);
 518         if (young)
 519                 flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
 520
 521         return young;
 522 }
 523
 524 void pmdp_splitting_flush(struct vm_area_struct *vma,
 525                           unsigned long address, pmd_t *pmdp)
 526 {
 527         int set;
 528         VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 529         set = !test_and_set_bit(_PAGE_BIT_SPLITTING,
 530                                 (unsigned long *)pmdp);
 531         if (set) {
 532                 pmd_update(vma->vm_mm, address, pmdp);
 533                 /* need tlb flush only to serialize against gup-fast */
 534                 flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
 535         }
 536 }
 537 #endif
 538
 539 /**
 540  * reserve_top_address - reserves a hole in the top of kernel address space
 541  * @reserve - size of hole to reserve
 542  *
 543  * Can be used to relocate the fixmap area and poke a hole in the top
 544  * of kernel address space to make room for a hypervisor.
 545  */
 546 void __init reserve_top_address(unsigned long reserve)
 547 {
 548 #ifdef CONFIG_X86_32
 549         BUG_ON(fixmaps_set > 0);
 550         __FIXADDR_TOP = round_down(-reserve, 1 << PMD_SHIFT) - PAGE_SIZE;
 551         printk(KERN_INFO "Reserving virtual address space above 0x%08lx (rounded to 0x%08lx)\n",
 552                -reserve, __FIXADDR_TOP + PAGE_SIZE);
 553 #endif
 554 }
 555
 556 int fixmaps_set;
 557
 558 void __native_set_fixmap(enum fixed_addresses idx, pte_t pte)
 559 {
 560         unsigned long address = __fix_to_virt(idx);
 561
 562         if (idx >= __end_of_fixed_addresses) {
 563                 BUG();
 564                 return;
 565         }
 566         set_pte_vaddr(address, pte);
 567         fixmaps_set++;
 568 }
 569
 570 void native_set_fixmap(enum fixed_addresses idx, phys_addr_t phys,
 571                        pgprot_t flags)
 572 {
 573         __native_set_fixmap(idx, pfn_pte(phys >> PAGE_SHIFT, flags));
 574 }
 575
 576 #ifdef CONFIG_HAVE_ARCH_HUGE_VMAP
 577 /**
 578  * pud_set_huge - setup kernel PUD mapping
 579  *
 580  * MTRRs can override PAT memory types with 4KiB granularity. Therefore, this
 581  * function sets up a huge page only if any of the following conditions are met:
 582  *
 583  * - MTRRs are disabled, or
 584  *
 585  * - MTRRs are enabled and the range is completely covered by a single MTRR, or
 586  *
 587  * - MTRRs are enabled and the corresponding MTRR memory type is WB, which
 588  *   has no effect on the requested PAT memory type.
 589  *
 590  * Callers should try to decrease page size (1GB -> 2MB -> 4K) if the bigger
 591  * page mapping attempt fails.
 592  *
 593  * Returns 1 on success and 0 on failure.
 594  */
 595 int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot)
 596 {
 597         u8 mtrr, uniform;
 598
 599         mtrr = mtrr_type_lookup(addr, addr + PUD_SIZE, &uniform);
 600         if ((mtrr != MTRR_TYPE_INVALID) && (!uniform) &&
 601             (mtrr != MTRR_TYPE_WRBACK))
 602                 return 0;
 603
 604         /* Bail out if we are we on a populated non-leaf entry: */
 605         if (pud_present(*pud) && !pud_huge(*pud))
 606                 return 0;
 607
 608         prot = pgprot_4k_2_large(prot);
 609
 610         set_pte((pte_t *)pud, pfn_pte(
 611                 (u64)addr >> PAGE_SHIFT,
 612                 __pgprot(pgprot_val(prot) | _PAGE_PSE)));
 613
 614         return 1;
 615 }
 616
 617 /**
 618  * pmd_set_huge - setup kernel PMD mapping
 619  *
 620  * See text over pud_set_huge() above.
 621  *
 622  * Returns 1 on success and 0 on failure.
 623  */
 624 int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot)
 625 {
 626         u8 mtrr, uniform;
 627
 628         mtrr = mtrr_type_lookup(addr, addr + PMD_SIZE, &uniform);
 629         if ((mtrr != MTRR_TYPE_INVALID) && (!uniform) &&
 630             (mtrr != MTRR_TYPE_WRBACK)) {
 631                 pr_warn_once("%s: Cannot satisfy [mem %#010llx-%#010llx] with a huge-page mapping due to MTRR override.\n",
 632                              __func__, addr, addr + PMD_SIZE);
 633                 return 0;
 634         }
 635
 636         /* Bail out if we are we on a populated non-leaf entry: */
 637         if (pmd_present(*pmd) && !pmd_huge(*pmd))
 638                 return 0;
 639
 640         prot = pgprot_4k_2_large(prot);
 641
 642         set_pte((pte_t *)pmd, pfn_pte(
 643                 (u64)addr >> PAGE_SHIFT,
 644                 __pgprot(pgprot_val(prot) | _PAGE_PSE)));
 645
 646         return 1;
 647 }
 648
 649 /**
 650  * pud_clear_huge - clear kernel PUD mapping when it is set
 651  *
 652  * Returns 1 on success and 0 on failure (no PUD map is found).
 653  */
 654 int pud_clear_huge(pud_t *pud)
 655 {
 656         if (pud_large(*pud)) {
 657                 pud_clear(pud);
 658                 return 1;
 659         }
 660
 661         return 0;
 662 }
 663
 664 /**
 665  * pmd_clear_huge - clear kernel PMD mapping when it is set
 666  *
 667  * Returns 1 on success and 0 on failure (no PMD map is found).
 668  */
 669 int pmd_clear_huge(pmd_t *pmd)
 670 {
 671         if (pmd_large(*pmd)) {
 672                 pmd_clear(pmd);
 673                 return 1;
 674         }
 675
 676         return 0;
 677 }
 678
 679 #ifdef CONFIG_X86_64
 680 /**
 681  * pud_free_pmd_page - Clear pud entry and free pmd page.
 682  * @pud: Pointer to a PUD.
 683  * @addr: Virtual address associated with pud.
 684  *
 685  * Context: The pud range has been unmapped and TLB purged.
 686  * Return: 1 if clearing the entry succeeded. 0 otherwise.
 687  *
 688  * NOTE: Callers must allow a single page allocation.
 689  */
 690 int pud_free_pmd_page(pud_t *pud, unsigned long addr)
 691 {
 692         pmd_t *pmd, *pmd_sv;
 693         pte_t *pte;
 694         int i;
 695
 696         if (pud_none(*pud))
 697                 return 1;
 698
 699         pmd = (pmd_t *)pud_page_vaddr(*pud);
 700         pmd_sv = (pmd_t *)__get_free_page(GFP_KERNEL);
 701         if (!pmd_sv)
 702                 return 0;
 703
 704         for (i = 0; i < PTRS_PER_PMD; i++) {
 705                 pmd_sv[i] = pmd[i];
 706                 if (!pmd_none(pmd[i]))
 707                         pmd_clear(&pmd[i]);
 708         }
 709
 710         pud_clear(pud);
 711
 712         /* INVLPG to clear all paging-structure caches */
 713         flush_tlb_kernel_range(addr, addr + PAGE_SIZE-1);
 714
 715         for (i = 0; i < PTRS_PER_PMD; i++) {
 716                 if (!pmd_none(pmd_sv[i])) {
 717                         pte = (pte_t *)pmd_page_vaddr(pmd_sv[i]);
 718                         free_page((unsigned long)pte);
 719                 }
 720         }
 721
 722         free_page((unsigned long)pmd_sv);
 723         free_page((unsigned long)pmd);
 724
 725         return 1;
 726 }
 727
 728 /**
 729  * pmd_free_pte_page - Clear pmd entry and free pte page.
 730  * @pmd: Pointer to a PMD.
 731  * @addr: Virtual address associated with pmd.
 732  *
 733  * Context: The pmd range has been unmapped and TLB purged.
 734  * Return: 1 if clearing the entry succeeded. 0 otherwise.
 735  */
 736 int pmd_free_pte_page(pmd_t *pmd, unsigned long addr)
 737 {
 738         pte_t *pte;
 739
 740         if (pmd_none(*pmd))
 741                 return 1;
 742
 743         pte = (pte_t *)pmd_page_vaddr(*pmd);
 744         pmd_clear(pmd);
 745
 746         /* INVLPG to clear all paging-structure caches */
 747         flush_tlb_kernel_range(addr, addr + PAGE_SIZE-1);
 748
 749         free_page((unsigned long)pte);
 750
 751         return 1;
 752 }
 753
 754 #else /* !CONFIG_X86_64 */
 755
 756 int pud_free_pmd_page(pud_t *pud, unsigned long addr)
 757 {
 758         return pud_none(*pud);
 759 }
 760
 761 /*
 762  * Disable free page handling on x86-PAE. This assures that ioremap()
 763  * does not update sync'd pmd entries. See vmalloc_sync_one().
 764  */
 765 int pmd_free_pte_page(pmd_t *pmd, unsigned long addr)
 766 {
 767         return pmd_none(*pmd);
 768 }
 769
 770 #endif /* CONFIG_X86_64 */
 771 #endif  /* CONFIG_HAVE_ARCH_HUGE_VMAP */