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