mm: put_and_wait_on_page_locked() while page is migrated
[sfrench/cifs-2.6.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         /* Writepage batching in laptop mode; RECLAIM_WRITE */
83         unsigned int may_writepage:1;
84
85         /* Can mapped pages be reclaimed? */
86         unsigned int may_unmap:1;
87
88         /* Can pages be swapped as part of reclaim? */
89         unsigned int may_swap:1;
90
91         /* e.g. boosted watermark reclaim leaves slabs alone */
92         unsigned int may_shrinkslab:1;
93
94         /*
95          * Cgroups are not reclaimed below their configured memory.low,
96          * unless we threaten to OOM. If any cgroups are skipped due to
97          * memory.low and nothing was reclaimed, go back for memory.low.
98          */
99         unsigned int memcg_low_reclaim:1;
100         unsigned int memcg_low_skipped:1;
101
102         unsigned int hibernation_mode:1;
103
104         /* One of the zones is ready for compaction */
105         unsigned int compaction_ready:1;
106
107         /* Allocation order */
108         s8 order;
109
110         /* Scan (total_size >> priority) pages at once */
111         s8 priority;
112
113         /* The highest zone to isolate pages for reclaim from */
114         s8 reclaim_idx;
115
116         /* This context's GFP mask */
117         gfp_t gfp_mask;
118
119         /* Incremented by the number of inactive pages that were scanned */
120         unsigned long nr_scanned;
121
122         /* Number of pages freed so far during a call to shrink_zones() */
123         unsigned long nr_reclaimed;
124
125         struct {
126                 unsigned int dirty;
127                 unsigned int unqueued_dirty;
128                 unsigned int congested;
129                 unsigned int writeback;
130                 unsigned int immediate;
131                 unsigned int file_taken;
132                 unsigned int taken;
133         } nr;
134 };
135
136 #ifdef ARCH_HAS_PREFETCH
137 #define prefetch_prev_lru_page(_page, _base, _field)                    \
138         do {                                                            \
139                 if ((_page)->lru.prev != _base) {                       \
140                         struct page *prev;                              \
141                                                                         \
142                         prev = lru_to_page(&(_page->lru));              \
143                         prefetch(&prev->_field);                        \
144                 }                                                       \
145         } while (0)
146 #else
147 #define prefetch_prev_lru_page(_page, _base, _field) do { } while (0)
148 #endif
149
150 #ifdef ARCH_HAS_PREFETCHW
151 #define prefetchw_prev_lru_page(_page, _base, _field)                   \
152         do {                                                            \
153                 if ((_page)->lru.prev != _base) {                       \
154                         struct page *prev;                              \
155                                                                         \
156                         prev = lru_to_page(&(_page->lru));              \
157                         prefetchw(&prev->_field);                       \
158                 }                                                       \
159         } while (0)
160 #else
161 #define prefetchw_prev_lru_page(_page, _base, _field) do { } while (0)
162 #endif
163
164 /*
165  * From 0 .. 100.  Higher means more swappy.
166  */
167 int vm_swappiness = 60;
168 /*
169  * The total number of pages which are beyond the high watermark within all
170  * zones.
171  */
172 unsigned long vm_total_pages;
173
174 static LIST_HEAD(shrinker_list);
175 static DECLARE_RWSEM(shrinker_rwsem);
176
177 #ifdef CONFIG_MEMCG_KMEM
178
179 /*
180  * We allow subsystems to populate their shrinker-related
181  * LRU lists before register_shrinker_prepared() is called
182  * for the shrinker, since we don't want to impose
183  * restrictions on their internal registration order.
184  * In this case shrink_slab_memcg() may find corresponding
185  * bit is set in the shrinkers map.
186  *
187  * This value is used by the function to detect registering
188  * shrinkers and to skip do_shrink_slab() calls for them.
189  */
190 #define SHRINKER_REGISTERING ((struct shrinker *)~0UL)
191
192 static DEFINE_IDR(shrinker_idr);
193 static int shrinker_nr_max;
194
195 static int prealloc_memcg_shrinker(struct shrinker *shrinker)
196 {
197         int id, ret = -ENOMEM;
198
199         down_write(&shrinker_rwsem);
200         /* This may call shrinker, so it must use down_read_trylock() */
201         id = idr_alloc(&shrinker_idr, SHRINKER_REGISTERING, 0, 0, GFP_KERNEL);
202         if (id < 0)
203                 goto unlock;
204
205         if (id >= shrinker_nr_max) {
206                 if (memcg_expand_shrinker_maps(id)) {
207                         idr_remove(&shrinker_idr, id);
208                         goto unlock;
209                 }
210
211                 shrinker_nr_max = id + 1;
212         }
213         shrinker->id = id;
214         ret = 0;
215 unlock:
216         up_write(&shrinker_rwsem);
217         return ret;
218 }
219
220 static void unregister_memcg_shrinker(struct shrinker *shrinker)
221 {
222         int id = shrinker->id;
223
224         BUG_ON(id < 0);
225
226         down_write(&shrinker_rwsem);
227         idr_remove(&shrinker_idr, id);
228         up_write(&shrinker_rwsem);
229 }
230 #else /* CONFIG_MEMCG_KMEM */
231 static int prealloc_memcg_shrinker(struct shrinker *shrinker)
232 {
233         return 0;
234 }
235
236 static void unregister_memcg_shrinker(struct shrinker *shrinker)
237 {
238 }
239 #endif /* CONFIG_MEMCG_KMEM */
240
241 #ifdef CONFIG_MEMCG
242 static bool global_reclaim(struct scan_control *sc)
243 {
244         return !sc->target_mem_cgroup;
245 }
246
247 /**
248  * sane_reclaim - is the usual dirty throttling mechanism operational?
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 sane_reclaim(struct scan_control *sc)
261 {
262         struct mem_cgroup *memcg = sc->target_mem_cgroup;
263
264         if (!memcg)
265                 return true;
266 #ifdef CONFIG_CGROUP_WRITEBACK
267         if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
268                 return true;
269 #endif
270         return false;
271 }
272
273 static void set_memcg_congestion(pg_data_t *pgdat,
274                                 struct mem_cgroup *memcg,
275                                 bool congested)
276 {
277         struct mem_cgroup_per_node *mn;
278
279         if (!memcg)
280                 return;
281
282         mn = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
283         WRITE_ONCE(mn->congested, congested);
284 }
285
286 static bool memcg_congested(pg_data_t *pgdat,
287                         struct mem_cgroup *memcg)
288 {
289         struct mem_cgroup_per_node *mn;
290
291         mn = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
292         return READ_ONCE(mn->congested);
293
294 }
295 #else
296 static bool global_reclaim(struct scan_control *sc)
297 {
298         return true;
299 }
300
301 static bool sane_reclaim(struct scan_control *sc)
302 {
303         return true;
304 }
305
306 static inline void set_memcg_congestion(struct pglist_data *pgdat,
307                                 struct mem_cgroup *memcg, bool congested)
308 {
309 }
310
311 static inline bool memcg_congested(struct pglist_data *pgdat,
312                         struct mem_cgroup *memcg)
313 {
314         return false;
315
316 }
317 #endif
318
319 /*
320  * This misses isolated pages which are not accounted for to save counters.
321  * As the data only determines if reclaim or compaction continues, it is
322  * not expected that isolated pages will be a dominating factor.
323  */
324 unsigned long zone_reclaimable_pages(struct zone *zone)
325 {
326         unsigned long nr;
327
328         nr = zone_page_state_snapshot(zone, NR_ZONE_INACTIVE_FILE) +
329                 zone_page_state_snapshot(zone, NR_ZONE_ACTIVE_FILE);
330         if (get_nr_swap_pages() > 0)
331                 nr += zone_page_state_snapshot(zone, NR_ZONE_INACTIVE_ANON) +
332                         zone_page_state_snapshot(zone, NR_ZONE_ACTIVE_ANON);
333
334         return nr;
335 }
336
337 /**
338  * lruvec_lru_size -  Returns the number of pages on the given LRU list.
339  * @lruvec: lru vector
340  * @lru: lru to use
341  * @zone_idx: zones to consider (use MAX_NR_ZONES for the whole LRU list)
342  */
343 unsigned long lruvec_lru_size(struct lruvec *lruvec, enum lru_list lru, int zone_idx)
344 {
345         unsigned long lru_size;
346         int zid;
347
348         if (!mem_cgroup_disabled())
349                 lru_size = mem_cgroup_get_lru_size(lruvec, lru);
350         else
351                 lru_size = node_page_state(lruvec_pgdat(lruvec), NR_LRU_BASE + lru);
352
353         for (zid = zone_idx + 1; zid < MAX_NR_ZONES; zid++) {
354                 struct zone *zone = &lruvec_pgdat(lruvec)->node_zones[zid];
355                 unsigned long size;
356
357                 if (!managed_zone(zone))
358                         continue;
359
360                 if (!mem_cgroup_disabled())
361                         size = mem_cgroup_get_zone_lru_size(lruvec, lru, zid);
362                 else
363                         size = zone_page_state(&lruvec_pgdat(lruvec)->node_zones[zid],
364                                        NR_ZONE_LRU_BASE + lru);
365                 lru_size -= min(size, lru_size);
366         }
367
368         return lru_size;
369
370 }
371
372 /*
373  * Add a shrinker callback to be called from the vm.
374  */
375 int prealloc_shrinker(struct shrinker *shrinker)
376 {
377         size_t size = sizeof(*shrinker->nr_deferred);
378
379         if (shrinker->flags & SHRINKER_NUMA_AWARE)
380                 size *= nr_node_ids;
381
382         shrinker->nr_deferred = kzalloc(size, GFP_KERNEL);
383         if (!shrinker->nr_deferred)
384                 return -ENOMEM;
385
386         if (shrinker->flags & SHRINKER_MEMCG_AWARE) {
387                 if (prealloc_memcg_shrinker(shrinker))
388                         goto free_deferred;
389         }
390
391         return 0;
392
393 free_deferred:
394         kfree(shrinker->nr_deferred);
395         shrinker->nr_deferred = NULL;
396         return -ENOMEM;
397 }
398
399 void free_prealloced_shrinker(struct shrinker *shrinker)
400 {
401         if (!shrinker->nr_deferred)
402                 return;
403
404         if (shrinker->flags & SHRINKER_MEMCG_AWARE)
405                 unregister_memcg_shrinker(shrinker);
406
407         kfree(shrinker->nr_deferred);
408         shrinker->nr_deferred = NULL;
409 }
410
411 void register_shrinker_prepared(struct shrinker *shrinker)
412 {
413         down_write(&shrinker_rwsem);
414         list_add_tail(&shrinker->list, &shrinker_list);
415 #ifdef CONFIG_MEMCG_KMEM
416         if (shrinker->flags & SHRINKER_MEMCG_AWARE)
417                 idr_replace(&shrinker_idr, shrinker, shrinker->id);
418 #endif
419         up_write(&shrinker_rwsem);
420 }
421
422 int register_shrinker(struct shrinker *shrinker)
423 {
424         int err = prealloc_shrinker(shrinker);
425
426         if (err)
427                 return err;
428         register_shrinker_prepared(shrinker);
429         return 0;
430 }
431 EXPORT_SYMBOL(register_shrinker);
432
433 /*
434  * Remove one
435  */
436 void unregister_shrinker(struct shrinker *shrinker)
437 {
438         if (!shrinker->nr_deferred)
439                 return;
440         if (shrinker->flags & SHRINKER_MEMCG_AWARE)
441                 unregister_memcg_shrinker(shrinker);
442         down_write(&shrinker_rwsem);
443         list_del(&shrinker->list);
444         up_write(&shrinker_rwsem);
445         kfree(shrinker->nr_deferred);
446         shrinker->nr_deferred = NULL;
447 }
448 EXPORT_SYMBOL(unregister_shrinker);
449
450 #define SHRINK_BATCH 128
451
452 static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
453                                     struct shrinker *shrinker, int priority)
454 {
455         unsigned long freed = 0;
456         unsigned long long delta;
457         long total_scan;
458         long freeable;
459         long nr;
460         long new_nr;
461         int nid = shrinkctl->nid;
462         long batch_size = shrinker->batch ? shrinker->batch
463                                           : SHRINK_BATCH;
464         long scanned = 0, next_deferred;
465
466         if (!(shrinker->flags & SHRINKER_NUMA_AWARE))
467                 nid = 0;
468
469         freeable = shrinker->count_objects(shrinker, shrinkctl);
470         if (freeable == 0 || freeable == SHRINK_EMPTY)
471                 return freeable;
472
473         /*
474          * copy the current shrinker scan count into a local variable
475          * and zero it so that other concurrent shrinker invocations
476          * don't also do this scanning work.
477          */
478         nr = atomic_long_xchg(&shrinker->nr_deferred[nid], 0);
479
480         total_scan = nr;
481         if (shrinker->seeks) {
482                 delta = freeable >> priority;
483                 delta *= 4;
484                 do_div(delta, shrinker->seeks);
485         } else {
486                 /*
487                  * These objects don't require any IO to create. Trim
488                  * them aggressively under memory pressure to keep
489                  * them from causing refetches in the IO caches.
490                  */
491                 delta = freeable / 2;
492         }
493
494         /*
495          * Make sure we apply some minimal pressure on default priority
496          * even on small cgroups. Stale objects are not only consuming memory
497          * by themselves, but can also hold a reference to a dying cgroup,
498          * preventing it from being reclaimed. A dying cgroup with all
499          * corresponding structures like per-cpu stats and kmem caches
500          * can be really big, so it may lead to a significant waste of memory.
501          */
502         delta = max_t(unsigned long long, delta, min(freeable, batch_size));
503
504         total_scan += delta;
505         if (total_scan < 0) {
506                 pr_err("shrink_slab: %pF negative objects to delete nr=%ld\n",
507                        shrinker->scan_objects, total_scan);
508                 total_scan = freeable;
509                 next_deferred = nr;
510         } else
511                 next_deferred = total_scan;
512
513         /*
514          * We need to avoid excessive windup on filesystem shrinkers
515          * due to large numbers of GFP_NOFS allocations causing the
516          * shrinkers to return -1 all the time. This results in a large
517          * nr being built up so when a shrink that can do some work
518          * comes along it empties the entire cache due to nr >>>
519          * freeable. This is bad for sustaining a working set in
520          * memory.
521          *
522          * Hence only allow the shrinker to scan the entire cache when
523          * a large delta change is calculated directly.
524          */
525         if (delta < freeable / 4)
526                 total_scan = min(total_scan, freeable / 2);
527
528         /*
529          * Avoid risking looping forever due to too large nr value:
530          * never try to free more than twice the estimate number of
531          * freeable entries.
532          */
533         if (total_scan > freeable * 2)
534                 total_scan = freeable * 2;
535
536         trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,
537                                    freeable, delta, total_scan, priority);
538
539         /*
540          * Normally, we should not scan less than batch_size objects in one
541          * pass to avoid too frequent shrinker calls, but if the slab has less
542          * than batch_size objects in total and we are really tight on memory,
543          * we will try to reclaim all available objects, otherwise we can end
544          * up failing allocations although there are plenty of reclaimable
545          * objects spread over several slabs with usage less than the
546          * batch_size.
547          *
548          * We detect the "tight on memory" situations by looking at the total
549          * number of objects we want to scan (total_scan). If it is greater
550          * than the total number of objects on slab (freeable), we must be
551          * scanning at high prio and therefore should try to reclaim as much as
552          * possible.
553          */
554         while (total_scan >= batch_size ||
555                total_scan >= freeable) {
556                 unsigned long ret;
557                 unsigned long nr_to_scan = min(batch_size, total_scan);
558
559                 shrinkctl->nr_to_scan = nr_to_scan;
560                 shrinkctl->nr_scanned = nr_to_scan;
561                 ret = shrinker->scan_objects(shrinker, shrinkctl);
562                 if (ret == SHRINK_STOP)
563                         break;
564                 freed += ret;
565
566                 count_vm_events(SLABS_SCANNED, shrinkctl->nr_scanned);
567                 total_scan -= shrinkctl->nr_scanned;
568                 scanned += shrinkctl->nr_scanned;
569
570                 cond_resched();
571         }
572
573         if (next_deferred >= scanned)
574                 next_deferred -= scanned;
575         else
576                 next_deferred = 0;
577         /*
578          * move the unused scan count back into the shrinker in a
579          * manner that handles concurrent updates. If we exhausted the
580          * scan, there is no need to do an update.
581          */
582         if (next_deferred > 0)
583                 new_nr = atomic_long_add_return(next_deferred,
584                                                 &shrinker->nr_deferred[nid]);
585         else
586                 new_nr = atomic_long_read(&shrinker->nr_deferred[nid]);
587
588         trace_mm_shrink_slab_end(shrinker, nid, freed, nr, new_nr, total_scan);
589         return freed;
590 }
591
592 #ifdef CONFIG_MEMCG_KMEM
593 static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
594                         struct mem_cgroup *memcg, int priority)
595 {
596         struct memcg_shrinker_map *map;
597         unsigned long ret, freed = 0;
598         int i;
599
600         if (!memcg_kmem_enabled() || !mem_cgroup_online(memcg))
601                 return 0;
602
603         if (!down_read_trylock(&shrinker_rwsem))
604                 return 0;
605
606         map = rcu_dereference_protected(memcg->nodeinfo[nid]->shrinker_map,
607                                         true);
608         if (unlikely(!map))
609                 goto unlock;
610
611         for_each_set_bit(i, map->map, shrinker_nr_max) {
612                 struct shrink_control sc = {
613                         .gfp_mask = gfp_mask,
614                         .nid = nid,
615                         .memcg = memcg,
616                 };
617                 struct shrinker *shrinker;
618
619                 shrinker = idr_find(&shrinker_idr, i);
620                 if (unlikely(!shrinker || shrinker == SHRINKER_REGISTERING)) {
621                         if (!shrinker)
622                                 clear_bit(i, map->map);
623                         continue;
624                 }
625
626                 ret = do_shrink_slab(&sc, shrinker, priority);
627                 if (ret == SHRINK_EMPTY) {
628                         clear_bit(i, map->map);
629                         /*
630                          * After the shrinker reported that it had no objects to
631                          * free, but before we cleared the corresponding bit in
632                          * the memcg shrinker map, a new object might have been
633                          * added. To make sure, we have the bit set in this
634                          * case, we invoke the shrinker one more time and reset
635                          * the bit if it reports that it is not empty anymore.
636                          * The memory barrier here pairs with the barrier in
637                          * memcg_set_shrinker_bit():
638                          *
639                          * list_lru_add()     shrink_slab_memcg()
640                          *   list_add_tail()    clear_bit()
641                          *   <MB>               <MB>
642                          *   set_bit()          do_shrink_slab()
643                          */
644                         smp_mb__after_atomic();
645                         ret = do_shrink_slab(&sc, shrinker, priority);
646                         if (ret == SHRINK_EMPTY)
647                                 ret = 0;
648                         else
649                                 memcg_set_shrinker_bit(memcg, nid, i);
650                 }
651                 freed += ret;
652
653                 if (rwsem_is_contended(&shrinker_rwsem)) {
654                         freed = freed ? : 1;
655                         break;
656                 }
657         }
658 unlock:
659         up_read(&shrinker_rwsem);
660         return freed;
661 }
662 #else /* CONFIG_MEMCG_KMEM */
663 static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
664                         struct mem_cgroup *memcg, int priority)
665 {
666         return 0;
667 }
668 #endif /* CONFIG_MEMCG_KMEM */
669
670 /**
671  * shrink_slab - shrink slab caches
672  * @gfp_mask: allocation context
673  * @nid: node whose slab caches to target
674  * @memcg: memory cgroup whose slab caches to target
675  * @priority: the reclaim priority
676  *
677  * Call the shrink functions to age shrinkable caches.
678  *
679  * @nid is passed along to shrinkers with SHRINKER_NUMA_AWARE set,
680  * unaware shrinkers will receive a node id of 0 instead.
681  *
682  * @memcg specifies the memory cgroup to target. Unaware shrinkers
683  * are called only if it is the root cgroup.
684  *
685  * @priority is sc->priority, we take the number of objects and >> by priority
686  * in order to get the scan target.
687  *
688  * Returns the number of reclaimed slab objects.
689  */
690 static unsigned long shrink_slab(gfp_t gfp_mask, int nid,
691                                  struct mem_cgroup *memcg,
692                                  int priority)
693 {
694         unsigned long ret, freed = 0;
695         struct shrinker *shrinker;
696
697         if (!mem_cgroup_is_root(memcg))
698                 return shrink_slab_memcg(gfp_mask, nid, memcg, priority);
699
700         if (!down_read_trylock(&shrinker_rwsem))
701                 goto out;
702
703         list_for_each_entry(shrinker, &shrinker_list, list) {
704                 struct shrink_control sc = {
705                         .gfp_mask = gfp_mask,
706                         .nid = nid,
707                         .memcg = memcg,
708                 };
709
710                 ret = do_shrink_slab(&sc, shrinker, priority);
711                 if (ret == SHRINK_EMPTY)
712                         ret = 0;
713                 freed += ret;
714                 /*
715                  * Bail out if someone want to register a new shrinker to
716                  * prevent the regsitration from being stalled for long periods
717                  * by parallel ongoing shrinking.
718                  */
719                 if (rwsem_is_contended(&shrinker_rwsem)) {
720                         freed = freed ? : 1;
721                         break;
722                 }
723         }
724
725         up_read(&shrinker_rwsem);
726 out:
727         cond_resched();
728         return freed;
729 }
730
731 void drop_slab_node(int nid)
732 {
733         unsigned long freed;
734
735         do {
736                 struct mem_cgroup *memcg = NULL;
737
738                 freed = 0;
739                 memcg = mem_cgroup_iter(NULL, NULL, NULL);
740                 do {
741                         freed += shrink_slab(GFP_KERNEL, nid, memcg, 0);
742                 } while ((memcg = mem_cgroup_iter(NULL, memcg, NULL)) != NULL);
743         } while (freed > 10);
744 }
745
746 void drop_slab(void)
747 {
748         int nid;
749
750         for_each_online_node(nid)
751                 drop_slab_node(nid);
752 }
753
754 static inline int is_page_cache_freeable(struct page *page)
755 {
756         /*
757          * A freeable page cache page is referenced only by the caller
758          * that isolated the page, the page cache and optional buffer
759          * heads at page->private.
760          */
761         int page_cache_pins = PageTransHuge(page) && PageSwapCache(page) ?
762                 HPAGE_PMD_NR : 1;
763         return page_count(page) - page_has_private(page) == 1 + page_cache_pins;
764 }
765
766 static int may_write_to_inode(struct inode *inode, struct scan_control *sc)
767 {
768         if (current->flags & PF_SWAPWRITE)
769                 return 1;
770         if (!inode_write_congested(inode))
771                 return 1;
772         if (inode_to_bdi(inode) == current->backing_dev_info)
773                 return 1;
774         return 0;
775 }
776
777 /*
778  * We detected a synchronous write error writing a page out.  Probably
779  * -ENOSPC.  We need to propagate that into the address_space for a subsequent
780  * fsync(), msync() or close().
781  *
782  * The tricky part is that after writepage we cannot touch the mapping: nothing
783  * prevents it from being freed up.  But we have a ref on the page and once
784  * that page is locked, the mapping is pinned.
785  *
786  * We're allowed to run sleeping lock_page() here because we know the caller has
787  * __GFP_FS.
788  */
789 static void handle_write_error(struct address_space *mapping,
790                                 struct page *page, int error)
791 {
792         lock_page(page);
793         if (page_mapping(page) == mapping)
794                 mapping_set_error(mapping, error);
795         unlock_page(page);
796 }
797
798 /* possible outcome of pageout() */
799 typedef enum {
800         /* failed to write page out, page is locked */
801         PAGE_KEEP,
802         /* move page to the active list, page is locked */
803         PAGE_ACTIVATE,
804         /* page has been sent to the disk successfully, page is unlocked */
805         PAGE_SUCCESS,
806         /* page is clean and locked */
807         PAGE_CLEAN,
808 } pageout_t;
809
810 /*
811  * pageout is called by shrink_page_list() for each dirty page.
812  * Calls ->writepage().
813  */
814 static pageout_t pageout(struct page *page, struct address_space *mapping,
815                          struct scan_control *sc)
816 {
817         /*
818          * If the page is dirty, only perform writeback if that write
819          * will be non-blocking.  To prevent this allocation from being
820          * stalled by pagecache activity.  But note that there may be
821          * stalls if we need to run get_block().  We could test
822          * PagePrivate for that.
823          *
824          * If this process is currently in __generic_file_write_iter() against
825          * this page's queue, we can perform writeback even if that
826          * will block.
827          *
828          * If the page is swapcache, write it back even if that would
829          * block, for some throttling. This happens by accident, because
830          * swap_backing_dev_info is bust: it doesn't reflect the
831          * congestion state of the swapdevs.  Easy to fix, if needed.
832          */
833         if (!is_page_cache_freeable(page))
834                 return PAGE_KEEP;
835         if (!mapping) {
836                 /*
837                  * Some data journaling orphaned pages can have
838                  * page->mapping == NULL while being dirty with clean buffers.
839                  */
840                 if (page_has_private(page)) {
841                         if (try_to_free_buffers(page)) {
842                                 ClearPageDirty(page);
843                                 pr_info("%s: orphaned page\n", __func__);
844                                 return PAGE_CLEAN;
845                         }
846                 }
847                 return PAGE_KEEP;
848         }
849         if (mapping->a_ops->writepage == NULL)
850                 return PAGE_ACTIVATE;
851         if (!may_write_to_inode(mapping->host, sc))
852                 return PAGE_KEEP;
853
854         if (clear_page_dirty_for_io(page)) {
855                 int res;
856                 struct writeback_control wbc = {
857                         .sync_mode = WB_SYNC_NONE,
858                         .nr_to_write = SWAP_CLUSTER_MAX,
859                         .range_start = 0,
860                         .range_end = LLONG_MAX,
861                         .for_reclaim = 1,
862                 };
863
864                 SetPageReclaim(page);
865                 res = mapping->a_ops->writepage(page, &wbc);
866                 if (res < 0)
867                         handle_write_error(mapping, page, res);
868                 if (res == AOP_WRITEPAGE_ACTIVATE) {
869                         ClearPageReclaim(page);
870                         return PAGE_ACTIVATE;
871                 }
872
873                 if (!PageWriteback(page)) {
874                         /* synchronous write or broken a_ops? */
875                         ClearPageReclaim(page);
876                 }
877                 trace_mm_vmscan_writepage(page);
878                 inc_node_page_state(page, NR_VMSCAN_WRITE);
879                 return PAGE_SUCCESS;
880         }
881
882         return PAGE_CLEAN;
883 }
884
885 /*
886  * Same as remove_mapping, but if the page is removed from the mapping, it
887  * gets returned with a refcount of 0.
888  */
889 static int __remove_mapping(struct address_space *mapping, struct page *page,
890                             bool reclaimed)
891 {
892         unsigned long flags;
893         int refcount;
894
895         BUG_ON(!PageLocked(page));
896         BUG_ON(mapping != page_mapping(page));
897
898         xa_lock_irqsave(&mapping->i_pages, flags);
899         /*
900          * The non racy check for a busy page.
901          *
902          * Must be careful with the order of the tests. When someone has
903          * a ref to the page, it may be possible that they dirty it then
904          * drop the reference. So if PageDirty is tested before page_count
905          * here, then the following race may occur:
906          *
907          * get_user_pages(&page);
908          * [user mapping goes away]
909          * write_to(page);
910          *                              !PageDirty(page)    [good]
911          * SetPageDirty(page);
912          * put_page(page);
913          *                              !page_count(page)   [good, discard it]
914          *
915          * [oops, our write_to data is lost]
916          *
917          * Reversing the order of the tests ensures such a situation cannot
918          * escape unnoticed. The smp_rmb is needed to ensure the page->flags
919          * load is not satisfied before that of page->_refcount.
920          *
921          * Note that if SetPageDirty is always performed via set_page_dirty,
922          * and thus under the i_pages lock, then this ordering is not required.
923          */
924         if (unlikely(PageTransHuge(page)) && PageSwapCache(page))
925                 refcount = 1 + HPAGE_PMD_NR;
926         else
927                 refcount = 2;
928         if (!page_ref_freeze(page, refcount))
929                 goto cannot_free;
930         /* note: atomic_cmpxchg in page_ref_freeze provides the smp_rmb */
931         if (unlikely(PageDirty(page))) {
932                 page_ref_unfreeze(page, refcount);
933                 goto cannot_free;
934         }
935
936         if (PageSwapCache(page)) {
937                 swp_entry_t swap = { .val = page_private(page) };
938                 mem_cgroup_swapout(page, swap);
939                 __delete_from_swap_cache(page, swap);
940                 xa_unlock_irqrestore(&mapping->i_pages, flags);
941                 put_swap_page(page, swap);
942         } else {
943                 void (*freepage)(struct page *);
944                 void *shadow = NULL;
945
946                 freepage = mapping->a_ops->freepage;
947                 /*
948                  * Remember a shadow entry for reclaimed file cache in
949                  * order to detect refaults, thus thrashing, later on.
950                  *
951                  * But don't store shadows in an address space that is
952                  * already exiting.  This is not just an optizimation,
953                  * inode reclaim needs to empty out the radix tree or
954                  * the nodes are lost.  Don't plant shadows behind its
955                  * back.
956                  *
957                  * We also don't store shadows for DAX mappings because the
958                  * only page cache pages found in these are zero pages
959                  * covering holes, and because we don't want to mix DAX
960                  * exceptional entries and shadow exceptional entries in the
961                  * same address_space.
962                  */
963                 if (reclaimed && page_is_file_cache(page) &&
964                     !mapping_exiting(mapping) && !dax_mapping(mapping))
965                         shadow = workingset_eviction(mapping, page);
966                 __delete_from_page_cache(page, shadow);
967                 xa_unlock_irqrestore(&mapping->i_pages, flags);
968
969                 if (freepage != NULL)
970                         freepage(page);
971         }
972
973         return 1;
974
975 cannot_free:
976         xa_unlock_irqrestore(&mapping->i_pages, flags);
977         return 0;
978 }
979
980 /*
981  * Attempt to detach a locked page from its ->mapping.  If it is dirty or if
982  * someone else has a ref on the page, abort and return 0.  If it was
983  * successfully detached, return 1.  Assumes the caller has a single ref on
984  * this page.
985  */
986 int remove_mapping(struct address_space *mapping, struct page *page)
987 {
988         if (__remove_mapping(mapping, page, false)) {
989                 /*
990                  * Unfreezing the refcount with 1 rather than 2 effectively
991                  * drops the pagecache ref for us without requiring another
992                  * atomic operation.
993                  */
994                 page_ref_unfreeze(page, 1);
995                 return 1;
996         }
997         return 0;
998 }
999
1000 /**
1001  * putback_lru_page - put previously isolated page onto appropriate LRU list
1002  * @page: page to be put back to appropriate lru list
1003  *
1004  * Add previously isolated @page to appropriate LRU list.
1005  * Page may still be unevictable for other reasons.
1006  *
1007  * lru_lock must not be held, interrupts must be enabled.
1008  */
1009 void putback_lru_page(struct page *page)
1010 {
1011         lru_cache_add(page);
1012         put_page(page);         /* drop ref from isolate */
1013 }
1014
1015 enum page_references {
1016         PAGEREF_RECLAIM,
1017         PAGEREF_RECLAIM_CLEAN,
1018         PAGEREF_KEEP,
1019         PAGEREF_ACTIVATE,
1020 };
1021
1022 static enum page_references page_check_references(struct page *page,
1023                                                   struct scan_control *sc)
1024 {
1025         int referenced_ptes, referenced_page;
1026         unsigned long vm_flags;
1027
1028         referenced_ptes = page_referenced(page, 1, sc->target_mem_cgroup,
1029                                           &vm_flags);
1030         referenced_page = TestClearPageReferenced(page);
1031
1032         /*
1033          * Mlock lost the isolation race with us.  Let try_to_unmap()
1034          * move the page to the unevictable list.
1035          */
1036         if (vm_flags & VM_LOCKED)
1037                 return PAGEREF_RECLAIM;
1038
1039         if (referenced_ptes) {
1040                 if (PageSwapBacked(page))
1041                         return PAGEREF_ACTIVATE;
1042                 /*
1043                  * All mapped pages start out with page table
1044                  * references from the instantiating fault, so we need
1045                  * to look twice if a mapped file page is used more
1046                  * than once.
1047                  *
1048                  * Mark it and spare it for another trip around the
1049                  * inactive list.  Another page table reference will
1050                  * lead to its activation.
1051                  *
1052                  * Note: the mark is set for activated pages as well
1053                  * so that recently deactivated but used pages are
1054                  * quickly recovered.
1055                  */
1056                 SetPageReferenced(page);
1057
1058                 if (referenced_page || referenced_ptes > 1)
1059                         return PAGEREF_ACTIVATE;
1060
1061                 /*
1062                  * Activate file-backed executable pages after first usage.
1063                  */
1064                 if (vm_flags & VM_EXEC)
1065                         return PAGEREF_ACTIVATE;
1066
1067                 return PAGEREF_KEEP;
1068         }
1069
1070         /* Reclaim if clean, defer dirty pages to writeback */
1071         if (referenced_page && !PageSwapBacked(page))
1072                 return PAGEREF_RECLAIM_CLEAN;
1073
1074         return PAGEREF_RECLAIM;
1075 }
1076
1077 /* Check if a page is dirty or under writeback */
1078 static void page_check_dirty_writeback(struct page *page,
1079                                        bool *dirty, bool *writeback)
1080 {
1081         struct address_space *mapping;
1082
1083         /*
1084          * Anonymous pages are not handled by flushers and must be written
1085          * from reclaim context. Do not stall reclaim based on them
1086          */
1087         if (!page_is_file_cache(page) ||
1088             (PageAnon(page) && !PageSwapBacked(page))) {
1089                 *dirty = false;
1090                 *writeback = false;
1091                 return;
1092         }
1093
1094         /* By default assume that the page flags are accurate */
1095         *dirty = PageDirty(page);
1096         *writeback = PageWriteback(page);
1097
1098         /* Verify dirty/writeback state if the filesystem supports it */
1099         if (!page_has_private(page))
1100                 return;
1101
1102         mapping = page_mapping(page);
1103         if (mapping && mapping->a_ops->is_dirty_writeback)
1104                 mapping->a_ops->is_dirty_writeback(page, dirty, writeback);
1105 }
1106
1107 /*
1108  * shrink_page_list() returns the number of reclaimed pages
1109  */
1110 static unsigned long shrink_page_list(struct list_head *page_list,
1111                                       struct pglist_data *pgdat,
1112                                       struct scan_control *sc,
1113                                       enum ttu_flags ttu_flags,
1114                                       struct reclaim_stat *stat,
1115                                       bool force_reclaim)
1116 {
1117         LIST_HEAD(ret_pages);
1118         LIST_HEAD(free_pages);
1119         int pgactivate = 0;
1120         unsigned nr_unqueued_dirty = 0;
1121         unsigned nr_dirty = 0;
1122         unsigned nr_congested = 0;
1123         unsigned nr_reclaimed = 0;
1124         unsigned nr_writeback = 0;
1125         unsigned nr_immediate = 0;
1126         unsigned nr_ref_keep = 0;
1127         unsigned nr_unmap_fail = 0;
1128
1129         cond_resched();
1130
1131         while (!list_empty(page_list)) {
1132                 struct address_space *mapping;
1133                 struct page *page;
1134                 int may_enter_fs;
1135                 enum page_references references = PAGEREF_RECLAIM_CLEAN;
1136                 bool dirty, writeback;
1137
1138                 cond_resched();
1139
1140                 page = lru_to_page(page_list);
1141                 list_del(&page->lru);
1142
1143                 if (!trylock_page(page))
1144                         goto keep;
1145
1146                 VM_BUG_ON_PAGE(PageActive(page), page);
1147
1148                 sc->nr_scanned++;
1149
1150                 if (unlikely(!page_evictable(page)))
1151                         goto activate_locked;
1152
1153                 if (!sc->may_unmap && page_mapped(page))
1154                         goto keep_locked;
1155
1156                 /* Double the slab pressure for mapped and swapcache pages */
1157                 if ((page_mapped(page) || PageSwapCache(page)) &&
1158                     !(PageAnon(page) && !PageSwapBacked(page)))
1159                         sc->nr_scanned++;
1160
1161                 may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
1162                         (PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));
1163
1164                 /*
1165                  * The number of dirty pages determines if a node is marked
1166                  * reclaim_congested which affects wait_iff_congested. kswapd
1167                  * will stall and start writing pages if the tail of the LRU
1168                  * is all dirty unqueued pages.
1169                  */
1170                 page_check_dirty_writeback(page, &dirty, &writeback);
1171                 if (dirty || writeback)
1172                         nr_dirty++;
1173
1174                 if (dirty && !writeback)
1175                         nr_unqueued_dirty++;
1176
1177                 /*
1178                  * Treat this page as congested if the underlying BDI is or if
1179                  * pages are cycling through the LRU so quickly that the
1180                  * pages marked for immediate reclaim are making it to the
1181                  * end of the LRU a second time.
1182                  */
1183                 mapping = page_mapping(page);
1184                 if (((dirty || writeback) && mapping &&
1185                      inode_write_congested(mapping->host)) ||
1186                     (writeback && PageReclaim(page)))
1187                         nr_congested++;
1188
1189                 /*
1190                  * If a page at the tail of the LRU is under writeback, there
1191                  * are three cases to consider.
1192                  *
1193                  * 1) If reclaim is encountering an excessive number of pages
1194                  *    under writeback and this page is both under writeback and
1195                  *    PageReclaim then it indicates that pages are being queued
1196                  *    for IO but are being recycled through the LRU before the
1197                  *    IO can complete. Waiting on the page itself risks an
1198                  *    indefinite stall if it is impossible to writeback the
1199                  *    page due to IO error or disconnected storage so instead
1200                  *    note that the LRU is being scanned too quickly and the
1201                  *    caller can stall after page list has been processed.
1202                  *
1203                  * 2) Global or new memcg reclaim encounters a page that is
1204                  *    not marked for immediate reclaim, or the caller does not
1205                  *    have __GFP_FS (or __GFP_IO if it's simply going to swap,
1206                  *    not to fs). In this case mark the page for immediate
1207                  *    reclaim and continue scanning.
1208                  *
1209                  *    Require may_enter_fs because we would wait on fs, which
1210                  *    may not have submitted IO yet. And the loop driver might
1211                  *    enter reclaim, and deadlock if it waits on a page for
1212                  *    which it is needed to do the write (loop masks off
1213                  *    __GFP_IO|__GFP_FS for this reason); but more thought
1214                  *    would probably show more reasons.
1215                  *
1216                  * 3) Legacy memcg encounters a page that is already marked
1217                  *    PageReclaim. memcg does not have any dirty pages
1218                  *    throttling so we could easily OOM just because too many
1219                  *    pages are in writeback and there is nothing else to
1220                  *    reclaim. Wait for the writeback to complete.
1221                  *
1222                  * In cases 1) and 2) we activate the pages to get them out of
1223                  * the way while we continue scanning for clean pages on the
1224                  * inactive list and refilling from the active list. The
1225                  * observation here is that waiting for disk writes is more
1226                  * expensive than potentially causing reloads down the line.
1227                  * Since they're marked for immediate reclaim, they won't put
1228                  * memory pressure on the cache working set any longer than it
1229                  * takes to write them to disk.
1230                  */
1231                 if (PageWriteback(page)) {
1232                         /* Case 1 above */
1233                         if (current_is_kswapd() &&
1234                             PageReclaim(page) &&
1235                             test_bit(PGDAT_WRITEBACK, &pgdat->flags)) {
1236                                 nr_immediate++;
1237                                 goto activate_locked;
1238
1239                         /* Case 2 above */
1240                         } else if (sane_reclaim(sc) ||
1241                             !PageReclaim(page) || !may_enter_fs) {
1242                                 /*
1243                                  * This is slightly racy - end_page_writeback()
1244                                  * might have just cleared PageReclaim, then
1245                                  * setting PageReclaim here end up interpreted
1246                                  * as PageReadahead - but that does not matter
1247                                  * enough to care.  What we do want is for this
1248                                  * page to have PageReclaim set next time memcg
1249                                  * reclaim reaches the tests above, so it will
1250                                  * then wait_on_page_writeback() to avoid OOM;
1251                                  * and it's also appropriate in global reclaim.
1252                                  */
1253                                 SetPageReclaim(page);
1254                                 nr_writeback++;
1255                                 goto activate_locked;
1256
1257                         /* Case 3 above */
1258                         } else {
1259                                 unlock_page(page);
1260                                 wait_on_page_writeback(page);
1261                                 /* then go back and try same page again */
1262                                 list_add_tail(&page->lru, page_list);
1263                                 continue;
1264                         }
1265                 }
1266
1267                 if (!force_reclaim)
1268                         references = page_check_references(page, sc);
1269
1270                 switch (references) {
1271                 case PAGEREF_ACTIVATE:
1272                         goto activate_locked;
1273                 case PAGEREF_KEEP:
1274                         nr_ref_keep++;
1275                         goto keep_locked;
1276                 case PAGEREF_RECLAIM:
1277                 case PAGEREF_RECLAIM_CLEAN:
1278                         ; /* try to reclaim the page below */
1279                 }
1280
1281                 /*
1282                  * Anonymous process memory has backing store?
1283                  * Try to allocate it some swap space here.
1284                  * Lazyfree page could be freed directly
1285                  */
1286                 if (PageAnon(page) && PageSwapBacked(page)) {
1287                         if (!PageSwapCache(page)) {
1288                                 if (!(sc->gfp_mask & __GFP_IO))
1289                                         goto keep_locked;
1290                                 if (PageTransHuge(page)) {
1291                                         /* cannot split THP, skip it */
1292                                         if (!can_split_huge_page(page, NULL))
1293                                                 goto activate_locked;
1294                                         /*
1295                                          * Split pages without a PMD map right
1296                                          * away. Chances are some or all of the
1297                                          * tail pages can be freed without IO.
1298                                          */
1299                                         if (!compound_mapcount(page) &&
1300                                             split_huge_page_to_list(page,
1301                                                                     page_list))
1302                                                 goto activate_locked;
1303                                 }
1304                                 if (!add_to_swap(page)) {
1305                                         if (!PageTransHuge(page))
1306                                                 goto activate_locked;
1307                                         /* Fallback to swap normal pages */
1308                                         if (split_huge_page_to_list(page,
1309                                                                     page_list))
1310                                                 goto activate_locked;
1311 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
1312                                         count_vm_event(THP_SWPOUT_FALLBACK);
1313 #endif
1314                                         if (!add_to_swap(page))
1315                                                 goto activate_locked;
1316                                 }
1317
1318                                 may_enter_fs = 1;
1319
1320                                 /* Adding to swap updated mapping */
1321                                 mapping = page_mapping(page);
1322                         }
1323                 } else if (unlikely(PageTransHuge(page))) {
1324                         /* Split file THP */
1325                         if (split_huge_page_to_list(page, page_list))
1326                                 goto keep_locked;
1327                 }
1328
1329                 /*
1330                  * The page is mapped into the page tables of one or more
1331                  * processes. Try to unmap it here.
1332                  */
1333                 if (page_mapped(page)) {
1334                         enum ttu_flags flags = ttu_flags | TTU_BATCH_FLUSH;
1335
1336                         if (unlikely(PageTransHuge(page)))
1337                                 flags |= TTU_SPLIT_HUGE_PMD;
1338                         if (!try_to_unmap(page, flags)) {
1339                                 nr_unmap_fail++;
1340                                 goto activate_locked;
1341                         }
1342                 }
1343
1344                 if (PageDirty(page)) {
1345                         /*
1346                          * Only kswapd can writeback filesystem pages
1347                          * to avoid risk of stack overflow. But avoid
1348                          * injecting inefficient single-page IO into
1349                          * flusher writeback as much as possible: only
1350                          * write pages when we've encountered many
1351                          * dirty pages, and when we've already scanned
1352                          * the rest of the LRU for clean pages and see
1353                          * the same dirty pages again (PageReclaim).
1354                          */
1355                         if (page_is_file_cache(page) &&
1356                             (!current_is_kswapd() || !PageReclaim(page) ||
1357                              !test_bit(PGDAT_DIRTY, &pgdat->flags))) {
1358                                 /*
1359                                  * Immediately reclaim when written back.
1360                                  * Similar in principal to deactivate_page()
1361                                  * except we already have the page isolated
1362                                  * and know it's dirty
1363                                  */
1364                                 inc_node_page_state(page, NR_VMSCAN_IMMEDIATE);
1365                                 SetPageReclaim(page);
1366
1367                                 goto activate_locked;
1368                         }
1369
1370                         if (references == PAGEREF_RECLAIM_CLEAN)
1371                                 goto keep_locked;
1372                         if (!may_enter_fs)
1373                                 goto keep_locked;
1374                         if (!sc->may_writepage)
1375                                 goto keep_locked;
1376
1377                         /*
1378                          * Page is dirty. Flush the TLB if a writable entry
1379                          * potentially exists to avoid CPU writes after IO
1380                          * starts and then write it out here.
1381                          */
1382                         try_to_unmap_flush_dirty();
1383                         switch (pageout(page, mapping, sc)) {
1384                         case PAGE_KEEP:
1385                                 goto keep_locked;
1386                         case PAGE_ACTIVATE:
1387                                 goto activate_locked;
1388                         case PAGE_SUCCESS:
1389                                 if (PageWriteback(page))
1390                                         goto keep;
1391                                 if (PageDirty(page))
1392                                         goto keep;
1393
1394                                 /*
1395                                  * A synchronous write - probably a ramdisk.  Go
1396                                  * ahead and try to reclaim the page.
1397                                  */
1398                                 if (!trylock_page(page))
1399                                         goto keep;
1400                                 if (PageDirty(page) || PageWriteback(page))
1401                                         goto keep_locked;
1402                                 mapping = page_mapping(page);
1403                         case PAGE_CLEAN:
1404                                 ; /* try to free the page below */
1405                         }
1406                 }
1407
1408                 /*
1409                  * If the page has buffers, try to free the buffer mappings
1410                  * associated with this page. If we succeed we try to free
1411                  * the page as well.
1412                  *
1413                  * We do this even if the page is PageDirty().
1414                  * try_to_release_page() does not perform I/O, but it is
1415                  * possible for a page to have PageDirty set, but it is actually
1416                  * clean (all its buffers are clean).  This happens if the
1417                  * buffers were written out directly, with submit_bh(). ext3
1418                  * will do this, as well as the blockdev mapping.
1419                  * try_to_release_page() will discover that cleanness and will
1420                  * drop the buffers and mark the page clean - it can be freed.
1421                  *
1422                  * Rarely, pages can have buffers and no ->mapping.  These are
1423                  * the pages which were not successfully invalidated in
1424                  * truncate_complete_page().  We try to drop those buffers here
1425                  * and if that worked, and the page is no longer mapped into
1426                  * process address space (page_count == 1) it can be freed.
1427                  * Otherwise, leave the page on the LRU so it is swappable.
1428                  */
1429                 if (page_has_private(page)) {
1430                         if (!try_to_release_page(page, sc->gfp_mask))
1431                                 goto activate_locked;
1432                         if (!mapping && page_count(page) == 1) {
1433                                 unlock_page(page);
1434                                 if (put_page_testzero(page))
1435                                         goto free_it;
1436                                 else {
1437                                         /*
1438                                          * rare race with speculative reference.
1439                                          * the speculative reference will free
1440                                          * this page shortly, so we may
1441                                          * increment nr_reclaimed here (and
1442                                          * leave it off the LRU).
1443                                          */
1444                                         nr_reclaimed++;
1445                                         continue;
1446                                 }
1447                         }
1448                 }
1449
1450                 if (PageAnon(page) && !PageSwapBacked(page)) {
1451                         /* follow __remove_mapping for reference */
1452                         if (!page_ref_freeze(page, 1))
1453                                 goto keep_locked;
1454                         if (PageDirty(page)) {
1455                                 page_ref_unfreeze(page, 1);
1456                                 goto keep_locked;
1457                         }
1458
1459                         count_vm_event(PGLAZYFREED);
1460                         count_memcg_page_event(page, PGLAZYFREED);
1461                 } else if (!mapping || !__remove_mapping(mapping, page, true))
1462                         goto keep_locked;
1463
1464                 unlock_page(page);
1465 free_it:
1466                 nr_reclaimed++;
1467
1468                 /*
1469                  * Is there need to periodically free_page_list? It would
1470                  * appear not as the counts should be low
1471                  */
1472                 if (unlikely(PageTransHuge(page))) {
1473                         mem_cgroup_uncharge(page);
1474                         (*get_compound_page_dtor(page))(page);
1475                 } else
1476                         list_add(&page->lru, &free_pages);
1477                 continue;
1478
1479 activate_locked:
1480                 /* Not a candidate for swapping, so reclaim swap space. */
1481                 if (PageSwapCache(page) && (mem_cgroup_swap_full(page) ||
1482                                                 PageMlocked(page)))
1483                         try_to_free_swap(page);
1484                 VM_BUG_ON_PAGE(PageActive(page), page);
1485                 if (!PageMlocked(page)) {
1486                         SetPageActive(page);
1487                         pgactivate++;
1488                         count_memcg_page_event(page, PGACTIVATE);
1489                 }
1490 keep_locked:
1491                 unlock_page(page);
1492 keep:
1493                 list_add(&page->lru, &ret_pages);
1494                 VM_BUG_ON_PAGE(PageLRU(page) || PageUnevictable(page), page);
1495         }
1496
1497         mem_cgroup_uncharge_list(&free_pages);
1498         try_to_unmap_flush();
1499         free_unref_page_list(&free_pages);
1500
1501         list_splice(&ret_pages, page_list);
1502         count_vm_events(PGACTIVATE, pgactivate);
1503
1504         if (stat) {
1505                 stat->nr_dirty = nr_dirty;
1506                 stat->nr_congested = nr_congested;
1507                 stat->nr_unqueued_dirty = nr_unqueued_dirty;
1508                 stat->nr_writeback = nr_writeback;
1509                 stat->nr_immediate = nr_immediate;
1510                 stat->nr_activate = pgactivate;
1511                 stat->nr_ref_keep = nr_ref_keep;
1512                 stat->nr_unmap_fail = nr_unmap_fail;
1513         }
1514         return nr_reclaimed;
1515 }
1516
1517 unsigned long reclaim_clean_pages_from_list(struct zone *zone,
1518                                             struct list_head *page_list)
1519 {
1520         struct scan_control sc = {
1521                 .gfp_mask = GFP_KERNEL,
1522                 .priority = DEF_PRIORITY,
1523                 .may_unmap = 1,
1524         };
1525         unsigned long ret;
1526         struct page *page, *next;
1527         LIST_HEAD(clean_pages);
1528
1529         list_for_each_entry_safe(page, next, page_list, lru) {
1530                 if (page_is_file_cache(page) && !PageDirty(page) &&
1531                     !__PageMovable(page)) {
1532                         ClearPageActive(page);
1533                         list_move(&page->lru, &clean_pages);
1534                 }
1535         }
1536
1537         ret = shrink_page_list(&clean_pages, zone->zone_pgdat, &sc,
1538                         TTU_IGNORE_ACCESS, NULL, true);
1539         list_splice(&clean_pages, page_list);
1540         mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_FILE, -ret);
1541         return ret;
1542 }
1543
1544 /*
1545  * Attempt to remove the specified page from its LRU.  Only take this page
1546  * if it is of the appropriate PageActive status.  Pages which are being
1547  * freed elsewhere are also ignored.
1548  *
1549  * page:        page to consider
1550  * mode:        one of the LRU isolation modes defined above
1551  *
1552  * returns 0 on success, -ve errno on failure.
1553  */
1554 int __isolate_lru_page(struct page *page, isolate_mode_t mode)
1555 {
1556         int ret = -EINVAL;
1557
1558         /* Only take pages on the LRU. */
1559         if (!PageLRU(page))
1560                 return ret;
1561
1562         /* Compaction should not handle unevictable pages but CMA can do so */
1563         if (PageUnevictable(page) && !(mode & ISOLATE_UNEVICTABLE))
1564                 return ret;
1565
1566         ret = -EBUSY;
1567
1568         /*
1569          * To minimise LRU disruption, the caller can indicate that it only
1570          * wants to isolate pages it will be able to operate on without
1571          * blocking - clean pages for the most part.
1572          *
1573          * ISOLATE_ASYNC_MIGRATE is used to indicate that it only wants to pages
1574          * that it is possible to migrate without blocking
1575          */
1576         if (mode & ISOLATE_ASYNC_MIGRATE) {
1577                 /* All the caller can do on PageWriteback is block */
1578                 if (PageWriteback(page))
1579                         return ret;
1580
1581                 if (PageDirty(page)) {
1582                         struct address_space *mapping;
1583                         bool migrate_dirty;
1584
1585                         /*
1586                          * Only pages without mappings or that have a
1587                          * ->migratepage callback are possible to migrate
1588                          * without blocking. However, we can be racing with
1589                          * truncation so it's necessary to lock the page
1590                          * to stabilise the mapping as truncation holds
1591                          * the page lock until after the page is removed
1592                          * from the page cache.
1593                          */
1594                         if (!trylock_page(page))
1595                                 return ret;
1596
1597                         mapping = page_mapping(page);
1598                         migrate_dirty = !mapping || mapping->a_ops->migratepage;
1599                         unlock_page(page);
1600                         if (!migrate_dirty)
1601                                 return ret;
1602                 }
1603         }
1604
1605         if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
1606                 return ret;
1607
1608         if (likely(get_page_unless_zero(page))) {
1609                 /*
1610                  * Be careful not to clear PageLRU until after we're
1611                  * sure the page is not being freed elsewhere -- the
1612                  * page release code relies on it.
1613                  */
1614                 ClearPageLRU(page);
1615                 ret = 0;
1616         }
1617
1618         return ret;
1619 }
1620
1621
1622 /*
1623  * Update LRU sizes after isolating pages. The LRU size updates must
1624  * be complete before mem_cgroup_update_lru_size due to a santity check.
1625  */
1626 static __always_inline void update_lru_sizes(struct lruvec *lruvec,
1627                         enum lru_list lru, unsigned long *nr_zone_taken)
1628 {
1629         int zid;
1630
1631         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1632                 if (!nr_zone_taken[zid])
1633                         continue;
1634
1635                 __update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
1636 #ifdef CONFIG_MEMCG
1637                 mem_cgroup_update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
1638 #endif
1639         }
1640
1641 }
1642
1643 /*
1644  * zone_lru_lock is heavily contended.  Some of the functions that
1645  * shrink the lists perform better by taking out a batch of pages
1646  * and working on them outside the LRU lock.
1647  *
1648  * For pagecache intensive workloads, this function is the hottest
1649  * spot in the kernel (apart from copy_*_user functions).
1650  *
1651  * Appropriate locks must be held before calling this function.
1652  *
1653  * @nr_to_scan: The number of eligible pages to look through on the list.
1654  * @lruvec:     The LRU vector to pull pages from.
1655  * @dst:        The temp list to put pages on to.
1656  * @nr_scanned: The number of pages that were scanned.
1657  * @sc:         The scan_control struct for this reclaim session
1658  * @mode:       One of the LRU isolation modes
1659  * @lru:        LRU list id for isolating
1660  *
1661  * returns how many pages were moved onto *@dst.
1662  */
1663 static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
1664                 struct lruvec *lruvec, struct list_head *dst,
1665                 unsigned long *nr_scanned, struct scan_control *sc,
1666                 isolate_mode_t mode, enum lru_list lru)
1667 {
1668         struct list_head *src = &lruvec->lists[lru];
1669         unsigned long nr_taken = 0;
1670         unsigned long nr_zone_taken[MAX_NR_ZONES] = { 0 };
1671         unsigned long nr_skipped[MAX_NR_ZONES] = { 0, };
1672         unsigned long skipped = 0;
1673         unsigned long scan, total_scan, nr_pages;
1674         LIST_HEAD(pages_skipped);
1675
1676         scan = 0;
1677         for (total_scan = 0;
1678              scan < nr_to_scan && nr_taken < nr_to_scan && !list_empty(src);
1679              total_scan++) {
1680                 struct page *page;
1681
1682                 page = lru_to_page(src);
1683                 prefetchw_prev_lru_page(page, src, flags);
1684
1685                 VM_BUG_ON_PAGE(!PageLRU(page), page);
1686
1687                 if (page_zonenum(page) > sc->reclaim_idx) {
1688                         list_move(&page->lru, &pages_skipped);
1689                         nr_skipped[page_zonenum(page)]++;
1690                         continue;
1691                 }
1692
1693                 /*
1694                  * Do not count skipped pages because that makes the function
1695                  * return with no isolated pages if the LRU mostly contains
1696                  * ineligible pages.  This causes the VM to not reclaim any
1697                  * pages, triggering a premature OOM.
1698                  */
1699                 scan++;
1700                 switch (__isolate_lru_page(page, mode)) {
1701                 case 0:
1702                         nr_pages = hpage_nr_pages(page);
1703                         nr_taken += nr_pages;
1704                         nr_zone_taken[page_zonenum(page)] += nr_pages;
1705                         list_move(&page->lru, dst);
1706                         break;
1707
1708                 case -EBUSY:
1709                         /* else it is being freed elsewhere */
1710                         list_move(&page->lru, src);
1711                         continue;
1712
1713                 default:
1714                         BUG();
1715                 }
1716         }
1717
1718         /*
1719          * Splice any skipped pages to the start of the LRU list. Note that
1720          * this disrupts the LRU order when reclaiming for lower zones but
1721          * we cannot splice to the tail. If we did then the SWAP_CLUSTER_MAX
1722          * scanning would soon rescan the same pages to skip and put the
1723          * system at risk of premature OOM.
1724          */
1725         if (!list_empty(&pages_skipped)) {
1726                 int zid;
1727
1728                 list_splice(&pages_skipped, src);
1729                 for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1730                         if (!nr_skipped[zid])
1731                                 continue;
1732
1733                         __count_zid_vm_events(PGSCAN_SKIP, zid, nr_skipped[zid]);
1734                         skipped += nr_skipped[zid];
1735                 }
1736         }
1737         *nr_scanned = total_scan;
1738         trace_mm_vmscan_lru_isolate(sc->reclaim_idx, sc->order, nr_to_scan,
1739                                     total_scan, skipped, nr_taken, mode, lru);
1740         update_lru_sizes(lruvec, lru, nr_zone_taken);
1741         return nr_taken;
1742 }
1743
1744 /**
1745  * isolate_lru_page - tries to isolate a page from its LRU list
1746  * @page: page to isolate from its LRU list
1747  *
1748  * Isolates a @page from an LRU list, clears PageLRU and adjusts the
1749  * vmstat statistic corresponding to whatever LRU list the page was on.
1750  *
1751  * Returns 0 if the page was removed from an LRU list.
1752  * Returns -EBUSY if the page was not on an LRU list.
1753  *
1754  * The returned page will have PageLRU() cleared.  If it was found on
1755  * the active list, it will have PageActive set.  If it was found on
1756  * the unevictable list, it will have the PageUnevictable bit set. That flag
1757  * may need to be cleared by the caller before letting the page go.
1758  *
1759  * The vmstat statistic corresponding to the list on which the page was
1760  * found will be decremented.
1761  *
1762  * Restrictions:
1763  *
1764  * (1) Must be called with an elevated refcount on the page. This is a
1765  *     fundamentnal difference from isolate_lru_pages (which is called
1766  *     without a stable reference).
1767  * (2) the lru_lock must not be held.
1768  * (3) interrupts must be enabled.
1769  */
1770 int isolate_lru_page(struct page *page)
1771 {
1772         int ret = -EBUSY;
1773
1774         VM_BUG_ON_PAGE(!page_count(page), page);
1775         WARN_RATELIMIT(PageTail(page), "trying to isolate tail page");
1776
1777         if (PageLRU(page)) {
1778                 struct zone *zone = page_zone(page);
1779                 struct lruvec *lruvec;
1780
1781                 spin_lock_irq(zone_lru_lock(zone));
1782                 lruvec = mem_cgroup_page_lruvec(page, zone->zone_pgdat);
1783                 if (PageLRU(page)) {
1784                         int lru = page_lru(page);
1785                         get_page(page);
1786                         ClearPageLRU(page);
1787                         del_page_from_lru_list(page, lruvec, lru);
1788                         ret = 0;
1789                 }
1790                 spin_unlock_irq(zone_lru_lock(zone));
1791         }
1792         return ret;
1793 }
1794
1795 /*
1796  * A direct reclaimer may isolate SWAP_CLUSTER_MAX pages from the LRU list and
1797  * then get resheduled. When there are massive number of tasks doing page
1798  * allocation, such sleeping direct reclaimers may keep piling up on each CPU,
1799  * the LRU list will go small and be scanned faster than necessary, leading to
1800  * unnecessary swapping, thrashing and OOM.
1801  */
1802 static int too_many_isolated(struct pglist_data *pgdat, int file,
1803                 struct scan_control *sc)
1804 {
1805         unsigned long inactive, isolated;
1806
1807         if (current_is_kswapd())
1808                 return 0;
1809
1810         if (!sane_reclaim(sc))
1811                 return 0;
1812
1813         if (file) {
1814                 inactive = node_page_state(pgdat, NR_INACTIVE_FILE);
1815                 isolated = node_page_state(pgdat, NR_ISOLATED_FILE);
1816         } else {
1817                 inactive = node_page_state(pgdat, NR_INACTIVE_ANON);
1818                 isolated = node_page_state(pgdat, NR_ISOLATED_ANON);
1819         }
1820
1821         /*
1822          * GFP_NOIO/GFP_NOFS callers are allowed to isolate more pages, so they
1823          * won't get blocked by normal direct-reclaimers, forming a circular
1824          * deadlock.
1825          */
1826         if ((sc->gfp_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
1827                 inactive >>= 3;
1828
1829         return isolated > inactive;
1830 }
1831
1832 static noinline_for_stack void
1833 putback_inactive_pages(struct lruvec *lruvec, struct list_head *page_list)
1834 {
1835         struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1836         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1837         LIST_HEAD(pages_to_free);
1838
1839         /*
1840          * Put back any unfreeable pages.
1841          */
1842         while (!list_empty(page_list)) {
1843                 struct page *page = lru_to_page(page_list);
1844                 int lru;
1845
1846                 VM_BUG_ON_PAGE(PageLRU(page), page);
1847                 list_del(&page->lru);
1848                 if (unlikely(!page_evictable(page))) {
1849                         spin_unlock_irq(&pgdat->lru_lock);
1850                         putback_lru_page(page);
1851                         spin_lock_irq(&pgdat->lru_lock);
1852                         continue;
1853                 }
1854
1855                 lruvec = mem_cgroup_page_lruvec(page, pgdat);
1856
1857                 SetPageLRU(page);
1858                 lru = page_lru(page);
1859                 add_page_to_lru_list(page, lruvec, lru);
1860
1861                 if (is_active_lru(lru)) {
1862                         int file = is_file_lru(lru);
1863                         int numpages = hpage_nr_pages(page);
1864                         reclaim_stat->recent_rotated[file] += numpages;
1865                 }
1866                 if (put_page_testzero(page)) {
1867                         __ClearPageLRU(page);
1868                         __ClearPageActive(page);
1869                         del_page_from_lru_list(page, lruvec, lru);
1870
1871                         if (unlikely(PageCompound(page))) {
1872                                 spin_unlock_irq(&pgdat->lru_lock);
1873                                 mem_cgroup_uncharge(page);
1874                                 (*get_compound_page_dtor(page))(page);
1875                                 spin_lock_irq(&pgdat->lru_lock);
1876                         } else
1877                                 list_add(&page->lru, &pages_to_free);
1878                 }
1879         }
1880
1881         /*
1882          * To save our caller's stack, now use input list for pages to free.
1883          */
1884         list_splice(&pages_to_free, page_list);
1885 }
1886
1887 /*
1888  * If a kernel thread (such as nfsd for loop-back mounts) services
1889  * a backing device by writing to the page cache it sets PF_LESS_THROTTLE.
1890  * In that case we should only throttle if the backing device it is
1891  * writing to is congested.  In other cases it is safe to throttle.
1892  */
1893 static int current_may_throttle(void)
1894 {
1895         return !(current->flags & PF_LESS_THROTTLE) ||
1896                 current->backing_dev_info == NULL ||
1897                 bdi_write_congested(current->backing_dev_info);
1898 }
1899
1900 /*
1901  * shrink_inactive_list() is a helper for shrink_node().  It returns the number
1902  * of reclaimed pages
1903  */
1904 static noinline_for_stack unsigned long
1905 shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
1906                      struct scan_control *sc, enum lru_list lru)
1907 {
1908         LIST_HEAD(page_list);
1909         unsigned long nr_scanned;
1910         unsigned long nr_reclaimed = 0;
1911         unsigned long nr_taken;
1912         struct reclaim_stat stat = {};
1913         isolate_mode_t isolate_mode = 0;
1914         int file = is_file_lru(lru);
1915         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1916         struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1917         bool stalled = false;
1918
1919         while (unlikely(too_many_isolated(pgdat, file, sc))) {
1920                 if (stalled)
1921                         return 0;
1922
1923                 /* wait a bit for the reclaimer. */
1924                 msleep(100);
1925                 stalled = true;
1926
1927                 /* We are about to die and free our memory. Return now. */
1928                 if (fatal_signal_pending(current))
1929                         return SWAP_CLUSTER_MAX;
1930         }
1931
1932         lru_add_drain();
1933
1934         if (!sc->may_unmap)
1935                 isolate_mode |= ISOLATE_UNMAPPED;
1936
1937         spin_lock_irq(&pgdat->lru_lock);
1938
1939         nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &page_list,
1940                                      &nr_scanned, sc, isolate_mode, lru);
1941
1942         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1943         reclaim_stat->recent_scanned[file] += nr_taken;
1944
1945         if (current_is_kswapd()) {
1946                 if (global_reclaim(sc))
1947                         __count_vm_events(PGSCAN_KSWAPD, nr_scanned);
1948                 count_memcg_events(lruvec_memcg(lruvec), PGSCAN_KSWAPD,
1949                                    nr_scanned);
1950         } else {
1951                 if (global_reclaim(sc))
1952                         __count_vm_events(PGSCAN_DIRECT, nr_scanned);
1953                 count_memcg_events(lruvec_memcg(lruvec), PGSCAN_DIRECT,
1954                                    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         if (current_is_kswapd()) {
1967                 if (global_reclaim(sc))
1968                         __count_vm_events(PGSTEAL_KSWAPD, nr_reclaimed);
1969                 count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_KSWAPD,
1970                                    nr_reclaimed);
1971         } else {
1972                 if (global_reclaim(sc))
1973                         __count_vm_events(PGSTEAL_DIRECT, nr_reclaimed);
1974                 count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_DIRECT,
1975                                    nr_reclaimed);
1976         }
1977
1978         putback_inactive_pages(lruvec, &page_list);
1979
1980         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
1981
1982         spin_unlock_irq(&pgdat->lru_lock);
1983
1984         mem_cgroup_uncharge_list(&page_list);
1985         free_unref_page_list(&page_list);
1986
1987         /*
1988          * If dirty pages are scanned that are not queued for IO, it
1989          * implies that flushers are not doing their job. This can
1990          * happen when memory pressure pushes dirty pages to the end of
1991          * the LRU before the dirty limits are breached and the dirty
1992          * data has expired. It can also happen when the proportion of
1993          * dirty pages grows not through writes but through memory
1994          * pressure reclaiming all the clean cache. And in some cases,
1995          * the flushers simply cannot keep up with the allocation
1996          * rate. Nudge the flusher threads in case they are asleep.
1997          */
1998         if (stat.nr_unqueued_dirty == nr_taken)
1999                 wakeup_flusher_threads(WB_REASON_VMSCAN);
2000
2001         sc->nr.dirty += stat.nr_dirty;
2002         sc->nr.congested += stat.nr_congested;
2003         sc->nr.unqueued_dirty += stat.nr_unqueued_dirty;
2004         sc->nr.writeback += stat.nr_writeback;
2005         sc->nr.immediate += stat.nr_immediate;
2006         sc->nr.taken += nr_taken;
2007         if (file)
2008                 sc->nr.file_taken += nr_taken;
2009
2010         trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
2011                         nr_scanned, nr_reclaimed, &stat, sc->priority, file);
2012         return nr_reclaimed;
2013 }
2014
2015 /*
2016  * This moves pages from the active list to the inactive list.
2017  *
2018  * We move them the other way if the page is referenced by one or more
2019  * processes, from rmap.
2020  *
2021  * If the pages are mostly unmapped, the processing is fast and it is
2022  * appropriate to hold zone_lru_lock across the whole operation.  But if
2023  * the pages are mapped, the processing is slow (page_referenced()) so we
2024  * should drop zone_lru_lock around each page.  It's impossible to balance
2025  * this, so instead we remove the pages from the LRU while processing them.
2026  * It is safe to rely on PG_active against the non-LRU pages in here because
2027  * nobody will play with that bit on a non-LRU page.
2028  *
2029  * The downside is that we have to touch page->_refcount against each page.
2030  * But we had to alter page->flags anyway.
2031  *
2032  * Returns the number of pages moved to the given lru.
2033  */
2034
2035 static unsigned move_active_pages_to_lru(struct lruvec *lruvec,
2036                                      struct list_head *list,
2037                                      struct list_head *pages_to_free,
2038                                      enum lru_list lru)
2039 {
2040         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2041         struct page *page;
2042         int nr_pages;
2043         int nr_moved = 0;
2044
2045         while (!list_empty(list)) {
2046                 page = lru_to_page(list);
2047                 lruvec = mem_cgroup_page_lruvec(page, pgdat);
2048
2049                 VM_BUG_ON_PAGE(PageLRU(page), page);
2050                 SetPageLRU(page);
2051
2052                 nr_pages = hpage_nr_pages(page);
2053                 update_lru_size(lruvec, lru, page_zonenum(page), nr_pages);
2054                 list_move(&page->lru, &lruvec->lists[lru]);
2055
2056                 if (put_page_testzero(page)) {
2057                         __ClearPageLRU(page);
2058                         __ClearPageActive(page);
2059                         del_page_from_lru_list(page, lruvec, lru);
2060
2061                         if (unlikely(PageCompound(page))) {
2062                                 spin_unlock_irq(&pgdat->lru_lock);
2063                                 mem_cgroup_uncharge(page);
2064                                 (*get_compound_page_dtor(page))(page);
2065                                 spin_lock_irq(&pgdat->lru_lock);
2066                         } else
2067                                 list_add(&page->lru, pages_to_free);
2068                 } else {
2069                         nr_moved += nr_pages;
2070                 }
2071         }
2072
2073         if (!is_active_lru(lru)) {
2074                 __count_vm_events(PGDEACTIVATE, nr_moved);
2075                 count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE,
2076                                    nr_moved);
2077         }
2078
2079         return nr_moved;
2080 }
2081
2082 static void shrink_active_list(unsigned long nr_to_scan,
2083                                struct lruvec *lruvec,
2084                                struct scan_control *sc,
2085                                enum lru_list lru)
2086 {
2087         unsigned long nr_taken;
2088         unsigned long nr_scanned;
2089         unsigned long vm_flags;
2090         LIST_HEAD(l_hold);      /* The pages which were snipped off */
2091         LIST_HEAD(l_active);
2092         LIST_HEAD(l_inactive);
2093         struct page *page;
2094         struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
2095         unsigned nr_deactivate, nr_activate;
2096         unsigned nr_rotated = 0;
2097         isolate_mode_t isolate_mode = 0;
2098         int file = is_file_lru(lru);
2099         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2100
2101         lru_add_drain();
2102
2103         if (!sc->may_unmap)
2104                 isolate_mode |= ISOLATE_UNMAPPED;
2105
2106         spin_lock_irq(&pgdat->lru_lock);
2107
2108         nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &l_hold,
2109                                      &nr_scanned, sc, isolate_mode, lru);
2110
2111         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
2112         reclaim_stat->recent_scanned[file] += nr_taken;
2113
2114         __count_vm_events(PGREFILL, nr_scanned);
2115         count_memcg_events(lruvec_memcg(lruvec), PGREFILL, nr_scanned);
2116
2117         spin_unlock_irq(&pgdat->lru_lock);
2118
2119         while (!list_empty(&l_hold)) {
2120                 cond_resched();
2121                 page = lru_to_page(&l_hold);
2122                 list_del(&page->lru);
2123
2124                 if (unlikely(!page_evictable(page))) {
2125                         putback_lru_page(page);
2126                         continue;
2127                 }
2128
2129                 if (unlikely(buffer_heads_over_limit)) {
2130                         if (page_has_private(page) && trylock_page(page)) {
2131                                 if (page_has_private(page))
2132                                         try_to_release_page(page, 0);
2133                                 unlock_page(page);
2134                         }
2135                 }
2136
2137                 if (page_referenced(page, 0, sc->target_mem_cgroup,
2138                                     &vm_flags)) {
2139                         nr_rotated += hpage_nr_pages(page);
2140                         /*
2141                          * Identify referenced, file-backed active pages and
2142                          * give them one more trip around the active list. So
2143                          * that executable code get better chances to stay in
2144                          * memory under moderate memory pressure.  Anon pages
2145                          * are not likely to be evicted by use-once streaming
2146                          * IO, plus JVM can create lots of anon VM_EXEC pages,
2147                          * so we ignore them here.
2148                          */
2149                         if ((vm_flags & VM_EXEC) && page_is_file_cache(page)) {
2150                                 list_add(&page->lru, &l_active);
2151                                 continue;
2152                         }
2153                 }
2154
2155                 ClearPageActive(page);  /* we are de-activating */
2156                 SetPageWorkingset(page);
2157                 list_add(&page->lru, &l_inactive);
2158         }
2159
2160         /*
2161          * Move pages back to the lru list.
2162          */
2163         spin_lock_irq(&pgdat->lru_lock);
2164         /*
2165          * Count referenced pages from currently used mappings as rotated,
2166          * even though only some of them are actually re-activated.  This
2167          * helps balance scan pressure between file and anonymous pages in
2168          * get_scan_count.
2169          */
2170         reclaim_stat->recent_rotated[file] += nr_rotated;
2171
2172         nr_activate = move_active_pages_to_lru(lruvec, &l_active, &l_hold, lru);
2173         nr_deactivate = move_active_pages_to_lru(lruvec, &l_inactive, &l_hold, lru - LRU_ACTIVE);
2174         __mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
2175         spin_unlock_irq(&pgdat->lru_lock);
2176
2177         mem_cgroup_uncharge_list(&l_hold);
2178         free_unref_page_list(&l_hold);
2179         trace_mm_vmscan_lru_shrink_active(pgdat->node_id, nr_taken, nr_activate,
2180                         nr_deactivate, nr_rotated, sc->priority, file);
2181 }
2182
2183 /*
2184  * The inactive anon list should be small enough that the VM never has
2185  * to do too much work.
2186  *
2187  * The inactive file list should be small enough to leave most memory
2188  * to the established workingset on the scan-resistant active list,
2189  * but large enough to avoid thrashing the aggregate readahead window.
2190  *
2191  * Both inactive lists should also be large enough that each inactive
2192  * page has a chance to be referenced again before it is reclaimed.
2193  *
2194  * If that fails and refaulting is observed, the inactive list grows.
2195  *
2196  * The inactive_ratio is the target ratio of ACTIVE to INACTIVE pages
2197  * on this LRU, maintained by the pageout code. An inactive_ratio
2198  * of 3 means 3:1 or 25% of the pages are kept on the inactive list.
2199  *
2200  * total     target    max
2201  * memory    ratio     inactive
2202  * -------------------------------------
2203  *   10MB       1         5MB
2204  *  100MB       1        50MB
2205  *    1GB       3       250MB
2206  *   10GB      10       0.9GB
2207  *  100GB      31         3GB
2208  *    1TB     101        10GB
2209  *   10TB     320        32GB
2210  */
2211 static bool inactive_list_is_low(struct lruvec *lruvec, bool file,
2212                                  struct mem_cgroup *memcg,
2213                                  struct scan_control *sc, bool actual_reclaim)
2214 {
2215         enum lru_list active_lru = file * LRU_FILE + LRU_ACTIVE;
2216         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2217         enum lru_list inactive_lru = file * LRU_FILE;
2218         unsigned long inactive, active;
2219         unsigned long inactive_ratio;
2220         unsigned long refaults;
2221         unsigned long gb;
2222
2223         /*
2224          * If we don't have swap space, anonymous page deactivation
2225          * is pointless.
2226          */
2227         if (!file && !total_swap_pages)
2228                 return false;
2229
2230         inactive = lruvec_lru_size(lruvec, inactive_lru, sc->reclaim_idx);
2231         active = lruvec_lru_size(lruvec, active_lru, sc->reclaim_idx);
2232
2233         if (memcg)
2234                 refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
2235         else
2236                 refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);
2237
2238         /*
2239          * When refaults are being observed, it means a new workingset
2240          * is being established. Disable active list protection to get
2241          * rid of the stale workingset quickly.
2242          */
2243         if (file && actual_reclaim && lruvec->refaults != refaults) {
2244                 inactive_ratio = 0;
2245         } else {
2246                 gb = (inactive + active) >> (30 - PAGE_SHIFT);
2247                 if (gb)
2248                         inactive_ratio = int_sqrt(10 * gb);
2249                 else
2250                         inactive_ratio = 1;
2251         }
2252
2253         if (actual_reclaim)
2254                 trace_mm_vmscan_inactive_list_is_low(pgdat->node_id, sc->reclaim_idx,
2255                         lruvec_lru_size(lruvec, inactive_lru, MAX_NR_ZONES), inactive,
2256                         lruvec_lru_size(lruvec, active_lru, MAX_NR_ZONES), active,
2257                         inactive_ratio, file);
2258
2259         return inactive * inactive_ratio < active;
2260 }
2261
2262 static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
2263                                  struct lruvec *lruvec, struct mem_cgroup *memcg,
2264                                  struct scan_control *sc)
2265 {
2266         if (is_active_lru(lru)) {
2267                 if (inactive_list_is_low(lruvec, is_file_lru(lru),
2268                                          memcg, sc, true))
2269                         shrink_active_list(nr_to_scan, lruvec, sc, lru);
2270                 return 0;
2271         }
2272
2273         return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);
2274 }
2275
2276 enum scan_balance {
2277         SCAN_EQUAL,
2278         SCAN_FRACT,
2279         SCAN_ANON,
2280         SCAN_FILE,
2281 };
2282
2283 /*
2284  * Determine how aggressively the anon and file LRU lists should be
2285  * scanned.  The relative value of each set of LRU lists is determined
2286  * by looking at the fraction of the pages scanned we did rotate back
2287  * onto the active list instead of evict.
2288  *
2289  * nr[0] = anon inactive pages to scan; nr[1] = anon active pages to scan
2290  * nr[2] = file inactive pages to scan; nr[3] = file active pages to scan
2291  */
2292 static void get_scan_count(struct lruvec *lruvec, struct mem_cgroup *memcg,
2293                            struct scan_control *sc, unsigned long *nr,
2294                            unsigned long *lru_pages)
2295 {
2296         int swappiness = mem_cgroup_swappiness(memcg);
2297         struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
2298         u64 fraction[2];
2299         u64 denominator = 0;    /* gcc */
2300         struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2301         unsigned long anon_prio, file_prio;
2302         enum scan_balance scan_balance;
2303         unsigned long anon, file;
2304         unsigned long ap, fp;
2305         enum lru_list lru;
2306
2307         /* If we have no swap space, do not bother scanning anon pages. */
2308         if (!sc->may_swap || mem_cgroup_get_nr_swap_pages(memcg) <= 0) {
2309                 scan_balance = SCAN_FILE;
2310                 goto out;
2311         }
2312
2313         /*
2314          * Global reclaim will swap to prevent OOM even with no
2315          * swappiness, but memcg users want to use this knob to
2316          * disable swapping for individual groups completely when
2317          * using the memory controller's swap limit feature would be
2318          * too expensive.
2319          */
2320         if (!global_reclaim(sc) && !swappiness) {
2321                 scan_balance = SCAN_FILE;
2322                 goto out;
2323         }
2324
2325         /*
2326          * Do not apply any pressure balancing cleverness when the
2327          * system is close to OOM, scan both anon and file equally
2328          * (unless the swappiness setting disagrees with swapping).
2329          */
2330         if (!sc->priority && swappiness) {
2331                 scan_balance = SCAN_EQUAL;
2332                 goto out;
2333         }
2334
2335         /*
2336          * Prevent the reclaimer from falling into the cache trap: as
2337          * cache pages start out inactive, every cache fault will tip
2338          * the scan balance towards the file LRU.  And as the file LRU
2339          * shrinks, so does the window for rotation from references.
2340          * This means we have a runaway feedback loop where a tiny
2341          * thrashing file LRU becomes infinitely more attractive than
2342          * anon pages.  Try to detect this based on file LRU size.
2343          */
2344         if (global_reclaim(sc)) {
2345                 unsigned long pgdatfile;
2346                 unsigned long pgdatfree;
2347                 int z;
2348                 unsigned long total_high_wmark = 0;
2349
2350                 pgdatfree = sum_zone_node_page_state(pgdat->node_id, NR_FREE_PAGES);
2351                 pgdatfile = node_page_state(pgdat, NR_ACTIVE_FILE) +
2352                            node_page_state(pgdat, NR_INACTIVE_FILE);
2353
2354                 for (z = 0; z < MAX_NR_ZONES; z++) {
2355                         struct zone *zone = &pgdat->node_zones[z];
2356                         if (!managed_zone(zone))
2357                                 continue;
2358
2359                         total_high_wmark += high_wmark_pages(zone);
2360                 }
2361
2362                 if (unlikely(pgdatfile + pgdatfree <= total_high_wmark)) {
2363                         /*
2364                          * Force SCAN_ANON if there are enough inactive
2365                          * anonymous pages on the LRU in eligible zones.
2366                          * Otherwise, the small LRU gets thrashed.
2367                          */
2368                         if (!inactive_list_is_low(lruvec, false, memcg, sc, false) &&
2369                             lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, sc->reclaim_idx)
2370                                         >> sc->priority) {
2371                                 scan_balance = SCAN_ANON;
2372                                 goto out;
2373                         }
2374                 }
2375         }
2376
2377         /*
2378          * If there is enough inactive page cache, i.e. if the size of the
2379          * inactive list is greater than that of the active list *and* the
2380          * inactive list actually has some pages to scan on this priority, we
2381          * do not reclaim anything from the anonymous working set right now.
2382          * Without the second condition we could end up never scanning an
2383          * lruvec even if it has plenty of old anonymous pages unless the
2384          * system is under heavy pressure.
2385          */
2386         if (!inactive_list_is_low(lruvec, true, memcg, sc, false) &&
2387             lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
2388                 scan_balance = SCAN_FILE;
2389                 goto out;
2390         }
2391
2392         scan_balance = SCAN_FRACT;
2393
2394         /*
2395          * With swappiness at 100, anonymous and file have the same priority.
2396          * This scanning priority is essentially the inverse of IO cost.
2397          */
2398         anon_prio = swappiness;
2399         file_prio = 200 - anon_prio;
2400
2401         /*
2402          * OK, so we have swap space and a fair amount of page cache
2403          * pages.  We use the recently rotated / recently scanned
2404          * ratios to determine how valuable each cache is.
2405          *
2406          * Because workloads change over time (and to avoid overflow)
2407          * we keep these statistics as a floating average, which ends
2408          * up weighing recent references more than old ones.
2409          *
2410          * anon in [0], file in [1]
2411          */
2412
2413         anon  = lruvec_lru_size(lruvec, LRU_ACTIVE_ANON, MAX_NR_ZONES) +
2414                 lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, MAX_NR_ZONES);
2415         file  = lruvec_lru_size(lruvec, LRU_ACTIVE_FILE, MAX_NR_ZONES) +
2416                 lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, MAX_NR_ZONES);
2417
2418         spin_lock_irq(&pgdat->lru_lock);
2419         if (unlikely(reclaim_stat->recent_scanned[0] > anon / 4)) {
2420                 reclaim_stat->recent_scanned[0] /= 2;
2421                 reclaim_stat->recent_rotated[0] /= 2;
2422         }
2423
2424         if (unlikely(reclaim_stat->recent_scanned[1] > file / 4)) {
2425                 reclaim_stat->recent_scanned[1] /= 2;
2426                 reclaim_stat->recent_rotated[1] /= 2;
2427         }
2428
2429         /*
2430          * The amount of pressure on anon vs file pages is inversely
2431          * proportional to the fraction of recently scanned pages on
2432          * each list that were recently referenced and in active use.
2433          */
2434         ap = anon_prio * (reclaim_stat->recent_scanned[0] + 1);
2435         ap /= reclaim_stat->recent_rotated[0] + 1;
2436
2437         fp = file_prio * (reclaim_stat->recent_scanned[1] + 1);
2438         fp /= reclaim_stat->recent_rotated[1] + 1;
2439         spin_unlock_irq(&pgdat->lru_lock);
2440
2441         fraction[0] = ap;
2442         fraction[1] = fp;
2443         denominator = ap + fp + 1;
2444 out:
2445         *lru_pages = 0;
2446         for_each_evictable_lru(lru) {
2447                 int file = is_file_lru(lru);
2448                 unsigned long size;
2449                 unsigned long scan;
2450
2451                 size = lruvec_lru_size(lruvec, lru, sc->reclaim_idx);
2452                 scan = size >> sc->priority;
2453                 /*
2454                  * If the cgroup's already been deleted, make sure to
2455                  * scrape out the remaining cache.
2456                  */
2457                 if (!scan && !mem_cgroup_online(memcg))
2458                         scan = min(size, SWAP_CLUSTER_MAX);
2459
2460                 switch (scan_balance) {
2461                 case SCAN_EQUAL:
2462                         /* Scan lists relative to size */
2463                         break;
2464                 case SCAN_FRACT:
2465                         /*
2466                          * Scan types proportional to swappiness and
2467                          * their relative recent reclaim efficiency.
2468                          * Make sure we don't miss the last page
2469                          * because of a round-off error.
2470                          */
2471                         scan = DIV64_U64_ROUND_UP(scan * fraction[file],
2472                                                   denominator);
2473                         break;
2474                 case SCAN_FILE:
2475                 case SCAN_ANON:
2476                         /* Scan one type exclusively */
2477                         if ((scan_balance == SCAN_FILE) != file) {
2478                                 size = 0;
2479                                 scan = 0;
2480                         }
2481                         break;
2482                 default:
2483                         /* Look ma, no brain */
2484                         BUG();
2485                 }
2486
2487                 *lru_pages += size;
2488                 nr[lru] = scan;
2489         }
2490 }
2491
2492 /*
2493  * This is a basic per-node page freer.  Used by both kswapd and direct reclaim.
2494  */
2495 static void shrink_node_memcg(struct pglist_data *pgdat, struct mem_cgroup *memcg,
2496                               struct scan_control *sc, unsigned long *lru_pages)
2497 {
2498         struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
2499         unsigned long nr[NR_LRU_LISTS];
2500         unsigned long targets[NR_LRU_LISTS];
2501         unsigned long nr_to_scan;
2502         enum lru_list lru;
2503         unsigned long nr_reclaimed = 0;
2504         unsigned long nr_to_reclaim = sc->nr_to_reclaim;
2505         struct blk_plug plug;
2506         bool scan_adjusted;
2507
2508         get_scan_count(lruvec, memcg, sc, nr, lru_pages);
2509
2510         /* Record the original scan target for proportional adjustments later */
2511         memcpy(targets, nr, sizeof(nr));
2512
2513         /*
2514          * Global reclaiming within direct reclaim at DEF_PRIORITY is a normal
2515          * event that can occur when there is little memory pressure e.g.
2516          * multiple streaming readers/writers. Hence, we do not abort scanning
2517          * when the requested number of pages are reclaimed when scanning at
2518          * DEF_PRIORITY on the assumption that the fact we are direct
2519          * reclaiming implies that kswapd is not keeping up and it is best to
2520          * do a batch of work at once. For memcg reclaim one check is made to
2521          * abort proportional reclaim if either the file or anon lru has already
2522          * dropped to zero at the first pass.
2523          */
2524         scan_adjusted = (global_reclaim(sc) && !current_is_kswapd() &&
2525                          sc->priority == DEF_PRIORITY);
2526
2527         blk_start_plug(&plug);
2528         while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
2529                                         nr[LRU_INACTIVE_FILE]) {
2530                 unsigned long nr_anon, nr_file, percentage;
2531                 unsigned long nr_scanned;
2532
2533                 for_each_evictable_lru(lru) {
2534                         if (nr[lru]) {
2535                                 nr_to_scan = min(nr[lru], SWAP_CLUSTER_MAX);
2536                                 nr[lru] -= nr_to_scan;
2537
2538                                 nr_reclaimed += shrink_list(lru, nr_to_scan,
2539                                                             lruvec, memcg, sc);
2540                         }
2541                 }
2542
2543                 cond_resched();
2544
2545                 if (nr_reclaimed < nr_to_reclaim || scan_adjusted)
2546                         continue;
2547
2548                 /*
2549                  * For kswapd and memcg, reclaim at least the number of pages
2550                  * requested. Ensure that the anon and file LRUs are scanned
2551                  * proportionally what was requested by get_scan_count(). We
2552                  * stop reclaiming one LRU and reduce the amount scanning
2553                  * proportional to the original scan target.
2554                  */
2555                 nr_file = nr[LRU_INACTIVE_FILE] + nr[LRU_ACTIVE_FILE];
2556                 nr_anon = nr[LRU_INACTIVE_ANON] + nr[LRU_ACTIVE_ANON];
2557
2558                 /*
2559                  * It's just vindictive to attack the larger once the smaller
2560                  * has gone to zero.  And given the way we stop scanning the
2561                  * smaller below, this makes sure that we only make one nudge
2562                  * towards proportionality once we've got nr_to_reclaim.
2563                  */
2564                 if (!nr_file || !nr_anon)
2565                         break;
2566
2567                 if (nr_file > nr_anon) {
2568                         unsigned long scan_target = targets[LRU_INACTIVE_ANON] +
2569                                                 targets[LRU_ACTIVE_ANON] + 1;
2570                         lru = LRU_BASE;
2571                         percentage = nr_anon * 100 / scan_target;
2572                 } else {
2573                         unsigned long scan_target = targets[LRU_INACTIVE_FILE] +
2574                                                 targets[LRU_ACTIVE_FILE] + 1;
2575                         lru = LRU_FILE;
2576                         percentage = nr_file * 100 / scan_target;
2577                 }
2578
2579                 /* Stop scanning the smaller of the LRU */
2580                 nr[lru] = 0;
2581                 nr[lru + LRU_ACTIVE] = 0;
2582
2583                 /*
2584                  * Recalculate the other LRU scan count based on its original
2585                  * scan target and the percentage scanning already complete
2586                  */
2587                 lru = (lru == LRU_FILE) ? LRU_BASE : LRU_FILE;
2588                 nr_scanned = targets[lru] - nr[lru];
2589                 nr[lru] = targets[lru] * (100 - percentage) / 100;
2590                 nr[lru] -= min(nr[lru], nr_scanned);
2591
2592                 lru += LRU_ACTIVE;
2593                 nr_scanned = targets[lru] - nr[lru];
2594                 nr[lru] = targets[lru] * (100 - percentage) / 100;
2595                 nr[lru] -= min(nr[lru], nr_scanned);
2596
2597                 scan_adjusted = true;
2598         }
2599         blk_finish_plug(&plug);
2600         sc->nr_reclaimed += nr_reclaimed;
2601
2602         /*
2603          * Even if we did not try to evict anon pages at all, we want to
2604          * rebalance the anon lru active/inactive ratio.
2605          */
2606         if (inactive_list_is_low(lruvec, false, memcg, sc, true))
2607                 shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
2608                                    sc, LRU_ACTIVE_ANON);
2609 }
2610
2611 /* Use reclaim/compaction for costly allocs or under memory pressure */
2612 static bool in_reclaim_compaction(struct scan_control *sc)
2613 {
2614         if (IS_ENABLED(CONFIG_COMPACTION) && sc->order &&
2615                         (sc->order > PAGE_ALLOC_COSTLY_ORDER ||
2616                          sc->priority < DEF_PRIORITY - 2))
2617                 return true;
2618
2619         return false;
2620 }
2621
2622 /*
2623  * Reclaim/compaction is used for high-order allocation requests. It reclaims
2624  * order-0 pages before compacting the zone. should_continue_reclaim() returns
2625  * true if more pages should be reclaimed such that when the page allocator
2626  * calls try_to_compact_zone() that it will have enough free pages to succeed.
2627  * It will give up earlier than that if there is difficulty reclaiming pages.
2628  */
2629 static inline bool should_continue_reclaim(struct pglist_data *pgdat,
2630                                         unsigned long nr_reclaimed,
2631                                         unsigned long nr_scanned,
2632                                         struct scan_control *sc)
2633 {
2634         unsigned long pages_for_compaction;
2635         unsigned long inactive_lru_pages;
2636         int z;
2637
2638         /* If not in reclaim/compaction mode, stop */
2639         if (!in_reclaim_compaction(sc))
2640                 return false;
2641
2642         /* Consider stopping depending on scan and reclaim activity */
2643         if (sc->gfp_mask & __GFP_RETRY_MAYFAIL) {
2644                 /*
2645                  * For __GFP_RETRY_MAYFAIL allocations, stop reclaiming if the
2646                  * full LRU list has been scanned and we are still failing
2647                  * to reclaim pages. This full LRU scan is potentially
2648                  * expensive but a __GFP_RETRY_MAYFAIL caller really wants to succeed
2649                  */
2650                 if (!nr_reclaimed && !nr_scanned)
2651                         return false;
2652         } else {
2653                 /*
2654                  * For non-__GFP_RETRY_MAYFAIL allocations which can presumably
2655                  * fail without consequence, stop if we failed to reclaim
2656                  * any pages from the last SWAP_CLUSTER_MAX number of
2657                  * pages that were scanned. This will return to the
2658                  * caller faster at the risk reclaim/compaction and
2659                  * the resulting allocation attempt fails
2660                  */
2661                 if (!nr_reclaimed)
2662                         return false;
2663         }
2664
2665         /*
2666          * If we have not reclaimed enough pages for compaction and the
2667          * inactive lists are large enough, continue reclaiming
2668          */
2669         pages_for_compaction = compact_gap(sc->order);
2670         inactive_lru_pages = node_page_state(pgdat, NR_INACTIVE_FILE);
2671         if (get_nr_swap_pages() > 0)
2672                 inactive_lru_pages += node_page_state(pgdat, NR_INACTIVE_ANON);
2673         if (sc->nr_reclaimed < pages_for_compaction &&
2674                         inactive_lru_pages > pages_for_compaction)
2675                 return true;
2676
2677         /* If compaction would go ahead or the allocation would succeed, stop */
2678         for (z = 0; z <= sc->reclaim_idx; z++) {
2679                 struct zone *zone = &pgdat->node_zones[z];
2680                 if (!managed_zone(zone))
2681                         continue;
2682
2683                 switch (compaction_suitable(zone, sc->order, 0, sc->reclaim_idx)) {
2684                 case COMPACT_SUCCESS:
2685                 case COMPACT_CONTINUE:
2686                         return false;
2687                 default:
2688                         /* check next zone */
2689                         ;
2690                 }
2691         }
2692         return true;
2693 }
2694
2695 static bool pgdat_memcg_congested(pg_data_t *pgdat, struct mem_cgroup *memcg)
2696 {
2697         return test_bit(PGDAT_CONGESTED, &pgdat->flags) ||
2698                 (memcg && memcg_congested(pgdat, memcg));
2699 }
2700
2701 static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc)
2702 {
2703         struct reclaim_state *reclaim_state = current->reclaim_state;
2704         unsigned long nr_reclaimed, nr_scanned;
2705         bool reclaimable = false;
2706
2707         do {
2708                 struct mem_cgroup *root = sc->target_mem_cgroup;
2709                 struct mem_cgroup_reclaim_cookie reclaim = {
2710                         .pgdat = pgdat,
2711                         .priority = sc->priority,
2712                 };
2713                 unsigned long node_lru_pages = 0;
2714                 struct mem_cgroup *memcg;
2715
2716                 memset(&sc->nr, 0, sizeof(sc->nr));
2717
2718                 nr_reclaimed = sc->nr_reclaimed;
2719                 nr_scanned = sc->nr_scanned;
2720
2721                 memcg = mem_cgroup_iter(root, NULL, &reclaim);
2722                 do {
2723                         unsigned long lru_pages;
2724                         unsigned long reclaimed;
2725                         unsigned long scanned;
2726
2727                         switch (mem_cgroup_protected(root, memcg)) {
2728                         case MEMCG_PROT_MIN:
2729                                 /*
2730                                  * Hard protection.
2731                                  * If there is no reclaimable memory, OOM.
2732                                  */
2733                                 continue;
2734                         case MEMCG_PROT_LOW:
2735                                 /*
2736                                  * Soft protection.
2737                                  * Respect the protection only as long as
2738                                  * there is an unprotected supply
2739                                  * of reclaimable memory from other cgroups.
2740                                  */
2741                                 if (!sc->memcg_low_reclaim) {
2742                                         sc->memcg_low_skipped = 1;
2743                                         continue;
2744                                 }
2745                                 memcg_memory_event(memcg, MEMCG_LOW);
2746                                 break;
2747                         case MEMCG_PROT_NONE:
2748                                 break;
2749                         }
2750
2751                         reclaimed = sc->nr_reclaimed;
2752                         scanned = sc->nr_scanned;
2753                         shrink_node_memcg(pgdat, memcg, sc, &lru_pages);
2754                         node_lru_pages += lru_pages;
2755
2756                         if (sc->may_shrinkslab) {
2757                                 shrink_slab(sc->gfp_mask, pgdat->node_id,
2758                                     memcg, sc->priority);
2759                         }
2760
2761                         /* Record the group's reclaim efficiency */
2762                         vmpressure(sc->gfp_mask, memcg, false,
2763                                    sc->nr_scanned - scanned,
2764                                    sc->nr_reclaimed - reclaimed);
2765
2766                         /*
2767                          * Direct reclaim and kswapd have to scan all memory
2768                          * cgroups to fulfill the overall scan target for the
2769                          * node.
2770                          *
2771                          * Limit reclaim, on the other hand, only cares about
2772                          * nr_to_reclaim pages to be reclaimed and it will
2773                          * retry with decreasing priority if one round over the
2774                          * whole hierarchy is not sufficient.
2775                          */
2776                         if (!global_reclaim(sc) &&
2777                                         sc->nr_reclaimed >= sc->nr_to_reclaim) {
2778                                 mem_cgroup_iter_break(root, memcg);
2779                                 break;
2780                         }
2781                 } while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));
2782
2783                 if (reclaim_state) {
2784                         sc->nr_reclaimed += reclaim_state->reclaimed_slab;
2785                         reclaim_state->reclaimed_slab = 0;
2786                 }
2787
2788                 /* Record the subtree's reclaim efficiency */
2789                 vmpressure(sc->gfp_mask, sc->target_mem_cgroup, true,
2790                            sc->nr_scanned - nr_scanned,
2791                            sc->nr_reclaimed - nr_reclaimed);
2792
2793                 if (sc->nr_reclaimed - nr_reclaimed)
2794                         reclaimable = true;
2795
2796                 if (current_is_kswapd()) {
2797                         /*
2798                          * If reclaim is isolating dirty pages under writeback,
2799                          * it implies that the long-lived page allocation rate
2800                          * is exceeding the page laundering rate. Either the
2801                          * global limits are not being effective at throttling
2802                          * processes due to the page distribution throughout
2803                          * zones or there is heavy usage of a slow backing
2804                          * device. The only option is to throttle from reclaim
2805                          * context which is not ideal as there is no guarantee
2806                          * the dirtying process is throttled in the same way
2807                          * balance_dirty_pages() manages.
2808                          *
2809                          * Once a node is flagged PGDAT_WRITEBACK, kswapd will
2810                          * count the number of pages under pages flagged for
2811                          * immediate reclaim and stall if any are encountered
2812                          * in the nr_immediate check below.
2813                          */
2814                         if (sc->nr.writeback && sc->nr.writeback == sc->nr.taken)
2815                                 set_bit(PGDAT_WRITEBACK, &pgdat->flags);
2816
2817                         /*
2818                          * Tag a node as congested if all the dirty pages
2819                          * scanned were backed by a congested BDI and
2820                          * wait_iff_congested will stall.
2821                          */
2822                         if (sc->nr.dirty && sc->nr.dirty == sc->nr.congested)
2823                                 set_bit(PGDAT_CONGESTED, &pgdat->flags);
2824
2825                         /* Allow kswapd to start writing pages during reclaim.*/
2826                         if (sc->nr.unqueued_dirty == sc->nr.file_taken)
2827                                 set_bit(PGDAT_DIRTY, &pgdat->flags);
2828
2829                         /*
2830                          * If kswapd scans pages marked marked for immediate
2831                          * reclaim and under writeback (nr_immediate), it
2832                          * implies that pages are cycling through the LRU
2833                          * faster than they are written so also forcibly stall.
2834                          */
2835                         if (sc->nr.immediate)
2836                                 congestion_wait(BLK_RW_ASYNC, HZ/10);
2837                 }
2838
2839                 /*
2840                  * Legacy memcg will stall in page writeback so avoid forcibly
2841                  * stalling in wait_iff_congested().
2842                  */
2843                 if (!global_reclaim(sc) && sane_reclaim(sc) &&
2844                     sc->nr.dirty && sc->nr.dirty == sc->nr.congested)
2845                         set_memcg_congestion(pgdat, root, true);
2846
2847                 /*
2848                  * Stall direct reclaim for IO completions if underlying BDIs
2849                  * and node is congested. Allow kswapd to continue until it
2850                  * starts encountering unqueued dirty pages or cycling through
2851                  * the LRU too quickly.
2852                  */
2853                 if (!sc->hibernation_mode && !current_is_kswapd() &&
2854                    current_may_throttle() && pgdat_memcg_congested(pgdat, root))
2855                         wait_iff_congested(BLK_RW_ASYNC, HZ/10);
2856
2857         } while (should_continue_reclaim(pgdat, sc->nr_reclaimed - nr_reclaimed,
2858                                          sc->nr_scanned - nr_scanned, sc));
2859
2860         /*
2861          * Kswapd gives up on balancing particular nodes after too
2862          * many failures to reclaim anything from them and goes to
2863          * sleep. On reclaim progress, reset the failure counter. A
2864          * successful direct reclaim run will revive a dormant kswapd.
2865          */
2866         if (reclaimable)
2867                 pgdat->kswapd_failures = 0;
2868
2869         return reclaimable;
2870 }
2871
2872 /*
2873  * Returns true if compaction should go ahead for a costly-order request, or
2874  * the allocation would already succeed without compaction. Return false if we
2875  * should reclaim first.
2876  */
2877 static inline bool compaction_ready(struct zone *zone, struct scan_control *sc)
2878 {
2879         unsigned long watermark;
2880         enum compact_result suitable;
2881
2882         suitable = compaction_suitable(zone, sc->order, 0, sc->reclaim_idx);
2883         if (suitable == COMPACT_SUCCESS)
2884                 /* Allocation should succeed already. Don't reclaim. */
2885                 return true;
2886         if (suitable == COMPACT_SKIPPED)
2887                 /* Compaction cannot yet proceed. Do reclaim. */
2888                 return false;
2889
2890         /*
2891          * Compaction is already possible, but it takes time to run and there
2892          * are potentially other callers using the pages just freed. So proceed
2893          * with reclaim to make a buffer of free pages available to give
2894          * compaction a reasonable chance of completing and allocating the page.
2895          * Note that we won't actually reclaim the whole buffer in one attempt
2896          * as the target watermark in should_continue_reclaim() is lower. But if
2897          * we are already above the high+gap watermark, don't reclaim at all.
2898          */
2899         watermark = high_wmark_pages(zone) + compact_gap(sc->order);
2900
2901         return zone_watermark_ok_safe(zone, 0, watermark, sc->reclaim_idx);
2902 }
2903
2904 /*
2905  * This is the direct reclaim path, for page-allocating processes.  We only
2906  * try to reclaim pages from zones which will satisfy the caller's allocation
2907  * request.
2908  *
2909  * If a zone is deemed to be full of pinned pages then just give it a light
2910  * scan then give up on it.
2911  */
2912 static void shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
2913 {
2914         struct zoneref *z;
2915         struct zone *zone;
2916         unsigned long nr_soft_reclaimed;
2917         unsigned long nr_soft_scanned;
2918         gfp_t orig_mask;
2919         pg_data_t *last_pgdat = NULL;
2920
2921         /*
2922          * If the number of buffer_heads in the machine exceeds the maximum
2923          * allowed level, force direct reclaim to scan the highmem zone as
2924          * highmem pages could be pinning lowmem pages storing buffer_heads
2925          */
2926         orig_mask = sc->gfp_mask;
2927         if (buffer_heads_over_limit) {
2928                 sc->gfp_mask |= __GFP_HIGHMEM;
2929                 sc->reclaim_idx = gfp_zone(sc->gfp_mask);
2930         }
2931
2932         for_each_zone_zonelist_nodemask(zone, z, zonelist,
2933                                         sc->reclaim_idx, sc->nodemask) {
2934                 /*
2935                  * Take care memory controller reclaiming has small influence
2936                  * to global LRU.
2937                  */
2938                 if (global_reclaim(sc)) {
2939                         if (!cpuset_zone_allowed(zone,
2940                                                  GFP_KERNEL | __GFP_HARDWALL))
2941                                 continue;
2942
2943                         /*
2944                          * If we already have plenty of memory free for
2945                          * compaction in this zone, don't free any more.
2946                          * Even though compaction is invoked for any
2947                          * non-zero order, only frequent costly order
2948                          * reclamation is disruptive enough to become a
2949                          * noticeable problem, like transparent huge
2950                          * page allocations.
2951                          */
2952                         if (IS_ENABLED(CONFIG_COMPACTION) &&
2953                             sc->order > PAGE_ALLOC_COSTLY_ORDER &&
2954                             compaction_ready(zone, sc)) {
2955                                 sc->compaction_ready = true;
2956                                 continue;
2957                         }
2958
2959                         /*
2960                          * Shrink each node in the zonelist once. If the
2961                          * zonelist is ordered by zone (not the default) then a
2962                          * node may be shrunk multiple times but in that case
2963                          * the user prefers lower zones being preserved.
2964                          */
2965                         if (zone->zone_pgdat == last_pgdat)
2966                                 continue;
2967
2968                         /*
2969                          * This steals pages from memory cgroups over softlimit
2970                          * and returns the number of reclaimed pages and
2971                          * scanned pages. This works for global memory pressure
2972                          * and balancing, not for a memcg's limit.
2973                          */
2974                         nr_soft_scanned = 0;
2975                         nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone->zone_pgdat,
2976                                                 sc->order, sc->gfp_mask,
2977                                                 &nr_soft_scanned);
2978                         sc->nr_reclaimed += nr_soft_reclaimed;
2979                         sc->nr_scanned += nr_soft_scanned;
2980                         /* need some check for avoid more shrink_zone() */
2981                 }
2982
2983                 /* See comment about same check for global reclaim above */
2984                 if (zone->zone_pgdat == last_pgdat)
2985                         continue;
2986                 last_pgdat = zone->zone_pgdat;
2987                 shrink_node(zone->zone_pgdat, sc);
2988         }
2989
2990         /*
2991          * Restore to original mask to avoid the impact on the caller if we
2992          * promoted it to __GFP_HIGHMEM.
2993          */
2994         sc->gfp_mask = orig_mask;
2995 }
2996
2997 static void snapshot_refaults(struct mem_cgroup *root_memcg, pg_data_t *pgdat)
2998 {
2999         struct mem_cgroup *memcg;
3000
3001         memcg = mem_cgroup_iter(root_memcg, NULL, NULL);
3002         do {
3003                 unsigned long refaults;
3004                 struct lruvec *lruvec;
3005
3006                 if (memcg)
3007                         refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
3008                 else
3009                         refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);
3010
3011                 lruvec = mem_cgroup_lruvec(pgdat, memcg);
3012                 lruvec->refaults = refaults;
3013         } while ((memcg = mem_cgroup_iter(root_memcg, memcg, NULL)));
3014 }
3015
3016 /*
3017  * This is the main entry point to direct page reclaim.
3018  *
3019  * If a full scan of the inactive list fails to free enough memory then we
3020  * are "out of memory" and something needs to be killed.
3021  *
3022  * If the caller is !__GFP_FS then the probability of a failure is reasonably
3023  * high - the zone may be full of dirty or under-writeback pages, which this
3024  * caller can't do much about.  We kick the writeback threads and take explicit
3025  * naps in the hope that some of these pages can be written.  But if the
3026  * allocating task holds filesystem locks which prevent writeout this might not
3027  * work, and the allocation attempt will fail.
3028  *
3029  * returns:     0, if no pages reclaimed
3030  *              else, the number of pages reclaimed
3031  */
3032 static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
3033                                           struct scan_control *sc)
3034 {
3035         int initial_priority = sc->priority;
3036         pg_data_t *last_pgdat;
3037         struct zoneref *z;
3038         struct zone *zone;
3039 retry:
3040         delayacct_freepages_start();
3041
3042         if (global_reclaim(sc))
3043                 __count_zid_vm_events(ALLOCSTALL, sc->reclaim_idx, 1);
3044
3045         do {
3046                 vmpressure_prio(sc->gfp_mask, sc->target_mem_cgroup,
3047                                 sc->priority);
3048                 sc->nr_scanned = 0;
3049                 shrink_zones(zonelist, sc);
3050
3051                 if (sc->nr_reclaimed >= sc->nr_to_reclaim)
3052                         break;
3053
3054                 if (sc->compaction_ready)
3055                         break;
3056
3057                 /*
3058                  * If we're getting trouble reclaiming, start doing
3059                  * writepage even in laptop mode.
3060                  */
3061                 if (sc->priority < DEF_PRIORITY - 2)
3062                         sc->may_writepage = 1;
3063         } while (--sc->priority >= 0);
3064
3065         last_pgdat = NULL;
3066         for_each_zone_zonelist_nodemask(zone, z, zonelist, sc->reclaim_idx,
3067                                         sc->nodemask) {
3068                 if (zone->zone_pgdat == last_pgdat)
3069                         continue;
3070                 last_pgdat = zone->zone_pgdat;
3071                 snapshot_refaults(sc->target_mem_cgroup, zone->zone_pgdat);
3072                 set_memcg_congestion(last_pgdat, sc->target_mem_cgroup, false);
3073         }
3074
3075         delayacct_freepages_end();
3076
3077         if (sc->nr_reclaimed)
3078                 return sc->nr_reclaimed;
3079
3080         /* Aborted reclaim to try compaction? don't OOM, then */
3081         if (sc->compaction_ready)
3082                 return 1;
3083
3084         /* Untapped cgroup reserves?  Don't OOM, retry. */
3085         if (sc->memcg_low_skipped) {
3086                 sc->priority = initial_priority;
3087                 sc->memcg_low_reclaim = 1;
3088                 sc->memcg_low_skipped = 0;
3089                 goto retry;
3090         }
3091
3092         return 0;
3093 }
3094
3095 static bool allow_direct_reclaim(pg_data_t *pgdat)
3096 {
3097         struct zone *zone;
3098         unsigned long pfmemalloc_reserve = 0;
3099         unsigned long free_pages = 0;
3100         int i;
3101         bool wmark_ok;
3102
3103         if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
3104                 return true;
3105
3106         for (i = 0; i <= ZONE_NORMAL; i++) {
3107                 zone = &pgdat->node_zones[i];
3108                 if (!managed_zone(zone))
3109                         continue;
3110
3111                 if (!zone_reclaimable_pages(zone))
3112                         continue;
3113
3114                 pfmemalloc_reserve += min_wmark_pages(zone);
3115                 free_pages += zone_page_state(zone, NR_FREE_PAGES);
3116         }
3117
3118         /* If there are no reserves (unexpected config) then do not throttle */
3119         if (!pfmemalloc_reserve)
3120                 return true;
3121
3122         wmark_ok = free_pages > pfmemalloc_reserve / 2;
3123
3124         /* kswapd must be awake if processes are being throttled */
3125         if (!wmark_ok && waitqueue_active(&pgdat->kswapd_wait)) {
3126                 pgdat->kswapd_classzone_idx = min(pgdat->kswapd_classzone_idx,
3127                                                 (enum zone_type)ZONE_NORMAL);
3128                 wake_up_interruptible(&pgdat->kswapd_wait);
3129         }
3130
3131         return wmark_ok;
3132 }
3133
3134 /*
3135  * Throttle direct reclaimers if backing storage is backed by the network
3136  * and the PFMEMALLOC reserve for the preferred node is getting dangerously
3137  * depleted. kswapd will continue to make progress and wake the processes
3138  * when the low watermark is reached.
3139  *
3140  * Returns true if a fatal signal was delivered during throttling. If this
3141  * happens, the page allocator should not consider triggering the OOM killer.
3142  */
3143 static bool throttle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
3144                                         nodemask_t *nodemask)
3145 {
3146         struct zoneref *z;
3147         struct zone *zone;
3148         pg_data_t *pgdat = NULL;
3149
3150         /*
3151          * Kernel threads should not be throttled as they may be indirectly
3152          * responsible for cleaning pages necessary for reclaim to make forward
3153          * progress. kjournald for example may enter direct reclaim while
3154          * committing a transaction where throttling it could forcing other
3155          * processes to block on log_wait_commit().
3156          */
3157         if (current->flags & PF_KTHREAD)
3158                 goto out;
3159
3160         /*
3161          * If a fatal signal is pending, this process should not throttle.
3162          *&n