mm: fix race in kunmap_atomic()
[linux-2.6.git] / arch / tile / mm / highmem.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/highmem.h>
16 #include <linux/module.h>
17 #include <linux/pagemap.h>
18 #include <asm/homecache.h>
19
20 #define kmap_get_pte(vaddr) \
21         pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
22                 (vaddr)), (vaddr))
23
24
25 void *kmap(struct page *page)
26 {
27         void *kva;
28         unsigned long flags;
29         pte_t *ptep;
30
31         might_sleep();
32         if (!PageHighMem(page))
33                 return page_address(page);
34         kva = kmap_high(page);
35
36         /*
37          * Rewrite the PTE under the lock.  This ensures that the page
38          * is not currently migrating.
39          */
40         ptep = kmap_get_pte((unsigned long)kva);
41         flags = homecache_kpte_lock();
42         set_pte_at(&init_mm, kva, ptep, mk_pte(page, page_to_kpgprot(page)));
43         homecache_kpte_unlock(flags);
44
45         return kva;
46 }
47 EXPORT_SYMBOL(kmap);
48
49 void kunmap(struct page *page)
50 {
51         if (in_interrupt())
52                 BUG();
53         if (!PageHighMem(page))
54                 return;
55         kunmap_high(page);
56 }
57 EXPORT_SYMBOL(kunmap);
58
59 /*
60  * Describe a single atomic mapping of a page on a given cpu at a
61  * given address, and allow it to be linked into a list.
62  */
63 struct atomic_mapped_page {
64         struct list_head list;
65         struct page *page;
66         int cpu;
67         unsigned long va;
68 };
69
70 static spinlock_t amp_lock = __SPIN_LOCK_UNLOCKED(&amp_lock);
71 static struct list_head amp_list = LIST_HEAD_INIT(amp_list);
72
73 /*
74  * Combining this structure with a per-cpu declaration lets us give
75  * each cpu an atomic_mapped_page structure per type.
76  */
77 struct kmap_amps {
78         struct atomic_mapped_page per_type[KM_TYPE_NR];
79 };
80 static DEFINE_PER_CPU(struct kmap_amps, amps);
81
82 /*
83  * Add a page and va, on this cpu, to the list of kmap_atomic pages,
84  * and write the new pte to memory.  Writing the new PTE under the
85  * lock guarantees that it is either on the list before migration starts
86  * (if we won the race), or set_pte() sets the migrating bit in the PTE
87  * (if we lost the race).  And doing it under the lock guarantees
88  * that when kmap_atomic_fix_one_pte() comes along, it finds a valid
89  * PTE in memory, iff the mapping is still on the amp_list.
90  *
91  * Finally, doing it under the lock lets us safely examine the page
92  * to see if it is immutable or not, for the generic kmap_atomic() case.
93  * If we examine it earlier we are exposed to a race where it looks
94  * writable earlier, but becomes immutable before we write the PTE.
95  */
96 static void kmap_atomic_register(struct page *page, enum km_type type,
97                                  unsigned long va, pte_t *ptep, pte_t pteval)
98 {
99         unsigned long flags;
100         struct atomic_mapped_page *amp;
101
102         flags = homecache_kpte_lock();
103         spin_lock(&amp_lock);
104
105         /* With interrupts disabled, now fill in the per-cpu info. */
106         amp = &__get_cpu_var(amps).per_type[type];
107         amp->page = page;
108         amp->cpu = smp_processor_id();
109         amp->va = va;
110
111         /* For generic kmap_atomic(), choose the PTE writability now. */
112         if (!pte_read(pteval))
113                 pteval = mk_pte(page, page_to_kpgprot(page));
114
115         list_add(&amp->list, &amp_list);
116         set_pte(ptep, pteval);
117         arch_flush_lazy_mmu_mode();
118
119         spin_unlock(&amp_lock);
120         homecache_kpte_unlock(flags);
121 }
122
123 /*
124  * Remove a page and va, on this cpu, from the list of kmap_atomic pages.
125  * Linear-time search, but we count on the lists being short.
126  * We don't need to adjust the PTE under the lock (as opposed to the
127  * kmap_atomic_register() case), since we're just unconditionally
128  * zeroing the PTE after it's off the list.
129  */
130 static void kmap_atomic_unregister(struct page *page, unsigned long va)
131 {
132         unsigned long flags;
133         struct atomic_mapped_page *amp;
134         int cpu = smp_processor_id();
135         spin_lock_irqsave(&amp_lock, flags);
136         list_for_each_entry(amp, &amp_list, list) {
137                 if (amp->page == page && amp->cpu == cpu && amp->va == va)
138                         break;
139         }
140         BUG_ON(&amp->list == &amp_list);
141         list_del(&amp->list);
142         spin_unlock_irqrestore(&amp_lock, flags);
143 }
144
145 /* Helper routine for kmap_atomic_fix_kpte(), below. */
146 static void kmap_atomic_fix_one_kpte(struct atomic_mapped_page *amp,
147                                      int finished)
148 {
149         pte_t *ptep = kmap_get_pte(amp->va);
150         if (!finished) {
151                 set_pte(ptep, pte_mkmigrate(*ptep));
152                 flush_remote(0, 0, NULL, amp->va, PAGE_SIZE, PAGE_SIZE,
153                              cpumask_of(amp->cpu), NULL, 0);
154         } else {
155                 /*
156                  * Rewrite a default kernel PTE for this page.
157                  * We rely on the fact that set_pte() writes the
158                  * present+migrating bits last.
159                  */
160                 pte_t pte = mk_pte(amp->page, page_to_kpgprot(amp->page));
161                 set_pte(ptep, pte);
162         }
163 }
164
165 /*
166  * This routine is a helper function for homecache_fix_kpte(); see
167  * its comments for more information on the "finished" argument here.
168  *
169  * Note that we hold the lock while doing the remote flushes, which
170  * will stall any unrelated cpus trying to do kmap_atomic operations.
171  * We could just update the PTEs under the lock, and save away copies
172  * of the structs (or just the va+cpu), then flush them after we
173  * release the lock, but it seems easier just to do it all under the lock.
174  */
175 void kmap_atomic_fix_kpte(struct page *page, int finished)
176 {
177         struct atomic_mapped_page *amp;
178         unsigned long flags;
179         spin_lock_irqsave(&amp_lock, flags);
180         list_for_each_entry(amp, &amp_list, list) {
181                 if (amp->page == page)
182                         kmap_atomic_fix_one_kpte(amp, finished);
183         }
184         spin_unlock_irqrestore(&amp_lock, flags);
185 }
186
187 /*
188  * kmap_atomic/kunmap_atomic is significantly faster than kmap/kunmap
189  * because the kmap code must perform a global TLB invalidation when
190  * the kmap pool wraps.
191  *
192  * Note that they may be slower than on x86 (etc.) because unlike on
193  * those platforms, we do have to take a global lock to map and unmap
194  * pages on Tile (see above).
195  *
196  * When holding an atomic kmap is is not legal to sleep, so atomic
197  * kmaps are appropriate for short, tight code paths only.
198  */
199 void *kmap_atomic_prot(struct page *page, pgprot_t prot)
200 {
201         unsigned long vaddr;
202         int idx, type;
203         pte_t *pte;
204
205         /* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */
206         pagefault_disable();
207
208         /* Avoid icache flushes by disallowing atomic executable mappings. */
209         BUG_ON(pte_exec(prot));
210
211         if (!PageHighMem(page))
212                 return page_address(page);
213
214         type = kmap_atomic_idx_push();
215         idx = type + KM_TYPE_NR*smp_processor_id();
216         vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
217         pte = kmap_get_pte(vaddr);
218         BUG_ON(!pte_none(*pte));
219
220         /* Register that this page is mapped atomically on this cpu. */
221         kmap_atomic_register(page, type, vaddr, pte, mk_pte(page, prot));
222
223         return (void *)vaddr;
224 }
225 EXPORT_SYMBOL(kmap_atomic_prot);
226
227 void *__kmap_atomic(struct page *page)
228 {
229         /* PAGE_NONE is a magic value that tells us to check immutability. */
230         return kmap_atomic_prot(page, type, PAGE_NONE);
231 }
232 EXPORT_SYMBOL(__kmap_atomic);
233
234 void __kunmap_atomic(void *kvaddr)
235 {
236         unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
237
238         if (vaddr >= __fix_to_virt(FIX_KMAP_END) &&
239             vaddr <= __fix_to_virt(FIX_KMAP_BEGIN)) {
240                 pte_t *pte = kmap_get_pte(vaddr);
241                 pte_t pteval = *pte;
242                 int idx, type;
243
244                 type = kmap_atomic_idx();
245                 idx = type + KM_TYPE_NR*smp_processor_id();
246
247                 /*
248                  * Force other mappings to Oops if they try to access this pte
249                  * without first remapping it.  Keeping stale mappings around
250                  * is a bad idea.
251                  */
252                 BUG_ON(!pte_present(pteval) && !pte_migrating(pteval));
253                 kmap_atomic_unregister(pte_page(pteval), vaddr);
254                 kpte_clear_flush(pte, vaddr);
255                 kmap_atomic_idx_pop();
256         } else {
257                 /* Must be a lowmem page */
258                 BUG_ON(vaddr < PAGE_OFFSET);
259                 BUG_ON(vaddr >= (unsigned long)high_memory);
260         }
261
262         arch_flush_lazy_mmu_mode();
263         pagefault_enable();
264 }
265 EXPORT_SYMBOL(__kunmap_atomic);
266
267 /*
268  * This API is supposed to allow us to map memory without a "struct page".
269  * Currently we don't support this, though this may change in the future.
270  */
271 void *kmap_atomic_pfn(unsigned long pfn)
272 {
273         return kmap_atomic(pfn_to_page(pfn));
274 }
275 void *kmap_atomic_prot_pfn(unsigned long pfn, pgprot_t prot)
276 {
277         return kmap_atomic_prot(pfn_to_page(pfn), prot);
278 }
279
280 struct page *kmap_atomic_to_page(void *ptr)
281 {
282         pte_t *pte;
283         unsigned long vaddr = (unsigned long)ptr;
284
285         if (vaddr < FIXADDR_START)
286                 return virt_to_page(ptr);
287
288         pte = kmap_get_pte(vaddr);
289         return pte_page(*pte);
290 }