KVM: PPC: Implement MMU notifiers for Book3S HV guests
[linux-2.6.git] / arch / powerpc / mm / hugetlbpage.c
1 /*
2  * PPC Huge TLB Page Support for Kernel.
3  *
4  * Copyright (C) 2003 David Gibson, IBM Corporation.
5  * Copyright (C) 2011 Becky Bruce, Freescale Semiconductor
6  *
7  * Based on the IA-32 version:
8  * Copyright (C) 2002, Rohit Seth <rohit.seth@intel.com>
9  */
10
11 #include <linux/mm.h>
12 #include <linux/io.h>
13 #include <linux/slab.h>
14 #include <linux/hugetlb.h>
15 #include <linux/export.h>
16 #include <linux/of_fdt.h>
17 #include <linux/memblock.h>
18 #include <linux/bootmem.h>
19 #include <linux/moduleparam.h>
20 #include <asm/pgtable.h>
21 #include <asm/pgalloc.h>
22 #include <asm/tlb.h>
23 #include <asm/setup.h>
24
25 #define PAGE_SHIFT_64K  16
26 #define PAGE_SHIFT_16M  24
27 #define PAGE_SHIFT_16G  34
28
29 unsigned int HPAGE_SHIFT;
30
31 /*
32  * Tracks gpages after the device tree is scanned and before the
33  * huge_boot_pages list is ready.  On non-Freescale implementations, this is
34  * just used to track 16G pages and so is a single array.  FSL-based
35  * implementations may have more than one gpage size, so we need multiple
36  * arrays
37  */
38 #ifdef CONFIG_PPC_FSL_BOOK3E
39 #define MAX_NUMBER_GPAGES       128
40 struct psize_gpages {
41         u64 gpage_list[MAX_NUMBER_GPAGES];
42         unsigned int nr_gpages;
43 };
44 static struct psize_gpages gpage_freearray[MMU_PAGE_COUNT];
45 #else
46 #define MAX_NUMBER_GPAGES       1024
47 static u64 gpage_freearray[MAX_NUMBER_GPAGES];
48 static unsigned nr_gpages;
49 #endif
50
51 static inline int shift_to_mmu_psize(unsigned int shift)
52 {
53         int psize;
54
55         for (psize = 0; psize < MMU_PAGE_COUNT; ++psize)
56                 if (mmu_psize_defs[psize].shift == shift)
57                         return psize;
58         return -1;
59 }
60
61 static inline unsigned int mmu_psize_to_shift(unsigned int mmu_psize)
62 {
63         if (mmu_psize_defs[mmu_psize].shift)
64                 return mmu_psize_defs[mmu_psize].shift;
65         BUG();
66 }
67
68 #define hugepd_none(hpd)        ((hpd).pd == 0)
69
70 pte_t *find_linux_pte_or_hugepte(pgd_t *pgdir, unsigned long ea, unsigned *shift)
71 {
72         pgd_t *pg;
73         pud_t *pu;
74         pmd_t *pm;
75         hugepd_t *hpdp = NULL;
76         unsigned pdshift = PGDIR_SHIFT;
77
78         if (shift)
79                 *shift = 0;
80
81         pg = pgdir + pgd_index(ea);
82         if (is_hugepd(pg)) {
83                 hpdp = (hugepd_t *)pg;
84         } else if (!pgd_none(*pg)) {
85                 pdshift = PUD_SHIFT;
86                 pu = pud_offset(pg, ea);
87                 if (is_hugepd(pu))
88                         hpdp = (hugepd_t *)pu;
89                 else if (!pud_none(*pu)) {
90                         pdshift = PMD_SHIFT;
91                         pm = pmd_offset(pu, ea);
92                         if (is_hugepd(pm))
93                                 hpdp = (hugepd_t *)pm;
94                         else if (!pmd_none(*pm)) {
95                                 return pte_offset_kernel(pm, ea);
96                         }
97                 }
98         }
99
100         if (!hpdp)
101                 return NULL;
102
103         if (shift)
104                 *shift = hugepd_shift(*hpdp);
105         return hugepte_offset(hpdp, ea, pdshift);
106 }
107 EXPORT_SYMBOL_GPL(find_linux_pte_or_hugepte);
108
109 pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
110 {
111         return find_linux_pte_or_hugepte(mm->pgd, addr, NULL);
112 }
113
114 static int __hugepte_alloc(struct mm_struct *mm, hugepd_t *hpdp,
115                            unsigned long address, unsigned pdshift, unsigned pshift)
116 {
117         struct kmem_cache *cachep;
118         pte_t *new;
119
120 #ifdef CONFIG_PPC_FSL_BOOK3E
121         int i;
122         int num_hugepd = 1 << (pshift - pdshift);
123         cachep = hugepte_cache;
124 #else
125         cachep = PGT_CACHE(pdshift - pshift);
126 #endif
127
128         new = kmem_cache_zalloc(cachep, GFP_KERNEL|__GFP_REPEAT);
129
130         BUG_ON(pshift > HUGEPD_SHIFT_MASK);
131         BUG_ON((unsigned long)new & HUGEPD_SHIFT_MASK);
132
133         if (! new)
134                 return -ENOMEM;
135
136         spin_lock(&mm->page_table_lock);
137 #ifdef CONFIG_PPC_FSL_BOOK3E
138         /*
139          * We have multiple higher-level entries that point to the same
140          * actual pte location.  Fill in each as we go and backtrack on error.
141          * We need all of these so the DTLB pgtable walk code can find the
142          * right higher-level entry without knowing if it's a hugepage or not.
143          */
144         for (i = 0; i < num_hugepd; i++, hpdp++) {
145                 if (unlikely(!hugepd_none(*hpdp)))
146                         break;
147                 else
148                         hpdp->pd = ((unsigned long)new & ~PD_HUGE) | pshift;
149         }
150         /* If we bailed from the for loop early, an error occurred, clean up */
151         if (i < num_hugepd) {
152                 for (i = i - 1 ; i >= 0; i--, hpdp--)
153                         hpdp->pd = 0;
154                 kmem_cache_free(cachep, new);
155         }
156 #else
157         if (!hugepd_none(*hpdp))
158                 kmem_cache_free(cachep, new);
159         else
160                 hpdp->pd = ((unsigned long)new & ~PD_HUGE) | pshift;
161 #endif
162         spin_unlock(&mm->page_table_lock);
163         return 0;
164 }
165
166 /*
167  * These macros define how to determine which level of the page table holds
168  * the hpdp.
169  */
170 #ifdef CONFIG_PPC_FSL_BOOK3E
171 #define HUGEPD_PGD_SHIFT PGDIR_SHIFT
172 #define HUGEPD_PUD_SHIFT PUD_SHIFT
173 #else
174 #define HUGEPD_PGD_SHIFT PUD_SHIFT
175 #define HUGEPD_PUD_SHIFT PMD_SHIFT
176 #endif
177
178 pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr, unsigned long sz)
179 {
180         pgd_t *pg;
181         pud_t *pu;
182         pmd_t *pm;
183         hugepd_t *hpdp = NULL;
184         unsigned pshift = __ffs(sz);
185         unsigned pdshift = PGDIR_SHIFT;
186
187         addr &= ~(sz-1);
188
189         pg = pgd_offset(mm, addr);
190
191         if (pshift >= HUGEPD_PGD_SHIFT) {
192                 hpdp = (hugepd_t *)pg;
193         } else {
194                 pdshift = PUD_SHIFT;
195                 pu = pud_alloc(mm, pg, addr);
196                 if (pshift >= HUGEPD_PUD_SHIFT) {
197                         hpdp = (hugepd_t *)pu;
198                 } else {
199                         pdshift = PMD_SHIFT;
200                         pm = pmd_alloc(mm, pu, addr);
201                         hpdp = (hugepd_t *)pm;
202                 }
203         }
204
205         if (!hpdp)
206                 return NULL;
207
208         BUG_ON(!hugepd_none(*hpdp) && !hugepd_ok(*hpdp));
209
210         if (hugepd_none(*hpdp) && __hugepte_alloc(mm, hpdp, addr, pdshift, pshift))
211                 return NULL;
212
213         return hugepte_offset(hpdp, addr, pdshift);
214 }
215
216 #ifdef CONFIG_PPC_FSL_BOOK3E
217 /* Build list of addresses of gigantic pages.  This function is used in early
218  * boot before the buddy or bootmem allocator is setup.
219  */
220 void add_gpage(u64 addr, u64 page_size, unsigned long number_of_pages)
221 {
222         unsigned int idx = shift_to_mmu_psize(__ffs(page_size));
223         int i;
224
225         if (addr == 0)
226                 return;
227
228         gpage_freearray[idx].nr_gpages = number_of_pages;
229
230         for (i = 0; i < number_of_pages; i++) {
231                 gpage_freearray[idx].gpage_list[i] = addr;
232                 addr += page_size;
233         }
234 }
235
236 /*
237  * Moves the gigantic page addresses from the temporary list to the
238  * huge_boot_pages list.
239  */
240 int alloc_bootmem_huge_page(struct hstate *hstate)
241 {
242         struct huge_bootmem_page *m;
243         int idx = shift_to_mmu_psize(hstate->order + PAGE_SHIFT);
244         int nr_gpages = gpage_freearray[idx].nr_gpages;
245
246         if (nr_gpages == 0)
247                 return 0;
248
249 #ifdef CONFIG_HIGHMEM
250         /*
251          * If gpages can be in highmem we can't use the trick of storing the
252          * data structure in the page; allocate space for this
253          */
254         m = alloc_bootmem(sizeof(struct huge_bootmem_page));
255         m->phys = gpage_freearray[idx].gpage_list[--nr_gpages];
256 #else
257         m = phys_to_virt(gpage_freearray[idx].gpage_list[--nr_gpages]);
258 #endif
259
260         list_add(&m->list, &huge_boot_pages);
261         gpage_freearray[idx].nr_gpages = nr_gpages;
262         gpage_freearray[idx].gpage_list[nr_gpages] = 0;
263         m->hstate = hstate;
264
265         return 1;
266 }
267 /*
268  * Scan the command line hugepagesz= options for gigantic pages; store those in
269  * a list that we use to allocate the memory once all options are parsed.
270  */
271
272 unsigned long gpage_npages[MMU_PAGE_COUNT];
273
274 static int __init do_gpage_early_setup(char *param, char *val)
275 {
276         static phys_addr_t size;
277         unsigned long npages;
278
279         /*
280          * The hugepagesz and hugepages cmdline options are interleaved.  We
281          * use the size variable to keep track of whether or not this was done
282          * properly and skip over instances where it is incorrect.  Other
283          * command-line parsing code will issue warnings, so we don't need to.
284          *
285          */
286         if ((strcmp(param, "default_hugepagesz") == 0) ||
287             (strcmp(param, "hugepagesz") == 0)) {
288                 size = memparse(val, NULL);
289         } else if (strcmp(param, "hugepages") == 0) {
290                 if (size != 0) {
291                         if (sscanf(val, "%lu", &npages) <= 0)
292                                 npages = 0;
293                         gpage_npages[shift_to_mmu_psize(__ffs(size))] = npages;
294                         size = 0;
295                 }
296         }
297         return 0;
298 }
299
300
301 /*
302  * This function allocates physical space for pages that are larger than the
303  * buddy allocator can handle.  We want to allocate these in highmem because
304  * the amount of lowmem is limited.  This means that this function MUST be
305  * called before lowmem_end_addr is set up in MMU_init() in order for the lmb
306  * allocate to grab highmem.
307  */
308 void __init reserve_hugetlb_gpages(void)
309 {
310         static __initdata char cmdline[COMMAND_LINE_SIZE];
311         phys_addr_t size, base;
312         int i;
313
314         strlcpy(cmdline, boot_command_line, COMMAND_LINE_SIZE);
315         parse_args("hugetlb gpages", cmdline, NULL, 0, &do_gpage_early_setup);
316
317         /*
318          * Walk gpage list in reverse, allocating larger page sizes first.
319          * Skip over unsupported sizes, or sizes that have 0 gpages allocated.
320          * When we reach the point in the list where pages are no longer
321          * considered gpages, we're done.
322          */
323         for (i = MMU_PAGE_COUNT-1; i >= 0; i--) {
324                 if (mmu_psize_defs[i].shift == 0 || gpage_npages[i] == 0)
325                         continue;
326                 else if (mmu_psize_to_shift(i) < (MAX_ORDER + PAGE_SHIFT))
327                         break;
328
329                 size = (phys_addr_t)(1ULL << mmu_psize_to_shift(i));
330                 base = memblock_alloc_base(size * gpage_npages[i], size,
331                                            MEMBLOCK_ALLOC_ANYWHERE);
332                 add_gpage(base, size, gpage_npages[i]);
333         }
334 }
335
336 #else /* !PPC_FSL_BOOK3E */
337
338 /* Build list of addresses of gigantic pages.  This function is used in early
339  * boot before the buddy or bootmem allocator is setup.
340  */
341 void add_gpage(u64 addr, u64 page_size, unsigned long number_of_pages)
342 {
343         if (!addr)
344                 return;
345         while (number_of_pages > 0) {
346                 gpage_freearray[nr_gpages] = addr;
347                 nr_gpages++;
348                 number_of_pages--;
349                 addr += page_size;
350         }
351 }
352
353 /* Moves the gigantic page addresses from the temporary list to the
354  * huge_boot_pages list.
355  */
356 int alloc_bootmem_huge_page(struct hstate *hstate)
357 {
358         struct huge_bootmem_page *m;
359         if (nr_gpages == 0)
360                 return 0;
361         m = phys_to_virt(gpage_freearray[--nr_gpages]);
362         gpage_freearray[nr_gpages] = 0;
363         list_add(&m->list, &huge_boot_pages);
364         m->hstate = hstate;
365         return 1;
366 }
367 #endif
368
369 int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep)
370 {
371         return 0;
372 }
373
374 #ifdef CONFIG_PPC_FSL_BOOK3E
375 #define HUGEPD_FREELIST_SIZE \
376         ((PAGE_SIZE - sizeof(struct hugepd_freelist)) / sizeof(pte_t))
377
378 struct hugepd_freelist {
379         struct rcu_head rcu;
380         unsigned int index;
381         void *ptes[0];
382 };
383
384 static DEFINE_PER_CPU(struct hugepd_freelist *, hugepd_freelist_cur);
385
386 static void hugepd_free_rcu_callback(struct rcu_head *head)
387 {
388         struct hugepd_freelist *batch =
389                 container_of(head, struct hugepd_freelist, rcu);
390         unsigned int i;
391
392         for (i = 0; i < batch->index; i++)
393                 kmem_cache_free(hugepte_cache, batch->ptes[i]);
394
395         free_page((unsigned long)batch);
396 }
397
398 static void hugepd_free(struct mmu_gather *tlb, void *hugepte)
399 {
400         struct hugepd_freelist **batchp;
401
402         batchp = &__get_cpu_var(hugepd_freelist_cur);
403
404         if (atomic_read(&tlb->mm->mm_users) < 2 ||
405             cpumask_equal(mm_cpumask(tlb->mm),
406                           cpumask_of(smp_processor_id()))) {
407                 kmem_cache_free(hugepte_cache, hugepte);
408                 return;
409         }
410
411         if (*batchp == NULL) {
412                 *batchp = (struct hugepd_freelist *)__get_free_page(GFP_ATOMIC);
413                 (*batchp)->index = 0;
414         }
415
416         (*batchp)->ptes[(*batchp)->index++] = hugepte;
417         if ((*batchp)->index == HUGEPD_FREELIST_SIZE) {
418                 call_rcu_sched(&(*batchp)->rcu, hugepd_free_rcu_callback);
419                 *batchp = NULL;
420         }
421 }
422 #endif
423
424 static void free_hugepd_range(struct mmu_gather *tlb, hugepd_t *hpdp, int pdshift,
425                               unsigned long start, unsigned long end,
426                               unsigned long floor, unsigned long ceiling)
427 {
428         pte_t *hugepte = hugepd_page(*hpdp);
429         int i;
430
431         unsigned long pdmask = ~((1UL << pdshift) - 1);
432         unsigned int num_hugepd = 1;
433
434 #ifdef CONFIG_PPC_FSL_BOOK3E
435         /* Note: On fsl the hpdp may be the first of several */
436         num_hugepd = (1 << (hugepd_shift(*hpdp) - pdshift));
437 #else
438         unsigned int shift = hugepd_shift(*hpdp);
439 #endif
440
441         start &= pdmask;
442         if (start < floor)
443                 return;
444         if (ceiling) {
445                 ceiling &= pdmask;
446                 if (! ceiling)
447                         return;
448         }
449         if (end - 1 > ceiling - 1)
450                 return;
451
452         for (i = 0; i < num_hugepd; i++, hpdp++)
453                 hpdp->pd = 0;
454
455         tlb->need_flush = 1;
456
457 #ifdef CONFIG_PPC_FSL_BOOK3E
458         hugepd_free(tlb, hugepte);
459 #else
460         pgtable_free_tlb(tlb, hugepte, pdshift - shift);
461 #endif
462 }
463
464 static void hugetlb_free_pmd_range(struct mmu_gather *tlb, pud_t *pud,
465                                    unsigned long addr, unsigned long end,
466                                    unsigned long floor, unsigned long ceiling)
467 {
468         pmd_t *pmd;
469         unsigned long next;
470         unsigned long start;
471
472         start = addr;
473         do {
474                 pmd = pmd_offset(pud, addr);
475                 next = pmd_addr_end(addr, end);
476                 if (pmd_none(*pmd))
477                         continue;
478 #ifdef CONFIG_PPC_FSL_BOOK3E
479                 /*
480                  * Increment next by the size of the huge mapping since
481                  * there may be more than one entry at this level for a
482                  * single hugepage, but all of them point to
483                  * the same kmem cache that holds the hugepte.
484                  */
485                 next = addr + (1 << hugepd_shift(*(hugepd_t *)pmd));
486 #endif
487                 free_hugepd_range(tlb, (hugepd_t *)pmd, PMD_SHIFT,
488                                   addr, next, floor, ceiling);
489         } while (addr = next, addr != end);
490
491         start &= PUD_MASK;
492         if (start < floor)
493                 return;
494         if (ceiling) {
495                 ceiling &= PUD_MASK;
496                 if (!ceiling)
497                         return;
498         }
499         if (end - 1 > ceiling - 1)
500                 return;
501
502         pmd = pmd_offset(pud, start);
503         pud_clear(pud);
504         pmd_free_tlb(tlb, pmd, start);
505 }
506
507 static void hugetlb_free_pud_range(struct mmu_gather *tlb, pgd_t *pgd,
508                                    unsigned long addr, unsigned long end,
509                                    unsigned long floor, unsigned long ceiling)
510 {
511         pud_t *pud;
512         unsigned long next;
513         unsigned long start;
514
515         start = addr;
516         do {
517                 pud = pud_offset(pgd, addr);
518                 next = pud_addr_end(addr, end);
519                 if (!is_hugepd(pud)) {
520                         if (pud_none_or_clear_bad(pud))
521                                 continue;
522                         hugetlb_free_pmd_range(tlb, pud, addr, next, floor,
523                                                ceiling);
524                 } else {
525 #ifdef CONFIG_PPC_FSL_BOOK3E
526                         /*
527                          * Increment next by the size of the huge mapping since
528                          * there may be more than one entry at this level for a
529                          * single hugepage, but all of them point to
530                          * the same kmem cache that holds the hugepte.
531                          */
532                         next = addr + (1 << hugepd_shift(*(hugepd_t *)pud));
533 #endif
534                         free_hugepd_range(tlb, (hugepd_t *)pud, PUD_SHIFT,
535                                           addr, next, floor, ceiling);
536                 }
537         } while (addr = next, addr != end);
538
539         start &= PGDIR_MASK;
540         if (start < floor)
541                 return;
542         if (ceiling) {
543                 ceiling &= PGDIR_MASK;
544                 if (!ceiling)
545                         return;
546         }
547         if (end - 1 > ceiling - 1)
548                 return;
549
550         pud = pud_offset(pgd, start);
551         pgd_clear(pgd);
552         pud_free_tlb(tlb, pud, start);
553 }
554
555 /*
556  * This function frees user-level page tables of a process.
557  *
558  * Must be called with pagetable lock held.
559  */
560 void hugetlb_free_pgd_range(struct mmu_gather *tlb,
561                             unsigned long addr, unsigned long end,
562                             unsigned long floor, unsigned long ceiling)
563 {
564         pgd_t *pgd;
565         unsigned long next;
566
567         /*
568          * Because there are a number of different possible pagetable
569          * layouts for hugepage ranges, we limit knowledge of how
570          * things should be laid out to the allocation path
571          * (huge_pte_alloc(), above).  Everything else works out the
572          * structure as it goes from information in the hugepd
573          * pointers.  That means that we can't here use the
574          * optimization used in the normal page free_pgd_range(), of
575          * checking whether we're actually covering a large enough
576          * range to have to do anything at the top level of the walk
577          * instead of at the bottom.
578          *
579          * To make sense of this, you should probably go read the big
580          * block comment at the top of the normal free_pgd_range(),
581          * too.
582          */
583
584         do {
585                 next = pgd_addr_end(addr, end);
586                 pgd = pgd_offset(tlb->mm, addr);
587                 if (!is_hugepd(pgd)) {
588                         if (pgd_none_or_clear_bad(pgd))
589                                 continue;
590                         hugetlb_free_pud_range(tlb, pgd, addr, next, floor, ceiling);
591                 } else {
592 #ifdef CONFIG_PPC_FSL_BOOK3E
593                         /*
594                          * Increment next by the size of the huge mapping since
595                          * there may be more than one entry at the pgd level
596                          * for a single hugepage, but all of them point to the
597                          * same kmem cache that holds the hugepte.
598                          */
599                         next = addr + (1 << hugepd_shift(*(hugepd_t *)pgd));
600 #endif
601                         free_hugepd_range(tlb, (hugepd_t *)pgd, PGDIR_SHIFT,
602                                           addr, next, floor, ceiling);
603                 }
604         } while (addr = next, addr != end);
605 }
606
607 struct page *
608 follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
609 {
610         pte_t *ptep;
611         struct page *page;
612         unsigned shift;
613         unsigned long mask;
614
615         ptep = find_linux_pte_or_hugepte(mm->pgd, address, &shift);
616
617         /* Verify it is a huge page else bail. */
618         if (!ptep || !shift)
619                 return ERR_PTR(-EINVAL);
620
621         mask = (1UL << shift) - 1;
622         page = pte_page(*ptep);
623         if (page)
624                 page += (address & mask) / PAGE_SIZE;
625
626         return page;
627 }
628
629 int pmd_huge(pmd_t pmd)
630 {
631         return 0;
632 }
633
634 int pud_huge(pud_t pud)
635 {
636         return 0;
637 }
638
639 struct page *
640 follow_huge_pmd(struct mm_struct *mm, unsigned long address,
641                 pmd_t *pmd, int write)
642 {
643         BUG();
644         return NULL;
645 }
646
647 static noinline int gup_hugepte(pte_t *ptep, unsigned long sz, unsigned long addr,
648                        unsigned long end, int write, struct page **pages, int *nr)
649 {
650         unsigned long mask;
651         unsigned long pte_end;
652         struct page *head, *page, *tail;
653         pte_t pte;
654         int refs;
655
656         pte_end = (addr + sz) & ~(sz-1);
657         if (pte_end < end)
658                 end = pte_end;
659
660         pte = *ptep;
661         mask = _PAGE_PRESENT | _PAGE_USER;
662         if (write)
663                 mask |= _PAGE_RW;
664
665         if ((pte_val(pte) & mask) != mask)
666                 return 0;
667
668         /* hugepages are never "special" */
669         VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
670
671         refs = 0;
672         head = pte_page(pte);
673
674         page = head + ((addr & (sz-1)) >> PAGE_SHIFT);
675         tail = page;
676         do {
677                 VM_BUG_ON(compound_head(page) != head);
678                 pages[*nr] = page;
679                 (*nr)++;
680                 page++;
681                 refs++;
682         } while (addr += PAGE_SIZE, addr != end);
683
684         if (!page_cache_add_speculative(head, refs)) {
685                 *nr -= refs;
686                 return 0;
687         }
688
689         if (unlikely(pte_val(pte) != pte_val(*ptep))) {
690                 /* Could be optimized better */
691                 *nr -= refs;
692                 while (refs--)
693                         put_page(head);
694                 return 0;
695         }
696
697         /*
698          * Any tail page need their mapcount reference taken before we
699          * return.
700          */
701         while (refs--) {
702                 if (PageTail(tail))
703                         get_huge_page_tail(tail);
704                 tail++;
705         }
706
707         return 1;
708 }
709
710 static unsigned long hugepte_addr_end(unsigned long addr, unsigned long end,
711                                       unsigned long sz)
712 {
713         unsigned long __boundary = (addr + sz) & ~(sz-1);
714         return (__boundary - 1 < end - 1) ? __boundary : end;
715 }
716
717 int gup_hugepd(hugepd_t *hugepd, unsigned pdshift,
718                unsigned long addr, unsigned long end,
719                int write, struct page **pages, int *nr)
720 {
721         pte_t *ptep;
722         unsigned long sz = 1UL << hugepd_shift(*hugepd);
723         unsigned long next;
724
725         ptep = hugepte_offset(hugepd, addr, pdshift);
726         do {
727                 next = hugepte_addr_end(addr, end, sz);
728                 if (!gup_hugepte(ptep, sz, addr, end, write, pages, nr))
729                         return 0;
730         } while (ptep++, addr = next, addr != end);
731
732         return 1;
733 }
734
735 #ifdef CONFIG_PPC_MM_SLICES
736 unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
737                                         unsigned long len, unsigned long pgoff,
738                                         unsigned long flags)
739 {
740         struct hstate *hstate = hstate_file(file);
741         int mmu_psize = shift_to_mmu_psize(huge_page_shift(hstate));
742
743         return slice_get_unmapped_area(addr, len, flags, mmu_psize, 1, 0);
744 }
745 #endif
746
747 unsigned long vma_mmu_pagesize(struct vm_area_struct *vma)
748 {
749 #ifdef CONFIG_PPC_MM_SLICES
750         unsigned int psize = get_slice_psize(vma->vm_mm, vma->vm_start);
751
752         return 1UL << mmu_psize_to_shift(psize);
753 #else
754         if (!is_vm_hugetlb_page(vma))
755                 return PAGE_SIZE;
756
757         return huge_page_size(hstate_vma(vma));
758 #endif
759 }
760
761 static inline bool is_power_of_4(unsigned long x)
762 {
763         if (is_power_of_2(x))
764                 return (__ilog2(x) % 2) ? false : true;
765         return false;
766 }
767
768 static int __init add_huge_page_size(unsigned long long size)
769 {
770         int shift = __ffs(size);
771         int mmu_psize;
772
773         /* Check that it is a page size supported by the hardware and
774          * that it fits within pagetable and slice limits. */
775 #ifdef CONFIG_PPC_FSL_BOOK3E
776         if ((size < PAGE_SIZE) || !is_power_of_4(size))
777                 return -EINVAL;
778 #else
779         if (!is_power_of_2(size)
780             || (shift > SLICE_HIGH_SHIFT) || (shift <= PAGE_SHIFT))
781                 return -EINVAL;
782 #endif
783
784         if ((mmu_psize = shift_to_mmu_psize(shift)) < 0)
785                 return -EINVAL;
786
787 #ifdef CONFIG_SPU_FS_64K_LS
788         /* Disable support for 64K huge pages when 64K SPU local store
789          * support is enabled as the current implementation conflicts.
790          */
791         if (shift == PAGE_SHIFT_64K)
792                 return -EINVAL;
793 #endif /* CONFIG_SPU_FS_64K_LS */
794
795         BUG_ON(mmu_psize_defs[mmu_psize].shift != shift);
796
797         /* Return if huge page size has already been setup */
798         if (size_to_hstate(size))
799                 return 0;
800
801         hugetlb_add_hstate(shift - PAGE_SHIFT);
802
803         return 0;
804 }
805
806 static int __init hugepage_setup_sz(char *str)
807 {
808         unsigned long long size;
809
810         size = memparse(str, &str);
811
812         if (add_huge_page_size(size) != 0)
813                 printk(KERN_WARNING "Invalid huge page size specified(%llu)\n", size);
814
815         return 1;
816 }
817 __setup("hugepagesz=", hugepage_setup_sz);
818
819 #ifdef CONFIG_PPC_FSL_BOOK3E
820 struct kmem_cache *hugepte_cache;
821 static int __init hugetlbpage_init(void)
822 {
823         int psize;
824
825         for (psize = 0; psize < MMU_PAGE_COUNT; ++psize) {
826                 unsigned shift;
827
828                 if (!mmu_psize_defs[psize].shift)
829                         continue;
830
831                 shift = mmu_psize_to_shift(psize);
832
833                 /* Don't treat normal page sizes as huge... */
834                 if (shift != PAGE_SHIFT)
835                         if (add_huge_page_size(1ULL << shift) < 0)
836                                 continue;
837         }
838
839         /*
840          * Create a kmem cache for hugeptes.  The bottom bits in the pte have
841          * size information encoded in them, so align them to allow this
842          */
843         hugepte_cache =  kmem_cache_create("hugepte-cache", sizeof(pte_t),
844                                            HUGEPD_SHIFT_MASK + 1, 0, NULL);
845         if (hugepte_cache == NULL)
846                 panic("%s: Unable to create kmem cache for hugeptes\n",
847                       __func__);
848
849         /* Default hpage size = 4M */
850         if (mmu_psize_defs[MMU_PAGE_4M].shift)
851                 HPAGE_SHIFT = mmu_psize_defs[MMU_PAGE_4M].shift;
852         else
853                 panic("%s: Unable to set default huge page size\n", __func__);
854
855
856         return 0;
857 }
858 #else
859 static int __init hugetlbpage_init(void)
860 {
861         int psize;
862
863         if (!mmu_has_feature(MMU_FTR_16M_PAGE))
864                 return -ENODEV;
865
866         for (psize = 0; psize < MMU_PAGE_COUNT; ++psize) {
867                 unsigned shift;
868                 unsigned pdshift;
869
870                 if (!mmu_psize_defs[psize].shift)
871                         continue;
872
873                 shift = mmu_psize_to_shift(psize);
874
875                 if (add_huge_page_size(1ULL << shift) < 0)
876                         continue;
877
878                 if (shift < PMD_SHIFT)
879                         pdshift = PMD_SHIFT;
880                 else if (shift < PUD_SHIFT)
881                         pdshift = PUD_SHIFT;
882                 else
883                         pdshift = PGDIR_SHIFT;
884
885                 pgtable_cache_add(pdshift - shift, NULL);
886                 if (!PGT_CACHE(pdshift - shift))
887                         panic("hugetlbpage_init(): could not create "
888                               "pgtable cache for %d bit pagesize\n", shift);
889         }
890
891         /* Set default large page size. Currently, we pick 16M or 1M
892          * depending on what is available
893          */
894         if (mmu_psize_defs[MMU_PAGE_16M].shift)
895                 HPAGE_SHIFT = mmu_psize_defs[MMU_PAGE_16M].shift;
896         else if (mmu_psize_defs[MMU_PAGE_1M].shift)
897                 HPAGE_SHIFT = mmu_psize_defs[MMU_PAGE_1M].shift;
898
899         return 0;
900 }
901 #endif
902 module_init(hugetlbpage_init);
903
904 void flush_dcache_icache_hugepage(struct page *page)
905 {
906         int i;
907         void *start;
908
909         BUG_ON(!PageCompound(page));
910
911         for (i = 0; i < (1UL << compound_order(page)); i++) {
912                 if (!PageHighMem(page)) {
913                         __flush_dcache_icache(page_address(page+i));
914                 } else {
915                         start = kmap_atomic(page+i, KM_PPC_SYNC_ICACHE);
916                         __flush_dcache_icache(start);
917                         kunmap_atomic(start, KM_PPC_SYNC_ICACHE);
918                 }
919         }
920 }