1a2b36f8866d88b7708722ff81b9026e5445f22e
[linux-2.6.git] / arch / tile / mm / pgtable.c
1 /*
2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
3  *
4  *   This program is free software; you can redistribute it and/or
5  *   modify it under the terms of the GNU General Public License
6  *   as published by the Free Software Foundation, version 2.
7  *
8  *   This program is distributed in the hope that it will be useful, but
9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11  *   NON INFRINGEMENT.  See the GNU General Public License for
12  *   more details.
13  */
14
15 #include <linux/sched.h>
16 #include <linux/kernel.h>
17 #include <linux/errno.h>
18 #include <linux/mm.h>
19 #include <linux/swap.h>
20 #include <linux/highmem.h>
21 #include <linux/slab.h>
22 #include <linux/pagemap.h>
23 #include <linux/spinlock.h>
24 #include <linux/cpumask.h>
25 #include <linux/module.h>
26 #include <linux/io.h>
27 #include <linux/vmalloc.h>
28 #include <linux/smp.h>
29
30 #include <asm/system.h>
31 #include <asm/pgtable.h>
32 #include <asm/pgalloc.h>
33 #include <asm/fixmap.h>
34 #include <asm/tlb.h>
35 #include <asm/tlbflush.h>
36 #include <asm/homecache.h>
37
38 #define K(x) ((x) << (PAGE_SHIFT-10))
39
40 /*
41  * The normal show_free_areas() is too verbose on Tile, with dozens
42  * of processors and often four NUMA zones each with high and lowmem.
43  */
44 void show_mem(void)
45 {
46         struct zone *zone;
47
48         pr_err("Active:%lu inactive:%lu dirty:%lu writeback:%lu unstable:%lu"
49                " free:%lu\n slab:%lu mapped:%lu pagetables:%lu bounce:%lu"
50                " pagecache:%lu swap:%lu\n",
51                (global_page_state(NR_ACTIVE_ANON) +
52                 global_page_state(NR_ACTIVE_FILE)),
53                (global_page_state(NR_INACTIVE_ANON) +
54                 global_page_state(NR_INACTIVE_FILE)),
55                global_page_state(NR_FILE_DIRTY),
56                global_page_state(NR_WRITEBACK),
57                global_page_state(NR_UNSTABLE_NFS),
58                global_page_state(NR_FREE_PAGES),
59                (global_page_state(NR_SLAB_RECLAIMABLE) +
60                 global_page_state(NR_SLAB_UNRECLAIMABLE)),
61                global_page_state(NR_FILE_MAPPED),
62                global_page_state(NR_PAGETABLE),
63                global_page_state(NR_BOUNCE),
64                global_page_state(NR_FILE_PAGES),
65                nr_swap_pages);
66
67         for_each_zone(zone) {
68                 unsigned long flags, order, total = 0, largest_order = -1;
69
70                 if (!populated_zone(zone))
71                         continue;
72
73                 spin_lock_irqsave(&zone->lock, flags);
74                 for (order = 0; order < MAX_ORDER; order++) {
75                         int nr = zone->free_area[order].nr_free;
76                         total += nr << order;
77                         if (nr)
78                                 largest_order = order;
79                 }
80                 spin_unlock_irqrestore(&zone->lock, flags);
81                 pr_err("Node %d %7s: %lukB (largest %luKb)\n",
82                        zone_to_nid(zone), zone->name,
83                        K(total), largest_order ? K(1UL) << largest_order : 0);
84         }
85 }
86
87 /*
88  * Associate a virtual page frame with a given physical page frame
89  * and protection flags for that frame.
90  */
91 static void set_pte_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags)
92 {
93         pgd_t *pgd;
94         pud_t *pud;
95         pmd_t *pmd;
96         pte_t *pte;
97
98         pgd = swapper_pg_dir + pgd_index(vaddr);
99         if (pgd_none(*pgd)) {
100                 BUG();
101                 return;
102         }
103         pud = pud_offset(pgd, vaddr);
104         if (pud_none(*pud)) {
105                 BUG();
106                 return;
107         }
108         pmd = pmd_offset(pud, vaddr);
109         if (pmd_none(*pmd)) {
110                 BUG();
111                 return;
112         }
113         pte = pte_offset_kernel(pmd, vaddr);
114         /* <pfn,flags> stored as-is, to permit clearing entries */
115         set_pte(pte, pfn_pte(pfn, flags));
116
117         /*
118          * It's enough to flush this one mapping.
119          * This appears conservative since it is only called
120          * from __set_fixmap.
121          */
122         local_flush_tlb_page(NULL, vaddr, PAGE_SIZE);
123 }
124
125 void __set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t flags)
126 {
127         unsigned long address = __fix_to_virt(idx);
128
129         if (idx >= __end_of_fixed_addresses) {
130                 BUG();
131                 return;
132         }
133         set_pte_pfn(address, phys >> PAGE_SHIFT, flags);
134 }
135
136 #if defined(CONFIG_HIGHPTE)
137 pte_t *_pte_offset_map(pmd_t *dir, unsigned long address)
138 {
139         pte_t *pte = kmap_atomic(pmd_page(*dir)) +
140                 (pmd_ptfn(*dir) << HV_LOG2_PAGE_TABLE_ALIGN) & ~PAGE_MASK;
141         return &pte[pte_index(address)];
142 }
143 #endif
144
145 /**
146  * shatter_huge_page() - ensure a given address is mapped by a small page.
147  *
148  * This function converts a huge PTE mapping kernel LOWMEM into a bunch
149  * of small PTEs with the same caching.  No cache flush required, but we
150  * must do a global TLB flush.
151  *
152  * Any caller that wishes to modify a kernel mapping that might
153  * have been made with a huge page should call this function,
154  * since doing so properly avoids race conditions with installing the
155  * newly-shattered page and then flushing all the TLB entries.
156  *
157  * @addr: Address at which to shatter any existing huge page.
158  */
159 void shatter_huge_page(unsigned long addr)
160 {
161         pgd_t *pgd;
162         pud_t *pud;
163         pmd_t *pmd;
164         unsigned long flags = 0;  /* happy compiler */
165 #ifdef __PAGETABLE_PMD_FOLDED
166         struct list_head *pos;
167 #endif
168
169         /* Get a pointer to the pmd entry that we need to change. */
170         addr &= HPAGE_MASK;
171         BUG_ON(pgd_addr_invalid(addr));
172         BUG_ON(addr < PAGE_OFFSET);  /* only for kernel LOWMEM */
173         pgd = swapper_pg_dir + pgd_index(addr);
174         pud = pud_offset(pgd, addr);
175         BUG_ON(!pud_present(*pud));
176         pmd = pmd_offset(pud, addr);
177         BUG_ON(!pmd_present(*pmd));
178         if (!pmd_huge_page(*pmd))
179                 return;
180
181         /*
182          * Grab the pgd_lock, since we may need it to walk the pgd_list,
183          * and since we need some kind of lock here to avoid races.
184          */
185         spin_lock_irqsave(&pgd_lock, flags);
186         if (!pmd_huge_page(*pmd)) {
187                 /* Lost the race to convert the huge page. */
188                 spin_unlock_irqrestore(&pgd_lock, flags);
189                 return;
190         }
191
192         /* Shatter the huge page into the preallocated L2 page table. */
193         pmd_populate_kernel(&init_mm, pmd,
194                             get_prealloc_pte(pte_pfn(*(pte_t *)pmd)));
195
196 #ifdef __PAGETABLE_PMD_FOLDED
197         /* Walk every pgd on the system and update the pmd there. */
198         list_for_each(pos, &pgd_list) {
199                 pmd_t *copy_pmd;
200                 pgd = list_to_pgd(pos) + pgd_index(addr);
201                 pud = pud_offset(pgd, addr);
202                 copy_pmd = pmd_offset(pud, addr);
203                 __set_pmd(copy_pmd, *pmd);
204         }
205 #endif
206
207         /* Tell every cpu to notice the change. */
208         flush_remote(0, 0, NULL, addr, HPAGE_SIZE, HPAGE_SIZE,
209                      cpu_possible_mask, NULL, 0);
210
211         /* Hold the lock until the TLB flush is finished to avoid races. */
212         spin_unlock_irqrestore(&pgd_lock, flags);
213 }
214
215 /*
216  * List of all pgd's needed so it can invalidate entries in both cached
217  * and uncached pgd's. This is essentially codepath-based locking
218  * against pageattr.c; it is the unique case in which a valid change
219  * of kernel pagetables can't be lazily synchronized by vmalloc faults.
220  * vmalloc faults work because attached pagetables are never freed.
221  * The locking scheme was chosen on the basis of manfred's
222  * recommendations and having no core impact whatsoever.
223  * -- wli
224  */
225 DEFINE_SPINLOCK(pgd_lock);
226 LIST_HEAD(pgd_list);
227
228 static inline void pgd_list_add(pgd_t *pgd)
229 {
230         list_add(pgd_to_list(pgd), &pgd_list);
231 }
232
233 static inline void pgd_list_del(pgd_t *pgd)
234 {
235         list_del(pgd_to_list(pgd));
236 }
237
238 #define KERNEL_PGD_INDEX_START pgd_index(PAGE_OFFSET)
239 #define KERNEL_PGD_PTRS (PTRS_PER_PGD - KERNEL_PGD_INDEX_START)
240
241 static void pgd_ctor(pgd_t *pgd)
242 {
243         unsigned long flags;
244
245         memset(pgd, 0, KERNEL_PGD_INDEX_START*sizeof(pgd_t));
246         spin_lock_irqsave(&pgd_lock, flags);
247
248 #ifndef __tilegx__
249         /*
250          * Check that the user interrupt vector has no L2.
251          * It never should for the swapper, and new page tables
252          * should always start with an empty user interrupt vector.
253          */
254         BUG_ON(((u64 *)swapper_pg_dir)[pgd_index(MEM_USER_INTRPT)] != 0);
255 #endif
256
257         memcpy(pgd + KERNEL_PGD_INDEX_START,
258                swapper_pg_dir + KERNEL_PGD_INDEX_START,
259                KERNEL_PGD_PTRS * sizeof(pgd_t));
260
261         pgd_list_add(pgd);
262         spin_unlock_irqrestore(&pgd_lock, flags);
263 }
264
265 static void pgd_dtor(pgd_t *pgd)
266 {
267         unsigned long flags; /* can be called from interrupt context */
268
269         spin_lock_irqsave(&pgd_lock, flags);
270         pgd_list_del(pgd);
271         spin_unlock_irqrestore(&pgd_lock, flags);
272 }
273
274 pgd_t *pgd_alloc(struct mm_struct *mm)
275 {
276         pgd_t *pgd = kmem_cache_alloc(pgd_cache, GFP_KERNEL);
277         if (pgd)
278                 pgd_ctor(pgd);
279         return pgd;
280 }
281
282 void pgd_free(struct mm_struct *mm, pgd_t *pgd)
283 {
284         pgd_dtor(pgd);
285         kmem_cache_free(pgd_cache, pgd);
286 }
287
288
289 #define L2_USER_PGTABLE_PAGES (1 << L2_USER_PGTABLE_ORDER)
290
291 struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
292 {
293         gfp_t flags = GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO;
294         struct page *p;
295 #if L2_USER_PGTABLE_ORDER > 0
296         int i;
297 #endif
298
299 #ifdef CONFIG_HIGHPTE
300         flags |= __GFP_HIGHMEM;
301 #endif
302
303         p = alloc_pages(flags, L2_USER_PGTABLE_ORDER);
304         if (p == NULL)
305                 return NULL;
306
307 #if L2_USER_PGTABLE_ORDER > 0
308         /*
309          * Make every page have a page_count() of one, not just the first.
310          * We don't use __GFP_COMP since it doesn't look like it works
311          * correctly with tlb_remove_page().
312          */
313         for (i = 1; i < L2_USER_PGTABLE_PAGES; ++i) {
314                 init_page_count(p+i);
315                 inc_zone_page_state(p+i, NR_PAGETABLE);
316         }
317 #endif
318
319         pgtable_page_ctor(p);
320         return p;
321 }
322
323 /*
324  * Free page immediately (used in __pte_alloc if we raced with another
325  * process).  We have to correct whatever pte_alloc_one() did before
326  * returning the pages to the allocator.
327  */
328 void pte_free(struct mm_struct *mm, struct page *p)
329 {
330         int i;
331
332         pgtable_page_dtor(p);
333         __free_page(p);
334
335         for (i = 1; i < L2_USER_PGTABLE_PAGES; ++i) {
336                 __free_page(p+i);
337                 dec_zone_page_state(p+i, NR_PAGETABLE);
338         }
339 }
340
341 void __pte_free_tlb(struct mmu_gather *tlb, struct page *pte,
342                     unsigned long address)
343 {
344         int i;
345
346         pgtable_page_dtor(pte);
347         tlb_remove_page(tlb, pte);
348
349         for (i = 1; i < L2_USER_PGTABLE_PAGES; ++i) {
350                 tlb_remove_page(tlb, pte + i);
351                 dec_zone_page_state(pte + i, NR_PAGETABLE);
352         }
353 }
354
355 #ifndef __tilegx__
356
357 /*
358  * FIXME: needs to be atomic vs hypervisor writes.  For now we make the
359  * window of vulnerability a bit smaller by doing an unlocked 8-bit update.
360  */
361 int ptep_test_and_clear_young(struct vm_area_struct *vma,
362                               unsigned long addr, pte_t *ptep)
363 {
364 #if HV_PTE_INDEX_ACCESSED < 8 || HV_PTE_INDEX_ACCESSED >= 16
365 # error Code assumes HV_PTE "accessed" bit in second byte
366 #endif
367         u8 *tmp = (u8 *)ptep;
368         u8 second_byte = tmp[1];
369         if (!(second_byte & (1 << (HV_PTE_INDEX_ACCESSED - 8))))
370                 return 0;
371         tmp[1] = second_byte & ~(1 << (HV_PTE_INDEX_ACCESSED - 8));
372         return 1;
373 }
374
375 /*
376  * This implementation is atomic vs hypervisor writes, since the hypervisor
377  * always writes the low word (where "accessed" and "dirty" are) and this
378  * routine only writes the high word.
379  */
380 void ptep_set_wrprotect(struct mm_struct *mm,
381                         unsigned long addr, pte_t *ptep)
382 {
383 #if HV_PTE_INDEX_WRITABLE < 32
384 # error Code assumes HV_PTE "writable" bit in high word
385 #endif
386         u32 *tmp = (u32 *)ptep;
387         tmp[1] = tmp[1] & ~(1 << (HV_PTE_INDEX_WRITABLE - 32));
388 }
389
390 #endif
391
392 pte_t *virt_to_pte(struct mm_struct* mm, unsigned long addr)
393 {
394         pgd_t *pgd;
395         pud_t *pud;
396         pmd_t *pmd;
397
398         if (pgd_addr_invalid(addr))
399                 return NULL;
400
401         pgd = mm ? pgd_offset(mm, addr) : swapper_pg_dir + pgd_index(addr);
402         pud = pud_offset(pgd, addr);
403         if (!pud_present(*pud))
404                 return NULL;
405         pmd = pmd_offset(pud, addr);
406         if (pmd_huge_page(*pmd))
407                 return (pte_t *)pmd;
408         if (!pmd_present(*pmd))
409                 return NULL;
410         return pte_offset_kernel(pmd, addr);
411 }
412
413 pgprot_t set_remote_cache_cpu(pgprot_t prot, int cpu)
414 {
415         unsigned int width = smp_width;
416         int x = cpu % width;
417         int y = cpu / width;
418         BUG_ON(y >= smp_height);
419         BUG_ON(hv_pte_get_mode(prot) != HV_PTE_MODE_CACHE_TILE_L3);
420         BUG_ON(cpu < 0 || cpu >= NR_CPUS);
421         BUG_ON(!cpu_is_valid_lotar(cpu));
422         return hv_pte_set_lotar(prot, HV_XY_TO_LOTAR(x, y));
423 }
424
425 int get_remote_cache_cpu(pgprot_t prot)
426 {
427         HV_LOTAR lotar = hv_pte_get_lotar(prot);
428         int x = HV_LOTAR_X(lotar);
429         int y = HV_LOTAR_Y(lotar);
430         BUG_ON(hv_pte_get_mode(prot) != HV_PTE_MODE_CACHE_TILE_L3);
431         return x + y * smp_width;
432 }
433
434 /*
435  * Convert a kernel VA to a PA and homing information.
436  */
437 int va_to_cpa_and_pte(void *va, unsigned long long *cpa, pte_t *pte)
438 {
439         struct page *page = virt_to_page(va);
440         pte_t null_pte = { 0 };
441
442         *cpa = __pa(va);
443
444         /* Note that this is not writing a page table, just returning a pte. */
445         *pte = pte_set_home(null_pte, page_home(page));
446
447         return 0; /* return non-zero if not hfh? */
448 }
449 EXPORT_SYMBOL(va_to_cpa_and_pte);
450
451 void __set_pte(pte_t *ptep, pte_t pte)
452 {
453 #ifdef __tilegx__
454         *ptep = pte;
455 #else
456 # if HV_PTE_INDEX_PRESENT >= 32 || HV_PTE_INDEX_MIGRATING >= 32
457 #  error Must write the present and migrating bits last
458 # endif
459         if (pte_present(pte)) {
460                 ((u32 *)ptep)[1] = (u32)(pte_val(pte) >> 32);
461                 barrier();
462                 ((u32 *)ptep)[0] = (u32)(pte_val(pte));
463         } else {
464                 ((u32 *)ptep)[0] = (u32)(pte_val(pte));
465                 barrier();
466                 ((u32 *)ptep)[1] = (u32)(pte_val(pte) >> 32);
467         }
468 #endif /* __tilegx__ */
469 }
470
471 void set_pte(pte_t *ptep, pte_t pte)
472 {
473         struct page *page = pfn_to_page(pte_pfn(pte));
474
475         /* Update the home of a PTE if necessary */
476         pte = pte_set_home(pte, page_home(page));
477
478         __set_pte(ptep, pte);
479 }
480
481 /* Can this mm load a PTE with cached_priority set? */
482 static inline int mm_is_priority_cached(struct mm_struct *mm)
483 {
484         return mm->context.priority_cached;
485 }
486
487 /*
488  * Add a priority mapping to an mm_context and
489  * notify the hypervisor if this is the first one.
490  */
491 void start_mm_caching(struct mm_struct *mm)
492 {
493         if (!mm_is_priority_cached(mm)) {
494                 mm->context.priority_cached = -1U;
495                 hv_set_caching(-1U);
496         }
497 }
498
499 /*
500  * Validate and return the priority_cached flag.  We know if it's zero
501  * that we don't need to scan, since we immediately set it non-zero
502  * when we first consider a MAP_CACHE_PRIORITY mapping.
503  *
504  * We only _try_ to acquire the mmap_sem semaphore; if we can't acquire it,
505  * since we're in an interrupt context (servicing switch_mm) we don't
506  * worry about it and don't unset the "priority_cached" field.
507  * Presumably we'll come back later and have more luck and clear
508  * the value then; for now we'll just keep the cache marked for priority.
509  */
510 static unsigned int update_priority_cached(struct mm_struct *mm)
511 {
512         if (mm->context.priority_cached && down_write_trylock(&mm->mmap_sem)) {
513                 struct vm_area_struct *vm;
514                 for (vm = mm->mmap; vm; vm = vm->vm_next) {
515                         if (hv_pte_get_cached_priority(vm->vm_page_prot))
516                                 break;
517                 }
518                 if (vm == NULL)
519                         mm->context.priority_cached = 0;
520                 up_write(&mm->mmap_sem);
521         }
522         return mm->context.priority_cached;
523 }
524
525 /* Set caching correctly for an mm that we are switching to. */
526 void check_mm_caching(struct mm_struct *prev, struct mm_struct *next)
527 {
528         if (!mm_is_priority_cached(next)) {
529                 /*
530                  * If the new mm doesn't use priority caching, just see if we
531                  * need the hv_set_caching(), or can assume it's already zero.
532                  */
533                 if (mm_is_priority_cached(prev))
534                         hv_set_caching(0);
535         } else {
536                 hv_set_caching(update_priority_cached(next));
537         }
538 }
539
540 #if CHIP_HAS_MMIO()
541
542 /* Map an arbitrary MMIO address, homed according to pgprot, into VA space. */
543 void __iomem *ioremap_prot(resource_size_t phys_addr, unsigned long size,
544                            pgprot_t home)
545 {
546         void *addr;
547         struct vm_struct *area;
548         unsigned long offset, last_addr;
549         pgprot_t pgprot;
550
551         /* Don't allow wraparound or zero size */
552         last_addr = phys_addr + size - 1;
553         if (!size || last_addr < phys_addr)
554                 return NULL;
555
556         /* Create a read/write, MMIO VA mapping homed at the requested shim. */
557         pgprot = PAGE_KERNEL;
558         pgprot = hv_pte_set_mode(pgprot, HV_PTE_MODE_MMIO);
559         pgprot = hv_pte_set_lotar(pgprot, hv_pte_get_lotar(home));
560
561         /*
562          * Mappings have to be page-aligned
563          */
564         offset = phys_addr & ~PAGE_MASK;
565         phys_addr &= PAGE_MASK;
566         size = PAGE_ALIGN(last_addr+1) - phys_addr;
567
568         /*
569          * Ok, go for it..
570          */
571         area = get_vm_area(size, VM_IOREMAP /* | other flags? */);
572         if (!area)
573                 return NULL;
574         area->phys_addr = phys_addr;
575         addr = area->addr;
576         if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,
577                                phys_addr, pgprot)) {
578                 remove_vm_area((void *)(PAGE_MASK & (unsigned long) addr));
579                 return NULL;
580         }
581         return (__force void __iomem *) (offset + (char *)addr);
582 }
583 EXPORT_SYMBOL(ioremap_prot);
584
585 /* Map a PCI MMIO bus address into VA space. */
586 void __iomem *ioremap(resource_size_t phys_addr, unsigned long size)
587 {
588         panic("ioremap for PCI MMIO is not supported");
589 }
590 EXPORT_SYMBOL(ioremap);
591
592 /* Unmap an MMIO VA mapping. */
593 void iounmap(volatile void __iomem *addr_in)
594 {
595         volatile void __iomem *addr = (volatile void __iomem *)
596                 (PAGE_MASK & (unsigned long __force)addr_in);
597 #if 1
598         vunmap((void * __force)addr);
599 #else
600         /* x86 uses this complicated flow instead of vunmap().  Is
601          * there any particular reason we should do the same? */
602         struct vm_struct *p, *o;
603
604         /* Use the vm area unlocked, assuming the caller
605            ensures there isn't another iounmap for the same address
606            in parallel. Reuse of the virtual address is prevented by
607            leaving it in the global lists until we're done with it.
608            cpa takes care of the direct mappings. */
609         read_lock(&vmlist_lock);
610         for (p = vmlist; p; p = p->next) {
611                 if (p->addr == addr)
612                         break;
613         }
614         read_unlock(&vmlist_lock);
615
616         if (!p) {
617                 pr_err("iounmap: bad address %p\n", addr);
618                 dump_stack();
619                 return;
620         }
621
622         /* Finally remove it */
623         o = remove_vm_area((void *)addr);
624         BUG_ON(p != o || o == NULL);
625         kfree(p);
626 #endif
627 }
628 EXPORT_SYMBOL(iounmap);
629
630 #endif /* CHIP_HAS_MMIO() */