ALSA: virtio: use module_virtio_driver() to simplify the code
[linux-2.6-microblaze.git] / mm / vmscan.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
4  *
5  *  Swap reorganised 29.12.95, Stephen Tweedie.
6  *  kswapd added: 7.1.96  sct
7  *  Removed kswapd_ctl limits, and swap out as many pages as needed
8  *  to bring the system back to freepages.high: 2.4.97, Rik van Riel.
9  *  Zone aware kswapd started 02/00, Kanoj Sarcar (kanoj@sgi.com).
10  *  Multiqueue VM started 5.8.00, Rik van Riel.
11  */
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15 #include <linux/mm.h>
16 #include <linux/sched/mm.h>
17 #include <linux/module.h>
18 #include <linux/gfp.h>
19 #include <linux/kernel_stat.h>
20 #include <linux/swap.h>
21 #include <linux/pagemap.h>
22 #include <linux/init.h>
23 #include <linux/highmem.h>
24 #include <linux/vmpressure.h>
25 #include <linux/vmstat.h>
26 #include <linux/file.h>
27 #include <linux/writeback.h>
28 #include <linux/blkdev.h>
29 #include <linux/buffer_head.h>  /* for try_to_release_page(),
30                                         buffer_heads_over_limit */
31 #include <linux/mm_inline.h>
32 #include <linux/backing-dev.h>
33 #include <linux/rmap.h>
34 #include <linux/topology.h>
35 #include <linux/cpu.h>
36 #include <linux/cpuset.h>
37 #include <linux/compaction.h>
38 #include <linux/notifier.h>
39 #include <linux/rwsem.h>
40 #include <linux/delay.h>
41 #include <linux/kthread.h>
42 #include <linux/freezer.h>
43 #include <linux/memcontrol.h>
44 #include <linux/delayacct.h>
45 #include <linux/sysctl.h>
46 #include <linux/oom.h>
47 #include <linux/pagevec.h>
48 #include <linux/prefetch.h>
49 #include <linux/printk.h>
50 #include <linux/dax.h>
51 #include <linux/psi.h>
52
53 #include <asm/tlbflush.h>
54 #include <asm/div64.h>
55
56 #include <linux/swapops.h>
57 #include <linux/balloon_compaction.h>
58
59 #include "internal.h"
60
61 #define CREATE_TRACE_POINTS
62 #include <trace/events/vmscan.h>
63
64 struct scan_control {
65         /* How many pages shrink_list() should reclaim */
66         unsigned long nr_to_reclaim;
67
68         /*
69          * Nodemask of nodes allowed by the caller. If NULL, all nodes
70          * are scanned.
71          */
72         nodemask_t      *nodemask;
73
74         /*
75          * The memory cgroup that hit its limit and as a result is the
76          * primary target of this reclaim invocation.
77          */
78         struct mem_cgroup *target_mem_cgroup;
79
80         /*
81          * Scan pressure balancing between anon and file LRUs
82          */
83         unsigned long   anon_cost;
84         unsigned long   file_cost;
85
86         /* Can active pages be deactivated as part of reclaim? */
87 #define DEACTIVATE_ANON 1
88 #define DEACTIVATE_FILE 2
89         unsigned int may_deactivate:2;
90         unsigned int force_deactivate:1;
91         unsigned int skipped_deactivate:1;
92
93         /* Writepage batching in laptop mode; RECLAIM_WRITE */
94         unsigned int may_writepage:1;
95
96         /* Can mapped pages be reclaimed? */
97         unsigned int may_unmap:1;
98
99         /* Can pages be swapped as part of reclaim? */
100         unsigned int may_swap:1;
101
102         /*
103          * Cgroups are not reclaimed below their configured memory.low,
104          * unless we threaten to OOM. If any cgroups are skipped due to
105          * memory.low and nothing was reclaimed, go back for memory.low.
106          */
107         unsigned int memcg_low_reclaim:1;
108         unsigned int memcg_low_skipped:1;
109
110         unsigned int hibernation_mode:1;
111
112         /* One of the zones is ready for compaction */
113         unsigned int compaction_ready:1;
114
115         /* There is easily reclaimable cold cache in the current node */
116         unsigned int cache_trim_mode:1;
117
118         /* The file pages on the current node are dangerously low */
119         unsigned int file_is_tiny:1;
120
121         /* Allocation order */
122         s8 order;
123
124         /* Scan (total_size >> priority) pages at once */
125         s8 priority;
126
127         /* The highest zone to isolate pages for reclaim from */
128         s8 reclaim_idx;
129
130         /* This context's GFP mask */
131         gfp_t gfp_mask;
132
133         /* Incremented by the number of inactive pages that were scanned */
134         unsigned long nr_scanned;
135
136         /* Number of pages freed so far during a call to shrink_zones() */
137         unsigned long nr_reclaimed;
138
139         struct {
140                 unsigned int dirty;
141                 unsigned int unqueued_dirty;
142                 unsigned int congested;
143                 unsigned int writeback;
144                 unsigned int immediate;
145                 unsigned int file_taken;
146                 unsigned int taken;
147         } nr;
148
149         /* for recording the reclaimed slab by now */
150         struct reclaim_state reclaim_state;
151 };
152
153 #ifdef ARCH_HAS_PREFETCHW
154 #define prefetchw_prev_lru_page(_page, _base, _field)                   \
155         do {                                                            \
156                 if ((_page)->lru.prev != _base) {                       \
157                         struct page *prev;                              \
158                                                                         \
159                         prev = lru_to_page(&(_page->lru));              \
160                         prefetchw(&prev->_field);                       \
161                 }                                                       \
162         } while (0)
163 #else
164 #define prefetchw_prev_lru_page(_page, _base, _field) do { } while (0)
165 #endif
166
167 /*
168  * From 0 .. 200.  Higher means more swappy.
169  */
170 int vm_swappiness = 60;
171
172 static void set_task_reclaim_state(struct task_struct *task,
173                                    struct reclaim_state *rs)
174 {
175         /* Check for an overwrite */
176         WARN_ON_ONCE(rs && task->reclaim_state);
177
178         /* Check for the nulling of an already-nulled member */
179         WARN_ON_ONCE(!rs && !task->reclaim_state);
180
181         task->reclaim_state = rs;
182 }
183
184 static LIST_HEAD(shrinker_list);
185 static DECLARE_RWSEM(shrinker_rwsem);
186
187 #ifdef CONFIG_MEMCG
188 /*
189  * We allow subsystems to populate their shrinker-related
190  * LRU lists before register_shrinker_prepared() is called
191  * for the shrinker, since we don't want to impose
192  * restrictions on their internal registration order.
193  * In this case shrink_slab_memcg() may find corresponding
194  * bit is set in the shrinkers map.
195  *
196  * This value is used by the function to detect registering
197  * shrinkers and to skip do_shrink_slab() calls for them.
198  */
199 #define SHRINKER_REGISTERING ((struct shrinker *)~0UL)
200
201 static DEFINE_IDR(shrinker_idr);
202 static int shrinker_nr_max;
203
204 static int prealloc_memcg_shrinker(struct shrinker *shrinker)
205 {
206         int id, ret = -ENOMEM;
207
208         down_write(&shrinker_rwsem);
209         /* This may call shrinker, so it must use down_read_trylock() */
210         id = idr_alloc(&shrinker_idr, SHRINKER_REGISTERING, 0, 0, GFP_KERNEL);
211         if (id < 0)
212                 goto unlock;
213
214         if (id >= shrinker_nr_max) {
215                 if (memcg_expand_shrinker_maps(id)) {
216                         idr_remove(&shrinker_idr, id);
217                         goto unlock;
218                 }
219
220                 shrinker_nr_max = id + 1;
221         }
222         shrinker->id = id;
223         ret = 0;
224 unlock:
225         up_write(&shrinker_rwsem);
226         return ret;
227 }
228
229 static void unregister_memcg_shrinker(struct shrinker *shrinker)
230 {
231         int id = shrinker->id;
232
233         BUG_ON(id < 0);
234
235         down_write(&shrinker_rwsem);
236         idr_remove(&shrinker_idr, id);
237         up_write(&shrinker_rwsem);
238 }
239
240 static bool cgroup_reclaim(struct scan_control *sc)
241 {
242         return sc->target_mem_cgroup;
243 }
244
245 /**
246  * writeback_throttling_sane - is the usual dirty throttling mechanism available?
247  * @sc: scan_control in question
248  *
249  * The normal page dirty throttling mechanism in balance_dirty_pages() is
250  * completely broken with the legacy memcg and direct stalling in
251  * shrink_page_list() is used for throttling instead, which lacks all the
252  * niceties such as fairness, adaptive pausing, bandwidth proportional
253  * allocation and configurability.
254  *
255  * This function tests whether the vmscan currently in progress can assume
256  * that the normal dirty throttling mechanism is operational.
257  */
258 static bool writeback_throttling_sane(struct scan_control *sc)
259 {
260         if (!cgroup_reclaim(sc))
261                 return true;
262 #ifdef CONFIG_CGROUP_WRITEBACK
263         if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
264                 return true;
265 #endif
266         return false;
267 }
268 #else
269 static int prealloc_memcg_shrinker(struct shrinker *shrinker)
270 {
271         return 0;
272 }
273
274 static void unregister_memcg_shrinker(struct shrinker *shrinker)
275 {
276 }
277
278 static bool cgroup_reclaim(struct scan_control *sc)
279 {
280         return false;
281 }
282
283 static bool writeback_throttling_sane(struct scan_control *sc)
284 {
285         return true;
286 }
287 #endif
288
289 /*
290  * This misses isolated pages which are not accounted for to save counters.
291  * As the data only determines if reclaim or compaction continues, it is
292  * not expected that isolated pages will be a dominating factor.
293  */
294 unsigned long zone_reclaimable_pages(struct zone *zone)
295 {
296         unsigned long nr;
297
298         nr = zone_page_state_snapshot(zone, NR_ZONE_INACTIVE_FILE) +
299                 zone_page_state_snapshot(zone, NR_ZONE_ACTIVE_FILE);
300         if (get_nr_swap_pages() > 0)
301                 nr += zone_page_state_snapshot(zone, NR_ZONE_INACTIVE_ANON) +
302                         zone_page_state_snapshot(zone, NR_ZONE_ACTIVE_ANON);
303
304         return nr;
305 }
306
307 /**
308  * lruvec_lru_size -  Returns the number of pages on the given LRU list.
309  * @lruvec: lru vector
310  * @lru: lru to use
311  * @zone_idx: zones to consider (use MAX_NR_ZONES for the whole LRU list)
312  */
313 static unsigned long lruvec_lru_size(struct lruvec *lruvec, enum lru_list lru,
314                                      int zone_idx)
315 {
316         unsigned long size = 0;
317         int zid;
318
319         for (zid = 0; zid <= zone_idx && zid < MAX_NR_ZONES; zid++) {
320                 struct zone *zone = &lruvec_pgdat(lruvec)->node_zones[zid];
321
322                 if (!managed_zone(zone))
323                         continue;
324
325                 if (!mem_cgroup_disabled())
326                         size += mem_cgroup_get_zone_lru_size(lruvec, lru, zid);
327                 else
328                         size += zone_page_state(zone, NR_ZONE_LRU_BASE + lru);
329         }
330         return size;
331 }
332
333 /*
334  * Add a shrinker callback to be called from the vm.
335  */
336 int prealloc_shrinker(struct shrinker *shrinker)
337 {
338         unsigned int size = sizeof(*shrinker->nr_deferred);
339
340         if (shrinker->flags & SHRINKER_NUMA_AWARE)
341                 size *= nr_node_ids;
342
343         shrinker->nr_deferred = kzalloc(size, GFP_KERNEL);
344         if (!shrinker->nr_deferred)
345                 return -ENOMEM;
346
347         if (shrinker->flags & SHRINKER_MEMCG_AWARE) {
348                 if (prealloc_memcg_shrinker(shrinker))
349                         goto free_deferred;
350         }
351
352         return 0;
353
354 free_deferred:
355         kfree(shrinker->nr_deferred);
356         shrinker->nr_deferred = NULL;
357         return -ENOMEM;
358 }
359
360 void free_prealloced_shrinker(struct shrinker *shrinker)
361 {
362         if (!shrinker->nr_deferred)
363                 return;
364
365         if (shrinker->flags & SHRINKER_MEMCG_AWARE)
366                 unregister_memcg_shrinker(shrinker);
367
368         kfree(shrinker->nr_deferred);
369         shrinker->nr_deferred = NULL;
370 }
371
372 void register_shrinker_prepared(struct shrinker *shrinker)
373 {
374         down_write(&shrinker_rwsem);
375         list_add_tail(&shrinker->list, &shrinker_list);
376 #ifdef CONFIG_MEMCG
377         if (shrinker->flags & SHRINKER_MEMCG_AWARE)
378                 idr_replace(&shrinker_idr, shrinker, shrinker->id);
379 #endif
380         up_write(&shrinker_rwsem);
381 }
382
383 int register_shrinker(struct shrinker *shrinker)
384 {
385         int err = prealloc_shrinker(shrinker);
386
387         if (err)
388                 return err;
389         register_shrinker_prepared(shrinker);
390         return 0;
391 }
392 EXPORT_SYMBOL(register_shrinker);
393
394 /*
395  * Remove one
396  */
397 void unregister_shrinker(struct shrinker *shrinker)
398 {
399         if (!shrinker->nr_deferred)
400                 return;
401         if (shrinker->flags & SHRINKER_MEMCG_AWARE)
402                 unregister_memcg_shrinker(shrinker);
403         down_write(&shrinker_rwsem);
404         list_del(&shrinker->list);
405         up_write(&shrinker_rwsem);
406         kfree(shrinker->nr_deferred);
407         shrinker->nr_deferred = NULL;
408 }
409 EXPORT_SYMBOL(unregister_shrinker);
410
411 #define SHRINK_BATCH 128
412
413 static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
414                                     struct shrinker *shrinker, int priority)
415 {
416         unsigned long freed = 0;
417         unsigned long long delta;
418         long total_scan;
419         long freeable;
420         long nr;
421         long new_nr;
422         int nid = shrinkctl->nid;
423         long batch_size = shrinker->batch ? shrinker->batch
424                                           : SHRINK_BATCH;
425         long scanned = 0, next_deferred;
426
427         if (!(shrinker->flags & SHRINKER_NUMA_AWARE))
428                 nid = 0;
429
430         freeable = shrinker->count_objects(shrinker, shrinkctl);
431         if (freeable == 0 || freeable == SHRINK_EMPTY)
432                 return freeable;
433
434         /*
435          * copy the current shrinker scan count into a local variable
436          * and zero it so that other concurrent shrinker invocations
437          * don't also do this scanning work.
438          */
439         nr = atomic_long_xchg(&shrinker->nr_deferred[nid], 0);
440
441         total_scan = nr;
442         if (shrinker->seeks) {
443                 delta = freeable >> priority;
444                 delta *= 4;
445                 do_div(delta, shrinker->seeks);
446         } else {
447                 /*
448                  * These objects don't require any IO to create. Trim
449                  * them aggressively under memory pressure to keep
450                  * them from causing refetches in the IO caches.
451                  */
452                 delta = freeable / 2;
453         }
454
455         total_scan += delta;
456         if (total_scan < 0) {
457                 pr_err("shrink_slab: %pS negative objects to delete nr=%ld\n",
458                        shrinker->scan_objects, total_scan);
459                 total_scan = freeable;
460                 next_deferred = nr;
461         } else
462                 next_deferred = total_scan;
463
464         /*
465          * We need to avoid excessive windup on filesystem shrinkers
466          * due to large numbers of GFP_NOFS allocations causing the
467          * shrinkers to return -1 all the time. This results in a large
468          * nr being built up so when a shrink that can do some work
469          * comes along it empties the entire cache due to nr >>>
470          * freeable. This is bad for sustaining a working set in
471          * memory.
472          *
473          * Hence only allow the shrinker to scan the entire cache when
474          * a large delta change is calculated directly.
475          */
476         if (delta < freeable / 4)
477                 total_scan = min(total_scan, freeable / 2);
478
479         /*
480          * Avoid risking looping forever due to too large nr value:
481          * never try to free more than twice the estimate number of
482          * freeable entries.
483          */
484         if (total_scan > freeable * 2)
485                 total_scan = freeable * 2;
486
487         trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,
488                                    freeable, delta, total_scan, priority);
489
490         /*
491          * Normally, we should not scan less than batch_size objects in one
492          * pass to avoid too frequent shrinker calls, but if the slab has less
493          * than batch_size objects in total and we are really tight on memory,
494          * we will try to reclaim all available objects, otherwise we can end
495          * up failing allocations although there are plenty of reclaimable
496          * objects spread over several slabs with usage less than the
497          * batch_size.
498          *
499          * We detect the "tight on memory" situations by looking at the total
500          * number of objects we want to scan (total_scan). If it is greater
501          * than the total number of objects on slab (freeable), we must be
502          * scanning at high prio and therefore should try to reclaim as much as
503          * possible.
504          */
505         while (total_scan >= batch_size ||
506                total_scan >= freeable) {
507                 unsigned long ret;
508                 unsigned long nr_to_scan = min(batch_size, total_scan);
509
510                 shrinkctl->nr_to_scan = nr_to_scan;
511                 shrinkctl->nr_scanned = nr_to_scan;
512                 ret = shrinker->scan_objects(shrinker, shrinkctl);
513                 if (ret == SHRINK_STOP)
514                         break;
515                 freed += ret;
516
517                 count_vm_events(SLABS_SCANNED, shrinkctl->nr_scanned);
518                 total_scan -= shrinkctl->nr_scanned;
519                 scanned += shrinkctl->nr_scanned;
520
521                 cond_resched();
522         }
523
524         if (next_deferred >= scanned)
525                 next_deferred -= scanned;
526         else
527                 next_deferred = 0;
528         /*
529          * move the unused scan count back into the shrinker in a
530          * manner that handles concurrent updates. If we exhausted the
531          * scan, there is no need to do an update.
532          */
533         if (next_deferred > 0)
534                 new_nr = atomic_long_add_return(next_deferred,
535                                                 &shrinker->nr_deferred[nid]);
536         else
537                 new_nr = atomic_long_read(&shrinker->nr_deferred[nid]);
538
539         trace_mm_shrink_slab_end(shrinker, nid, freed, nr, new_nr, total_scan);
540         return freed;
541 }
542
543 #ifdef CONFIG_MEMCG
544 static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
545                         struct mem_cgroup *memcg, int priority)
546 {
547         struct memcg_shrinker_map *map;
548         unsigned long ret, freed = 0;
549         int i;
550
551         if (!mem_cgroup_online(memcg))
552                 return 0;
553
554         if (!down_read_trylock(&shrinker_rwsem))
555                 return 0;
556
557         map = rcu_dereference_protected(memcg->nodeinfo[nid]->shrinker_map,
558                                         true);
559         if (unlikely(!map))
560                 goto unlock;
561
562         for_each_set_bit(i, map->map, shrinker_nr_max) {
563                 struct shrink_control sc = {
564                         .gfp_mask = gfp_mask,
565                         .nid = nid,
566                         .memcg = memcg,
567                 };
568                 struct shrinker *shrinker;
569
570                 shrinker = idr_find(&shrinker_idr, i);
571                 if (unlikely(!shrinker || shrinker == SHRINKER_REGISTERING)) {
572                         if (!shrinker)
573                                 clear_bit(i, map->map);
574                         continue;
575                 }
576
577                 /* Call non-slab shrinkers even though kmem is disabled */
578                 if (!memcg_kmem_enabled() &&
579                     !(shrinker->flags & SHRINKER_NONSLAB))
580                         continue;
581
582                 ret = do_shrink_slab(&sc, shrinker, priority);
583                 if (ret == SHRINK_EMPTY) {
584                         clear_bit(i, map->map);
585                         /*
586                          * After the shrinker reported that it had no objects to
587                          * free, but before we cleared the corresponding bit in
588                          * the memcg shrinker map, a new object might have been
589                          * added. To make sure, we have the bit set in this
590                          * case, we invoke the shrinker one more time and reset
591                          * the bit if it reports that it is not empty anymore.
592                          * The memory barrier here pairs with the barrier in
593                          * memcg_set_shrinker_bit():
594                          *
595                          * list_lru_add()     shrink_slab_memcg()
596                          *   list_add_tail()    clear_bit()
597                          *   <MB>               <MB>
598                          *   set_bit()          do_shrink_slab()
599                          */
600                         smp_mb__after_atomic();
601                         ret = do_shrink_slab(&sc, shrinker, priority);
602                         if (ret == SHRINK_EMPTY)
603                                 ret = 0;
604                         else
605                                 memcg_set_shrinker_bit(memcg, nid, i);
606                 }
607                 freed += ret;
608
609                 if (rwsem_is_contended(&shrinker_rwsem)) {
610                         freed = freed ? : 1;
611                         break;
612                 }
613         }
614 unlock:
615         up_read(&shrinker_rwsem);
616         return freed;
617 }
618 #else /* CONFIG_MEMCG */
619 static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
620                         struct mem_cgroup *memcg, int priority)
621 {
622         return 0;
623 }
624 #endif /* CONFIG_MEMCG */
625
626 /**
627  * shrink_slab - shrink slab caches
628  * @gfp_mask: allocation context
629  * @nid: node whose slab caches to target
630  * @memcg: memory cgroup whose slab caches to target
631  * @priority: the reclaim priority
632  *
633  * Call the shrink functions to age shrinkable caches.
634  *
635  * @nid is passed along to shrinkers with SHRINKER_NUMA_AWARE set,
636  * unaware shrinkers will receive a node id of 0 instead.
637  *
638  * @memcg specifies the memory cgroup to target. Unaware shrinkers
639  * are called only if it is the root cgroup.
640  *
641  * @priority is sc->priority, we take the number of objects and >> by priority
642  * in order to get the scan target.
643  *
644  * Returns the number of reclaimed slab objects.
645  */
646 static unsigned long shrink_slab(gfp_t gfp_mask, int nid,
647                                  struct mem_cgroup *memcg,
648                                  int priority)
649 {
650         unsigned long ret, freed = 0;
651         struct shrinker *shrinker;
652
653         /*
654          * The root memcg might be allocated even though memcg is disabled
655          * via "cgroup_disable=memory" boot parameter.  This could make
656          * mem_cgroup_is_root() return false, then just run memcg slab
657          * shrink, but skip global shrink.  This may result in premature
658          * oom.
659          */
660         if (!mem_cgroup_disabled() && !mem_cgroup_is_root(memcg))
661                 return shrink_slab_memcg(gfp_mask, nid, memcg, priority);
662
663         if (!down_read_trylock(&shrinker_rwsem))
664                 goto out;
665
666         list_for_each_entry(shrinker, &shrinker_list, list) {
667                 struct shrink_control sc = {
668                         .gfp_mask = gfp_mask,
669                         .nid = nid,
670                         .memcg = memcg,
671                 };
672
673                 ret = do_shrink_slab(&sc, shrinker, priority);
674                 if (ret == SHRINK_EMPTY)
675                         ret = 0;
676                 freed += ret;
677                 /*
678                  * Bail out if someone want to register a new shrinker to
679                  * prevent the registration from being stalled for long periods
680                  * by parallel ongoing shrinking.
681                  */
682                 if (rwsem_is_contended(&shrinker_rwsem)) {
683                         freed = freed ? : 1;
684                         break;
685                 }
686         }
687
688         up_read(&shrinker_rwsem);
689 out:
690         cond_resched();
691         return freed;
692 }
693
694 void drop_slab_node(int nid)
695 {
696         unsigned long freed;
697
698         do {
699                 struct mem_cgroup *memcg = NULL;
700
701                 if (fatal_signal_pending(current))
702                         return;
703
704                 freed = 0;
705                 memcg = mem_cgroup_iter(NULL, NULL, NULL);
706                 do {
707                         freed += shrink_slab(GFP_KERNEL, nid, memcg, 0);
708                 } while ((memcg = mem_cgroup_iter(NULL, memcg, NULL)) != NULL);
709         } while (freed > 10);
710 }
711
712 void drop_slab(void)
713 {
714         int nid;
715
716         for_each_online_node(nid)
717                 drop_slab_node(nid);
718 }
719
720 static inline int is_page_cache_freeable(struct page *page)
721 {
722         /*
723          * A freeable page cache page is referenced only by the caller
724          * that isolated the page, the page cache and optional buffer
725          * heads at page->private.
726          */
727         int page_cache_pins = thp_nr_pages(page);
728         return page_count(page) - page_has_private(page) == 1 + page_cache_pins;
729 }
730
731 static int may_write_to_inode(struct inode *inode)
732 {
733         if (current->flags & PF_SWAPWRITE)
734                 return 1;
735         if (!inode_write_congested(inode))
736                 return 1;
737         if (inode_to_bdi(inode) == current->backing_dev_info)
738                 return 1;
739         return 0;
740 }
741
742 /*
743  * We detected a synchronous write error writing a page out.  Probably
744  * -ENOSPC.  We need to propagate that into the address_space for a subsequent
745  * fsync(), msync() or close().
746  *
747  * The tricky part is that after writepage we cannot touch the mapping: nothing
748  * prevents it from being freed up.  But we have a ref on the page and once
749  * that page is locked, the mapping is pinned.
750  *
751  * We're allowed to run sleeping lock_page() here because we know the caller has
752  * __GFP_FS.
753  */
754 static void handle_write_error(struct address_space *mapping,
755                                 struct page *page, int error)
756 {
757         lock_page(page);
758         if (page_mapping(page) == mapping)
759                 mapping_set_error(mapping, error);
760         unlock_page(page);
761 }
762
763 /* possible outcome of pageout() */
764 typedef enum {
765         /* failed to write page out, page is locked */
766         PAGE_KEEP,
767         /* move page to the active list, page is locked */
768         PAGE_ACTIVATE,
769         /* page has been sent to the disk successfully, page is unlocked */
770         PAGE_SUCCESS,
771         /* page is clean and locked */
772         PAGE_CLEAN,
773 } pageout_t;
774
775 /*
776  * pageout is called by shrink_page_list() for each dirty page.
777  * Calls ->writepage().
778  */
779 static pageout_t pageout(struct page *page, struct address_space *mapping)
780 {
781         /*
782          * If the page is dirty, only perform writeback if that write
783          * will be non-blocking.  To prevent this allocation from being
784          * stalled by pagecache activity.  But note that there may be
785          * stalls if we need to run get_block().  We could test
786          * PagePrivate for that.
787          *
788          * If this process is currently in __generic_file_write_iter() against
789          * this page's queue, we can perform writeback even if that
790          * will block.
791          *
792          * If the page is swapcache, write it back even if that would
793          * block, for some throttling. This happens by accident, because
794          * swap_backing_dev_info is bust: it doesn't reflect the
795          * congestion state of the swapdevs.  Easy to fix, if needed.
796          */
797         if (!is_page_cache_freeable(page))
798                 return PAGE_KEEP;
799         if (!mapping) {
800                 /*
801                  * Some data journaling orphaned pages can have
802                  * page->mapping == NULL while being dirty with clean buffers.
803                  */
804                 if (page_has_private(page)) {
805                         if (try_to_free_buffers(page)) {
806                                 ClearPageDirty(page);
807                                 pr_info("%s: orphaned page\n", __func__);
808                                 return PAGE_CLEAN;
809                         }
810                 }
811                 return PAGE_KEEP;
812         }
813         if (mapping->a_ops->writepage == NULL)
814                 return PAGE_ACTIVATE;
815         if (!may_write_to_inode(mapping->host))
816                 return PAGE_KEEP;
817
818         if (clear_page_dirty_for_io(page)) {
819                 int res;
820                 struct writeback_control wbc = {
821                         .sync_mode = WB_SYNC_NONE,
822                         .nr_to_write = SWAP_CLUSTER_MAX,
823                         .range_start = 0,
824                         .range_end = LLONG_MAX,
825                         .for_reclaim = 1,
826                 };
827
828                 SetPageReclaim(page);
829                 res = mapping->a_ops->writepage(page, &wbc);
830                 if (res < 0)
831                         handle_write_error(mapping, page, res);
832                 if (res == AOP_WRITEPAGE_ACTIVATE) {
833                         ClearPageReclaim(page);
834                         return PAGE_ACTIVATE;
835                 }
836
837                 if (!PageWriteback(page)) {
838                         /* synchronous write or broken a_ops? */
839                         ClearPageReclaim(page);
840                 }
841                 trace_mm_vmscan_writepage(page);
842                 inc_node_page_state(page, NR_VMSCAN_WRITE);
843                 return PAGE_SUCCESS;
844         }
845
846         return PAGE_CLEAN;
847 }
848
849 /*
850  * Same as remove_mapping, but if the page is removed from the mapping, it
851  * gets returned with a refcount of 0.
852  */
853 static int __remove_mapping(struct address_space *mapping, struct page *page,
854                             bool reclaimed, struct mem_cgroup *target_memcg)
855 {
856         unsigned long flags;
857         int refcount;
858         void *shadow = NULL;
859
860         BUG_ON(!PageLocked(page));
861         BUG_ON(mapping != page_mapping(page));
862
863         xa_lock_irqsave(&mapping->i_pages, flags);
864         /*
865          * The non racy check for a busy page.
866          *
867          * Must be careful with the order of the tests. When someone has
868          * a ref to the page, it may be possible that they dirty it then
869          * drop the reference. So if PageDirty is tested before page_count
870          * here, then the following race may occur:
871          *
872          * get_user_pages(&page);
873          * [user mapping goes away]
874          * write_to(page);
875          *                              !PageDirty(page)    [good]
876          * SetPageDirty(page);
877          * put_page(page);
878          *                              !page_count(page)   [good, discard it]
879          *
880          * [oops, our write_to data is lost]
881          *
882          * Reversing the order of the tests ensures such a situation cannot
883          * escape unnoticed. The smp_rmb is needed to ensure the page->flags
884          * load is not satisfied before that of page->_refcount.
885          *
886          * Note that if SetPageDirty is always performed via set_page_dirty,
887          * and thus under the i_pages lock, then this ordering is not required.
888          */
889         refcount = 1 + compound_nr(page);
890         if (!page_ref_freeze(page, refcount))
891                 goto cannot_free;
892         /* note: atomic_cmpxchg in page_ref_freeze provides the smp_rmb */
893         if (unlikely(PageDirty(page))) {
894                 page_ref_unfreeze(page, refcount);
895                 goto cannot_free;
896         }
897
898         if (PageSwapCache(page)) {
899                 swp_entry_t swap = { .val = page_private(page) };
900                 mem_cgroup_swapout(page, swap);
901                 if (reclaimed && !mapping_exiting(mapping))
902                         shadow = workingset_eviction(page, target_memcg);
903                 __delete_from_swap_cache(page, swap, shadow);
904                 xa_unlock_irqrestore(&mapping->i_pages, flags);
905                 put_swap_page(page, swap);
906         } else {
907                 void (*freepage)(struct page *);
908
909                 freepage = mapping->a_ops->freepage;
910                 /*
911                  * Remember a shadow entry for reclaimed file cache in
912                  * order to detect refaults, thus thrashing, later on.
913                  *
914                  * But don't store shadows in an address space that is
915                  * already exiting.  This is not just an optimization,
916                  * inode reclaim needs to empty out the radix tree or
917                  * the nodes are lost.  Don't plant shadows behind its
918                  * back.
919                  *
920                  * We also don't store shadows for DAX mappings because the
921                  * only page cache pages found in these are zero pages
922                  * covering holes, and because we don't want to mix DAX
923                  * exceptional entries and shadow exceptional entries in the
924                  * same address_space.
925                  */
926                 if (reclaimed && page_is_file_lru(page) &&
927                     !mapping_exiting(mapping) && !dax_mapping(mapping))
928                         shadow = workingset_eviction(page, target_memcg);
929                 __delete_from_page_cache(page, shadow);
930                 xa_unlock_irqrestore(&mapping->i_pages, flags);
931
932                 if (freepage != NULL)
933                         freepage(page);
934         }
935
936         return 1;
937
938 cannot_free:
939         xa_unlock_irqrestore(&mapping->i_pages, flags);
940         return 0;
941 }
942
943 /*
944  * Attempt to detach a locked page from its ->mapping.  If it is dirty or if
945  * someone else has a ref on the page, abort and return 0.  If it was
946  * successfully detached, return 1.  Assumes the caller has a single ref on
947  * this page.
948  */
949 int remove_mapping(struct address_space *mapping, struct page *page)
950 {
951         if (__remove_mapping(mapping, page, false, NULL)) {
952                 /*
953                  * Unfreezing the refcount with 1 rather than 2 effectively
954                  * drops the pagecache ref for us without requiring another
955                  * atomic operation.
956                  */
957                 page_ref_unfreeze(page, 1);
958                 return 1;
959         }
960         return 0;
961 }
962
963 /**
964  * putback_lru_page - put previously isolated page onto appropriate LRU list
965  * @page: page to be put back to appropriate lru list
966  *
967  * Add previously isolated @page to appropriate LRU list.
968  * Page may still be unevictable for other reasons.
969  *
970  * lru_lock must not be held, interrupts must be enabled.
971  */
972 void putback_lru_page(struct page *page)
973 {
974         lru_cache_add(page);
975         put_page(page);         /* drop ref from isolate */
976 }
977
978 enum page_references {
979         PAGEREF_RECLAIM,
980         PAGEREF_RECLAIM_CLEAN,
981         PAGEREF_KEEP,
982         PAGEREF_ACTIVATE,
983 };
984
985 static enum page_references page_check_references(struct page *page,
986                                                   struct scan_control *sc)
987 {
988         int referenced_ptes, referenced_page;
989         unsigned long vm_flags;
990
991         referenced_ptes = page_referenced(page, 1, sc->target_mem_cgroup,
992                                           &vm_flags);
993         referenced_page = TestClearPageReferenced(page);
994
995         /*
996          * Mlock lost the isolation race with us.  Let try_to_unmap()
997          * move the page to the unevictable list.
998          */
999         if (vm_flags & VM_LOCKED)
1000                 return PAGEREF_RECLAIM;
1001
1002         if (referenced_ptes) {
1003                 /*
1004                  * All mapped pages start out with page table
1005                  * references from the instantiating fault, so we need
1006                  * to look twice if a mapped file page is used more
1007                  * than once.
1008                  *
1009                  * Mark it and spare it for another trip around the
1010                  * inactive list.  Another page table reference will
1011                  * lead to its activation.
1012                  *
1013                  * Note: the mark is set for activated pages as well
1014                  * so that recently deactivated but used pages are
1015                  * quickly recovered.
1016                  */
1017                 SetPageReferenced(page);
1018
1019                 if (referenced_page || referenced_ptes > 1)
1020                         return PAGEREF_ACTIVATE;
1021
1022                 /*
1023                  * Activate file-backed executable pages after first usage.
1024                  */
1025                 if ((vm_flags & VM_EXEC) && !PageSwapBacked(page))
1026                         return PAGEREF_ACTIVATE;
1027
1028                 return PAGEREF_KEEP;
1029         }
1030
1031         /* Reclaim if clean, defer dirty pages to writeback */
1032         if (referenced_page && !PageSwapBacked(page))
1033                 return PAGEREF_RECLAIM_CLEAN;
1034
1035         return PAGEREF_RECLAIM;
1036 }
1037
1038 /* Check if a page is dirty or under writeback */
1039 static void page_check_dirty_writeback(struct page *page,
1040                                        bool *dirty, bool *writeback)
1041 {
1042         struct address_space *mapping;
1043
1044         /*
1045          * Anonymous pages are not handled by flushers and must be written
1046          * from reclaim context. Do not stall reclaim based on them
1047          */
1048         if (!page_is_file_lru(page) ||
1049             (PageAnon(page) && !PageSwapBacked(page))) {
1050                 *dirty = false;
1051                 *writeback = false;
1052                 return;
1053         }
1054
1055         /* By default assume that the page flags are accurate */
1056         *dirty = PageDirty(page);
1057         *writeback = PageWriteback(page);
1058
1059         /* Verify dirty/writeback state if the filesystem supports it */
1060         if (!page_has_private(page))
1061                 return;
1062
1063         mapping = page_mapping(page);
1064         if (mapping && mapping->a_ops->is_dirty_writeback)
1065                 mapping->a_ops->is_dirty_writeback(page, dirty, writeback);
1066 }
1067
1068 /*
1069  * shrink_page_list() returns the number of reclaimed pages
1070  */
1071 static unsigned int shrink_page_list(struct list_head *page_list,
1072                                      struct pglist_data *pgdat,
1073                                      struct scan_control *sc,
1074                                      struct reclaim_stat *stat,
1075                                      bool ignore_references)
1076 {
1077         LIST_HEAD(ret_pages);
1078         LIST_HEAD(free_pages);
1079         unsigned int nr_reclaimed = 0;
1080         unsigned int pgactivate = 0;
1081
1082         memset(stat, 0, sizeof(*stat));
1083         cond_resched();
1084
1085         while (!list_empty(page_list)) {
1086                 struct address_space *mapping;
1087                 struct page *page;
1088                 enum page_references references = PAGEREF_RECLAIM;
1089                 bool dirty, writeback, may_enter_fs;
1090                 unsigned int nr_pages;
1091
1092                 cond_resched();
1093
1094                 page = lru_to_page(page_list);
1095                 list_del(&page->lru);
1096
1097                 if (!trylock_page(page))
1098                         goto keep;
1099
1100                 VM_BUG_ON_PAGE(PageActive(page), page);
1101
1102                 nr_pages = compound_nr(page);
1103
1104                 /* Account the number of base pages even though THP */
1105                 sc->nr_scanned += nr_pages;
1106
1107                 if (unlikely(!page_evictable(page)))
1108                         goto activate_locked;
1109
1110                 if (!sc->may_unmap && page_mapped(page))
1111                         goto keep_locked;
1112
1113                 may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
1114                         (PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));
1115
1116                 /*
1117                  * The number of dirty pages determines if a node is marked
1118                  * reclaim_congested which affects wait_iff_congested. kswapd
1119                  * will stall and start writing pages if the tail of the LRU
1120                  * is all dirty unqueued pages.
1121                  */
1122                 page_check_dirty_writeback(page, &dirty, &writeback);
1123                 if (dirty || writeback)
1124                         stat->nr_dirty++;
1125
1126                 if (dirty && !writeback)
1127                         stat->nr_unqueued_dirty++;
1128
1129                 /*
1130                  * Treat this page as congested if the underlying BDI is or if
1131                  * pages are cycling through the LRU so quickly that the
1132                  * pages marked for immediate reclaim are making it to the
1133                  * end of the LRU a second time.
1134                  */
1135                 mapping = page_mapping(page);
1136                 if (((dirty || writeback) && mapping &&
1137                      inode_write_congested(mapping->host)) ||
1138                     (writeback && PageReclaim(page)))
1139                         stat->nr_congested++;
1140
1141                 /*
1142                  * If a page at the tail of the LRU is under writeback, there
1143                  * are three cases to consider.
1144                  *
1145                  * 1) If reclaim is encountering an excessive number of pages
1146                  *    under writeback and this page is both under writeback and
1147                  *    PageReclaim then it indicates that pages are being queued
1148                  *    for IO but are being recycled through the LRU before the
1149                  *    IO can complete. Waiting on the page itself risks an
1150                  *    indefinite stall if it is impossible to writeback the
1151                  *    page due to IO error or disconnected storage so instead
1152                  *    note that the LRU is being scanned too quickly and the
1153                  *    caller can stall after page list has been processed.
1154                  *
1155                  * 2) Global or new memcg reclaim encounters a page that is
1156                  *    not marked for immediate reclaim, or the caller does not
1157                  *    have __GFP_FS (or __GFP_IO if it's simply going to swap,
1158                  *    not to fs). In this case mark the page for immediate
1159                  *    reclaim and continue scanning.
1160                  *
1161                  *    Require may_enter_fs because we would wait on fs, which
1162                  *    may not have submitted IO yet. And the loop driver might
1163                  *    enter reclaim, and deadlock if it waits on a page for
1164                  *    which it is needed to do the write (loop masks off
1165                  *    __GFP_IO|__GFP_FS for this reason); but more thought
1166                  *    would probably show more reasons.
1167                  *
1168                  * 3) Legacy memcg encounters a page that is already marked
1169                  *    PageReclaim. memcg does not have any dirty pages
1170                  *    throttling so we could easily OOM just because too many
1171                  *    pages are in writeback and there is nothing else to
1172                  *    reclaim. Wait for the writeback to complete.
1173                  *
1174                  * In cases 1) and 2) we activate the pages to get them out of
1175                  * the way while we continue scanning for clean pages on the
1176                  * inactive list and refilling from the active list. The
1177                  * observation here is that waiting for disk writes is more
1178                  * expensive than potentially causing reloads down the line.
1179                  * Since they're marked for immediate reclaim, they won't put
1180                  * memory pressure on the cache working set any longer than it
1181                  * takes to write them to disk.
1182                  */
1183                 if (PageWriteback(page)) {
1184                         /* Case 1 above */
1185                         if (current_is_kswapd() &&
1186                             PageReclaim(page) &&
1187                             test_bit(PGDAT_WRITEBACK, &pgdat->flags)) {
1188                                 stat->nr_immediate++;
1189                                 goto activate_locked;
1190
1191                         /* Case 2 above */
1192                         } else if (writeback_throttling_sane(sc) ||
1193                             !PageReclaim(page) || !may_enter_fs) {
1194                                 /*
1195                                  * This is slightly racy - end_page_writeback()
1196                                  * might have just cleared PageReclaim, then
1197                                  * setting PageReclaim here end up interpreted
1198                                  * as PageReadahead - but that does not matter
1199                                  * enough to care.  What we do want is for this
1200                                  * page to have PageReclaim set next time memcg
1201                                  * reclaim reaches the tests above, so it will
1202                                  * then wait_on_page_writeback() to avoid OOM;
1203                                  * and it's also appropriate in global reclaim.
1204                                  */
1205                                 SetPageReclaim(page);
1206                                 stat->nr_writeback++;
1207                                 goto activate_locked;
1208
1209                         /* Case 3 above */
1210                         } else {
1211                                 unlock_page(page);
1212                                 wait_on_page_writeback(page);
1213                                 /* then go back and try same page again */
1214                                 list_add_tail(&page->lru, page_list);
1215                                 continue;
1216                         }
1217                 }
1218
1219                 if (!ignore_references)
1220                         references = page_check_references(page, sc);
1221
1222                 switch (references) {
1223                 case PAGEREF_ACTIVATE:
1224                         goto activate_locked;
1225                 case PAGEREF_KEEP:
1226                         stat->nr_ref_keep += nr_pages;
1227                         goto keep_locked;
1228                 case PAGEREF_RECLAIM:
1229                 case PAGEREF_RECLAIM_CLEAN:
1230                         ; /* try to reclaim the page below */
1231                 }
1232
1233                 /*
1234                  * Anonymous process memory has backing store?
1235                  * Try to allocate it some swap space here.
1236                  * Lazyfree page could be freed directly
1237                  */
1238                 if (PageAnon(page) && PageSwapBacked(page)) {
1239                         if (!PageSwapCache(page)) {
1240                                 if (!(sc->gfp_mask & __GFP_IO))
1241                                         goto keep_locked;
1242                                 if (page_maybe_dma_pinned(page))
1243                                         goto keep_locked;
1244                                 if (PageTransHuge(page)) {
1245                                         /* cannot split THP, skip it */
1246                                         if (!can_split_huge_page(page, NULL))
1247                                                 goto activate_locked;
1248                                         /*
1249                                          * Split pages without a PMD map right
1250                                          * away. Chances are some or all of the
1251                                          * tail pages can be freed without IO.
1252                                          */
1253                                         if (!compound_mapcount(page) &&
1254                                             split_huge_page_to_list(page,
1255                                                                     page_list))
1256                                                 goto activate_locked;
1257                                 }
1258                                 if (!add_to_swap(page)) {
1259                                         if (!PageTransHuge(page))
1260                                                 goto activate_locked_split;
1261                                         /* Fallback to swap normal pages */
1262                                         if (split_huge_page_to_list(page,
1263                                                                     page_list))
1264                                                 goto activate_locked;
1265 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1266                                         count_vm_event(THP_SWPOUT_FALLBACK);
1267 #endif
1268                                         if (!add_to_swap(page))
1269                                                 goto activate_locked_split;
1270                                 }
1271
1272                                 may_enter_fs = true;
1273
1274                                 /* Adding to swap updated mapping */
1275                                 mapping = page_mapping(page);
1276                         }
1277                 } else if (unlikely(PageTransHuge(page))) {
1278                         /* Split file THP */
1279                         if (split_huge_page_to_list(page, page_list))
1280                                 goto keep_locked;
1281                 }
1282
1283                 /*
1284                  * THP may get split above, need minus tail pages and update
1285                  * nr_pages to avoid accounting tail pages twice.
1286                  *
1287                  * The tail pages that are added into swap cache successfully
1288                  * reach here.
1289                  */
1290                 if ((nr_pages > 1) && !PageTransHuge(page)) {
1291                         sc->nr_scanned -= (nr_pages - 1);
1292                         nr_pages = 1;
1293                 }
1294
1295                 /*
1296                  * The page is mapped into the page tables of one or more
1297                  * processes. Try to unmap it here.
1298                  */
1299                 if (page_mapped(page)) {
1300                         enum ttu_flags flags = TTU_BATCH_FLUSH;
1301                         bool was_swapbacked = PageSwapBacked(page);
1302
1303                         if (unlikely(PageTransHuge(page)))
1304                                 flags |= TTU_SPLIT_HUGE_PMD;
1305
1306                         if (!try_to_unmap(page, flags)) {
1307                                 stat->nr_unmap_fail += nr_pages;
1308                                 if (!was_swapbacked && PageSwapBacked(page))
1309                                         stat->nr_lazyfree_fail += nr_pages;
1310                                 goto activate_locked;
1311                         }
1312                 }
1313
1314                 if (PageDirty(page)) {
1315                         /*
1316                          * Only kswapd can writeback filesystem pages
1317                          * to avoid risk of stack overflow. But avoid
1318                          * injecting inefficient single-page IO into
1319                          * flusher writeback as much as possible: only
1320                          * write pages when we've encountered many
1321                          * dirty pages, and when we've already scanned
1322                          * the rest of the LRU for clean pages and see
1323                          * the same dirty pages again (PageReclaim).
1324                          */
1325                         if (page_is_file_lru(page) &&
1326                             (!current_is_kswapd() || !PageReclaim(page) ||
1327                              !test_bit(PGDAT_DIRTY, &pgdat->flags))) {
1328                                 /*
1329                                  * Immediately reclaim when written back.
1330                                  * Similar in principal to deactivate_page()
1331                                  * except we already have the page isolated
1332                                  * and know it's dirty
1333                                  */
1334                                 inc_node_page_state(page, NR_VMSCAN_IMMEDIATE);
1335                                 SetPageReclaim(page);
1336
1337                                 goto activate_locked;
1338                         }
1339
1340                         if (references == PAGEREF_RECLAIM_CLEAN)
1341                                 goto keep_locked;
1342                         if (!may_enter_fs)
1343                                 goto keep_locked;
1344                         if (!sc->may_writepage)
1345                                 goto keep_locked;
1346
1347                         /*
1348                          * Page is dirty. Flush the TLB if a writable entry
1349                          * potentially exists to avoid CPU writes after IO
1350                          * starts and then write it out here.
1351                          */
1352                         try_to_unmap_flush_dirty();
1353                         switch (pageout(page, mapping)) {
1354                         case PAGE_KEEP:
1355                                 goto keep_locked;
1356                         case PAGE_ACTIVATE:
1357                                 goto activate_locked;
1358                         case PAGE_SUCCESS:
1359                                 stat->nr_pageout += thp_nr_pages(page);
1360
1361                                 if (PageWriteback(page))
1362                                         goto keep;
1363                                 if (PageDirty(page))
1364                                         goto keep;
1365
1366                                 /*
1367                                  * A synchronous write - probably a ramdisk.  Go
1368                                  * ahead and try to reclaim the page.
1369                                  */
1370                                 if (!trylock_page(page))
1371                                         goto keep;
1372                                 if (PageDirty(page) || PageWriteback(page))
1373                                         goto keep_locked;
1374                                 mapping = page_mapping(page);
1375                                 fallthrough;
1376                         case PAGE_CLEAN:
1377                                 ; /* try to free the page below */
1378                         }
1379                 }
1380
1381                 /*
1382                  * If the page has buffers, try to free the buffer mappings
1383                  * associated with this page. If we succeed we try to free
1384                  * the page as well.
1385                  *
1386                  * We do this even if the page is PageDirty().
1387                  * try_to_release_page() does not perform I/O, but it is
1388                  * possible for a page to have PageDirty set, but it is actually
1389                  * clean (all its buffers are clean).  This happens if the
1390                  * buffers were written out directly, with submit_bh(). ext3
1391                  * will do this, as well as the blockdev mapping.
1392                  * try_to_release_page() will discover that cleanness and will
1393                  * drop the buffers and mark the page clean - it can be freed.
1394                  *
1395                  * Rarely, pages can have buffers and no ->mapping.  These are
1396                  * the pages which were not successfully invalidated in
1397                  * truncate_cleanup_page().  We try to drop those buffers here
1398                  * and if that worked, and the page is no longer mapped into
1399                  * process address space (page_count == 1) it can be freed.
1400                  * Otherwise, leave the page on the LRU so it is swappable.
1401                  */
1402                 if (page_has_private(page)) {
1403                         if (!try_to_release_page(page, sc->gfp_mask))
1404                                 goto activate_locked;
1405                         if (!mapping && page_count(page) == 1) {
1406                                 unlock_page(page);
1407                                 if (put_page_testzero(page))
1408                                         goto free_it;
1409                                 else {
1410                                         /*
1411                                          * rare race with speculative reference.
1412                                          * the speculative reference will free
1413                                          * this page shortly, so we may
1414                                          * increment nr_reclaimed here (and
1415                                          * leave it off the LRU).
1416                                          */
1417                                         nr_reclaimed++;
1418                                         continue;
1419                                 }
1420                         }
1421                 }
1422
1423                 if (PageAnon(page) && !PageSwapBacked(page)) {
1424                         /* follow __remove_mapping for reference */
1425                         if (!page_ref_freeze(page, 1))
1426                                 goto keep_locked;
1427                         if (PageDirty(page)) {
1428                                 page_ref_unfreeze(page, 1);
1429                                 goto keep_locked;
1430                         }
1431
1432                         count_vm_event(PGLAZYFREED);
1433                         count_memcg_page_event(page, PGLAZYFREED);
1434                 } else if (!mapping || !__remove_mapping(mapping, page, true,
1435                                                          sc->target_mem_cgroup))
1436                         goto keep_locked;
1437
1438                 unlock_page(page);
1439 free_it:
1440                 /*
1441                  * THP may get swapped out in a whole, need account
1442                  * all base pages.
1443                  */
1444                 nr_reclaimed += nr_pages;
1445
1446                 /*
1447                  * Is there need to periodically free_page_list? It would
1448                  * appear not as the counts should be low
1449                  */
1450                 if (unlikely(PageTransHuge(page)))
1451                         destroy_compound_page(page);
1452                 else
1453                         list_add(&page->lru, &free_pages);
1454                 continue;
1455
1456 activate_locked_split:
1457                 /*
1458                  * The tail pages that are failed to add into swap cache
1459                  * reach here.  Fixup nr_scanned and nr_pages.
1460                  */
1461                 if (nr_pages > 1) {
1462                         sc->nr_scanned -= (nr_pages - 1);
1463                         nr_pages = 1;
1464                 }
1465 activate_locked:
1466                 /* Not a candidate for swapping, so reclaim swap space. */
1467                 if (PageSwapCache(page) && (mem_cgroup_swap_full(page) ||
1468                                                 PageMlocked(page)))
1469                         try_to_free_swap(page);
1470                 VM_BUG_ON_PAGE(PageActive(page), page);
1471                 if (!PageMlocked(page)) {
1472                         int type = page_is_file_lru(page);
1473                         SetPageActive(page);
1474                         stat->nr_activate[type] += nr_pages;
1475                         count_memcg_page_event(page, PGACTIVATE);
1476                 }
1477 keep_locked:
1478                 unlock_page(page);
1479 keep:
1480                 list_add(&page->lru, &ret_pages);
1481                 VM_BUG_ON_PAGE(PageLRU(page) || PageUnevictable(page), page);
1482         }
1483
1484         pgactivate = stat->nr_activate[0] + stat->nr_activate[1];
1485
1486         mem_cgroup_uncharge_list(&free_pages);
1487         try_to_unmap_flush();
1488         free_unref_page_list(&free_pages);
1489
1490         list_splice(&ret_pages, page_list);
1491         count_vm_events(PGACTIVATE, pgactivate);
1492
1493         return nr_reclaimed;
1494 }
1495
1496 unsigned int reclaim_clean_pages_from_list(struct zone *zone,
1497                                             struct list_head *page_list)
1498 {
1499         struct scan_control sc = {
1500                 .gfp_mask = GFP_KERNEL,
1501                 .priority = DEF_PRIORITY,
1502                 .may_unmap = 1,
1503         };
1504         struct reclaim_stat stat;
1505         unsigned int nr_reclaimed;
1506         struct page *page, *next;
1507         LIST_HEAD(clean_pages);
1508
1509         list_for_each_entry_safe(page, next, page_list, lru) {
1510                 if (page_is_file_lru(page) && !PageDirty(page) &&
1511                     !__PageMovable(page) && !PageUnevictable(page)) {
1512                         ClearPageActive(page);
1513                         list_move(&page->lru, &clean_pages);
1514                 }
1515         }
1516
1517         nr_reclaimed = shrink_page_list(&clean_pages, zone->zone_pgdat, &sc,
1518                                         &stat, true);
1519         list_splice(&clean_pages, page_list);
1520         mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_FILE,
1521                             -(long)nr_reclaimed);
1522         /*
1523          * Since lazyfree pages are isolated from file LRU from the beginning,
1524          * they will rotate back to anonymous LRU in the end if it failed to
1525          * discard so isolated count will be mismatched.
1526          * Compensate the isolated count for both LRU lists.
1527          */
1528         mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_ANON,
1529                             stat.nr_lazyfree_fail);
1530         mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_FILE,
1531                             -(long)stat.nr_lazyfree_fail);
1532         return nr_reclaimed;
1533 }
1534
1535 /*
1536  * Attempt to remove the specified page from its LRU.  Only take this page
1537  * if it is of the appropriate PageActive status.  Pages which are being
1538  * freed elsewhere are also ignored.
1539  *
1540  * page:        page to consider
1541  * mode:        one of the LRU isolation modes defined above
1542  *
1543  * returns true on success, false on failure.
1544  */
1545 bool __isolate_lru_page_prepare(struct page *page, isolate_mode_t mode)
1546 {
1547         /* Only take pages on the LRU. */
1548         if (!PageLRU(page))
1549                 return false;
1550
1551         /* Compaction should not handle unevictable pages but CMA can do so */
1552         if (PageUnevictable(page) && !(mode & ISOLATE_UNEVICTABLE))
1553                 return false;
1554
1555         /*
1556          * To minimise LRU disruption, the caller can indicate that it only
1557          * wants to isolate pages it will be able to operate on without
1558          * blocking - clean pages for the most part.
1559          *
1560          * ISOLATE_ASYNC_MIGRATE is used to indicate that it only wants to pages
1561          * that it is possible to migrate without blocking
1562          */
1563         if (mode & ISOLATE_ASYNC_MIGRATE) {
1564                 /* All the caller can do on PageWriteback is block */
1565                 if (PageWriteback(page))
1566                         return false;
1567
1568                 if (PageDirty(page)) {
1569                         struct address_space *mapping;
1570                         bool migrate_dirty;
1571
1572                         /*
1573                          * Only pages without mappings or that have a
1574                          * ->migratepage callback are possible to migrate
1575                          * without blocking. However, we can be racing with
1576                          * truncation so it's necessary to lock the page
1577                          * to stabilise the mapping as truncation holds
1578                          * the page lock until after the page is removed
1579                          * from the page cache.
1580                          */
1581                         if (!trylock_page(page))
1582                                 return false;
1583
1584                         mapping = page_mapping(page);
1585                         migrate_dirty = !mapping || mapping->a_ops->migratepage;
1586                         unlock_page(page);
1587                         if (!migrate_dirty)
1588                                 return false;
1589                 }
1590         }
1591
1592         if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
1593                 return false;
1594
1595         return true;
1596 }
1597
1598 /*
1599  * Update LRU sizes after isolating pages. The LRU size updates must
1600  * be complete before mem_cgroup_update_lru_size due to a sanity check.
1601  */
1602 static __always_inline void update_lru_sizes(struct lruvec *lruvec,
1603                         enum lru_list lru, unsigned long *nr_zone_taken)
1604 {
1605         int zid;
1606
1607         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1608                 if (!nr_zone_taken[zid])
1609                         continue;
1610
1611                 update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
1612         }
1613
1614 }
1615
1616 /**
1617  * Isolating page from the lruvec to fill in @dst list by nr_to_scan times.
1618  *
1619  * lruvec->lru_lock is heavily contended.  Some of the functions that
1620  * shrink the lists perform better by taking out a batch of pages
1621  * and working on them outside the LRU lock.
1622  *
1623  * For pagecache intensive workloads, this function is the hottest
1624  * spot in the kernel (apart from copy_*_user functions).
1625  *
1626  * Lru_lock must be held before calling this function.
1627  *
1628  * @nr_to_scan: The number of eligible pages to look through on the list.
1629  * @lruvec:     The LRU vector to pull pages from.
1630  * @dst:        The temp list to put pages on to.
1631  * @nr_scanned: The number of pages that were scanned.
1632  * @sc:         The scan_control struct for this reclaim session
1633  * @lru:        LRU list id for isolating
1634  *
1635  * returns how many pages were moved onto *@dst.
1636  */
1637 static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
1638                 struct lruvec *lruvec, struct list_head *dst,
1639                 unsigned long *nr_scanned, struct scan_control *sc,
1640                 enum lru_list lru)
1641 {
1642         struct list_head *src = &lruvec->lists[lru];
1643         unsigned long nr_taken = 0;
1644         unsigned long nr_zone_taken[MAX_NR_ZONES] = { 0 };
1645         unsigned long nr_skipped[MAX_NR_ZONES] = { 0, };
1646         unsigned long skipped = 0;
1647         unsigned long scan, total_scan, nr_pages;
1648         LIST_HEAD(pages_skipped);
1649         isolate_mode_t mode = (sc->may_unmap ? 0 : ISOLATE_UNMAPPED);
1650
1651         total_scan = 0;
1652         scan = 0;
1653         while (scan < nr_to_scan && !list_empty(src)) {
1654                 struct page *page;
1655
1656                 page = lru_to_page(src);
1657                 prefetchw_prev_lru_page(page, src, flags);
1658
1659                 nr_pages = compound_nr(page);
1660                 total_scan += nr_pages;
1661
1662                 if (page_zonenum(page) > sc->reclaim_idx) {
1663                         list_move(&page->lru, &pages_skipped);
1664                         nr_skipped[page_zonenum(page)] += nr_pages;
1665                         continue;
1666                 }
1667
1668                 /*
1669                  * Do not count skipped pages because that makes the function
1670                  * return with no isolated pages if the LRU mostly contains
1671                  * ineligible pages.  This causes the VM to not reclaim any
1672                  * pages, triggering a premature OOM.
1673                  *
1674                  * Account all tail pages of THP.  This would not cause
1675                  * premature OOM since __isolate_lru_page() returns -EBUSY
1676                  * only when the page is being freed somewhere else.
1677                  */
1678                 scan += nr_pages;
1679                 if (!__isolate_lru_page_prepare(page, mode)) {
1680                         /* It is being freed elsewhere */
1681                         list_move(&page->lru, src);
1682                         continue;
1683                 }
1684                 /*
1685                  * Be careful not to clear PageLRU until after we're
1686                  * sure the page is not being freed elsewhere -- the
1687                  * page release code relies on it.
1688                  */
1689                 if (unlikely(!get_page_unless_zero(page))) {
1690                         list_move(&page->lru, src);
1691                         continue;
1692                 }
1693
1694                 if (!TestClearPageLRU(page)) {
1695                         /* Another thread is already isolating this page */
1696                         put_page(page);
1697                         list_move(&page->lru, src);
1698                         continue;
1699                 }
1700
1701                 nr_taken += nr_pages;
1702                 nr_zone_taken[page_zonenum(page)] += nr_pages;
1703                 list_move(&page->lru, dst);
1704         }
1705
1706         /*
1707          * Splice any skipped pages to the start of the LRU list. Note that
1708          * this disrupts the LRU order when reclaiming for lower zones but
1709          * we cannot splice to the tail. If we did then the SWAP_CLUSTER_MAX
1710          * scanning would soon rescan the same pages to skip and put the
1711          * system at risk of premature OOM.
1712          */
1713         if (!list_empty(&pages_skipped)) {
1714                 int zid;
1715
1716                 list_splice(&pages_skipped, src);
1717                 for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1718                         if (!nr_skipped[zid])
1719                                 continue;
1720
1721                         __count_zid_vm_events(PGSCAN_SKIP, zid, nr_skipped[zid]);
1722                         skipped += nr_skipped[zid];
1723                 }
1724         }
1725         *nr_scanned = total_scan;
1726         trace_mm_vmscan_lru_isolate(sc->reclaim_idx, sc->order, nr_to_scan,
1727                                     total_scan, skipped, nr_taken, mode, lru);
1728         update_lru_sizes(lruvec, lru, nr_zone_taken);
1729         return nr_taken;
1730 }
1731
1732 /**
1733  * isolate_lru_page - tries to isolate a page from its LRU list
1734  * @page: page to isolate from its LRU list
1735  *
1736  * Isolates a @page from an LRU list, clears PageLRU and adjusts the
1737  * vmstat statistic corresponding to whatever LRU list the page was on.
1738  *
1739  * Returns 0 if the page was removed from an LRU list.
1740  * Returns -EBUSY if the page was not on an LRU list.
1741  *
1742  * The returned page will have PageLRU() cleared.  If it was found on
1743  * the active list, it will have PageActive set.  If it was found on
1744  * the unevictable list, it will have the PageUnevictable bit set. That flag
1745  * may need to be cleared by the caller before letting the page go.
1746  *
1747  * The vmstat statistic corresponding to the list on which the page was
1748  * found will be decremented.
1749  *
1750  * Restrictions:
1751  *
1752  * (1) Must be called with an elevated refcount on the page. This is a
1753  *     fundamental difference from isolate_lru_pages (which is called
1754  *     without a stable reference).
1755  * (2) the lru_lock must not be held.
1756  * (3) interrupts must be enabled.
1757  */
1758 int isolate_lru_page(struct page *page)
1759 {
1760         int ret = -EBUSY;
1761
1762         VM_BUG_ON_PAGE(!page_count(page), page);
1763         WARN_RATELIMIT(PageTail(page), "trying to isolate tail page");
1764
1765         if (TestClearPageLRU(page)) {
1766                 struct lruvec *lruvec;
1767
1768                 get_page(page);
1769                 lruvec = lock_page_lruvec_irq(page);
1770                 del_page_from_lru_list(page, lruvec);
1771                 unlock_page_lruvec_irq(lruvec);
1772                 ret = 0;
1773         }
1774
1775         return ret;
1776 }
1777
1778 /*
1779  * A direct reclaimer may isolate SWAP_CLUSTER_MAX pages from the LRU list and
1780  * then get rescheduled. When there are massive number of tasks doing page
1781  * allocation, such sleeping direct reclaimers may keep piling up on each CPU,
1782  * the LRU list will go small and be scanned faster than necessary, leading to
1783  * unnecessary swapping, thrashing and OOM.
1784  */
1785 static int too_many_isolated(struct pglist_data *pgdat, int file,
1786                 struct scan_control *sc)
1787 {
1788         unsigned long inactive, isolated;
1789
1790         if (current_is_kswapd())
1791                 return 0;
1792
1793         if (!writeback_throttling_sane(sc))
1794                 return 0;
1795
1796         if (file) {
1797                 inactive = node_page_state(pgdat, NR_INACTIVE_FILE);
1798                 isolated = node_page_state(pgdat, NR_ISOLATED_FILE);
1799         } else {
1800                 inactive = node_page_state(pgdat, NR_INACTIVE_ANON);
1801                 isolated = node_page_state(pgdat, NR_ISOLATED_ANON);
1802         }
1803
1804         /*
1805          * GFP_NOIO/GFP_NOFS callers are allowed to isolate more pages, so they
1806          * won't get blocked by normal direct-reclaimers, forming a circular
1807          * deadlock.
1808          */
1809         if ((sc->gfp_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
1810                 inactive >>= 3;
1811
1812         return isolated > inactive;
1813 }
1814
1815 /*
1816  * move_pages_to_lru() moves pages from private @list to appropriate LRU list.
1817  * On return, @list is reused as a list of pages to be freed by the caller.
1818  *
1819  * Returns the number of pages moved to the given lruvec.
1820  */
1821 static unsigned noinline_for_stack move_pages_to_lru(struct lruvec *lruvec,
1822                                                      struct list_head *list)
1823 {
1824         int nr_pages, nr_moved = 0;
1825         LIST_HEAD(pages_to_free);
1826         struct page *page;
1827
1828         while (!list_empty(list)) {
1829                 page = lru_to_page(list);
1830                 VM_BUG_ON_PAGE(PageLRU(page), page);
1831                 list_del(&page->lru);
1832                 if (unlikely(!page_evictable(page))) {
1833                         spin_unlock_irq(&lruvec->lru_lock);
1834                         putback_lru_page(page);
1835                         spin_lock_irq(&lruvec->lru_lock);
1836                         continue;
1837                 }
1838
1839                 /*
1840                  * The SetPageLRU needs to be kept here for list integrity.
1841                  * Otherwise:
1842                  *   #0 move_pages_to_lru             #1 release_pages
1843                  *   if !put_page_testzero
1844                  *                                    if (put_page_testzero())
1845                  *                                      !PageLRU //skip lru_lock
1846                  *     SetPageLRU()
1847                  *     list_add(&page->lru,)
1848                  *                                        list_add(&page->lru,)
1849                  */
1850                 SetPageLRU(page);
1851
1852                 if (unlikely(put_page_testzero(page))) {
1853                         __clear_page_lru_flags(page);
1854
1855                         if (unlikely(PageCompound(page))) {
1856                                 spin_unlock_irq(&lruvec->lru_lock);
1857                                 destroy_compound_page(page);
1858                                 spin_lock_irq(&lruvec->lru_lock);
1859                         } else
1860                                 list_add(&page->lru, &pages_to_free);
1861
1862                         continue;
1863                 }
1864
1865                 /*
1866                  * All pages were isolated from the same lruvec (and isolation
1867                  * inhibits memcg migration).
1868                  */
1869                 VM_BUG_ON_PAGE(!lruvec_holds_page_lru_lock(page, lruvec), page);
1870                 add_page_to_lru_list(page, lruvec);
1871                 nr_pages = thp_nr_pages(page);
1872                 nr_moved += nr_pages;
1873                 if (PageActive(page))
1874                         workingset_age_nonresident(lruvec, nr_pages);
1875         }
1876
1877         /*
1878          * To save our caller's stack, now use input list for pages to free.
1879          */
1880         list_splice(&pages_to_free, list);
1881
1882         return nr_moved;
1883 }
1884
1885 /*
1886  * If a kernel thread (such as nfsd for loop-back mounts) services
1887  * a backing device by writing to the page cache it sets PF_LOCAL_THROTTLE.
1888  * In that case we should only throttle if the backing device it is
1889  * writing to is congested.  In other cases it is safe to throttle.
1890  */
1891 static int current_may_throttle(void)
1892 {
1893         return !(current->flags & PF_LOCAL_THROTTLE) ||
1894                 current->backing_dev_info == NULL ||
1895                 bdi_write_congested(current->backing_dev_info);
1896 }
1897
1898 /*
1899  * shrink_inactive_list() is a helper for shrink_node().  It returns the number
1900  * of reclaimed pages
1901  */
1902 static noinline_for_stack unsigned long
1903 shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
1904                      struct scan_control *sc, enum lru_list lru)
1905 {
1906         LIST_HEAD(page_list);
1907         unsigned long nr_scanned;
1908         unsigned int nr_reclaimed = 0;
1909         unsigned long nr_taken;
1910         struct reclaim_stat stat;
1911         bool file = is_file_lru(lru);
1912         enum vm_event_item item;
1913         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1914         bool stalled = false;
1915
1916         while (unlikely(too_many_isolated(pgdat, file, sc))) {
1917                 if (stalled)
1918                         return 0;
1919
1920                 /* wait a bit for the reclaimer. */
1921                 msleep(100);
1922                 stalled = true;
1923
1924                 /* We are about to die and free our memory. Return now. */
1925                 if (fatal_signal_pending(current))
1926                         return SWAP_CLUSTER_MAX;
1927         }
1928
1929         lru_add_drain();
1930
1931         spin_lock_irq(&lruvec->lru_lock);
1932
1933         nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &page_list,
1934                                      &nr_scanned, sc, lru);
1935
1936         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1937         item = current_is_kswapd() ? PGSCAN_KSWAPD : PGSCAN_DIRECT;
1938         if (!cgroup_reclaim(sc))
1939                 __count_vm_events(item, nr_scanned);
1940         __count_memcg_events(lruvec_memcg(lruvec), item, nr_scanned);
1941         __count_vm_events(PGSCAN_ANON + file, nr_scanned);
1942
1943         spin_unlock_irq(&lruvec->lru_lock);
1944
1945         if (nr_taken == 0)
1946                 return 0;
1947
1948         nr_reclaimed = shrink_page_list(&page_list, pgdat, sc, &stat, false);
1949
1950         spin_lock_irq(&lruvec->lru_lock);
1951         move_pages_to_lru(lruvec, &page_list);
1952
1953         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
1954         item = current_is_kswapd() ? PGSTEAL_KSWAPD : PGSTEAL_DIRECT;
1955         if (!cgroup_reclaim(sc))
1956                 __count_vm_events(item, nr_reclaimed);
1957         __count_memcg_events(lruvec_memcg(lruvec), item, nr_reclaimed);
1958         __count_vm_events(PGSTEAL_ANON + file, nr_reclaimed);
1959         spin_unlock_irq(&lruvec->lru_lock);
1960
1961         lru_note_cost(lruvec, file, stat.nr_pageout);
1962         mem_cgroup_uncharge_list(&page_list);
1963         free_unref_page_list(&page_list);
1964
1965         /*
1966          * If dirty pages are scanned that are not queued for IO, it
1967          * implies that flushers are not doing their job. This can
1968          * happen when memory pressure pushes dirty pages to the end of
1969          * the LRU before the dirty limits are breached and the dirty
1970          * data has expired. It can also happen when the proportion of
1971          * dirty pages grows not through writes but through memory
1972          * pressure reclaiming all the clean cache. And in some cases,
1973          * the flushers simply cannot keep up with the allocation
1974          * rate. Nudge the flusher threads in case they are asleep.
1975          */
1976         if (stat.nr_unqueued_dirty == nr_taken)
1977                 wakeup_flusher_threads(WB_REASON_VMSCAN);
1978
1979         sc->nr.dirty += stat.nr_dirty;
1980         sc->nr.congested += stat.nr_congested;
1981         sc->nr.unqueued_dirty += stat.nr_unqueued_dirty;
1982         sc->nr.writeback += stat.nr_writeback;
1983         sc->nr.immediate += stat.nr_immediate;
1984         sc->nr.taken += nr_taken;
1985         if (file)
1986                 sc->nr.file_taken += nr_taken;
1987
1988         trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
1989                         nr_scanned, nr_reclaimed, &stat, sc->priority, file);
1990         return nr_reclaimed;
1991 }
1992
1993 /*
1994  * shrink_active_list() moves pages from the active LRU to the inactive LRU.
1995  *
1996  * We move them the other way if the page is referenced by one or more
1997  * processes.
1998  *
1999  * If the pages are mostly unmapped, the processing is fast and it is
2000  * appropriate to hold lru_lock across the whole operation.  But if
2001  * the pages are mapped, the processing is slow (page_referenced()), so
2002  * we should drop lru_lock around each page.  It's impossible to balance
2003  * this, so instead we remove the pages from the LRU while processing them.
2004  * It is safe to rely on PG_active against the non-LRU pages in here because
2005  * nobody will play with that bit on a non-LRU page.
2006  *
2007  * The downside is that we have to touch page->_refcount against each page.
2008  * But we had to alter page->flags anyway.
2009  */
2010 static void shrink_active_list(unsigned long nr_to_scan,
2011                                struct lruvec *lruvec,
2012                                struct scan_control *sc,
2013                                enum lru_list lru)
2014 {
2015         unsigned long nr_taken;
2016         unsigned long nr_scanned;
2017         unsigned long vm_flags;
2018         LIST_HEAD(l_hold);      /* The pages which were snipped off */
2019         LIST_HEAD(l_active);
2020         LIST_HEAD(l_inactive);
2021         struct page *page;
2022         unsigned nr_deactivate, nr_activate;
2023         unsigned nr_rotated = 0;
2024         int file = is_file_lru(lru);
2025         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2026
2027         lru_add_drain();
2028
2029         spin_lock_irq(&lruvec->lru_lock);
2030
2031         nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &l_hold,
2032                                      &nr_scanned, sc, lru);
2033
2034         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
2035
2036         if (!cgroup_reclaim(sc))
2037                 __count_vm_events(PGREFILL, nr_scanned);
2038         __count_memcg_events(lruvec_memcg(lruvec), PGREFILL, nr_scanned);
2039
2040         spin_unlock_irq(&lruvec->lru_lock);
2041
2042         while (!list_empty(&l_hold)) {
2043                 cond_resched();
2044                 page = lru_to_page(&l_hold);
2045                 list_del(&page->lru);
2046
2047                 if (unlikely(!page_evictable(page))) {
2048                         putback_lru_page(page);
2049                         continue;
2050                 }
2051
2052                 if (unlikely(buffer_heads_over_limit)) {
2053                         if (page_has_private(page) && trylock_page(page)) {
2054                                 if (page_has_private(page))
2055                                         try_to_release_page(page, 0);
2056                                 unlock_page(page);
2057                         }
2058                 }
2059
2060                 if (page_referenced(page, 0, sc->target_mem_cgroup,
2061                                     &vm_flags)) {
2062                         /*
2063                          * Identify referenced, file-backed active pages and
2064                          * give them one more trip around the active list. So
2065                          * that executable code get better chances to stay in
2066                          * memory under moderate memory pressure.  Anon pages
2067                          * are not likely to be evicted by use-once streaming
2068                          * IO, plus JVM can create lots of anon VM_EXEC pages,
2069                          * so we ignore them here.
2070                          */
2071                         if ((vm_flags & VM_EXEC) && page_is_file_lru(page)) {
2072                                 nr_rotated += thp_nr_pages(page);
2073                                 list_add(&page->lru, &l_active);
2074                                 continue;
2075                         }
2076                 }
2077
2078                 ClearPageActive(page);  /* we are de-activating */
2079                 SetPageWorkingset(page);
2080                 list_add(&page->lru, &l_inactive);
2081         }
2082
2083         /*
2084          * Move pages back to the lru list.
2085          */
2086         spin_lock_irq(&lruvec->lru_lock);
2087
2088         nr_activate = move_pages_to_lru(lruvec, &l_active);
2089         nr_deactivate = move_pages_to_lru(lruvec, &l_inactive);
2090         /* Keep all free pages in l_active list */
2091         list_splice(&l_inactive, &l_active);
2092
2093         __count_vm_events(PGDEACTIVATE, nr_deactivate);
2094         __count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE, nr_deactivate);
2095
2096         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
2097         spin_unlock_irq(&lruvec->lru_lock);
2098
2099         mem_cgroup_uncharge_list(&l_active);
2100         free_unref_page_list(&l_active);
2101         trace_mm_vmscan_lru_shrink_active(pgdat->node_id, nr_taken, nr_activate,
2102                         nr_deactivate, nr_rotated, sc->priority, file);
2103 }
2104
2105 unsigned long reclaim_pages(struct list_head *page_list)
2106 {
2107         int nid = NUMA_NO_NODE;
2108         unsigned int nr_reclaimed = 0;
2109         LIST_HEAD(node_page_list);
2110         struct reclaim_stat dummy_stat;
2111         struct page *page;
2112         struct scan_control sc = {
2113                 .gfp_mask = GFP_KERNEL,
2114                 .priority = DEF_PRIORITY,
2115                 .may_writepage = 1,
2116                 .may_unmap = 1,
2117                 .may_swap = 1,
2118         };
2119
2120         while (!list_empty(page_list)) {
2121                 page = lru_to_page(page_list);
2122                 if (nid == NUMA_NO_NODE) {
2123                         nid = page_to_nid(page);
2124                         INIT_LIST_HEAD(&node_page_list);
2125                 }
2126
2127                 if (nid == page_to_nid(page)) {
2128                         ClearPageActive(page);
2129                         list_move(&page->lru, &node_page_list);
2130                         continue;
2131                 }
2132
2133                 nr_reclaimed += shrink_page_list(&node_page_list,
2134                                                 NODE_DATA(nid),
2135                                                 &sc, &dummy_stat, false);
2136                 while (!list_empty(&node_page_list)) {
2137                         page = lru_to_page(&node_page_list);
2138                         list_del(&page->lru);
2139                         putback_lru_page(page);
2140                 }
2141
2142                 nid = NUMA_NO_NODE;
2143         }
2144
2145         if (!list_empty(&node_page_list)) {
2146                 nr_reclaimed += shrink_page_list(&node_page_list,
2147                                                 NODE_DATA(nid),
2148                                                 &sc, &dummy_stat, false);
2149                 while (!list_empty(&node_page_list)) {
2150                         page = lru_to_page(&node_page_list);
2151                         list_del(&page->lru);
2152                         putback_lru_page(page);
2153                 }
2154         }
2155
2156         return nr_reclaimed;
2157 }
2158
2159 static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
2160                                  struct lruvec *lruvec, struct scan_control *sc)
2161 {
2162         if (is_active_lru(lru)) {
2163                 if (sc->may_deactivate & (1 << is_file_lru(lru)))
2164                         shrink_active_list(nr_to_scan, lruvec, sc, lru);
2165                 else
2166                         sc->skipped_deactivate = 1;
2167                 return 0;
2168         }
2169
2170         return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);
2171 }
2172
2173 /*
2174  * The inactive anon list should be small enough that the VM never has
2175  * to do too much work.
2176  *
2177  * The inactive file list should be small enough to leave most memory
2178  * to the established workingset on the scan-resistant active list,
2179  * but large enough to avoid thrashing the aggregate readahead window.
2180  *
2181  * Both inactive lists should also be large enough that each inactive
2182  * page has a chance to be referenced again before it is reclaimed.
2183  *
2184  * If that fails and refaulting is observed, the inactive list grows.
2185  *
2186  * The inactive_ratio is the target ratio of ACTIVE to INACTIVE pages
2187  * on this LRU, maintained by the pageout code. An inactive_ratio
2188  * of 3 means 3:1 or 25% of the pages are kept on the inactive list.
2189  *
2190  * total     target    max
2191  * memory    ratio     inactive
2192  * -------------------------------------
2193  *   10MB       1         5MB
2194  *  100MB       1        50MB
2195  *    1GB       3       250MB
2196  *   10GB      10       0.9GB
2197  *  100GB      31         3GB
2198  *    1TB     101        10GB
2199  *   10TB     320        32GB
2200  */
2201 static bool inactive_is_low(struct lruvec *lruvec, enum lru_list inactive_lru)
2202 {
2203         enum lru_list active_lru = inactive_lru + LRU_ACTIVE;
2204         unsigned long inactive, active;
2205         unsigned long inactive_ratio;
2206         unsigned long gb;
2207
2208         inactive = lruvec_page_state(lruvec, NR_LRU_BASE + inactive_lru);
2209         active = lruvec_page_state(lruvec, NR_LRU_BASE + active_lru);
2210
2211         gb = (inactive + active) >> (30 - PAGE_SHIFT);
2212         if (gb)
2213                 inactive_ratio = int_sqrt(10 * gb);
2214         else
2215                 inactive_ratio = 1;
2216
2217         return inactive * inactive_ratio < active;
2218 }
2219
2220 enum scan_balance {
2221         SCAN_EQUAL,
2222         SCAN_FRACT,
2223         SCAN_ANON,
2224         SCAN_FILE,
2225 };
2226
2227 /*
2228  * Determine how aggressively the anon and file LRU lists should be
2229  * scanned.  The relative value of each set of LRU lists is determined
2230  * by looking at the fraction of the pages scanned we did rotate back
2231  * onto the active list instead of evict.
2232  *
2233  * nr[0] = anon inactive pages to scan; nr[1] = anon active pages to scan
2234  * nr[2] = file inactive pages to scan; nr[3] = file active pages to scan
2235  */
2236 static void get_scan_count(struct lruvec *lruvec, struct scan_control *sc,
2237                            unsigned long *nr)
2238 {
2239         struct mem_cgroup *memcg = lruvec_memcg(lruvec);
2240         unsigned long anon_cost, file_cost, total_cost;
2241         int swappiness = mem_cgroup_swappiness(memcg);
2242         u64 fraction[ANON_AND_FILE];
2243         u64 denominator = 0;    /* gcc */
2244         enum scan_balance scan_balance;
2245         unsigned long ap, fp;
2246         enum lru_list lru;
2247
2248         /* If we have no swap space, do not bother scanning anon pages. */
2249         if (!sc->may_swap || mem_cgroup_get_nr_swap_pages(memcg) <= 0) {
2250                 scan_balance = SCAN_FILE;
2251                 goto out;
2252         }
2253
2254         /*
2255          * Global reclaim will swap to prevent OOM even with no
2256          * swappiness, but memcg users want to use this knob to
2257          * disable swapping for individual groups completely when
2258          * using the memory controller's swap limit feature would be
2259          * too expensive.
2260          */
2261         if (cgroup_reclaim(sc) && !swappiness) {
2262                 scan_balance = SCAN_FILE;
2263                 goto out;
2264         }
2265
2266         /*
2267          * Do not apply any pressure balancing cleverness when the
2268          * system is close to OOM, scan both anon and file equally
2269          * (unless the swappiness setting disagrees with swapping).
2270          */
2271         if (!sc->priority && swappiness) {
2272                 scan_balance = SCAN_EQUAL;
2273                 goto out;
2274         }
2275
2276         /*
2277          * If the system is almost out of file pages, force-scan anon.
2278          */
2279         if (sc->file_is_tiny) {
2280                 scan_balance = SCAN_ANON;
2281                 goto out;
2282         }
2283
2284         /*
2285          * If there is enough inactive page cache, we do not reclaim
2286          * anything from the anonymous working right now.
2287          */
2288         if (sc->cache_trim_mode) {
2289                 scan_balance = SCAN_FILE;
2290                 goto out;
2291         }
2292
2293         scan_balance = SCAN_FRACT;
2294         /*
2295          * Calculate the pressure balance between anon and file pages.
2296          *
2297          * The amount of pressure we put on each LRU is inversely
2298          * proportional to the cost of reclaiming each list, as
2299          * determined by the share of pages that are refaulting, times
2300          * the relative IO cost of bringing back a swapped out
2301          * anonymous page vs reloading a filesystem page (swappiness).
2302          *
2303          * Although we limit that influence to ensure no list gets
2304          * left behind completely: at least a third of the pressure is
2305          * applied, before swappiness.
2306          *
2307          * With swappiness at 100, anon and file have equal IO cost.
2308          */
2309         total_cost = sc->anon_cost + sc->file_cost;
2310         anon_cost = total_cost + sc->anon_cost;
2311         file_cost = total_cost + sc->file_cost;
2312         total_cost = anon_cost + file_cost;
2313
2314         ap = swappiness * (total_cost + 1);
2315         ap /= anon_cost + 1;
2316
2317         fp = (200 - swappiness) * (total_cost + 1);
2318         fp /= file_cost + 1;
2319
2320         fraction[0] = ap;
2321         fraction[1] = fp;
2322         denominator = ap + fp;
2323 out:
2324         for_each_evictable_lru(lru) {
2325                 int file = is_file_lru(lru);
2326                 unsigned long lruvec_size;
2327                 unsigned long scan;
2328                 unsigned long protection;
2329
2330                 lruvec_size = lruvec_lru_size(lruvec, lru, sc->reclaim_idx);
2331                 protection = mem_cgroup_protection(sc->target_mem_cgroup,
2332                                                    memcg,
2333                                                    sc->memcg_low_reclaim);
2334
2335                 if (protection) {
2336                         /*
2337                          * Scale a cgroup's reclaim pressure by proportioning
2338                          * its current usage to its memory.low or memory.min
2339                          * setting.
2340                          *
2341                          * This is important, as otherwise scanning aggression
2342                          * becomes extremely binary -- from nothing as we
2343                          * approach the memory protection threshold, to totally
2344                          * nominal as we exceed it.  This results in requiring
2345                          * setting extremely liberal protection thresholds. It
2346                          * also means we simply get no protection at all if we
2347                          * set it too low, which is not ideal.
2348                          *
2349                          * If there is any protection in place, we reduce scan
2350                          * pressure by how much of the total memory used is
2351                          * within protection thresholds.
2352                          *
2353                          * There is one special case: in the first reclaim pass,
2354                          * we skip over all groups that are within their low
2355                          * protection. If that fails to reclaim enough pages to
2356                          * satisfy the reclaim goal, we come back and override
2357                          * the best-effort low protection. However, we still
2358                          * ideally want to honor how well-behaved groups are in
2359                          * that case instead of simply punishing them all
2360                          * equally. As such, we reclaim them based on how much
2361                          * memory they are using, reducing the scan pressure
2362                          * again by how much of the total memory used is under
2363                          * hard protection.
2364                          */
2365                         unsigned long cgroup_size = mem_cgroup_size(memcg);
2366
2367                         /* Avoid TOCTOU with earlier protection check */
2368                         cgroup_size = max(cgroup_size, protection);
2369
2370                         scan = lruvec_size - lruvec_size * protection /
2371                                 cgroup_size;
2372
2373                         /*
2374                          * Minimally target SWAP_CLUSTER_MAX pages to keep
2375                          * reclaim moving forwards, avoiding decrementing
2376                          * sc->priority further than desirable.
2377                          */
2378                         scan = max(scan, SWAP_CLUSTER_MAX);
2379                 } else {
2380                         scan = lruvec_size;
2381                 }
2382
2383                 scan >>= sc->priority;
2384
2385                 /*
2386                  * If the cgroup's already been deleted, make sure to
2387                  * scrape out the remaining cache.
2388                  */
2389                 if (!scan && !mem_cgroup_online(memcg))
2390                         scan = min(lruvec_size, SWAP_CLUSTER_MAX);
2391
2392                 switch (scan_balance) {
2393                 case SCAN_EQUAL:
2394                         /* Scan lists relative to size */
2395                         break;
2396                 case SCAN_FRACT:
2397                         /*
2398                          * Scan types proportional to swappiness and
2399                          * their relative recent reclaim efficiency.
2400                          * Make sure we don't miss the last page on
2401                          * the offlined memory cgroups because of a
2402                          * round-off error.
2403                          */
2404                         scan = mem_cgroup_online(memcg) ?
2405                                div64_u64(scan * fraction[file], denominator) :
2406                                DIV64_U64_ROUND_UP(scan * fraction[file],
2407                                                   denominator);
2408                         break;
2409                 case SCAN_FILE:
2410                 case SCAN_ANON:
2411                         /* Scan one type exclusively */
2412                         if ((scan_balance == SCAN_FILE) != file)
2413                                 scan = 0;
2414                         break;
2415                 default:
2416                         /* Look ma, no brain */
2417                         BUG();
2418                 }
2419
2420                 nr[lru] = scan;
2421         }
2422 }
2423
2424 static void shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc)
2425 {
2426         unsigned long nr[NR_LRU_LISTS];
2427         unsigned long targets[NR_LRU_LISTS];
2428         unsigned long nr_to_scan;
2429         enum lru_list lru;
2430         unsigned long nr_reclaimed = 0;
2431         unsigned long nr_to_reclaim = sc->nr_to_reclaim;
2432         struct blk_plug plug;
2433         bool scan_adjusted;
2434
2435         get_scan_count(lruvec, sc, nr);
2436
2437         /* Record the original scan target for proportional adjustments later */
2438         memcpy(targets, nr, sizeof(nr));
2439
2440         /*
2441          * Global reclaiming within direct reclaim at DEF_PRIORITY is a normal
2442          * event that can occur when there is little memory pressure e.g.
2443          * multiple streaming readers/writers. Hence, we do not abort scanning
2444          * when the requested number of pages are reclaimed when scanning at
2445          * DEF_PRIORITY on the assumption that the fact we are direct
2446          * reclaiming implies that kswapd is not keeping up and it is best to
2447          * do a batch of work at once. For memcg reclaim one check is made to
2448          * abort proportional reclaim if either the file or anon lru has already
2449          * dropped to zero at the first pass.
2450          */
2451         scan_adjusted = (!cgroup_reclaim(sc) && !current_is_kswapd() &&
2452                          sc->priority == DEF_PRIORITY);
2453
2454         blk_start_plug(&plug);
2455         while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
2456                                         nr[LRU_INACTIVE_FILE]) {
2457                 unsigned long nr_anon, nr_file, percentage;
2458                 unsigned long nr_scanned;
2459
2460                 for_each_evictable_lru(lru) {
2461                         if (nr[lru]) {
2462                                 nr_to_scan = min(nr[lru], SWAP_CLUSTER_MAX);
2463                                 nr[lru] -= nr_to_scan;
2464
2465                                 nr_reclaimed += shrink_list(lru, nr_to_scan,
2466                                                             lruvec, sc);
2467                         }
2468                 }
2469
2470                 cond_resched();
2471
2472                 if (nr_reclaimed < nr_to_reclaim || scan_adjusted)
2473                         continue;
2474
2475                 /*
2476                  * For kswapd and memcg, reclaim at least the number of pages
2477                  * requested. Ensure that the anon and file LRUs are scanned
2478                  * proportionally what was requested by get_scan_count(). We
2479                  * stop reclaiming one LRU and reduce the amount scanning
2480                  * proportional to the original scan target.
2481                  */
2482                 nr_file = nr[LRU_INACTIVE_FILE] + nr[LRU_ACTIVE_FILE];
2483                 nr_anon = nr[LRU_INACTIVE_ANON] + nr[LRU_ACTIVE_ANON];
2484
2485                 /*
2486                  * It's just vindictive to attack the larger once the smaller
2487                  * has gone to zero.  And given the way we stop scanning the
2488                  * smaller below, this makes sure that we only make one nudge
2489                  * towards proportionality once we've got nr_to_reclaim.
2490                  */
2491                 if (!nr_file || !nr_anon)
2492                         break;
2493
2494                 if (nr_file > nr_anon) {
2495                         unsigned long scan_target = targets[LRU_INACTIVE_ANON] +
2496                                                 targets[LRU_ACTIVE_ANON] + 1;
2497                         lru = LRU_BASE;
2498                         percentage = nr_anon * 100 / scan_target;
2499                 } else {
2500                         unsigned long scan_target = targets[LRU_INACTIVE_FILE] +
2501                                                 targets[LRU_ACTIVE_FILE] + 1;
2502                         lru = LRU_FILE;
2503                         percentage = nr_file * 100 / scan_target;
2504                 }
2505
2506                 /* Stop scanning the smaller of the LRU */
2507                 nr[lru] = 0;
2508                 nr[lru + LRU_ACTIVE] = 0;
2509
2510                 /*
2511                  * Recalculate the other LRU scan count based on its original
2512                  * scan target and the percentage scanning already complete
2513                  */
2514                 lru = (lru == LRU_FILE) ? LRU_BASE : LRU_FILE;
2515                 nr_scanned = targets[lru] - nr[lru];
2516                 nr[lru] = targets[lru] * (100 - percentage) / 100;
2517                 nr[lru] -= min(nr[lru], nr_scanned);
2518
2519                 lru += LRU_ACTIVE;
2520                 nr_scanned = targets[lru] - nr[lru];
2521                 nr[lru] = targets[lru] * (100 - percentage) / 100;
2522                 nr[lru] -= min(nr[lru], nr_scanned);
2523
2524                 scan_adjusted = true;
2525         }
2526         blk_finish_plug(&plug);
2527         sc->nr_reclaimed += nr_reclaimed;
2528
2529         /*
2530          * Even if we did not try to evict anon pages at all, we want to
2531          * rebalance the anon lru active/inactive ratio.
2532          */
2533         if (total_swap_pages && inactive_is_low(lruvec, LRU_INACTIVE_ANON))
2534                 shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
2535                                    sc, LRU_ACTIVE_ANON);
2536 }
2537
2538 /* Use reclaim/compaction for costly allocs or under memory pressure */
2539 static bool in_reclaim_compaction(struct scan_control *sc)
2540 {
2541         if (IS_ENABLED(CONFIG_COMPACTION) && sc->order &&
2542                         (sc->order > PAGE_ALLOC_COSTLY_ORDER ||
2543                          sc->priority < DEF_PRIORITY - 2))
2544                 return true;
2545
2546         return false;
2547 }
2548
2549 /*
2550  * Reclaim/compaction is used for high-order allocation requests. It reclaims
2551  * order-0 pages before compacting the zone. should_continue_reclaim() returns
2552  * true if more pages should be reclaimed such that when the page allocator
2553  * calls try_to_compact_pages() that it will have enough free pages to succeed.
2554  * It will give up earlier than that if there is difficulty reclaiming pages.
2555  */
2556 static inline bool should_continue_reclaim(struct pglist_data *pgdat,
2557                                         unsigned long nr_reclaimed,
2558                                         struct scan_control *sc)
2559 {
2560         unsigned long pages_for_compaction;
2561         unsigned long inactive_lru_pages;
2562         int z;
2563
2564         /* If not in reclaim/compaction mode, stop */
2565         if (!in_reclaim_compaction(sc))
2566                 return false;
2567
2568         /*
2569          * Stop if we failed to reclaim any pages from the last SWAP_CLUSTER_MAX
2570          * number of pages that were scanned. This will return to the caller
2571          * with the risk reclaim/compaction and the resulting allocation attempt
2572          * fails. In the past we have tried harder for __GFP_RETRY_MAYFAIL
2573          * allocations through requiring that the full LRU list has been scanned
2574          * first, by assuming that zero delta of sc->nr_scanned means full LRU
2575          * scan, but that approximation was wrong, and there were corner cases
2576          * where always a non-zero amount of pages were scanned.
2577          */
2578         if (!nr_reclaimed)
2579                 return false;
2580
2581         /* If compaction would go ahead or the allocation would succeed, stop */
2582         for (z = 0; z <= sc->reclaim_idx; z++) {
2583                 struct zone *zone = &pgdat->node_zones[z];
2584                 if (!managed_zone(zone))
2585                         continue;
2586
2587                 switch (compaction_suitable(zone, sc->order, 0, sc->reclaim_idx)) {
2588                 case COMPACT_SUCCESS:
2589                 case COMPACT_CONTINUE:
2590                         return false;
2591                 default:
2592                         /* check next zone */
2593                         ;
2594                 }
2595         }
2596
2597         /*
2598          * If we have not reclaimed enough pages for compaction and the
2599          * inactive lists are large enough, continue reclaiming
2600          */
2601         pages_for_compaction = compact_gap(sc->order);
2602         inactive_lru_pages = node_page_state(pgdat, NR_INACTIVE_FILE);
2603         if (get_nr_swap_pages() > 0)
2604                 inactive_lru_pages += node_page_state(pgdat, NR_INACTIVE_ANON);
2605
2606         return inactive_lru_pages > pages_for_compaction;
2607 }
2608
2609 static void shrink_node_memcgs(pg_data_t *pgdat, struct scan_control *sc)
2610 {
2611         struct mem_cgroup *target_memcg = sc->target_mem_cgroup;
2612         struct mem_cgroup *memcg;
2613
2614         memcg = mem_cgroup_iter(target_memcg, NULL, NULL);
2615         do {
2616                 struct lruvec *lruvec = mem_cgroup_lruvec(memcg, pgdat);
2617                 unsigned long reclaimed;
2618                 unsigned long scanned;
2619
2620                 /*
2621                  * This loop can become CPU-bound when target memcgs
2622                  * aren't eligible for reclaim - either because they
2623                  * don't have any reclaimable pages, or because their
2624                  * memory is explicitly protected. Avoid soft lockups.
2625                  */
2626                 cond_resched();
2627
2628                 mem_cgroup_calculate_protection(target_memcg, memcg);
2629
2630                 if (mem_cgroup_below_min(memcg)) {
2631                         /*
2632                          * Hard protection.
2633                          * If there is no reclaimable memory, OOM.
2634                          */
2635                         continue;
2636                 } else if (mem_cgroup_below_low(memcg)) {
2637                         /*
2638                          * Soft protection.
2639                          * Respect the protection only as long as
2640                          * there is an unprotected supply
2641                          * of reclaimable memory from other cgroups.
2642                          */
2643                         if (!sc->memcg_low_reclaim) {
2644                                 sc->memcg_low_skipped = 1;
2645                                 continue;
2646                         }
2647                         memcg_memory_event(memcg, MEMCG_LOW);
2648                 }
2649
2650                 reclaimed = sc->nr_reclaimed;
2651                 scanned = sc->nr_scanned;
2652
2653                 shrink_lruvec(lruvec, sc);
2654
2655                 shrink_slab(sc->gfp_mask, pgdat->node_id, memcg,
2656                             sc->priority);
2657
2658                 /* Record the group's reclaim efficiency */
2659                 vmpressure(sc->gfp_mask, memcg, false,
2660                            sc->nr_scanned - scanned,
2661                            sc->nr_reclaimed - reclaimed);
2662
2663         } while ((memcg = mem_cgroup_iter(target_memcg, memcg, NULL)));
2664 }
2665
2666 static void shrink_node(pg_data_t *pgdat, struct scan_control *sc)
2667 {
2668         struct reclaim_state *reclaim_state = current->reclaim_state;
2669         unsigned long nr_reclaimed, nr_scanned;
2670         struct lruvec *target_lruvec;
2671         bool reclaimable = false;
2672         unsigned long file;
2673
2674         target_lruvec = mem_cgroup_lruvec(sc->target_mem_cgroup, pgdat);
2675
2676 again:
2677         memset(&sc->nr, 0, sizeof(sc->nr));
2678
2679         nr_reclaimed = sc->nr_reclaimed;
2680         nr_scanned = sc->nr_scanned;
2681
2682         /*
2683          * Determine the scan balance between anon and file LRUs.
2684          */
2685         spin_lock_irq(&target_lruvec->lru_lock);
2686         sc->anon_cost = target_lruvec->anon_cost;
2687         sc->file_cost = target_lruvec->file_cost;
2688         spin_unlock_irq(&target_lruvec->lru_lock);
2689
2690         /*
2691          * Target desirable inactive:active list ratios for the anon
2692          * and file LRU lists.
2693          */
2694         if (!sc->force_deactivate) {
2695                 unsigned long refaults;
2696
2697                 refaults = lruvec_page_state(target_lruvec,
2698                                 WORKINGSET_ACTIVATE_ANON);
2699                 if (refaults != target_lruvec->refaults[0] ||
2700                         inactive_is_low(target_lruvec, LRU_INACTIVE_ANON))
2701                         sc->may_deactivate |= DEACTIVATE_ANON;
2702                 else
2703                         sc->may_deactivate &= ~DEACTIVATE_ANON;
2704
2705                 /*
2706                  * When refaults are being observed, it means a new
2707                  * workingset is being established. Deactivate to get
2708                  * rid of any stale active pages quickly.
2709                  */
2710                 refaults = lruvec_page_state(target_lruvec,
2711                                 WORKINGSET_ACTIVATE_FILE);
2712                 if (refaults != target_lruvec->refaults[1] ||
2713                     inactive_is_low(target_lruvec, LRU_INACTIVE_FILE))
2714                         sc->may_deactivate |= DEACTIVATE_FILE;
2715                 else
2716                         sc->may_deactivate &= ~DEACTIVATE_FILE;
2717         } else
2718                 sc->may_deactivate = DEACTIVATE_ANON | DEACTIVATE_FILE;
2719
2720         /*
2721          * If we have plenty of inactive file pages that aren't
2722          * thrashing, try to reclaim those first before touching
2723          * anonymous pages.
2724          */
2725         file = lruvec_page_state(target_lruvec, NR_INACTIVE_FILE);
2726         if (file >> sc->priority && !(sc->may_deactivate & DEACTIVATE_FILE))
2727                 sc->cache_trim_mode = 1;
2728         else
2729                 sc->cache_trim_mode = 0;
2730
2731         /*
2732          * Prevent the reclaimer from falling into the cache trap: as
2733          * cache pages start out inactive, every cache fault will tip
2734          * the scan balance towards the file LRU.  And as the file LRU
2735          * shrinks, so does the window for rotation from references.
2736          * This means we have a runaway feedback loop where a tiny
2737          * thrashing file LRU becomes infinitely more attractive than
2738          * anon pages.  Try to detect this based on file LRU size.
2739          */
2740         if (!cgroup_reclaim(sc)) {
2741                 unsigned long total_high_wmark = 0;
2742                 unsigned long free, anon;
2743                 int z;
2744
2745                 free = sum_zone_node_page_state(pgdat->node_id, NR_FREE_PAGES);
2746                 file = node_page_state(pgdat, NR_ACTIVE_FILE) +
2747                            node_page_state(pgdat, NR_INACTIVE_FILE);
2748
2749                 for (z = 0; z < MAX_NR_ZONES; z++) {
2750                         struct zone *zone = &pgdat->node_zones[z];
2751                         if (!managed_zone(zone))
2752                                 continue;
2753
2754                         total_high_wmark += high_wmark_pages(zone);
2755                 }
2756
2757                 /*
2758                  * Consider anon: if that's low too, this isn't a
2759                  * runaway file reclaim problem, but rather just
2760                  * extreme pressure. Reclaim as per usual then.
2761                  */
2762                 anon = node_page_state(pgdat, NR_INACTIVE_ANON);
2763
2764                 sc->file_is_tiny =
2765                         file + free <= total_high_wmark &&
2766                         !(sc->may_deactivate & DEACTIVATE_ANON) &&
2767                         anon >> sc->priority;
2768         }
2769
2770         shrink_node_memcgs(pgdat, sc);
2771
2772         if (reclaim_state) {
2773                 sc->nr_reclaimed += reclaim_state->reclaimed_slab;
2774                 reclaim_state->reclaimed_slab = 0;
2775         }
2776
2777         /* Record the subtree's reclaim efficiency */
2778         vmpressure(sc->gfp_mask, sc->target_mem_cgroup, true,
2779                    sc->nr_scanned - nr_scanned,
2780                    sc->nr_reclaimed - nr_reclaimed);
2781
2782         if (sc->nr_reclaimed - nr_reclaimed)
2783                 reclaimable = true;
2784
2785         if (current_is_kswapd()) {
2786                 /*
2787                  * If reclaim is isolating dirty pages under writeback,
2788                  * it implies that the long-lived page allocation rate
2789                  * is exceeding the page laundering rate. Either the
2790                  * global limits are not being effective at throttling
2791                  * processes due to the page distribution throughout
2792                  * zones or there is heavy usage of a slow backing
2793                  * device. The only option is to throttle from reclaim
2794                  * context which is not ideal as there is no guarantee
2795                  * the dirtying process is throttled in the same way
2796                  * balance_dirty_pages() manages.
2797                  *
2798                  * Once a node is flagged PGDAT_WRITEBACK, kswapd will
2799                  * count the number of pages under pages flagged for
2800                  * immediate reclaim and stall if any are encountered
2801                  * in the nr_immediate check below.
2802                  */
2803                 if (sc->nr.writeback && sc->nr.writeback == sc->nr.taken)
2804                         set_bit(PGDAT_WRITEBACK, &pgdat->flags);
2805
2806                 /* Allow kswapd to start writing pages during reclaim.*/
2807                 if (sc->nr.unqueued_dirty == sc->nr.file_taken)
2808                         set_bit(PGDAT_DIRTY, &pgdat->flags);
2809
2810                 /*
2811                  * If kswapd scans pages marked for immediate
2812                  * reclaim and under writeback (nr_immediate), it
2813                  * implies that pages are cycling through the LRU
2814                  * faster than they are written so also forcibly stall.
2815                  */
2816                 if (sc->nr.immediate)
2817                         congestion_wait(BLK_RW_ASYNC, HZ/10);
2818         }
2819
2820         /*
2821          * Tag a node/memcg as congested if all the dirty pages
2822          * scanned were backed by a congested BDI and
2823          * wait_iff_congested will stall.
2824          *
2825          * Legacy memcg will stall in page writeback so avoid forcibly
2826          * stalling in wait_iff_congested().
2827          */
2828         if ((current_is_kswapd() ||
2829              (cgroup_reclaim(sc) && writeback_throttling_sane(sc))) &&
2830             sc->nr.dirty && sc->nr.dirty == sc->nr.congested)
2831                 set_bit(LRUVEC_CONGESTED, &target_lruvec->flags);
2832
2833         /*
2834          * Stall direct reclaim for IO completions if underlying BDIs
2835          * and node is congested. Allow kswapd to continue until it
2836          * starts encountering unqueued dirty pages or cycling through
2837          * the LRU too quickly.
2838          */
2839         if (!current_is_kswapd() && current_may_throttle() &&
2840             !sc->hibernation_mode &&
2841             test_bit(LRUVEC_CONGESTED, &target_lruvec->flags))
2842                 wait_iff_congested(BLK_RW_ASYNC, HZ/10);
2843
2844         if (should_continue_reclaim(pgdat, sc->nr_reclaimed - nr_reclaimed,
2845                                     sc))
2846                 goto again;
2847
2848         /*
2849          * Kswapd gives up on balancing particular nodes after too
2850          * many failures to reclaim anything from them and goes to
2851          * sleep. On reclaim progress, reset the failure counter. A
2852          * successful direct reclaim run will revive a dormant kswapd.
2853          */
2854         if (reclaimable)
2855                 pgdat->kswapd_failures = 0;
2856 }
2857
2858 /*
2859  * Returns true if compaction should go ahead for a costly-order request, or
2860  * the allocation would already succeed without compaction. Return false if we
2861  * should reclaim first.
2862  */
2863 static inline bool compaction_ready(struct zone *zone, struct scan_control *sc)
2864 {
2865         unsigned long watermark;
2866         enum compact_result suitable;
2867
2868         suitable = compaction_suitable(zone, sc->order, 0, sc->reclaim_idx);
2869         if (suitable == COMPACT_SUCCESS)
2870                 /* Allocation should succeed already. Don't reclaim. */
2871                 return true;
2872         if (suitable == COMPACT_SKIPPED)
2873                 /* Compaction cannot yet proceed. Do reclaim. */
2874                 return false;
2875
2876         /*
2877          * Compaction is already possible, but it takes time to run and there
2878          * are potentially other callers using the pages just freed. So proceed
2879          * with reclaim to make a buffer of free pages available to give
2880          * compaction a reasonable chance of completing and allocating the page.
2881          * Note that we won't actually reclaim the whole buffer in one attempt
2882          * as the target watermark in should_continue_reclaim() is lower. But if
2883          * we are already above the high+gap watermark, don't reclaim at all.
2884          */
2885         watermark = high_wmark_pages(zone) + compact_gap(sc->order);
2886
2887         return zone_watermark_ok_safe(zone, 0, watermark, sc->reclaim_idx);
2888 }
2889
2890 /*
2891  * This is the direct reclaim path, for page-allocating processes.  We only
2892  * try to reclaim pages from zones which will satisfy the caller's allocation
2893  * request.
2894  *
2895  * If a zone is deemed to be full of pinned pages then just give it a light
2896  * scan then give up on it.
2897  */
2898 static void shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
2899 {
2900         struct zoneref *z;
2901         struct zone *zone;
2902         unsigned long nr_soft_reclaimed;
2903         unsigned long nr_soft_scanned;
2904         gfp_t orig_mask;
2905         pg_data_t *last_pgdat = NULL;
2906
2907         /*
2908          * If the number of buffer_heads in the machine exceeds the maximum
2909          * allowed level, force direct reclaim to scan the highmem zone as
2910          * highmem pages could be pinning lowmem pages storing buffer_heads
2911          */
2912         orig_mask = sc->gfp_mask;
2913         if (buffer_heads_over_limit) {
2914                 sc->gfp_mask |= __GFP_HIGHMEM;
2915                 sc->reclaim_idx = gfp_zone(sc->gfp_mask);
2916         }
2917
2918         for_each_zone_zonelist_nodemask(zone, z, zonelist,
2919                                         sc->reclaim_idx, sc->nodemask) {
2920                 /*
2921                  * Take care memory controller reclaiming has small influence
2922                  * to global LRU.
2923                  */
2924                 if (!cgroup_reclaim(sc)) {
2925                         if (!cpuset_zone_allowed(zone,
2926                                                  GFP_KERNEL | __GFP_HARDWALL))
2927                                 continue;
2928
2929                         /*
2930                          * If we already have plenty of memory free for
2931                          * compaction in this zone, don't free any more.
2932                          * Even though compaction is invoked for any
2933                          * non-zero order, only frequent costly order
2934                          * reclamation is disruptive enough to become a
2935                          * noticeable problem, like transparent huge
2936                          * page allocations.
2937                          */
2938                         if (IS_ENABLED(CONFIG_COMPACTION) &&
2939                             sc->order > PAGE_ALLOC_COSTLY_ORDER &&
2940                             compaction_ready(zone, sc)) {
2941                                 sc->compaction_ready = true;
2942                                 continue;
2943                         }
2944
2945                         /*
2946                          * Shrink each node in the zonelist once. If the
2947                          * zonelist is ordered by zone (not the default) then a
2948                          * node may be shrunk multiple times but in that case
2949                          * the user prefers lower zones being preserved.
2950                          */
2951                         if (zone->zone_pgdat == last_pgdat)
2952                                 continue;
2953
2954                         /*
2955                          * This steals pages from memory cgroups over softlimit
2956                          * and returns the number of reclaimed pages and
2957                          * scanned pages. This works for global memory pressure
2958                          * and balancing, not for a memcg's limit.
2959                          */
2960                         nr_soft_scanned = 0;
2961                         nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone->zone_pgdat,
2962                                                 sc->order, sc->gfp_mask,
2963                                                 &nr_soft_scanned);
2964                         sc->nr_reclaimed += nr_soft_reclaimed;
2965                         sc->nr_scanned += nr_soft_scanned;
2966                         /* need some check for avoid more shrink_zone() */
2967                 }
2968
2969                 /* See comment about same check for global reclaim above */
2970                 if (zone->zone_pgdat == last_pgdat)
2971                         continue;
2972                 last_pgdat = zone->zone_pgdat;
2973                 shrink_node(zone->zone_pgdat, sc);
2974         }
2975
2976         /*
2977          * Restore to original mask to avoid the impact on the caller if we
2978          * promoted it to __GFP_HIGHMEM.
2979          */
2980         sc->gfp_mask = orig_mask;
2981 }
2982
2983 static void snapshot_refaults(struct mem_cgroup *target_memcg, pg_data_t *pgdat)
2984 {
2985         struct lruvec *target_lruvec;
2986         unsigned long refaults;
2987
2988         target_lruvec = mem_cgroup_lruvec(target_memcg, pgdat);
2989         refaults = lruvec_page_state(target_lruvec, WORKINGSET_ACTIVATE_ANON);
2990         target_lruvec->refaults[0] = refaults;
2991         refaults = lruvec_page_state(target_lruvec, WORKINGSET_ACTIVATE_FILE);
2992         target_lruvec->refaults[1] = refaults;
2993 }
2994
2995 /*
2996  * This is the main entry point to direct page reclaim.
2997  *
2998  * If a full scan of the inactive list fails to free enough memory then we
2999  * are "out of memory" and something needs to be killed.
3000  *
3001  * If the caller is !__GFP_FS then the probability of a failure is reasonably
3002  * high - the zone may be full of dirty or under-writeback pages, which this
3003  * caller can't do much about.  We kick the writeback threads and take explicit
3004  * naps in the hope that some of these pages can be written.  But if the
3005  * allocating task holds filesystem locks which prevent writeout this might not
3006  * work, and the allocation attempt will fail.
3007  *
3008  * returns:     0, if no pages reclaimed
3009  *              else, the number of pages reclaimed
3010  */
3011 static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
3012                                           struct scan_control *sc)
3013 {
3014         int initial_priority = sc->priority;
3015         pg_data_t *last_pgdat;
3016         struct zoneref *z;
3017         struct zone *zone;
3018 retry:
3019         delayacct_freepages_start();
3020
3021         if (!cgroup_reclaim(sc))
3022                 __count_zid_vm_events(ALLOCSTALL, sc->reclaim_idx, 1);
3023
3024         do {
3025                 vmpressure_prio(sc->gfp_mask, sc->target_mem_cgroup,
3026                                 sc->priority);
3027                 sc->nr_scanned = 0;
3028                 shrink_zones(zonelist, sc);
3029
3030                 if (sc->nr_reclaimed >= sc->nr_to_reclaim)
3031                         break;
3032
3033                 if (sc->compaction_ready)
3034                         break;
3035
3036                 /*
3037                  * If we're getting trouble reclaiming, start doing
3038                  * writepage even in laptop mode.
3039                  */
3040                 if (sc->priority < DEF_PRIORITY - 2)
3041                         sc->may_writepage = 1;
3042         } while (--sc->priority >= 0);
3043
3044         last_pgdat = NULL;
3045         for_each_zone_zonelist_nodemask(zone, z, zonelist, sc->reclaim_idx,
3046                                         sc->nodemask) {
3047                 if (zone->zone_pgdat == last_pgdat)
3048                         continue;
3049                 last_pgdat = zone->zone_pgdat;
3050
3051                 snapshot_refaults(sc->target_mem_cgroup, zone->zone_pgdat);
3052
3053                 if (cgroup_reclaim(sc)) {
3054                         struct lruvec *lruvec;
3055
3056                         lruvec = mem_cgroup_lruvec(sc->target_mem_cgroup,
3057                                                    zone->zone_pgdat);
3058                         clear_bit(LRUVEC_CONGESTED, &lruvec->flags);
3059                 }
3060         }
3061
3062         delayacct_freepages_end();
3063
3064         if (sc->nr_reclaimed)
3065                 return sc->nr_reclaimed;
3066
3067         /* Aborted reclaim to try compaction? don't OOM, then */
3068         if (sc->compaction_ready)
3069                 return 1;
3070
3071         /*
3072          * We make inactive:active ratio decisions based on the node's
3073          * composition of memory, but a restrictive reclaim_idx or a
3074          * memory.low cgroup setting can exempt large amounts of
3075          * memory from reclaim. Neither of which are very common, so
3076          * instead of doing costly eligibility calculations of the
3077          * entire cgroup subtree up front, we assume the estimates are
3078          * good, and retry with forcible deactivation if that fails.
3079          */
3080         if (sc->skipped_deactivate) {
3081                 sc->priority = initial_priority;
3082                 sc->force_deactivate = 1;
3083                 sc->skipped_deactivate = 0;
3084                 goto retry;
3085         }
3086
3087         /* Untapped cgroup reserves?  Don't OOM, retry. */
3088         if (sc->memcg_low_skipped) {
3089                 sc->priority = initial_priority;
3090                 sc->force_deactivate = 0;
3091                 sc->memcg_low_reclaim = 1;
3092                 sc->memcg_low_skipped = 0;
3093                 goto retry;
3094         }
3095
3096         return 0;
3097 }
3098
3099 static bool allow_direct_reclaim(pg_data_t *pgdat)
3100 {
3101         struct zone *zone;
3102         unsigned long pfmemalloc_reserve = 0;
3103         unsigned long free_pages = 0;
3104         int i;
3105         bool wmark_ok;
3106
3107         if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
3108                 return true;
3109
3110         for (i = 0; i <= ZONE_NORMAL; i++) {
3111                 zone = &pgdat->node_zones[i];
3112                 if (!managed_zone(zone))
3113                         continue;
3114
3115                 if (!zone_reclaimable_pages(zone))
3116                         continue;
3117
3118                 pfmemalloc_reserve += min_wmark_pages(zone);
3119                 free_pages += zone_page_state(zone, NR_FREE_PAGES);
3120         }
3121
3122         /* If there are no reserves (unexpected config) then do not throttle */
3123         if (!pfmemalloc_reserve)
3124                 return true;
3125
3126         wmark_ok = free_pages > pfmemalloc_reserve / 2;
3127
3128         /* kswapd must be awake if processes are being throttled */
3129         if (!wmark_ok && waitqueue_active(&pgdat->kswapd_wait)) {
3130                 if (READ_ONCE(pgdat->kswapd_highest_zoneidx) > ZONE_NORMAL)
3131                         WRITE_ONCE(pgdat->kswapd_highest_zoneidx, ZONE_NORMAL);
3132
3133                 wake_up_interruptible(&pgdat->kswapd_wait);
3134         }
3135
3136         return wmark_ok;
3137 }
3138
3139 /*
3140  * Throttle direct reclaimers if backing storage is backed by the network
3141  * and the PFMEMALLOC reserve for the preferred node is getting dangerously
3142  * depleted. kswapd will continue to make progress and wake the processes
3143  * when the low watermark is reached.
3144  *
3145  * Returns true if a fatal signal was delivered during throttling. If this
3146  * happens, the page allocator should not consider triggering the OOM killer.
3147  */
3148 static bool throttle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
3149                                         nodemask_t *nodemask)
3150 {
3151         struct zoneref *z;
3152         struct zone *zone;
3153         pg_data_t *pgdat = NULL;
3154
3155         /*
3156          * Kernel threads should not be throttled as they may be indirectly
3157          * responsible for cleaning pages necessary for reclaim to make forward
3158          * progress. kjournald for example may enter direct reclaim while
3159          * committing a transaction where throttling it could forcing other
3160          * processes to block on log_wait_commit().
3161          */
3162         if (current->flags & PF_KTHREAD)
3163                 goto out;
3164
3165         /*
3166          * If a fatal signal is pending, this process should not throttle.
3167          * It should return quickly so it can exit and free its memory
3168          */
3169         if (fatal_signal_pending(current))
3170                 goto out;
3171
3172         /*
3173          * Check if the pfmemalloc reserves are ok by finding the first node
3174          * with a usable ZONE_NORMAL or lower zone. The expectation is that
3175          * GFP_KERNEL will be required for allocating network buffers when
3176          * swapping over the network so ZONE_HIGHMEM is unusable.
3177          *
3178          * Throttling is based on the first usable node and throttled processes
3179          * wait on a queue until kswapd makes progress and wakes them. There
3180          * is an affinity then between processes waking up and where reclaim
3181          * progress has been made assuming the process wakes on the same node.
3182          * More importantly, processes running on remote nodes will not compete
3183          * for remote pfmemalloc reserves and processes on different nodes
3184          * should make reasonable progress.
3185          */
3186         for_each_zone_zonelist_nodemask(zone, z, zonelist,
3187                                         gfp_zone(gfp_mask), nodemask) {
3188                 if (zone_idx(zone) > ZONE_NORMAL)
3189                         continue;
3190
3191                 /* Throttle based on the first usable node */
3192                 pgdat = zone->zone_pgdat;
3193                 if (allow_direct_reclaim(pgdat))
3194                         goto out;
3195                 break;
3196         }
3197
3198         /* If no zone was usable by the allocation flags then do not throttle */
3199         if (!pgdat)
3200                 goto out;
3201
3202         /* Account for the throttling */
3203         count_vm_event(PGSCAN_DIRECT_THROTTLE);
3204
3205         /*
3206          * If the caller cannot enter the filesystem, it's possible that it
3207          * is due to the caller holding an FS lock or performing a journal
3208          * transaction in the case of a filesystem like ext[3|4]. In this case,
3209          * it is not safe to block on pfmemalloc_wait as kswapd could be
3210          * blocked waiting on the same lock. Instead, throttle for up to a
3211          * second before continuing.
3212          */
3213         if (!(gfp_mask & __GFP_FS)) {
3214                 wait_event_interruptible_timeout(pgdat->pfmemalloc_wait,
3215                         allow_direct_reclaim(pgdat), HZ);
3216
3217                 goto check_pending;
3218         }
3219
3220         /* Throttle until kswapd wakes the process */
3221         wait_event_killable(zone->zone_pgdat->pfmemalloc_wait,
3222                 allow_direct_reclaim(pgdat));
3223
3224 check_pending:
3225         if (fatal_signal_pending(current))
3226                 return true;
3227
3228 out:
3229         return false;
3230 }
3231
3232 unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
3233                                 gfp_t gfp_mask, nodemask_t *nodemask)
3234 {
3235         unsigned long nr_reclaimed;
3236         struct scan_control sc = {
3237                 .nr_to_reclaim = SWAP_CLUSTER_MAX,
3238                 .gfp_mask = current_gfp_context(gfp_mask),
3239                 .reclaim_idx = gfp_zone(gfp_mask),
3240                 .order = order,
3241                 .nodemask = nodemask,
3242                 .priority = DEF_PRIORITY,
3243                 .may_writepage = !laptop_mode,
3244                 .may_unmap = 1,
3245                 .may_swap = 1,
3246         };
3247
3248         /*
3249          * scan_control uses s8 fields for order, priority, and reclaim_idx.
3250          * Confirm they are large enough for max values.
3251          */
3252         BUILD_BUG_ON(MAX_ORDER > S8_MAX);
3253         BUILD_BUG_ON(DEF_PRIORITY > S8_MAX);
3254         BUILD_BUG_ON(MAX_NR_ZONES > S8_MAX);
3255
3256         /*
3257          * Do not enter reclaim if fatal signal was delivered while throttled.
3258          * 1 is returned so that the page allocator does not OOM kill at this
3259          * point.
3260          */
3261         if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
3262                 return 1;
3263
3264         set_task_reclaim_state(current, &sc.reclaim_state);
3265         trace_mm_vmscan_direct_reclaim_begin(order, sc.gfp_mask);
3266
3267         nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3268
3269         trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);
3270         set_task_reclaim_state(current, NULL);
3271
3272         return nr_reclaimed;
3273 }
3274
3275 #ifdef CONFIG_MEMCG
3276
3277 /* Only used by soft limit reclaim. Do not reuse for anything else. */
3278 unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
3279                                                 gfp_t gfp_mask, bool noswap,
3280                                                 pg_data_t *pgdat,
3281                                                 unsigned long *nr_scanned)
3282 {
3283         struct lruvec *lruvec = mem_cgroup_lruvec(memcg, pgdat);
3284         struct scan_control sc = {
3285                 .nr_to_reclaim = SWAP_CLUSTER_MAX,
3286                 .target_mem_cgroup = memcg,
3287                 .may_writepage = !laptop_mode,
3288                 .may_unmap = 1,
3289                 .reclaim_idx = MAX_NR_ZONES - 1,
3290                 .may_swap = !noswap,
3291         };
3292
3293         WARN_ON_ONCE(!current->reclaim_state);
3294
3295         sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
3296                         (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
3297
3298         trace_mm_vmscan_memcg_softlimit_reclaim_begin(sc.order,
3299                                                       sc.gfp_mask);
3300
3301         /*
3302          * NOTE: Although we can get the priority field, using it
3303          * here is not a good idea, since it limits the pages we can scan.
3304          * if we don't reclaim here, the shrink_node from balance_pgdat
3305          * will pick up pages from other mem cgroup's as well. We hack
3306          * the priority and make it zero.
3307          */
3308         shrink_lruvec(lruvec, &sc);
3309
3310         trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);
3311
3312         *nr_scanned = sc.nr_scanned;
3313
3314         return sc.nr_reclaimed;
3315 }
3316
3317 unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
3318                                            unsigned long nr_pages,
3319                                            gfp_t gfp_mask,
3320                                            bool may_swap)
3321 {
3322         unsigned long nr_reclaimed;
3323         unsigned int noreclaim_flag;
3324         struct scan_control sc = {
3325                 .nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3326                 .gfp_mask = (current_gfp_context(gfp_mask) & GFP_RECLAIM_MASK) |
3327                                 (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
3328                 .reclaim_idx = MAX_NR_ZONES - 1,
3329                 .target_mem_cgroup = memcg,
3330                 .priority = DEF_PRIORITY,
3331                 .may_writepage = !laptop_mode,
3332                 .may_unmap = 1,
3333                 .may_swap = may_swap,
3334         };
3335         /*
3336          * Traverse the ZONELIST_FALLBACK zonelist of the current node to put
3337          * equal pressure on all the nodes. This is based on the assumption that
3338          * the reclaim does not bail out early.
3339          */
3340         struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
3341
3342         set_task_reclaim_state(current, &sc.reclaim_state);
3343         trace_mm_vmscan_memcg_reclaim_begin(0, sc.gfp_mask);
3344         noreclaim_flag = memalloc_noreclaim_save();
3345
3346         nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3347
3348         memalloc_noreclaim_restore(noreclaim_flag);
3349         trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);
3350         set_task_reclaim_state(current, NULL);
3351
3352         return nr_reclaimed;
3353 }
3354 #endif
3355
3356 static void age_active_anon(struct pglist_data *pgdat,
3357                                 struct scan_control *sc)
3358 {
3359         struct mem_cgroup *memcg;
3360         struct lruvec *lruvec;
3361
3362         if (!total_swap_pages)
3363                 return;
3364
3365         lruvec = mem_cgroup_lruvec(NULL, pgdat);
3366         if (!inactive_is_low(lruvec, LRU_INACTIVE_ANON))
3367                 return;
3368
3369         memcg = mem_cgroup_iter(NULL, NULL, NULL);
3370         do {
3371                 lruvec = mem_cgroup_lruvec(memcg, pgdat);
3372                 shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
3373                                    sc, LRU_ACTIVE_ANON);
3374                 memcg = mem_cgroup_iter(NULL, memcg, NULL);
3375         } while (memcg);
3376 }
3377
3378 static bool pgdat_watermark_boosted(pg_data_t *pgdat, int highest_zoneidx)
3379 {
3380         int i;
3381         struct zone *zone;
3382
3383         /*
3384          * Check for watermark boosts top-down as the higher zones
3385          * are more likely to be boosted. Both watermarks and boosts
3386          * should not be checked at the same time as reclaim would
3387          * start prematurely when there is no boosting and a lower
3388          * zone is balanced.
3389          */
3390         for (i = highest_zoneidx; i >= 0; i--) {
3391                 zone = pgdat->node_zones + i;
3392                 if (!managed_zone(zone))
3393                         continue;
3394
3395                 if (zone->watermark_boost)
3396                         return true;
3397         }
3398
3399         return false;
3400 }
3401
3402 /*
3403  * Returns true if there is an eligible zone balanced for the request order
3404  * and highest_zoneidx
3405  */
3406 static bool pgdat_balanced(pg_data_t *pgdat, int order, int highest_zoneidx)
3407 {
3408         int i;
3409         unsigned long mark = -1;
3410         struct zone *zone;
3411
3412         /*
3413          * Check watermarks bottom-up as lower zones are more likely to
3414          * meet watermarks.
3415          */
3416         for (i = 0; i <= highest_zoneidx; i++) {
3417                 zone = pgdat->node_zones + i;
3418
3419                 if (!managed_zone(zone))
3420                         continue;
3421
3422                 mark = high_wmark_pages(zone);
3423                 if (zone_watermark_ok_safe(zone, order, mark, highest_zoneidx))
3424                         return true;
3425         }
3426
3427         /*
3428          * If a node has no populated zone within highest_zoneidx, it does not
3429          * need balancing by definition. This can happen if a zone-restricted
3430          * allocation tries to wake a remote kswapd.
3431          */
3432         if (mark == -1)
3433                 return true;
3434
3435         return false;
3436 }
3437
3438 /* Clear pgdat state for congested, dirty or under writeback. */
3439 static void clear_pgdat_congested(pg_data_t *pgdat)
3440 {
3441         struct lruvec *lruvec = mem_cgroup_lruvec(NULL, pgdat);
3442
3443         clear_bit(LRUVEC_CONGESTED, &lruvec->flags);
3444         clear_bit(PGDAT_DIRTY, &pgdat->flags);
3445         clear_bit(PGDAT_WRITEBACK, &pgdat->flags);
3446 }
3447
3448 /*
3449  * Prepare kswapd for sleeping. This verifies that there are no processes
3450  * waiting in throttle_direct_reclaim() and that watermarks have been met.
3451  *
3452  * Returns true if kswapd is ready to sleep
3453  */
3454 static bool prepare_kswapd_sleep(pg_data_t *pgdat, int order,
3455                                 int highest_zoneidx)
3456 {
3457         /*
3458          * The throttled processes are normally woken up in balance_pgdat() as
3459          * soon as allow_direct_reclaim() is true. But there is a potential
3460          * race between when kswapd checks the watermarks and a process gets
3461          * throttled. There is also a potential race if processes get
3462          * throttled, kswapd wakes, a large process exits thereby balancing the
3463          * zones, which causes kswapd to exit balance_pgdat() before reaching
3464          * the wake up checks. If kswapd is going to sleep, no process should
3465          * be sleeping on pfmemalloc_wait, so wake them now if necessary. If
3466          * the wake up is premature, processes will wake kswapd and get
3467          * throttled again. The difference from wake ups in balance_pgdat() is
3468          * that here we are under prepare_to_wait().
3469          */
3470         if (waitqueue_active(&pgdat->pfmemalloc_wait))
3471                 wake_up_all(&pgdat->pfmemalloc_wait);
3472
3473         /* Hopeless node, leave it to direct reclaim */
3474         if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
3475                 return true;
3476
3477         if (pgdat_balanced(pgdat, order, highest_zoneidx)) {
3478                 clear_pgdat_congested(pgdat);
3479                 return true;
3480         }
3481
3482         return false;
3483 }
3484
3485 /*
3486  * kswapd shrinks a node of pages that are at or below the highest usable
3487  * zone that is currently unbalanced.
3488  *
3489  * Returns true if kswapd scanned at least the requested number of pages to
3490  * reclaim or if the lack of progress was due to pages under writeback.
3491  * This is used to determine if the scanning priority needs to be raised.
3492  */
3493 static bool kswapd_shrink_node(pg_data_t *pgdat,
3494                                struct scan_control *sc)
3495 {
3496         struct zone *zone;
3497         int z;
3498
3499         /* Reclaim a number of pages proportional to the number of zones */
3500         sc->nr_to_reclaim = 0;
3501         for (z = 0; z <= sc->reclaim_idx; z++) {
3502                 zone = pgdat->node_zones + z;
3503                 if (!managed_zone(zone))
3504                         continue;
3505
3506                 sc->nr_to_reclaim += max(high_wmark_pages(zone), SWAP_CLUSTER_MAX);
3507         }
3508
3509         /*
3510          * Historically care was taken to put equal pressure on all zones but
3511          * now pressure is applied based on node LRU order.
3512          */
3513         shrink_node(pgdat, sc);
3514
3515         /*
3516          * Fragmentation may mean that the system cannot be rebalanced for
3517          * high-order allocations. If twice the allocation size has been
3518          * reclaimed then recheck watermarks only at order-0 to prevent
3519          * excessive reclaim. Assume that a process requested a high-order
3520          * can direct reclaim/compact.
3521          */
3522         if (sc->order && sc->nr_reclaimed >= compact_gap(sc->order))
3523                 sc->order = 0;
3524
3525         return sc->nr_scanned >= sc->nr_to_reclaim;
3526 }
3527
3528 /*
3529  * For kswapd, balance_pgdat() will reclaim pages across a node from zones
3530  * that are eligible for use by the caller until at least one zone is
3531  * balanced.
3532  *
3533  * Returns the order kswapd finished reclaiming at.
3534  *
3535  * kswapd scans the zones in the highmem->normal->dma direction.  It skips
3536  * zones which have free_pages > high_wmark_pages(zone), but once a zone is
3537  * found to have free_pages <= high_wmark_pages(zone), any page in that zone
3538  * or lower is eligible for reclaim until at least one usable zone is
3539  * balanced.
3540  */
3541 static int balance_pgdat(pg_data_t *pgdat, int order, int highest_zoneidx)
3542 {
3543         int i;
3544         unsigned long nr_soft_reclaimed;
3545         unsigned long nr_soft_scanned;
3546         unsigned long pflags;
3547         unsigned long nr_boost_reclaim;
3548         unsigned long zone_boosts[MAX_NR_ZONES] = { 0, };
3549         bool boosted;
3550         struct zone *zone;
3551         struct scan_control sc = {
3552                 .gfp_mask = GFP_KERNEL,
3553                 .order = order,
3554                 .may_unmap = 1,
3555         };
3556
3557         set_task_reclaim_state(current, &sc.reclaim_state);
3558         psi_memstall_enter(&pflags);
3559         __fs_reclaim_acquire();
3560
3561         count_vm_event(PAGEOUTRUN);
3562
3563         /*
3564          * Account for the reclaim boost. Note that the zone boost is left in
3565          * place so that parallel allocations that are near the watermark will
3566          * stall or direct reclaim until kswapd is finished.
3567          */
3568         nr_boost_reclaim = 0;
3569         for (i = 0; i <= highest_zoneidx; i++) {
3570                 zone = pgdat->node_zones + i;
3571                 if (!managed_zone(zone))
3572                         continue;
3573
3574                 nr_boost_reclaim += zone->watermark_boost;
3575                 zone_boosts[i] = zone->watermark_boost;
3576         }
3577         boosted = nr_boost_reclaim;
3578
3579 restart:
3580         sc.priority = DEF_PRIORITY;
3581         do {
3582                 unsigned long nr_reclaimed = sc.nr_reclaimed;
3583                 bool raise_priority = true;
3584                 bool balanced;
3585                 bool ret;
3586
3587                 sc.reclaim_idx = highest_zoneidx;
3588
3589                 /*
3590                  * If the number of buffer_heads exceeds the maximum allowed
3591                  * then consider reclaiming from all zones. This has a dual
3592                  * purpose -- on 64-bit systems it is expected that
3593                  * buffer_heads are stripped during active rotation. On 32-bit
3594                  * systems, highmem pages can pin lowmem memory and shrinking
3595                  * buffers can relieve lowmem pressure. Reclaim may still not
3596                  * go ahead if all eligible zones for the original allocation
3597                  * request are balanced to avoid excessive reclaim from kswapd.
3598                  */
3599                 if (buffer_heads_over_limit) {
3600                         for (i = MAX_NR_ZONES - 1; i >= 0; i--) {
3601                                 zone = pgdat->node_zones + i;
3602                                 if (!managed_zone(zone))
3603                                         continue;
3604
3605                                 sc.reclaim_idx = i;
3606                                 break;
3607                         }
3608                 }
3609
3610                 /*
3611                  * If the pgdat is imbalanced then ignore boosting and preserve
3612                  * the watermarks for a later time and restart. Note that the
3613                  * zone watermarks will be still reset at the end of balancing
3614                  * on the grounds that the normal reclaim should be enough to
3615                  * re-evaluate if boosting is required when kswapd next wakes.
3616                  */
3617                 balanced = pgdat_balanced(pgdat, sc.order, highest_zoneidx);
3618                 if (!balanced && nr_boost_reclaim) {
3619                         nr_boost_reclaim = 0;
3620                         goto restart;
3621                 }
3622
3623                 /*
3624                  * If boosting is not active then only reclaim if there are no
3625                  * eligible zones. Note that sc.reclaim_idx is not used as
3626                  * buffer_heads_over_limit may have adjusted it.
3627                  */
3628                 if (!nr_boost_reclaim && balanced)
3629                         goto out;
3630
3631                 /* Limit the priority of boosting to avoid reclaim writeback */
3632                 if (nr_boost_reclaim && sc.priority == DEF_PRIORITY - 2)
3633                         raise_priority = false;
3634
3635                 /*
3636                  * Do not writeback or swap pages for boosted reclaim. The
3637                  * intent is to relieve pressure not issue sub-optimal IO
3638                  * from reclaim context. If no pages are reclaimed, the
3639                  * reclaim will be aborted.
3640                  */
3641                 sc.may_writepage = !laptop_mode && !nr_boost_reclaim;
3642                 sc.may_swap = !nr_boost_reclaim;
3643
3644                 /*
3645                  * Do some background aging of the anon list, to give
3646                  * pages a chance to be referenced before reclaiming. All
3647                  * pages are rotated regardless of classzone as this is
3648                  * about consistent aging.
3649                  */
3650                 age_active_anon(pgdat, &sc);
3651
3652                 /*
3653                  * If we're getting trouble reclaiming, start doing writepage
3654                  * even in laptop mode.
3655                  */
3656                 if (sc.priority < DEF_PRIORITY - 2)
3657                         sc.may_writepage = 1;
3658
3659                 /* Call soft limit reclaim before calling shrink_node. */
3660                 sc.nr_scanned = 0;
3661                 nr_soft_scanned = 0;
3662                 nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(pgdat, sc.order,
3663                                                 sc.gfp_mask, &nr_soft_scanned);
3664                 sc.nr_reclaimed += nr_soft_reclaimed;
3665
3666                 /*
3667                  * There should be no need to raise the scanning priority if
3668                  * enough pages are already being scanned that that high
3669                  * watermark would be met at 100% efficiency.
3670                  */
3671                 if (kswapd_shrink_node(pgdat, &sc))
3672                         raise_priority = false;
3673
3674                 /*
3675                  * If the low watermark is met there is no need for processes
3676                  * to be throttled on pfmemalloc_wait as they should not be
3677                  * able to safely make forward progress. Wake them
3678                  */
3679                 if (waitqueue_active(&pgdat->pfmemalloc_wait) &&
3680                                 allow_direct_reclaim(pgdat))
3681                         wake_up_all(&pgdat->pfmemalloc_wait);
3682
3683                 /* Check if kswapd should be suspending */
3684                 __fs_reclaim_release();
3685                 ret = try_to_freeze();
3686                 __fs_reclaim_acquire();
3687                 if (ret || kthread_should_stop())
3688                         break;
3689
3690                 /*
3691                  * Raise priority if scanning rate is too low or there was no
3692                  * progress in reclaiming pages
3693                  */
3694                 nr_reclaimed = sc.nr_reclaimed - nr_reclaimed;
3695                 nr_boost_reclaim -= min(nr_boost_reclaim, nr_reclaimed);
3696
3697                 /*
3698                  * If reclaim made no progress for a boost, stop reclaim as
3699                  * IO cannot be queued and it could be an infinite loop in
3700                  * extreme circumstances.
3701                  */
3702                 if (nr_boost_reclaim && !nr_reclaimed)
3703                         break;
3704
3705                 if (raise_priority || !nr_reclaimed)
3706                         sc.priority--;
3707         } while (sc.priority >= 1);
3708
3709         if (!sc.nr_reclaimed)
3710                 pgdat->kswapd_failures++;
3711
3712 out:
3713         /* If reclaim was boosted, account for the reclaim done in this pass */
3714         if (boosted) {
3715                 unsigned long flags;
3716
3717                 for (i = 0; i <= highest_zoneidx; i++) {
3718                         if (!zone_boosts[i])
3719                                 continue;
3720
3721                         /* Increments are under the zone lock */
3722                         zone = pgdat->node_zones + i;
3723                         spin_lock_irqsave(&zone->lock, flags);
3724                         zone->watermark_boost -= min(zone->watermark_boost, zone_boosts[i]);
3725                         spin_unlock_irqrestore(&zone->lock, flags);
3726                 }
3727
3728                 /*
3729                  * As there is now likely space, wakeup kcompact to defragment
3730                  * pageblocks.
3731                  */
3732                 wakeup_kcompactd(pgdat, pageblock_order, highest_zoneidx);
3733         }
3734
3735         snapshot_refaults(NULL, pgdat);
3736         __fs_reclaim_release();
3737         psi_memstall_leave(&pflags);
3738         set_task_reclaim_state(current, NULL);
3739
3740         /*
3741          * Return the order kswapd stopped reclaiming at as
3742          * prepare_kswapd_sleep() takes it into account. If another caller
3743          * entered the allocator slow path while kswapd was awake, order will
3744          * remain at the higher level.
3745          */
3746         return sc.order;
3747 }
3748
3749 /*
3750  * The pgdat->kswapd_highest_zoneidx is used to pass the highest zone index to
3751  * be reclaimed by kswapd from the waker. If the value is MAX_NR_ZONES which is
3752  * not a valid index then either kswapd runs for first time or kswapd couldn't
3753  * sleep after previous reclaim attempt (node is still unbalanced). In that
3754  * case return the zone index of the previous kswapd reclaim cycle.
3755  */
3756 static enum zone_type kswapd_highest_zoneidx(pg_data_t *pgdat,
3757                                            enum zone_type prev_highest_zoneidx)
3758 {
3759         enum zone_type curr_idx = READ_ONCE(pgdat->kswapd_highest_zoneidx);
3760
3761         return curr_idx == MAX_NR_ZONES ? prev_highest_zoneidx : curr_idx;
3762 }
3763
3764 static void kswapd_try_to_sleep(pg_data_t *pgdat, int alloc_order, int reclaim_order,
3765                                 unsigned int highest_zoneidx)
3766 {
3767         long remaining = 0;
3768         DEFINE_WAIT(wait);
3769
3770         if (freezing(current) || kthread_should_stop())
3771                 return;
3772
3773         prepare_to_wait(&pgdat->kswapd_wait, &wait, TASK_INTERRUPTIBLE);
3774
3775         /*
3776          * Try to sleep for a short interval. Note that kcompactd will only be
3777          * woken if it is possible to sleep for a short interval. This is
3778          * deliberate on the assumption that if reclaim cannot keep an
3779          * eligible zone balanced that it's also unlikely that compaction will
3780          * succeed.
3781          */
3782         if (prepare_kswapd_sleep(pgdat, reclaim_order, highest_zoneidx)) {
3783                 /*
3784                  * Compaction records what page blocks it recently failed to
3785                  * isolate pages from and skips them in the future scanning.
3786                  * When kswapd is going to sleep, it is reasonable to assume
3787                  * that pages and compaction may succeed so reset the cache.
3788                  */
3789                 reset_isolation_suitable(pgdat);
3790
3791                 /*
3792                  * We have freed the memory, now we should compact it to make
3793                  * allocation of the requested order possible.
3794                  */
3795                 wakeup_kcompactd(pgdat, alloc_order, highest_zoneidx);
3796
3797                 remaining = schedule_timeout(HZ/10);
3798
3799                 /*
3800                  * If woken prematurely then reset kswapd_highest_zoneidx and
3801                  * order. The values will either be from a wakeup request or
3802                  * the previous request that slept prematurely.
3803                  */
3804                 if (remaining) {
3805                         WRITE_ONCE(pgdat->kswapd_highest_zoneidx,
3806                                         kswapd_highest_zoneidx(pgdat,
3807                                                         highest_zoneidx));
3808
3809                         if (READ_ONCE(pgdat->kswapd_order) < reclaim_order)
3810                                 WRITE_ONCE(pgdat->kswapd_order, reclaim_order);
3811                 }
3812
3813                 finish_wait(&pgdat->kswapd_wait, &wait);
3814                 prepare_to_wait(&pgdat->kswapd_wait, &wait, TASK_INTERRUPTIBLE);
3815         }
3816
3817         /*
3818          * After a short sleep, check if it was a premature sleep. If not, then
3819          * go fully to sleep until explicitly woken up.
3820          */
3821         if (!remaining &&
3822             prepare_kswapd_sleep(pgdat, reclaim_order, highest_zoneidx)) {
3823                 trace_mm_vmscan_kswapd_sleep(pgdat->node_id);
3824
3825                 /*
3826                  * vmstat counters are not perfectly accurate and the estimated
3827                  * value for counters such as NR_FREE_PAGES can deviate from the
3828                  * true value by nr_online_cpus * threshold. To avoid the zone
3829                  * watermarks being breached while under pressure, we reduce the
3830                  * per-cpu vmstat threshold while kswapd is awake and restore
3831                  * them before going back to sleep.
3832                  */
3833                 set_pgdat_percpu_threshold(pgdat, calculate_normal_threshold);
3834
3835                 if (!kthread_should_stop())
3836                         schedule();
3837
3838                 set_pgdat_percpu_threshold(pgdat, calculate_pressure_threshold);
3839         } else {
3840                 if (remaining)
3841                         count_vm_event(KSWAPD_LOW_WMARK_HIT_QUICKLY);
3842                 else
3843                         count_vm_event(KSWAPD_HIGH_WMARK_HIT_QUICKLY);
3844         }
3845         finish_wait(&pgdat->kswapd_wait, &wait);
3846 }
3847
3848 /*
3849  * The background pageout daemon, started as a kernel thread
3850  * from the init process.
3851  *
3852  * This basically trickles out pages so that we have _some_
3853  * free memory available even if there is no other activity
3854  * that frees anything up. This is needed for things like routing
3855  * etc, where we otherwise might have all activity going on in
3856  * asynchronous contexts that cannot page things out.
3857  *
3858  * If there are applications that are active memory-allocators
3859  * (most normal use), this basically shouldn't matter.
3860  */
3861 static int kswapd(void *p)
3862 {
3863         unsigned int alloc_order, reclaim_order;
3864         unsigned int highest_zoneidx = MAX_NR_ZONES - 1;
3865         pg_data_t *pgdat = (pg_data_t*)p;
3866         struct task_struct *tsk = current;
3867         const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
3868
3869         if (!cpumask_empty(cpumask))
3870                 set_cpus_allowed_ptr(tsk, cpumask);
3871
3872         /*
3873          * Tell the memory management that we're a "memory allocator",
3874          * and that if we need more memory we should get access to it
3875          * regardless (see "__alloc_pages()"). "kswapd" should
3876          * never get caught in the normal page freeing logic.
3877          *
3878          * (Kswapd normally doesn't need memory anyway, but sometimes
3879          * you need a small amount of memory in order to be able to
3880          * page out something else, and this flag essentially protects
3881          * us from recursively trying to free more memory as we're
3882          * trying to free the first piece of memory in the first place).
3883          */
3884         tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
3885         set_freezable();
3886
3887         WRITE_ONCE(pgdat->kswapd_order, 0);
3888         WRITE_ONCE(pgdat->kswapd_highest_zoneidx, MAX_NR_ZONES);
3889         for ( ; ; ) {
3890                 bool ret;
3891
3892                 alloc_order = reclaim_order = READ_ONCE(pgdat->kswapd_order);
3893                 highest_zoneidx = kswapd_highest_zoneidx(pgdat,
3894                                                         highest_zoneidx);
3895
3896 kswapd_try_sleep:
3897                 kswapd_try_to_sleep(pgdat, alloc_order, reclaim_order,
3898                                         highest_zoneidx);
3899
3900                 /* Read the new order and highest_zoneidx */
3901                 alloc_order = READ_ONCE(pgdat->kswapd_order);
3902                 highest_zoneidx = kswapd_highest_zoneidx(pgdat,
3903                                                         highest_zoneidx);
3904                 WRITE_ONCE(pgdat->kswapd_order, 0);
3905                 WRITE_ONCE(pgdat->kswapd_highest_zoneidx, MAX_NR_ZONES);
3906
3907                 ret = try_to_freeze();
3908                 if (kthread_should_stop())
3909                         break;
3910
3911                 /*
3912                  * We can speed up thawing tasks if we don't call balance_pgdat
3913                  * after returning from the refrigerator
3914                  */
3915                 if (ret)
3916                         continue;
3917
3918                 /*
3919                  * Reclaim begins at the requested order but if a high-order
3920                  * reclaim fails then kswapd falls back to reclaiming for
3921                  * order-0. If that happens, kswapd will consider sleeping
3922                  * for the order it finished reclaiming at (reclaim_order)
3923                  * but kcompactd is woken to compact for the original
3924                  * request (alloc_order).
3925                  */
3926                 trace_mm_vmscan_kswapd_wake(pgdat->node_id, highest_zoneidx,
3927                                                 alloc_order);
3928                 reclaim_order = balance_pgdat(pgdat, alloc_order,
3929                                                 highest_zoneidx);
3930                 if (reclaim_order < alloc_order)
3931                         goto kswapd_try_sleep;
3932         }
3933
3934         tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
3935
3936         return 0;
3937 }
3938
3939 /*
3940  * A zone is low on free memory or too fragmented for high-order memory.  If
3941  * kswapd should reclaim (direct reclaim is deferred), wake it up for the zone's
3942  * pgdat.  It will wake up kcompactd after reclaiming memory.  If kswapd reclaim
3943  * has failed or is not needed, still wake up kcompactd if only compaction is
3944  * needed.
3945  */
3946 void wakeup_kswapd(struct zone *zone, gfp_t gfp_flags, int order,
3947                    enum zone_type highest_zoneidx)
3948 {
3949         pg_data_t *pgdat;
3950         enum zone_type curr_idx;
3951
3952         if (!managed_zone(zone))
3953                 return;
3954
3955         if (!cpuset_zone_allowed(zone, gfp_flags))
3956                 return;
3957
3958         pgdat = zone->zone_pgdat;
3959         curr_idx = READ_ONCE(pgdat->kswapd_highest_zoneidx);
3960
3961         if (curr_idx == MAX_NR_ZONES || curr_idx < highest_zoneidx)
3962                 WRITE_ONCE(pgdat->kswapd_highest_zoneidx, highest_zoneidx);
3963
3964         if (READ_ONCE(pgdat->kswapd_order) < order)
3965                 WRITE_ONCE(pgdat->kswapd_order, order);
3966
3967         if (!waitqueue_active(&pgdat->kswapd_wait))
3968                 return;
3969
3970         /* Hopeless node, leave it to direct reclaim if possible */
3971         if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES ||
3972             (pgdat_balanced(pgdat, order, highest_zoneidx) &&
3973              !pgdat_watermark_boosted(pgdat, highest_zoneidx))) {
3974                 /*
3975                  * There may be plenty of free memory available, but it's too
3976                  * fragmented for high-order allocations.  Wake up kcompactd
3977                  * and rely on compaction_suitable() to determine if it's
3978                  * needed.  If it fails, it will defer subsequent attempts to
3979                  * ratelimit its work.
3980                  */
3981                 if (!(gfp_flags & __GFP_DIRECT_RECLAIM))
3982                         wakeup_kcompactd(pgdat, order, highest_zoneidx);
3983                 return;
3984         }
3985
3986         trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, highest_zoneidx, order,
3987                                       gfp_flags);
3988         wake_up_interruptible(&pgdat->kswapd_wait);
3989 }
3990
3991 #ifdef CONFIG_HIBERNATION
3992 /*
3993  * Try to free `nr_to_reclaim' of memory, system-wide, and return the number of
3994  * freed pages.
3995  *
3996  * Rather than trying to age LRUs the aim is to preserve the overall
3997  * LRU order by reclaiming preferentially
3998  * inactive > active > active referenced > active mapped
3999  */
4000 unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
4001 {
4002         struct scan_control sc = {
4003                 .nr_to_reclaim = nr_to_reclaim,
4004                 .gfp_mask = GFP_HIGHUSER_MOVABLE,
4005                 .reclaim_idx = MAX_NR_ZONES - 1,
4006                 .priority = DEF_PRIORITY,
4007                 .may_writepage = 1,
4008                 .may_unmap = 1,
4009                 .may_swap = 1,
4010                 .hibernation_mode = 1,
4011         };
4012         struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
4013         unsigned long nr_reclaimed;
4014         unsigned int noreclaim_flag;
4015
4016         fs_reclaim_acquire(sc.gfp_mask);
4017         noreclaim_flag = memalloc_noreclaim_save();
4018         set_task_reclaim_state(current, &sc.reclaim_state);
4019
4020         nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
4021
4022         set_task_reclaim_state(current, NULL);
4023         memalloc_noreclaim_restore(noreclaim_flag);
4024         fs_reclaim_release(sc.gfp_mask);
4025
4026         return nr_reclaimed;
4027 }
4028 #endif /* CONFIG_HIBERNATION */
4029
4030 /*
4031  * This kswapd start function will be called by init and node-hot-add.
4032  * On node-hot-add, kswapd will moved to proper cpus if cpus are hot-added.
4033  */
4034 int kswapd_run(int nid)
4035 {
4036         pg_data_t *pgdat = NODE_DATA(nid);
4037         int ret = 0;
4038
4039         if (pgdat->kswapd)
4040                 return 0;
4041
4042         pgdat->kswapd = kthread_run(kswapd, pgdat, "kswapd%d", nid);
4043         if (IS_ERR(pgdat->kswapd)) {
4044                 /* failure at boot is fatal */
4045                 BUG_ON(system_state < SYSTEM_RUNNING);
4046                 pr_err("Failed to start kswapd on node %d\n", nid);
4047                 ret = PTR_ERR(pgdat->kswapd);
4048                 pgdat->kswapd = NULL;
4049         }
4050         return ret;
4051 }
4052
4053 /*
4054  * Called by memory hotplug when all memory in a node is offlined.  Caller must
4055  * hold mem_hotplug_begin/end().
4056  */
4057 void kswapd_stop(int nid)
4058 {
4059         struct task_struct *kswapd = NODE_DATA(nid)->kswapd;
4060
4061         if (kswapd) {
4062                 kthread_stop(kswapd);
4063                 NODE_DATA(nid)->kswapd = NULL;
4064         }
4065 }
4066
4067 static int __init kswapd_init(void)
4068 {
4069         int nid;
4070
4071         swap_setup();
4072         for_each_node_state(nid, N_MEMORY)
4073                 kswapd_run(nid);
4074         return 0;
4075 }
4076
4077 module_init(kswapd_init)
4078
4079 #ifdef CONFIG_NUMA
4080 /*
4081  * Node reclaim mode
4082  *
4083  * If non-zero call node_reclaim when the number of free pages falls below
4084  * the watermarks.
4085  */
4086 int node_reclaim_mode __read_mostly;
4087
4088 /*
4089  * These bit locations are exposed in the vm.zone_reclaim_mode sysctl
4090  * ABI.  New bits are OK, but existing bits can never change.
4091  */
4092 #define RECLAIM_ZONE  (1<<0)   /* Run shrink_inactive_list on the zone */
4093 #define RECLAIM_WRITE (1<<1)   /* Writeout pages during reclaim */
4094 #define RECLAIM_UNMAP (1<<2)   /* Unmap pages during reclaim */
4095
4096 /*
4097  * Priority for NODE_RECLAIM. This determines the fraction of pages
4098  * of a node considered for each zone_reclaim. 4 scans 1/16th of
4099  * a zone.
4100  */
4101 #define NODE_RECLAIM_PRIORITY 4
4102
4103 /*
4104  * Percentage of pages in a zone that must be unmapped for node_reclaim to
4105  * occur.
4106  */
4107 int sysctl_min_unmapped_ratio = 1;
4108
4109 /*
4110  * If the number of slab pages in a zone grows beyond this percentage then
4111  * slab reclaim needs to occur.
4112  */
4113 int sysctl_min_slab_ratio = 5;
4114
4115 static inline unsigned long node_unmapped_file_pages(struct pglist_data *pgdat)
4116 {
4117         unsigned long file_mapped = node_page_state(pgdat, NR_FILE_MAPPED);
4118         unsigned long file_lru = node_page_state(pgdat, NR_INACTIVE_FILE) +
4119                 node_page_state(pgdat, NR_ACTIVE_FILE);
4120
4121         /*
4122          * It's possible for there to be more file mapped pages than
4123          * accounted for by the pages on the file LRU lists because
4124          * tmpfs pages accounted for as ANON can also be FILE_MAPPED
4125          */
4126         return (file_lru > file_mapped) ? (file_lru - file_mapped) : 0;
4127 }
4128
4129 /* Work out how many page cache pages we can reclaim in this reclaim_mode */
4130 static unsigned long node_pagecache_reclaimable(struct pglist_data *pgdat)
4131 {
4132         unsigned long nr_pagecache_reclaimable;
4133         unsigned long delta = 0;
4134
4135         /*
4136          * If RECLAIM_UNMAP is set, then all file pages are considered
4137          * potentially reclaimable. Otherwise, we have to worry about
4138          * pages like swapcache and node_unmapped_file_pages() provides
4139          * a better estimate
4140          */
4141         if (node_reclaim_mode & RECLAIM_UNMAP)
4142                 nr_pagecache_reclaimable = node_page_state(pgdat, NR_FILE_PAGES);
4143         else
4144                 nr_pagecache_reclaimable = node_unmapped_file_pages(pgdat);
4145
4146         /* If we can't clean pages, remove dirty pages from consideration */
4147         if (!(node_reclaim_mode & RECLAIM_WRITE))
4148                 delta += node_page_state(pgdat, NR_FILE_DIRTY);
4149
4150         /* Watch for any possible underflows due to delta */
4151         if (unlikely(delta > nr_pagecache_reclaimable))
4152                 delta = nr_pagecache_reclaimable;
4153
4154         return nr_pagecache_reclaimable - delta;
4155 }
4156
4157 /*
4158  * Try to free up some pages from this node through reclaim.
4159  */
4160 static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
4161 {
4162         /* Minimum pages needed in order to stay on node */
4163         const unsigned long nr_pages = 1 << order;
4164         struct task_struct *p = current;
4165         unsigned int noreclaim_flag;
4166         struct scan_control sc = {
4167                 .nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
4168                 .gfp_mask = current_gfp_context(gfp_mask),
4169                 .order = order,
4170                 .priority = NODE_RECLAIM_PRIORITY,
4171                 .may_writepage = !!(node_reclaim_mode & RECLAIM_WRITE),
4172                 .may_unmap = !!(node_reclaim_mode & RECLAIM_UNMAP),
4173                 .may_swap = 1,
4174                 .reclaim_idx = gfp_zone(gfp_mask),
4175         };
4176
4177         trace_mm_vmscan_node_reclaim_begin(pgdat->node_id, order,
4178                                            sc.gfp_mask);
4179
4180         cond_resched();
4181         fs_reclaim_acquire(sc.gfp_mask);
4182         /*
4183          * We need to be able to allocate from the reserves for RECLAIM_UNMAP
4184          * and we also need to be able to write out pages for RECLAIM_WRITE
4185          * and RECLAIM_UNMAP.
4186          */
4187         noreclaim_flag = memalloc_noreclaim_save();
4188         p->flags |= PF_SWAPWRITE;
4189         set_task_reclaim_state(p, &sc.reclaim_state);
4190
4191         if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
4192                 /*
4193                  * Free memory by calling shrink node with increasing
4194                  * priorities until we have enough memory freed.
4195                  */
4196                 do {
4197                         shrink_node(pgdat, &sc);
4198                 } while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
4199         }
4200
4201         set_task_reclaim_state(p, NULL);
4202         current->flags &= ~PF_SWAPWRITE;
4203         memalloc_noreclaim_restore(noreclaim_flag);
4204         fs_reclaim_release(sc.gfp_mask);
4205
4206         trace_mm_vmscan_node_reclaim_end(sc.nr_reclaimed);
4207
4208         return sc.nr_reclaimed >= nr_pages;
4209 }
4210
4211 int node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
4212 {
4213         int ret;
4214
4215         /*
4216          * Node reclaim reclaims unmapped file backed pages and
4217          * slab pages if we are over the defined limits.
4218          *
4219          * A small portion of unmapped file backed pages is needed for
4220          * file I/O otherwise pages read by file I/O will be immediately
4221          * thrown out if the node is overallocated. So we do not reclaim
4222          * if less than a specified percentage of the node is used by
4223          * unmapped file backed pages.
4224          */
4225         if (node_pagecache_reclaimable(pgdat) <= pgdat->min_unmapped_pages &&
4226             node_page_state_pages(pgdat, NR_SLAB_RECLAIMABLE_B) <=
4227             pgdat->min_slab_pages)
4228                 return NODE_RECLAIM_FULL;
4229
4230         /*
4231          * Do not scan if the allocation should not be delayed.
4232          */
4233         if (!gfpflags_allow_blocking(gfp_mask) || (current->flags & PF_MEMALLOC))
4234                 return NODE_RECLAIM_NOSCAN;
4235
4236         /*
4237          * Only run node reclaim on the local node or on nodes that do not
4238          * have associated processors. This will favor the local processor
4239          * over remote processors and spread off node memory allocations
4240          * as wide as possible.
4241          */
4242         if (node_state(pgdat->node_id, N_CPU) && pgdat->node_id != numa_node_id())
4243                 return NODE_RECLAIM_NOSCAN;
4244
4245         if (test_and_set_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags))
4246                 return NODE_RECLAIM_NOSCAN;
4247
4248         ret = __node_reclaim(pgdat, gfp_mask, order);
4249         clear_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags);
4250
4251         if (!ret)
4252                 count_vm_event(PGSCAN_ZONE_RECLAIM_FAILED);
4253
4254         return ret;
4255 }
4256 #endif
4257
4258 /**
4259  * check_move_unevictable_pages - check pages for evictability and move to
4260  * appropriate zone lru list
4261  * @pvec: pagevec with lru pages to check
4262  *
4263  * Checks pages for evictability, if an evictable page is in the unevictable
4264  * lru list, moves it to the appropriate evictable lru list. This function
4265  * should be only used for lru pages.
4266  */
4267 void check_move_unevictable_pages(struct pagevec *pvec)
4268 {
4269         struct lruvec *lruvec = NULL;
4270         int pgscanned = 0;
4271         int pgrescued = 0;
4272         int i;
4273
4274         for (i = 0; i < pvec->nr; i++) {
4275                 struct page *page = pvec->pages[i];
4276                 int nr_pages;
4277
4278                 if (PageTransTail(page))
4279                         continue;
4280
4281                 nr_pages = thp_nr_pages(page);
4282                 pgscanned += nr_pages;
4283
4284                 /* block memcg migration during page moving between lru */
4285                 if (!TestClearPageLRU(page))
4286                         continue;
4287
4288                 lruvec = relock_page_lruvec_irq(page, lruvec);
4289                 if (page_evictable(page) && PageUnevictable(page)) {
4290                         del_page_from_lru_list(page, lruvec);
4291                         ClearPageUnevictable(page);
4292                         add_page_to_lru_list(page, lruvec);
4293                         pgrescued += nr_pages;
4294                 }
4295                 SetPageLRU(page);
4296         }
4297
4298         if (lruvec) {
4299                 __count_vm_events(UNEVICTABLE_PGRESCUED, pgrescued);
4300                 __count_vm_events(UNEVICTABLE_PGSCANNED, pgscanned);
4301                 unlock_page_lruvec_irq(lruvec);
4302         } else if (pgscanned) {
4303                 count_vm_events(UNEVICTABLE_PGSCANNED, pgscanned);
4304         }
4305 }
4306 EXPORT_SYMBOL_GPL(check_move_unevictable_pages);