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