arch/powerpc/mm/hugetlbpage.c

   1 /*
   2  * PPC Huge TLB Page Support for Kernel.
   3  *
   4  * Copyright (C) 2003 David Gibson, IBM Corporation.
   5  * Copyright (C) 2011 Becky Bruce, Freescale Semiconductor
   6  *
   7  * Based on the IA-32 version:
   8  * Copyright (C) 2002, Rohit Seth <rohit.seth@intel.com>
   9  */
  10
  11 #include <linux/mm.h>
  12 #include <linux/io.h>
  13 #include <linux/slab.h>
  14 #include <linux/hugetlb.h>
  15 #include <linux/export.h>
  16 #include <linux/of_fdt.h>
  17 #include <linux/memblock.h>
  18 #include <linux/bootmem.h>
  19 #include <linux/moduleparam.h>
  20 #include <asm/pgtable.h>
  21 #include <asm/pgalloc.h>
  22 #include <asm/tlb.h>
  23 #include <asm/setup.h>
  24 #include <asm/hugetlb.h>
  25
  26 #ifdef CONFIG_HUGETLB_PAGE
  27
  28 #define PAGE_SHIFT_64K  16
  29 #define PAGE_SHIFT_16M  24
  30 #define PAGE_SHIFT_16G  34
  31
  32 unsigned int HPAGE_SHIFT;
  33
  34 /*
  35  * Tracks gpages after the device tree is scanned and before the
  36  * huge_boot_pages list is ready.  On non-Freescale implementations, this is
  37  * just used to track 16G pages and so is a single array.  FSL-based
  38  * implementations may have more than one gpage size, so we need multiple
  39  * arrays
  40  */
  41 #ifdef CONFIG_PPC_FSL_BOOK3E
  42 #define MAX_NUMBER_GPAGES       128
  43 struct psize_gpages {
  44         u64 gpage_list[MAX_NUMBER_GPAGES];
  45         unsigned int nr_gpages;
  46 };
  47 static struct psize_gpages gpage_freearray[MMU_PAGE_COUNT];
  48 #else
  49 #define MAX_NUMBER_GPAGES       1024
  50 static u64 gpage_freearray[MAX_NUMBER_GPAGES];
  51 static unsigned nr_gpages;
  52 #endif
  53
  54 #define hugepd_none(hpd)        ((hpd).pd == 0)
  55
  56 pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
  57 {
  58         /* Only called for hugetlbfs pages, hence can ignore THP */
  59         return __find_linux_pte_or_hugepte(mm->pgd, addr, NULL, NULL);
  60 }
  61
  62 static int __hugepte_alloc(struct mm_struct *mm, hugepd_t *hpdp,
  63                            unsigned long address, unsigned pdshift, unsigned pshift)
  64 {
  65         struct kmem_cache *cachep;
  66         pte_t *new;
  67
  68 #ifdef CONFIG_PPC_FSL_BOOK3E
  69         int i;
  70         int num_hugepd = 1 << (pshift - pdshift);
  71         cachep = hugepte_cache;
  72 #else
  73         cachep = PGT_CACHE(pdshift - pshift);
  74 #endif
  75
  76         new = kmem_cache_zalloc(cachep, GFP_KERNEL);
  77
  78         BUG_ON(pshift > HUGEPD_SHIFT_MASK);
  79         BUG_ON((unsigned long)new & HUGEPD_SHIFT_MASK);
  80
  81         if (! new)
  82                 return -ENOMEM;
  83
  84         /*
  85          * Make sure other cpus find the hugepd set only after a
  86          * properly initialized page table is visible to them.
  87          * For more details look for comment in __pte_alloc().
  88          */
  89         smp_wmb();
  90
  91         spin_lock(&mm->page_table_lock);
  92 #ifdef CONFIG_PPC_FSL_BOOK3E
  93         /*
  94          * We have multiple higher-level entries that point to the same
  95          * actual pte location.  Fill in each as we go and backtrack on error.
  96          * We need all of these so the DTLB pgtable walk code can find the
  97          * right higher-level entry without knowing if it's a hugepage or not.
  98          */
  99         for (i = 0; i < num_hugepd; i++, hpdp++) {
 100                 if (unlikely(!hugepd_none(*hpdp)))
 101                         break;
 102                 else
 103                         /* We use the old format for PPC_FSL_BOOK3E */
 104                         hpdp->pd = ((unsigned long)new & ~PD_HUGE) | pshift;
 105         }
 106         /* If we bailed from the for loop early, an error occurred, clean up */
 107         if (i < num_hugepd) {
 108                 for (i = i - 1 ; i >= 0; i--, hpdp--)
 109                         hpdp->pd = 0;
 110                 kmem_cache_free(cachep, new);
 111         }
 112 #else
 113         if (!hugepd_none(*hpdp))
 114                 kmem_cache_free(cachep, new);
 115         else {
 116 #ifdef CONFIG_PPC_BOOK3S_64
 117                 hpdp->pd = __pa(new) | (shift_to_mmu_psize(pshift) << 2);
 118 #else
 119                 hpdp->pd = ((unsigned long)new & ~PD_HUGE) | pshift;
 120 #endif
 121         }
 122 #endif
 123         spin_unlock(&mm->page_table_lock);
 124         return 0;
 125 }
 126
 127 /*
 128  * These macros define how to determine which level of the page table holds
 129  * the hpdp.
 130  */
 131 #ifdef CONFIG_PPC_FSL_BOOK3E
 132 #define HUGEPD_PGD_SHIFT PGDIR_SHIFT
 133 #define HUGEPD_PUD_SHIFT PUD_SHIFT
 134 #else
 135 #define HUGEPD_PGD_SHIFT PUD_SHIFT
 136 #define HUGEPD_PUD_SHIFT PMD_SHIFT
 137 #endif
 138
 139 #ifdef CONFIG_PPC_BOOK3S_64
 140 /*
 141  * At this point we do the placement change only for BOOK3S 64. This would
 142  * possibly work on other subarchs.
 143  */
 144 pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr, unsigned long sz)
 145 {
 146         pgd_t *pg;
 147         pud_t *pu;
 148         pmd_t *pm;
 149         hugepd_t *hpdp = NULL;
 150         unsigned pshift = __ffs(sz);
 151         unsigned pdshift = PGDIR_SHIFT;
 152
 153         addr &= ~(sz-1);
 154         pg = pgd_offset(mm, addr);
 155
 156         if (pshift == PGDIR_SHIFT)
 157                 /* 16GB huge page */
 158                 return (pte_t *) pg;
 159         else if (pshift > PUD_SHIFT)
 160                 /*
 161                  * We need to use hugepd table
 162                  */
 163                 hpdp = (hugepd_t *)pg;
 164         else {
 165                 pdshift = PUD_SHIFT;
 166                 pu = pud_alloc(mm, pg, addr);
 167                 if (pshift == PUD_SHIFT)
 168                         return (pte_t *)pu;
 169                 else if (pshift > PMD_SHIFT)
 170                         hpdp = (hugepd_t *)pu;
 171                 else {
 172                         pdshift = PMD_SHIFT;
 173                         pm = pmd_alloc(mm, pu, addr);
 174                         if (pshift == PMD_SHIFT)
 175                                 /* 16MB hugepage */
 176                                 return (pte_t *)pm;
 177                         else
 178                                 hpdp = (hugepd_t *)pm;
 179                 }
 180         }
 181         if (!hpdp)
 182                 return NULL;
 183
 184         BUG_ON(!hugepd_none(*hpdp) && !hugepd_ok(*hpdp));
 185
 186         if (hugepd_none(*hpdp) && __hugepte_alloc(mm, hpdp, addr, pdshift, pshift))
 187                 return NULL;
 188
 189         return hugepte_offset(*hpdp, addr, pdshift);
 190 }
 191
 192 #else
 193
 194 pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr, unsigned long sz)
 195 {
 196         pgd_t *pg;
 197         pud_t *pu;
 198         pmd_t *pm;
 199         hugepd_t *hpdp = NULL;
 200         unsigned pshift = __ffs(sz);
 201         unsigned pdshift = PGDIR_SHIFT;
 202
 203         addr &= ~(sz-1);
 204
 205         pg = pgd_offset(mm, addr);
 206
 207         if (pshift >= HUGEPD_PGD_SHIFT) {
 208                 hpdp = (hugepd_t *)pg;
 209         } else {
 210                 pdshift = PUD_SHIFT;
 211                 pu = pud_alloc(mm, pg, addr);
 212                 if (pshift >= HUGEPD_PUD_SHIFT) {
 213                         hpdp = (hugepd_t *)pu;
 214                 } else {
 215                         pdshift = PMD_SHIFT;
 216                         pm = pmd_alloc(mm, pu, addr);
 217                         hpdp = (hugepd_t *)pm;
 218                 }
 219         }
 220
 221         if (!hpdp)
 222                 return NULL;
 223
 224         BUG_ON(!hugepd_none(*hpdp) && !hugepd_ok(*hpdp));
 225
 226         if (hugepd_none(*hpdp) && __hugepte_alloc(mm, hpdp, addr, pdshift, pshift))
 227                 return NULL;
 228
 229         return hugepte_offset(*hpdp, addr, pdshift);
 230 }
 231 #endif
 232
 233 #ifdef CONFIG_PPC_FSL_BOOK3E
 234 /* Build list of addresses of gigantic pages.  This function is used in early
 235  * boot before the buddy allocator is setup.
 236  */
 237 void add_gpage(u64 addr, u64 page_size, unsigned long number_of_pages)
 238 {
 239         unsigned int idx = shift_to_mmu_psize(__ffs(page_size));
 240         int i;
 241
 242         if (addr == 0)
 243                 return;
 244
 245         gpage_freearray[idx].nr_gpages = number_of_pages;
 246
 247         for (i = 0; i < number_of_pages; i++) {
 248                 gpage_freearray[idx].gpage_list[i] = addr;
 249                 addr += page_size;
 250         }
 251 }
 252
 253 /*
 254  * Moves the gigantic page addresses from the temporary list to the
 255  * huge_boot_pages list.
 256  */
 257 int alloc_bootmem_huge_page(struct hstate *hstate)
 258 {
 259         struct huge_bootmem_page *m;
 260         int idx = shift_to_mmu_psize(huge_page_shift(hstate));
 261         int nr_gpages = gpage_freearray[idx].nr_gpages;
 262
 263         if (nr_gpages == 0)
 264                 return 0;
 265
 266 #ifdef CONFIG_HIGHMEM
 267         /*
 268          * If gpages can be in highmem we can't use the trick of storing the
 269          * data structure in the page; allocate space for this
 270          */
 271         m = memblock_virt_alloc(sizeof(struct huge_bootmem_page), 0);
 272         m->phys = gpage_freearray[idx].gpage_list[--nr_gpages];
 273 #else
 274         m = phys_to_virt(gpage_freearray[idx].gpage_list[--nr_gpages]);
 275 #endif
 276
 277         list_add(&m->list, &huge_boot_pages);
 278         gpage_freearray[idx].nr_gpages = nr_gpages;
 279         gpage_freearray[idx].gpage_list[nr_gpages] = 0;
 280         m->hstate = hstate;
 281
 282         return 1;
 283 }
 284 /*
 285  * Scan the command line hugepagesz= options for gigantic pages; store those in
 286  * a list that we use to allocate the memory once all options are parsed.
 287  */
 288
 289 unsigned long gpage_npages[MMU_PAGE_COUNT];
 290
 291 static int __init do_gpage_early_setup(char *param, char *val,
 292                                        const char *unused, void *arg)
 293 {
 294         static phys_addr_t size;
 295         unsigned long npages;
 296
 297         /*
 298          * The hugepagesz and hugepages cmdline options are interleaved.  We
 299          * use the size variable to keep track of whether or not this was done
 300          * properly and skip over instances where it is incorrect.  Other
 301          * command-line parsing code will issue warnings, so we don't need to.
 302          *
 303          */
 304         if ((strcmp(param, "default_hugepagesz") == 0) ||
 305             (strcmp(param, "hugepagesz") == 0)) {
 306                 size = memparse(val, NULL);
 307         } else if (strcmp(param, "hugepages") == 0) {
 308                 if (size != 0) {
 309                         if (sscanf(val, "%lu", &npages) <= 0)
 310                                 npages = 0;
 311                         if (npages > MAX_NUMBER_GPAGES) {
 312                                 pr_warn("MMU: %lu pages requested for page "
 313                                         "size %llu KB, limiting to "
 314                                         __stringify(MAX_NUMBER_GPAGES) "\n",
 315                                         npages, size / 1024);
 316                                 npages = MAX_NUMBER_GPAGES;
 317                         }
 318                         gpage_npages[shift_to_mmu_psize(__ffs(size))] = npages;
 319                         size = 0;
 320                 }
 321         }
 322         return 0;
 323 }
 324
 325
 326 /*
 327  * This function allocates physical space for pages that are larger than the
 328  * buddy allocator can handle.  We want to allocate these in highmem because
 329  * the amount of lowmem is limited.  This means that this function MUST be
 330  * called before lowmem_end_addr is set up in MMU_init() in order for the lmb
 331  * allocate to grab highmem.
 332  */
 333 void __init reserve_hugetlb_gpages(void)
 334 {
 335         static __initdata char cmdline[COMMAND_LINE_SIZE];
 336         phys_addr_t size, base;
 337         int i;
 338
 339         strlcpy(cmdline, boot_command_line, COMMAND_LINE_SIZE);
 340         parse_args("hugetlb gpages", cmdline, NULL, 0, 0, 0,
 341                         NULL, &do_gpage_early_setup);
 342
 343         /*
 344          * Walk gpage list in reverse, allocating larger page sizes first.
 345          * Skip over unsupported sizes, or sizes that have 0 gpages allocated.
 346          * When we reach the point in the list where pages are no longer
 347          * considered gpages, we're done.
 348          */
 349         for (i = MMU_PAGE_COUNT-1; i >= 0; i--) {
 350                 if (mmu_psize_defs[i].shift == 0 || gpage_npages[i] == 0)
 351                         continue;
 352                 else if (mmu_psize_to_shift(i) < (MAX_ORDER + PAGE_SHIFT))
 353                         break;
 354
 355                 size = (phys_addr_t)(1ULL << mmu_psize_to_shift(i));
 356                 base = memblock_alloc_base(size * gpage_npages[i], size,
 357                                            MEMBLOCK_ALLOC_ANYWHERE);
 358                 add_gpage(base, size, gpage_npages[i]);
 359         }
 360 }
 361
 362 #else /* !PPC_FSL_BOOK3E */
 363
 364 /* Build list of addresses of gigantic pages.  This function is used in early
 365  * boot before the buddy allocator is setup.
 366  */
 367 void add_gpage(u64 addr, u64 page_size, unsigned long number_of_pages)
 368 {
 369         if (!addr)
 370                 return;
 371         while (number_of_pages > 0) {
 372                 gpage_freearray[nr_gpages] = addr;
 373                 nr_gpages++;
 374                 number_of_pages--;
 375                 addr += page_size;
 376         }
 377 }
 378
 379 /* Moves the gigantic page addresses from the temporary list to the
 380  * huge_boot_pages list.
 381  */
 382 int alloc_bootmem_huge_page(struct hstate *hstate)
 383 {
 384         struct huge_bootmem_page *m;
 385         if (nr_gpages == 0)
 386                 return 0;
 387         m = phys_to_virt(gpage_freearray[--nr_gpages]);
 388         gpage_freearray[nr_gpages] = 0;
 389         list_add(&m->list, &huge_boot_pages);
 390         m->hstate = hstate;
 391         return 1;
 392 }
 393 #endif
 394
 395 #ifdef CONFIG_PPC_FSL_BOOK3E
 396 #define HUGEPD_FREELIST_SIZE \
 397         ((PAGE_SIZE - sizeof(struct hugepd_freelist)) / sizeof(pte_t))
 398
 399 struct hugepd_freelist {
 400         struct rcu_head rcu;
 401         unsigned int index;
 402         void *ptes[0];
 403 };
 404
 405 static DEFINE_PER_CPU(struct hugepd_freelist *, hugepd_freelist_cur);
 406
 407 static void hugepd_free_rcu_callback(struct rcu_head *head)
 408 {
 409         struct hugepd_freelist *batch =
 410                 container_of(head, struct hugepd_freelist, rcu);
 411         unsigned int i;
 412
 413         for (i = 0; i < batch->index; i++)
 414                 kmem_cache_free(hugepte_cache, batch->ptes[i]);
 415
 416         free_page((unsigned long)batch);
 417 }
 418
 419 static void hugepd_free(struct mmu_gather *tlb, void *hugepte)
 420 {
 421         struct hugepd_freelist **batchp;
 422
 423         batchp = &get_cpu_var(hugepd_freelist_cur);
 424
 425         if (atomic_read(&tlb->mm->mm_users) < 2 ||
 426             cpumask_equal(mm_cpumask(tlb->mm),
 427                           cpumask_of(smp_processor_id()))) {
 428                 kmem_cache_free(hugepte_cache, hugepte);
 429                 put_cpu_var(hugepd_freelist_cur);
 430                 return;
 431         }
 432
 433         if (*batchp == NULL) {
 434                 *batchp = (struct hugepd_freelist *)__get_free_page(GFP_ATOMIC);
 435                 (*batchp)->index = 0;
 436         }
 437
 438         (*batchp)->ptes[(*batchp)->index++] = hugepte;
 439         if ((*batchp)->index == HUGEPD_FREELIST_SIZE) {
 440                 call_rcu_sched(&(*batchp)->rcu, hugepd_free_rcu_callback);
 441                 *batchp = NULL;
 442         }
 443         put_cpu_var(hugepd_freelist_cur);
 444 }
 445 #endif
 446
 447 static void free_hugepd_range(struct mmu_gather *tlb, hugepd_t *hpdp, int pdshift,
 448                               unsigned long start, unsigned long end,
 449                               unsigned long floor, unsigned long ceiling)
 450 {
 451         pte_t *hugepte = hugepd_page(*hpdp);
 452         int i;
 453
 454         unsigned long pdmask = ~((1UL << pdshift) - 1);
 455         unsigned int num_hugepd = 1;
 456
 457 #ifdef CONFIG_PPC_FSL_BOOK3E
 458         /* Note: On fsl the hpdp may be the first of several */
 459         num_hugepd = (1 << (hugepd_shift(*hpdp) - pdshift));
 460 #else
 461         unsigned int shift = hugepd_shift(*hpdp);
 462 #endif
 463
 464         start &= pdmask;
 465         if (start < floor)
 466                 return;
 467         if (ceiling) {
 468                 ceiling &= pdmask;
 469                 if (! ceiling)
 470                         return;
 471         }
 472         if (end - 1 > ceiling - 1)
 473                 return;
 474
 475         for (i = 0; i < num_hugepd; i++, hpdp++)
 476                 hpdp->pd = 0;
 477
 478 #ifdef CONFIG_PPC_FSL_BOOK3E
 479         hugepd_free(tlb, hugepte);
 480 #else
 481         pgtable_free_tlb(tlb, hugepte, pdshift - shift);
 482 #endif
 483 }
 484
 485 static void hugetlb_free_pmd_range(struct mmu_gather *tlb, pud_t *pud,
 486                                    unsigned long addr, unsigned long end,
 487                                    unsigned long floor, unsigned long ceiling)
 488 {
 489         pmd_t *pmd;
 490         unsigned long next;
 491         unsigned long start;
 492
 493         start = addr;
 494         do {
 495                 pmd = pmd_offset(pud, addr);
 496                 next = pmd_addr_end(addr, end);
 497                 if (!is_hugepd(__hugepd(pmd_val(*pmd)))) {
 498                         /*
 499                          * if it is not hugepd pointer, we should already find
 500                          * it cleared.
 501                          */
 502                         WARN_ON(!pmd_none_or_clear_bad(pmd));
 503                         continue;
 504                 }
 505 #ifdef CONFIG_PPC_FSL_BOOK3E
 506                 /*
 507                  * Increment next by the size of the huge mapping since
 508                  * there may be more than one entry at this level for a
 509                  * single hugepage, but all of them point to
 510                  * the same kmem cache that holds the hugepte.
 511                  */
 512                 next = addr + (1 << hugepd_shift(*(hugepd_t *)pmd));
 513 #endif
 514                 free_hugepd_range(tlb, (hugepd_t *)pmd, PMD_SHIFT,
 515                                   addr, next, floor, ceiling);
 516         } while (addr = next, addr != end);
 517
 518         start &= PUD_MASK;
 519         if (start < floor)
 520                 return;
 521         if (ceiling) {
 522                 ceiling &= PUD_MASK;
 523                 if (!ceiling)
 524                         return;
 525         }
 526         if (end - 1 > ceiling - 1)
 527                 return;
 528
 529         pmd = pmd_offset(pud, start);
 530         pud_clear(pud);
 531         pmd_free_tlb(tlb, pmd, start);
 532         mm_dec_nr_pmds(tlb->mm);
 533 }
 534
 535 static void hugetlb_free_pud_range(struct mmu_gather *tlb, pgd_t *pgd,
 536                                    unsigned long addr, unsigned long end,
 537                                    unsigned long floor, unsigned long ceiling)
 538 {
 539         pud_t *pud;
 540         unsigned long next;
 541         unsigned long start;
 542
 543         start = addr;
 544         do {
 545                 pud = pud_offset(pgd, addr);
 546                 next = pud_addr_end(addr, end);
 547                 if (!is_hugepd(__hugepd(pud_val(*pud)))) {
 548                         if (pud_none_or_clear_bad(pud))
 549                                 continue;
 550                         hugetlb_free_pmd_range(tlb, pud, addr, next, floor,
 551                                                ceiling);
 552                 } else {
 553 #ifdef CONFIG_PPC_FSL_BOOK3E
 554                         /*
 555                          * Increment next by the size of the huge mapping since
 556                          * there may be more than one entry at this level for a
 557                          * single hugepage, but all of them point to
 558                          * the same kmem cache that holds the hugepte.
 559                          */
 560                         next = addr + (1 << hugepd_shift(*(hugepd_t *)pud));
 561 #endif
 562                         free_hugepd_range(tlb, (hugepd_t *)pud, PUD_SHIFT,
 563                                           addr, next, floor, ceiling);
 564                 }
 565         } while (addr = next, addr != end);
 566
 567         start &= PGDIR_MASK;
 568         if (start < floor)
 569                 return;
 570         if (ceiling) {
 571                 ceiling &= PGDIR_MASK;
 572                 if (!ceiling)
 573                         return;
 574         }
 575         if (end - 1 > ceiling - 1)
 576                 return;
 577
 578         pud = pud_offset(pgd, start);
 579         pgd_clear(pgd);
 580         pud_free_tlb(tlb, pud, start);
 581 }
 582
 583 /*
 584  * This function frees user-level page tables of a process.
 585  */
 586 void hugetlb_free_pgd_range(struct mmu_gather *tlb,
 587                             unsigned long addr, unsigned long end,
 588                             unsigned long floor, unsigned long ceiling)
 589 {
 590         pgd_t *pgd;
 591         unsigned long next;
 592
 593         /*
 594          * Because there are a number of different possible pagetable
 595          * layouts for hugepage ranges, we limit knowledge of how
 596          * things should be laid out to the allocation path
 597          * (huge_pte_alloc(), above).  Everything else works out the
 598          * structure as it goes from information in the hugepd
 599          * pointers.  That means that we can't here use the
 600          * optimization used in the normal page free_pgd_range(), of
 601          * checking whether we're actually covering a large enough
 602          * range to have to do anything at the top level of the walk
 603          * instead of at the bottom.
 604          *
 605          * To make sense of this, you should probably go read the big
 606          * block comment at the top of the normal free_pgd_range(),
 607          * too.
 608          */
 609
 610         do {
 611                 next = pgd_addr_end(addr, end);
 612                 pgd = pgd_offset(tlb->mm, addr);
 613                 if (!is_hugepd(__hugepd(pgd_val(*pgd)))) {
 614                         if (pgd_none_or_clear_bad(pgd))
 615                                 continue;
 616                         hugetlb_free_pud_range(tlb, pgd, addr, next, floor, ceiling);
 617                 } else {
 618 #ifdef CONFIG_PPC_FSL_BOOK3E
 619                         /*
 620                          * Increment next by the size of the huge mapping since
 621                          * there may be more than one entry at the pgd level
 622                          * for a single hugepage, but all of them point to the
 623                          * same kmem cache that holds the hugepte.
 624                          */
 625                         next = addr + (1 << hugepd_shift(*(hugepd_t *)pgd));
 626 #endif
 627                         free_hugepd_range(tlb, (hugepd_t *)pgd, PGDIR_SHIFT,
 628                                           addr, next, floor, ceiling);
 629                 }
 630         } while (addr = next, addr != end);
 631 }
 632
 633 /*
 634  * We are holding mmap_sem, so a parallel huge page collapse cannot run.
 635  * To prevent hugepage split, disable irq.
 636  */
 637 struct page *
 638 follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
 639 {
 640         bool is_thp;
 641         pte_t *ptep, pte;
 642         unsigned shift;
 643         unsigned long mask, flags;
 644         struct page *page = ERR_PTR(-EINVAL);
 645
 646         local_irq_save(flags);
 647         ptep = find_linux_pte_or_hugepte(mm->pgd, address, &is_thp, &shift);
 648         if (!ptep)
 649                 goto no_page;
 650         pte = READ_ONCE(*ptep);
 651         /*
 652          * Verify it is a huge page else bail.
 653          * Transparent hugepages are handled by generic code. We can skip them
 654          * here.
 655          */
 656         if (!shift || is_thp)
 657                 goto no_page;
 658
 659         if (!pte_present(pte)) {
 660                 page = NULL;
 661                 goto no_page;
 662         }
 663         mask = (1UL << shift) - 1;
 664         page = pte_page(pte);
 665         if (page)
 666                 page += (address & mask) / PAGE_SIZE;
 667
 668 no_page:
 669         local_irq_restore(flags);
 670         return page;
 671 }
 672
 673 struct page *
 674 follow_huge_pmd(struct mm_struct *mm, unsigned long address,
 675                 pmd_t *pmd, int write)
 676 {
 677         BUG();
 678         return NULL;
 679 }
 680
 681 struct page *
 682 follow_huge_pud(struct mm_struct *mm, unsigned long address,
 683                 pud_t *pud, int write)
 684 {
 685         BUG();
 686         return NULL;
 687 }
 688
 689 static unsigned long hugepte_addr_end(unsigned long addr, unsigned long end,
 690                                       unsigned long sz)
 691 {
 692         unsigned long __boundary = (addr + sz) & ~(sz-1);
 693         return (__boundary - 1 < end - 1) ? __boundary : end;
 694 }
 695
 696 int gup_huge_pd(hugepd_t hugepd, unsigned long addr, unsigned pdshift,
 697                 unsigned long end, int write, struct page **pages, int *nr)
 698 {
 699         pte_t *ptep;
 700         unsigned long sz = 1UL << hugepd_shift(hugepd);
 701         unsigned long next;
 702
 703         ptep = hugepte_offset(hugepd, addr, pdshift);
 704         do {
 705                 next = hugepte_addr_end(addr, end, sz);
 706                 if (!gup_hugepte(ptep, sz, addr, end, write, pages, nr))
 707                         return 0;
 708         } while (ptep++, addr = next, addr != end);
 709
 710         return 1;
 711 }
 712
 713 #ifdef CONFIG_PPC_MM_SLICES
 714 unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
 715                                         unsigned long len, unsigned long pgoff,
 716                                         unsigned long flags)
 717 {
 718         struct hstate *hstate = hstate_file(file);
 719         int mmu_psize = shift_to_mmu_psize(huge_page_shift(hstate));
 720
 721         if (radix_enabled())
 722                 return radix__hugetlb_get_unmapped_area(file, addr, len,
 723                                                        pgoff, flags);
 724         return slice_get_unmapped_area(addr, len, flags, mmu_psize, 1);
 725 }
 726 #endif
 727
 728 unsigned long vma_mmu_pagesize(struct vm_area_struct *vma)
 729 {
 730 #ifdef CONFIG_PPC_MM_SLICES
 731         unsigned int psize = get_slice_psize(vma->vm_mm, vma->vm_start);
 732         /* With radix we don't use slice, so derive it from vma*/
 733         if (!radix_enabled())
 734                 return 1UL << mmu_psize_to_shift(psize);
 735 #endif
 736         if (!is_vm_hugetlb_page(vma))
 737                 return PAGE_SIZE;
 738
 739         return huge_page_size(hstate_vma(vma));
 740 }
 741
 742 static inline bool is_power_of_4(unsigned long x)
 743 {
 744         if (is_power_of_2(x))
 745                 return (__ilog2(x) % 2) ? false : true;
 746         return false;
 747 }
 748
 749 static int __init add_huge_page_size(unsigned long long size)
 750 {
 751         int shift = __ffs(size);
 752         int mmu_psize;
 753
 754         /* Check that it is a page size supported by the hardware and
 755          * that it fits within pagetable and slice limits. */
 756 #ifdef CONFIG_PPC_FSL_BOOK3E
 757         if ((size < PAGE_SIZE) || !is_power_of_4(size))
 758                 return -EINVAL;
 759 #else
 760         if (!is_power_of_2(size)
 761             || (shift > SLICE_HIGH_SHIFT) || (shift <= PAGE_SHIFT))
 762                 return -EINVAL;
 763 #endif
 764
 765         if ((mmu_psize = shift_to_mmu_psize(shift)) < 0)
 766                 return -EINVAL;
 767
 768         BUG_ON(mmu_psize_defs[mmu_psize].shift != shift);
 769
 770         /* Return if huge page size has already been setup */
 771         if (size_to_hstate(size))
 772                 return 0;
 773
 774         hugetlb_add_hstate(shift - PAGE_SHIFT);
 775
 776         return 0;
 777 }
 778
 779 static int __init hugepage_setup_sz(char *str)
 780 {
 781         unsigned long long size;
 782
 783         size = memparse(str, &str);
 784
 785         if (add_huge_page_size(size) != 0) {
 786                 hugetlb_bad_size();
 787                 pr_err("Invalid huge page size specified(%llu)\n", size);
 788         }
 789
 790         return 1;
 791 }
 792 __setup("hugepagesz=", hugepage_setup_sz);
 793
 794 #ifdef CONFIG_PPC_FSL_BOOK3E
 795 struct kmem_cache *hugepte_cache;
 796 static int __init hugetlbpage_init(void)
 797 {
 798         int psize;
 799
 800         for (psize = 0; psize < MMU_PAGE_COUNT; ++psize) {
 801                 unsigned shift;
 802
 803                 if (!mmu_psize_defs[psize].shift)
 804                         continue;
 805
 806                 shift = mmu_psize_to_shift(psize);
 807
 808                 /* Don't treat normal page sizes as huge... */
 809                 if (shift != PAGE_SHIFT)
 810                         if (add_huge_page_size(1ULL << shift) < 0)
 811                                 continue;
 812         }
 813
 814         /*
 815          * Create a kmem cache for hugeptes.  The bottom bits in the pte have
 816          * size information encoded in them, so align them to allow this
 817          */
 818         hugepte_cache =  kmem_cache_create("hugepte-cache", sizeof(pte_t),
 819                                            HUGEPD_SHIFT_MASK + 1, 0, NULL);
 820         if (hugepte_cache == NULL)
 821                 panic("%s: Unable to create kmem cache for hugeptes\n",
 822                       __func__);
 823
 824         /* Default hpage size = 4M */
 825         if (mmu_psize_defs[MMU_PAGE_4M].shift)
 826                 HPAGE_SHIFT = mmu_psize_defs[MMU_PAGE_4M].shift;
 827         else
 828                 panic("%s: Unable to set default huge page size\n", __func__);
 829
 830
 831         return 0;
 832 }
 833 #else
 834 static int __init hugetlbpage_init(void)
 835 {
 836         int psize;
 837
 838         if (!radix_enabled() && !mmu_has_feature(MMU_FTR_16M_PAGE))
 839                 return -ENODEV;
 840
 841         for (psize = 0; psize < MMU_PAGE_COUNT; ++psize) {
 842                 unsigned shift;
 843                 unsigned pdshift;
 844
 845                 if (!mmu_psize_defs[psize].shift)
 846                         continue;
 847
 848                 shift = mmu_psize_to_shift(psize);
 849
 850                 if (add_huge_page_size(1ULL << shift) < 0)
 851                         continue;
 852
 853                 if (shift < PMD_SHIFT)
 854                         pdshift = PMD_SHIFT;
 855                 else if (shift < PUD_SHIFT)
 856                         pdshift = PUD_SHIFT;
 857                 else
 858                         pdshift = PGDIR_SHIFT;
 859                 /*
 860                  * if we have pdshift and shift value same, we don't
 861                  * use pgt cache for hugepd.
 862                  */
 863                 if (pdshift != shift) {
 864                         pgtable_cache_add(pdshift - shift, NULL);
 865                         if (!PGT_CACHE(pdshift - shift))
 866                                 panic("hugetlbpage_init(): could not create "
 867                                       "pgtable cache for %d bit pagesize\n", shift);
 868                 }
 869         }
 870
 871         /* Set default large page size. Currently, we pick 16M or 1M
 872          * depending on what is available
 873          */
 874         if (mmu_psize_defs[MMU_PAGE_16M].shift)
 875                 HPAGE_SHIFT = mmu_psize_defs[MMU_PAGE_16M].shift;
 876         else if (mmu_psize_defs[MMU_PAGE_1M].shift)
 877                 HPAGE_SHIFT = mmu_psize_defs[MMU_PAGE_1M].shift;
 878         else if (mmu_psize_defs[MMU_PAGE_2M].shift)
 879                 HPAGE_SHIFT = mmu_psize_defs[MMU_PAGE_2M].shift;
 880
 881
 882         return 0;
 883 }
 884 #endif
 885 arch_initcall(hugetlbpage_init);
 886
 887 void flush_dcache_icache_hugepage(struct page *page)
 888 {
 889         int i;
 890         void *start;
 891
 892         BUG_ON(!PageCompound(page));
 893
 894         for (i = 0; i < (1UL << compound_order(page)); i++) {
 895                 if (!PageHighMem(page)) {
 896                         __flush_dcache_icache(page_address(page+i));
 897                 } else {
 898                         start = kmap_atomic(page+i);
 899                         __flush_dcache_icache(start);
 900                         kunmap_atomic(start);
 901                 }
 902         }
 903 }
 904
 905 #endif /* CONFIG_HUGETLB_PAGE */
 906
 907 /*
 908  * We have 4 cases for pgds and pmds:
 909  * (1) invalid (all zeroes)
 910  * (2) pointer to next table, as normal; bottom 6 bits == 0
 911  * (3) leaf pte for huge page _PAGE_PTE set
 912  * (4) hugepd pointer, _PAGE_PTE = 0 and bits [2..6] indicate size of table
 913  *
 914  * So long as we atomically load page table pointers we are safe against teardown,
 915  * we can follow the address down to the the page and take a ref on it.
 916  * This function need to be called with interrupts disabled. We use this variant
 917  * when we have MSR[EE] = 0 but the paca->soft_enabled = 1
 918  */
 919
 920 pte_t *__find_linux_pte_or_hugepte(pgd_t *pgdir, unsigned long ea,
 921                                    bool *is_thp, unsigned *shift)
 922 {
 923         pgd_t pgd, *pgdp;
 924         pud_t pud, *pudp;
 925         pmd_t pmd, *pmdp;
 926         pte_t *ret_pte;
 927         hugepd_t *hpdp = NULL;
 928         unsigned pdshift = PGDIR_SHIFT;
 929
 930         if (shift)
 931                 *shift = 0;
 932
 933         if (is_thp)
 934                 *is_thp = false;
 935
 936         pgdp = pgdir + pgd_index(ea);
 937         pgd  = READ_ONCE(*pgdp);
 938         /*
 939          * Always operate on the local stack value. This make sure the
 940          * value don't get updated by a parallel THP split/collapse,
 941          * page fault or a page unmap. The return pte_t * is still not
 942          * stable. So should be checked there for above conditions.
 943          */
 944         if (pgd_none(pgd))
 945                 return NULL;
 946         else if (pgd_huge(pgd)) {
 947                 ret_pte = (pte_t *) pgdp;
 948                 goto out;
 949         } else if (is_hugepd(__hugepd(pgd_val(pgd))))
 950                 hpdp = (hugepd_t *)&pgd;
 951         else {
 952                 /*
 953                  * Even if we end up with an unmap, the pgtable will not
 954                  * be freed, because we do an rcu free and here we are
 955                  * irq disabled
 956                  */
 957                 pdshift = PUD_SHIFT;
 958                 pudp = pud_offset(&pgd, ea);
 959                 pud  = READ_ONCE(*pudp);
 960
 961                 if (pud_none(pud))
 962                         return NULL;
 963                 else if (pud_huge(pud)) {
 964                         ret_pte = (pte_t *) pudp;
 965                         goto out;
 966                 } else if (is_hugepd(__hugepd(pud_val(pud))))
 967                         hpdp = (hugepd_t *)&pud;
 968                 else {
 969                         pdshift = PMD_SHIFT;
 970                         pmdp = pmd_offset(&pud, ea);
 971                         pmd  = READ_ONCE(*pmdp);
 972                         /*
 973                          * A hugepage collapse is captured by pmd_none, because
 974                          * it mark the pmd none and do a hpte invalidate.
 975                          */
 976                         if (pmd_none(pmd))
 977                                 return NULL;
 978
 979                         if (pmd_trans_huge(pmd)) {
 980                                 if (is_thp)
 981                                         *is_thp = true;
 982                                 ret_pte = (pte_t *) pmdp;
 983                                 goto out;
 984                         }
 985
 986                         if (pmd_huge(pmd)) {
 987                                 ret_pte = (pte_t *) pmdp;
 988                                 goto out;
 989                         } else if (is_hugepd(__hugepd(pmd_val(pmd))))
 990                                 hpdp = (hugepd_t *)&pmd;
 991                         else
 992                                 return pte_offset_kernel(&pmd, ea);
 993                 }
 994         }
 995         if (!hpdp)
 996                 return NULL;
 997
 998         ret_pte = hugepte_offset(*hpdp, ea, pdshift);
 999         pdshift = hugepd_shift(*hpdp);
1000 out:
1001         if (shift)
1002                 *shift = pdshift;
1003         return ret_pte;
1004 }
1005 EXPORT_SYMBOL_GPL(__find_linux_pte_or_hugepte);
1006
1007 int gup_hugepte(pte_t *ptep, unsigned long sz, unsigned long addr,
1008                 unsigned long end, int write, struct page **pages, int *nr)
1009 {
1010         unsigned long mask;
1011         unsigned long pte_end;
1012         struct page *head, *page;
1013         pte_t pte;
1014         int refs;
1015
1016         pte_end = (addr + sz) & ~(sz-1);
1017         if (pte_end < end)
1018                 end = pte_end;
1019
1020         pte = READ_ONCE(*ptep);
1021         mask = _PAGE_PRESENT | _PAGE_READ;
1022
1023         /*
1024          * On some CPUs like the 8xx, _PAGE_RW hence _PAGE_WRITE is defined
1025          * as 0 and _PAGE_RO has to be set when a page is not writable
1026          */
1027         if (write)
1028                 mask |= _PAGE_WRITE;
1029         else
1030                 mask |= _PAGE_RO;
1031
1032         if ((pte_val(pte) & mask) != mask)
1033                 return 0;
1034
1035         /* hugepages are never "special" */
1036         VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
1037
1038         refs = 0;
1039         head = pte_page(pte);
1040
1041         page = head + ((addr & (sz-1)) >> PAGE_SHIFT);
1042         do {
1043                 VM_BUG_ON(compound_head(page) != head);
1044                 pages[*nr] = page;
1045                 (*nr)++;
1046                 page++;
1047                 refs++;
1048         } while (addr += PAGE_SIZE, addr != end);
1049
1050         if (!page_cache_add_speculative(head, refs)) {
1051                 *nr -= refs;
1052                 return 0;
1053         }
1054
1055         if (unlikely(pte_val(pte) != pte_val(*ptep))) {
1056                 /* Could be optimized better */
1057                 *nr -= refs;
1058                 while (refs--)
1059                         put_page(head);
1060                 return 0;
1061         }
1062
1063         return 1;
1064 }