SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/powerpc/mm/hugetlbpage.c

   1 /*
   2  * PPC64 (POWER4) Huge TLB Page Support for Kernel.
   3  *
   4  * Copyright (C) 2003 David Gibson, IBM Corporation.
   5  *
   6  * Based on the IA-32 version:
   7  * Copyright (C) 2002, Rohit Seth <rohit.seth@intel.com>
   8  */
   9
  10 #include <linux/init.h>
  11 #include <linux/fs.h>
  12 #include <linux/mm.h>
  13 #include <linux/hugetlb.h>
  14 #include <linux/pagemap.h>
  15 #include <linux/slab.h>
  16 #include <linux/err.h>
  17 #include <linux/sysctl.h>
  18 #include <asm/mman.h>
  19 #include <asm/pgalloc.h>
  20 #include <asm/tlb.h>
  21 #include <asm/tlbflush.h>
  22 #include <asm/mmu_context.h>
  23 #include <asm/machdep.h>
  24 #include <asm/cputable.h>
  25 #include <asm/spu.h>
  26
  27 #define PAGE_SHIFT_64K  16
  28 #define PAGE_SHIFT_16M  24
  29 #define PAGE_SHIFT_16G  34
  30
  31 #define NUM_LOW_AREAS   (0x100000000UL >> SID_SHIFT)
  32 #define NUM_HIGH_AREAS  (PGTABLE_RANGE >> HTLB_AREA_SHIFT)
  33 #define MAX_NUMBER_GPAGES       1024
  34
  35 /* Tracks the 16G pages after the device tree is scanned and before the
  36  * huge_boot_pages list is ready.  */
  37 static unsigned long gpage_freearray[MAX_NUMBER_GPAGES];
  38 static unsigned nr_gpages;
  39
  40 unsigned int hugepte_shift;
  41 #define PTRS_PER_HUGEPTE        (1 << hugepte_shift)
  42 #define HUGEPTE_TABLE_SIZE      (sizeof(pte_t) << hugepte_shift)
  43
  44 #define HUGEPD_SHIFT            (HPAGE_SHIFT + hugepte_shift)
  45 #define HUGEPD_SIZE             (1UL << HUGEPD_SHIFT)
  46 #define HUGEPD_MASK             (~(HUGEPD_SIZE-1))
  47
  48 #define huge_pgtable_cache      (pgtable_cache[HUGEPTE_CACHE_NUM])
  49
  50 /* Flag to mark huge PD pointers.  This means pmd_bad() and pud_bad()
  51  * will choke on pointers to hugepte tables, which is handy for
  52  * catching screwups early. */
  53 #define HUGEPD_OK       0x1
  54
  55 typedef struct { unsigned long pd; } hugepd_t;
  56
  57 #define hugepd_none(hpd)        ((hpd).pd == 0)
  58
  59 static inline pte_t *hugepd_page(hugepd_t hpd)
  60 {
  61         BUG_ON(!(hpd.pd & HUGEPD_OK));
  62         return (pte_t *)(hpd.pd & ~HUGEPD_OK);
  63 }
  64
  65 static inline pte_t *hugepte_offset(hugepd_t *hpdp, unsigned long addr)
  66 {
  67         unsigned long idx = ((addr >> HPAGE_SHIFT) & (PTRS_PER_HUGEPTE-1));
  68         pte_t *dir = hugepd_page(*hpdp);
  69
  70         return dir + idx;
  71 }
  72
  73 static int __hugepte_alloc(struct mm_struct *mm, hugepd_t *hpdp,
  74                            unsigned long address)
  75 {
  76         pte_t *new = kmem_cache_alloc(huge_pgtable_cache,
  77                                       GFP_KERNEL|__GFP_REPEAT);
  78
  79         if (! new)
  80                 return -ENOMEM;
  81
  82         spin_lock(&mm->page_table_lock);
  83         if (!hugepd_none(*hpdp))
  84                 kmem_cache_free(huge_pgtable_cache, new);
  85         else
  86                 hpdp->pd = (unsigned long)new | HUGEPD_OK;
  87         spin_unlock(&mm->page_table_lock);
  88         return 0;
  89 }
  90
  91 /* Base page size affects how we walk hugetlb page tables */
  92 #ifdef CONFIG_PPC_64K_PAGES
  93 #define hpmd_offset(pud, addr)          pmd_offset(pud, addr)
  94 #define hpmd_alloc(mm, pud, addr)       pmd_alloc(mm, pud, addr)
  95 #else
  96 static inline
  97 pmd_t *hpmd_offset(pud_t *pud, unsigned long addr)
  98 {
  99         if (HPAGE_SHIFT == PAGE_SHIFT_64K)
 100                 return pmd_offset(pud, addr);
 101         else
 102                 return (pmd_t *) pud;
 103 }
 104 static inline
 105 pmd_t *hpmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long addr)
 106 {
 107         if (HPAGE_SHIFT == PAGE_SHIFT_64K)
 108                 return pmd_alloc(mm, pud, addr);
 109         else
 110                 return (pmd_t *) pud;
 111 }
 112 #endif
 113
 114 /* Build list of addresses of gigantic pages.  This function is used in early
 115  * boot before the buddy or bootmem allocator is setup.
 116  */
 117 void add_gpage(unsigned long addr, unsigned long page_size,
 118         unsigned long number_of_pages)
 119 {
 120         if (!addr)
 121                 return;
 122         while (number_of_pages > 0) {
 123                 gpage_freearray[nr_gpages] = addr;
 124                 nr_gpages++;
 125                 number_of_pages--;
 126                 addr += page_size;
 127         }
 128 }
 129
 130 /* Moves the gigantic page addresses from the temporary list to the
 131  * huge_boot_pages list.  */
 132 int alloc_bootmem_huge_page(struct hstate *h)
 133 {
 134         struct huge_bootmem_page *m;
 135         if (nr_gpages == 0)
 136                 return 0;
 137         m = phys_to_virt(gpage_freearray[--nr_gpages]);
 138         gpage_freearray[nr_gpages] = 0;
 139         list_add(&m->list, &huge_boot_pages);
 140         m->hstate = h;
 141         return 1;
 142 }
 143
 144
 145 /* Modelled after find_linux_pte() */
 146 pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
 147 {
 148         pgd_t *pg;
 149         pud_t *pu;
 150         pmd_t *pm;
 151
 152         BUG_ON(get_slice_psize(mm, addr) != mmu_huge_psize);
 153
 154         addr &= HPAGE_MASK;
 155
 156         pg = pgd_offset(mm, addr);
 157         if (!pgd_none(*pg)) {
 158                 pu = pud_offset(pg, addr);
 159                 if (!pud_none(*pu)) {
 160                         pm = hpmd_offset(pu, addr);
 161                         if (!pmd_none(*pm))
 162                                 return hugepte_offset((hugepd_t *)pm, addr);
 163                 }
 164         }
 165
 166         return NULL;
 167 }
 168
 169 pte_t *huge_pte_alloc(struct mm_struct *mm,
 170                         unsigned long addr, unsigned long sz)
 171 {
 172         pgd_t *pg;
 173         pud_t *pu;
 174         pmd_t *pm;
 175         hugepd_t *hpdp = NULL;
 176
 177         BUG_ON(get_slice_psize(mm, addr) != mmu_huge_psize);
 178
 179         addr &= HPAGE_MASK;
 180
 181         pg = pgd_offset(mm, addr);
 182         pu = pud_alloc(mm, pg, addr);
 183
 184         if (pu) {
 185                 pm = hpmd_alloc(mm, pu, addr);
 186                 if (pm)
 187                         hpdp = (hugepd_t *)pm;
 188         }
 189
 190         if (! hpdp)
 191                 return NULL;
 192
 193         if (hugepd_none(*hpdp) && __hugepte_alloc(mm, hpdp, addr))
 194                 return NULL;
 195
 196         return hugepte_offset(hpdp, addr);
 197 }
 198
 199 int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep)
 200 {
 201         return 0;
 202 }
 203
 204 static void free_hugepte_range(struct mmu_gather *tlb, hugepd_t *hpdp)
 205 {
 206         pte_t *hugepte = hugepd_page(*hpdp);
 207
 208         hpdp->pd = 0;
 209         tlb->need_flush = 1;
 210         pgtable_free_tlb(tlb, pgtable_free_cache(hugepte, HUGEPTE_CACHE_NUM,
 211                                                  PGF_CACHENUM_MASK));
 212 }
 213
 214 static void hugetlb_free_pmd_range(struct mmu_gather *tlb, pud_t *pud,
 215                                    unsigned long addr, unsigned long end,
 216                                    unsigned long floor, unsigned long ceiling)
 217 {
 218         pmd_t *pmd;
 219         unsigned long next;
 220         unsigned long start;
 221
 222         start = addr;
 223         pmd = pmd_offset(pud, addr);
 224         do {
 225                 next = pmd_addr_end(addr, end);
 226                 if (pmd_none(*pmd))
 227                         continue;
 228                 free_hugepte_range(tlb, (hugepd_t *)pmd);
 229         } while (pmd++, addr = next, addr != end);
 230
 231         start &= PUD_MASK;
 232         if (start < floor)
 233                 return;
 234         if (ceiling) {
 235                 ceiling &= PUD_MASK;
 236                 if (!ceiling)
 237                         return;
 238         }
 239         if (end - 1 > ceiling - 1)
 240                 return;
 241
 242         pmd = pmd_offset(pud, start);
 243         pud_clear(pud);
 244         pmd_free_tlb(tlb, pmd);
 245 }
 246
 247 static void hugetlb_free_pud_range(struct mmu_gather *tlb, pgd_t *pgd,
 248                                    unsigned long addr, unsigned long end,
 249                                    unsigned long floor, unsigned long ceiling)
 250 {
 251         pud_t *pud;
 252         unsigned long next;
 253         unsigned long start;
 254
 255         start = addr;
 256         pud = pud_offset(pgd, addr);
 257         do {
 258                 next = pud_addr_end(addr, end);
 259 #ifdef CONFIG_PPC_64K_PAGES
 260                 if (pud_none_or_clear_bad(pud))
 261                         continue;
 262                 hugetlb_free_pmd_range(tlb, pud, addr, next, floor, ceiling);
 263 #else
 264                 if (HPAGE_SHIFT == PAGE_SHIFT_64K) {
 265                         if (pud_none_or_clear_bad(pud))
 266                                 continue;
 267                         hugetlb_free_pmd_range(tlb, pud, addr, next, floor, ceiling);
 268                 } else {
 269                         if (pud_none(*pud))
 270                                 continue;
 271                         free_hugepte_range(tlb, (hugepd_t *)pud);
 272                 }
 273 #endif
 274         } while (pud++, addr = next, addr != end);
 275
 276         start &= PGDIR_MASK;
 277         if (start < floor)
 278                 return;
 279         if (ceiling) {
 280                 ceiling &= PGDIR_MASK;
 281                 if (!ceiling)
 282                         return;
 283         }
 284         if (end - 1 > ceiling - 1)
 285                 return;
 286
 287         pud = pud_offset(pgd, start);
 288         pgd_clear(pgd);
 289         pud_free_tlb(tlb, pud);
 290 }
 291
 292 /*
 293  * This function frees user-level page tables of a process.
 294  *
 295  * Must be called with pagetable lock held.
 296  */
 297 void hugetlb_free_pgd_range(struct mmu_gather *tlb,
 298                             unsigned long addr, unsigned long end,
 299                             unsigned long floor, unsigned long ceiling)
 300 {
 301         pgd_t *pgd;
 302         unsigned long next;
 303         unsigned long start;
 304
 305         /*
 306          * Comments below take from the normal free_pgd_range().  They
 307          * apply here too.  The tests against HUGEPD_MASK below are
 308          * essential, because we *don't* test for this at the bottom
 309          * level.  Without them we'll attempt to free a hugepte table
 310          * when we unmap just part of it, even if there are other
 311          * active mappings using it.
 312          *
 313          * The next few lines have given us lots of grief...
 314          *
 315          * Why are we testing HUGEPD* at this top level?  Because
 316          * often there will be no work to do at all, and we'd prefer
 317          * not to go all the way down to the bottom just to discover
 318          * that.
 319          *
 320          * Why all these "- 1"s?  Because 0 represents both the bottom
 321          * of the address space and the top of it (using -1 for the
 322          * top wouldn't help much: the masks would do the wrong thing).
 323          * The rule is that addr 0 and floor 0 refer to the bottom of
 324          * the address space, but end 0 and ceiling 0 refer to the top
 325          * Comparisons need to use "end - 1" and "ceiling - 1" (though
 326          * that end 0 case should be mythical).
 327          *
 328          * Wherever addr is brought up or ceiling brought down, we
 329          * must be careful to reject "the opposite 0" before it
 330          * confuses the subsequent tests.  But what about where end is
 331          * brought down by HUGEPD_SIZE below? no, end can't go down to
 332          * 0 there.
 333          *
 334          * Whereas we round start (addr) and ceiling down, by different
 335          * masks at different levels, in order to test whether a table
 336          * now has no other vmas using it, so can be freed, we don't
 337          * bother to round floor or end up - the tests don't need that.
 338          */
 339
 340         addr &= HUGEPD_MASK;
 341         if (addr < floor) {
 342                 addr += HUGEPD_SIZE;
 343                 if (!addr)
 344                         return;
 345         }
 346         if (ceiling) {
 347                 ceiling &= HUGEPD_MASK;
 348                 if (!ceiling)
 349                         return;
 350         }
 351         if (end - 1 > ceiling - 1)
 352                 end -= HUGEPD_SIZE;
 353         if (addr > end - 1)
 354                 return;
 355
 356         start = addr;
 357         pgd = pgd_offset(tlb->mm, addr);
 358         do {
 359                 BUG_ON(get_slice_psize(tlb->mm, addr) != mmu_huge_psize);
 360                 next = pgd_addr_end(addr, end);
 361                 if (pgd_none_or_clear_bad(pgd))
 362                         continue;
 363                 hugetlb_free_pud_range(tlb, pgd, addr, next, floor, ceiling);
 364         } while (pgd++, addr = next, addr != end);
 365 }
 366
 367 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
 368                      pte_t *ptep, pte_t pte)
 369 {
 370         if (pte_present(*ptep)) {
 371                 /* We open-code pte_clear because we need to pass the right
 372                  * argument to hpte_need_flush (huge / !huge). Might not be
 373                  * necessary anymore if we make hpte_need_flush() get the
 374                  * page size from the slices
 375                  */
 376                 pte_update(mm, addr & HPAGE_MASK, ptep, ~0UL, 1);
 377         }
 378         *ptep = __pte(pte_val(pte) & ~_PAGE_HPTEFLAGS);
 379 }
 380
 381 pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
 382                               pte_t *ptep)
 383 {
 384         unsigned long old = pte_update(mm, addr, ptep, ~0UL, 1);
 385         return __pte(old);
 386 }
 387
 388 struct page *
 389 follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
 390 {
 391         pte_t *ptep;
 392         struct page *page;
 393
 394         if (get_slice_psize(mm, address) != mmu_huge_psize)
 395                 return ERR_PTR(-EINVAL);
 396
 397         ptep = huge_pte_offset(mm, address);
 398         page = pte_page(*ptep);
 399         if (page)
 400                 page += (address % HPAGE_SIZE) / PAGE_SIZE;
 401
 402         return page;
 403 }
 404
 405 int pmd_huge(pmd_t pmd)
 406 {
 407         return 0;
 408 }
 409
 410 int pud_huge(pud_t pud)
 411 {
 412         return 0;
 413 }
 414
 415 struct page *
 416 follow_huge_pmd(struct mm_struct *mm, unsigned long address,
 417                 pmd_t *pmd, int write)
 418 {
 419         BUG();
 420         return NULL;
 421 }
 422
 423
 424 unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
 425                                         unsigned long len, unsigned long pgoff,
 426                                         unsigned long flags)
 427 {
 428         return slice_get_unmapped_area(addr, len, flags,
 429                                        mmu_huge_psize, 1, 0);
 430 }
 431
 432 /*
 433  * Called by asm hashtable.S for doing lazy icache flush
 434  */
 435 static unsigned int hash_huge_page_do_lazy_icache(unsigned long rflags,
 436                                                   pte_t pte, int trap)
 437 {
 438         struct page *page;
 439         int i;
 440
 441         if (!pfn_valid(pte_pfn(pte)))
 442                 return rflags;
 443
 444         page = pte_page(pte);
 445
 446         /* page is dirty */
 447         if (!test_bit(PG_arch_1, &page->flags) && !PageReserved(page)) {
 448                 if (trap == 0x400) {
 449                         for (i = 0; i < (HPAGE_SIZE / PAGE_SIZE); i++)
 450                                 __flush_dcache_icache(page_address(page+i));
 451                         set_bit(PG_arch_1, &page->flags);
 452                 } else {
 453                         rflags |= HPTE_R_N;
 454                 }
 455         }
 456         return rflags;
 457 }
 458
 459 int hash_huge_page(struct mm_struct *mm, unsigned long access,
 460                    unsigned long ea, unsigned long vsid, int local,
 461                    unsigned long trap)
 462 {
 463         pte_t *ptep;
 464         unsigned long old_pte, new_pte;
 465         unsigned long va, rflags, pa;
 466         long slot;
 467         int err = 1;
 468         int ssize = user_segment_size(ea);
 469
 470         ptep = huge_pte_offset(mm, ea);
 471
 472         /* Search the Linux page table for a match with va */
 473         va = hpt_va(ea, vsid, ssize);
 474
 475         /*
 476          * If no pte found or not present, send the problem up to
 477          * do_page_fault
 478          */
 479         if (unlikely(!ptep || pte_none(*ptep)))
 480                 goto out;
 481
 482         /*
 483          * Check the user's access rights to the page.  If access should be
 484          * prevented then send the problem up to do_page_fault.
 485          */
 486         if (unlikely(access & ~pte_val(*ptep)))
 487                 goto out;
 488         /*
 489          * At this point, we have a pte (old_pte) which can be used to build
 490          * or update an HPTE. There are 2 cases:
 491          *
 492          * 1. There is a valid (present) pte with no associated HPTE (this is
 493          *      the most common case)
 494          * 2. There is a valid (present) pte with an associated HPTE. The
 495          *      current values of the pp bits in the HPTE prevent access
 496          *      because we are doing software DIRTY bit management and the
 497          *      page is currently not DIRTY.
 498          */
 499
 500
 501         do {
 502                 old_pte = pte_val(*ptep);
 503                 if (old_pte & _PAGE_BUSY)
 504                         goto out;
 505                 new_pte = old_pte | _PAGE_BUSY | _PAGE_ACCESSED;
 506         } while(old_pte != __cmpxchg_u64((unsigned long *)ptep,
 507                                          old_pte, new_pte));
 508
 509         rflags = 0x2 | (!(new_pte & _PAGE_RW));
 510         /* _PAGE_EXEC -> HW_NO_EXEC since it's inverted */
 511         rflags |= ((new_pte & _PAGE_EXEC) ? 0 : HPTE_R_N);
 512         if (!cpu_has_feature(CPU_FTR_COHERENT_ICACHE))
 513                 /* No CPU has hugepages but lacks no execute, so we
 514                  * don't need to worry about that case */
 515                 rflags = hash_huge_page_do_lazy_icache(rflags, __pte(old_pte),
 516                                                        trap);
 517
 518         /* Check if pte already has an hpte (case 2) */
 519         if (unlikely(old_pte & _PAGE_HASHPTE)) {
 520                 /* There MIGHT be an HPTE for this pte */
 521                 unsigned long hash, slot;
 522
 523                 hash = hpt_hash(va, HPAGE_SHIFT, ssize);
 524                 if (old_pte & _PAGE_F_SECOND)
 525                         hash = ~hash;
 526                 slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
 527                 slot += (old_pte & _PAGE_F_GIX) >> 12;
 528
 529                 if (ppc_md.hpte_updatepp(slot, rflags, va, mmu_huge_psize,
 530                                          ssize, local) == -1)
 531                         old_pte &= ~_PAGE_HPTEFLAGS;
 532         }
 533
 534         if (likely(!(old_pte & _PAGE_HASHPTE))) {
 535                 unsigned long hash = hpt_hash(va, HPAGE_SHIFT, ssize);
 536                 unsigned long hpte_group;
 537
 538                 pa = pte_pfn(__pte(old_pte)) << PAGE_SHIFT;
 539
 540 repeat:
 541                 hpte_group = ((hash & htab_hash_mask) *
 542                               HPTES_PER_GROUP) & ~0x7UL;
 543
 544                 /* clear HPTE slot informations in new PTE */
 545 #ifdef CONFIG_PPC_64K_PAGES
 546                 new_pte = (new_pte & ~_PAGE_HPTEFLAGS) | _PAGE_HPTE_SUB0;
 547 #else
 548                 new_pte = (new_pte & ~_PAGE_HPTEFLAGS) | _PAGE_HASHPTE;
 549 #endif
 550                 /* Add in WIMG bits */
 551                 rflags |= (new_pte & (_PAGE_WRITETHRU | _PAGE_NO_CACHE |
 552                                       _PAGE_COHERENT | _PAGE_GUARDED));
 553
 554                 /* Insert into the hash table, primary slot */
 555                 slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags, 0,
 556                                           mmu_huge_psize, ssize);
 557
 558                 /* Primary is full, try the secondary */
 559                 if (unlikely(slot == -1)) {
 560                         hpte_group = ((~hash & htab_hash_mask) *
 561                                       HPTES_PER_GROUP) & ~0x7UL;
 562                         slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags,
 563                                                   HPTE_V_SECONDARY,
 564                                                   mmu_huge_psize, ssize);
 565                         if (slot == -1) {
 566                                 if (mftb() & 0x1)
 567                                         hpte_group = ((hash & htab_hash_mask) *
 568                                                       HPTES_PER_GROUP)&~0x7UL;
 569
 570                                 ppc_md.hpte_remove(hpte_group);
 571                                 goto repeat;
 572                         }
 573                 }
 574
 575                 if (unlikely(slot == -2))
 576                         panic("hash_huge_page: pte_insert failed\n");
 577
 578                 new_pte |= (slot << 12) & (_PAGE_F_SECOND | _PAGE_F_GIX);
 579         }
 580
 581         /*
 582          * No need to use ldarx/stdcx here
 583          */
 584         *ptep = __pte(new_pte & ~_PAGE_BUSY);
 585
 586         err = 0;
 587
 588  out:
 589         return err;
 590 }
 591
 592 void set_huge_psize(int psize)
 593 {
 594         /* Check that it is a page size supported by the hardware and
 595          * that it fits within pagetable limits. */
 596         if (mmu_psize_defs[psize].shift &&
 597                 mmu_psize_defs[psize].shift < SID_SHIFT_1T &&
 598                 (mmu_psize_defs[psize].shift > MIN_HUGEPTE_SHIFT ||
 599                  mmu_psize_defs[psize].shift == PAGE_SHIFT_64K ||
 600                  mmu_psize_defs[psize].shift == PAGE_SHIFT_16G)) {
 601                 /* Return if huge page size is the same as the
 602                  * base page size. */
 603                 if (mmu_psize_defs[psize].shift == PAGE_SHIFT)
 604                         return;
 605
 606                 HPAGE_SHIFT = mmu_psize_defs[psize].shift;
 607                 mmu_huge_psize = psize;
 608
 609                 switch (HPAGE_SHIFT) {
 610                 case PAGE_SHIFT_64K:
 611                     /* We only allow 64k hpages with 4k base page,
 612                      * which was checked above, and always put them
 613                      * at the PMD */
 614                     hugepte_shift = PMD_SHIFT;
 615                     break;
 616                 case PAGE_SHIFT_16M:
 617                     /* 16M pages can be at two different levels
 618                      * of pagestables based on base page size */
 619                     if (PAGE_SHIFT == PAGE_SHIFT_64K)
 620                             hugepte_shift = PMD_SHIFT;
 621                     else /* 4k base page */
 622                             hugepte_shift = PUD_SHIFT;
 623                     break;
 624                 case PAGE_SHIFT_16G:
 625                     /* 16G pages are always at PGD level */
 626                     hugepte_shift = PGDIR_SHIFT;
 627                     break;
 628                 }
 629                 hugepte_shift -= HPAGE_SHIFT;
 630         } else
 631                 HPAGE_SHIFT = 0;
 632 }
 633
 634 static int __init hugepage_setup_sz(char *str)
 635 {
 636         unsigned long long size;
 637         int mmu_psize = -1;
 638         int shift;
 639
 640         size = memparse(str, &str);
 641
 642         shift = __ffs(size);
 643         switch (shift) {
 644 #ifndef CONFIG_PPC_64K_PAGES
 645         case PAGE_SHIFT_64K:
 646                 mmu_psize = MMU_PAGE_64K;
 647                 break;
 648 #endif
 649         case PAGE_SHIFT_16M:
 650                 mmu_psize = MMU_PAGE_16M;
 651                 break;
 652         case PAGE_SHIFT_16G:
 653                 mmu_psize = MMU_PAGE_16G;
 654                 break;
 655         }
 656
 657         if (mmu_psize >= 0 && mmu_psize_defs[mmu_psize].shift) {
 658                 set_huge_psize(mmu_psize);
 659                 hugetlb_add_hstate(shift - PAGE_SHIFT);
 660         }
 661         else
 662                 printk(KERN_WARNING "Invalid huge page size specified(%llu)\n", size);
 663
 664         return 1;
 665 }
 666 __setup("hugepagesz=", hugepage_setup_sz);
 667
 668 static void zero_ctor(struct kmem_cache *cache, void *addr)
 669 {
 670         memset(addr, 0, kmem_cache_size(cache));
 671 }
 672
 673 static int __init hugetlbpage_init(void)
 674 {
 675         if (!cpu_has_feature(CPU_FTR_16M_PAGE))
 676                 return -ENODEV;
 677
 678         huge_pgtable_cache = kmem_cache_create("hugepte_cache",
 679                                                HUGEPTE_TABLE_SIZE,
 680                                                HUGEPTE_TABLE_SIZE,
 681                                                0,
 682                                                zero_ctor);
 683         if (! huge_pgtable_cache)
 684                 panic("hugetlbpage_init(): could not create hugepte cache\n");
 685
 686         return 0;
 687 }
 688
 689 module_init(hugetlbpage_init);