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