Merge tag 'for-linus-5.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rw/uml
[linux-2.6-microblaze.git] / include / linux / mm_inline.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef LINUX_MM_INLINE_H
3 #define LINUX_MM_INLINE_H
4
5 #include <linux/atomic.h>
6 #include <linux/huge_mm.h>
7 #include <linux/swap.h>
8 #include <linux/string.h>
9
10 /**
11  * folio_is_file_lru - Should the folio be on a file LRU or anon LRU?
12  * @folio: The folio to test.
13  *
14  * We would like to get this info without a page flag, but the state
15  * needs to survive until the folio is last deleted from the LRU, which
16  * could be as far down as __page_cache_release.
17  *
18  * Return: An integer (not a boolean!) used to sort a folio onto the
19  * right LRU list and to account folios correctly.
20  * 1 if @folio is a regular filesystem backed page cache folio
21  * or a lazily freed anonymous folio (e.g. via MADV_FREE).
22  * 0 if @folio is a normal anonymous folio, a tmpfs folio or otherwise
23  * ram or swap backed folio.
24  */
25 static inline int folio_is_file_lru(struct folio *folio)
26 {
27         return !folio_test_swapbacked(folio);
28 }
29
30 static inline int page_is_file_lru(struct page *page)
31 {
32         return folio_is_file_lru(page_folio(page));
33 }
34
35 static __always_inline void update_lru_size(struct lruvec *lruvec,
36                                 enum lru_list lru, enum zone_type zid,
37                                 long nr_pages)
38 {
39         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
40
41         __mod_lruvec_state(lruvec, NR_LRU_BASE + lru, nr_pages);
42         __mod_zone_page_state(&pgdat->node_zones[zid],
43                                 NR_ZONE_LRU_BASE + lru, nr_pages);
44 #ifdef CONFIG_MEMCG
45         mem_cgroup_update_lru_size(lruvec, lru, zid, nr_pages);
46 #endif
47 }
48
49 /**
50  * __folio_clear_lru_flags - Clear page lru flags before releasing a page.
51  * @folio: The folio that was on lru and now has a zero reference.
52  */
53 static __always_inline void __folio_clear_lru_flags(struct folio *folio)
54 {
55         VM_BUG_ON_FOLIO(!folio_test_lru(folio), folio);
56
57         __folio_clear_lru(folio);
58
59         /* this shouldn't happen, so leave the flags to bad_page() */
60         if (folio_test_active(folio) && folio_test_unevictable(folio))
61                 return;
62
63         __folio_clear_active(folio);
64         __folio_clear_unevictable(folio);
65 }
66
67 static __always_inline void __clear_page_lru_flags(struct page *page)
68 {
69         __folio_clear_lru_flags(page_folio(page));
70 }
71
72 /**
73  * folio_lru_list - Which LRU list should a folio be on?
74  * @folio: The folio to test.
75  *
76  * Return: The LRU list a folio should be on, as an index
77  * into the array of LRU lists.
78  */
79 static __always_inline enum lru_list folio_lru_list(struct folio *folio)
80 {
81         enum lru_list lru;
82
83         VM_BUG_ON_FOLIO(folio_test_active(folio) && folio_test_unevictable(folio), folio);
84
85         if (folio_test_unevictable(folio))
86                 return LRU_UNEVICTABLE;
87
88         lru = folio_is_file_lru(folio) ? LRU_INACTIVE_FILE : LRU_INACTIVE_ANON;
89         if (folio_test_active(folio))
90                 lru += LRU_ACTIVE;
91
92         return lru;
93 }
94
95 static __always_inline
96 void lruvec_add_folio(struct lruvec *lruvec, struct folio *folio)
97 {
98         enum lru_list lru = folio_lru_list(folio);
99
100         update_lru_size(lruvec, lru, folio_zonenum(folio),
101                         folio_nr_pages(folio));
102         if (lru != LRU_UNEVICTABLE)
103                 list_add(&folio->lru, &lruvec->lists[lru]);
104 }
105
106 static __always_inline void add_page_to_lru_list(struct page *page,
107                                 struct lruvec *lruvec)
108 {
109         lruvec_add_folio(lruvec, page_folio(page));
110 }
111
112 static __always_inline
113 void lruvec_add_folio_tail(struct lruvec *lruvec, struct folio *folio)
114 {
115         enum lru_list lru = folio_lru_list(folio);
116
117         update_lru_size(lruvec, lru, folio_zonenum(folio),
118                         folio_nr_pages(folio));
119         /* This is not expected to be used on LRU_UNEVICTABLE */
120         list_add_tail(&folio->lru, &lruvec->lists[lru]);
121 }
122
123 static __always_inline void add_page_to_lru_list_tail(struct page *page,
124                                 struct lruvec *lruvec)
125 {
126         lruvec_add_folio_tail(lruvec, page_folio(page));
127 }
128
129 static __always_inline
130 void lruvec_del_folio(struct lruvec *lruvec, struct folio *folio)
131 {
132         enum lru_list lru = folio_lru_list(folio);
133
134         if (lru != LRU_UNEVICTABLE)
135                 list_del(&folio->lru);
136         update_lru_size(lruvec, lru, folio_zonenum(folio),
137                         -folio_nr_pages(folio));
138 }
139
140 static __always_inline void del_page_from_lru_list(struct page *page,
141                                 struct lruvec *lruvec)
142 {
143         lruvec_del_folio(lruvec, page_folio(page));
144 }
145
146 #ifdef CONFIG_ANON_VMA_NAME
147 /*
148  * mmap_lock should be read-locked when calling anon_vma_name(). Caller should
149  * either keep holding the lock while using the returned pointer or it should
150  * raise anon_vma_name refcount before releasing the lock.
151  */
152 extern struct anon_vma_name *anon_vma_name(struct vm_area_struct *vma);
153 extern struct anon_vma_name *anon_vma_name_alloc(const char *name);
154 extern void anon_vma_name_free(struct kref *kref);
155
156 /* mmap_lock should be read-locked */
157 static inline void anon_vma_name_get(struct anon_vma_name *anon_name)
158 {
159         if (anon_name)
160                 kref_get(&anon_name->kref);
161 }
162
163 static inline void anon_vma_name_put(struct anon_vma_name *anon_name)
164 {
165         if (anon_name)
166                 kref_put(&anon_name->kref, anon_vma_name_free);
167 }
168
169 static inline
170 struct anon_vma_name *anon_vma_name_reuse(struct anon_vma_name *anon_name)
171 {
172         /* Prevent anon_name refcount saturation early on */
173         if (kref_read(&anon_name->kref) < REFCOUNT_MAX) {
174                 anon_vma_name_get(anon_name);
175                 return anon_name;
176
177         }
178         return anon_vma_name_alloc(anon_name->name);
179 }
180
181 static inline void dup_anon_vma_name(struct vm_area_struct *orig_vma,
182                                      struct vm_area_struct *new_vma)
183 {
184         struct anon_vma_name *anon_name = anon_vma_name(orig_vma);
185
186         if (anon_name)
187                 new_vma->anon_name = anon_vma_name_reuse(anon_name);
188 }
189
190 static inline void free_anon_vma_name(struct vm_area_struct *vma)
191 {
192         /*
193          * Not using anon_vma_name because it generates a warning if mmap_lock
194          * is not held, which might be the case here.
195          */
196         if (!vma->vm_file)
197                 anon_vma_name_put(vma->anon_name);
198 }
199
200 static inline bool anon_vma_name_eq(struct anon_vma_name *anon_name1,
201                                     struct anon_vma_name *anon_name2)
202 {
203         if (anon_name1 == anon_name2)
204                 return true;
205
206         return anon_name1 && anon_name2 &&
207                 !strcmp(anon_name1->name, anon_name2->name);
208 }
209
210 #else /* CONFIG_ANON_VMA_NAME */
211 static inline struct anon_vma_name *anon_vma_name(struct vm_area_struct *vma)
212 {
213         return NULL;
214 }
215
216 static inline struct anon_vma_name *anon_vma_name_alloc(const char *name)
217 {
218         return NULL;
219 }
220
221 static inline void anon_vma_name_get(struct anon_vma_name *anon_name) {}
222 static inline void anon_vma_name_put(struct anon_vma_name *anon_name) {}
223 static inline void dup_anon_vma_name(struct vm_area_struct *orig_vma,
224                                      struct vm_area_struct *new_vma) {}
225 static inline void free_anon_vma_name(struct vm_area_struct *vma) {}
226
227 static inline bool anon_vma_name_eq(struct anon_vma_name *anon_name1,
228                                     struct anon_vma_name *anon_name2)
229 {
230         return true;
231 }
232
233 #endif  /* CONFIG_ANON_VMA_NAME */
234
235 static inline void init_tlb_flush_pending(struct mm_struct *mm)
236 {
237         atomic_set(&mm->tlb_flush_pending, 0);
238 }
239
240 static inline void inc_tlb_flush_pending(struct mm_struct *mm)
241 {
242         atomic_inc(&mm->tlb_flush_pending);
243         /*
244          * The only time this value is relevant is when there are indeed pages
245          * to flush. And we'll only flush pages after changing them, which
246          * requires the PTL.
247          *
248          * So the ordering here is:
249          *
250          *      atomic_inc(&mm->tlb_flush_pending);
251          *      spin_lock(&ptl);
252          *      ...
253          *      set_pte_at();
254          *      spin_unlock(&ptl);
255          *
256          *                              spin_lock(&ptl)
257          *                              mm_tlb_flush_pending();
258          *                              ....
259          *                              spin_unlock(&ptl);
260          *
261          *      flush_tlb_range();
262          *      atomic_dec(&mm->tlb_flush_pending);
263          *
264          * Where the increment if constrained by the PTL unlock, it thus
265          * ensures that the increment is visible if the PTE modification is
266          * visible. After all, if there is no PTE modification, nobody cares
267          * about TLB flushes either.
268          *
269          * This very much relies on users (mm_tlb_flush_pending() and
270          * mm_tlb_flush_nested()) only caring about _specific_ PTEs (and
271          * therefore specific PTLs), because with SPLIT_PTE_PTLOCKS and RCpc
272          * locks (PPC) the unlock of one doesn't order against the lock of
273          * another PTL.
274          *
275          * The decrement is ordered by the flush_tlb_range(), such that
276          * mm_tlb_flush_pending() will not return false unless all flushes have
277          * completed.
278          */
279 }
280
281 static inline void dec_tlb_flush_pending(struct mm_struct *mm)
282 {
283         /*
284          * See inc_tlb_flush_pending().
285          *
286          * This cannot be smp_mb__before_atomic() because smp_mb() simply does
287          * not order against TLB invalidate completion, which is what we need.
288          *
289          * Therefore we must rely on tlb_flush_*() to guarantee order.
290          */
291         atomic_dec(&mm->tlb_flush_pending);
292 }
293
294 static inline bool mm_tlb_flush_pending(struct mm_struct *mm)
295 {
296         /*
297          * Must be called after having acquired the PTL; orders against that
298          * PTLs release and therefore ensures that if we observe the modified
299          * PTE we must also observe the increment from inc_tlb_flush_pending().
300          *
301          * That is, it only guarantees to return true if there is a flush
302          * pending for _this_ PTL.
303          */
304         return atomic_read(&mm->tlb_flush_pending);
305 }
306
307 static inline bool mm_tlb_flush_nested(struct mm_struct *mm)
308 {
309         /*
310          * Similar to mm_tlb_flush_pending(), we must have acquired the PTL
311          * for which there is a TLB flush pending in order to guarantee
312          * we've seen both that PTE modification and the increment.
313          *
314          * (no requirement on actually still holding the PTL, that is irrelevant)
315          */
316         return atomic_read(&mm->tlb_flush_pending) > 1;
317 }
318
319
320 #endif