vmscan.c 115.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  linux/mm/vmscan.c
 *
 *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
 *
 *  Swap reorganised 29.12.95, Stephen Tweedie.
 *  kswapd added: 7.1.96  sct
 *  Removed kswapd_ctl limits, and swap out as many pages as needed
 *  to bring the system back to freepages.high: 2.4.97, Rik van Riel.
 *  Zone aware kswapd started 02/00, Kanoj Sarcar (kanoj@sgi.com).
 *  Multiqueue VM started 5.8.00, Rik van Riel.
 */

14 15
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

L
Linus Torvalds 已提交
16
#include <linux/mm.h>
17
#include <linux/sched/mm.h>
L
Linus Torvalds 已提交
18
#include <linux/module.h>
19
#include <linux/gfp.h>
L
Linus Torvalds 已提交
20 21 22 23 24
#include <linux/kernel_stat.h>
#include <linux/swap.h>
#include <linux/pagemap.h>
#include <linux/init.h>
#include <linux/highmem.h>
25
#include <linux/vmpressure.h>
26
#include <linux/vmstat.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32 33 34 35 36 37
#include <linux/file.h>
#include <linux/writeback.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>	/* for try_to_release_page(),
					buffer_heads_over_limit */
#include <linux/mm_inline.h>
#include <linux/backing-dev.h>
#include <linux/rmap.h>
#include <linux/topology.h>
#include <linux/cpu.h>
#include <linux/cpuset.h>
38
#include <linux/compaction.h>
L
Linus Torvalds 已提交
39 40
#include <linux/notifier.h>
#include <linux/rwsem.h>
41
#include <linux/delay.h>
42
#include <linux/kthread.h>
43
#include <linux/freezer.h>
44
#include <linux/memcontrol.h>
45
#include <linux/delayacct.h>
46
#include <linux/sysctl.h>
47
#include <linux/oom.h>
48
#include <linux/prefetch.h>
49
#include <linux/printk.h>
50
#include <linux/dax.h>
L
Linus Torvalds 已提交
51 52 53 54 55

#include <asm/tlbflush.h>
#include <asm/div64.h>

#include <linux/swapops.h>
56
#include <linux/balloon_compaction.h>
L
Linus Torvalds 已提交
57

58 59
#include "internal.h"

60 61 62
#define CREATE_TRACE_POINTS
#include <trace/events/vmscan.h>

L
Linus Torvalds 已提交
63
struct scan_control {
64 65 66
	/* How many pages shrink_list() should reclaim */
	unsigned long nr_to_reclaim;

L
Linus Torvalds 已提交
67
	/* This context's GFP mask */
A
Al Viro 已提交
68
	gfp_t gfp_mask;
L
Linus Torvalds 已提交
69

70
	/* Allocation order */
A
Andy Whitcroft 已提交
71
	int order;
72

73 74 75 76 77
	/*
	 * Nodemask of nodes allowed by the caller. If NULL, all nodes
	 * are scanned.
	 */
	nodemask_t	*nodemask;
78

79 80 81 82 83
	/*
	 * The memory cgroup that hit its limit and as a result is the
	 * primary target of this reclaim invocation.
	 */
	struct mem_cgroup *target_mem_cgroup;
84

85 86 87
	/* Scan (total_size >> priority) pages at once */
	int priority;

88 89 90
	/* The highest zone to isolate pages for reclaim from */
	enum zone_type reclaim_idx;

91
	/* Writepage batching in laptop mode; RECLAIM_WRITE */
92 93 94 95 96 97 98 99
	unsigned int may_writepage:1;

	/* Can mapped pages be reclaimed? */
	unsigned int may_unmap:1;

	/* Can pages be swapped as part of reclaim? */
	unsigned int may_swap:1;

100 101 102 103 104 105 106
	/*
	 * Cgroups are not reclaimed below their configured memory.low,
	 * unless we threaten to OOM. If any cgroups are skipped due to
	 * memory.low and nothing was reclaimed, go back for memory.low.
	 */
	unsigned int memcg_low_reclaim:1;
	unsigned int memcg_low_skipped:1;
107

108 109 110 111 112 113 114 115 116 117
	unsigned int hibernation_mode:1;

	/* One of the zones is ready for compaction */
	unsigned int compaction_ready:1;

	/* Incremented by the number of inactive pages that were scanned */
	unsigned long nr_scanned;

	/* Number of pages freed so far during a call to shrink_zones() */
	unsigned long nr_reclaimed;
L
Linus Torvalds 已提交
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
};

#ifdef ARCH_HAS_PREFETCH
#define prefetch_prev_lru_page(_page, _base, _field)			\
	do {								\
		if ((_page)->lru.prev != _base) {			\
			struct page *prev;				\
									\
			prev = lru_to_page(&(_page->lru));		\
			prefetch(&prev->_field);			\
		}							\
	} while (0)
#else
#define prefetch_prev_lru_page(_page, _base, _field) do { } while (0)
#endif

#ifdef ARCH_HAS_PREFETCHW
#define prefetchw_prev_lru_page(_page, _base, _field)			\
	do {								\
		if ((_page)->lru.prev != _base) {			\
			struct page *prev;				\
									\
			prev = lru_to_page(&(_page->lru));		\
			prefetchw(&prev->_field);			\
		}							\
	} while (0)
#else
#define prefetchw_prev_lru_page(_page, _base, _field) do { } while (0)
#endif

/*
 * From 0 .. 100.  Higher means more swappy.
 */
int vm_swappiness = 60;
152 153 154 155 156
/*
 * The total number of pages which are beyond the high watermark within all
 * zones.
 */
unsigned long vm_total_pages;
L
Linus Torvalds 已提交
157 158 159 160

static LIST_HEAD(shrinker_list);
static DECLARE_RWSEM(shrinker_rwsem);

A
Andrew Morton 已提交
161
#ifdef CONFIG_MEMCG
162 163
static bool global_reclaim(struct scan_control *sc)
{
164
	return !sc->target_mem_cgroup;
165
}
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186

/**
 * sane_reclaim - is the usual dirty throttling mechanism operational?
 * @sc: scan_control in question
 *
 * The normal page dirty throttling mechanism in balance_dirty_pages() is
 * completely broken with the legacy memcg and direct stalling in
 * shrink_page_list() is used for throttling instead, which lacks all the
 * niceties such as fairness, adaptive pausing, bandwidth proportional
 * allocation and configurability.
 *
 * This function tests whether the vmscan currently in progress can assume
 * that the normal dirty throttling mechanism is operational.
 */
static bool sane_reclaim(struct scan_control *sc)
{
	struct mem_cgroup *memcg = sc->target_mem_cgroup;

	if (!memcg)
		return true;
#ifdef CONFIG_CGROUP_WRITEBACK
187
	if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
188 189 190 191
		return true;
#endif
	return false;
}
192
#else
193 194 195 196
static bool global_reclaim(struct scan_control *sc)
{
	return true;
}
197 198 199 200 201

static bool sane_reclaim(struct scan_control *sc)
{
	return true;
}
202 203
#endif

204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
/*
 * This misses isolated pages which are not accounted for to save counters.
 * As the data only determines if reclaim or compaction continues, it is
 * not expected that isolated pages will be a dominating factor.
 */
unsigned long zone_reclaimable_pages(struct zone *zone)
{
	unsigned long nr;

	nr = zone_page_state_snapshot(zone, NR_ZONE_INACTIVE_FILE) +
		zone_page_state_snapshot(zone, NR_ZONE_ACTIVE_FILE);
	if (get_nr_swap_pages() > 0)
		nr += zone_page_state_snapshot(zone, NR_ZONE_INACTIVE_ANON) +
			zone_page_state_snapshot(zone, NR_ZONE_ACTIVE_ANON);

	return nr;
}

M
Mel Gorman 已提交
222 223 224 225 226 227 228
unsigned long pgdat_reclaimable_pages(struct pglist_data *pgdat)
{
	unsigned long nr;

	nr = node_page_state_snapshot(pgdat, NR_ACTIVE_FILE) +
	     node_page_state_snapshot(pgdat, NR_INACTIVE_FILE) +
	     node_page_state_snapshot(pgdat, NR_ISOLATED_FILE);
229 230

	if (get_nr_swap_pages() > 0)
M
Mel Gorman 已提交
231 232 233
		nr += node_page_state_snapshot(pgdat, NR_ACTIVE_ANON) +
		      node_page_state_snapshot(pgdat, NR_INACTIVE_ANON) +
		      node_page_state_snapshot(pgdat, NR_ISOLATED_ANON);
234 235 236 237

	return nr;
}

238 239 240 241 242 243 244
/**
 * lruvec_lru_size -  Returns the number of pages on the given LRU list.
 * @lruvec: lru vector
 * @lru: lru to use
 * @zone_idx: zones to consider (use MAX_NR_ZONES for the whole LRU list)
 */
unsigned long lruvec_lru_size(struct lruvec *lruvec, enum lru_list lru, int zone_idx)
245
{
246 247 248
	unsigned long lru_size;
	int zid;

249
	if (!mem_cgroup_disabled())
250 251 252
		lru_size = mem_cgroup_get_lru_size(lruvec, lru);
	else
		lru_size = node_page_state(lruvec_pgdat(lruvec), NR_LRU_BASE + lru);
253

254 255 256
	for (zid = zone_idx + 1; zid < MAX_NR_ZONES; zid++) {
		struct zone *zone = &lruvec_pgdat(lruvec)->node_zones[zid];
		unsigned long size;
257

258 259 260 261 262 263 264 265 266 267 268 269
		if (!managed_zone(zone))
			continue;

		if (!mem_cgroup_disabled())
			size = mem_cgroup_get_zone_lru_size(lruvec, lru, zid);
		else
			size = zone_page_state(&lruvec_pgdat(lruvec)->node_zones[zid],
				       NR_ZONE_LRU_BASE + lru);
		lru_size -= min(size, lru_size);
	}

	return lru_size;
270 271 272

}

L
Linus Torvalds 已提交
273
/*
G
Glauber Costa 已提交
274
 * Add a shrinker callback to be called from the vm.
L
Linus Torvalds 已提交
275
 */
G
Glauber Costa 已提交
276
int register_shrinker(struct shrinker *shrinker)
L
Linus Torvalds 已提交
277
{
G
Glauber Costa 已提交
278 279 280 281 282 283 284 285 286
	size_t size = sizeof(*shrinker->nr_deferred);

	if (shrinker->flags & SHRINKER_NUMA_AWARE)
		size *= nr_node_ids;

	shrinker->nr_deferred = kzalloc(size, GFP_KERNEL);
	if (!shrinker->nr_deferred)
		return -ENOMEM;

287 288 289
	down_write(&shrinker_rwsem);
	list_add_tail(&shrinker->list, &shrinker_list);
	up_write(&shrinker_rwsem);
G
Glauber Costa 已提交
290
	return 0;
L
Linus Torvalds 已提交
291
}
292
EXPORT_SYMBOL(register_shrinker);
L
Linus Torvalds 已提交
293 294 295 296

/*
 * Remove one
 */
297
void unregister_shrinker(struct shrinker *shrinker)
L
Linus Torvalds 已提交
298 299 300 301
{
	down_write(&shrinker_rwsem);
	list_del(&shrinker->list);
	up_write(&shrinker_rwsem);
302
	kfree(shrinker->nr_deferred);
L
Linus Torvalds 已提交
303
}
304
EXPORT_SYMBOL(unregister_shrinker);
L
Linus Torvalds 已提交
305 306

#define SHRINK_BATCH 128
G
Glauber Costa 已提交
307

308 309 310 311
static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
				    struct shrinker *shrinker,
				    unsigned long nr_scanned,
				    unsigned long nr_eligible)
G
Glauber Costa 已提交
312 313 314 315
{
	unsigned long freed = 0;
	unsigned long long delta;
	long total_scan;
316
	long freeable;
G
Glauber Costa 已提交
317 318 319 320 321
	long nr;
	long new_nr;
	int nid = shrinkctl->nid;
	long batch_size = shrinker->batch ? shrinker->batch
					  : SHRINK_BATCH;
322
	long scanned = 0, next_deferred;
G
Glauber Costa 已提交
323

324 325
	freeable = shrinker->count_objects(shrinker, shrinkctl);
	if (freeable == 0)
G
Glauber Costa 已提交
326 327 328 329 330 331 332 333 334 335
		return 0;

	/*
	 * copy the current shrinker scan count into a local variable
	 * and zero it so that other concurrent shrinker invocations
	 * don't also do this scanning work.
	 */
	nr = atomic_long_xchg(&shrinker->nr_deferred[nid], 0);

	total_scan = nr;
336
	delta = (4 * nr_scanned) / shrinker->seeks;
337
	delta *= freeable;
338
	do_div(delta, nr_eligible + 1);
G
Glauber Costa 已提交
339 340
	total_scan += delta;
	if (total_scan < 0) {
341
		pr_err("shrink_slab: %pF negative objects to delete nr=%ld\n",
D
Dave Chinner 已提交
342
		       shrinker->scan_objects, total_scan);
343
		total_scan = freeable;
344 345 346
		next_deferred = nr;
	} else
		next_deferred = total_scan;
G
Glauber Costa 已提交
347 348 349 350 351 352 353

	/*
	 * We need to avoid excessive windup on filesystem shrinkers
	 * due to large numbers of GFP_NOFS allocations causing the
	 * shrinkers to return -1 all the time. This results in a large
	 * nr being built up so when a shrink that can do some work
	 * comes along it empties the entire cache due to nr >>>
354
	 * freeable. This is bad for sustaining a working set in
G
Glauber Costa 已提交
355 356 357 358 359
	 * memory.
	 *
	 * Hence only allow the shrinker to scan the entire cache when
	 * a large delta change is calculated directly.
	 */
360 361
	if (delta < freeable / 4)
		total_scan = min(total_scan, freeable / 2);
G
Glauber Costa 已提交
362 363 364 365 366 367

	/*
	 * Avoid risking looping forever due to too large nr value:
	 * never try to free more than twice the estimate number of
	 * freeable entries.
	 */
368 369
	if (total_scan > freeable * 2)
		total_scan = freeable * 2;
G
Glauber Costa 已提交
370 371

	trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,
372 373
				   nr_scanned, nr_eligible,
				   freeable, delta, total_scan);
G
Glauber Costa 已提交
374

375 376 377 378 379 380 381 382 383 384 385
	/*
	 * Normally, we should not scan less than batch_size objects in one
	 * pass to avoid too frequent shrinker calls, but if the slab has less
	 * than batch_size objects in total and we are really tight on memory,
	 * we will try to reclaim all available objects, otherwise we can end
	 * up failing allocations although there are plenty of reclaimable
	 * objects spread over several slabs with usage less than the
	 * batch_size.
	 *
	 * We detect the "tight on memory" situations by looking at the total
	 * number of objects we want to scan (total_scan). If it is greater
386
	 * than the total number of objects on slab (freeable), we must be
387 388 389 390
	 * scanning at high prio and therefore should try to reclaim as much as
	 * possible.
	 */
	while (total_scan >= batch_size ||
391
	       total_scan >= freeable) {
D
Dave Chinner 已提交
392
		unsigned long ret;
393
		unsigned long nr_to_scan = min(batch_size, total_scan);
G
Glauber Costa 已提交
394

395
		shrinkctl->nr_to_scan = nr_to_scan;
396
		shrinkctl->nr_scanned = nr_to_scan;
D
Dave Chinner 已提交
397 398 399 400
		ret = shrinker->scan_objects(shrinker, shrinkctl);
		if (ret == SHRINK_STOP)
			break;
		freed += ret;
G
Glauber Costa 已提交
401

402 403 404
		count_vm_events(SLABS_SCANNED, shrinkctl->nr_scanned);
		total_scan -= shrinkctl->nr_scanned;
		scanned += shrinkctl->nr_scanned;
G
Glauber Costa 已提交
405 406 407 408

		cond_resched();
	}

409 410 411 412
	if (next_deferred >= scanned)
		next_deferred -= scanned;
	else
		next_deferred = 0;
G
Glauber Costa 已提交
413 414 415 416 417
	/*
	 * move the unused scan count back into the shrinker in a
	 * manner that handles concurrent updates. If we exhausted the
	 * scan, there is no need to do an update.
	 */
418 419
	if (next_deferred > 0)
		new_nr = atomic_long_add_return(next_deferred,
G
Glauber Costa 已提交
420 421 422 423
						&shrinker->nr_deferred[nid]);
	else
		new_nr = atomic_long_read(&shrinker->nr_deferred[nid]);

424
	trace_mm_shrink_slab_end(shrinker, nid, freed, nr, new_nr, total_scan);
G
Glauber Costa 已提交
425
	return freed;
426 427
}

428
/**
429
 * shrink_slab - shrink slab caches
430 431
 * @gfp_mask: allocation context
 * @nid: node whose slab caches to target
432
 * @memcg: memory cgroup whose slab caches to target
433 434
 * @nr_scanned: pressure numerator
 * @nr_eligible: pressure denominator
L
Linus Torvalds 已提交
435
 *
436
 * Call the shrink functions to age shrinkable caches.
L
Linus Torvalds 已提交
437
 *
438 439
 * @nid is passed along to shrinkers with SHRINKER_NUMA_AWARE set,
 * unaware shrinkers will receive a node id of 0 instead.
L
Linus Torvalds 已提交
440
 *
441 442
 * @memcg specifies the memory cgroup to target. If it is not NULL,
 * only shrinkers with SHRINKER_MEMCG_AWARE set will be called to scan
443 444
 * objects from the memory cgroup specified. Otherwise, only unaware
 * shrinkers are called.
445
 *
446 447 448 449 450 451 452
 * @nr_scanned and @nr_eligible form a ratio that indicate how much of
 * the available objects should be scanned.  Page reclaim for example
 * passes the number of pages scanned and the number of pages on the
 * LRU lists that it considered on @nid, plus a bias in @nr_scanned
 * when it encountered mapped pages.  The ratio is further biased by
 * the ->seeks setting of the shrink function, which indicates the
 * cost to recreate an object relative to that of an LRU page.
453
 *
454
 * Returns the number of reclaimed slab objects.
L
Linus Torvalds 已提交
455
 */
456 457 458 459
static unsigned long shrink_slab(gfp_t gfp_mask, int nid,
				 struct mem_cgroup *memcg,
				 unsigned long nr_scanned,
				 unsigned long nr_eligible)
L
Linus Torvalds 已提交
460 461
{
	struct shrinker *shrinker;
D
Dave Chinner 已提交
462
	unsigned long freed = 0;
L
Linus Torvalds 已提交
463

464
	if (memcg && (!memcg_kmem_enabled() || !mem_cgroup_online(memcg)))
465 466
		return 0;

467 468
	if (nr_scanned == 0)
		nr_scanned = SWAP_CLUSTER_MAX;
L
Linus Torvalds 已提交
469

470
	if (!down_read_trylock(&shrinker_rwsem)) {
D
Dave Chinner 已提交
471 472 473 474 475 476 477
		/*
		 * If we would return 0, our callers would understand that we
		 * have nothing else to shrink and give up trying. By returning
		 * 1 we keep it going and assume we'll be able to shrink next
		 * time.
		 */
		freed = 1;
478 479
		goto out;
	}
L
Linus Torvalds 已提交
480 481

	list_for_each_entry(shrinker, &shrinker_list, list) {
482 483 484
		struct shrink_control sc = {
			.gfp_mask = gfp_mask,
			.nid = nid,
485
			.memcg = memcg,
486
		};
487

488 489 490 491 492 493 494
		/*
		 * If kernel memory accounting is disabled, we ignore
		 * SHRINKER_MEMCG_AWARE flag and call all shrinkers
		 * passing NULL for memcg.
		 */
		if (memcg_kmem_enabled() &&
		    !!memcg != !!(shrinker->flags & SHRINKER_MEMCG_AWARE))
495 496
			continue;

497 498
		if (!(shrinker->flags & SHRINKER_NUMA_AWARE))
			sc.nid = 0;
L
Linus Torvalds 已提交
499

500
		freed += do_shrink_slab(&sc, shrinker, nr_scanned, nr_eligible);
L
Linus Torvalds 已提交
501
	}
502

L
Linus Torvalds 已提交
503
	up_read(&shrinker_rwsem);
504 505
out:
	cond_resched();
D
Dave Chinner 已提交
506
	return freed;
L
Linus Torvalds 已提交
507 508
}

509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
void drop_slab_node(int nid)
{
	unsigned long freed;

	do {
		struct mem_cgroup *memcg = NULL;

		freed = 0;
		do {
			freed += shrink_slab(GFP_KERNEL, nid, memcg,
					     1000, 1000);
		} while ((memcg = mem_cgroup_iter(NULL, memcg, NULL)) != NULL);
	} while (freed > 10);
}

void drop_slab(void)
{
	int nid;

	for_each_online_node(nid)
		drop_slab_node(nid);
}

L
Linus Torvalds 已提交
532 533
static inline int is_page_cache_freeable(struct page *page)
{
534 535 536 537 538
	/*
	 * A freeable page cache page is referenced only by the caller
	 * that isolated the page, the page cache radix tree and
	 * optional buffer heads at page->private.
	 */
539
	return page_count(page) - page_has_private(page) == 2;
L
Linus Torvalds 已提交
540 541
}

542
static int may_write_to_inode(struct inode *inode, struct scan_control *sc)
L
Linus Torvalds 已提交
543
{
544
	if (current->flags & PF_SWAPWRITE)
L
Linus Torvalds 已提交
545
		return 1;
546
	if (!inode_write_congested(inode))
L
Linus Torvalds 已提交
547
		return 1;
548
	if (inode_to_bdi(inode) == current->backing_dev_info)
L
Linus Torvalds 已提交
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
		return 1;
	return 0;
}

/*
 * We detected a synchronous write error writing a page out.  Probably
 * -ENOSPC.  We need to propagate that into the address_space for a subsequent
 * fsync(), msync() or close().
 *
 * The tricky part is that after writepage we cannot touch the mapping: nothing
 * prevents it from being freed up.  But we have a ref on the page and once
 * that page is locked, the mapping is pinned.
 *
 * We're allowed to run sleeping lock_page() here because we know the caller has
 * __GFP_FS.
 */
static void handle_write_error(struct address_space *mapping,
				struct page *page, int error)
{
J
Jens Axboe 已提交
568
	lock_page(page);
569 570
	if (page_mapping(page) == mapping)
		mapping_set_error(mapping, error);
L
Linus Torvalds 已提交
571 572 573
	unlock_page(page);
}

574 575 576 577 578 579 580 581 582 583 584 585
/* possible outcome of pageout() */
typedef enum {
	/* failed to write page out, page is locked */
	PAGE_KEEP,
	/* move page to the active list, page is locked */
	PAGE_ACTIVATE,
	/* page has been sent to the disk successfully, page is unlocked */
	PAGE_SUCCESS,
	/* page is clean and locked */
	PAGE_CLEAN,
} pageout_t;

L
Linus Torvalds 已提交
586
/*
A
Andrew Morton 已提交
587 588
 * pageout is called by shrink_page_list() for each dirty page.
 * Calls ->writepage().
L
Linus Torvalds 已提交
589
 */
590
static pageout_t pageout(struct page *page, struct address_space *mapping,
591
			 struct scan_control *sc)
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599
{
	/*
	 * If the page is dirty, only perform writeback if that write
	 * will be non-blocking.  To prevent this allocation from being
	 * stalled by pagecache activity.  But note that there may be
	 * stalls if we need to run get_block().  We could test
	 * PagePrivate for that.
	 *
600
	 * If this process is currently in __generic_file_write_iter() against
L
Linus Torvalds 已提交
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
	 * this page's queue, we can perform writeback even if that
	 * will block.
	 *
	 * If the page is swapcache, write it back even if that would
	 * block, for some throttling. This happens by accident, because
	 * swap_backing_dev_info is bust: it doesn't reflect the
	 * congestion state of the swapdevs.  Easy to fix, if needed.
	 */
	if (!is_page_cache_freeable(page))
		return PAGE_KEEP;
	if (!mapping) {
		/*
		 * Some data journaling orphaned pages can have
		 * page->mapping == NULL while being dirty with clean buffers.
		 */
616
		if (page_has_private(page)) {
L
Linus Torvalds 已提交
617 618
			if (try_to_free_buffers(page)) {
				ClearPageDirty(page);
619
				pr_info("%s: orphaned page\n", __func__);
L
Linus Torvalds 已提交
620 621 622 623 624 625 626
				return PAGE_CLEAN;
			}
		}
		return PAGE_KEEP;
	}
	if (mapping->a_ops->writepage == NULL)
		return PAGE_ACTIVATE;
627
	if (!may_write_to_inode(mapping->host, sc))
L
Linus Torvalds 已提交
628 629 630 631 632 633 634
		return PAGE_KEEP;

	if (clear_page_dirty_for_io(page)) {
		int res;
		struct writeback_control wbc = {
			.sync_mode = WB_SYNC_NONE,
			.nr_to_write = SWAP_CLUSTER_MAX,
635 636
			.range_start = 0,
			.range_end = LLONG_MAX,
L
Linus Torvalds 已提交
637 638 639 640 641 642 643
			.for_reclaim = 1,
		};

		SetPageReclaim(page);
		res = mapping->a_ops->writepage(page, &wbc);
		if (res < 0)
			handle_write_error(mapping, page, res);
644
		if (res == AOP_WRITEPAGE_ACTIVATE) {
L
Linus Torvalds 已提交
645 646 647
			ClearPageReclaim(page);
			return PAGE_ACTIVATE;
		}
648

L
Linus Torvalds 已提交
649 650 651 652
		if (!PageWriteback(page)) {
			/* synchronous write or broken a_ops? */
			ClearPageReclaim(page);
		}
653
		trace_mm_vmscan_writepage(page);
654
		inc_node_page_state(page, NR_VMSCAN_WRITE);
L
Linus Torvalds 已提交
655 656 657 658 659 660
		return PAGE_SUCCESS;
	}

	return PAGE_CLEAN;
}

661
/*
N
Nick Piggin 已提交
662 663
 * Same as remove_mapping, but if the page is removed from the mapping, it
 * gets returned with a refcount of 0.
664
 */
665 666
static int __remove_mapping(struct address_space *mapping, struct page *page,
			    bool reclaimed)
667
{
668 669
	unsigned long flags;

670 671
	BUG_ON(!PageLocked(page));
	BUG_ON(mapping != page_mapping(page));
672

673
	spin_lock_irqsave(&mapping->tree_lock, flags);
674
	/*
N
Nick Piggin 已提交
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
	 * The non racy check for a busy page.
	 *
	 * Must be careful with the order of the tests. When someone has
	 * a ref to the page, it may be possible that they dirty it then
	 * drop the reference. So if PageDirty is tested before page_count
	 * here, then the following race may occur:
	 *
	 * get_user_pages(&page);
	 * [user mapping goes away]
	 * write_to(page);
	 *				!PageDirty(page)    [good]
	 * SetPageDirty(page);
	 * put_page(page);
	 *				!page_count(page)   [good, discard it]
	 *
	 * [oops, our write_to data is lost]
	 *
	 * Reversing the order of the tests ensures such a situation cannot
	 * escape unnoticed. The smp_rmb is needed to ensure the page->flags
694
	 * load is not satisfied before that of page->_refcount.
N
Nick Piggin 已提交
695 696 697
	 *
	 * Note that if SetPageDirty is always performed via set_page_dirty,
	 * and thus under tree_lock, then this ordering is not required.
698
	 */
699
	if (!page_ref_freeze(page, 2))
700
		goto cannot_free;
N
Nick Piggin 已提交
701 702
	/* note: atomic_cmpxchg in page_freeze_refs provides the smp_rmb */
	if (unlikely(PageDirty(page))) {
703
		page_ref_unfreeze(page, 2);
704
		goto cannot_free;
N
Nick Piggin 已提交
705
	}
706 707 708

	if (PageSwapCache(page)) {
		swp_entry_t swap = { .val = page_private(page) };
709
		mem_cgroup_swapout(page, swap);
710
		__delete_from_swap_cache(page);
711
		spin_unlock_irqrestore(&mapping->tree_lock, flags);
712
		put_swap_page(page, swap);
N
Nick Piggin 已提交
713
	} else {
714
		void (*freepage)(struct page *);
715
		void *shadow = NULL;
716 717

		freepage = mapping->a_ops->freepage;
718 719 720 721 722 723 724 725 726
		/*
		 * Remember a shadow entry for reclaimed file cache in
		 * order to detect refaults, thus thrashing, later on.
		 *
		 * But don't store shadows in an address space that is
		 * already exiting.  This is not just an optizimation,
		 * inode reclaim needs to empty out the radix tree or
		 * the nodes are lost.  Don't plant shadows behind its
		 * back.
727 728 729 730 731 732
		 *
		 * We also don't store shadows for DAX mappings because the
		 * only page cache pages found in these are zero pages
		 * covering holes, and because we don't want to mix DAX
		 * exceptional entries and shadow exceptional entries in the
		 * same page_tree.
733 734
		 */
		if (reclaimed && page_is_file_cache(page) &&
735
		    !mapping_exiting(mapping) && !dax_mapping(mapping))
736
			shadow = workingset_eviction(mapping, page);
J
Johannes Weiner 已提交
737
		__delete_from_page_cache(page, shadow);
738
		spin_unlock_irqrestore(&mapping->tree_lock, flags);
739 740 741

		if (freepage != NULL)
			freepage(page);
742 743 744 745 746
	}

	return 1;

cannot_free:
747
	spin_unlock_irqrestore(&mapping->tree_lock, flags);
748 749 750
	return 0;
}

N
Nick Piggin 已提交
751 752 753 754 755 756 757 758
/*
 * Attempt to detach a locked page from its ->mapping.  If it is dirty or if
 * someone else has a ref on the page, abort and return 0.  If it was
 * successfully detached, return 1.  Assumes the caller has a single ref on
 * this page.
 */
int remove_mapping(struct address_space *mapping, struct page *page)
{
759
	if (__remove_mapping(mapping, page, false)) {
N
Nick Piggin 已提交
760 761 762 763 764
		/*
		 * Unfreezing the refcount with 1 rather than 2 effectively
		 * drops the pagecache ref for us without requiring another
		 * atomic operation.
		 */
765
		page_ref_unfreeze(page, 1);
N
Nick Piggin 已提交
766 767 768 769 770
		return 1;
	}
	return 0;
}

L
Lee Schermerhorn 已提交
771 772 773 774 775 776 777 778 779 780 781
/**
 * putback_lru_page - put previously isolated page onto appropriate LRU list
 * @page: page to be put back to appropriate lru list
 *
 * Add previously isolated @page to appropriate LRU list.
 * Page may still be unevictable for other reasons.
 *
 * lru_lock must not be held, interrupts must be enabled.
 */
void putback_lru_page(struct page *page)
{
782
	bool is_unevictable;
783
	int was_unevictable = PageUnevictable(page);
L
Lee Schermerhorn 已提交
784

785
	VM_BUG_ON_PAGE(PageLRU(page), page);
L
Lee Schermerhorn 已提交
786 787 788 789

redo:
	ClearPageUnevictable(page);

790
	if (page_evictable(page)) {
L
Lee Schermerhorn 已提交
791 792 793 794 795 796
		/*
		 * For evictable pages, we can use the cache.
		 * In event of a race, worst case is we end up with an
		 * unevictable page on [in]active list.
		 * We know how to handle that.
		 */
797
		is_unevictable = false;
798
		lru_cache_add(page);
L
Lee Schermerhorn 已提交
799 800 801 802 803
	} else {
		/*
		 * Put unevictable pages directly on zone's unevictable
		 * list.
		 */
804
		is_unevictable = true;
L
Lee Schermerhorn 已提交
805
		add_page_to_unevictable_list(page);
806
		/*
807 808 809
		 * When racing with an mlock or AS_UNEVICTABLE clearing
		 * (page is unlocked) make sure that if the other thread
		 * does not observe our setting of PG_lru and fails
810
		 * isolation/check_move_unevictable_pages,
811
		 * we see PG_mlocked/AS_UNEVICTABLE cleared below and move
812 813
		 * the page back to the evictable list.
		 *
814
		 * The other side is TestClearPageMlocked() or shmem_lock().
815 816
		 */
		smp_mb();
L
Lee Schermerhorn 已提交
817 818 819 820 821 822 823
	}

	/*
	 * page's status can change while we move it among lru. If an evictable
	 * page is on unevictable list, it never be freed. To avoid that,
	 * check after we added it to the list, again.
	 */
824
	if (is_unevictable && page_evictable(page)) {
L
Lee Schermerhorn 已提交
825 826 827 828 829 830 831 832 833 834
		if (!isolate_lru_page(page)) {
			put_page(page);
			goto redo;
		}
		/* This means someone else dropped this page from LRU
		 * So, it will be freed or putback to LRU again. There is
		 * nothing to do here.
		 */
	}

835
	if (was_unevictable && !is_unevictable)
836
		count_vm_event(UNEVICTABLE_PGRESCUED);
837
	else if (!was_unevictable && is_unevictable)
838 839
		count_vm_event(UNEVICTABLE_PGCULLED);

L
Lee Schermerhorn 已提交
840 841 842
	put_page(page);		/* drop ref from isolate */
}

843 844 845
enum page_references {
	PAGEREF_RECLAIM,
	PAGEREF_RECLAIM_CLEAN,
846
	PAGEREF_KEEP,
847 848 849 850 851 852
	PAGEREF_ACTIVATE,
};

static enum page_references page_check_references(struct page *page,
						  struct scan_control *sc)
{
853
	int referenced_ptes, referenced_page;
854 855
	unsigned long vm_flags;

856 857
	referenced_ptes = page_referenced(page, 1, sc->target_mem_cgroup,
					  &vm_flags);
858
	referenced_page = TestClearPageReferenced(page);
859 860 861 862 863 864 865 866

	/*
	 * Mlock lost the isolation race with us.  Let try_to_unmap()
	 * move the page to the unevictable list.
	 */
	if (vm_flags & VM_LOCKED)
		return PAGEREF_RECLAIM;

867
	if (referenced_ptes) {
868
		if (PageSwapBacked(page))
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
			return PAGEREF_ACTIVATE;
		/*
		 * All mapped pages start out with page table
		 * references from the instantiating fault, so we need
		 * to look twice if a mapped file page is used more
		 * than once.
		 *
		 * Mark it and spare it for another trip around the
		 * inactive list.  Another page table reference will
		 * lead to its activation.
		 *
		 * Note: the mark is set for activated pages as well
		 * so that recently deactivated but used pages are
		 * quickly recovered.
		 */
		SetPageReferenced(page);

886
		if (referenced_page || referenced_ptes > 1)
887 888
			return PAGEREF_ACTIVATE;

889 890 891 892 893 894
		/*
		 * Activate file-backed executable pages after first usage.
		 */
		if (vm_flags & VM_EXEC)
			return PAGEREF_ACTIVATE;

895 896
		return PAGEREF_KEEP;
	}
897 898

	/* Reclaim if clean, defer dirty pages to writeback */
899
	if (referenced_page && !PageSwapBacked(page))
900 901 902
		return PAGEREF_RECLAIM_CLEAN;

	return PAGEREF_RECLAIM;
903 904
}

905 906 907 908
/* Check if a page is dirty or under writeback */
static void page_check_dirty_writeback(struct page *page,
				       bool *dirty, bool *writeback)
{
909 910
	struct address_space *mapping;

911 912 913 914
	/*
	 * Anonymous pages are not handled by flushers and must be written
	 * from reclaim context. Do not stall reclaim based on them
	 */
S
Shaohua Li 已提交
915 916
	if (!page_is_file_cache(page) ||
	    (PageAnon(page) && !PageSwapBacked(page))) {
917 918 919 920 921 922 923 924
		*dirty = false;
		*writeback = false;
		return;
	}

	/* By default assume that the page flags are accurate */
	*dirty = PageDirty(page);
	*writeback = PageWriteback(page);
925 926 927 928 929 930 931 932

	/* Verify dirty/writeback state if the filesystem supports it */
	if (!page_has_private(page))
		return;

	mapping = page_mapping(page);
	if (mapping && mapping->a_ops->is_dirty_writeback)
		mapping->a_ops->is_dirty_writeback(page, dirty, writeback);
933 934
}

935 936 937 938 939 940
struct reclaim_stat {
	unsigned nr_dirty;
	unsigned nr_unqueued_dirty;
	unsigned nr_congested;
	unsigned nr_writeback;
	unsigned nr_immediate;
941 942 943
	unsigned nr_activate;
	unsigned nr_ref_keep;
	unsigned nr_unmap_fail;
944 945
};

L
Linus Torvalds 已提交
946
/*
A
Andrew Morton 已提交
947
 * shrink_page_list() returns the number of reclaimed pages
L
Linus Torvalds 已提交
948
 */
A
Andrew Morton 已提交
949
static unsigned long shrink_page_list(struct list_head *page_list,
M
Mel Gorman 已提交
950
				      struct pglist_data *pgdat,
951
				      struct scan_control *sc,
952
				      enum ttu_flags ttu_flags,
953
				      struct reclaim_stat *stat,
954
				      bool force_reclaim)
L
Linus Torvalds 已提交
955 956
{
	LIST_HEAD(ret_pages);
957
	LIST_HEAD(free_pages);
L
Linus Torvalds 已提交
958
	int pgactivate = 0;
959 960 961 962 963 964
	unsigned nr_unqueued_dirty = 0;
	unsigned nr_dirty = 0;
	unsigned nr_congested = 0;
	unsigned nr_reclaimed = 0;
	unsigned nr_writeback = 0;
	unsigned nr_immediate = 0;
965 966
	unsigned nr_ref_keep = 0;
	unsigned nr_unmap_fail = 0;
L
Linus Torvalds 已提交
967 968 969 970 971 972 973

	cond_resched();

	while (!list_empty(page_list)) {
		struct address_space *mapping;
		struct page *page;
		int may_enter_fs;
974
		enum page_references references = PAGEREF_RECLAIM_CLEAN;
975
		bool dirty, writeback;
L
Linus Torvalds 已提交
976 977 978 979 980 981

		cond_resched();

		page = lru_to_page(page_list);
		list_del(&page->lru);

N
Nick Piggin 已提交
982
		if (!trylock_page(page))
L
Linus Torvalds 已提交
983 984
			goto keep;

985
		VM_BUG_ON_PAGE(PageActive(page), page);
L
Linus Torvalds 已提交
986 987

		sc->nr_scanned++;
988

989
		if (unlikely(!page_evictable(page)))
M
Minchan Kim 已提交
990
			goto activate_locked;
L
Lee Schermerhorn 已提交
991

992
		if (!sc->may_unmap && page_mapped(page))
993 994
			goto keep_locked;

L
Linus Torvalds 已提交
995
		/* Double the slab pressure for mapped and swapcache pages */
S
Shaohua Li 已提交
996 997
		if ((page_mapped(page) || PageSwapCache(page)) &&
		    !(PageAnon(page) && !PageSwapBacked(page)))
L
Linus Torvalds 已提交
998 999
			sc->nr_scanned++;

1000 1001 1002
		may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
			(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
		/*
		 * The number of dirty pages determines if a zone is marked
		 * reclaim_congested which affects wait_iff_congested. kswapd
		 * will stall and start writing pages if the tail of the LRU
		 * is all dirty unqueued pages.
		 */
		page_check_dirty_writeback(page, &dirty, &writeback);
		if (dirty || writeback)
			nr_dirty++;

		if (dirty && !writeback)
			nr_unqueued_dirty++;

1016 1017 1018 1019 1020 1021
		/*
		 * Treat this page as congested if the underlying BDI is or if
		 * pages are cycling through the LRU so quickly that the
		 * pages marked for immediate reclaim are making it to the
		 * end of the LRU a second time.
		 */
1022
		mapping = page_mapping(page);
1023
		if (((dirty || writeback) && mapping &&
1024
		     inode_write_congested(mapping->host)) ||
1025
		    (writeback && PageReclaim(page)))
1026 1027
			nr_congested++;

1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
		/*
		 * If a page at the tail of the LRU is under writeback, there
		 * are three cases to consider.
		 *
		 * 1) If reclaim is encountering an excessive number of pages
		 *    under writeback and this page is both under writeback and
		 *    PageReclaim then it indicates that pages are being queued
		 *    for IO but are being recycled through the LRU before the
		 *    IO can complete. Waiting on the page itself risks an
		 *    indefinite stall if it is impossible to writeback the
		 *    page due to IO error or disconnected storage so instead
1039 1040
		 *    note that the LRU is being scanned too quickly and the
		 *    caller can stall after page list has been processed.
1041
		 *
1042
		 * 2) Global or new memcg reclaim encounters a page that is
1043 1044 1045
		 *    not marked for immediate reclaim, or the caller does not
		 *    have __GFP_FS (or __GFP_IO if it's simply going to swap,
		 *    not to fs). In this case mark the page for immediate
1046
		 *    reclaim and continue scanning.
1047
		 *
1048 1049
		 *    Require may_enter_fs because we would wait on fs, which
		 *    may not have submitted IO yet. And the loop driver might
1050 1051 1052 1053 1054
		 *    enter reclaim, and deadlock if it waits on a page for
		 *    which it is needed to do the write (loop masks off
		 *    __GFP_IO|__GFP_FS for this reason); but more thought
		 *    would probably show more reasons.
		 *
1055
		 * 3) Legacy memcg encounters a page that is already marked
1056 1057 1058 1059
		 *    PageReclaim. memcg does not have any dirty pages
		 *    throttling so we could easily OOM just because too many
		 *    pages are in writeback and there is nothing else to
		 *    reclaim. Wait for the writeback to complete.
1060 1061 1062 1063 1064 1065 1066 1067 1068
		 *
		 * In cases 1) and 2) we activate the pages to get them out of
		 * the way while we continue scanning for clean pages on the
		 * inactive list and refilling from the active list. The
		 * observation here is that waiting for disk writes is more
		 * expensive than potentially causing reloads down the line.
		 * Since they're marked for immediate reclaim, they won't put
		 * memory pressure on the cache working set any longer than it
		 * takes to write them to disk.
1069
		 */
1070
		if (PageWriteback(page)) {
1071 1072 1073
			/* Case 1 above */
			if (current_is_kswapd() &&
			    PageReclaim(page) &&
M
Mel Gorman 已提交
1074
			    test_bit(PGDAT_WRITEBACK, &pgdat->flags)) {
1075
				nr_immediate++;
1076
				goto activate_locked;
1077 1078

			/* Case 2 above */
1079
			} else if (sane_reclaim(sc) ||
1080
			    !PageReclaim(page) || !may_enter_fs) {
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
				/*
				 * This is slightly racy - end_page_writeback()
				 * might have just cleared PageReclaim, then
				 * setting PageReclaim here end up interpreted
				 * as PageReadahead - but that does not matter
				 * enough to care.  What we do want is for this
				 * page to have PageReclaim set next time memcg
				 * reclaim reaches the tests above, so it will
				 * then wait_on_page_writeback() to avoid OOM;
				 * and it's also appropriate in global reclaim.
				 */
				SetPageReclaim(page);
1093
				nr_writeback++;
1094
				goto activate_locked;
1095 1096 1097

			/* Case 3 above */
			} else {
1098
				unlock_page(page);
1099
				wait_on_page_writeback(page);
1100 1101 1102
				/* then go back and try same page again */
				list_add_tail(&page->lru, page_list);
				continue;
1103
			}
1104
		}
L
Linus Torvalds 已提交
1105

1106 1107 1108
		if (!force_reclaim)
			references = page_check_references(page, sc);

1109 1110
		switch (references) {
		case PAGEREF_ACTIVATE:
L
Linus Torvalds 已提交
1111
			goto activate_locked;
1112
		case PAGEREF_KEEP:
1113
			nr_ref_keep++;
1114
			goto keep_locked;
1115 1116 1117 1118
		case PAGEREF_RECLAIM:
		case PAGEREF_RECLAIM_CLEAN:
			; /* try to reclaim the page below */
		}
L
Linus Torvalds 已提交
1119 1120 1121 1122

		/*
		 * Anonymous process memory has backing store?
		 * Try to allocate it some swap space here.
S
Shaohua Li 已提交
1123
		 * Lazyfree page could be freed directly
L
Linus Torvalds 已提交
1124
		 */
S
Shaohua Li 已提交
1125 1126
		if (PageAnon(page) && PageSwapBacked(page) &&
		    !PageSwapCache(page)) {
1127 1128
			if (!(sc->gfp_mask & __GFP_IO))
				goto keep_locked;
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
			if (PageTransHuge(page)) {
				/* cannot split THP, skip it */
				if (!can_split_huge_page(page, NULL))
					goto activate_locked;
				/*
				 * Split pages without a PMD map right
				 * away. Chances are some or all of the
				 * tail pages can be freed without IO.
				 */
				if (!compound_mapcount(page) &&
				    split_huge_page_to_list(page, page_list))
					goto activate_locked;
			}
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
			if (!add_to_swap(page)) {
				if (!PageTransHuge(page))
					goto activate_locked;
				/* Split THP and swap individual base pages */
				if (split_huge_page_to_list(page, page_list))
					goto activate_locked;
				if (!add_to_swap(page))
					goto activate_locked;
			}

			/* XXX: We don't support THP writes */
			if (PageTransHuge(page) &&
				  split_huge_page_to_list(page, page_list)) {
				delete_from_swap_cache(page);
L
Linus Torvalds 已提交
1156
				goto activate_locked;
1157 1158
			}

1159
			may_enter_fs = 1;
L
Linus Torvalds 已提交
1160

1161 1162
			/* Adding to swap updated mapping */
			mapping = page_mapping(page);
1163 1164 1165 1166
		} else if (unlikely(PageTransHuge(page))) {
			/* Split file THP */
			if (split_huge_page_to_list(page, page_list))
				goto keep_locked;
1167
		}
L
Linus Torvalds 已提交
1168

1169 1170
		VM_BUG_ON_PAGE(PageTransHuge(page), page);

L
Linus Torvalds 已提交
1171 1172 1173 1174
		/*
		 * The page is mapped into the page tables of one or more
		 * processes. Try to unmap it here.
		 */
S
Shaohua Li 已提交
1175
		if (page_mapped(page)) {
M
Minchan Kim 已提交
1176
			if (!try_to_unmap(page, ttu_flags | TTU_BATCH_FLUSH)) {
1177
				nr_unmap_fail++;
L
Linus Torvalds 已提交
1178 1179 1180 1181 1182
				goto activate_locked;
			}
		}

		if (PageDirty(page)) {
1183
			/*
1184 1185 1186 1187 1188 1189 1190 1191
			 * Only kswapd can writeback filesystem pages
			 * to avoid risk of stack overflow. But avoid
			 * injecting inefficient single-page IO into
			 * flusher writeback as much as possible: only
			 * write pages when we've encountered many
			 * dirty pages, and when we've already scanned
			 * the rest of the LRU for clean pages and see
			 * the same dirty pages again (PageReclaim).
1192
			 */
1193
			if (page_is_file_cache(page) &&
1194 1195
			    (!current_is_kswapd() || !PageReclaim(page) ||
			     !test_bit(PGDAT_DIRTY, &pgdat->flags))) {
1196 1197 1198 1199 1200 1201
				/*
				 * Immediately reclaim when written back.
				 * Similar in principal to deactivate_page()
				 * except we already have the page isolated
				 * and know it's dirty
				 */
1202
				inc_node_page_state(page, NR_VMSCAN_IMMEDIATE);
1203 1204
				SetPageReclaim(page);

1205
				goto activate_locked;
1206 1207
			}

1208
			if (references == PAGEREF_RECLAIM_CLEAN)
L
Linus Torvalds 已提交
1209
				goto keep_locked;
1210
			if (!may_enter_fs)
L
Linus Torvalds 已提交
1211
				goto keep_locked;
1212
			if (!sc->may_writepage)
L
Linus Torvalds 已提交
1213 1214
				goto keep_locked;

1215 1216 1217 1218 1219 1220
			/*
			 * Page is dirty. Flush the TLB if a writable entry
			 * potentially exists to avoid CPU writes after IO
			 * starts and then write it out here.
			 */
			try_to_unmap_flush_dirty();
1221
			switch (pageout(page, mapping, sc)) {
L
Linus Torvalds 已提交
1222 1223 1224 1225 1226
			case PAGE_KEEP:
				goto keep_locked;
			case PAGE_ACTIVATE:
				goto activate_locked;
			case PAGE_SUCCESS:
1227
				if (PageWriteback(page))
1228
					goto keep;
1229
				if (PageDirty(page))
L
Linus Torvalds 已提交
1230
					goto keep;
1231

L
Linus Torvalds 已提交
1232 1233 1234 1235
				/*
				 * A synchronous write - probably a ramdisk.  Go
				 * ahead and try to reclaim the page.
				 */
N
Nick Piggin 已提交
1236
				if (!trylock_page(page))
L
Linus Torvalds 已提交
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
					goto keep;
				if (PageDirty(page) || PageWriteback(page))
					goto keep_locked;
				mapping = page_mapping(page);
			case PAGE_CLEAN:
				; /* try to free the page below */
			}
		}

		/*
		 * If the page has buffers, try to free the buffer mappings
		 * associated with this page. If we succeed we try to free
		 * the page as well.
		 *
		 * We do this even if the page is PageDirty().
		 * try_to_release_page() does not perform I/O, but it is
		 * possible for a page to have PageDirty set, but it is actually
		 * clean (all its buffers are clean).  This happens if the
		 * buffers were written out directly, with submit_bh(). ext3
L
Lee Schermerhorn 已提交
1256
		 * will do this, as well as the blockdev mapping.
L
Linus Torvalds 已提交
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
		 * try_to_release_page() will discover that cleanness and will
		 * drop the buffers and mark the page clean - it can be freed.
		 *
		 * Rarely, pages can have buffers and no ->mapping.  These are
		 * the pages which were not successfully invalidated in
		 * truncate_complete_page().  We try to drop those buffers here
		 * and if that worked, and the page is no longer mapped into
		 * process address space (page_count == 1) it can be freed.
		 * Otherwise, leave the page on the LRU so it is swappable.
		 */
1267
		if (page_has_private(page)) {
L
Linus Torvalds 已提交
1268 1269
			if (!try_to_release_page(page, sc->gfp_mask))
				goto activate_locked;
N
Nick Piggin 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
			if (!mapping && page_count(page) == 1) {
				unlock_page(page);
				if (put_page_testzero(page))
					goto free_it;
				else {
					/*
					 * rare race with speculative reference.
					 * the speculative reference will free
					 * this page shortly, so we may
					 * increment nr_reclaimed here (and
					 * leave it off the LRU).
					 */
					nr_reclaimed++;
					continue;
				}
			}
L
Linus Torvalds 已提交
1286 1287
		}

S
Shaohua Li 已提交
1288 1289 1290 1291 1292 1293 1294 1295
		if (PageAnon(page) && !PageSwapBacked(page)) {
			/* follow __remove_mapping for reference */
			if (!page_ref_freeze(page, 1))
				goto keep_locked;
			if (PageDirty(page)) {
				page_ref_unfreeze(page, 1);
				goto keep_locked;
			}
L
Linus Torvalds 已提交
1296

S
Shaohua Li 已提交
1297
			count_vm_event(PGLAZYFREED);
1298
			count_memcg_page_event(page, PGLAZYFREED);
S
Shaohua Li 已提交
1299 1300
		} else if (!mapping || !__remove_mapping(mapping, page, true))
			goto keep_locked;
N
Nick Piggin 已提交
1301 1302 1303 1304 1305 1306 1307
		/*
		 * At this point, we have no other references and there is
		 * no way to pick any more up (removed from LRU, removed
		 * from pagecache). Can use non-atomic bitops now (and
		 * we obviously don't have to worry about waking up a process
		 * waiting on the page lock, because there are no references.
		 */
1308
		__ClearPageLocked(page);
N
Nick Piggin 已提交
1309
free_it:
1310
		nr_reclaimed++;
1311 1312 1313 1314 1315 1316

		/*
		 * Is there need to periodically free_page_list? It would
		 * appear not as the counts should be low
		 */
		list_add(&page->lru, &free_pages);
L
Linus Torvalds 已提交
1317 1318 1319
		continue;

activate_locked:
1320
		/* Not a candidate for swapping, so reclaim swap space. */
M
Minchan Kim 已提交
1321 1322
		if (PageSwapCache(page) && (mem_cgroup_swap_full(page) ||
						PageMlocked(page)))
1323
			try_to_free_swap(page);
1324
		VM_BUG_ON_PAGE(PageActive(page), page);
M
Minchan Kim 已提交
1325 1326 1327
		if (!PageMlocked(page)) {
			SetPageActive(page);
			pgactivate++;
1328
			count_memcg_page_event(page, PGACTIVATE);
M
Minchan Kim 已提交
1329
		}
L
Linus Torvalds 已提交
1330 1331 1332 1333
keep_locked:
		unlock_page(page);
keep:
		list_add(&page->lru, &ret_pages);
1334
		VM_BUG_ON_PAGE(PageLRU(page) || PageUnevictable(page), page);
L
Linus Torvalds 已提交
1335
	}
1336

1337
	mem_cgroup_uncharge_list(&free_pages);
1338
	try_to_unmap_flush();
1339
	free_hot_cold_page_list(&free_pages, true);
1340

L
Linus Torvalds 已提交
1341
	list_splice(&ret_pages, page_list);
1342
	count_vm_events(PGACTIVATE, pgactivate);
1343

1344 1345 1346 1347 1348 1349
	if (stat) {
		stat->nr_dirty = nr_dirty;
		stat->nr_congested = nr_congested;
		stat->nr_unqueued_dirty = nr_unqueued_dirty;
		stat->nr_writeback = nr_writeback;
		stat->nr_immediate = nr_immediate;
1350 1351 1352
		stat->nr_activate = pgactivate;
		stat->nr_ref_keep = nr_ref_keep;
		stat->nr_unmap_fail = nr_unmap_fail;
1353
	}
1354
	return nr_reclaimed;
L
Linus Torvalds 已提交
1355 1356
}

1357 1358 1359 1360 1361 1362 1363 1364
unsigned long reclaim_clean_pages_from_list(struct zone *zone,
					    struct list_head *page_list)
{
	struct scan_control sc = {
		.gfp_mask = GFP_KERNEL,
		.priority = DEF_PRIORITY,
		.may_unmap = 1,
	};
1365
	unsigned long ret;
1366 1367 1368 1369
	struct page *page, *next;
	LIST_HEAD(clean_pages);

	list_for_each_entry_safe(page, next, page_list, lru) {
1370
		if (page_is_file_cache(page) && !PageDirty(page) &&
1371
		    !__PageMovable(page)) {
1372 1373 1374 1375 1376
			ClearPageActive(page);
			list_move(&page->lru, &clean_pages);
		}
	}

M
Mel Gorman 已提交
1377
	ret = shrink_page_list(&clean_pages, zone->zone_pgdat, &sc,
S
Shaohua Li 已提交
1378
			TTU_IGNORE_ACCESS, NULL, true);
1379
	list_splice(&clean_pages, page_list);
M
Mel Gorman 已提交
1380
	mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_FILE, -ret);
1381 1382 1383
	return ret;
}

A
Andy Whitcroft 已提交
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
/*
 * Attempt to remove the specified page from its LRU.  Only take this page
 * if it is of the appropriate PageActive status.  Pages which are being
 * freed elsewhere are also ignored.
 *
 * page:	page to consider
 * mode:	one of the LRU isolation modes defined above
 *
 * returns 0 on success, -ve errno on failure.
 */
1394
int __isolate_lru_page(struct page *page, isolate_mode_t mode)
A
Andy Whitcroft 已提交
1395 1396 1397 1398 1399 1400 1401
{
	int ret = -EINVAL;

	/* Only take pages on the LRU. */
	if (!PageLRU(page))
		return ret;

M
Minchan Kim 已提交
1402 1403
	/* Compaction should not handle unevictable pages but CMA can do so */
	if (PageUnevictable(page) && !(mode & ISOLATE_UNEVICTABLE))
L
Lee Schermerhorn 已提交
1404 1405
		return ret;

A
Andy Whitcroft 已提交
1406
	ret = -EBUSY;
K
KAMEZAWA Hiroyuki 已提交
1407

1408 1409 1410 1411 1412 1413 1414 1415
	/*
	 * To minimise LRU disruption, the caller can indicate that it only
	 * wants to isolate pages it will be able to operate on without
	 * blocking - clean pages for the most part.
	 *
	 * ISOLATE_ASYNC_MIGRATE is used to indicate that it only wants to pages
	 * that it is possible to migrate without blocking
	 */
1416
	if (mode & ISOLATE_ASYNC_MIGRATE) {
1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
		/* All the caller can do on PageWriteback is block */
		if (PageWriteback(page))
			return ret;

		if (PageDirty(page)) {
			struct address_space *mapping;

			/*
			 * Only pages without mappings or that have a
			 * ->migratepage callback are possible to migrate
			 * without blocking
			 */
			mapping = page_mapping(page);
			if (mapping && !mapping->a_ops->migratepage)
				return ret;
		}
	}
1434

1435 1436 1437
	if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
		return ret;

A
Andy Whitcroft 已提交
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
	if (likely(get_page_unless_zero(page))) {
		/*
		 * Be careful not to clear PageLRU until after we're
		 * sure the page is not being freed elsewhere -- the
		 * page release code relies on it.
		 */
		ClearPageLRU(page);
		ret = 0;
	}

	return ret;
}

1451 1452 1453 1454 1455 1456

/*
 * Update LRU sizes after isolating pages. The LRU size updates must
 * be complete before mem_cgroup_update_lru_size due to a santity check.
 */
static __always_inline void update_lru_sizes(struct lruvec *lruvec,
1457
			enum lru_list lru, unsigned long *nr_zone_taken)
1458 1459 1460 1461 1462 1463 1464 1465 1466
{
	int zid;

	for (zid = 0; zid < MAX_NR_ZONES; zid++) {
		if (!nr_zone_taken[zid])
			continue;

		__update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
#ifdef CONFIG_MEMCG
1467
		mem_cgroup_update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
1468
#endif
1469 1470
	}

1471 1472
}

L
Linus Torvalds 已提交
1473
/*
1474
 * zone_lru_lock is heavily contended.  Some of the functions that
L
Linus Torvalds 已提交
1475 1476 1477 1478 1479 1480 1481 1482
 * shrink the lists perform better by taking out a batch of pages
 * and working on them outside the LRU lock.
 *
 * For pagecache intensive workloads, this function is the hottest
 * spot in the kernel (apart from copy_*_user functions).
 *
 * Appropriate locks must be held before calling this function.
 *
1483
 * @nr_to_scan:	The number of eligible pages to look through on the list.
1484
 * @lruvec:	The LRU vector to pull pages from.
L
Linus Torvalds 已提交
1485
 * @dst:	The temp list to put pages on to.
H
Hugh Dickins 已提交
1486
 * @nr_scanned:	The number of pages that were scanned.
1487
 * @sc:		The scan_control struct for this reclaim session
A
Andy Whitcroft 已提交
1488
 * @mode:	One of the LRU isolation modes
1489
 * @lru:	LRU list id for isolating
L
Linus Torvalds 已提交
1490 1491 1492
 *
 * returns how many pages were moved onto *@dst.
 */
1493
static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
1494
		struct lruvec *lruvec, struct list_head *dst,
1495
		unsigned long *nr_scanned, struct scan_control *sc,
1496
		isolate_mode_t mode, enum lru_list lru)
L
Linus Torvalds 已提交
1497
{
H
Hugh Dickins 已提交
1498
	struct list_head *src = &lruvec->lists[lru];
1499
	unsigned long nr_taken = 0;
M
Mel Gorman 已提交
1500
	unsigned long nr_zone_taken[MAX_NR_ZONES] = { 0 };
1501
	unsigned long nr_skipped[MAX_NR_ZONES] = { 0, };
1502
	unsigned long skipped = 0;
1503
	unsigned long scan, total_scan, nr_pages;
1504
	LIST_HEAD(pages_skipped);
L
Linus Torvalds 已提交
1505

1506 1507 1508 1509
	scan = 0;
	for (total_scan = 0;
	     scan < nr_to_scan && nr_taken < nr_to_scan && !list_empty(src);
	     total_scan++) {
A
Andy Whitcroft 已提交
1510 1511
		struct page *page;

L
Linus Torvalds 已提交
1512 1513 1514
		page = lru_to_page(src);
		prefetchw_prev_lru_page(page, src, flags);

1515
		VM_BUG_ON_PAGE(!PageLRU(page), page);
N
Nick Piggin 已提交
1516

1517 1518
		if (page_zonenum(page) > sc->reclaim_idx) {
			list_move(&page->lru, &pages_skipped);
1519
			nr_skipped[page_zonenum(page)]++;
1520 1521 1522
			continue;
		}

1523 1524 1525 1526 1527 1528 1529
		/*
		 * Do not count skipped pages because that makes the function
		 * return with no isolated pages if the LRU mostly contains
		 * ineligible pages.  This causes the VM to not reclaim any
		 * pages, triggering a premature OOM.
		 */
		scan++;
1530
		switch (__isolate_lru_page(page, mode)) {
A
Andy Whitcroft 已提交
1531
		case 0:
M
Mel Gorman 已提交
1532 1533 1534
			nr_pages = hpage_nr_pages(page);
			nr_taken += nr_pages;
			nr_zone_taken[page_zonenum(page)] += nr_pages;
A
Andy Whitcroft 已提交
1535 1536 1537 1538 1539 1540 1541
			list_move(&page->lru, dst);
			break;

		case -EBUSY:
			/* else it is being freed elsewhere */
			list_move(&page->lru, src);
			continue;
1542

A
Andy Whitcroft 已提交
1543 1544 1545
		default:
			BUG();
		}
L
Linus Torvalds 已提交
1546 1547
	}

1548 1549 1550 1551 1552 1553 1554
	/*
	 * Splice any skipped pages to the start of the LRU list. Note that
	 * this disrupts the LRU order when reclaiming for lower zones but
	 * we cannot splice to the tail. If we did then the SWAP_CLUSTER_MAX
	 * scanning would soon rescan the same pages to skip and put the
	 * system at risk of premature OOM.
	 */
1555 1556 1557
	if (!list_empty(&pages_skipped)) {
		int zid;

1558
		list_splice(&pages_skipped, src);
1559 1560 1561 1562 1563
		for (zid = 0; zid < MAX_NR_ZONES; zid++) {
			if (!nr_skipped[zid])
				continue;

			__count_zid_vm_events(PGSCAN_SKIP, zid, nr_skipped[zid]);
1564
			skipped += nr_skipped[zid];
1565 1566
		}
	}
1567
	*nr_scanned = total_scan;
1568
	trace_mm_vmscan_lru_isolate(sc->reclaim_idx, sc->order, nr_to_scan,
1569
				    total_scan, skipped, nr_taken, mode, lru);
1570
	update_lru_sizes(lruvec, lru, nr_zone_taken);
L
Linus Torvalds 已提交
1571 1572 1573
	return nr_taken;
}

1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
/**
 * isolate_lru_page - tries to isolate a page from its LRU list
 * @page: page to isolate from its LRU list
 *
 * Isolates a @page from an LRU list, clears PageLRU and adjusts the
 * vmstat statistic corresponding to whatever LRU list the page was on.
 *
 * Returns 0 if the page was removed from an LRU list.
 * Returns -EBUSY if the page was not on an LRU list.
 *
 * The returned page will have PageLRU() cleared.  If it was found on
L
Lee Schermerhorn 已提交
1585 1586 1587
 * the active list, it will have PageActive set.  If it was found on
 * the unevictable list, it will have the PageUnevictable bit set. That flag
 * may need to be cleared by the caller before letting the page go.
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602
 *
 * The vmstat statistic corresponding to the list on which the page was
 * found will be decremented.
 *
 * Restrictions:
 * (1) Must be called with an elevated refcount on the page. This is a
 *     fundamentnal difference from isolate_lru_pages (which is called
 *     without a stable reference).
 * (2) the lru_lock must not be held.
 * (3) interrupts must be enabled.
 */
int isolate_lru_page(struct page *page)
{
	int ret = -EBUSY;

1603
	VM_BUG_ON_PAGE(!page_count(page), page);
1604
	WARN_RATELIMIT(PageTail(page), "trying to isolate tail page");
1605

1606 1607
	if (PageLRU(page)) {
		struct zone *zone = page_zone(page);
1608
		struct lruvec *lruvec;
1609

1610
		spin_lock_irq(zone_lru_lock(zone));
M
Mel Gorman 已提交
1611
		lruvec = mem_cgroup_page_lruvec(page, zone->zone_pgdat);
1612
		if (PageLRU(page)) {
L
Lee Schermerhorn 已提交
1613
			int lru = page_lru(page);
1614
			get_page(page);
1615
			ClearPageLRU(page);
1616 1617
			del_page_from_lru_list(page, lruvec, lru);
			ret = 0;
1618
		}
1619
		spin_unlock_irq(zone_lru_lock(zone));
1620 1621 1622 1623
	}
	return ret;
}

1624
/*
F
Fengguang Wu 已提交
1625 1626 1627 1628 1629
 * A direct reclaimer may isolate SWAP_CLUSTER_MAX pages from the LRU list and
 * then get resheduled. When there are massive number of tasks doing page
 * allocation, such sleeping direct reclaimers may keep piling up on each CPU,
 * the LRU list will go small and be scanned faster than necessary, leading to
 * unnecessary swapping, thrashing and OOM.
1630
 */
M
Mel Gorman 已提交
1631
static int too_many_isolated(struct pglist_data *pgdat, int file,
1632 1633 1634 1635 1636 1637 1638
		struct scan_control *sc)
{
	unsigned long inactive, isolated;

	if (current_is_kswapd())
		return 0;

1639
	if (!sane_reclaim(sc))
1640 1641 1642
		return 0;

	if (file) {
M
Mel Gorman 已提交
1643 1644
		inactive = node_page_state(pgdat, NR_INACTIVE_FILE);
		isolated = node_page_state(pgdat, NR_ISOLATED_FILE);
1645
	} else {
M
Mel Gorman 已提交
1646 1647
		inactive = node_page_state(pgdat, NR_INACTIVE_ANON);
		isolated = node_page_state(pgdat, NR_ISOLATED_ANON);
1648 1649
	}

1650 1651 1652 1653 1654
	/*
	 * GFP_NOIO/GFP_NOFS callers are allowed to isolate more pages, so they
	 * won't get blocked by normal direct-reclaimers, forming a circular
	 * deadlock.
	 */
1655
	if ((sc->gfp_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
1656 1657
		inactive >>= 3;

1658 1659 1660
	return isolated > inactive;
}

1661
static noinline_for_stack void
H
Hugh Dickins 已提交
1662
putback_inactive_pages(struct lruvec *lruvec, struct list_head *page_list)
1663
{
1664
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
M
Mel Gorman 已提交
1665
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1666
	LIST_HEAD(pages_to_free);
1667 1668 1669 1670 1671

	/*
	 * Put back any unfreeable pages.
	 */
	while (!list_empty(page_list)) {
1672
		struct page *page = lru_to_page(page_list);
1673
		int lru;
1674

1675
		VM_BUG_ON_PAGE(PageLRU(page), page);
1676
		list_del(&page->lru);
1677
		if (unlikely(!page_evictable(page))) {
M
Mel Gorman 已提交
1678
			spin_unlock_irq(&pgdat->lru_lock);
1679
			putback_lru_page(page);
M
Mel Gorman 已提交
1680
			spin_lock_irq(&pgdat->lru_lock);
1681 1682
			continue;
		}
1683

M
Mel Gorman 已提交
1684
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
1685

1686
		SetPageLRU(page);
1687
		lru = page_lru(page);
1688 1689
		add_page_to_lru_list(page, lruvec, lru);

1690 1691
		if (is_active_lru(lru)) {
			int file = is_file_lru(lru);
1692 1693
			int numpages = hpage_nr_pages(page);
			reclaim_stat->recent_rotated[file] += numpages;
1694
		}
1695 1696 1697
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
1698
			del_page_from_lru_list(page, lruvec, lru);
1699 1700

			if (unlikely(PageCompound(page))) {
M
Mel Gorman 已提交
1701
				spin_unlock_irq(&pgdat->lru_lock);
1702
				mem_cgroup_uncharge(page);
1703
				(*get_compound_page_dtor(page))(page);
M
Mel Gorman 已提交
1704
				spin_lock_irq(&pgdat->lru_lock);
1705 1706
			} else
				list_add(&page->lru, &pages_to_free);
1707 1708 1709
		}
	}

1710 1711 1712 1713
	/*
	 * To save our caller's stack, now use input list for pages to free.
	 */
	list_splice(&pages_to_free, page_list);
1714 1715
}

1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
/*
 * If a kernel thread (such as nfsd for loop-back mounts) services
 * a backing device by writing to the page cache it sets PF_LESS_THROTTLE.
 * In that case we should only throttle if the backing device it is
 * writing to is congested.  In other cases it is safe to throttle.
 */
static int current_may_throttle(void)
{
	return !(current->flags & PF_LESS_THROTTLE) ||
		current->backing_dev_info == NULL ||
		bdi_write_congested(current->backing_dev_info);
}

L
Linus Torvalds 已提交
1729
/*
1730
 * shrink_inactive_list() is a helper for shrink_node().  It returns the number
A
Andrew Morton 已提交
1731
 * of reclaimed pages
L
Linus Torvalds 已提交
1732
 */
1733
static noinline_for_stack unsigned long
1734
shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
1735
		     struct scan_control *sc, enum lru_list lru)
L
Linus Torvalds 已提交
1736 1737
{
	LIST_HEAD(page_list);
1738
	unsigned long nr_scanned;
1739
	unsigned long nr_reclaimed = 0;
1740
	unsigned long nr_taken;
1741
	struct reclaim_stat stat = {};
1742
	isolate_mode_t isolate_mode = 0;
1743
	int file = is_file_lru(lru);
M
Mel Gorman 已提交
1744
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1745
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1746
	bool stalled = false;
1747

M
Mel Gorman 已提交
1748
	while (unlikely(too_many_isolated(pgdat, file, sc))) {
1749 1750 1751 1752 1753 1754
		if (stalled)
			return 0;

		/* wait a bit for the reclaimer. */
		msleep(100);
		stalled = true;
1755 1756 1757 1758 1759 1760

		/* We are about to die and free our memory. Return now. */
		if (fatal_signal_pending(current))
			return SWAP_CLUSTER_MAX;
	}

L
Linus Torvalds 已提交
1761
	lru_add_drain();
1762 1763

	if (!sc->may_unmap)
1764
		isolate_mode |= ISOLATE_UNMAPPED;
1765

M
Mel Gorman 已提交
1766
	spin_lock_irq(&pgdat->lru_lock);
1767

1768 1769
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &page_list,
				     &nr_scanned, sc, isolate_mode, lru);
1770

M
Mel Gorman 已提交
1771
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1772
	reclaim_stat->recent_scanned[file] += nr_taken;
1773

1774 1775
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1776
			__count_vm_events(PGSCAN_KSWAPD, nr_scanned);
1777 1778 1779 1780
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_KSWAPD,
				   nr_scanned);
	} else {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1781
			__count_vm_events(PGSCAN_DIRECT, nr_scanned);
1782 1783
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_DIRECT,
				   nr_scanned);
1784
	}
M
Mel Gorman 已提交
1785
	spin_unlock_irq(&pgdat->lru_lock);
1786

1787
	if (nr_taken == 0)
1788
		return 0;
A
Andy Whitcroft 已提交
1789

S
Shaohua Li 已提交
1790
	nr_reclaimed = shrink_page_list(&page_list, pgdat, sc, 0,
1791
				&stat, false);
1792

M
Mel Gorman 已提交
1793
	spin_lock_irq(&pgdat->lru_lock);
1794

1795 1796
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1797
			__count_vm_events(PGSTEAL_KSWAPD, nr_reclaimed);
1798 1799 1800 1801
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_KSWAPD,
				   nr_reclaimed);
	} else {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1802
			__count_vm_events(PGSTEAL_DIRECT, nr_reclaimed);
1803 1804
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_DIRECT,
				   nr_reclaimed);
Y
Ying Han 已提交
1805
	}
N
Nick Piggin 已提交
1806

1807
	putback_inactive_pages(lruvec, &page_list);
1808

M
Mel Gorman 已提交
1809
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
1810

M
Mel Gorman 已提交
1811
	spin_unlock_irq(&pgdat->lru_lock);
1812

1813
	mem_cgroup_uncharge_list(&page_list);
1814
	free_hot_cold_page_list(&page_list, true);
1815

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
	/*
	 * If reclaim is isolating dirty pages under writeback, it implies
	 * that the long-lived page allocation rate is exceeding the page
	 * laundering rate. Either the global limits are not being effective
	 * at throttling processes due to the page distribution throughout
	 * zones or there is heavy usage of a slow backing device. The
	 * only option is to throttle from reclaim context which is not ideal
	 * as there is no guarantee the dirtying process is throttled in the
	 * same way balance_dirty_pages() manages.
	 *
1826 1827 1828
	 * Once a zone is flagged ZONE_WRITEBACK, kswapd will count the number
	 * of pages under pages flagged for immediate reclaim and stall if any
	 * are encountered in the nr_immediate check below.
1829
	 */
1830
	if (stat.nr_writeback && stat.nr_writeback == nr_taken)
M
Mel Gorman 已提交
1831
		set_bit(PGDAT_WRITEBACK, &pgdat->flags);
1832

1833
	/*
1834 1835
	 * Legacy memcg will stall in page writeback so avoid forcibly
	 * stalling here.
1836
	 */
1837
	if (sane_reclaim(sc)) {
1838 1839 1840 1841
		/*
		 * Tag a zone as congested if all the dirty pages scanned were
		 * backed by a congested BDI and wait_iff_congested will stall.
		 */
1842
		if (stat.nr_dirty && stat.nr_dirty == stat.nr_congested)
M
Mel Gorman 已提交
1843
			set_bit(PGDAT_CONGESTED, &pgdat->flags);
1844

1845 1846
		/*
		 * If dirty pages are scanned that are not queued for IO, it
1847 1848 1849 1850 1851 1852 1853 1854 1855
		 * implies that flushers are not doing their job. This can
		 * happen when memory pressure pushes dirty pages to the end of
		 * the LRU before the dirty limits are breached and the dirty
		 * data has expired. It can also happen when the proportion of
		 * dirty pages grows not through writes but through memory
		 * pressure reclaiming all the clean cache. And in some cases,
		 * the flushers simply cannot keep up with the allocation
		 * rate. Nudge the flusher threads in case they are asleep, but
		 * also allow kswapd to start writing pages during reclaim.
1856
		 */
1857 1858
		if (stat.nr_unqueued_dirty == nr_taken) {
			wakeup_flusher_threads(0, WB_REASON_VMSCAN);
M
Mel Gorman 已提交
1859
			set_bit(PGDAT_DIRTY, &pgdat->flags);
1860
		}
1861 1862

		/*
1863 1864 1865
		 * If kswapd scans pages marked marked for immediate
		 * reclaim and under writeback (nr_immediate), it implies
		 * that pages are cycling through the LRU faster than
1866 1867
		 * they are written so also forcibly stall.
		 */
1868
		if (stat.nr_immediate && current_may_throttle())
1869
			congestion_wait(BLK_RW_ASYNC, HZ/10);
1870
	}
1871

1872 1873 1874 1875 1876
	/*
	 * Stall direct reclaim for IO completions if underlying BDIs or zone
	 * is congested. Allow kswapd to continue until it starts encountering
	 * unqueued dirty pages or cycling through the LRU too quickly.
	 */
1877 1878
	if (!sc->hibernation_mode && !current_is_kswapd() &&
	    current_may_throttle())
M
Mel Gorman 已提交
1879
		wait_iff_congested(pgdat, BLK_RW_ASYNC, HZ/10);
1880

M
Mel Gorman 已提交
1881 1882
	trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
			nr_scanned, nr_reclaimed,
1883 1884 1885 1886
			stat.nr_dirty,  stat.nr_writeback,
			stat.nr_congested, stat.nr_immediate,
			stat.nr_activate, stat.nr_ref_keep,
			stat.nr_unmap_fail,
1887
			sc->priority, file);
1888
	return nr_reclaimed;
L
Linus Torvalds 已提交
1889 1890 1891 1892 1893 1894 1895 1896 1897
}

/*
 * This moves pages from the active list to the inactive list.
 *
 * We move them the other way if the page is referenced by one or more
 * processes, from rmap.
 *
 * If the pages are mostly unmapped, the processing is fast and it is
1898
 * appropriate to hold zone_lru_lock across the whole operation.  But if
L
Linus Torvalds 已提交
1899
 * the pages are mapped, the processing is slow (page_referenced()) so we
1900
 * should drop zone_lru_lock around each page.  It's impossible to balance
L
Linus Torvalds 已提交
1901 1902 1903 1904
 * this, so instead we remove the pages from the LRU while processing them.
 * It is safe to rely on PG_active against the non-LRU pages in here because
 * nobody will play with that bit on a non-LRU page.
 *
1905
 * The downside is that we have to touch page->_refcount against each page.
L
Linus Torvalds 已提交
1906
 * But we had to alter page->flags anyway.
1907 1908
 *
 * Returns the number of pages moved to the given lru.
L
Linus Torvalds 已提交
1909
 */
1910

1911
static unsigned move_active_pages_to_lru(struct lruvec *lruvec,
1912
				     struct list_head *list,
1913
				     struct list_head *pages_to_free,
1914 1915
				     enum lru_list lru)
{
M
Mel Gorman 已提交
1916
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1917
	struct page *page;
1918
	int nr_pages;
1919
	int nr_moved = 0;
1920 1921 1922

	while (!list_empty(list)) {
		page = lru_to_page(list);
M
Mel Gorman 已提交
1923
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
1924

1925
		VM_BUG_ON_PAGE(PageLRU(page), page);
1926 1927
		SetPageLRU(page);

1928
		nr_pages = hpage_nr_pages(page);
M
Mel Gorman 已提交
1929
		update_lru_size(lruvec, lru, page_zonenum(page), nr_pages);
1930
		list_move(&page->lru, &lruvec->lists[lru]);
1931

1932 1933 1934
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
1935
			del_page_from_lru_list(page, lruvec, lru);
1936 1937

			if (unlikely(PageCompound(page))) {
M
Mel Gorman 已提交
1938
				spin_unlock_irq(&pgdat->lru_lock);
1939
				mem_cgroup_uncharge(page);
1940
				(*get_compound_page_dtor(page))(page);
M
Mel Gorman 已提交
1941
				spin_lock_irq(&pgdat->lru_lock);
1942 1943
			} else
				list_add(&page->lru, pages_to_free);
1944 1945
		} else {
			nr_moved += nr_pages;
1946 1947
		}
	}
1948

1949
	if (!is_active_lru(lru)) {
1950
		__count_vm_events(PGDEACTIVATE, nr_moved);
1951 1952 1953
		count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE,
				   nr_moved);
	}
1954 1955

	return nr_moved;
1956
}
1957

H
Hugh Dickins 已提交
1958
static void shrink_active_list(unsigned long nr_to_scan,
1959
			       struct lruvec *lruvec,
1960
			       struct scan_control *sc,
1961
			       enum lru_list lru)
L
Linus Torvalds 已提交
1962
{
1963
	unsigned long nr_taken;
H
Hugh Dickins 已提交
1964
	unsigned long nr_scanned;
1965
	unsigned long vm_flags;
L
Linus Torvalds 已提交
1966
	LIST_HEAD(l_hold);	/* The pages which were snipped off */
1967
	LIST_HEAD(l_active);
1968
	LIST_HEAD(l_inactive);
L
Linus Torvalds 已提交
1969
	struct page *page;
1970
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1971 1972
	unsigned nr_deactivate, nr_activate;
	unsigned nr_rotated = 0;
1973
	isolate_mode_t isolate_mode = 0;
1974
	int file = is_file_lru(lru);
M
Mel Gorman 已提交
1975
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
L
Linus Torvalds 已提交
1976 1977

	lru_add_drain();
1978 1979

	if (!sc->may_unmap)
1980
		isolate_mode |= ISOLATE_UNMAPPED;
1981

M
Mel Gorman 已提交
1982
	spin_lock_irq(&pgdat->lru_lock);
1983

1984 1985
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &l_hold,
				     &nr_scanned, sc, isolate_mode, lru);
1986

M
Mel Gorman 已提交
1987
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1988
	reclaim_stat->recent_scanned[file] += nr_taken;
1989

M
Mel Gorman 已提交
1990
	__count_vm_events(PGREFILL, nr_scanned);
1991
	count_memcg_events(lruvec_memcg(lruvec), PGREFILL, nr_scanned);
1992

M
Mel Gorman 已提交
1993
	spin_unlock_irq(&pgdat->lru_lock);
L
Linus Torvalds 已提交
1994 1995 1996 1997 1998

	while (!list_empty(&l_hold)) {
		cond_resched();
		page = lru_to_page(&l_hold);
		list_del(&page->lru);
1999

2000
		if (unlikely(!page_evictable(page))) {
L
Lee Schermerhorn 已提交
2001 2002 2003 2004
			putback_lru_page(page);
			continue;
		}

2005 2006 2007 2008 2009 2010 2011 2012
		if (unlikely(buffer_heads_over_limit)) {
			if (page_has_private(page) && trylock_page(page)) {
				if (page_has_private(page))
					try_to_release_page(page, 0);
				unlock_page(page);
			}
		}

2013 2014
		if (page_referenced(page, 0, sc->target_mem_cgroup,
				    &vm_flags)) {
2015
			nr_rotated += hpage_nr_pages(page);
2016 2017 2018 2019 2020 2021 2022 2023 2024
			/*
			 * Identify referenced, file-backed active pages and
			 * give them one more trip around the active list. So
			 * that executable code get better chances to stay in
			 * memory under moderate memory pressure.  Anon pages
			 * are not likely to be evicted by use-once streaming
			 * IO, plus JVM can create lots of anon VM_EXEC pages,
			 * so we ignore them here.
			 */
2025
			if ((vm_flags & VM_EXEC) && page_is_file_cache(page)) {
2026 2027 2028 2029
				list_add(&page->lru, &l_active);
				continue;
			}
		}
2030

2031
		ClearPageActive(page);	/* we are de-activating */
L
Linus Torvalds 已提交
2032 2033 2034
		list_add(&page->lru, &l_inactive);
	}

2035
	/*
2036
	 * Move pages back to the lru list.
2037
	 */
M
Mel Gorman 已提交
2038
	spin_lock_irq(&pgdat->lru_lock);
2039
	/*
2040 2041 2042
	 * Count referenced pages from currently used mappings as rotated,
	 * even though only some of them are actually re-activated.  This
	 * helps balance scan pressure between file and anonymous pages in
2043
	 * get_scan_count.
2044
	 */
2045
	reclaim_stat->recent_rotated[file] += nr_rotated;
2046

2047 2048
	nr_activate = move_active_pages_to_lru(lruvec, &l_active, &l_hold, lru);
	nr_deactivate = move_active_pages_to_lru(lruvec, &l_inactive, &l_hold, lru - LRU_ACTIVE);
M
Mel Gorman 已提交
2049 2050
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
	spin_unlock_irq(&pgdat->lru_lock);
2051

2052
	mem_cgroup_uncharge_list(&l_hold);
2053
	free_hot_cold_page_list(&l_hold, true);
2054 2055
	trace_mm_vmscan_lru_shrink_active(pgdat->node_id, nr_taken, nr_activate,
			nr_deactivate, nr_rotated, sc->priority, file);
L
Linus Torvalds 已提交
2056 2057
}

2058 2059 2060
/*
 * The inactive anon list should be small enough that the VM never has
 * to do too much work.
2061
 *
2062 2063 2064
 * The inactive file list should be small enough to leave most memory
 * to the established workingset on the scan-resistant active list,
 * but large enough to avoid thrashing the aggregate readahead window.
2065
 *
2066 2067
 * Both inactive lists should also be large enough that each inactive
 * page has a chance to be referenced again before it is reclaimed.
2068
 *
2069 2070
 * If that fails and refaulting is observed, the inactive list grows.
 *
2071 2072 2073
 * The inactive_ratio is the target ratio of ACTIVE to INACTIVE pages
 * on this LRU, maintained by the pageout code. A zone->inactive_ratio
 * of 3 means 3:1 or 25% of the pages are kept on the inactive list.
2074
 *
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
 * total     target    max
 * memory    ratio     inactive
 * -------------------------------------
 *   10MB       1         5MB
 *  100MB       1        50MB
 *    1GB       3       250MB
 *   10GB      10       0.9GB
 *  100GB      31         3GB
 *    1TB     101        10GB
 *   10TB     320        32GB
2085
 */
2086
static bool inactive_list_is_low(struct lruvec *lruvec, bool file,
2087 2088
				 struct mem_cgroup *memcg,
				 struct scan_control *sc, bool actual_reclaim)
2089
{
2090
	enum lru_list active_lru = file * LRU_FILE + LRU_ACTIVE;
2091 2092 2093 2094 2095
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
	enum lru_list inactive_lru = file * LRU_FILE;
	unsigned long inactive, active;
	unsigned long inactive_ratio;
	unsigned long refaults;
2096
	unsigned long gb;
2097

2098 2099 2100 2101 2102 2103
	/*
	 * If we don't have swap space, anonymous page deactivation
	 * is pointless.
	 */
	if (!file && !total_swap_pages)
		return false;
2104

2105 2106
	inactive = lruvec_lru_size(lruvec, inactive_lru, sc->reclaim_idx);
	active = lruvec_lru_size(lruvec, active_lru, sc->reclaim_idx);
2107

2108
	if (memcg)
2109
		refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
2110
	else
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
		refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);

	/*
	 * When refaults are being observed, it means a new workingset
	 * is being established. Disable active list protection to get
	 * rid of the stale workingset quickly.
	 */
	if (file && actual_reclaim && lruvec->refaults != refaults) {
		inactive_ratio = 0;
	} else {
		gb = (inactive + active) >> (30 - PAGE_SHIFT);
		if (gb)
			inactive_ratio = int_sqrt(10 * gb);
		else
			inactive_ratio = 1;
	}
2127

2128 2129 2130 2131 2132
	if (actual_reclaim)
		trace_mm_vmscan_inactive_list_is_low(pgdat->node_id, sc->reclaim_idx,
			lruvec_lru_size(lruvec, inactive_lru, MAX_NR_ZONES), inactive,
			lruvec_lru_size(lruvec, active_lru, MAX_NR_ZONES), active,
			inactive_ratio, file);
2133

2134
	return inactive * inactive_ratio < active;
2135 2136
}

2137
static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
2138 2139
				 struct lruvec *lruvec, struct mem_cgroup *memcg,
				 struct scan_control *sc)
2140
{
2141
	if (is_active_lru(lru)) {
2142 2143
		if (inactive_list_is_low(lruvec, is_file_lru(lru),
					 memcg, sc, true))
2144
			shrink_active_list(nr_to_scan, lruvec, sc, lru);
2145 2146 2147
		return 0;
	}

2148
	return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);
2149 2150
}

2151 2152 2153 2154 2155 2156 2157
enum scan_balance {
	SCAN_EQUAL,
	SCAN_FRACT,
	SCAN_ANON,
	SCAN_FILE,
};

2158 2159 2160 2161 2162 2163
/*
 * Determine how aggressively the anon and file LRU lists should be
 * scanned.  The relative value of each set of LRU lists is determined
 * by looking at the fraction of the pages scanned we did rotate back
 * onto the active list instead of evict.
 *
W
Wanpeng Li 已提交
2164 2165
 * nr[0] = anon inactive pages to scan; nr[1] = anon active pages to scan
 * nr[2] = file inactive pages to scan; nr[3] = file active pages to scan
2166
 */
2167
static void get_scan_count(struct lruvec *lruvec, struct mem_cgroup *memcg,
2168 2169
			   struct scan_control *sc, unsigned long *nr,
			   unsigned long *lru_pages)
2170
{
2171
	int swappiness = mem_cgroup_swappiness(memcg);
2172 2173 2174
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
	u64 fraction[2];
	u64 denominator = 0;	/* gcc */
M
Mel Gorman 已提交
2175
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2176
	unsigned long anon_prio, file_prio;
2177
	enum scan_balance scan_balance;
2178
	unsigned long anon, file;
2179
	unsigned long ap, fp;
H
Hugh Dickins 已提交
2180
	enum lru_list lru;
2181 2182

	/* If we have no swap space, do not bother scanning anon pages. */
2183
	if (!sc->may_swap || mem_cgroup_get_nr_swap_pages(memcg) <= 0) {
2184
		scan_balance = SCAN_FILE;
2185 2186
		goto out;
	}
2187

2188 2189 2190 2191 2192 2193 2194
	/*
	 * Global reclaim will swap to prevent OOM even with no
	 * swappiness, but memcg users want to use this knob to
	 * disable swapping for individual groups completely when
	 * using the memory controller's swap limit feature would be
	 * too expensive.
	 */
2195
	if (!global_reclaim(sc) && !swappiness) {
2196
		scan_balance = SCAN_FILE;
2197 2198 2199 2200 2201 2202 2203 2204
		goto out;
	}

	/*
	 * Do not apply any pressure balancing cleverness when the
	 * system is close to OOM, scan both anon and file equally
	 * (unless the swappiness setting disagrees with swapping).
	 */
2205
	if (!sc->priority && swappiness) {
2206
		scan_balance = SCAN_EQUAL;
2207 2208 2209
		goto out;
	}

2210 2211 2212 2213 2214 2215 2216 2217 2218 2219
	/*
	 * Prevent the reclaimer from falling into the cache trap: as
	 * cache pages start out inactive, every cache fault will tip
	 * the scan balance towards the file LRU.  And as the file LRU
	 * shrinks, so does the window for rotation from references.
	 * This means we have a runaway feedback loop where a tiny
	 * thrashing file LRU becomes infinitely more attractive than
	 * anon pages.  Try to detect this based on file LRU size.
	 */
	if (global_reclaim(sc)) {
M
Mel Gorman 已提交
2220 2221 2222 2223
		unsigned long pgdatfile;
		unsigned long pgdatfree;
		int z;
		unsigned long total_high_wmark = 0;
2224

M
Mel Gorman 已提交
2225 2226 2227 2228 2229 2230
		pgdatfree = sum_zone_node_page_state(pgdat->node_id, NR_FREE_PAGES);
		pgdatfile = node_page_state(pgdat, NR_ACTIVE_FILE) +
			   node_page_state(pgdat, NR_INACTIVE_FILE);

		for (z = 0; z < MAX_NR_ZONES; z++) {
			struct zone *zone = &pgdat->node_zones[z];
2231
			if (!managed_zone(zone))
M
Mel Gorman 已提交
2232 2233 2234 2235
				continue;

			total_high_wmark += high_wmark_pages(zone);
		}
2236

M
Mel Gorman 已提交
2237
		if (unlikely(pgdatfile + pgdatfree <= total_high_wmark)) {
2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
			/*
			 * Force SCAN_ANON if there are enough inactive
			 * anonymous pages on the LRU in eligible zones.
			 * Otherwise, the small LRU gets thrashed.
			 */
			if (!inactive_list_is_low(lruvec, false, memcg, sc, false) &&
			    lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, sc->reclaim_idx)
					>> sc->priority) {
				scan_balance = SCAN_ANON;
				goto out;
			}
2249 2250 2251
		}
	}

2252
	/*
2253 2254 2255 2256 2257 2258 2259
	 * If there is enough inactive page cache, i.e. if the size of the
	 * inactive list is greater than that of the active list *and* the
	 * inactive list actually has some pages to scan on this priority, we
	 * do not reclaim anything from the anonymous working set right now.
	 * Without the second condition we could end up never scanning an
	 * lruvec even if it has plenty of old anonymous pages unless the
	 * system is under heavy pressure.
2260
	 */
2261
	if (!inactive_list_is_low(lruvec, true, memcg, sc, false) &&
2262
	    lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
2263
		scan_balance = SCAN_FILE;
2264 2265 2266
		goto out;
	}

2267 2268
	scan_balance = SCAN_FRACT;

2269 2270 2271 2272
	/*
	 * With swappiness at 100, anonymous and file have the same priority.
	 * This scanning priority is essentially the inverse of IO cost.
	 */
2273
	anon_prio = swappiness;
H
Hugh Dickins 已提交
2274
	file_prio = 200 - anon_prio;
2275

2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
	/*
	 * OK, so we have swap space and a fair amount of page cache
	 * pages.  We use the recently rotated / recently scanned
	 * ratios to determine how valuable each cache is.
	 *
	 * Because workloads change over time (and to avoid overflow)
	 * we keep these statistics as a floating average, which ends
	 * up weighing recent references more than old ones.
	 *
	 * anon in [0], file in [1]
	 */
2287

2288 2289 2290 2291
	anon  = lruvec_lru_size(lruvec, LRU_ACTIVE_ANON, MAX_NR_ZONES) +
		lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, MAX_NR_ZONES);
	file  = lruvec_lru_size(lruvec, LRU_ACTIVE_FILE, MAX_NR_ZONES) +
		lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, MAX_NR_ZONES);
2292

M
Mel Gorman 已提交
2293
	spin_lock_irq(&pgdat->lru_lock);
2294 2295 2296
	if (unlikely(reclaim_stat->recent_scanned[0] > anon / 4)) {
		reclaim_stat->recent_scanned[0] /= 2;
		reclaim_stat->recent_rotated[0] /= 2;
2297 2298
	}

2299 2300 2301
	if (unlikely(reclaim_stat->recent_scanned[1] > file / 4)) {
		reclaim_stat->recent_scanned[1] /= 2;
		reclaim_stat->recent_rotated[1] /= 2;
2302 2303 2304
	}

	/*
2305 2306 2307
	 * The amount of pressure on anon vs file pages is inversely
	 * proportional to the fraction of recently scanned pages on
	 * each list that were recently referenced and in active use.
2308
	 */
2309
	ap = anon_prio * (reclaim_stat->recent_scanned[0] + 1);
2310
	ap /= reclaim_stat->recent_rotated[0] + 1;
2311

2312
	fp = file_prio * (reclaim_stat->recent_scanned[1] + 1);
2313
	fp /= reclaim_stat->recent_rotated[1] + 1;
M
Mel Gorman 已提交
2314
	spin_unlock_irq(&pgdat->lru_lock);
2315

2316 2317 2318 2319
	fraction[0] = ap;
	fraction[1] = fp;
	denominator = ap + fp + 1;
out:
2320 2321 2322 2323 2324
	*lru_pages = 0;
	for_each_evictable_lru(lru) {
		int file = is_file_lru(lru);
		unsigned long size;
		unsigned long scan;
2325

2326 2327 2328 2329 2330 2331 2332 2333
		size = lruvec_lru_size(lruvec, lru, sc->reclaim_idx);
		scan = size >> sc->priority;
		/*
		 * If the cgroup's already been deleted, make sure to
		 * scrape out the remaining cache.
		 */
		if (!scan && !mem_cgroup_online(memcg))
			scan = min(size, SWAP_CLUSTER_MAX);
2334

2335 2336 2337 2338 2339
		switch (scan_balance) {
		case SCAN_EQUAL:
			/* Scan lists relative to size */
			break;
		case SCAN_FRACT:
2340
			/*
2341 2342
			 * Scan types proportional to swappiness and
			 * their relative recent reclaim efficiency.
2343
			 */
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
			scan = div64_u64(scan * fraction[file],
					 denominator);
			break;
		case SCAN_FILE:
		case SCAN_ANON:
			/* Scan one type exclusively */
			if ((scan_balance == SCAN_FILE) != file) {
				size = 0;
				scan = 0;
			}
			break;
		default:
			/* Look ma, no brain */
			BUG();
2358
		}
2359 2360 2361

		*lru_pages += size;
		nr[lru] = scan;
2362
	}
2363
}
2364

2365
/*
2366
 * This is a basic per-node page freer.  Used by both kswapd and direct reclaim.
2367
 */
2368
static void shrink_node_memcg(struct pglist_data *pgdat, struct mem_cgroup *memcg,
2369
			      struct scan_control *sc, unsigned long *lru_pages)
2370
{
2371
	struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
2372
	unsigned long nr[NR_LRU_LISTS];
2373
	unsigned long targets[NR_LRU_LISTS];
2374 2375 2376 2377 2378
	unsigned long nr_to_scan;
	enum lru_list lru;
	unsigned long nr_reclaimed = 0;
	unsigned long nr_to_reclaim = sc->nr_to_reclaim;
	struct blk_plug plug;
2379
	bool scan_adjusted;
2380

2381
	get_scan_count(lruvec, memcg, sc, nr, lru_pages);
2382

2383 2384 2385
	/* Record the original scan target for proportional adjustments later */
	memcpy(targets, nr, sizeof(nr));

2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399
	/*
	 * Global reclaiming within direct reclaim at DEF_PRIORITY is a normal
	 * event that can occur when there is little memory pressure e.g.
	 * multiple streaming readers/writers. Hence, we do not abort scanning
	 * when the requested number of pages are reclaimed when scanning at
	 * DEF_PRIORITY on the assumption that the fact we are direct
	 * reclaiming implies that kswapd is not keeping up and it is best to
	 * do a batch of work at once. For memcg reclaim one check is made to
	 * abort proportional reclaim if either the file or anon lru has already
	 * dropped to zero at the first pass.
	 */
	scan_adjusted = (global_reclaim(sc) && !current_is_kswapd() &&
			 sc->priority == DEF_PRIORITY);

2400 2401 2402
	blk_start_plug(&plug);
	while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
					nr[LRU_INACTIVE_FILE]) {
2403 2404 2405
		unsigned long nr_anon, nr_file, percentage;
		unsigned long nr_scanned;

2406 2407 2408 2409 2410 2411
		for_each_evictable_lru(lru) {
			if (nr[lru]) {
				nr_to_scan = min(nr[lru], SWAP_CLUSTER_MAX);
				nr[lru] -= nr_to_scan;

				nr_reclaimed += shrink_list(lru, nr_to_scan,
2412
							    lruvec, memcg, sc);
2413 2414
			}
		}
2415

2416 2417
		cond_resched();

2418 2419 2420 2421 2422
		if (nr_reclaimed < nr_to_reclaim || scan_adjusted)
			continue;

		/*
		 * For kswapd and memcg, reclaim at least the number of pages
2423
		 * requested. Ensure that the anon and file LRUs are scanned
2424 2425 2426 2427 2428 2429 2430
		 * proportionally what was requested by get_scan_count(). We
		 * stop reclaiming one LRU and reduce the amount scanning
		 * proportional to the original scan target.
		 */
		nr_file = nr[LRU_INACTIVE_FILE] + nr[LRU_ACTIVE_FILE];
		nr_anon = nr[LRU_INACTIVE_ANON] + nr[LRU_ACTIVE_ANON];

2431 2432 2433 2434 2435 2436 2437 2438 2439
		/*
		 * It's just vindictive to attack the larger once the smaller
		 * has gone to zero.  And given the way we stop scanning the
		 * smaller below, this makes sure that we only make one nudge
		 * towards proportionality once we've got nr_to_reclaim.
		 */
		if (!nr_file || !nr_anon)
			break;

2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470
		if (nr_file > nr_anon) {
			unsigned long scan_target = targets[LRU_INACTIVE_ANON] +
						targets[LRU_ACTIVE_ANON] + 1;
			lru = LRU_BASE;
			percentage = nr_anon * 100 / scan_target;
		} else {
			unsigned long scan_target = targets[LRU_INACTIVE_FILE] +
						targets[LRU_ACTIVE_FILE] + 1;
			lru = LRU_FILE;
			percentage = nr_file * 100 / scan_target;
		}

		/* Stop scanning the smaller of the LRU */
		nr[lru] = 0;
		nr[lru + LRU_ACTIVE] = 0;

		/*
		 * Recalculate the other LRU scan count based on its original
		 * scan target and the percentage scanning already complete
		 */
		lru = (lru == LRU_FILE) ? LRU_BASE : LRU_FILE;
		nr_scanned = targets[lru] - nr[lru];
		nr[lru] = targets[lru] * (100 - percentage) / 100;
		nr[lru] -= min(nr[lru], nr_scanned);

		lru += LRU_ACTIVE;
		nr_scanned = targets[lru] - nr[lru];
		nr[lru] = targets[lru] * (100 - percentage) / 100;
		nr[lru] -= min(nr[lru], nr_scanned);

		scan_adjusted = true;
2471 2472 2473 2474 2475 2476 2477 2478
	}
	blk_finish_plug(&plug);
	sc->nr_reclaimed += nr_reclaimed;

	/*
	 * Even if we did not try to evict anon pages at all, we want to
	 * rebalance the anon lru active/inactive ratio.
	 */
2479
	if (inactive_list_is_low(lruvec, false, memcg, sc, true))
2480 2481 2482 2483
		shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
				   sc, LRU_ACTIVE_ANON);
}

M
Mel Gorman 已提交
2484
/* Use reclaim/compaction for costly allocs or under memory pressure */
2485
static bool in_reclaim_compaction(struct scan_control *sc)
M
Mel Gorman 已提交
2486
{
2487
	if (IS_ENABLED(CONFIG_COMPACTION) && sc->order &&
M
Mel Gorman 已提交
2488
			(sc->order > PAGE_ALLOC_COSTLY_ORDER ||
2489
			 sc->priority < DEF_PRIORITY - 2))
M
Mel Gorman 已提交
2490 2491 2492 2493 2494
		return true;

	return false;
}

2495
/*
M
Mel Gorman 已提交
2496 2497 2498 2499 2500
 * Reclaim/compaction is used for high-order allocation requests. It reclaims
 * order-0 pages before compacting the zone. should_continue_reclaim() returns
 * true if more pages should be reclaimed such that when the page allocator
 * calls try_to_compact_zone() that it will have enough free pages to succeed.
 * It will give up earlier than that if there is difficulty reclaiming pages.
2501
 */
2502
static inline bool should_continue_reclaim(struct pglist_data *pgdat,
2503 2504 2505 2506 2507 2508
					unsigned long nr_reclaimed,
					unsigned long nr_scanned,
					struct scan_control *sc)
{
	unsigned long pages_for_compaction;
	unsigned long inactive_lru_pages;
2509
	int z;
2510 2511

	/* If not in reclaim/compaction mode, stop */
2512
	if (!in_reclaim_compaction(sc))
2513 2514
		return false;

2515
	/* Consider stopping depending on scan and reclaim activity */
2516
	if (sc->gfp_mask & __GFP_RETRY_MAYFAIL) {
2517
		/*
2518
		 * For __GFP_RETRY_MAYFAIL allocations, stop reclaiming if the
2519 2520
		 * full LRU list has been scanned and we are still failing
		 * to reclaim pages. This full LRU scan is potentially
2521
		 * expensive but a __GFP_RETRY_MAYFAIL caller really wants to succeed
2522 2523 2524 2525 2526
		 */
		if (!nr_reclaimed && !nr_scanned)
			return false;
	} else {
		/*
2527
		 * For non-__GFP_RETRY_MAYFAIL allocations which can presumably
2528 2529 2530 2531 2532 2533 2534 2535 2536
		 * fail without consequence, stop if we failed to reclaim
		 * any pages from the last SWAP_CLUSTER_MAX number of
		 * pages that were scanned. This will return to the
		 * caller faster at the risk reclaim/compaction and
		 * the resulting allocation attempt fails
		 */
		if (!nr_reclaimed)
			return false;
	}
2537 2538 2539 2540 2541

	/*
	 * If we have not reclaimed enough pages for compaction and the
	 * inactive lists are large enough, continue reclaiming
	 */
2542
	pages_for_compaction = compact_gap(sc->order);
2543
	inactive_lru_pages = node_page_state(pgdat, NR_INACTIVE_FILE);
2544
	if (get_nr_swap_pages() > 0)
2545
		inactive_lru_pages += node_page_state(pgdat, NR_INACTIVE_ANON);
2546 2547 2548 2549 2550
	if (sc->nr_reclaimed < pages_for_compaction &&
			inactive_lru_pages > pages_for_compaction)
		return true;

	/* If compaction would go ahead or the allocation would succeed, stop */
2551 2552
	for (z = 0; z <= sc->reclaim_idx; z++) {
		struct zone *zone = &pgdat->node_zones[z];
2553
		if (!managed_zone(zone))
2554 2555 2556
			continue;

		switch (compaction_suitable(zone, sc->order, 0, sc->reclaim_idx)) {
2557
		case COMPACT_SUCCESS:
2558 2559 2560 2561 2562 2563
		case COMPACT_CONTINUE:
			return false;
		default:
			/* check next zone */
			;
		}
2564
	}
2565
	return true;
2566 2567
}

2568
static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc)
L
Linus Torvalds 已提交
2569
{
2570
	struct reclaim_state *reclaim_state = current->reclaim_state;
2571
	unsigned long nr_reclaimed, nr_scanned;
2572
	bool reclaimable = false;
L
Linus Torvalds 已提交
2573

2574 2575 2576
	do {
		struct mem_cgroup *root = sc->target_mem_cgroup;
		struct mem_cgroup_reclaim_cookie reclaim = {
2577
			.pgdat = pgdat,
2578 2579
			.priority = sc->priority,
		};
2580
		unsigned long node_lru_pages = 0;
2581
		struct mem_cgroup *memcg;
2582

2583 2584
		nr_reclaimed = sc->nr_reclaimed;
		nr_scanned = sc->nr_scanned;
L
Linus Torvalds 已提交
2585

2586 2587
		memcg = mem_cgroup_iter(root, NULL, &reclaim);
		do {
2588
			unsigned long lru_pages;
2589
			unsigned long reclaimed;
2590
			unsigned long scanned;
2591

2592
			if (mem_cgroup_low(root, memcg)) {
2593 2594
				if (!sc->memcg_low_reclaim) {
					sc->memcg_low_skipped = 1;
2595
					continue;
2596
				}
2597
				mem_cgroup_event(memcg, MEMCG_LOW);
2598 2599
			}

2600
			reclaimed = sc->nr_reclaimed;
2601
			scanned = sc->nr_scanned;
2602

2603 2604
			shrink_node_memcg(pgdat, memcg, sc, &lru_pages);
			node_lru_pages += lru_pages;
2605

2606
			if (memcg)
2607
				shrink_slab(sc->gfp_mask, pgdat->node_id,
2608 2609 2610
					    memcg, sc->nr_scanned - scanned,
					    lru_pages);

2611 2612 2613 2614 2615
			/* Record the group's reclaim efficiency */
			vmpressure(sc->gfp_mask, memcg, false,
				   sc->nr_scanned - scanned,
				   sc->nr_reclaimed - reclaimed);

2616
			/*
2617 2618
			 * Direct reclaim and kswapd have to scan all memory
			 * cgroups to fulfill the overall scan target for the
2619
			 * node.
2620 2621 2622 2623 2624
			 *
			 * Limit reclaim, on the other hand, only cares about
			 * nr_to_reclaim pages to be reclaimed and it will
			 * retry with decreasing priority if one round over the
			 * whole hierarchy is not sufficient.
2625
			 */
2626 2627
			if (!global_reclaim(sc) &&
					sc->nr_reclaimed >= sc->nr_to_reclaim) {
2628 2629 2630
				mem_cgroup_iter_break(root, memcg);
				break;
			}
2631
		} while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));
2632

2633 2634 2635 2636
		/*
		 * Shrink the slab caches in the same proportion that
		 * the eligible LRU pages were scanned.
		 */
2637
		if (global_reclaim(sc))
2638
			shrink_slab(sc->gfp_mask, pgdat->node_id, NULL,
2639
				    sc->nr_scanned - nr_scanned,
2640
				    node_lru_pages);
2641 2642 2643 2644

		if (reclaim_state) {
			sc->nr_reclaimed += reclaim_state->reclaimed_slab;
			reclaim_state->reclaimed_slab = 0;
2645 2646
		}

2647 2648
		/* Record the subtree's reclaim efficiency */
		vmpressure(sc->gfp_mask, sc->target_mem_cgroup, true,
2649 2650 2651
			   sc->nr_scanned - nr_scanned,
			   sc->nr_reclaimed - nr_reclaimed);

2652 2653 2654
		if (sc->nr_reclaimed - nr_reclaimed)
			reclaimable = true;

2655
	} while (should_continue_reclaim(pgdat, sc->nr_reclaimed - nr_reclaimed,
2656
					 sc->nr_scanned - nr_scanned, sc));
2657

2658 2659 2660 2661 2662 2663 2664 2665 2666
	/*
	 * Kswapd gives up on balancing particular nodes after too
	 * many failures to reclaim anything from them and goes to
	 * sleep. On reclaim progress, reset the failure counter. A
	 * successful direct reclaim run will revive a dormant kswapd.
	 */
	if (reclaimable)
		pgdat->kswapd_failures = 0;

2667
	return reclaimable;
2668 2669
}

2670
/*
2671 2672 2673
 * Returns true if compaction should go ahead for a costly-order request, or
 * the allocation would already succeed without compaction. Return false if we
 * should reclaim first.
2674
 */
2675
static inline bool compaction_ready(struct zone *zone, struct scan_control *sc)
2676
{
M
Mel Gorman 已提交
2677
	unsigned long watermark;
2678
	enum compact_result suitable;
2679

2680 2681 2682 2683 2684 2685 2686
	suitable = compaction_suitable(zone, sc->order, 0, sc->reclaim_idx);
	if (suitable == COMPACT_SUCCESS)
		/* Allocation should succeed already. Don't reclaim. */
		return true;
	if (suitable == COMPACT_SKIPPED)
		/* Compaction cannot yet proceed. Do reclaim. */
		return false;
2687

2688
	/*
2689 2690 2691 2692 2693 2694 2695
	 * Compaction is already possible, but it takes time to run and there
	 * are potentially other callers using the pages just freed. So proceed
	 * with reclaim to make a buffer of free pages available to give
	 * compaction a reasonable chance of completing and allocating the page.
	 * Note that we won't actually reclaim the whole buffer in one attempt
	 * as the target watermark in should_continue_reclaim() is lower. But if
	 * we are already above the high+gap watermark, don't reclaim at all.
2696
	 */
2697
	watermark = high_wmark_pages(zone) + compact_gap(sc->order);
2698

2699
	return zone_watermark_ok_safe(zone, 0, watermark, sc->reclaim_idx);
2700 2701
}

L
Linus Torvalds 已提交
2702 2703 2704 2705 2706 2707 2708 2709
/*
 * This is the direct reclaim path, for page-allocating processes.  We only
 * try to reclaim pages from zones which will satisfy the caller's allocation
 * request.
 *
 * If a zone is deemed to be full of pinned pages then just give it a light
 * scan then give up on it.
 */
M
Michal Hocko 已提交
2710
static void shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
L
Linus Torvalds 已提交
2711
{
2712
	struct zoneref *z;
2713
	struct zone *zone;
2714 2715
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
2716
	gfp_t orig_mask;
2717
	pg_data_t *last_pgdat = NULL;
2718

2719 2720 2721 2722 2723
	/*
	 * If the number of buffer_heads in the machine exceeds the maximum
	 * allowed level, force direct reclaim to scan the highmem zone as
	 * highmem pages could be pinning lowmem pages storing buffer_heads
	 */
2724
	orig_mask = sc->gfp_mask;
2725
	if (buffer_heads_over_limit) {
2726
		sc->gfp_mask |= __GFP_HIGHMEM;
2727
		sc->reclaim_idx = gfp_zone(sc->gfp_mask);
2728
	}
2729

2730
	for_each_zone_zonelist_nodemask(zone, z, zonelist,
2731
					sc->reclaim_idx, sc->nodemask) {
2732 2733 2734 2735
		/*
		 * Take care memory controller reclaiming has small influence
		 * to global LRU.
		 */
2736
		if (global_reclaim(sc)) {
2737 2738
			if (!cpuset_zone_allowed(zone,
						 GFP_KERNEL | __GFP_HARDWALL))
2739
				continue;
2740

2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751
			/*
			 * If we already have plenty of memory free for
			 * compaction in this zone, don't free any more.
			 * Even though compaction is invoked for any
			 * non-zero order, only frequent costly order
			 * reclamation is disruptive enough to become a
			 * noticeable problem, like transparent huge
			 * page allocations.
			 */
			if (IS_ENABLED(CONFIG_COMPACTION) &&
			    sc->order > PAGE_ALLOC_COSTLY_ORDER &&
2752
			    compaction_ready(zone, sc)) {
2753 2754
				sc->compaction_ready = true;
				continue;
2755
			}
2756

2757 2758 2759 2760 2761 2762 2763 2764 2765
			/*
			 * Shrink each node in the zonelist once. If the
			 * zonelist is ordered by zone (not the default) then a
			 * node may be shrunk multiple times but in that case
			 * the user prefers lower zones being preserved.
			 */
			if (zone->zone_pgdat == last_pgdat)
				continue;

2766 2767 2768 2769 2770 2771 2772
			/*
			 * This steals pages from memory cgroups over softlimit
			 * and returns the number of reclaimed pages and
			 * scanned pages. This works for global memory pressure
			 * and balancing, not for a memcg's limit.
			 */
			nr_soft_scanned = 0;
2773
			nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone->zone_pgdat,
2774 2775 2776 2777
						sc->order, sc->gfp_mask,
						&nr_soft_scanned);
			sc->nr_reclaimed += nr_soft_reclaimed;
			sc->nr_scanned += nr_soft_scanned;
2778
			/* need some check for avoid more shrink_zone() */
2779
		}
2780

2781 2782 2783 2784
		/* See comment about same check for global reclaim above */
		if (zone->zone_pgdat == last_pgdat)
			continue;
		last_pgdat = zone->zone_pgdat;
2785
		shrink_node(zone->zone_pgdat, sc);
L
Linus Torvalds 已提交
2786
	}
2787

2788 2789 2790 2791 2792
	/*
	 * Restore to original mask to avoid the impact on the caller if we
	 * promoted it to __GFP_HIGHMEM.
	 */
	sc->gfp_mask = orig_mask;
L
Linus Torvalds 已提交
2793
}
2794

2795 2796 2797 2798 2799 2800 2801 2802 2803 2804
static void snapshot_refaults(struct mem_cgroup *root_memcg, pg_data_t *pgdat)
{
	struct mem_cgroup *memcg;

	memcg = mem_cgroup_iter(root_memcg, NULL, NULL);
	do {
		unsigned long refaults;
		struct lruvec *lruvec;

		if (memcg)
2805
			refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
2806 2807 2808 2809 2810 2811 2812 2813
		else
			refaults = node_page_state(pgdat, WORKINGSET_ACTIVATE);

		lruvec = mem_cgroup_lruvec(pgdat, memcg);
		lruvec->refaults = refaults;
	} while ((memcg = mem_cgroup_iter(root_memcg, memcg, NULL)));
}

L
Linus Torvalds 已提交
2814 2815 2816 2817 2818 2819 2820 2821
/*
 * This is the main entry point to direct page reclaim.
 *
 * If a full scan of the inactive list fails to free enough memory then we
 * are "out of memory" and something needs to be killed.
 *
 * If the caller is !__GFP_FS then the probability of a failure is reasonably
 * high - the zone may be full of dirty or under-writeback pages, which this
2822 2823 2824 2825
 * caller can't do much about.  We kick the writeback threads and take explicit
 * naps in the hope that some of these pages can be written.  But if the
 * allocating task holds filesystem locks which prevent writeout this might not
 * work, and the allocation attempt will fail.
2826 2827 2828
 *
 * returns:	0, if no pages reclaimed
 * 		else, the number of pages reclaimed
L
Linus Torvalds 已提交
2829
 */
2830
static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
2831
					  struct scan_control *sc)
L
Linus Torvalds 已提交
2832
{
2833
	int initial_priority = sc->priority;
2834 2835 2836
	pg_data_t *last_pgdat;
	struct zoneref *z;
	struct zone *zone;
2837
retry:
2838 2839
	delayacct_freepages_start();

2840
	if (global_reclaim(sc))
2841
		__count_zid_vm_events(ALLOCSTALL, sc->reclaim_idx, 1);
L
Linus Torvalds 已提交
2842

2843
	do {
2844 2845
		vmpressure_prio(sc->gfp_mask, sc->target_mem_cgroup,
				sc->priority);
2846
		sc->nr_scanned = 0;
M
Michal Hocko 已提交
2847
		shrink_zones(zonelist, sc);
2848

2849
		if (sc->nr_reclaimed >= sc->nr_to_reclaim)
2850 2851 2852 2853
			break;

		if (sc->compaction_ready)
			break;
L
Linus Torvalds 已提交
2854

2855 2856 2857 2858 2859 2860
		/*
		 * If we're getting trouble reclaiming, start doing
		 * writepage even in laptop mode.
		 */
		if (sc->priority < DEF_PRIORITY - 2)
			sc->may_writepage = 1;
2861
	} while (--sc->priority >= 0);
2862

2863 2864 2865 2866 2867 2868 2869 2870 2871
	last_pgdat = NULL;
	for_each_zone_zonelist_nodemask(zone, z, zonelist, sc->reclaim_idx,
					sc->nodemask) {
		if (zone->zone_pgdat == last_pgdat)
			continue;
		last_pgdat = zone->zone_pgdat;
		snapshot_refaults(sc->target_mem_cgroup, zone->zone_pgdat);
	}

2872 2873
	delayacct_freepages_end();

2874 2875 2876
	if (sc->nr_reclaimed)
		return sc->nr_reclaimed;

2877
	/* Aborted reclaim to try compaction? don't OOM, then */
2878
	if (sc->compaction_ready)
2879 2880
		return 1;

2881
	/* Untapped cgroup reserves?  Don't OOM, retry. */
2882
	if (sc->memcg_low_skipped) {
2883
		sc->priority = initial_priority;
2884 2885
		sc->memcg_low_reclaim = 1;
		sc->memcg_low_skipped = 0;
2886 2887 2888
		goto retry;
	}

2889
	return 0;
L
Linus Torvalds 已提交
2890 2891
}

2892
static bool allow_direct_reclaim(pg_data_t *pgdat)
2893 2894 2895 2896 2897 2898 2899
{
	struct zone *zone;
	unsigned long pfmemalloc_reserve = 0;
	unsigned long free_pages = 0;
	int i;
	bool wmark_ok;

2900 2901 2902
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

2903 2904
	for (i = 0; i <= ZONE_NORMAL; i++) {
		zone = &pgdat->node_zones[i];
2905 2906 2907 2908
		if (!managed_zone(zone))
			continue;

		if (!zone_reclaimable_pages(zone))
2909 2910
			continue;

2911 2912 2913 2914
		pfmemalloc_reserve += min_wmark_pages(zone);
		free_pages += zone_page_state(zone, NR_FREE_PAGES);
	}

2915 2916 2917 2918
	/* If there are no reserves (unexpected config) then do not throttle */
	if (!pfmemalloc_reserve)
		return true;

2919 2920 2921 2922
	wmark_ok = free_pages > pfmemalloc_reserve / 2;

	/* kswapd must be awake if processes are being throttled */
	if (!wmark_ok && waitqueue_active(&pgdat->kswapd_wait)) {
2923
		pgdat->kswapd_classzone_idx = min(pgdat->kswapd_classzone_idx,
2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934
						(enum zone_type)ZONE_NORMAL);
		wake_up_interruptible(&pgdat->kswapd_wait);
	}

	return wmark_ok;
}

/*
 * Throttle direct reclaimers if backing storage is backed by the network
 * and the PFMEMALLOC reserve for the preferred node is getting dangerously
 * depleted. kswapd will continue to make progress and wake the processes
2935 2936 2937 2938
 * when the low watermark is reached.
 *
 * Returns true if a fatal signal was delivered during throttling. If this
 * happens, the page allocator should not consider triggering the OOM killer.
2939
 */
2940
static bool throttle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
2941 2942
					nodemask_t *nodemask)
{
2943
	struct zoneref *z;
2944
	struct zone *zone;
2945
	pg_data_t *pgdat = NULL;
2946 2947 2948 2949 2950 2951 2952 2953 2954

	/*
	 * Kernel threads should not be throttled as they may be indirectly
	 * responsible for cleaning pages necessary for reclaim to make forward
	 * progress. kjournald for example may enter direct reclaim while
	 * committing a transaction where throttling it could forcing other
	 * processes to block on log_wait_commit().
	 */
	if (current->flags & PF_KTHREAD)
2955 2956 2957 2958 2959 2960 2961 2962
		goto out;

	/*
	 * If a fatal signal is pending, this process should not throttle.
	 * It should return quickly so it can exit and free its memory
	 */
	if (fatal_signal_pending(current))
		goto out;
2963

2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978
	/*
	 * Check if the pfmemalloc reserves are ok by finding the first node
	 * with a usable ZONE_NORMAL or lower zone. The expectation is that
	 * GFP_KERNEL will be required for allocating network buffers when
	 * swapping over the network so ZONE_HIGHMEM is unusable.
	 *
	 * Throttling is based on the first usable node and throttled processes
	 * wait on a queue until kswapd makes progress and wakes them. There
	 * is an affinity then between processes waking up and where reclaim
	 * progress has been made assuming the process wakes on the same node.
	 * More importantly, processes running on remote nodes will not compete
	 * for remote pfmemalloc reserves and processes on different nodes
	 * should make reasonable progress.
	 */
	for_each_zone_zonelist_nodemask(zone, z, zonelist,
2979
					gfp_zone(gfp_mask), nodemask) {
2980 2981 2982 2983 2984
		if (zone_idx(zone) > ZONE_NORMAL)
			continue;

		/* Throttle based on the first usable node */
		pgdat = zone->zone_pgdat;
2985
		if (allow_direct_reclaim(pgdat))
2986 2987 2988 2989 2990 2991
			goto out;
		break;
	}

	/* If no zone was usable by the allocation flags then do not throttle */
	if (!pgdat)
2992
		goto out;
2993

2994 2995 2996
	/* Account for the throttling */
	count_vm_event(PGSCAN_DIRECT_THROTTLE);

2997 2998 2999 3000 3001 3002 3003 3004 3005 3006
	/*
	 * If the caller cannot enter the filesystem, it's possible that it
	 * is due to the caller holding an FS lock or performing a journal
	 * transaction in the case of a filesystem like ext[3|4]. In this case,
	 * it is not safe to block on pfmemalloc_wait as kswapd could be
	 * blocked waiting on the same lock. Instead, throttle for up to a
	 * second before continuing.
	 */
	if (!(gfp_mask & __GFP_FS)) {
		wait_event_interruptible_timeout(pgdat->pfmemalloc_wait,
3007
			allow_direct_reclaim(pgdat), HZ);
3008 3009

		goto check_pending;
3010 3011 3012 3013
	}

	/* Throttle until kswapd wakes the process */
	wait_event_killable(zone->zone_pgdat->pfmemalloc_wait,
3014
		allow_direct_reclaim(pgdat));
3015 3016 3017 3018 3019 3020 3021

check_pending:
	if (fatal_signal_pending(current))
		return true;

out:
	return false;
3022 3023
}

3024
unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
3025
				gfp_t gfp_mask, nodemask_t *nodemask)
3026
{
3027
	unsigned long nr_reclaimed;
3028
	struct scan_control sc = {
3029
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
3030
		.gfp_mask = current_gfp_context(gfp_mask),
3031
		.reclaim_idx = gfp_zone(gfp_mask),
3032 3033 3034
		.order = order,
		.nodemask = nodemask,
		.priority = DEF_PRIORITY,
3035
		.may_writepage = !laptop_mode,
3036
		.may_unmap = 1,
3037
		.may_swap = 1,
3038 3039
	};

3040
	/*
3041 3042 3043
	 * Do not enter reclaim if fatal signal was delivered while throttled.
	 * 1 is returned so that the page allocator does not OOM kill at this
	 * point.
3044
	 */
3045
	if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
3046 3047
		return 1;

3048 3049
	trace_mm_vmscan_direct_reclaim_begin(order,
				sc.may_writepage,
3050
				sc.gfp_mask,
3051
				sc.reclaim_idx);
3052

3053
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3054 3055 3056 3057

	trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3058 3059
}

A
Andrew Morton 已提交
3060
#ifdef CONFIG_MEMCG
3061

3062
unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
3063
						gfp_t gfp_mask, bool noswap,
3064
						pg_data_t *pgdat,
3065
						unsigned long *nr_scanned)
3066 3067
{
	struct scan_control sc = {
3068
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
3069
		.target_mem_cgroup = memcg,
3070 3071
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3072
		.reclaim_idx = MAX_NR_ZONES - 1,
3073 3074
		.may_swap = !noswap,
	};
3075
	unsigned long lru_pages;
3076

3077 3078
	sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
			(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
3079

3080
	trace_mm_vmscan_memcg_softlimit_reclaim_begin(sc.order,
3081
						      sc.may_writepage,
3082 3083
						      sc.gfp_mask,
						      sc.reclaim_idx);
3084

3085 3086 3087
	/*
	 * NOTE: Although we can get the priority field, using it
	 * here is not a good idea, since it limits the pages we can scan.
3088
	 * if we don't reclaim here, the shrink_node from balance_pgdat
3089 3090 3091
	 * will pick up pages from other mem cgroup's as well. We hack
	 * the priority and make it zero.
	 */
3092
	shrink_node_memcg(pgdat, memcg, &sc, &lru_pages);
3093 3094 3095

	trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);

3096
	*nr_scanned = sc.nr_scanned;
3097 3098 3099
	return sc.nr_reclaimed;
}

3100
unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
3101
					   unsigned long nr_pages,
K
KOSAKI Motohiro 已提交
3102
					   gfp_t gfp_mask,
3103
					   bool may_swap)
3104
{
3105
	struct zonelist *zonelist;
3106
	unsigned long nr_reclaimed;
3107
	int nid;
3108
	unsigned int noreclaim_flag;
3109
	struct scan_control sc = {
3110
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3111
		.gfp_mask = (current_gfp_context(gfp_mask) & GFP_RECLAIM_MASK) |
3112
				(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
3113
		.reclaim_idx = MAX_NR_ZONES - 1,
3114 3115 3116 3117
		.target_mem_cgroup = memcg,
		.priority = DEF_PRIORITY,
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3118
		.may_swap = may_swap,
3119
	};
3120

3121 3122 3123 3124 3125
	/*
	 * Unlike direct reclaim via alloc_pages(), memcg's reclaim doesn't
	 * take care of from where we get pages. So the node where we start the
	 * scan does not need to be the current node.
	 */
3126
	nid = mem_cgroup_select_victim_node(memcg);
3127

3128
	zonelist = &NODE_DATA(nid)->node_zonelists[ZONELIST_FALLBACK];
3129 3130 3131

	trace_mm_vmscan_memcg_reclaim_begin(0,
					    sc.may_writepage,
3132 3133
					    sc.gfp_mask,
					    sc.reclaim_idx);
3134

3135
	noreclaim_flag = memalloc_noreclaim_save();
3136
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3137
	memalloc_noreclaim_restore(noreclaim_flag);
3138 3139 3140 3141

	trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3142 3143 3144
}
#endif

3145
static void age_active_anon(struct pglist_data *pgdat,
3146
				struct scan_control *sc)
3147
{
3148
	struct mem_cgroup *memcg;
3149

3150 3151 3152 3153 3154
	if (!total_swap_pages)
		return;

	memcg = mem_cgroup_iter(NULL, NULL, NULL);
	do {
3155
		struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
3156

3157
		if (inactive_list_is_low(lruvec, false, memcg, sc, true))
3158
			shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
3159
					   sc, LRU_ACTIVE_ANON);
3160 3161 3162

		memcg = mem_cgroup_iter(NULL, memcg, NULL);
	} while (memcg);
3163 3164
}

3165 3166 3167 3168 3169
/*
 * Returns true if there is an eligible zone balanced for the request order
 * and classzone_idx
 */
static bool pgdat_balanced(pg_data_t *pgdat, int order, int classzone_idx)
3170
{
3171 3172 3173
	int i;
	unsigned long mark = -1;
	struct zone *zone;
3174

3175 3176
	for (i = 0; i <= classzone_idx; i++) {
		zone = pgdat->node_zones + i;
3177

3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194
		if (!managed_zone(zone))
			continue;

		mark = high_wmark_pages(zone);
		if (zone_watermark_ok_safe(zone, order, mark, classzone_idx))
			return true;
	}

	/*
	 * If a node has no populated zone within classzone_idx, it does not
	 * need balancing by definition. This can happen if a zone-restricted
	 * allocation tries to wake a remote kswapd.
	 */
	if (mark == -1)
		return true;

	return false;
3195 3196
}

3197 3198 3199 3200 3201 3202 3203 3204
/* Clear pgdat state for congested, dirty or under writeback. */
static void clear_pgdat_congested(pg_data_t *pgdat)
{
	clear_bit(PGDAT_CONGESTED, &pgdat->flags);
	clear_bit(PGDAT_DIRTY, &pgdat->flags);
	clear_bit(PGDAT_WRITEBACK, &pgdat->flags);
}

3205 3206 3207 3208 3209 3210
/*
 * Prepare kswapd for sleeping. This verifies that there are no processes
 * waiting in throttle_direct_reclaim() and that watermarks have been met.
 *
 * Returns true if kswapd is ready to sleep
 */
3211
static bool prepare_kswapd_sleep(pg_data_t *pgdat, int order, int classzone_idx)
3212
{
3213
	/*
3214
	 * The throttled processes are normally woken up in balance_pgdat() as
3215
	 * soon as allow_direct_reclaim() is true. But there is a potential
3216 3217 3218 3219 3220 3221 3222 3223 3224
	 * race between when kswapd checks the watermarks and a process gets
	 * throttled. There is also a potential race if processes get
	 * throttled, kswapd wakes, a large process exits thereby balancing the
	 * zones, which causes kswapd to exit balance_pgdat() before reaching
	 * the wake up checks. If kswapd is going to sleep, no process should
	 * be sleeping on pfmemalloc_wait, so wake them now if necessary. If
	 * the wake up is premature, processes will wake kswapd and get
	 * throttled again. The difference from wake ups in balance_pgdat() is
	 * that here we are under prepare_to_wait().
3225
	 */
3226 3227
	if (waitqueue_active(&pgdat->pfmemalloc_wait))
		wake_up_all(&pgdat->pfmemalloc_wait);
3228

3229 3230 3231 3232
	/* Hopeless node, leave it to direct reclaim */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

3233 3234 3235
	if (pgdat_balanced(pgdat, order, classzone_idx)) {
		clear_pgdat_congested(pgdat);
		return true;
3236 3237
	}

3238
	return false;
3239 3240
}

3241
/*
3242 3243
 * kswapd shrinks a node of pages that are at or below the highest usable
 * zone that is currently unbalanced.
3244 3245
 *
 * Returns true if kswapd scanned at least the requested number of pages to
3246 3247
 * reclaim or if the lack of progress was due to pages under writeback.
 * This is used to determine if the scanning priority needs to be raised.
3248
 */
3249
static bool kswapd_shrink_node(pg_data_t *pgdat,
3250
			       struct scan_control *sc)
3251
{
3252 3253
	struct zone *zone;
	int z;
3254

3255 3256
	/* Reclaim a number of pages proportional to the number of zones */
	sc->nr_to_reclaim = 0;
3257
	for (z = 0; z <= sc->reclaim_idx; z++) {
3258
		zone = pgdat->node_zones + z;
3259
		if (!managed_zone(zone))
3260
			continue;
3261

3262 3263
		sc->nr_to_reclaim += max(high_wmark_pages(zone), SWAP_CLUSTER_MAX);
	}
3264 3265

	/*
3266 3267
	 * Historically care was taken to put equal pressure on all zones but
	 * now pressure is applied based on node LRU order.
3268
	 */
3269
	shrink_node(pgdat, sc);
3270

3271
	/*
3272 3273 3274 3275 3276
	 * Fragmentation may mean that the system cannot be rebalanced for
	 * high-order allocations. If twice the allocation size has been
	 * reclaimed then recheck watermarks only at order-0 to prevent
	 * excessive reclaim. Assume that a process requested a high-order
	 * can direct reclaim/compact.
3277
	 */
3278
	if (sc->order && sc->nr_reclaimed >= compact_gap(sc->order))
3279
		sc->order = 0;
3280

3281
	return sc->nr_scanned >= sc->nr_to_reclaim;
3282 3283
}

L
Linus Torvalds 已提交
3284
/*
3285 3286 3287
 * For kswapd, balance_pgdat() will reclaim pages across a node from zones
 * that are eligible for use by the caller until at least one zone is
 * balanced.
L
Linus Torvalds 已提交
3288
 *
3289
 * Returns the order kswapd finished reclaiming at.
L
Linus Torvalds 已提交
3290 3291
 *
 * kswapd scans the zones in the highmem->normal->dma direction.  It skips
3292
 * zones which have free_pages > high_wmark_pages(zone), but once a zone is
3293 3294 3295
 * found to have free_pages <= high_wmark_pages(zone), any page is that zone
 * or lower is eligible for reclaim until at least one usable zone is
 * balanced.
L
Linus Torvalds 已提交
3296
 */
3297
static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
L
Linus Torvalds 已提交
3298 3299
{
	int i;
3300 3301
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
3302
	struct zone *zone;
3303 3304
	struct scan_control sc = {
		.gfp_mask = GFP_KERNEL,
3305
		.order = order,
3306
		.priority = DEF_PRIORITY,
3307
		.may_writepage = !laptop_mode,
3308
		.may_unmap = 1,
3309
		.may_swap = 1,
3310
	};
3311
	count_vm_event(PAGEOUTRUN);
L
Linus Torvalds 已提交
3312

3313
	do {
3314
		unsigned long nr_reclaimed = sc.nr_reclaimed;
3315 3316
		bool raise_priority = true;

3317
		sc.reclaim_idx = classzone_idx;
L
Linus Torvalds 已提交
3318

3319
		/*
3320 3321 3322 3323 3324 3325 3326 3327
		 * If the number of buffer_heads exceeds the maximum allowed
		 * then consider reclaiming from all zones. This has a dual
		 * purpose -- on 64-bit systems it is expected that
		 * buffer_heads are stripped during active rotation. On 32-bit
		 * systems, highmem pages can pin lowmem memory and shrinking
		 * buffers can relieve lowmem pressure. Reclaim may still not
		 * go ahead if all eligible zones for the original allocation
		 * request are balanced to avoid excessive reclaim from kswapd.
3328 3329 3330 3331
		 */
		if (buffer_heads_over_limit) {
			for (i = MAX_NR_ZONES - 1; i >= 0; i--) {
				zone = pgdat->node_zones + i;
3332
				if (!managed_zone(zone))
3333
					continue;
3334

3335
				sc.reclaim_idx = i;
A
Andrew Morton 已提交
3336
				break;
L
Linus Torvalds 已提交
3337 3338
			}
		}
3339

3340
		/*
3341 3342 3343
		 * Only reclaim if there are no eligible zones. Note that
		 * sc.reclaim_idx is not used as buffer_heads_over_limit may
		 * have adjusted it.
3344
		 */
3345 3346
		if (pgdat_balanced(pgdat, sc.order, classzone_idx))
			goto out;
A
Andrew Morton 已提交
3347

3348 3349 3350 3351 3352 3353
		/*
		 * Do some background aging of the anon list, to give
		 * pages a chance to be referenced before reclaiming. All
		 * pages are rotated regardless of classzone as this is
		 * about consistent aging.
		 */
3354
		age_active_anon(pgdat, &sc);
3355

3356 3357 3358 3359
		/*
		 * If we're getting trouble reclaiming, start doing writepage
		 * even in laptop mode.
		 */
3360
		if (sc.priority < DEF_PRIORITY - 2)
3361 3362
			sc.may_writepage = 1;

3363 3364 3365
		/* Call soft limit reclaim before calling shrink_node. */
		sc.nr_scanned = 0;
		nr_soft_scanned = 0;
3366
		nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(pgdat, sc.order,
3367 3368 3369
						sc.gfp_mask, &nr_soft_scanned);
		sc.nr_reclaimed += nr_soft_reclaimed;

L
Linus Torvalds 已提交
3370
		/*
3371 3372 3373
		 * There should be no need to raise the scanning priority if
		 * enough pages are already being scanned that that high
		 * watermark would be met at 100% efficiency.
L
Linus Torvalds 已提交
3374
		 */
3375
		if (kswapd_shrink_node(pgdat, &sc))
3376
			raise_priority = false;
3377 3378 3379 3380 3381 3382 3383

		/*
		 * If the low watermark is met there is no need for processes
		 * to be throttled on pfmemalloc_wait as they should not be
		 * able to safely make forward progress. Wake them
		 */
		if (waitqueue_active(&pgdat->pfmemalloc_wait) &&
3384
				allow_direct_reclaim(pgdat))
3385
			wake_up_all(&pgdat->pfmemalloc_wait);
3386

3387 3388 3389
		/* Check if kswapd should be suspending */
		if (try_to_freeze() || kthread_should_stop())
			break;
3390

3391
		/*
3392 3393
		 * Raise priority if scanning rate is too low or there was no
		 * progress in reclaiming pages
3394
		 */
3395 3396
		nr_reclaimed = sc.nr_reclaimed - nr_reclaimed;
		if (raise_priority || !nr_reclaimed)
3397
			sc.priority--;
3398
	} while (sc.priority >= 1);
L
Linus Torvalds 已提交
3399

3400 3401 3402
	if (!sc.nr_reclaimed)
		pgdat->kswapd_failures++;

3403
out:
3404
	snapshot_refaults(NULL, pgdat);
3405
	/*
3406 3407 3408 3409
	 * Return the order kswapd stopped reclaiming at as
	 * prepare_kswapd_sleep() takes it into account. If another caller
	 * entered the allocator slow path while kswapd was awake, order will
	 * remain at the higher level.
3410
	 */
3411
	return sc.order;
L
Linus Torvalds 已提交
3412 3413
}

3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429
/*
 * pgdat->kswapd_classzone_idx is the highest zone index that a recent
 * allocation request woke kswapd for. When kswapd has not woken recently,
 * the value is MAX_NR_ZONES which is not a valid index. This compares a
 * given classzone and returns it or the highest classzone index kswapd
 * was recently woke for.
 */
static enum zone_type kswapd_classzone_idx(pg_data_t *pgdat,
					   enum zone_type classzone_idx)
{
	if (pgdat->kswapd_classzone_idx == MAX_NR_ZONES)
		return classzone_idx;

	return max(pgdat->kswapd_classzone_idx, classzone_idx);
}

3430 3431
static void kswapd_try_to_sleep(pg_data_t *pgdat, int alloc_order, int reclaim_order,
				unsigned int classzone_idx)
3432 3433 3434 3435 3436 3437 3438 3439 3440
{
	long remaining = 0;
	DEFINE_WAIT(wait);

	if (freezing(current) || kthread_should_stop())
		return;

	prepare_to_wait(&pgdat->kswapd_wait, &wait, TASK_INTERRUPTIBLE);

3441 3442 3443 3444 3445 3446 3447
	/*
	 * Try to sleep for a short interval. Note that kcompactd will only be
	 * woken if it is possible to sleep for a short interval. This is
	 * deliberate on the assumption that if reclaim cannot keep an
	 * eligible zone balanced that it's also unlikely that compaction will
	 * succeed.
	 */
3448
	if (prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460
		/*
		 * Compaction records what page blocks it recently failed to
		 * isolate pages from and skips them in the future scanning.
		 * When kswapd is going to sleep, it is reasonable to assume
		 * that pages and compaction may succeed so reset the cache.
		 */
		reset_isolation_suitable(pgdat);

		/*
		 * We have freed the memory, now we should compact it to make
		 * allocation of the requested order possible.
		 */
3461
		wakeup_kcompactd(pgdat, alloc_order, classzone_idx);
3462

3463
		remaining = schedule_timeout(HZ/10);
3464 3465 3466 3467 3468 3469 3470

		/*
		 * If woken prematurely then reset kswapd_classzone_idx and
		 * order. The values will either be from a wakeup request or
		 * the previous request that slept prematurely.
		 */
		if (remaining) {
3471
			pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);
3472 3473 3474
			pgdat->kswapd_order = max(pgdat->kswapd_order, reclaim_order);
		}

3475 3476 3477 3478 3479 3480 3481 3482
		finish_wait(&pgdat->kswapd_wait, &wait);
		prepare_to_wait(&pgdat->kswapd_wait, &wait, TASK_INTERRUPTIBLE);
	}

	/*
	 * After a short sleep, check if it was a premature sleep. If not, then
	 * go fully to sleep until explicitly woken up.
	 */
3483 3484
	if (!remaining &&
	    prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495
		trace_mm_vmscan_kswapd_sleep(pgdat->node_id);

		/*
		 * vmstat counters are not perfectly accurate and the estimated
		 * value for counters such as NR_FREE_PAGES can deviate from the
		 * true value by nr_online_cpus * threshold. To avoid the zone
		 * watermarks being breached while under pressure, we reduce the
		 * per-cpu vmstat threshold while kswapd is awake and restore
		 * them before going back to sleep.
		 */
		set_pgdat_percpu_threshold(pgdat, calculate_normal_threshold);
3496 3497 3498 3499

		if (!kthread_should_stop())
			schedule();

3500 3501 3502 3503 3504 3505 3506 3507 3508 3509
		set_pgdat_percpu_threshold(pgdat, calculate_pressure_threshold);
	} else {
		if (remaining)
			count_vm_event(KSWAPD_LOW_WMARK_HIT_QUICKLY);
		else
			count_vm_event(KSWAPD_HIGH_WMARK_HIT_QUICKLY);
	}
	finish_wait(&pgdat->kswapd_wait, &wait);
}

L
Linus Torvalds 已提交
3510 3511
/*
 * The background pageout daemon, started as a kernel thread
3512
 * from the init process.
L
Linus Torvalds 已提交
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524
 *
 * This basically trickles out pages so that we have _some_
 * free memory available even if there is no other activity
 * that frees anything up. This is needed for things like routing
 * etc, where we otherwise might have all activity going on in
 * asynchronous contexts that cannot page things out.
 *
 * If there are applications that are active memory-allocators
 * (most normal use), this basically shouldn't matter.
 */
static int kswapd(void *p)
{
3525 3526
	unsigned int alloc_order, reclaim_order;
	unsigned int classzone_idx = MAX_NR_ZONES - 1;
L
Linus Torvalds 已提交
3527 3528
	pg_data_t *pgdat = (pg_data_t*)p;
	struct task_struct *tsk = current;
3529

L
Linus Torvalds 已提交
3530 3531 3532
	struct reclaim_state reclaim_state = {
		.reclaimed_slab = 0,
	};
3533
	const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
L
Linus Torvalds 已提交
3534

R
Rusty Russell 已提交
3535
	if (!cpumask_empty(cpumask))
3536
		set_cpus_allowed_ptr(tsk, cpumask);
L
Linus Torvalds 已提交
3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550
	current->reclaim_state = &reclaim_state;

	/*
	 * Tell the memory management that we're a "memory allocator",
	 * and that if we need more memory we should get access to it
	 * regardless (see "__alloc_pages()"). "kswapd" should
	 * never get caught in the normal page freeing logic.
	 *
	 * (Kswapd normally doesn't need memory anyway, but sometimes
	 * you need a small amount of memory in order to be able to
	 * page out something else, and this flag essentially protects
	 * us from recursively trying to free more memory as we're
	 * trying to free the first piece of memory in the first place).
	 */
3551
	tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
3552
	set_freezable();
L
Linus Torvalds 已提交
3553

3554 3555
	pgdat->kswapd_order = 0;
	pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
L
Linus Torvalds 已提交
3556
	for ( ; ; ) {
3557
		bool ret;
3558

3559 3560 3561
		alloc_order = reclaim_order = pgdat->kswapd_order;
		classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);

3562 3563 3564
kswapd_try_sleep:
		kswapd_try_to_sleep(pgdat, alloc_order, reclaim_order,
					classzone_idx);
3565

3566 3567
		/* Read the new order and classzone_idx */
		alloc_order = reclaim_order = pgdat->kswapd_order;
3568
		classzone_idx = kswapd_classzone_idx(pgdat, 0);
3569
		pgdat->kswapd_order = 0;
3570
		pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
L
Linus Torvalds 已提交
3571

3572 3573 3574 3575 3576 3577 3578 3579
		ret = try_to_freeze();
		if (kthread_should_stop())
			break;

		/*
		 * We can speed up thawing tasks if we don't call balance_pgdat
		 * after returning from the refrigerator
		 */
3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
		if (ret)
			continue;

		/*
		 * Reclaim begins at the requested order but if a high-order
		 * reclaim fails then kswapd falls back to reclaiming for
		 * order-0. If that happens, kswapd will consider sleeping
		 * for the order it finished reclaiming at (reclaim_order)
		 * but kcompactd is woken to compact for the original
		 * request (alloc_order).
		 */
3591 3592
		trace_mm_vmscan_kswapd_wake(pgdat->node_id, classzone_idx,
						alloc_order);
3593
		fs_reclaim_acquire(GFP_KERNEL);
3594
		reclaim_order = balance_pgdat(pgdat, alloc_order, classzone_idx);
3595
		fs_reclaim_release(GFP_KERNEL);
3596 3597
		if (reclaim_order < alloc_order)
			goto kswapd_try_sleep;
L
Linus Torvalds 已提交
3598
	}
3599

3600
	tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
3601
	current->reclaim_state = NULL;
3602

L
Linus Torvalds 已提交
3603 3604 3605 3606 3607 3608
	return 0;
}

/*
 * A zone is low on free memory, so wake its kswapd task to service it.
 */
3609
void wakeup_kswapd(struct zone *zone, int order, enum zone_type classzone_idx)
L
Linus Torvalds 已提交
3610 3611 3612
{
	pg_data_t *pgdat;

3613
	if (!managed_zone(zone))
L
Linus Torvalds 已提交
3614 3615
		return;

3616
	if (!cpuset_zone_allowed(zone, GFP_KERNEL | __GFP_HARDWALL))
L
Linus Torvalds 已提交
3617
		return;
3618
	pgdat = zone->zone_pgdat;
3619 3620
	pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat,
							   classzone_idx);
3621
	pgdat->kswapd_order = max(pgdat->kswapd_order, order);
3622
	if (!waitqueue_active(&pgdat->kswapd_wait))
L
Linus Torvalds 已提交
3623
		return;
3624

3625 3626 3627 3628
	/* Hopeless node, leave it to direct reclaim */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return;

3629 3630
	if (pgdat_balanced(pgdat, order, classzone_idx))
		return;
3631

3632
	trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, classzone_idx, order);
3633
	wake_up_interruptible(&pgdat->kswapd_wait);
L
Linus Torvalds 已提交
3634 3635
}

3636
#ifdef CONFIG_HIBERNATION
L
Linus Torvalds 已提交
3637
/*
3638
 * Try to free `nr_to_reclaim' of memory, system-wide, and return the number of
3639 3640 3641 3642 3643
 * freed pages.
 *
 * Rather than trying to age LRUs the aim is to preserve the overall
 * LRU order by reclaiming preferentially
 * inactive > active > active referenced > active mapped
L
Linus Torvalds 已提交
3644
 */
3645
unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
L
Linus Torvalds 已提交
3646
{
3647 3648
	struct reclaim_state reclaim_state;
	struct scan_control sc = {
3649
		.nr_to_reclaim = nr_to_reclaim,
3650
		.gfp_mask = GFP_HIGHUSER_MOVABLE,
3651
		.reclaim_idx = MAX_NR_ZONES - 1,
3652
		.priority = DEF_PRIORITY,
3653
		.may_writepage = 1,
3654 3655
		.may_unmap = 1,
		.may_swap = 1,
3656
		.hibernation_mode = 1,
L
Linus Torvalds 已提交
3657
	};
3658
	struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
3659 3660
	struct task_struct *p = current;
	unsigned long nr_reclaimed;
3661
	unsigned int noreclaim_flag;
L
Linus Torvalds 已提交
3662

3663
	noreclaim_flag = memalloc_noreclaim_save();
3664
	fs_reclaim_acquire(sc.gfp_mask);
3665 3666
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
3667

3668
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3669

3670
	p->reclaim_state = NULL;
3671
	fs_reclaim_release(sc.gfp_mask);
3672
	memalloc_noreclaim_restore(noreclaim_flag);
3673

3674
	return nr_reclaimed;
L
Linus Torvalds 已提交
3675
}
3676
#endif /* CONFIG_HIBERNATION */
L
Linus Torvalds 已提交
3677 3678 3679 3680 3681

/* It's optimal to keep kswapds on the same CPUs as their memory, but
   not required for correctness.  So if the last cpu in a node goes
   away, we get changed to run anywhere: as the first one comes back,
   restore their cpu bindings. */
3682
static int kswapd_cpu_online(unsigned int cpu)
L
Linus Torvalds 已提交
3683
{
3684
	int nid;
L
Linus Torvalds 已提交
3685

3686 3687 3688
	for_each_node_state(nid, N_MEMORY) {
		pg_data_t *pgdat = NODE_DATA(nid);
		const struct cpumask *mask;
3689

3690
		mask = cpumask_of_node(pgdat->node_id);
3691

3692 3693 3694
		if (cpumask_any_and(cpu_online_mask, mask) < nr_cpu_ids)
			/* One of our CPUs online: restore mask */
			set_cpus_allowed_ptr(pgdat->kswapd, mask);
L
Linus Torvalds 已提交
3695
	}
3696
	return 0;
L
Linus Torvalds 已提交
3697 3698
}

3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713
/*
 * This kswapd start function will be called by init and node-hot-add.
 * On node-hot-add, kswapd will moved to proper cpus if cpus are hot-added.
 */
int kswapd_run(int nid)
{
	pg_data_t *pgdat = NODE_DATA(nid);
	int ret = 0;

	if (pgdat->kswapd)
		return 0;

	pgdat->kswapd = kthread_run(kswapd, pgdat, "kswapd%d", nid);
	if (IS_ERR(pgdat->kswapd)) {
		/* failure at boot is fatal */
3714
		BUG_ON(system_state < SYSTEM_RUNNING);
3715 3716
		pr_err("Failed to start kswapd on node %d\n", nid);
		ret = PTR_ERR(pgdat->kswapd);
3717
		pgdat->kswapd = NULL;
3718 3719 3720 3721
	}
	return ret;
}

3722
/*
3723
 * Called by memory hotplug when all memory in a node is offlined.  Caller must
3724
 * hold mem_hotplug_begin/end().
3725 3726 3727 3728 3729
 */
void kswapd_stop(int nid)
{
	struct task_struct *kswapd = NODE_DATA(nid)->kswapd;

3730
	if (kswapd) {
3731
		kthread_stop(kswapd);
3732 3733
		NODE_DATA(nid)->kswapd = NULL;
	}
3734 3735
}

L
Linus Torvalds 已提交
3736 3737
static int __init kswapd_init(void)
{
3738
	int nid, ret;
3739

L
Linus Torvalds 已提交
3740
	swap_setup();
3741
	for_each_node_state(nid, N_MEMORY)
3742
 		kswapd_run(nid);
3743 3744 3745 3746
	ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
					"mm/vmscan:online", kswapd_cpu_online,
					NULL);
	WARN_ON(ret < 0);
L
Linus Torvalds 已提交
3747 3748 3749 3750
	return 0;
}

module_init(kswapd_init)
3751 3752 3753

#ifdef CONFIG_NUMA
/*
3754
 * Node reclaim mode
3755
 *
3756
 * If non-zero call node_reclaim when the number of free pages falls below
3757 3758
 * the watermarks.
 */
3759
int node_reclaim_mode __read_mostly;
3760

3761
#define RECLAIM_OFF 0
3762
#define RECLAIM_ZONE (1<<0)	/* Run shrink_inactive_list on the zone */
3763
#define RECLAIM_WRITE (1<<1)	/* Writeout pages during reclaim */
3764
#define RECLAIM_UNMAP (1<<2)	/* Unmap pages during reclaim */
3765

3766
/*
3767
 * Priority for NODE_RECLAIM. This determines the fraction of pages
3768 3769 3770
 * of a node considered for each zone_reclaim. 4 scans 1/16th of
 * a zone.
 */
3771
#define NODE_RECLAIM_PRIORITY 4
3772

3773
/*
3774
 * Percentage of pages in a zone that must be unmapped for node_reclaim to
3775 3776 3777 3778
 * occur.
 */
int sysctl_min_unmapped_ratio = 1;

3779 3780 3781 3782 3783 3784
/*
 * If the number of slab pages in a zone grows beyond this percentage then
 * slab reclaim needs to occur.
 */
int sysctl_min_slab_ratio = 5;

3785
static inline unsigned long node_unmapped_file_pages(struct pglist_data *pgdat)
3786
{
3787 3788 3789
	unsigned long file_mapped = node_page_state(pgdat, NR_FILE_MAPPED);
	unsigned long file_lru = node_page_state(pgdat, NR_INACTIVE_FILE) +
		node_page_state(pgdat, NR_ACTIVE_FILE);
3790 3791 3792 3793 3794 3795 3796 3797 3798 3799

	/*
	 * It's possible for there to be more file mapped pages than
	 * accounted for by the pages on the file LRU lists because
	 * tmpfs pages accounted for as ANON can also be FILE_MAPPED
	 */
	return (file_lru > file_mapped) ? (file_lru - file_mapped) : 0;
}

/* Work out how many page cache pages we can reclaim in this reclaim_mode */
3800
static unsigned long node_pagecache_reclaimable(struct pglist_data *pgdat)
3801
{
3802 3803
	unsigned long nr_pagecache_reclaimable;
	unsigned long delta = 0;
3804 3805

	/*
3806
	 * If RECLAIM_UNMAP is set, then all file pages are considered
3807
	 * potentially reclaimable. Otherwise, we have to worry about
3808
	 * pages like swapcache and node_unmapped_file_pages() provides
3809 3810
	 * a better estimate
	 */
3811 3812
	if (node_reclaim_mode & RECLAIM_UNMAP)
		nr_pagecache_reclaimable = node_page_state(pgdat, NR_FILE_PAGES);
3813
	else
3814
		nr_pagecache_reclaimable = node_unmapped_file_pages(pgdat);
3815 3816

	/* If we can't clean pages, remove dirty pages from consideration */
3817 3818
	if (!(node_reclaim_mode & RECLAIM_WRITE))
		delta += node_page_state(pgdat, NR_FILE_DIRTY);
3819 3820 3821 3822 3823 3824 3825 3826

	/* Watch for any possible underflows due to delta */
	if (unlikely(delta > nr_pagecache_reclaimable))
		delta = nr_pagecache_reclaimable;

	return nr_pagecache_reclaimable - delta;
}

3827
/*
3828
 * Try to free up some pages from this node through reclaim.
3829
 */
3830
static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
3831
{
3832
	/* Minimum pages needed in order to stay on node */
3833
	const unsigned long nr_pages = 1 << order;
3834 3835
	struct task_struct *p = current;
	struct reclaim_state reclaim_state;
3836
	unsigned int noreclaim_flag;
3837
	struct scan_control sc = {
3838
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3839
		.gfp_mask = current_gfp_context(gfp_mask),
3840
		.order = order,
3841 3842 3843
		.priority = NODE_RECLAIM_PRIORITY,
		.may_writepage = !!(node_reclaim_mode & RECLAIM_WRITE),
		.may_unmap = !!(node_reclaim_mode & RECLAIM_UNMAP),
3844
		.may_swap = 1,
3845
		.reclaim_idx = gfp_zone(gfp_mask),
3846
	};
3847 3848

	cond_resched();
3849
	/*
3850
	 * We need to be able to allocate from the reserves for RECLAIM_UNMAP
3851
	 * and we also need to be able to write out pages for RECLAIM_WRITE
3852
	 * and RECLAIM_UNMAP.
3853
	 */
3854 3855
	noreclaim_flag = memalloc_noreclaim_save();
	p->flags |= PF_SWAPWRITE;
3856
	fs_reclaim_acquire(sc.gfp_mask);
3857 3858
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
3859

3860
	if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
3861 3862 3863 3864 3865
		/*
		 * Free memory by calling shrink zone with increasing
		 * priorities until we have enough memory freed.
		 */
		do {
3866
			shrink_node(pgdat, &sc);
3867
		} while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
3868
	}
3869

3870
	p->reclaim_state = NULL;
3871
	fs_reclaim_release(gfp_mask);
3872 3873
	current->flags &= ~PF_SWAPWRITE;
	memalloc_noreclaim_restore(noreclaim_flag);
3874
	return sc.nr_reclaimed >= nr_pages;
3875
}
3876

3877
int node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
3878
{
3879
	int ret;
3880 3881

	/*
3882
	 * Node reclaim reclaims unmapped file backed pages and
3883
	 * slab pages if we are over the defined limits.
3884
	 *
3885 3886
	 * A small portion of unmapped file backed pages is needed for
	 * file I/O otherwise pages read by file I/O will be immediately
3887 3888
	 * thrown out if the node is overallocated. So we do not reclaim
	 * if less than a specified percentage of the node is used by
3889
	 * unmapped file backed pages.
3890
	 */
3891
	if (node_pagecache_reclaimable(pgdat) <= pgdat->min_unmapped_pages &&
3892
	    node_page_state(pgdat, NR_SLAB_RECLAIMABLE) <= pgdat->min_slab_pages)
3893
		return NODE_RECLAIM_FULL;
3894 3895

	/*
3896
	 * Do not scan if the allocation should not be delayed.
3897
	 */
3898
	if (!gfpflags_allow_blocking(gfp_mask) || (current->flags & PF_MEMALLOC))
3899
		return NODE_RECLAIM_NOSCAN;
3900 3901

	/*
3902
	 * Only run node reclaim on the local node or on nodes that do not
3903 3904 3905 3906
	 * have associated processors. This will favor the local processor
	 * over remote processors and spread off node memory allocations
	 * as wide as possible.
	 */
3907 3908
	if (node_state(pgdat->node_id, N_CPU) && pgdat->node_id != numa_node_id())
		return NODE_RECLAIM_NOSCAN;
3909

3910 3911
	if (test_and_set_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags))
		return NODE_RECLAIM_NOSCAN;
3912

3913 3914
	ret = __node_reclaim(pgdat, gfp_mask, order);
	clear_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags);
3915

3916 3917 3918
	if (!ret)
		count_vm_event(PGSCAN_ZONE_RECLAIM_FAILED);

3919
	return ret;
3920
}
3921
#endif
L
Lee Schermerhorn 已提交
3922 3923 3924 3925 3926 3927

/*
 * page_evictable - test whether a page is evictable
 * @page: the page to test
 *
 * Test whether page is evictable--i.e., should be placed on active/inactive
3928
 * lists vs unevictable list.
L
Lee Schermerhorn 已提交
3929 3930
 *
 * Reasons page might not be evictable:
3931
 * (1) page's mapping marked unevictable
N
Nick Piggin 已提交
3932
 * (2) page is part of an mlocked VMA
3933
 *
L
Lee Schermerhorn 已提交
3934
 */
3935
int page_evictable(struct page *page)
L
Lee Schermerhorn 已提交
3936
{
3937
	return !mapping_unevictable(page_mapping(page)) && !PageMlocked(page);
L
Lee Schermerhorn 已提交
3938
}
3939

3940
#ifdef CONFIG_SHMEM
3941
/**
3942 3943 3944
 * check_move_unevictable_pages - check pages for evictability and move to appropriate zone lru list
 * @pages:	array of pages to check
 * @nr_pages:	number of pages to check
3945
 *
3946
 * Checks pages for evictability and moves them to the appropriate lru list.
3947 3948
 *
 * This function is only used for SysV IPC SHM_UNLOCK.
3949
 */
3950
void check_move_unevictable_pages(struct page **pages, int nr_pages)
3951
{
3952
	struct lruvec *lruvec;
3953
	struct pglist_data *pgdat = NULL;
3954 3955 3956
	int pgscanned = 0;
	int pgrescued = 0;
	int i;
3957

3958 3959
	for (i = 0; i < nr_pages; i++) {
		struct page *page = pages[i];
3960
		struct pglist_data *pagepgdat = page_pgdat(page);
3961

3962
		pgscanned++;
3963 3964 3965 3966 3967
		if (pagepgdat != pgdat) {
			if (pgdat)
				spin_unlock_irq(&pgdat->lru_lock);
			pgdat = pagepgdat;
			spin_lock_irq(&pgdat->lru_lock);
3968
		}
3969
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
3970

3971 3972
		if (!PageLRU(page) || !PageUnevictable(page))
			continue;
3973

3974
		if (page_evictable(page)) {
3975 3976
			enum lru_list lru = page_lru_base_type(page);

3977
			VM_BUG_ON_PAGE(PageActive(page), page);
3978
			ClearPageUnevictable(page);
3979 3980
			del_page_from_lru_list(page, lruvec, LRU_UNEVICTABLE);
			add_page_to_lru_list(page, lruvec, lru);
3981
			pgrescued++;
3982
		}
3983
	}
3984

3985
	if (pgdat) {
3986 3987
		__count_vm_events(UNEVICTABLE_PGRESCUED, pgrescued);
		__count_vm_events(UNEVICTABLE_PGSCANNED, pgscanned);
3988
		spin_unlock_irq(&pgdat->lru_lock);
3989 3990
	}
}
3991
#endif /* CONFIG_SHMEM */