Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/mm/swap.c
4 : : *
5 : : * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
6 : : */
7 : :
8 : : /*
9 : : * This file contains the default values for the operation of the
10 : : * Linux VM subsystem. Fine-tuning documentation can be found in
11 : : * Documentation/admin-guide/sysctl/vm.rst.
12 : : * Started 18.12.91
13 : : * Swap aging added 23.2.95, Stephen Tweedie.
14 : : * Buffermem limits added 12.3.98, Rik van Riel.
15 : : */
16 : :
17 : : #include <linux/mm.h>
18 : : #include <linux/sched.h>
19 : : #include <linux/kernel_stat.h>
20 : : #include <linux/swap.h>
21 : : #include <linux/mman.h>
22 : : #include <linux/pagemap.h>
23 : : #include <linux/pagevec.h>
24 : : #include <linux/init.h>
25 : : #include <linux/export.h>
26 : : #include <linux/mm_inline.h>
27 : : #include <linux/percpu_counter.h>
28 : : #include <linux/memremap.h>
29 : : #include <linux/percpu.h>
30 : : #include <linux/cpu.h>
31 : : #include <linux/notifier.h>
32 : : #include <linux/backing-dev.h>
33 : : #include <linux/memcontrol.h>
34 : : #include <linux/gfp.h>
35 : : #include <linux/uio.h>
36 : : #include <linux/hugetlb.h>
37 : : #include <linux/page_idle.h>
38 : :
39 : : #include "internal.h"
40 : :
41 : : #define CREATE_TRACE_POINTS
42 : : #include <trace/events/pagemap.h>
43 : :
44 : : /* How many pages do we try to swap or page in/out together? */
45 : : int page_cluster;
46 : :
47 : : static DEFINE_PER_CPU(struct pagevec, lru_add_pvec);
48 : : static DEFINE_PER_CPU(struct pagevec, lru_rotate_pvecs);
49 : : static DEFINE_PER_CPU(struct pagevec, lru_deactivate_file_pvecs);
50 : : static DEFINE_PER_CPU(struct pagevec, lru_deactivate_pvecs);
51 : : static DEFINE_PER_CPU(struct pagevec, lru_lazyfree_pvecs);
52 : : #ifdef CONFIG_SMP
53 : : static DEFINE_PER_CPU(struct pagevec, activate_page_pvecs);
54 : : #endif
55 : :
56 : : /*
57 : : * This path almost never happens for VM activity - pages are normally
58 : : * freed via pagevecs. But it gets used by networking.
59 : : */
60 : 3371 : static void __page_cache_release(struct page *page)
61 : : {
62 [ + + ]: 6742 : if (PageLRU(page)) {
63 : 62 : pg_data_t *pgdat = page_pgdat(page);
64 : 62 : struct lruvec *lruvec;
65 : 62 : unsigned long flags;
66 : :
67 : 62 : spin_lock_irqsave(&pgdat->lru_lock, flags);
68 : 62 : lruvec = mem_cgroup_page_lruvec(page, pgdat);
69 : 62 : VM_BUG_ON_PAGE(!PageLRU(page), page);
70 : 62 : __ClearPageLRU(page);
71 : 62 : del_page_from_lru_list(page, lruvec, page_off_lru(page));
72 : 62 : spin_unlock_irqrestore(&pgdat->lru_lock, flags);
73 : : }
74 : 3371 : __ClearPageWaiters(page);
75 : 3371 : }
76 : :
77 : 3371 : static void __put_single_page(struct page *page)
78 : : {
79 : 3371 : __page_cache_release(page);
80 : 3371 : mem_cgroup_uncharge(page);
81 : 3371 : free_unref_page(page);
82 : 3371 : }
83 : :
84 : 0 : static void __put_compound_page(struct page *page)
85 : : {
86 : 0 : compound_page_dtor *dtor;
87 : :
88 : : /*
89 : : * __page_cache_release() is supposed to be called for thp, not for
90 : : * hugetlb. This is because hugetlb page does never have PageLRU set
91 : : * (it's never listed to any LRU lists) and no memcg routines should
92 : : * be called for hugetlb (it has a separate hugetlb_cgroup.)
93 : : */
94 [ # # ]: 0 : if (!PageHuge(page))
95 : 0 : __page_cache_release(page);
96 : 0 : dtor = get_compound_page_dtor(page);
97 : 0 : (*dtor)(page);
98 : 0 : }
99 : :
100 : 3371 : void __put_page(struct page *page)
101 : : {
102 : 3371 : if (is_zone_device_page(page)) {
103 : : put_dev_pagemap(page->pgmap);
104 : :
105 : : /*
106 : : * The page belongs to the device that created pgmap. Do
107 : : * not return it to page allocator.
108 : : */
109 : : return;
110 : : }
111 : :
112 [ - + ]: 6742 : if (unlikely(PageCompound(page)))
113 : 0 : __put_compound_page(page);
114 : : else
115 : 3371 : __put_single_page(page);
116 : : }
117 : : EXPORT_SYMBOL(__put_page);
118 : :
119 : : /**
120 : : * put_pages_list() - release a list of pages
121 : : * @pages: list of pages threaded on page->lru
122 : : *
123 : : * Release a list of pages which are strung together on page.lru. Currently
124 : : * used by read_cache_pages() and related error recovery code.
125 : : */
126 : 24717 : void put_pages_list(struct list_head *pages)
127 : : {
128 [ - + ]: 24717 : while (!list_empty(pages)) {
129 : 0 : struct page *victim;
130 : :
131 : 0 : victim = lru_to_page(pages);
132 : 0 : list_del(&victim->lru);
133 : 0 : put_page(victim);
134 : : }
135 : 24717 : }
136 : : EXPORT_SYMBOL(put_pages_list);
137 : :
138 : : /*
139 : : * get_kernel_pages() - pin kernel pages in memory
140 : : * @kiov: An array of struct kvec structures
141 : : * @nr_segs: number of segments to pin
142 : : * @write: pinning for read/write, currently ignored
143 : : * @pages: array that receives pointers to the pages pinned.
144 : : * Should be at least nr_segs long.
145 : : *
146 : : * Returns number of pages pinned. This may be fewer than the number
147 : : * requested. If nr_pages is 0 or negative, returns 0. If no pages
148 : : * were pinned, returns -errno. Each page returned must be released
149 : : * with a put_page() call when it is finished with.
150 : : */
151 : 0 : int get_kernel_pages(const struct kvec *kiov, int nr_segs, int write,
152 : : struct page **pages)
153 : : {
154 : 0 : int seg;
155 : :
156 [ # # ]: 0 : for (seg = 0; seg < nr_segs; seg++) {
157 [ # # # # ]: 0 : if (WARN_ON(kiov[seg].iov_len != PAGE_SIZE))
158 : 0 : return seg;
159 : :
160 [ # # ]: 0 : pages[seg] = kmap_to_page(kiov[seg].iov_base);
161 [ # # ]: 0 : get_page(pages[seg]);
162 : : }
163 : :
164 : : return seg;
165 : : }
166 : : EXPORT_SYMBOL_GPL(get_kernel_pages);
167 : :
168 : : /*
169 : : * get_kernel_page() - pin a kernel page in memory
170 : : * @start: starting kernel address
171 : : * @write: pinning for read/write, currently ignored
172 : : * @pages: array that receives pointer to the page pinned.
173 : : * Must be at least nr_segs long.
174 : : *
175 : : * Returns 1 if page is pinned. If the page was not pinned, returns
176 : : * -errno. The page returned must be released with a put_page() call
177 : : * when it is finished with.
178 : : */
179 : 0 : int get_kernel_page(unsigned long start, int write, struct page **pages)
180 : : {
181 : 0 : const struct kvec kiov = {
182 : 0 : .iov_base = (void *)start,
183 : : .iov_len = PAGE_SIZE
184 : : };
185 : :
186 : 0 : return get_kernel_pages(&kiov, 1, write, pages);
187 : : }
188 : : EXPORT_SYMBOL_GPL(get_kernel_page);
189 : :
190 : 282229 : static void pagevec_lru_move_fn(struct pagevec *pvec,
191 : : void (*move_fn)(struct page *page, struct lruvec *lruvec, void *arg),
192 : : void *arg)
193 : : {
194 : 282229 : int i;
195 : 282229 : struct pglist_data *pgdat = NULL;
196 : 282229 : struct lruvec *lruvec;
197 : 282229 : unsigned long flags = 0;
198 : :
199 [ + + ]: 2046414 : for (i = 0; i < pagevec_count(pvec); i++) {
200 : 1764185 : struct page *page = pvec->pages[i];
201 [ + + ]: 1764185 : struct pglist_data *pagepgdat = page_pgdat(page);
202 : :
203 [ + + ]: 1764185 : if (pagepgdat != pgdat) {
204 [ - + ]: 282229 : if (pgdat)
205 : 0 : spin_unlock_irqrestore(&pgdat->lru_lock, flags);
206 : 282229 : pgdat = pagepgdat;
207 : 282229 : spin_lock_irqsave(&pgdat->lru_lock, flags);
208 : : }
209 : :
210 : 1764185 : lruvec = mem_cgroup_page_lruvec(page, pgdat);
211 : 1764185 : (*move_fn)(page, lruvec, arg);
212 : : }
213 [ + - ]: 282229 : if (pgdat)
214 : 282229 : spin_unlock_irqrestore(&pgdat->lru_lock, flags);
215 : 282229 : release_pages(pvec->pages, pvec->nr);
216 : 282229 : pagevec_reinit(pvec);
217 : 282229 : }
218 : :
219 : 0 : static void pagevec_move_tail_fn(struct page *page, struct lruvec *lruvec,
220 : : void *arg)
221 : : {
222 : 0 : int *pgmoved = arg;
223 : :
224 [ # # # # ]: 0 : if (PageLRU(page) && !PageUnevictable(page)) {
225 : 0 : del_page_from_lru_list(page, lruvec, page_lru(page));
226 : 0 : ClearPageActive(page);
227 : 0 : add_page_to_lru_list_tail(page, lruvec, page_lru(page));
228 : 0 : (*pgmoved)++;
229 : : }
230 : 0 : }
231 : :
232 : : /*
233 : : * pagevec_move_tail() must be called with IRQ disabled.
234 : : * Otherwise this may cause nasty races.
235 : : */
236 : 0 : static void pagevec_move_tail(struct pagevec *pvec)
237 : : {
238 : 0 : int pgmoved = 0;
239 : :
240 : 0 : pagevec_lru_move_fn(pvec, pagevec_move_tail_fn, &pgmoved);
241 [ # # ]: 0 : __count_vm_events(PGROTATED, pgmoved);
242 : 0 : }
243 : :
244 : : /*
245 : : * Writeback is about to end against a page which has been marked for immediate
246 : : * reclaim. If it still appears to be reclaimable, move it to the tail of the
247 : : * inactive list.
248 : : */
249 : 0 : void rotate_reclaimable_page(struct page *page)
250 : : {
251 [ # # # # : 0 : if (!PageLocked(page) && !PageDirty(page) &&
# # # # ]
252 [ # # ]: 0 : !PageUnevictable(page) && PageLRU(page)) {
253 : 0 : struct pagevec *pvec;
254 : 0 : unsigned long flags;
255 : :
256 [ # # ]: 0 : get_page(page);
257 : 0 : local_irq_save(flags);
258 : 0 : pvec = this_cpu_ptr(&lru_rotate_pvecs);
259 [ # # # # ]: 0 : if (!pagevec_add(pvec, page) || PageCompound(page))
260 : 0 : pagevec_move_tail(pvec);
261 : 0 : local_irq_restore(flags);
262 : : }
263 : 0 : }
264 : :
265 : 1763484 : static void update_page_reclaim_stat(struct lruvec *lruvec,
266 : : int file, int rotated)
267 : : {
268 : 1763484 : struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
269 : :
270 : 1763484 : reclaim_stat->recent_scanned[file]++;
271 [ + + ]: 1663413 : if (rotated)
272 : 1125261 : reclaim_stat->recent_rotated[file]++;
273 : : }
274 : :
275 : 100772 : static void __activate_page(struct page *page, struct lruvec *lruvec,
276 : : void *arg)
277 : : {
278 [ - + + - : 402387 : if (PageLRU(page) && !PageActive(page) && !PageUnevictable(page)) {
+ + + - ]
279 : 100071 : int file = page_is_file_cache(page);
280 : 100071 : int lru = page_lru_base_type(page);
281 : :
282 : 100071 : del_page_from_lru_list(page, lruvec, lru);
283 [ - + ]: 100071 : SetPageActive(page);
284 : 100071 : lru += LRU_ACTIVE;
285 : 100071 : add_page_to_lru_list(page, lruvec, lru);
286 : 100071 : trace_mm_lru_activate(page);
287 : :
288 : 100071 : __count_vm_event(PGACTIVATE);
289 : 100071 : update_page_reclaim_stat(lruvec, file, 1);
290 : : }
291 : 100772 : }
292 : :
293 : : #ifdef CONFIG_SMP
294 : 589959 : static void activate_page_drain(int cpu)
295 : : {
296 : 589959 : struct pagevec *pvec = &per_cpu(activate_page_pvecs, cpu);
297 : :
298 [ + + ]: 589959 : if (pagevec_count(pvec))
299 : 6285 : pagevec_lru_move_fn(pvec, __activate_page, NULL);
300 : 589959 : }
301 : :
302 : 0 : static bool need_activate_page_drain(int cpu)
303 : : {
304 [ # # ]: 0 : return pagevec_count(&per_cpu(activate_page_pvecs, cpu)) != 0;
305 : : }
306 : :
307 : 100772 : void activate_page(struct page *page)
308 : : {
309 [ - + ]: 100772 : page = compound_head(page);
310 [ - + + - : 403088 : if (PageLRU(page) && !PageActive(page) && !PageUnevictable(page)) {
+ - + - ]
311 : 100772 : struct pagevec *pvec = &get_cpu_var(activate_page_pvecs);
312 : :
313 [ - + ]: 100772 : get_page(page);
314 [ + + - + ]: 196087 : if (!pagevec_add(pvec, page) || PageCompound(page))
315 : 5457 : pagevec_lru_move_fn(pvec, __activate_page, NULL);
316 : 100772 : put_cpu_var(activate_page_pvecs);
317 : : }
318 : 100772 : }
319 : :
320 : : #else
321 : : static inline void activate_page_drain(int cpu)
322 : : {
323 : : }
324 : :
325 : : void activate_page(struct page *page)
326 : : {
327 : : pg_data_t *pgdat = page_pgdat(page);
328 : :
329 : : page = compound_head(page);
330 : : spin_lock_irq(&pgdat->lru_lock);
331 : : __activate_page(page, mem_cgroup_page_lruvec(page, pgdat), NULL);
332 : : spin_unlock_irq(&pgdat->lru_lock);
333 : : }
334 : : #endif
335 : :
336 : 38414 : static void __lru_cache_activate_page(struct page *page)
337 : : {
338 : 38414 : struct pagevec *pvec = &get_cpu_var(lru_add_pvec);
339 : 38414 : int i;
340 : :
341 : : /*
342 : : * Search backwards on the optimistic assumption that the page being
343 : : * activated has just been added to this pagevec. Note that only
344 : : * the local pagevec is examined as a !PageLRU page could be in the
345 : : * process of being released, reclaimed, migrated or on a remote
346 : : * pagevec that is currently being drained. Furthermore, marking
347 : : * a remote pagevec's page PageActive potentially hits a race where
348 : : * a page is marked PageActive just after it is added to the inactive
349 : : * list causing accounting errors and BUG_ON checks to trigger.
350 : : */
351 [ + + ]: 41471 : for (i = pagevec_count(pvec) - 1; i >= 0; i--) {
352 : 29939 : struct page *pagevec_page = pvec->pages[i];
353 : :
354 [ + + ]: 29939 : if (pagevec_page == page) {
355 : 26882 : SetPageActive(page);
356 : : break;
357 : : }
358 : : }
359 : :
360 : 38414 : put_cpu_var(lru_add_pvec);
361 : 38414 : }
362 : :
363 : : /*
364 : : * Mark a page as having seen activity.
365 : : *
366 : : * inactive,unreferenced -> inactive,referenced
367 : : * inactive,referenced -> active,unreferenced
368 : : * active,unreferenced -> active,referenced
369 : : *
370 : : * When a newly allocated page is not yet visible, so safe for non-atomic ops,
371 : : * __SetPageReferenced(page) may be substituted for mark_page_accessed(page).
372 : : */
373 : 15867845 : void mark_page_accessed(struct page *page)
374 : : {
375 [ - + ]: 15867845 : page = compound_head(page);
376 : :
377 [ - + + + ]: 31735670 : if (!PageReferenced(page)) {
378 [ - + ]: 539175 : SetPageReferenced(page);
379 [ - + + - ]: 30657340 : } else if (PageUnevictable(page)) {
380 : : /*
381 : : * Unevictable pages are on the "LRU_UNEVICTABLE" list. But,
382 : : * this list is never rotated or maintained, so marking an
383 : : * evictable page accessed has no effect.
384 : : */
385 [ - + + + ]: 30657340 : } else if (!PageActive(page)) {
386 : : /*
387 : : * If the page is on the LRU, queue it for activation via
388 : : * activate_page_pvecs. Otherwise, assume the page is on a
389 : : * pagevec, mark it active and it'll be moved to the active
390 : : * LRU on the next drain.
391 : : */
392 [ - + + + ]: 278372 : if (PageLRU(page))
393 : 100772 : activate_page(page);
394 : : else
395 : 38414 : __lru_cache_activate_page(page);
396 [ - + ]: 139186 : ClearPageReferenced(page);
397 [ + + ]: 139186 : if (page_is_file_cache(page))
398 : 138340 : workingset_activation(page);
399 : : }
400 : 15867845 : if (page_is_idle(page))
401 : : clear_page_idle(page);
402 : 15867845 : }
403 : : EXPORT_SYMBOL(mark_page_accessed);
404 : :
405 : 1663563 : static void __lru_cache_add(struct page *page)
406 : : {
407 : 1663563 : struct pagevec *pvec = &get_cpu_var(lru_add_pvec);
408 : :
409 [ - + ]: 1663563 : get_page(page);
410 [ + + - + ]: 3274195 : if (!pagevec_add(pvec, page) || PageCompound(page))
411 : 52931 : __pagevec_lru_add(pvec);
412 : 1663563 : put_cpu_var(lru_add_pvec);
413 : 1663563 : }
414 : :
415 : : /**
416 : : * lru_cache_add_anon - add a page to the page lists
417 : : * @page: the page to add
418 : : */
419 : 39474 : void lru_cache_add_anon(struct page *page)
420 : : {
421 [ - + - + ]: 78948 : if (PageActive(page))
422 [ # # ]: 0 : ClearPageActive(page);
423 : 39474 : __lru_cache_add(page);
424 : 39474 : }
425 : :
426 : 0 : void lru_cache_add_file(struct page *page)
427 : : {
428 [ # # # # ]: 0 : if (PageActive(page))
429 [ # # ]: 0 : ClearPageActive(page);
430 : 0 : __lru_cache_add(page);
431 : 0 : }
432 : : EXPORT_SYMBOL(lru_cache_add_file);
433 : :
434 : : /**
435 : : * lru_cache_add - add a page to a page list
436 : : * @page: the page to be added to the LRU.
437 : : *
438 : : * Queue the page for addition to the LRU via pagevec. The decision on whether
439 : : * to add the page to the [in]active [file|anon] list is deferred until the
440 : : * pagevec is drained. This gives a chance for the caller of lru_cache_add()
441 : : * have the page added to the active list using mark_page_accessed().
442 : : */
443 : 1624089 : void lru_cache_add(struct page *page)
444 : : {
445 : 1624089 : VM_BUG_ON_PAGE(PageActive(page) && PageUnevictable(page), page);
446 : 1624089 : VM_BUG_ON_PAGE(PageLRU(page), page);
447 : 525560 : __lru_cache_add(page);
448 : 525560 : }
449 : :
450 : : /**
451 : : * lru_cache_add_active_or_unevictable
452 : : * @page: the page to be added to LRU
453 : : * @vma: vma in which page is mapped for determining reclaimability
454 : : *
455 : : * Place @page on the active or unevictable LRU list, depending on its
456 : : * evictability. Note that if the page is not evictable, it goes
457 : : * directly back onto it's zone's unevictable list, it does NOT use a
458 : : * per cpu pagevec.
459 : : */
460 : 1098529 : void lru_cache_add_active_or_unevictable(struct page *page,
461 : : struct vm_area_struct *vma)
462 : : {
463 : 1098529 : VM_BUG_ON_PAGE(PageLRU(page), page);
464 : :
465 [ + - ]: 1098529 : if (likely((vma->vm_flags & (VM_LOCKED | VM_SPECIAL)) != VM_LOCKED))
466 [ - + ]: 1098529 : SetPageActive(page);
467 [ # # # # ]: 0 : else if (!TestSetPageMlocked(page)) {
468 : : /*
469 : : * We use the irq-unsafe __mod_zone_page_stat because this
470 : : * counter is not modified from interrupt context, and the pte
471 : : * lock is held(spinlock), which implies preemption disabled.
472 : : */
473 : 0 : __mod_zone_page_state(page_zone(page), NR_MLOCK,
474 : : hpage_nr_pages(page));
475 : 0 : count_vm_event(UNEVICTABLE_PGMLOCKED);
476 : : }
477 : 1098529 : lru_cache_add(page);
478 : 1098529 : }
479 : :
480 : : /*
481 : : * If the page can not be invalidated, it is moved to the
482 : : * inactive list to speed up its reclaim. It is moved to the
483 : : * head of the list, rather than the tail, to give the flusher
484 : : * threads some time to write it out, as this is much more
485 : : * effective than the single-page writeout from reclaim.
486 : : *
487 : : * If the page isn't page_mapped and dirty/writeback, the page
488 : : * could reclaim asap using PG_reclaim.
489 : : *
490 : : * 1. active, mapped page -> none
491 : : * 2. active, dirty/writeback page -> inactive, head, PG_reclaim
492 : : * 3. inactive, mapped page -> none
493 : : * 4. inactive, dirty/writeback page -> inactive, head, PG_reclaim
494 : : * 5. inactive, clean -> inactive, tail
495 : : * 6. Others -> none
496 : : *
497 : : * In 4, why it moves inactive's head, the VM expects the page would
498 : : * be write it out by flusher threads as this is much more effective
499 : : * than the single-page writeout from reclaim.
500 : : */
501 : 0 : static void lru_deactivate_file_fn(struct page *page, struct lruvec *lruvec,
502 : : void *arg)
503 : : {
504 : 0 : int lru, file;
505 : 0 : bool active;
506 : :
507 [ # # ]: 0 : if (!PageLRU(page))
508 : : return;
509 : :
510 [ # # ]: 0 : if (PageUnevictable(page))
511 : : return;
512 : :
513 : : /* Some processes are using the page */
514 [ # # ]: 0 : if (page_mapped(page))
515 : : return;
516 : :
517 : 0 : active = PageActive(page);
518 : 0 : file = page_is_file_cache(page);
519 : 0 : lru = page_lru_base_type(page);
520 : :
521 : 0 : del_page_from_lru_list(page, lruvec, lru + active);
522 : 0 : ClearPageActive(page);
523 : 0 : ClearPageReferenced(page);
524 : :
525 [ # # # # ]: 0 : if (PageWriteback(page) || PageDirty(page)) {
526 : : /*
527 : : * PG_reclaim could be raced with end_page_writeback
528 : : * It can make readahead confusing. But race window
529 : : * is _really_ small and it's non-critical problem.
530 : : */
531 : 0 : add_page_to_lru_list(page, lruvec, lru);
532 : 0 : SetPageReclaim(page);
533 : : } else {
534 : : /*
535 : : * The page's writeback ends up during pagevec
536 : : * We moves tha page into tail of inactive.
537 : : */
538 : 0 : add_page_to_lru_list_tail(page, lruvec, lru);
539 : 0 : __count_vm_event(PGROTATED);
540 : : }
541 : :
542 [ # # ]: 0 : if (active)
543 : 0 : __count_vm_event(PGDEACTIVATE);
544 : 0 : update_page_reclaim_stat(lruvec, file, 0);
545 : : }
546 : :
547 : 0 : static void lru_deactivate_fn(struct page *page, struct lruvec *lruvec,
548 : : void *arg)
549 : : {
550 [ # # # # : 0 : if (PageLRU(page) && PageActive(page) && !PageUnevictable(page)) {
# # ]
551 : 0 : int file = page_is_file_cache(page);
552 : 0 : int lru = page_lru_base_type(page);
553 : :
554 : 0 : del_page_from_lru_list(page, lruvec, lru + LRU_ACTIVE);
555 : 0 : ClearPageActive(page);
556 : 0 : ClearPageReferenced(page);
557 : 0 : add_page_to_lru_list(page, lruvec, lru);
558 : :
559 : 0 : __count_vm_events(PGDEACTIVATE, hpage_nr_pages(page));
560 : 0 : update_page_reclaim_stat(lruvec, file, 0);
561 : : }
562 : 0 : }
563 : :
564 : 0 : static void lru_lazyfree_fn(struct page *page, struct lruvec *lruvec,
565 : : void *arg)
566 : : {
567 [ # # # # : 0 : if (PageLRU(page) && PageAnon(page) && PageSwapBacked(page) &&
# # ]
568 [ # # ]: 0 : !PageSwapCache(page) && !PageUnevictable(page)) {
569 : 0 : bool active = PageActive(page);
570 : :
571 : 0 : del_page_from_lru_list(page, lruvec,
572 : : LRU_INACTIVE_ANON + active);
573 : 0 : ClearPageActive(page);
574 : 0 : ClearPageReferenced(page);
575 : : /*
576 : : * lazyfree pages are clean anonymous pages. They have
577 : : * SwapBacked flag cleared to distinguish normal anonymous
578 : : * pages
579 : : */
580 : 0 : ClearPageSwapBacked(page);
581 : 0 : add_page_to_lru_list(page, lruvec, LRU_INACTIVE_FILE);
582 : :
583 : 0 : __count_vm_events(PGLAZYFREE, hpage_nr_pages(page));
584 : 0 : count_memcg_page_event(page, PGLAZYFREE);
585 : 0 : update_page_reclaim_stat(lruvec, 1, 0);
586 : : }
587 : 0 : }
588 : :
589 : : /*
590 : : * Drain pages out of the cpu's pagevecs.
591 : : * Either "cpu" is the current CPU, and preemption has already been
592 : : * disabled; or "cpu" is being hot-unplugged, and is already dead.
593 : : */
594 : 589959 : void lru_add_drain_cpu(int cpu)
595 : : {
596 : 589959 : struct pagevec *pvec = &per_cpu(lru_add_pvec, cpu);
597 : :
598 [ + + ]: 589959 : if (pagevec_count(pvec))
599 : 217556 : __pagevec_lru_add(pvec);
600 : :
601 : 589959 : pvec = &per_cpu(lru_rotate_pvecs, cpu);
602 [ - + ]: 589959 : if (pagevec_count(pvec)) {
603 : 0 : unsigned long flags;
604 : :
605 : : /* No harm done if a racing interrupt already did this */
606 : 0 : local_irq_save(flags);
607 : 0 : pagevec_move_tail(pvec);
608 : 0 : local_irq_restore(flags);
609 : : }
610 : :
611 : 589959 : pvec = &per_cpu(lru_deactivate_file_pvecs, cpu);
612 [ - + ]: 589959 : if (pagevec_count(pvec))
613 : 0 : pagevec_lru_move_fn(pvec, lru_deactivate_file_fn, NULL);
614 : :
615 : 589959 : pvec = &per_cpu(lru_deactivate_pvecs, cpu);
616 [ - + ]: 589959 : if (pagevec_count(pvec))
617 : 0 : pagevec_lru_move_fn(pvec, lru_deactivate_fn, NULL);
618 : :
619 : 589959 : pvec = &per_cpu(lru_lazyfree_pvecs, cpu);
620 [ - + ]: 589959 : if (pagevec_count(pvec))
621 : 0 : pagevec_lru_move_fn(pvec, lru_lazyfree_fn, NULL);
622 : :
623 : 589959 : activate_page_drain(cpu);
624 : 589959 : }
625 : :
626 : : /**
627 : : * deactivate_file_page - forcefully deactivate a file page
628 : : * @page: page to deactivate
629 : : *
630 : : * This function hints the VM that @page is a good reclaim candidate,
631 : : * for example if its invalidation fails due to the page being dirty
632 : : * or under writeback.
633 : : */
634 : 0 : void deactivate_file_page(struct page *page)
635 : : {
636 : : /*
637 : : * In a workload with many unevictable page such as mprotect,
638 : : * unevictable page deactivation for accelerating reclaim is pointless.
639 : : */
640 [ # # # # ]: 0 : if (PageUnevictable(page))
641 : : return;
642 : :
643 [ # # ]: 0 : if (likely(get_page_unless_zero(page))) {
644 : 0 : struct pagevec *pvec = &get_cpu_var(lru_deactivate_file_pvecs);
645 : :
646 [ # # # # ]: 0 : if (!pagevec_add(pvec, page) || PageCompound(page))
647 : 0 : pagevec_lru_move_fn(pvec, lru_deactivate_file_fn, NULL);
648 : 0 : put_cpu_var(lru_deactivate_file_pvecs);
649 : : }
650 : : }
651 : :
652 : : /*
653 : : * deactivate_page - deactivate a page
654 : : * @page: page to deactivate
655 : : *
656 : : * deactivate_page() moves @page to the inactive list if @page was on the active
657 : : * list and was not an unevictable page. This is done to accelerate the reclaim
658 : : * of @page.
659 : : */
660 : 0 : void deactivate_page(struct page *page)
661 : : {
662 [ # # # # : 0 : if (PageLRU(page) && PageActive(page) && !PageUnevictable(page)) {
# # # # ]
663 : 0 : struct pagevec *pvec = &get_cpu_var(lru_deactivate_pvecs);
664 : :
665 [ # # ]: 0 : get_page(page);
666 [ # # # # ]: 0 : if (!pagevec_add(pvec, page) || PageCompound(page))
667 : 0 : pagevec_lru_move_fn(pvec, lru_deactivate_fn, NULL);
668 : 0 : put_cpu_var(lru_deactivate_pvecs);
669 : : }
670 : 0 : }
671 : :
672 : : /**
673 : : * mark_page_lazyfree - make an anon page lazyfree
674 : : * @page: page to deactivate
675 : : *
676 : : * mark_page_lazyfree() moves @page to the inactive file list.
677 : : * This is done to accelerate the reclaim of @page.
678 : : */
679 : 0 : void mark_page_lazyfree(struct page *page)
680 : : {
681 [ # # # # : 0 : if (PageLRU(page) && PageAnon(page) && PageSwapBacked(page) &&
# # # # ]
682 [ # # ]: 0 : !PageSwapCache(page) && !PageUnevictable(page)) {
683 : 0 : struct pagevec *pvec = &get_cpu_var(lru_lazyfree_pvecs);
684 : :
685 [ # # ]: 0 : get_page(page);
686 [ # # # # ]: 0 : if (!pagevec_add(pvec, page) || PageCompound(page))
687 : 0 : pagevec_lru_move_fn(pvec, lru_lazyfree_fn, NULL);
688 : 0 : put_cpu_var(lru_lazyfree_pvecs);
689 : : }
690 : 0 : }
691 : :
692 : 589959 : void lru_add_drain(void)
693 : : {
694 : 589959 : lru_add_drain_cpu(get_cpu());
695 : 589959 : put_cpu();
696 : 587403 : }
697 : :
698 : : #ifdef CONFIG_SMP
699 : :
700 : : static DEFINE_PER_CPU(struct work_struct, lru_add_drain_work);
701 : :
702 : 0 : static void lru_add_drain_per_cpu(struct work_struct *dummy)
703 : : {
704 : 0 : lru_add_drain();
705 : 0 : }
706 : :
707 : : /*
708 : : * Doesn't need any cpu hotplug locking because we do rely on per-cpu
709 : : * kworkers being shut down before our page_alloc_cpu_dead callback is
710 : : * executed on the offlined cpu.
711 : : * Calling this function with cpu hotplug locks held can actually lead
712 : : * to obscure indirect dependencies via WQ context.
713 : : */
714 : 0 : void lru_add_drain_all(void)
715 : : {
716 : 0 : static seqcount_t seqcount = SEQCNT_ZERO(seqcount);
717 : 0 : static DEFINE_MUTEX(lock);
718 : 0 : static struct cpumask has_work;
719 : 0 : int cpu, seq;
720 : :
721 : : /*
722 : : * Make sure nobody triggers this path before mm_percpu_wq is fully
723 : : * initialized.
724 : : */
725 [ # # # # ]: 0 : if (WARN_ON(!mm_percpu_wq))
726 : : return;
727 : :
728 : 0 : seq = raw_read_seqcount_latch(&seqcount);
729 : :
730 : 0 : mutex_lock(&lock);
731 : :
732 : : /*
733 : : * Piggyback on drain started and finished while we waited for lock:
734 : : * all pages pended at the time of our enter were drained from vectors.
735 : : */
736 [ # # ]: 0 : if (__read_seqcount_retry(&seqcount, seq))
737 : 0 : goto done;
738 : :
739 : 0 : raw_write_seqcount_latch(&seqcount);
740 : :
741 : 0 : cpumask_clear(&has_work);
742 : :
743 [ # # ]: 0 : for_each_online_cpu(cpu) {
744 : 0 : struct work_struct *work = &per_cpu(lru_add_drain_work, cpu);
745 : :
746 [ # # # # ]: 0 : if (pagevec_count(&per_cpu(lru_add_pvec, cpu)) ||
747 [ # # # # ]: 0 : pagevec_count(&per_cpu(lru_rotate_pvecs, cpu)) ||
748 [ # # # # ]: 0 : pagevec_count(&per_cpu(lru_deactivate_file_pvecs, cpu)) ||
749 [ # # # # ]: 0 : pagevec_count(&per_cpu(lru_deactivate_pvecs, cpu)) ||
750 [ # # # # ]: 0 : pagevec_count(&per_cpu(lru_lazyfree_pvecs, cpu)) ||
751 : : need_activate_page_drain(cpu)) {
752 : 0 : INIT_WORK(work, lru_add_drain_per_cpu);
753 : 0 : queue_work_on(cpu, mm_percpu_wq, work);
754 : 0 : cpumask_set_cpu(cpu, &has_work);
755 : : }
756 : : }
757 : :
758 [ # # ]: 0 : for_each_cpu(cpu, &has_work)
759 : 0 : flush_work(&per_cpu(lru_add_drain_work, cpu));
760 : :
761 : 0 : done:
762 : 0 : mutex_unlock(&lock);
763 : : }
764 : : #else
765 : : void lru_add_drain_all(void)
766 : : {
767 : : lru_add_drain();
768 : : }
769 : : #endif
770 : :
771 : : /**
772 : : * release_pages - batched put_page()
773 : : * @pages: array of pages to release
774 : : * @nr: number of pages
775 : : *
776 : : * Decrement the reference count on all the pages in @pages. If it
777 : : * fell to zero, remove the page from the LRU and free it.
778 : : */
779 : 445906 : void release_pages(struct page **pages, int nr)
780 : : {
781 : 445906 : int i;
782 : 445906 : LIST_HEAD(pages_to_free);
783 : 445906 : struct pglist_data *locked_pgdat = NULL;
784 : 445906 : struct lruvec *lruvec;
785 : 445906 : unsigned long uninitialized_var(flags);
786 : 445906 : unsigned int uninitialized_var(lock_batch);
787 : :
788 [ + + ]: 20372966 : for (i = 0; i < nr; i++) {
789 : 19927060 : struct page *page = pages[i];
790 : :
791 : : /*
792 : : * Make sure the IRQ-safe lock-holding time does not get
793 : : * excessive with a continuous string of pages from the
794 : : * same pgdat. The lock is held only if pgdat != NULL.
795 : : */
796 [ + + + + ]: 19927060 : if (locked_pgdat && ++lock_batch == SWAP_CLUSTER_MAX) {
797 : 114804 : spin_unlock_irqrestore(&locked_pgdat->lru_lock, flags);
798 : 114804 : locked_pgdat = NULL;
799 : : }
800 : :
801 [ - + ]: 19927060 : if (is_huge_zero_page(page))
802 : : continue;
803 : :
804 [ - + ]: 19927060 : if (is_zone_device_page(page)) {
805 : : if (locked_pgdat) {
806 : : spin_unlock_irqrestore(&locked_pgdat->lru_lock,
807 : : flags);
808 : : locked_pgdat = NULL;
809 : : }
810 : : /*
811 : : * ZONE_DEVICE pages that return 'false' from
812 : : * put_devmap_managed_page() do not require special
813 : : * processing, and instead, expect a call to
814 : : * put_page_testzero().
815 : : */
816 : : if (page_is_devmap_managed(page)) {
817 : : put_devmap_managed_page(page);
818 : : continue;
819 : : }
820 : : }
821 : :
822 [ - + ]: 19927060 : page = compound_head(page);
823 [ + + ]: 19927060 : if (!put_page_testzero(page))
824 : 18270083 : continue;
825 : :
826 [ - + ]: 3313954 : if (PageCompound(page)) {
827 [ # # ]: 0 : if (locked_pgdat) {
828 : 0 : spin_unlock_irqrestore(&locked_pgdat->lru_lock, flags);
829 : 0 : locked_pgdat = NULL;
830 : : }
831 : 0 : __put_compound_page(page);
832 : 0 : continue;
833 : : }
834 : :
835 [ - + + + ]: 3313954 : if (PageLRU(page)) {
836 [ + + ]: 1037809 : struct pglist_data *pgdat = page_pgdat(page);
837 : :
838 [ + + ]: 1037809 : if (pgdat != locked_pgdat) {
839 [ - + ]: 176473 : if (locked_pgdat)
840 : 0 : spin_unlock_irqrestore(&locked_pgdat->lru_lock,
841 : : flags);
842 : 176473 : lock_batch = 0;
843 : 176473 : locked_pgdat = pgdat;
844 : 176473 : spin_lock_irqsave(&locked_pgdat->lru_lock, flags);
845 : : }
846 : :
847 [ - + ]: 1037809 : lruvec = mem_cgroup_page_lruvec(page, locked_pgdat);
848 : 1037809 : VM_BUG_ON_PAGE(!PageLRU(page), page);
849 [ - + ]: 1037809 : __ClearPageLRU(page);
850 [ - + ]: 1037809 : del_page_from_lru_list(page, lruvec, page_off_lru(page));
851 : : }
852 : :
853 : : /* Clear Active bit in case of parallel mark_page_accessed */
854 [ - + ]: 1656977 : __ClearPageActive(page);
855 : 1656977 : __ClearPageWaiters(page);
856 : :
857 : 1656977 : list_add(&page->lru, &pages_to_free);
858 : : }
859 [ + + ]: 445906 : if (locked_pgdat)
860 : 61669 : spin_unlock_irqrestore(&locked_pgdat->lru_lock, flags);
861 : :
862 : 445906 : mem_cgroup_uncharge_list(&pages_to_free);
863 : 445906 : free_unref_page_list(&pages_to_free);
864 : 445906 : }
865 : : EXPORT_SYMBOL(release_pages);
866 : :
867 : : /*
868 : : * The pages which we're about to release may be in the deferred lru-addition
869 : : * queues. That would prevent them from really being freed right now. That's
870 : : * OK from a correctness point of view but is inefficient - those pages may be
871 : : * cache-warm and we want to give them back to the page allocator ASAP.
872 : : *
873 : : * So __pagevec_release() will drain those queues here. __pagevec_lru_add()
874 : : * and __pagevec_lru_add_active() call release_pages() directly to avoid
875 : : * mutual recursion.
876 : : */
877 : 3576 : void __pagevec_release(struct pagevec *pvec)
878 : : {
879 [ + + ]: 3576 : if (!pvec->percpu_pvec_drained) {
880 : 2556 : lru_add_drain();
881 : 2556 : pvec->percpu_pvec_drained = true;
882 : : }
883 : 3576 : release_pages(pvec->pages, pagevec_count(pvec));
884 : 3576 : pagevec_reinit(pvec);
885 : 3576 : }
886 : : EXPORT_SYMBOL(__pagevec_release);
887 : :
888 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
889 : : /* used by __split_huge_page_refcount() */
890 : : void lru_add_page_tail(struct page *page, struct page *page_tail,
891 : : struct lruvec *lruvec, struct list_head *list)
892 : : {
893 : : const int file = 0;
894 : :
895 : : VM_BUG_ON_PAGE(!PageHead(page), page);
896 : : VM_BUG_ON_PAGE(PageCompound(page_tail), page);
897 : : VM_BUG_ON_PAGE(PageLRU(page_tail), page);
898 : : lockdep_assert_held(&lruvec_pgdat(lruvec)->lru_lock);
899 : :
900 : : if (!list)
901 : : SetPageLRU(page_tail);
902 : :
903 : : if (likely(PageLRU(page)))
904 : : list_add_tail(&page_tail->lru, &page->lru);
905 : : else if (list) {
906 : : /* page reclaim is reclaiming a huge page */
907 : : get_page(page_tail);
908 : : list_add_tail(&page_tail->lru, list);
909 : : } else {
910 : : /*
911 : : * Head page has not yet been counted, as an hpage,
912 : : * so we must account for each subpage individually.
913 : : *
914 : : * Put page_tail on the list at the correct position
915 : : * so they all end up in order.
916 : : */
917 : : add_page_to_lru_list_tail(page_tail, lruvec,
918 : : page_lru(page_tail));
919 : : }
920 : :
921 : : if (!PageUnevictable(page))
922 : : update_page_reclaim_stat(lruvec, file, PageActive(page_tail));
923 : : }
924 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
925 : :
926 : 1663413 : static void __pagevec_lru_add_fn(struct page *page, struct lruvec *lruvec,
927 : : void *arg)
928 : : {
929 : 1663413 : enum lru_list lru;
930 [ - + ]: 1663413 : int was_unevictable = TestClearPageUnevictable(page);
931 : :
932 : 1663413 : VM_BUG_ON_PAGE(PageLRU(page), page);
933 : :
934 [ - + ]: 1663413 : SetPageLRU(page);
935 : : /*
936 : : * Page becomes evictable in two ways:
937 : : * 1) Within LRU lock [munlock_vma_page() and __munlock_pagevec()].
938 : : * 2) Before acquiring LRU lock to put the page to correct LRU and then
939 : : * a) do PageLRU check with lock [check_move_unevictable_pages]
940 : : * b) do PageLRU check before lock [clear_page_mlock]
941 : : *
942 : : * (1) & (2a) are ok as LRU lock will serialize them. For (2b), we need
943 : : * following strict ordering:
944 : : *
945 : : * #0: __pagevec_lru_add_fn #1: clear_page_mlock
946 : : *
947 : : * SetPageLRU() TestClearPageMlocked()
948 : : * smp_mb() // explicit ordering // above provides strict
949 : : * // ordering
950 : : * PageMlocked() PageLRU()
951 : : *
952 : : *
953 : : * if '#1' does not observe setting of PG_lru by '#0' and fails
954 : : * isolation, the explicit barrier will make sure that page_evictable
955 : : * check will put the page in correct LRU. Without smp_mb(), SetPageLRU
956 : : * can be reordered after PageMlocked check and can make '#1' to fail
957 : : * the isolation of the page whose Mlocked bit is cleared (#0 is also
958 : : * looking at the same page) and the evictable page will be stranded
959 : : * in an unevictable LRU.
960 : : */
961 : 1663413 : smp_mb();
962 : :
963 [ + - ]: 1663413 : if (page_evictable(page)) {
964 [ - + ]: 1663413 : lru = page_lru(page);
965 [ - + ]: 3326826 : update_page_reclaim_stat(lruvec, page_is_file_cache(page),
966 : : PageActive(page));
967 [ - + ]: 1663413 : if (was_unevictable)
968 : 0 : count_vm_event(UNEVICTABLE_PGRESCUED);
969 : : } else {
970 : 0 : lru = LRU_UNEVICTABLE;
971 [ # # ]: 0 : ClearPageActive(page);
972 [ # # ]: 0 : SetPageUnevictable(page);
973 [ # # ]: 0 : if (!was_unevictable)
974 : 0 : count_vm_event(UNEVICTABLE_PGCULLED);
975 : : }
976 : :
977 : 1663413 : add_page_to_lru_list(page, lruvec, lru);
978 : 1663413 : trace_mm_lru_insertion(page, lru);
979 : 1663413 : }
980 : :
981 : : /*
982 : : * Add the passed pages to the LRU, then drop the caller's refcount
983 : : * on them. Reinitialises the caller's pagevec.
984 : : */
985 : 270487 : void __pagevec_lru_add(struct pagevec *pvec)
986 : : {
987 : 270487 : pagevec_lru_move_fn(pvec, __pagevec_lru_add_fn, NULL);
988 : 270487 : }
989 : : EXPORT_SYMBOL(__pagevec_lru_add);
990 : :
991 : : /**
992 : : * pagevec_lookup_entries - gang pagecache lookup
993 : : * @pvec: Where the resulting entries are placed
994 : : * @mapping: The address_space to search
995 : : * @start: The starting entry index
996 : : * @nr_entries: The maximum number of pages
997 : : * @indices: The cache indices corresponding to the entries in @pvec
998 : : *
999 : : * pagevec_lookup_entries() will search for and return a group of up
1000 : : * to @nr_pages pages and shadow entries in the mapping. All
1001 : : * entries are placed in @pvec. pagevec_lookup_entries() takes a
1002 : : * reference against actual pages in @pvec.
1003 : : *
1004 : : * The search returns a group of mapping-contiguous entries with
1005 : : * ascending indexes. There may be holes in the indices due to
1006 : : * not-present entries.
1007 : : *
1008 : : * pagevec_lookup_entries() returns the number of entries which were
1009 : : * found.
1010 : : */
1011 : 2100 : unsigned pagevec_lookup_entries(struct pagevec *pvec,
1012 : : struct address_space *mapping,
1013 : : pgoff_t start, unsigned nr_entries,
1014 : : pgoff_t *indices)
1015 : : {
1016 : 4200 : pvec->nr = find_get_entries(mapping, start, nr_entries,
1017 : 2100 : pvec->pages, indices);
1018 : 2100 : return pagevec_count(pvec);
1019 : : }
1020 : :
1021 : : /**
1022 : : * pagevec_remove_exceptionals - pagevec exceptionals pruning
1023 : : * @pvec: The pagevec to prune
1024 : : *
1025 : : * pagevec_lookup_entries() fills both pages and exceptional radix
1026 : : * tree entries into the pagevec. This function prunes all
1027 : : * exceptionals from @pvec without leaving holes, so that it can be
1028 : : * passed on to page-only pagevec operations.
1029 : : */
1030 : 1026 : void pagevec_remove_exceptionals(struct pagevec *pvec)
1031 : : {
1032 : 1026 : int i, j;
1033 : :
1034 [ + + ]: 2052 : for (i = 0, j = 0; i < pagevec_count(pvec); i++) {
1035 : 1026 : struct page *page = pvec->pages[i];
1036 [ + - ]: 1026 : if (!xa_is_value(page))
1037 : 1026 : pvec->pages[j++] = page;
1038 : : }
1039 : 1026 : pvec->nr = j;
1040 : 1026 : }
1041 : :
1042 : : /**
1043 : : * pagevec_lookup_range - gang pagecache lookup
1044 : : * @pvec: Where the resulting pages are placed
1045 : : * @mapping: The address_space to search
1046 : : * @start: The starting page index
1047 : : * @end: The final page index
1048 : : *
1049 : : * pagevec_lookup_range() will search for & return a group of up to PAGEVEC_SIZE
1050 : : * pages in the mapping starting from index @start and upto index @end
1051 : : * (inclusive). The pages are placed in @pvec. pagevec_lookup() takes a
1052 : : * reference against the pages in @pvec.
1053 : : *
1054 : : * The search returns a group of mapping-contiguous pages with ascending
1055 : : * indexes. There may be holes in the indices due to not-present pages. We
1056 : : * also update @start to index the next page for the traversal.
1057 : : *
1058 : : * pagevec_lookup_range() returns the number of pages which were found. If this
1059 : : * number is smaller than PAGEVEC_SIZE, the end of specified range has been
1060 : : * reached.
1061 : : */
1062 : 13086 : unsigned pagevec_lookup_range(struct pagevec *pvec,
1063 : : struct address_space *mapping, pgoff_t *start, pgoff_t end)
1064 : : {
1065 : 26172 : pvec->nr = find_get_pages_range(mapping, start, end, PAGEVEC_SIZE,
1066 : 13086 : pvec->pages);
1067 : 13086 : return pagevec_count(pvec);
1068 : : }
1069 : : EXPORT_SYMBOL(pagevec_lookup_range);
1070 : :
1071 : 1230 : unsigned pagevec_lookup_range_tag(struct pagevec *pvec,
1072 : : struct address_space *mapping, pgoff_t *index, pgoff_t end,
1073 : : xa_mark_t tag)
1074 : : {
1075 : 2460 : pvec->nr = find_get_pages_range_tag(mapping, index, end, tag,
1076 : 1230 : PAGEVEC_SIZE, pvec->pages);
1077 : 1230 : return pagevec_count(pvec);
1078 : : }
1079 : : EXPORT_SYMBOL(pagevec_lookup_range_tag);
1080 : :
1081 : 0 : unsigned pagevec_lookup_range_nr_tag(struct pagevec *pvec,
1082 : : struct address_space *mapping, pgoff_t *index, pgoff_t end,
1083 : : xa_mark_t tag, unsigned max_pages)
1084 : : {
1085 : 0 : pvec->nr = find_get_pages_range_tag(mapping, index, end, tag,
1086 : 0 : min_t(unsigned int, max_pages, PAGEVEC_SIZE), pvec->pages);
1087 : 0 : return pagevec_count(pvec);
1088 : : }
1089 : : EXPORT_SYMBOL(pagevec_lookup_range_nr_tag);
1090 : : /*
1091 : : * Perform any setup for the swap system
1092 : : */
1093 : 30 : void __init swap_setup(void)
1094 : : {
1095 : 30 : unsigned long megs = totalram_pages() >> (20 - PAGE_SHIFT);
1096 : :
1097 : : /* Use a smaller cluster for small-memory machines */
1098 [ - + ]: 30 : if (megs < 16)
1099 : 0 : page_cluster = 2;
1100 : : else
1101 : 30 : page_cluster = 3;
1102 : : /*
1103 : : * Right now other parts of the system means that we
1104 : : * _really_ don't want to cluster much more
1105 : : */
1106 : 30 : }
1107 : :
1108 : : #ifdef CONFIG_DEV_PAGEMAP_OPS
1109 : : void put_devmap_managed_page(struct page *page)
1110 : : {
1111 : : int count;
1112 : :
1113 : : if (WARN_ON_ONCE(!page_is_devmap_managed(page)))
1114 : : return;
1115 : :
1116 : : count = page_ref_dec_return(page);
1117 : :
1118 : : /*
1119 : : * devmap page refcounts are 1-based, rather than 0-based: if
1120 : : * refcount is 1, then the page is free and the refcount is
1121 : : * stable because nobody holds a reference on the page.
1122 : : */
1123 : : if (count == 1)
1124 : : free_devmap_managed_page(page);
1125 : : else if (!count)
1126 : : __put_page(page);
1127 : : }
1128 : : EXPORT_SYMBOL(put_devmap_managed_page);
1129 : : #endif
|
