hugetlbpage.c 16.1 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 HPAGE_SHIFT_64K	16
#define HPAGE_SHIFT_16M	24

30 31
#define NUM_LOW_AREAS	(0x100000000UL >> SID_SHIFT)
#define NUM_HIGH_AREAS	(PGTABLE_RANGE >> HTLB_AREA_SHIFT)
32 33 34 35 36 37
#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;
38

39 40 41
unsigned int hugepte_shift;
#define PTRS_PER_HUGEPTE	(1 << hugepte_shift)
#define HUGEPTE_TABLE_SIZE	(sizeof(pte_t) << hugepte_shift)
42

43
#define HUGEPD_SHIFT		(HPAGE_SHIFT + hugepte_shift)
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
#define HUGEPD_SIZE		(1UL << HUGEPD_SHIFT)
#define HUGEPD_MASK		(~(HUGEPD_SIZE-1))

#define huge_pgtable_cache	(pgtable_cache[HUGEPTE_CACHE_NUM])

/* 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)

static inline pte_t *hugepd_page(hugepd_t hpd)
{
	BUG_ON(!(hpd.pd & HUGEPD_OK));
	return (pte_t *)(hpd.pd & ~HUGEPD_OK);
}

static inline pte_t *hugepte_offset(hugepd_t *hpdp, unsigned long addr)
{
	unsigned long idx = ((addr >> HPAGE_SHIFT) & (PTRS_PER_HUGEPTE-1));
	pte_t *dir = hugepd_page(*hpdp);

	return dir + idx;
}

static int __hugepte_alloc(struct mm_struct *mm, hugepd_t *hpdp,
			   unsigned long address)
{
	pte_t *new = kmem_cache_alloc(huge_pgtable_cache,
				      GFP_KERNEL|__GFP_REPEAT);

	if (! new)
		return -ENOMEM;

	spin_lock(&mm->page_table_lock);
	if (!hugepd_none(*hpdp))
		kmem_cache_free(huge_pgtable_cache, new);
	else
		hpdp->pd = (unsigned long)new | HUGEPD_OK;
	spin_unlock(&mm->page_table_lock);
	return 0;
}

90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
/* Base page size affects how we walk hugetlb page tables */
#ifdef CONFIG_PPC_64K_PAGES
#define hpmd_offset(pud, addr)		pmd_offset(pud, addr)
#define hpmd_alloc(mm, pud, addr)	pmd_alloc(mm, pud, addr)
#else
static inline
pmd_t *hpmd_offset(pud_t *pud, unsigned long addr)
{
	if (HPAGE_SHIFT == HPAGE_SHIFT_64K)
		return pmd_offset(pud, addr);
	else
		return (pmd_t *) pud;
}
static inline
pmd_t *hpmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long addr)
{
	if (HPAGE_SHIFT == HPAGE_SHIFT_64K)
		return pmd_alloc(mm, pud, addr);
	else
		return (pmd_t *) pud;
}
#endif

113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
/* 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;
	}
}

129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
/* Moves the gigantic page addresses from the temporary list to the
 * huge_boot_pages list.  */
int alloc_bootmem_huge_page(struct hstate *h)
{
	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);
	m->hstate = h;
	return 1;
}


144 145
/* Modelled after find_linux_pte() */
pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
L
Linus Torvalds 已提交
146
{
147 148
	pgd_t *pg;
	pud_t *pu;
149
	pmd_t *pm;
L
Linus Torvalds 已提交
150

151
	BUG_ON(get_slice_psize(mm, addr) != mmu_huge_psize);
L
Linus Torvalds 已提交
152

153 154 155 156 157 158
	addr &= HPAGE_MASK;

	pg = pgd_offset(mm, addr);
	if (!pgd_none(*pg)) {
		pu = pud_offset(pg, addr);
		if (!pud_none(*pu)) {
159
			pm = hpmd_offset(pu, addr);
160 161
			if (!pmd_none(*pm))
				return hugepte_offset((hugepd_t *)pm, addr);
162 163
		}
	}
L
Linus Torvalds 已提交
164

165
	return NULL;
L
Linus Torvalds 已提交
166 167
}

168 169
pte_t *huge_pte_alloc(struct mm_struct *mm,
			unsigned long addr, unsigned long sz)
L
Linus Torvalds 已提交
170
{
171 172
	pgd_t *pg;
	pud_t *pu;
173
	pmd_t *pm;
174
	hugepd_t *hpdp = NULL;
L
Linus Torvalds 已提交
175

176
	BUG_ON(get_slice_psize(mm, addr) != mmu_huge_psize);
L
Linus Torvalds 已提交
177

178
	addr &= HPAGE_MASK;
L
Linus Torvalds 已提交
179

180 181
	pg = pgd_offset(mm, addr);
	pu = pud_alloc(mm, pg, addr);
L
Linus Torvalds 已提交
182

183
	if (pu) {
184
		pm = hpmd_alloc(mm, pu, addr);
185 186 187 188 189 190 191 192 193 194 195 196 197
		if (pm)
			hpdp = (hugepd_t *)pm;
	}

	if (! hpdp)
		return NULL;

	if (hugepd_none(*hpdp) && __hugepte_alloc(mm, hpdp, addr))
		return NULL;

	return hugepte_offset(hpdp, addr);
}

198 199 200 201 202
int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep)
{
	return 0;
}

203 204 205 206 207 208 209
static void free_hugepte_range(struct mmu_gather *tlb, hugepd_t *hpdp)
{
	pte_t *hugepte = hugepd_page(*hpdp);

	hpdp->pd = 0;
	tlb->need_flush = 1;
	pgtable_free_tlb(tlb, pgtable_free_cache(hugepte, HUGEPTE_CACHE_NUM,
A
Adam Litke 已提交
210
						 PGF_CACHENUM_MASK));
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
}

static void hugetlb_free_pmd_range(struct mmu_gather *tlb, pud_t *pud,
				   unsigned long addr, unsigned long end,
				   unsigned long floor, unsigned long ceiling)
{
	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;
		free_hugepte_range(tlb, (hugepd_t *)pmd);
	} while (pmd++, addr = next, addr != end);

	start &= PUD_MASK;
	if (start < floor)
		return;
	if (ceiling) {
		ceiling &= PUD_MASK;
		if (!ceiling)
			return;
L
Linus Torvalds 已提交
237
	}
238 239
	if (end - 1 > ceiling - 1)
		return;
L
Linus Torvalds 已提交
240

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
	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;

	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;
		hugetlb_free_pmd_range(tlb, pud, addr, next, floor, ceiling);
#else
263 264 265 266 267 268 269 270 271
		if (HPAGE_SHIFT == HPAGE_SHIFT_64K) {
			if (pud_none_or_clear_bad(pud))
				continue;
			hugetlb_free_pmd_range(tlb, pud, addr, next, floor, ceiling);
		} else {
			if (pud_none(*pud))
				continue;
			free_hugepte_range(tlb, (hugepd_t *)pud);
		}
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
#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.
 */
296
void hugetlb_free_pgd_range(struct mmu_gather *tlb,
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
			    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.
	 */

	addr &= HUGEPD_MASK;
	if (addr < floor) {
		addr += HUGEPD_SIZE;
		if (!addr)
			return;
	}
	if (ceiling) {
		ceiling &= HUGEPD_MASK;
		if (!ceiling)
			return;
	}
	if (end - 1 > ceiling - 1)
		end -= HUGEPD_SIZE;
	if (addr > end - 1)
		return;

	start = addr;
356
	pgd = pgd_offset(tlb->mm, addr);
357
	do {
358
		BUG_ON(get_slice_psize(tlb->mm, addr) != mmu_huge_psize);
359 360 361
		next = pgd_addr_end(addr, end);
		if (pgd_none_or_clear_bad(pgd))
			continue;
362
		hugetlb_free_pud_range(tlb, pgd, addr, next, floor, ceiling);
363
	} while (pgd++, addr = next, addr != end);
L
Linus Torvalds 已提交
364 365
}

366 367 368 369
void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
		     pte_t *ptep, pte_t pte)
{
	if (pte_present(*ptep)) {
370
		/* We open-code pte_clear because we need to pass the right
371 372 373
		 * 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
374
		 */
375
		pte_update(mm, addr & HPAGE_MASK, ptep, ~0UL, 1);
376
	}
377
	*ptep = __pte(pte_val(pte) & ~_PAGE_HPTEFLAGS);
L
Linus Torvalds 已提交
378 379
}

380 381
pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
			      pte_t *ptep)
L
Linus Torvalds 已提交
382
{
383
	unsigned long old = pte_update(mm, addr, ptep, ~0UL, 1);
384
	return __pte(old);
L
Linus Torvalds 已提交
385 386 387 388 389 390 391 392
}

struct page *
follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
{
	pte_t *ptep;
	struct page *page;

393
	if (get_slice_psize(mm, address) != mmu_huge_psize)
L
Linus Torvalds 已提交
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
		return ERR_PTR(-EINVAL);

	ptep = huge_pte_offset(mm, address);
	page = pte_page(*ptep);
	if (page)
		page += (address % HPAGE_SIZE) / PAGE_SIZE;

	return page;
}

int pmd_huge(pmd_t pmd)
{
	return 0;
}

A
Andi Kleen 已提交
409 410 411 412 413
int pud_huge(pud_t pud)
{
	return 0;
}

L
Linus Torvalds 已提交
414 415 416 417 418 419 420 421 422 423 424 425 426
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)
{
427 428
	return slice_get_unmapped_area(addr, len, flags,
				       mmu_huge_psize, 1, 0);
L
Linus Torvalds 已提交
429 430
}

431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
/*
 * Called by asm hashtable.S for doing lazy icache flush
 */
static unsigned int hash_huge_page_do_lazy_icache(unsigned long rflags,
						  pte_t pte, int trap)
{
	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) {
			for (i = 0; i < (HPAGE_SIZE / PAGE_SIZE); i++)
				__flush_dcache_icache(page_address(page+i));
			set_bit(PG_arch_1, &page->flags);
		} else {
			rflags |= HPTE_R_N;
		}
	}
	return rflags;
}

L
Linus Torvalds 已提交
458
int hash_huge_page(struct mm_struct *mm, unsigned long access,
459 460
		   unsigned long ea, unsigned long vsid, int local,
		   unsigned long trap)
L
Linus Torvalds 已提交
461 462
{
	pte_t *ptep;
463 464
	unsigned long old_pte, new_pte;
	unsigned long va, rflags, pa;
L
Linus Torvalds 已提交
465 466
	long slot;
	int err = 1;
P
Paul Mackerras 已提交
467
	int ssize = user_segment_size(ea);
L
Linus Torvalds 已提交
468 469 470 471

	ptep = huge_pte_offset(mm, ea);

	/* Search the Linux page table for a match with va */
P
Paul Mackerras 已提交
472
	va = hpt_va(ea, vsid, ssize);
L
Linus Torvalds 已提交
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499

	/*
	 * 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. 
	 */


500 501 502 503
	do {
		old_pte = pte_val(*ptep);
		if (old_pte & _PAGE_BUSY)
			goto out;
504
		new_pte = old_pte | _PAGE_BUSY | _PAGE_ACCESSED;
505 506 507 508
	} while(old_pte != __cmpxchg_u64((unsigned long *)ptep,
					 old_pte, new_pte));

	rflags = 0x2 | (!(new_pte & _PAGE_RW));
L
Linus Torvalds 已提交
509
 	/* _PAGE_EXEC -> HW_NO_EXEC since it's inverted */
510
	rflags |= ((new_pte & _PAGE_EXEC) ? 0 : HPTE_R_N);
511 512 513 514 515
	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),
						       trap);
L
Linus Torvalds 已提交
516 517

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

P
Paul Mackerras 已提交
522
		hash = hpt_hash(va, HPAGE_SHIFT, ssize);
523
		if (old_pte & _PAGE_F_SECOND)
L
Linus Torvalds 已提交
524 525
			hash = ~hash;
		slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
526
		slot += (old_pte & _PAGE_F_GIX) >> 12;
L
Linus Torvalds 已提交
527

528
		if (ppc_md.hpte_updatepp(slot, rflags, va, mmu_huge_psize,
P
Paul Mackerras 已提交
529
					 ssize, local) == -1)
530
			old_pte &= ~_PAGE_HPTEFLAGS;
L
Linus Torvalds 已提交
531 532
	}

533
	if (likely(!(old_pte & _PAGE_HASHPTE))) {
P
Paul Mackerras 已提交
534
		unsigned long hash = hpt_hash(va, HPAGE_SHIFT, ssize);
L
Linus Torvalds 已提交
535 536
		unsigned long hpte_group;

537
		pa = pte_pfn(__pte(old_pte)) << PAGE_SHIFT;
L
Linus Torvalds 已提交
538 539 540 541 542

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

543
		/* clear HPTE slot informations in new PTE */
544 545 546
#ifdef CONFIG_PPC_64K_PAGES
		new_pte = (new_pte & ~_PAGE_HPTEFLAGS) | _PAGE_HPTE_SUB0;
#else
547
		new_pte = (new_pte & ~_PAGE_HPTEFLAGS) | _PAGE_HASHPTE;
548
#endif
L
Linus Torvalds 已提交
549
		/* Add in WIMG bits */
550 551
		rflags |= (new_pte & (_PAGE_WRITETHRU | _PAGE_NO_CACHE |
				      _PAGE_COHERENT | _PAGE_GUARDED));
L
Linus Torvalds 已提交
552

553 554
		/* Insert into the hash table, primary slot */
		slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags, 0,
P
Paul Mackerras 已提交
555
					  mmu_huge_psize, ssize);
L
Linus Torvalds 已提交
556 557 558 559 560

		/* Primary is full, try the secondary */
		if (unlikely(slot == -1)) {
			hpte_group = ((~hash & htab_hash_mask) *
				      HPTES_PER_GROUP) & ~0x7UL; 
561
			slot = ppc_md.hpte_insert(hpte_group, va, pa, rflags,
562
						  HPTE_V_SECONDARY,
P
Paul Mackerras 已提交
563
						  mmu_huge_psize, ssize);
L
Linus Torvalds 已提交
564 565
			if (slot == -1) {
				if (mftb() & 0x1)
566 567
					hpte_group = ((hash & htab_hash_mask) *
						      HPTES_PER_GROUP)&~0x7UL;
L
Linus Torvalds 已提交
568 569 570 571 572 573 574 575 576

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

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

I
Ishizaki Kou 已提交
577
		new_pte |= (slot << 12) & (_PAGE_F_SECOND | _PAGE_F_GIX);
L
Linus Torvalds 已提交
578 579
	}

580
	/*
H
Hugh Dickins 已提交
581
	 * No need to use ldarx/stdcx here
582 583 584
	 */
	*ptep = __pte(new_pte & ~_PAGE_BUSY);

L
Linus Torvalds 已提交
585 586 587 588 589
	err = 0;

 out:
	return err;
}
590

591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
void set_huge_psize(int psize)
{
	/* Check that it is a page size supported by the hardware and
	 * that it fits within pagetable limits. */
	if (mmu_psize_defs[psize].shift && mmu_psize_defs[psize].shift < SID_SHIFT &&
		(mmu_psize_defs[psize].shift > MIN_HUGEPTE_SHIFT ||
			mmu_psize_defs[psize].shift == HPAGE_SHIFT_64K)) {
		HPAGE_SHIFT = mmu_psize_defs[psize].shift;
		mmu_huge_psize = psize;
#ifdef CONFIG_PPC_64K_PAGES
		hugepte_shift = (PMD_SHIFT-HPAGE_SHIFT);
#else
		if (HPAGE_SHIFT == HPAGE_SHIFT_64K)
			hugepte_shift = (PMD_SHIFT-HPAGE_SHIFT);
		else
			hugepte_shift = (PUD_SHIFT-HPAGE_SHIFT);
#endif

	} else
		HPAGE_SHIFT = 0;
}

static int __init hugepage_setup_sz(char *str)
{
	unsigned long long size;
	int mmu_psize = -1;
	int shift;

	size = memparse(str, &str);

	shift = __ffs(size);
	switch (shift) {
#ifndef CONFIG_PPC_64K_PAGES
	case HPAGE_SHIFT_64K:
		mmu_psize = MMU_PAGE_64K;
		break;
#endif
	case HPAGE_SHIFT_16M:
		mmu_psize = MMU_PAGE_16M;
		break;
	}

	if (mmu_psize >=0 && mmu_psize_defs[mmu_psize].shift)
		set_huge_psize(mmu_psize);
	else
		printk(KERN_WARNING "Invalid huge page size specified(%llu)\n", size);

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

642
static void zero_ctor(struct kmem_cache *cache, void *addr)
643 644 645 646 647 648 649 650 651 652 653 654
{
	memset(addr, 0, kmem_cache_size(cache));
}

static int __init hugetlbpage_init(void)
{
	if (!cpu_has_feature(CPU_FTR_16M_PAGE))
		return -ENODEV;

	huge_pgtable_cache = kmem_cache_create("hugepte_cache",
					       HUGEPTE_TABLE_SIZE,
					       HUGEPTE_TABLE_SIZE,
655
					       0,
656
					       zero_ctor);
657 658 659 660 661 662 663
	if (! huge_pgtable_cache)
		panic("hugetlbpage_init(): could not create hugepte cache\n");

	return 0;
}

module_init(hugetlbpage_init);