hugetlbpage.c 19.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * PPC64 (POWER4) Huge TLB Page Support for Kernel.
 *
 * Copyright (C) 2003 David Gibson, IBM Corporation.
 *
 * Based on the IA-32 version:
 * Copyright (C) 2002, Rohit Seth <rohit.seth@intel.com>
 */

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/hugetlb.h>
#include <linux/pagemap.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/sysctl.h>
#include <asm/mman.h>
#include <asm/pgalloc.h>
#include <asm/tlb.h>
#include <asm/tlbflush.h>
#include <asm/mmu_context.h>
#include <asm/machdep.h>
#include <asm/cputable.h>
25
#include <asm/spu.h>
L
Linus Torvalds 已提交
26

27 28 29
#define PAGE_SHIFT_64K	16
#define PAGE_SHIFT_16M	24
#define PAGE_SHIFT_16G	34
30

31 32
#define NUM_LOW_AREAS	(0x100000000UL >> SID_SHIFT)
#define NUM_HIGH_AREAS	(PGTABLE_RANGE >> HTLB_AREA_SHIFT)
33 34 35 36 37 38
#define MAX_NUMBER_GPAGES	1024

/* Tracks the 16G pages after the device tree is scanned and before the
 * huge_boot_pages list is ready.  */
static unsigned long gpage_freearray[MAX_NUMBER_GPAGES];
static unsigned nr_gpages;
39

40 41 42 43 44 45 46 47 48 49 50 51 52
/* Array of valid huge page sizes - non-zero value(hugepte_shift) is
 * stored for the huge page sizes that are valid.
 */
unsigned int mmu_huge_psizes[MMU_PAGE_COUNT] = { }; /* initialize all to 0 */

#define hugepte_shift			mmu_huge_psizes
#define PTRS_PER_HUGEPTE(psize)		(1 << hugepte_shift[psize])
#define HUGEPTE_TABLE_SIZE(psize)	(sizeof(pte_t) << hugepte_shift[psize])

#define HUGEPD_SHIFT(psize)		(mmu_psize_to_shift(psize) \
						+ hugepte_shift[psize])
#define HUGEPD_SIZE(psize)		(1UL << HUGEPD_SHIFT(psize))
#define HUGEPD_MASK(psize)		(~(HUGEPD_SIZE(psize)-1))
53

54 55 56 57 58
/* Subtract one from array size because we don't need a cache for 4K since
 * is not a huge page size */
#define huge_pgtable_cache(psize)	(pgtable_cache[HUGEPTE_CACHE_NUM \
							+ psize-1])
#define HUGEPTE_CACHE_NAME(psize)	(huge_pgtable_cache_name[psize])
59

60 61 62 63
static const char *huge_pgtable_cache_name[MMU_PAGE_COUNT] = {
	"unused_4K", "hugepte_cache_64K", "unused_64K_AP",
	"hugepte_cache_1M", "hugepte_cache_16M", "hugepte_cache_16G"
};
64 65 66 67 68 69 70 71 72 73

/* Flag to mark huge PD pointers.  This means pmd_bad() and pud_bad()
 * will choke on pointers to hugepte tables, which is handy for
 * catching screwups early. */
#define HUGEPD_OK	0x1

typedef struct { unsigned long pd; } hugepd_t;

#define hugepd_none(hpd)	((hpd).pd == 0)

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
static inline int shift_to_mmu_psize(unsigned int shift)
{
	switch (shift) {
#ifndef CONFIG_PPC_64K_PAGES
	case PAGE_SHIFT_64K:
	    return MMU_PAGE_64K;
#endif
	case PAGE_SHIFT_16M:
	    return MMU_PAGE_16M;
	case PAGE_SHIFT_16G:
	    return MMU_PAGE_16G;
	}
	return -1;
}

static inline unsigned int mmu_psize_to_shift(unsigned int mmu_psize)
{
	if (mmu_psize_defs[mmu_psize].shift)
		return mmu_psize_defs[mmu_psize].shift;
	BUG();
}

96 97 98 99 100 101
static inline pte_t *hugepd_page(hugepd_t hpd)
{
	BUG_ON(!(hpd.pd & HUGEPD_OK));
	return (pte_t *)(hpd.pd & ~HUGEPD_OK);
}

102 103
static inline pte_t *hugepte_offset(hugepd_t *hpdp, unsigned long addr,
				    struct hstate *hstate)
104
{
105 106 107
	unsigned int shift = huge_page_shift(hstate);
	int psize = shift_to_mmu_psize(shift);
	unsigned long idx = ((addr >> shift) & (PTRS_PER_HUGEPTE(psize)-1));
108 109 110 111 112 113
	pte_t *dir = hugepd_page(*hpdp);

	return dir + idx;
}

static int __hugepte_alloc(struct mm_struct *mm, hugepd_t *hpdp,
114
			   unsigned long address, unsigned int psize)
115
{
116
	pte_t *new = kmem_cache_zalloc(huge_pgtable_cache(psize),
117 118 119 120 121 122 123
				      GFP_KERNEL|__GFP_REPEAT);

	if (! new)
		return -ENOMEM;

	spin_lock(&mm->page_table_lock);
	if (!hugepd_none(*hpdp))
124
		kmem_cache_free(huge_pgtable_cache(psize), new);
125 126 127 128 129 130
	else
		hpdp->pd = (unsigned long)new | HUGEPD_OK;
	spin_unlock(&mm->page_table_lock);
	return 0;
}

131 132
/* Base page size affects how we walk hugetlb page tables */
#ifdef CONFIG_PPC_64K_PAGES
133 134
#define hpmd_offset(pud, addr, h)	pmd_offset(pud, addr)
#define hpmd_alloc(mm, pud, addr, h)	pmd_alloc(mm, pud, addr)
135 136
#else
static inline
137
pmd_t *hpmd_offset(pud_t *pud, unsigned long addr, struct hstate *hstate)
138
{
139
	if (huge_page_shift(hstate) == PAGE_SHIFT_64K)
140 141 142 143 144
		return pmd_offset(pud, addr);
	else
		return (pmd_t *) pud;
}
static inline
145 146
pmd_t *hpmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long addr,
		  struct hstate *hstate)
147
{
148
	if (huge_page_shift(hstate) == PAGE_SHIFT_64K)
149 150 151 152 153 154
		return pmd_alloc(mm, pud, addr);
	else
		return (pmd_t *) pud;
}
#endif

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
/* Build list of addresses of gigantic pages.  This function is used in early
 * boot before the buddy or bootmem allocator is setup.
 */
void add_gpage(unsigned long addr, unsigned long page_size,
	unsigned long number_of_pages)
{
	if (!addr)
		return;
	while (number_of_pages > 0) {
		gpage_freearray[nr_gpages] = addr;
		nr_gpages++;
		number_of_pages--;
		addr += page_size;
	}
}

171
/* Moves the gigantic page addresses from the temporary list to the
172 173 174
 * huge_boot_pages list.
 */
int alloc_bootmem_huge_page(struct hstate *hstate)
175 176 177 178 179 180 181
{
	struct huge_bootmem_page *m;
	if (nr_gpages == 0)
		return 0;
	m = phys_to_virt(gpage_freearray[--nr_gpages]);
	gpage_freearray[nr_gpages] = 0;
	list_add(&m->list, &huge_boot_pages);
182
	m->hstate = hstate;
183 184 185 186
	return 1;
}


187 188
/* Modelled after find_linux_pte() */
pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
L
Linus Torvalds 已提交
189
{
190 191
	pgd_t *pg;
	pud_t *pu;
192
	pmd_t *pm;
L
Linus Torvalds 已提交
193

194 195 196 197 198 199 200 201
	unsigned int psize;
	unsigned int shift;
	unsigned long sz;
	struct hstate *hstate;
	psize = get_slice_psize(mm, addr);
	shift = mmu_psize_to_shift(psize);
	sz = ((1UL) << shift);
	hstate = size_to_hstate(sz);
L
Linus Torvalds 已提交
202

203
	addr &= hstate->mask;
204 205 206 207 208

	pg = pgd_offset(mm, addr);
	if (!pgd_none(*pg)) {
		pu = pud_offset(pg, addr);
		if (!pud_none(*pu)) {
209
			pm = hpmd_offset(pu, addr, hstate);
210
			if (!pmd_none(*pm))
211 212
				return hugepte_offset((hugepd_t *)pm, addr,
						      hstate);
213 214
		}
	}
L
Linus Torvalds 已提交
215

216
	return NULL;
L
Linus Torvalds 已提交
217 218
}

219 220
pte_t *huge_pte_alloc(struct mm_struct *mm,
			unsigned long addr, unsigned long sz)
L
Linus Torvalds 已提交
221
{
222 223
	pgd_t *pg;
	pud_t *pu;
224
	pmd_t *pm;
225
	hugepd_t *hpdp = NULL;
226 227 228
	struct hstate *hstate;
	unsigned int psize;
	hstate = size_to_hstate(sz);
L
Linus Torvalds 已提交
229

230 231
	psize = get_slice_psize(mm, addr);
	BUG_ON(!mmu_huge_psizes[psize]);
L
Linus Torvalds 已提交
232

233
	addr &= hstate->mask;
L
Linus Torvalds 已提交
234

235 236
	pg = pgd_offset(mm, addr);
	pu = pud_alloc(mm, pg, addr);
L
Linus Torvalds 已提交
237

238
	if (pu) {
239
		pm = hpmd_alloc(mm, pu, addr, hstate);
240 241 242 243 244 245 246
		if (pm)
			hpdp = (hugepd_t *)pm;
	}

	if (! hpdp)
		return NULL;

247
	if (hugepd_none(*hpdp) && __hugepte_alloc(mm, hpdp, addr, psize))
248 249
		return NULL;

250
	return hugepte_offset(hpdp, addr, hstate);
251 252
}

253 254 255 256 257
int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep)
{
	return 0;
}

258 259
static void free_hugepte_range(struct mmu_gather *tlb, hugepd_t *hpdp,
			       unsigned int psize)
260 261 262 263 264
{
	pte_t *hugepte = hugepd_page(*hpdp);

	hpdp->pd = 0;
	tlb->need_flush = 1;
265 266
	pgtable_free_tlb(tlb, pgtable_free_cache(hugepte,
						 HUGEPTE_CACHE_NUM+psize-1,
A
Adam Litke 已提交
267
						 PGF_CACHENUM_MASK));
268 269 270 271
}

static void hugetlb_free_pmd_range(struct mmu_gather *tlb, pud_t *pud,
				   unsigned long addr, unsigned long end,
272 273
				   unsigned long floor, unsigned long ceiling,
				   unsigned int psize)
274 275 276 277 278 279 280 281 282 283 284
{
	pmd_t *pmd;
	unsigned long next;
	unsigned long start;

	start = addr;
	pmd = pmd_offset(pud, addr);
	do {
		next = pmd_addr_end(addr, end);
		if (pmd_none(*pmd))
			continue;
285
		free_hugepte_range(tlb, (hugepd_t *)pmd, psize);
286 287 288 289 290 291 292 293 294
	} while (pmd++, addr = next, addr != end);

	start &= PUD_MASK;
	if (start < floor)
		return;
	if (ceiling) {
		ceiling &= PUD_MASK;
		if (!ceiling)
			return;
L
Linus Torvalds 已提交
295
	}
296 297
	if (end - 1 > ceiling - 1)
		return;
L
Linus Torvalds 已提交
298

299 300 301 302 303 304 305 306 307 308 309 310
	pmd = pmd_offset(pud, start);
	pud_clear(pud);
	pmd_free_tlb(tlb, pmd);
}

static void hugetlb_free_pud_range(struct mmu_gather *tlb, pgd_t *pgd,
				   unsigned long addr, unsigned long end,
				   unsigned long floor, unsigned long ceiling)
{
	pud_t *pud;
	unsigned long next;
	unsigned long start;
311 312 313
	unsigned int shift;
	unsigned int psize = get_slice_psize(tlb->mm, addr);
	shift = mmu_psize_to_shift(psize);
314 315 316 317 318 319 320 321

	start = addr;
	pud = pud_offset(pgd, addr);
	do {
		next = pud_addr_end(addr, end);
#ifdef CONFIG_PPC_64K_PAGES
		if (pud_none_or_clear_bad(pud))
			continue;
322 323
		hugetlb_free_pmd_range(tlb, pud, addr, next, floor, ceiling,
				       psize);
324
#else
325
		if (shift == PAGE_SHIFT_64K) {
326 327
			if (pud_none_or_clear_bad(pud))
				continue;
328 329
			hugetlb_free_pmd_range(tlb, pud, addr, next, floor,
					       ceiling, psize);
330 331 332
		} else {
			if (pud_none(*pud))
				continue;
333
			free_hugepte_range(tlb, (hugepd_t *)pud, psize);
334
		}
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
#endif
	} while (pud++, addr = next, addr != end);

	start &= PGDIR_MASK;
	if (start < floor)
		return;
	if (ceiling) {
		ceiling &= PGDIR_MASK;
		if (!ceiling)
			return;
	}
	if (end - 1 > ceiling - 1)
		return;

	pud = pud_offset(pgd, start);
	pgd_clear(pgd);
	pud_free_tlb(tlb, pud);
}

/*
 * This function frees user-level page tables of a process.
 *
 * Must be called with pagetable lock held.
 */
359
void hugetlb_free_pgd_range(struct mmu_gather *tlb,
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
			    unsigned long addr, unsigned long end,
			    unsigned long floor, unsigned long ceiling)
{
	pgd_t *pgd;
	unsigned long next;
	unsigned long start;

	/*
	 * Comments below take from the normal free_pgd_range().  They
	 * apply here too.  The tests against HUGEPD_MASK below are
	 * essential, because we *don't* test for this at the bottom
	 * level.  Without them we'll attempt to free a hugepte table
	 * when we unmap just part of it, even if there are other
	 * active mappings using it.
	 *
	 * The next few lines have given us lots of grief...
	 *
	 * Why are we testing HUGEPD* at this top level?  Because
	 * often there will be no work to do at all, and we'd prefer
	 * not to go all the way down to the bottom just to discover
	 * that.
	 *
	 * Why all these "- 1"s?  Because 0 represents both the bottom
	 * of the address space and the top of it (using -1 for the
	 * top wouldn't help much: the masks would do the wrong thing).
	 * The rule is that addr 0 and floor 0 refer to the bottom of
	 * the address space, but end 0 and ceiling 0 refer to the top
	 * Comparisons need to use "end - 1" and "ceiling - 1" (though
	 * that end 0 case should be mythical).
	 *
	 * Wherever addr is brought up or ceiling brought down, we
	 * must be careful to reject "the opposite 0" before it
	 * confuses the subsequent tests.  But what about where end is
	 * brought down by HUGEPD_SIZE below? no, end can't go down to
	 * 0 there.
	 *
	 * Whereas we round start (addr) and ceiling down, by different
	 * masks at different levels, in order to test whether a table
	 * now has no other vmas using it, so can be freed, we don't
	 * bother to round floor or end up - the tests don't need that.
	 */
401
	unsigned int psize = get_slice_psize(tlb->mm, addr);
402

403
	addr &= HUGEPD_MASK(psize);
404
	if (addr < floor) {
405
		addr += HUGEPD_SIZE(psize);
406 407 408 409
		if (!addr)
			return;
	}
	if (ceiling) {
410
		ceiling &= HUGEPD_MASK(psize);
411 412 413 414
		if (!ceiling)
			return;
	}
	if (end - 1 > ceiling - 1)
415
		end -= HUGEPD_SIZE(psize);
416 417 418 419
	if (addr > end - 1)
		return;

	start = addr;
420
	pgd = pgd_offset(tlb->mm, addr);
421
	do {
422 423
		psize = get_slice_psize(tlb->mm, addr);
		BUG_ON(!mmu_huge_psizes[psize]);
424 425 426
		next = pgd_addr_end(addr, end);
		if (pgd_none_or_clear_bad(pgd))
			continue;
427
		hugetlb_free_pud_range(tlb, pgd, addr, next, floor, ceiling);
428
	} while (pgd++, addr = next, addr != end);
L
Linus Torvalds 已提交
429 430
}

431 432 433 434
void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
		     pte_t *ptep, pte_t pte)
{
	if (pte_present(*ptep)) {
435
		/* We open-code pte_clear because we need to pass the right
436 437 438
		 * argument to hpte_need_flush (huge / !huge). Might not be
		 * necessary anymore if we make hpte_need_flush() get the
		 * page size from the slices
439
		 */
440 441 442 443 444
		unsigned int psize = get_slice_psize(mm, addr);
		unsigned int shift = mmu_psize_to_shift(psize);
		unsigned long sz = ((1UL) << shift);
		struct hstate *hstate = size_to_hstate(sz);
		pte_update(mm, addr & hstate->mask, ptep, ~0UL, 1);
445
	}
446
	*ptep = __pte(pte_val(pte) & ~_PAGE_HPTEFLAGS);
L
Linus Torvalds 已提交
447 448
}

449 450
pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
			      pte_t *ptep)
L
Linus Torvalds 已提交
451
{
452
	unsigned long old = pte_update(mm, addr, ptep, ~0UL, 1);
453
	return __pte(old);
L
Linus Torvalds 已提交
454 455 456 457 458 459 460
}

struct page *
follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
{
	pte_t *ptep;
	struct page *page;
461
	unsigned int mmu_psize = get_slice_psize(mm, address);
L
Linus Torvalds 已提交
462

463 464
	/* Verify it is a huge page else bail. */
	if (!mmu_huge_psizes[mmu_psize])
L
Linus Torvalds 已提交
465 466 467 468
		return ERR_PTR(-EINVAL);

	ptep = huge_pte_offset(mm, address);
	page = pte_page(*ptep);
469 470 471 472 473
	if (page) {
		unsigned int shift = mmu_psize_to_shift(mmu_psize);
		unsigned long sz = ((1UL) << shift);
		page += (address % sz) / PAGE_SIZE;
	}
L
Linus Torvalds 已提交
474 475 476 477 478 479 480 481 482

	return page;
}

int pmd_huge(pmd_t pmd)
{
	return 0;
}

A
Andi Kleen 已提交
483 484 485 486 487
int pud_huge(pud_t pud)
{
	return 0;
}

L
Linus Torvalds 已提交
488 489 490 491 492 493 494 495 496 497 498 499 500
struct page *
follow_huge_pmd(struct mm_struct *mm, unsigned long address,
		pmd_t *pmd, int write)
{
	BUG();
	return NULL;
}


unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
					unsigned long len, unsigned long pgoff,
					unsigned long flags)
{
501 502 503
	struct hstate *hstate = hstate_file(file);
	int mmu_psize = shift_to_mmu_psize(huge_page_shift(hstate));
	return slice_get_unmapped_area(addr, len, flags, mmu_psize, 1, 0);
L
Linus Torvalds 已提交
504 505
}

506 507 508 509
/*
 * Called by asm hashtable.S for doing lazy icache flush
 */
static unsigned int hash_huge_page_do_lazy_icache(unsigned long rflags,
510
					pte_t pte, int trap, unsigned long sz)
511 512 513 514 515 516 517 518 519 520 521 522
{
	struct page *page;
	int i;

	if (!pfn_valid(pte_pfn(pte)))
		return rflags;

	page = pte_page(pte);

	/* page is dirty */
	if (!test_bit(PG_arch_1, &page->flags) && !PageReserved(page)) {
		if (trap == 0x400) {
523
			for (i = 0; i < (sz / PAGE_SIZE); i++)
524 525 526 527 528 529 530 531 532
				__flush_dcache_icache(page_address(page+i));
			set_bit(PG_arch_1, &page->flags);
		} else {
			rflags |= HPTE_R_N;
		}
	}
	return rflags;
}

L
Linus Torvalds 已提交
533
int hash_huge_page(struct mm_struct *mm, unsigned long access,
534 535
		   unsigned long ea, unsigned long vsid, int local,
		   unsigned long trap)
L
Linus Torvalds 已提交
536 537
{
	pte_t *ptep;
538
	unsigned long old_pte, new_pte;
539
	unsigned long va, rflags, pa, sz;
L
Linus Torvalds 已提交
540 541
	long slot;
	int err = 1;
P
Paul Mackerras 已提交
542
	int ssize = user_segment_size(ea);
543 544 545
	unsigned int mmu_psize;
	int shift;
	mmu_psize = get_slice_psize(mm, ea);
L
Linus Torvalds 已提交
546

547 548
	if (!mmu_huge_psizes[mmu_psize])
		goto out;
L
Linus Torvalds 已提交
549 550 551
	ptep = huge_pte_offset(mm, ea);

	/* Search the Linux page table for a match with va */
P
Paul Mackerras 已提交
552
	va = hpt_va(ea, vsid, ssize);
L
Linus Torvalds 已提交
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579

	/*
	 * If no pte found or not present, send the problem up to
	 * do_page_fault
	 */
	if (unlikely(!ptep || pte_none(*ptep)))
		goto out;

	/* 
	 * Check the user's access rights to the page.  If access should be
	 * prevented then send the problem up to do_page_fault.
	 */
	if (unlikely(access & ~pte_val(*ptep)))
		goto out;
	/*
	 * At this point, we have a pte (old_pte) which can be used to build
	 * or update an HPTE. There are 2 cases:
	 *
	 * 1. There is a valid (present) pte with no associated HPTE (this is 
	 *	the most common case)
	 * 2. There is a valid (present) pte with an associated HPTE. The
	 *	current values of the pp bits in the HPTE prevent access
	 *	because we are doing software DIRTY bit management and the
	 *	page is currently not DIRTY. 
	 */


580 581 582 583
	do {
		old_pte = pte_val(*ptep);
		if (old_pte & _PAGE_BUSY)
			goto out;
584
		new_pte = old_pte | _PAGE_BUSY | _PAGE_ACCESSED;
585 586 587 588
	} while(old_pte != __cmpxchg_u64((unsigned long *)ptep,
					 old_pte, new_pte));

	rflags = 0x2 | (!(new_pte & _PAGE_RW));
L
Linus Torvalds 已提交
589
 	/* _PAGE_EXEC -> HW_NO_EXEC since it's inverted */
590
	rflags |= ((new_pte & _PAGE_EXEC) ? 0 : HPTE_R_N);
591 592
	shift = mmu_psize_to_shift(mmu_psize);
	sz = ((1UL) << shift);
593 594 595 596
	if (!cpu_has_feature(CPU_FTR_COHERENT_ICACHE))
		/* No CPU has hugepages but lacks no execute, so we
		 * don't need to worry about that case */
		rflags = hash_huge_page_do_lazy_icache(rflags, __pte(old_pte),
597
						       trap, sz);
L
Linus Torvalds 已提交
598 599

	/* Check if pte already has an hpte (case 2) */
600
	if (unlikely(old_pte & _PAGE_HASHPTE)) {
L
Linus Torvalds 已提交
601 602 603
		/* There MIGHT be an HPTE for this pte */
		unsigned long hash, slot;

604
		hash = hpt_hash(va, shift, ssize);
605
		if (old_pte & _PAGE_F_SECOND)
L
Linus Torvalds 已提交
606 607
			hash = ~hash;
		slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
608
		slot += (old_pte & _PAGE_F_GIX) >> 12;
L
Linus Torvalds 已提交
609

610
		if (ppc_md.hpte_updatepp(slot, rflags, va, mmu_psize,
P
Paul Mackerras 已提交
611
					 ssize, local) == -1)
612
			old_pte &= ~_PAGE_HPTEFLAGS;
L
Linus Torvalds 已提交
613 614
	}

615
	if (likely(!(old_pte & _PAGE_HASHPTE))) {
616
		unsigned long hash = hpt_hash(va, shift, ssize);
L
Linus Torvalds 已提交
617 618
		unsigned long hpte_group;

619
		pa = pte_pfn(__pte(old_pte)) << PAGE_SHIFT;
L
Linus Torvalds 已提交
620 621 622 623 624

repeat:
		hpte_group = ((hash & htab_hash_mask) *
			      HPTES_PER_GROUP) & ~0x7UL;

625
		/* clear HPTE slot informations in new PTE */
626 627 628
#ifdef CONFIG_PPC_64K_PAGES
		new_pte = (new_pte & ~_PAGE_HPTEFLAGS) | _PAGE_HPTE_SUB0;
#else
629
		new_pte = (new_pte & ~_PAGE_HPTEFLAGS) | _PAGE_HASHPTE;
630
#endif
L
Linus Torvalds 已提交
631
		/* Add in WIMG bits */
632 633
		rflags |= (new_pte & (_PAGE_WRITETHRU | _PAGE_NO_CACHE |
				      _PAGE_COHERENT | _PAGE_GUARDED));
L
Linus Torvalds 已提交
634

635 636
		/* Insert into the hash table, primary slot */
		slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags, 0,
637
					  mmu_psize, ssize);
L
Linus Torvalds 已提交
638 639 640 641 642

		/* Primary is full, try the secondary */
		if (unlikely(slot == -1)) {
			hpte_group = ((~hash & htab_hash_mask) *
				      HPTES_PER_GROUP) & ~0x7UL; 
643
			slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags,
644
						  HPTE_V_SECONDARY,
645
						  mmu_psize, ssize);
L
Linus Torvalds 已提交
646 647
			if (slot == -1) {
				if (mftb() & 0x1)
648 649
					hpte_group = ((hash & htab_hash_mask) *
						      HPTES_PER_GROUP)&~0x7UL;
L
Linus Torvalds 已提交
650 651 652 653 654 655 656 657 658

				ppc_md.hpte_remove(hpte_group);
				goto repeat;
                        }
		}

		if (unlikely(slot == -2))
			panic("hash_huge_page: pte_insert failed\n");

I
Ishizaki Kou 已提交
659
		new_pte |= (slot << 12) & (_PAGE_F_SECOND | _PAGE_F_GIX);
L
Linus Torvalds 已提交
660 661
	}

662
	/*
H
Hugh Dickins 已提交
663
	 * No need to use ldarx/stdcx here
664 665 666
	 */
	*ptep = __pte(new_pte & ~_PAGE_BUSY);

L
Linus Torvalds 已提交
667 668 669 670 671
	err = 0;

 out:
	return err;
}
672

673 674 675 676
void set_huge_psize(int psize)
{
	/* Check that it is a page size supported by the hardware and
	 * that it fits within pagetable limits. */
677 678
	if (mmu_psize_defs[psize].shift &&
		mmu_psize_defs[psize].shift < SID_SHIFT_1T &&
679
		(mmu_psize_defs[psize].shift > MIN_HUGEPTE_SHIFT ||
680 681
		 mmu_psize_defs[psize].shift == PAGE_SHIFT_64K ||
		 mmu_psize_defs[psize].shift == PAGE_SHIFT_16G)) {
682 683 684 685
		/* Return if huge page size has already been setup or is the
		 * same as the base page size. */
		if (mmu_huge_psizes[psize] ||
		   mmu_psize_defs[psize].shift == PAGE_SHIFT)
686
			return;
687
		hugetlb_add_hstate(mmu_psize_defs[psize].shift - PAGE_SHIFT);
688

689
		switch (mmu_psize_defs[psize].shift) {
690 691 692 693
		case PAGE_SHIFT_64K:
		    /* We only allow 64k hpages with 4k base page,
		     * which was checked above, and always put them
		     * at the PMD */
694
		    hugepte_shift[psize] = PMD_SHIFT;
695 696 697 698 699
		    break;
		case PAGE_SHIFT_16M:
		    /* 16M pages can be at two different levels
		     * of pagestables based on base page size */
		    if (PAGE_SHIFT == PAGE_SHIFT_64K)
700
			    hugepte_shift[psize] = PMD_SHIFT;
701
		    else /* 4k base page */
702
			    hugepte_shift[psize] = PUD_SHIFT;
703 704 705
		    break;
		case PAGE_SHIFT_16G:
		    /* 16G pages are always at PGD level */
706
		    hugepte_shift[psize] = PGDIR_SHIFT;
707 708
		    break;
		}
709
		hugepte_shift[psize] -= mmu_psize_defs[psize].shift;
710
	} else
711
		hugepte_shift[psize] = 0;
712 713 714 715 716
}

static int __init hugepage_setup_sz(char *str)
{
	unsigned long long size;
717
	int mmu_psize;
718 719 720 721 722
	int shift;

	size = memparse(str, &str);

	shift = __ffs(size);
723 724
	mmu_psize = shift_to_mmu_psize(shift);
	if (mmu_psize >= 0 && mmu_psize_defs[mmu_psize].shift)
725 726 727 728 729 730 731 732
		set_huge_psize(mmu_psize);
	else
		printk(KERN_WARNING "Invalid huge page size specified(%llu)\n", size);

	return 1;
}
__setup("hugepagesz=", hugepage_setup_sz);

733 734
static int __init hugetlbpage_init(void)
{
735 736
	unsigned int psize;

737 738
	if (!cpu_has_feature(CPU_FTR_16M_PAGE))
		return -ENODEV;
739

740 741 742 743 744 745 746
	/* Add supported huge page sizes.  Need to change HUGE_MAX_HSTATE
	 * and adjust PTE_NONCACHE_NUM if the number of supported huge page
	 * sizes changes.
	 */
	set_huge_psize(MMU_PAGE_16M);
	set_huge_psize(MMU_PAGE_16G);

747 748 749 750 751 752 753
	/* Temporarily disable support for 64K huge pages when 64K SPU local
	 * store support is enabled as the current implementation conflicts.
	 */
#ifndef CONFIG_SPU_FS_64K_LS
	set_huge_psize(MMU_PAGE_64K);
#endif

754 755 756 757 758 759 760
	for (psize = 0; psize < MMU_PAGE_COUNT; ++psize) {
		if (mmu_huge_psizes[psize]) {
			huge_pgtable_cache(psize) = kmem_cache_create(
						HUGEPTE_CACHE_NAME(psize),
						HUGEPTE_TABLE_SIZE(psize),
						HUGEPTE_TABLE_SIZE(psize),
						0,
761
						NULL);
762 763 764 765 766
			if (!huge_pgtable_cache(psize))
				panic("hugetlbpage_init(): could not create %s"\
				      "\n", HUGEPTE_CACHE_NAME(psize));
		}
	}
767 768 769 770 771

	return 0;
}

module_init(hugetlbpage_init);