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