Merge branch 'bugfixes' of git://git.linux-nfs.org/projects/trondmy/nfs-2.6
[linux-2.6.git] / include / linux / mmu_notifier.h
1 #ifndef _LINUX_MMU_NOTIFIER_H
2 #define _LINUX_MMU_NOTIFIER_H
3
4 #include <linux/list.h>
5 #include <linux/spinlock.h>
6 #include <linux/mm_types.h>
7
8 struct mmu_notifier;
9 struct mmu_notifier_ops;
10
11 #ifdef CONFIG_MMU_NOTIFIER
12
13 /*
14  * The mmu notifier_mm structure is allocated and installed in
15  * mm->mmu_notifier_mm inside the mm_take_all_locks() protected
16  * critical section and it's released only when mm_count reaches zero
17  * in mmdrop().
18  */
19 struct mmu_notifier_mm {
20         /* all mmu notifiers registerd in this mm are queued in this list */
21         struct hlist_head list;
22         /* to serialize the list modifications and hlist_unhashed */
23         spinlock_t lock;
24 };
25
26 struct mmu_notifier_ops {
27         /*
28          * Called either by mmu_notifier_unregister or when the mm is
29          * being destroyed by exit_mmap, always before all pages are
30          * freed. This can run concurrently with other mmu notifier
31          * methods (the ones invoked outside the mm context) and it
32          * should tear down all secondary mmu mappings and freeze the
33          * secondary mmu. If this method isn't implemented you've to
34          * be sure that nothing could possibly write to the pages
35          * through the secondary mmu by the time the last thread with
36          * tsk->mm == mm exits.
37          *
38          * As side note: the pages freed after ->release returns could
39          * be immediately reallocated by the gart at an alias physical
40          * address with a different cache model, so if ->release isn't
41          * implemented because all _software_ driven memory accesses
42          * through the secondary mmu are terminated by the time the
43          * last thread of this mm quits, you've also to be sure that
44          * speculative _hardware_ operations can't allocate dirty
45          * cachelines in the cpu that could not be snooped and made
46          * coherent with the other read and write operations happening
47          * through the gart alias address, so leading to memory
48          * corruption.
49          */
50         void (*release)(struct mmu_notifier *mn,
51                         struct mm_struct *mm);
52
53         /*
54          * clear_flush_young is called after the VM is
55          * test-and-clearing the young/accessed bitflag in the
56          * pte. This way the VM will provide proper aging to the
57          * accesses to the page through the secondary MMUs and not
58          * only to the ones through the Linux pte.
59          */
60         int (*clear_flush_young)(struct mmu_notifier *mn,
61                                  struct mm_struct *mm,
62                                  unsigned long address);
63
64         /*
65          * test_young is called to check the young/accessed bitflag in
66          * the secondary pte. This is used to know if the page is
67          * frequently used without actually clearing the flag or tearing
68          * down the secondary mapping on the page.
69          */
70         int (*test_young)(struct mmu_notifier *mn,
71                           struct mm_struct *mm,
72                           unsigned long address);
73
74         /*
75          * change_pte is called in cases that pte mapping to page is changed:
76          * for example, when ksm remaps pte to point to a new shared page.
77          */
78         void (*change_pte)(struct mmu_notifier *mn,
79                            struct mm_struct *mm,
80                            unsigned long address,
81                            pte_t pte);
82
83         /*
84          * Before this is invoked any secondary MMU is still ok to
85          * read/write to the page previously pointed to by the Linux
86          * pte because the page hasn't been freed yet and it won't be
87          * freed until this returns. If required set_page_dirty has to
88          * be called internally to this method.
89          */
90         void (*invalidate_page)(struct mmu_notifier *mn,
91                                 struct mm_struct *mm,
92                                 unsigned long address);
93
94         /*
95          * invalidate_range_start() and invalidate_range_end() must be
96          * paired and are called only when the mmap_sem and/or the
97          * locks protecting the reverse maps are held. The subsystem
98          * must guarantee that no additional references are taken to
99          * the pages in the range established between the call to
100          * invalidate_range_start() and the matching call to
101          * invalidate_range_end().
102          *
103          * Invalidation of multiple concurrent ranges may be
104          * optionally permitted by the driver. Either way the
105          * establishment of sptes is forbidden in the range passed to
106          * invalidate_range_begin/end for the whole duration of the
107          * invalidate_range_begin/end critical section.
108          *
109          * invalidate_range_start() is called when all pages in the
110          * range are still mapped and have at least a refcount of one.
111          *
112          * invalidate_range_end() is called when all pages in the
113          * range have been unmapped and the pages have been freed by
114          * the VM.
115          *
116          * The VM will remove the page table entries and potentially
117          * the page between invalidate_range_start() and
118          * invalidate_range_end(). If the page must not be freed
119          * because of pending I/O or other circumstances then the
120          * invalidate_range_start() callback (or the initial mapping
121          * by the driver) must make sure that the refcount is kept
122          * elevated.
123          *
124          * If the driver increases the refcount when the pages are
125          * initially mapped into an address space then either
126          * invalidate_range_start() or invalidate_range_end() may
127          * decrease the refcount. If the refcount is decreased on
128          * invalidate_range_start() then the VM can free pages as page
129          * table entries are removed.  If the refcount is only
130          * droppped on invalidate_range_end() then the driver itself
131          * will drop the last refcount but it must take care to flush
132          * any secondary tlb before doing the final free on the
133          * page. Pages will no longer be referenced by the linux
134          * address space but may still be referenced by sptes until
135          * the last refcount is dropped.
136          */
137         void (*invalidate_range_start)(struct mmu_notifier *mn,
138                                        struct mm_struct *mm,
139                                        unsigned long start, unsigned long end);
140         void (*invalidate_range_end)(struct mmu_notifier *mn,
141                                      struct mm_struct *mm,
142                                      unsigned long start, unsigned long end);
143 };
144
145 /*
146  * The notifier chains are protected by mmap_sem and/or the reverse map
147  * semaphores. Notifier chains are only changed when all reverse maps and
148  * the mmap_sem locks are taken.
149  *
150  * Therefore notifier chains can only be traversed when either
151  *
152  * 1. mmap_sem is held.
153  * 2. One of the reverse map locks is held (i_mmap_lock or anon_vma->lock).
154  * 3. No other concurrent thread can access the list (release)
155  */
156 struct mmu_notifier {
157         struct hlist_node hlist;
158         const struct mmu_notifier_ops *ops;
159 };
160
161 static inline int mm_has_notifiers(struct mm_struct *mm)
162 {
163         return unlikely(mm->mmu_notifier_mm);
164 }
165
166 extern int mmu_notifier_register(struct mmu_notifier *mn,
167                                  struct mm_struct *mm);
168 extern int __mmu_notifier_register(struct mmu_notifier *mn,
169                                    struct mm_struct *mm);
170 extern void mmu_notifier_unregister(struct mmu_notifier *mn,
171                                     struct mm_struct *mm);
172 extern void __mmu_notifier_mm_destroy(struct mm_struct *mm);
173 extern void __mmu_notifier_release(struct mm_struct *mm);
174 extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
175                                           unsigned long address);
176 extern int __mmu_notifier_test_young(struct mm_struct *mm,
177                                      unsigned long address);
178 extern void __mmu_notifier_change_pte(struct mm_struct *mm,
179                                       unsigned long address, pte_t pte);
180 extern void __mmu_notifier_invalidate_page(struct mm_struct *mm,
181                                           unsigned long address);
182 extern void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
183                                   unsigned long start, unsigned long end);
184 extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
185                                   unsigned long start, unsigned long end);
186
187 static inline void mmu_notifier_release(struct mm_struct *mm)
188 {
189         if (mm_has_notifiers(mm))
190                 __mmu_notifier_release(mm);
191 }
192
193 static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
194                                           unsigned long address)
195 {
196         if (mm_has_notifiers(mm))
197                 return __mmu_notifier_clear_flush_young(mm, address);
198         return 0;
199 }
200
201 static inline int mmu_notifier_test_young(struct mm_struct *mm,
202                                           unsigned long address)
203 {
204         if (mm_has_notifiers(mm))
205                 return __mmu_notifier_test_young(mm, address);
206         return 0;
207 }
208
209 static inline void mmu_notifier_change_pte(struct mm_struct *mm,
210                                            unsigned long address, pte_t pte)
211 {
212         if (mm_has_notifiers(mm))
213                 __mmu_notifier_change_pte(mm, address, pte);
214 }
215
216 static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
217                                           unsigned long address)
218 {
219         if (mm_has_notifiers(mm))
220                 __mmu_notifier_invalidate_page(mm, address);
221 }
222
223 static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
224                                   unsigned long start, unsigned long end)
225 {
226         if (mm_has_notifiers(mm))
227                 __mmu_notifier_invalidate_range_start(mm, start, end);
228 }
229
230 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
231                                   unsigned long start, unsigned long end)
232 {
233         if (mm_has_notifiers(mm))
234                 __mmu_notifier_invalidate_range_end(mm, start, end);
235 }
236
237 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
238 {
239         mm->mmu_notifier_mm = NULL;
240 }
241
242 static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
243 {
244         if (mm_has_notifiers(mm))
245                 __mmu_notifier_mm_destroy(mm);
246 }
247
248 /*
249  * These two macros will sometime replace ptep_clear_flush.
250  * ptep_clear_flush is implemented as macro itself, so this also is
251  * implemented as a macro until ptep_clear_flush will converted to an
252  * inline function, to diminish the risk of compilation failure. The
253  * invalidate_page method over time can be moved outside the PT lock
254  * and these two macros can be later removed.
255  */
256 #define ptep_clear_flush_notify(__vma, __address, __ptep)               \
257 ({                                                                      \
258         pte_t __pte;                                                    \
259         struct vm_area_struct *___vma = __vma;                          \
260         unsigned long ___address = __address;                           \
261         __pte = ptep_clear_flush(___vma, ___address, __ptep);           \
262         mmu_notifier_invalidate_page(___vma->vm_mm, ___address);        \
263         __pte;                                                          \
264 })
265
266 #define pmdp_clear_flush_notify(__vma, __address, __pmdp)               \
267 ({                                                                      \
268         pmd_t __pmd;                                                    \
269         struct vm_area_struct *___vma = __vma;                          \
270         unsigned long ___address = __address;                           \
271         VM_BUG_ON(__address & ~HPAGE_PMD_MASK);                         \
272         mmu_notifier_invalidate_range_start(___vma->vm_mm, ___address,  \
273                                             (__address)+HPAGE_PMD_SIZE);\
274         __pmd = pmdp_clear_flush(___vma, ___address, __pmdp);           \
275         mmu_notifier_invalidate_range_end(___vma->vm_mm, ___address,    \
276                                           (__address)+HPAGE_PMD_SIZE);  \
277         __pmd;                                                          \
278 })
279
280 #define pmdp_splitting_flush_notify(__vma, __address, __pmdp)           \
281 ({                                                                      \
282         struct vm_area_struct *___vma = __vma;                          \
283         unsigned long ___address = __address;                           \
284         VM_BUG_ON(__address & ~HPAGE_PMD_MASK);                         \
285         mmu_notifier_invalidate_range_start(___vma->vm_mm, ___address,  \
286                                             (__address)+HPAGE_PMD_SIZE);\
287         pmdp_splitting_flush(___vma, ___address, __pmdp);               \
288         mmu_notifier_invalidate_range_end(___vma->vm_mm, ___address,    \
289                                           (__address)+HPAGE_PMD_SIZE);  \
290 })
291
292 #define ptep_clear_flush_young_notify(__vma, __address, __ptep)         \
293 ({                                                                      \
294         int __young;                                                    \
295         struct vm_area_struct *___vma = __vma;                          \
296         unsigned long ___address = __address;                           \
297         __young = ptep_clear_flush_young(___vma, ___address, __ptep);   \
298         __young |= mmu_notifier_clear_flush_young(___vma->vm_mm,        \
299                                                   ___address);          \
300         __young;                                                        \
301 })
302
303 #define pmdp_clear_flush_young_notify(__vma, __address, __pmdp)         \
304 ({                                                                      \
305         int __young;                                                    \
306         struct vm_area_struct *___vma = __vma;                          \
307         unsigned long ___address = __address;                           \
308         __young = pmdp_clear_flush_young(___vma, ___address, __pmdp);   \
309         __young |= mmu_notifier_clear_flush_young(___vma->vm_mm,        \
310                                                   ___address);          \
311         __young;                                                        \
312 })
313
314 #define set_pte_at_notify(__mm, __address, __ptep, __pte)               \
315 ({                                                                      \
316         struct mm_struct *___mm = __mm;                                 \
317         unsigned long ___address = __address;                           \
318         pte_t ___pte = __pte;                                           \
319                                                                         \
320         set_pte_at(___mm, ___address, __ptep, ___pte);                  \
321         mmu_notifier_change_pte(___mm, ___address, ___pte);             \
322 })
323
324 #else /* CONFIG_MMU_NOTIFIER */
325
326 static inline void mmu_notifier_release(struct mm_struct *mm)
327 {
328 }
329
330 static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
331                                           unsigned long address)
332 {
333         return 0;
334 }
335
336 static inline int mmu_notifier_test_young(struct mm_struct *mm,
337                                           unsigned long address)
338 {
339         return 0;
340 }
341
342 static inline void mmu_notifier_change_pte(struct mm_struct *mm,
343                                            unsigned long address, pte_t pte)
344 {
345 }
346
347 static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
348                                           unsigned long address)
349 {
350 }
351
352 static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
353                                   unsigned long start, unsigned long end)
354 {
355 }
356
357 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
358                                   unsigned long start, unsigned long end)
359 {
360 }
361
362 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
363 {
364 }
365
366 static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
367 {
368 }
369
370 #define ptep_clear_flush_young_notify ptep_clear_flush_young
371 #define pmdp_clear_flush_young_notify pmdp_clear_flush_young
372 #define ptep_clear_flush_notify ptep_clear_flush
373 #define pmdp_clear_flush_notify pmdp_clear_flush
374 #define pmdp_splitting_flush_notify pmdp_splitting_flush
375 #define set_pte_at_notify set_pte_at
376
377 #endif /* CONFIG_MMU_NOTIFIER */
378
379 #endif /* _LINUX_MMU_NOTIFIER_H */