2 * PPC64 (POWER4) Huge TLB Page Support for Kernel.
4 * Copyright (C) 2003 David Gibson, IBM Corporation.
6 * Based on the IA-32 version:
7 * Copyright (C) 2002, Rohit Seth <rohit.seth@intel.com>
10 #include <linux/init.h>
13 #include <linux/hugetlb.h>
14 #include <linux/pagemap.h>
15 #include <linux/smp_lock.h>
16 #include <linux/slab.h>
17 #include <linux/err.h>
18 #include <linux/sysctl.h>
20 #include <asm/pgalloc.h>
22 #include <asm/tlbflush.h>
23 #include <asm/mmu_context.h>
24 #include <asm/machdep.h>
25 #include <asm/cputable.h>
28 #include <linux/sysctl.h>
30 #define NUM_LOW_AREAS (0x100000000UL >> SID_SHIFT)
31 #define NUM_HIGH_AREAS (PGTABLE_RANGE >> HTLB_AREA_SHIFT)
33 /* Modelled after find_linux_pte() */
34 pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
41 BUG_ON(! in_hugepage_area(mm->context, addr));
45 pg = pgd_offset(mm, addr);
47 pu = pud_offset(pg, addr);
49 pm = pmd_offset(pu, addr);
50 #ifdef CONFIG_PPC_64K_PAGES
51 /* Currently, we use the normal PTE offset within full
52 * size PTE pages, thus our huge PTEs are scattered in
53 * the PTE page and we do waste some. We may change
54 * that in the future, but the current mecanism keeps
58 /* Note: pte_offset_* are all equivalent on
59 * ppc64 as we don't have HIGHMEM
61 pt = pte_offset_kernel(pm, addr);
64 #else /* CONFIG_PPC_64K_PAGES */
65 /* On 4k pages, we put huge PTEs in the PMD page */
68 #endif /* CONFIG_PPC_64K_PAGES */
75 pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr)
82 BUG_ON(! in_hugepage_area(mm->context, addr));
86 pg = pgd_offset(mm, addr);
87 pu = pud_alloc(mm, pg, addr);
90 pm = pmd_alloc(mm, pu, addr);
92 #ifdef CONFIG_PPC_64K_PAGES
93 /* See comment in huge_pte_offset. Note that if we ever
94 * want to put the page size in the PMD, we would have
95 * to open code our own pte_alloc* function in order
96 * to populate and set the size atomically
98 pt = pte_alloc_map(mm, pm, addr);
99 #else /* CONFIG_PPC_64K_PAGES */
101 #endif /* CONFIG_PPC_64K_PAGES */
109 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
110 pte_t *ptep, pte_t pte)
112 if (pte_present(*ptep)) {
113 /* We open-code pte_clear because we need to pass the right
114 * argument to hpte_update (huge / !huge)
116 unsigned long old = pte_update(ptep, ~0UL);
117 if (old & _PAGE_HASHPTE)
118 hpte_update(mm, addr & HPAGE_MASK, ptep, old, 1);
121 *ptep = __pte(pte_val(pte) & ~_PAGE_HPTEFLAGS);
124 pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
127 unsigned long old = pte_update(ptep, ~0UL);
129 if (old & _PAGE_HASHPTE)
130 hpte_update(mm, addr & HPAGE_MASK, ptep, old, 1);
137 * This function checks for proper alignment of input addr and len parameters.
139 int is_aligned_hugepage_range(unsigned long addr, unsigned long len)
141 if (len & ~HPAGE_MASK)
143 if (addr & ~HPAGE_MASK)
145 if (! (within_hugepage_low_range(addr, len)
146 || within_hugepage_high_range(addr, len)) )
151 static void flush_low_segments(void *parm)
153 u16 areas = (unsigned long) parm;
156 asm volatile("isync" : : : "memory");
158 BUILD_BUG_ON((sizeof(areas)*8) != NUM_LOW_AREAS);
160 for (i = 0; i < NUM_LOW_AREAS; i++) {
161 if (! (areas & (1U << i)))
163 asm volatile("slbie %0"
164 : : "r" ((i << SID_SHIFT) | SLBIE_C));
167 asm volatile("isync" : : : "memory");
170 static void flush_high_segments(void *parm)
172 u16 areas = (unsigned long) parm;
175 asm volatile("isync" : : : "memory");
177 BUILD_BUG_ON((sizeof(areas)*8) != NUM_HIGH_AREAS);
179 for (i = 0; i < NUM_HIGH_AREAS; i++) {
180 if (! (areas & (1U << i)))
182 for (j = 0; j < (1UL << (HTLB_AREA_SHIFT-SID_SHIFT)); j++)
183 asm volatile("slbie %0"
184 :: "r" (((i << HTLB_AREA_SHIFT)
185 + (j << SID_SHIFT)) | SLBIE_C));
188 asm volatile("isync" : : : "memory");
191 static int prepare_low_area_for_htlb(struct mm_struct *mm, unsigned long area)
193 unsigned long start = area << SID_SHIFT;
194 unsigned long end = (area+1) << SID_SHIFT;
195 struct vm_area_struct *vma;
197 BUG_ON(area >= NUM_LOW_AREAS);
199 /* Check no VMAs are in the region */
200 vma = find_vma(mm, start);
201 if (vma && (vma->vm_start < end))
207 static int prepare_high_area_for_htlb(struct mm_struct *mm, unsigned long area)
209 unsigned long start = area << HTLB_AREA_SHIFT;
210 unsigned long end = (area+1) << HTLB_AREA_SHIFT;
211 struct vm_area_struct *vma;
213 BUG_ON(area >= NUM_HIGH_AREAS);
215 /* Check no VMAs are in the region */
216 vma = find_vma(mm, start);
217 if (vma && (vma->vm_start < end))
223 static int open_low_hpage_areas(struct mm_struct *mm, u16 newareas)
227 BUILD_BUG_ON((sizeof(newareas)*8) != NUM_LOW_AREAS);
228 BUILD_BUG_ON((sizeof(mm->context.low_htlb_areas)*8) != NUM_LOW_AREAS);
230 newareas &= ~(mm->context.low_htlb_areas);
232 return 0; /* The segments we want are already open */
234 for (i = 0; i < NUM_LOW_AREAS; i++)
235 if ((1 << i) & newareas)
236 if (prepare_low_area_for_htlb(mm, i) != 0)
239 mm->context.low_htlb_areas |= newareas;
241 /* update the paca copy of the context struct */
242 get_paca()->context = mm->context;
244 /* the context change must make it to memory before the flush,
245 * so that further SLB misses do the right thing. */
247 on_each_cpu(flush_low_segments, (void *)(unsigned long)newareas, 0, 1);
252 static int open_high_hpage_areas(struct mm_struct *mm, u16 newareas)
256 BUILD_BUG_ON((sizeof(newareas)*8) != NUM_HIGH_AREAS);
257 BUILD_BUG_ON((sizeof(mm->context.high_htlb_areas)*8)
260 newareas &= ~(mm->context.high_htlb_areas);
262 return 0; /* The areas we want are already open */
264 for (i = 0; i < NUM_HIGH_AREAS; i++)
265 if ((1 << i) & newareas)
266 if (prepare_high_area_for_htlb(mm, i) != 0)
269 mm->context.high_htlb_areas |= newareas;
271 /* update the paca copy of the context struct */
272 get_paca()->context = mm->context;
274 /* the context change must make it to memory before the flush,
275 * so that further SLB misses do the right thing. */
277 on_each_cpu(flush_high_segments, (void *)(unsigned long)newareas, 0, 1);
282 int prepare_hugepage_range(unsigned long addr, unsigned long len)
286 if ( (addr+len) < addr )
289 if ((addr + len) < 0x100000000UL)
290 err = open_low_hpage_areas(current->mm,
291 LOW_ESID_MASK(addr, len));
293 err = open_high_hpage_areas(current->mm,
294 HTLB_AREA_MASK(addr, len));
296 printk(KERN_DEBUG "prepare_hugepage_range(%lx, %lx)"
297 " failed (lowmask: 0x%04hx, highmask: 0x%04hx)\n",
299 LOW_ESID_MASK(addr, len), HTLB_AREA_MASK(addr, len));
307 follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
312 if (! in_hugepage_area(mm->context, address))
313 return ERR_PTR(-EINVAL);
315 ptep = huge_pte_offset(mm, address);
316 page = pte_page(*ptep);
318 page += (address % HPAGE_SIZE) / PAGE_SIZE;
323 int pmd_huge(pmd_t pmd)
329 follow_huge_pmd(struct mm_struct *mm, unsigned long address,
330 pmd_t *pmd, int write)
336 /* Because we have an exclusive hugepage region which lies within the
337 * normal user address space, we have to take special measures to make
338 * non-huge mmap()s evade the hugepage reserved regions. */
339 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
340 unsigned long len, unsigned long pgoff,
343 struct mm_struct *mm = current->mm;
344 struct vm_area_struct *vma;
345 unsigned long start_addr;
351 addr = PAGE_ALIGN(addr);
352 vma = find_vma(mm, addr);
353 if (((TASK_SIZE - len) >= addr)
354 && (!vma || (addr+len) <= vma->vm_start)
355 && !is_hugepage_only_range(mm, addr,len))
358 if (len > mm->cached_hole_size) {
359 start_addr = addr = mm->free_area_cache;
361 start_addr = addr = TASK_UNMAPPED_BASE;
362 mm->cached_hole_size = 0;
366 vma = find_vma(mm, addr);
367 while (TASK_SIZE - len >= addr) {
368 BUG_ON(vma && (addr >= vma->vm_end));
370 if (touches_hugepage_low_range(mm, addr, len)) {
371 addr = ALIGN(addr+1, 1<<SID_SHIFT);
372 vma = find_vma(mm, addr);
375 if (touches_hugepage_high_range(mm, addr, len)) {
376 addr = ALIGN(addr+1, 1UL<<HTLB_AREA_SHIFT);
377 vma = find_vma(mm, addr);
380 if (!vma || addr + len <= vma->vm_start) {
382 * Remember the place where we stopped the search:
384 mm->free_area_cache = addr + len;
387 if (addr + mm->cached_hole_size < vma->vm_start)
388 mm->cached_hole_size = vma->vm_start - addr;
393 /* Make sure we didn't miss any holes */
394 if (start_addr != TASK_UNMAPPED_BASE) {
395 start_addr = addr = TASK_UNMAPPED_BASE;
396 mm->cached_hole_size = 0;
403 * This mmap-allocator allocates new areas top-down from below the
404 * stack's low limit (the base):
406 * Because we have an exclusive hugepage region which lies within the
407 * normal user address space, we have to take special measures to make
408 * non-huge mmap()s evade the hugepage reserved regions.
411 arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
412 const unsigned long len, const unsigned long pgoff,
413 const unsigned long flags)
415 struct vm_area_struct *vma, *prev_vma;
416 struct mm_struct *mm = current->mm;
417 unsigned long base = mm->mmap_base, addr = addr0;
418 unsigned long largest_hole = mm->cached_hole_size;
421 /* requested length too big for entire address space */
425 /* dont allow allocations above current base */
426 if (mm->free_area_cache > base)
427 mm->free_area_cache = base;
429 /* requesting a specific address */
431 addr = PAGE_ALIGN(addr);
432 vma = find_vma(mm, addr);
433 if (TASK_SIZE - len >= addr &&
434 (!vma || addr + len <= vma->vm_start)
435 && !is_hugepage_only_range(mm, addr,len))
439 if (len <= largest_hole) {
441 mm->free_area_cache = base;
444 /* make sure it can fit in the remaining address space */
445 if (mm->free_area_cache < len)
448 /* either no address requested or cant fit in requested address hole */
449 addr = (mm->free_area_cache - len) & PAGE_MASK;
452 if (touches_hugepage_low_range(mm, addr, len)) {
453 addr = (addr & ((~0) << SID_SHIFT)) - len;
454 goto hugepage_recheck;
455 } else if (touches_hugepage_high_range(mm, addr, len)) {
456 addr = (addr & ((~0UL) << HTLB_AREA_SHIFT)) - len;
457 goto hugepage_recheck;
461 * Lookup failure means no vma is above this address,
462 * i.e. return with success:
464 if (!(vma = find_vma_prev(mm, addr, &prev_vma)))
468 * new region fits between prev_vma->vm_end and
469 * vma->vm_start, use it:
471 if (addr+len <= vma->vm_start &&
472 (!prev_vma || (addr >= prev_vma->vm_end))) {
473 /* remember the address as a hint for next time */
474 mm->cached_hole_size = largest_hole;
475 return (mm->free_area_cache = addr);
477 /* pull free_area_cache down to the first hole */
478 if (mm->free_area_cache == vma->vm_end) {
479 mm->free_area_cache = vma->vm_start;
480 mm->cached_hole_size = largest_hole;
484 /* remember the largest hole we saw so far */
485 if (addr + largest_hole < vma->vm_start)
486 largest_hole = vma->vm_start - addr;
488 /* try just below the current vma->vm_start */
489 addr = vma->vm_start-len;
490 } while (len <= vma->vm_start);
494 * if hint left us with no space for the requested
495 * mapping then try again:
498 mm->free_area_cache = base;
504 * A failed mmap() very likely causes application failure,
505 * so fall back to the bottom-up function here. This scenario
506 * can happen with large stack limits and large mmap()
509 mm->free_area_cache = TASK_UNMAPPED_BASE;
510 mm->cached_hole_size = ~0UL;
511 addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
513 * Restore the topdown base:
515 mm->free_area_cache = base;
516 mm->cached_hole_size = ~0UL;
521 static unsigned long htlb_get_low_area(unsigned long len, u16 segmask)
523 unsigned long addr = 0;
524 struct vm_area_struct *vma;
526 vma = find_vma(current->mm, addr);
527 while (addr + len <= 0x100000000UL) {
528 BUG_ON(vma && (addr >= vma->vm_end)); /* invariant */
530 if (! __within_hugepage_low_range(addr, len, segmask)) {
531 addr = ALIGN(addr+1, 1<<SID_SHIFT);
532 vma = find_vma(current->mm, addr);
536 if (!vma || (addr + len) <= vma->vm_start)
538 addr = ALIGN(vma->vm_end, HPAGE_SIZE);
539 /* Depending on segmask this might not be a confirmed
540 * hugepage region, so the ALIGN could have skipped
542 vma = find_vma(current->mm, addr);
548 static unsigned long htlb_get_high_area(unsigned long len, u16 areamask)
550 unsigned long addr = 0x100000000UL;
551 struct vm_area_struct *vma;
553 vma = find_vma(current->mm, addr);
554 while (addr + len <= TASK_SIZE_USER64) {
555 BUG_ON(vma && (addr >= vma->vm_end)); /* invariant */
557 if (! __within_hugepage_high_range(addr, len, areamask)) {
558 addr = ALIGN(addr+1, 1UL<<HTLB_AREA_SHIFT);
559 vma = find_vma(current->mm, addr);
563 if (!vma || (addr + len) <= vma->vm_start)
565 addr = ALIGN(vma->vm_end, HPAGE_SIZE);
566 /* Depending on segmask this might not be a confirmed
567 * hugepage region, so the ALIGN could have skipped
569 vma = find_vma(current->mm, addr);
575 unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
576 unsigned long len, unsigned long pgoff,
580 u16 areamask, curareas;
582 if (HPAGE_SHIFT == 0)
584 if (len & ~HPAGE_MASK)
587 if (!cpu_has_feature(CPU_FTR_16M_PAGE))
590 if (test_thread_flag(TIF_32BIT)) {
591 curareas = current->mm->context.low_htlb_areas;
593 /* First see if we can do the mapping in the existing
595 addr = htlb_get_low_area(len, curareas);
600 for (areamask = LOW_ESID_MASK(0x100000000UL-len, len);
601 ! lastshift; areamask >>=1) {
605 addr = htlb_get_low_area(len, curareas | areamask);
606 if ((addr != -ENOMEM)
607 && open_low_hpage_areas(current->mm, areamask) == 0)
611 curareas = current->mm->context.high_htlb_areas;
613 /* First see if we can do the mapping in the existing
615 addr = htlb_get_high_area(len, curareas);
620 for (areamask = HTLB_AREA_MASK(TASK_SIZE_USER64-len, len);
621 ! lastshift; areamask >>=1) {
625 addr = htlb_get_high_area(len, curareas | areamask);
626 if ((addr != -ENOMEM)
627 && open_high_hpage_areas(current->mm, areamask) == 0)
631 printk(KERN_DEBUG "hugetlb_get_unmapped_area() unable to open"
636 int hash_huge_page(struct mm_struct *mm, unsigned long access,
637 unsigned long ea, unsigned long vsid, int local)
640 unsigned long old_pte, new_pte;
641 unsigned long va, rflags, pa;
645 ptep = huge_pte_offset(mm, ea);
647 /* Search the Linux page table for a match with va */
648 va = (vsid << 28) | (ea & 0x0fffffff);
651 * If no pte found or not present, send the problem up to
654 if (unlikely(!ptep || pte_none(*ptep)))
658 * Check the user's access rights to the page. If access should be
659 * prevented then send the problem up to do_page_fault.
661 if (unlikely(access & ~pte_val(*ptep)))
664 * At this point, we have a pte (old_pte) which can be used to build
665 * or update an HPTE. There are 2 cases:
667 * 1. There is a valid (present) pte with no associated HPTE (this is
668 * the most common case)
669 * 2. There is a valid (present) pte with an associated HPTE. The
670 * current values of the pp bits in the HPTE prevent access
671 * because we are doing software DIRTY bit management and the
672 * page is currently not DIRTY.
677 old_pte = pte_val(*ptep);
678 if (old_pte & _PAGE_BUSY)
680 new_pte = old_pte | _PAGE_BUSY |
681 _PAGE_ACCESSED | _PAGE_HASHPTE;
682 } while(old_pte != __cmpxchg_u64((unsigned long *)ptep,
685 rflags = 0x2 | (!(new_pte & _PAGE_RW));
686 /* _PAGE_EXEC -> HW_NO_EXEC since it's inverted */
687 rflags |= ((new_pte & _PAGE_EXEC) ? 0 : HPTE_R_N);
689 /* Check if pte already has an hpte (case 2) */
690 if (unlikely(old_pte & _PAGE_HASHPTE)) {
691 /* There MIGHT be an HPTE for this pte */
692 unsigned long hash, slot;
694 hash = hpt_hash(va, HPAGE_SHIFT);
695 if (old_pte & _PAGE_F_SECOND)
697 slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
698 slot += (old_pte & _PAGE_F_GIX) >> 12;
700 if (ppc_md.hpte_updatepp(slot, rflags, va, 1, local) == -1)
701 old_pte &= ~_PAGE_HPTEFLAGS;
704 if (likely(!(old_pte & _PAGE_HASHPTE))) {
705 unsigned long hash = hpt_hash(va, HPAGE_SHIFT);
706 unsigned long hpte_group;
708 pa = pte_pfn(__pte(old_pte)) << PAGE_SHIFT;
711 hpte_group = ((hash & htab_hash_mask) *
712 HPTES_PER_GROUP) & ~0x7UL;
714 /* clear HPTE slot informations in new PTE */
715 new_pte = (new_pte & ~_PAGE_HPTEFLAGS) | _PAGE_HASHPTE;
717 /* Add in WIMG bits */
718 /* XXX We should store these in the pte */
719 /* --BenH: I think they are ... */
720 rflags |= _PAGE_COHERENT;
722 /* Insert into the hash table, primary slot */
723 slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags, 0,
726 /* Primary is full, try the secondary */
727 if (unlikely(slot == -1)) {
728 new_pte |= _PAGE_F_SECOND;
729 hpte_group = ((~hash & htab_hash_mask) *
730 HPTES_PER_GROUP) & ~0x7UL;
731 slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags,
736 hpte_group = ((hash & htab_hash_mask) *
737 HPTES_PER_GROUP)&~0x7UL;
739 ppc_md.hpte_remove(hpte_group);
744 if (unlikely(slot == -2))
745 panic("hash_huge_page: pte_insert failed\n");
747 new_pte |= (slot << 12) & _PAGE_F_GIX;
751 * No need to use ldarx/stdcx here because all who
752 * might be updating the pte will hold the
755 *ptep = __pte(new_pte & ~_PAGE_BUSY);