vmscan.c 114.5 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
L
Linus Torvalds 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 *  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.
 */

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

L
Linus Torvalds 已提交
17
#include <linux/mm.h>
18
#include <linux/sched/mm.h>
L
Linus Torvalds 已提交
19
#include <linux/module.h>
20
#include <linux/gfp.h>
L
Linus Torvalds 已提交
21 22 23 24 25
#include <linux/kernel_stat.h>
#include <linux/swap.h>
#include <linux/pagemap.h>
#include <linux/init.h>
#include <linux/highmem.h>
26
#include <linux/vmpressure.h>
27
#include <linux/vmstat.h>
L
Linus Torvalds 已提交
28 29 30 31 32 33 34 35 36 37 38
#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>
39
#include <linux/compaction.h>
L
Linus Torvalds 已提交
40 41
#include <linux/notifier.h>
#include <linux/rwsem.h>
42
#include <linux/delay.h>
43
#include <linux/kthread.h>
44
#include <linux/freezer.h>
45
#include <linux/memcontrol.h>
46
#include <linux/delayacct.h>
47
#include <linux/sysctl.h>
48
#include <linux/oom.h>
49
#include <linux/prefetch.h>
50
#include <linux/printk.h>
51
#include <linux/dax.h>
L
Linus Torvalds 已提交
52 53 54 55 56

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

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

59 60
#include "internal.h"

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

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

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

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

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

80 81 82 83 84
	/*
	 * 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;
85

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

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

92
	/* Writepage batching in laptop mode; RECLAIM_WRITE */
93 94 95 96 97 98 99 100
	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;

101 102 103 104 105 106 107
	/*
	 * 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;
108

109 110 111 112 113 114 115 116 117 118
	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;
119 120 121 122 123 124 125 126 127 128

	struct {
		unsigned int dirty;
		unsigned int unqueued_dirty;
		unsigned int congested;
		unsigned int writeback;
		unsigned int immediate;
		unsigned int file_taken;
		unsigned int taken;
	} nr;
L
Linus Torvalds 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
};

#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;
163 164 165 166 167
/*
 * The total number of pages which are beyond the high watermark within all
 * zones.
 */
unsigned long vm_total_pages;
L
Linus Torvalds 已提交
168 169 170 171

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

A
Andrew Morton 已提交
172
#ifdef CONFIG_MEMCG
173 174
static bool global_reclaim(struct scan_control *sc)
{
175
	return !sc->target_mem_cgroup;
176
}
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197

/**
 * 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
198
	if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
199 200 201 202
		return true;
#endif
	return false;
}
203
#else
204 205 206 207
static bool global_reclaim(struct scan_control *sc)
{
	return true;
}
208 209 210 211 212

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

215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
/*
 * 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;
}

233 234 235 236 237 238 239
/**
 * 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)
240
{
241 242 243
	unsigned long lru_size;
	int zid;

244
	if (!mem_cgroup_disabled())
245 246 247
		lru_size = mem_cgroup_get_lru_size(lruvec, lru);
	else
		lru_size = node_page_state(lruvec_pgdat(lruvec), NR_LRU_BASE + lru);
248

249 250 251
	for (zid = zone_idx + 1; zid < MAX_NR_ZONES; zid++) {
		struct zone *zone = &lruvec_pgdat(lruvec)->node_zones[zid];
		unsigned long size;
252

253 254 255 256 257 258 259 260 261 262 263 264
		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;
265 266 267

}

L
Linus Torvalds 已提交
268
/*
G
Glauber Costa 已提交
269
 * Add a shrinker callback to be called from the vm.
L
Linus Torvalds 已提交
270
 */
G
Glauber Costa 已提交
271
int register_shrinker(struct shrinker *shrinker)
L
Linus Torvalds 已提交
272
{
G
Glauber Costa 已提交
273 274 275 276 277 278 279 280 281
	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;

282 283 284
	down_write(&shrinker_rwsem);
	list_add_tail(&shrinker->list, &shrinker_list);
	up_write(&shrinker_rwsem);
G
Glauber Costa 已提交
285
	return 0;
L
Linus Torvalds 已提交
286
}
287
EXPORT_SYMBOL(register_shrinker);
L
Linus Torvalds 已提交
288 289 290 291

/*
 * Remove one
 */
292
void unregister_shrinker(struct shrinker *shrinker)
L
Linus Torvalds 已提交
293
{
294 295
	if (!shrinker->nr_deferred)
		return;
L
Linus Torvalds 已提交
296 297 298
	down_write(&shrinker_rwsem);
	list_del(&shrinker->list);
	up_write(&shrinker_rwsem);
299
	kfree(shrinker->nr_deferred);
300
	shrinker->nr_deferred = NULL;
L
Linus Torvalds 已提交
301
}
302
EXPORT_SYMBOL(unregister_shrinker);
L
Linus Torvalds 已提交
303 304

#define SHRINK_BATCH 128
G
Glauber Costa 已提交
305

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

320 321
	freeable = shrinker->count_objects(shrinker, shrinkctl);
	if (freeable == 0)
G
Glauber Costa 已提交
322 323 324 325 326 327 328 329 330 331
		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;
332 333 334
	delta = freeable >> priority;
	delta *= 4;
	do_div(delta, shrinker->seeks);
G
Glauber Costa 已提交
335 336
	total_scan += delta;
	if (total_scan < 0) {
337
		pr_err("shrink_slab: %pF negative objects to delete nr=%ld\n",
D
Dave Chinner 已提交
338
		       shrinker->scan_objects, total_scan);
339
		total_scan = freeable;
340 341 342
		next_deferred = nr;
	} else
		next_deferred = total_scan;
G
Glauber Costa 已提交
343 344 345 346 347 348 349

	/*
	 * 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 >>>
350
	 * freeable. This is bad for sustaining a working set in
G
Glauber Costa 已提交
351 352 353 354 355
	 * memory.
	 *
	 * Hence only allow the shrinker to scan the entire cache when
	 * a large delta change is calculated directly.
	 */
356 357
	if (delta < freeable / 4)
		total_scan = min(total_scan, freeable / 2);
G
Glauber Costa 已提交
358 359 360 361 362 363

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

	trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,
368
				   freeable, delta, total_scan, priority);
G
Glauber Costa 已提交
369

370 371 372 373 374 375 376 377 378 379 380
	/*
	 * 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
381
	 * than the total number of objects on slab (freeable), we must be
382 383 384 385
	 * scanning at high prio and therefore should try to reclaim as much as
	 * possible.
	 */
	while (total_scan >= batch_size ||
386
	       total_scan >= freeable) {
D
Dave Chinner 已提交
387
		unsigned long ret;
388
		unsigned long nr_to_scan = min(batch_size, total_scan);
G
Glauber Costa 已提交
389

390
		shrinkctl->nr_to_scan = nr_to_scan;
391
		shrinkctl->nr_scanned = nr_to_scan;
D
Dave Chinner 已提交
392 393 394 395
		ret = shrinker->scan_objects(shrinker, shrinkctl);
		if (ret == SHRINK_STOP)
			break;
		freed += ret;
G
Glauber Costa 已提交
396

397 398 399
		count_vm_events(SLABS_SCANNED, shrinkctl->nr_scanned);
		total_scan -= shrinkctl->nr_scanned;
		scanned += shrinkctl->nr_scanned;
G
Glauber Costa 已提交
400 401 402 403

		cond_resched();
	}

404 405 406 407
	if (next_deferred >= scanned)
		next_deferred -= scanned;
	else
		next_deferred = 0;
G
Glauber Costa 已提交
408 409 410 411 412
	/*
	 * 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.
	 */
413 414
	if (next_deferred > 0)
		new_nr = atomic_long_add_return(next_deferred,
G
Glauber Costa 已提交
415 416 417 418
						&shrinker->nr_deferred[nid]);
	else
		new_nr = atomic_long_read(&shrinker->nr_deferred[nid]);

419
	trace_mm_shrink_slab_end(shrinker, nid, freed, nr, new_nr, total_scan);
G
Glauber Costa 已提交
420
	return freed;
421 422
}

423
/**
424
 * shrink_slab - shrink slab caches
425 426
 * @gfp_mask: allocation context
 * @nid: node whose slab caches to target
427
 * @memcg: memory cgroup whose slab caches to target
428
 * @priority: the reclaim priority
L
Linus Torvalds 已提交
429
 *
430
 * Call the shrink functions to age shrinkable caches.
L
Linus Torvalds 已提交
431
 *
432 433
 * @nid is passed along to shrinkers with SHRINKER_NUMA_AWARE set,
 * unaware shrinkers will receive a node id of 0 instead.
L
Linus Torvalds 已提交
434
 *
435 436
 * @memcg specifies the memory cgroup to target. If it is not NULL,
 * only shrinkers with SHRINKER_MEMCG_AWARE set will be called to scan
437 438
 * objects from the memory cgroup specified. Otherwise, only unaware
 * shrinkers are called.
439
 *
440 441
 * @priority is sc->priority, we take the number of objects and >> by priority
 * in order to get the scan target.
442
 *
443
 * Returns the number of reclaimed slab objects.
L
Linus Torvalds 已提交
444
 */
445 446
static unsigned long shrink_slab(gfp_t gfp_mask, int nid,
				 struct mem_cgroup *memcg,
447
				 int priority)
L
Linus Torvalds 已提交
448 449
{
	struct shrinker *shrinker;
D
Dave Chinner 已提交
450
	unsigned long freed = 0;
L
Linus Torvalds 已提交
451

452
	if (memcg && (!memcg_kmem_enabled() || !mem_cgroup_online(memcg)))
453 454
		return 0;

455
	if (!down_read_trylock(&shrinker_rwsem))
456
		goto out;
L
Linus Torvalds 已提交
457 458

	list_for_each_entry(shrinker, &shrinker_list, list) {
459 460 461
		struct shrink_control sc = {
			.gfp_mask = gfp_mask,
			.nid = nid,
462
			.memcg = memcg,
463
		};
464

465 466 467 468 469 470 471
		/*
		 * 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))
472 473
			continue;

474 475
		if (!(shrinker->flags & SHRINKER_NUMA_AWARE))
			sc.nid = 0;
L
Linus Torvalds 已提交
476

477
		freed += do_shrink_slab(&sc, shrinker, priority);
478 479 480 481 482 483 484 485 486
		/*
		 * Bail out if someone want to register a new shrinker to
		 * prevent the regsitration from being stalled for long periods
		 * by parallel ongoing shrinking.
		 */
		if (rwsem_is_contended(&shrinker_rwsem)) {
			freed = freed ? : 1;
			break;
		}
L
Linus Torvalds 已提交
487
	}
488

L
Linus Torvalds 已提交
489
	up_read(&shrinker_rwsem);
490 491
out:
	cond_resched();
D
Dave Chinner 已提交
492
	return freed;
L
Linus Torvalds 已提交
493 494
}

495 496 497 498 499 500 501 502 503
void drop_slab_node(int nid)
{
	unsigned long freed;

	do {
		struct mem_cgroup *memcg = NULL;

		freed = 0;
		do {
504
			freed += shrink_slab(GFP_KERNEL, nid, memcg, 0);
505 506 507 508 509 510 511 512 513 514 515 516
		} 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 已提交
517 518
static inline int is_page_cache_freeable(struct page *page)
{
519 520 521 522 523
	/*
	 * 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.
	 */
524 525 526
	int radix_pins = PageTransHuge(page) && PageSwapCache(page) ?
		HPAGE_PMD_NR : 1;
	return page_count(page) - page_has_private(page) == 1 + radix_pins;
L
Linus Torvalds 已提交
527 528
}

529
static int may_write_to_inode(struct inode *inode, struct scan_control *sc)
L
Linus Torvalds 已提交
530
{
531
	if (current->flags & PF_SWAPWRITE)
L
Linus Torvalds 已提交
532
		return 1;
533
	if (!inode_write_congested(inode))
L
Linus Torvalds 已提交
534
		return 1;
535
	if (inode_to_bdi(inode) == current->backing_dev_info)
L
Linus Torvalds 已提交
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
		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 已提交
555
	lock_page(page);
556 557
	if (page_mapping(page) == mapping)
		mapping_set_error(mapping, error);
L
Linus Torvalds 已提交
558 559 560
	unlock_page(page);
}

561 562 563 564 565 566 567 568 569 570 571 572
/* 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 已提交
573
/*
A
Andrew Morton 已提交
574 575
 * pageout is called by shrink_page_list() for each dirty page.
 * Calls ->writepage().
L
Linus Torvalds 已提交
576
 */
577
static pageout_t pageout(struct page *page, struct address_space *mapping,
578
			 struct scan_control *sc)
L
Linus Torvalds 已提交
579 580 581 582 583 584 585 586
{
	/*
	 * 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.
	 *
587
	 * If this process is currently in __generic_file_write_iter() against
L
Linus Torvalds 已提交
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
	 * 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.
		 */
603
		if (page_has_private(page)) {
L
Linus Torvalds 已提交
604 605
			if (try_to_free_buffers(page)) {
				ClearPageDirty(page);
606
				pr_info("%s: orphaned page\n", __func__);
L
Linus Torvalds 已提交
607 608 609 610 611 612 613
				return PAGE_CLEAN;
			}
		}
		return PAGE_KEEP;
	}
	if (mapping->a_ops->writepage == NULL)
		return PAGE_ACTIVATE;
614
	if (!may_write_to_inode(mapping->host, sc))
L
Linus Torvalds 已提交
615 616 617 618 619 620 621
		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,
622 623
			.range_start = 0,
			.range_end = LLONG_MAX,
L
Linus Torvalds 已提交
624 625 626 627 628 629 630
			.for_reclaim = 1,
		};

		SetPageReclaim(page);
		res = mapping->a_ops->writepage(page, &wbc);
		if (res < 0)
			handle_write_error(mapping, page, res);
631
		if (res == AOP_WRITEPAGE_ACTIVATE) {
L
Linus Torvalds 已提交
632 633 634
			ClearPageReclaim(page);
			return PAGE_ACTIVATE;
		}
635

L
Linus Torvalds 已提交
636 637 638 639
		if (!PageWriteback(page)) {
			/* synchronous write or broken a_ops? */
			ClearPageReclaim(page);
		}
640
		trace_mm_vmscan_writepage(page);
641
		inc_node_page_state(page, NR_VMSCAN_WRITE);
L
Linus Torvalds 已提交
642 643 644 645 646 647
		return PAGE_SUCCESS;
	}

	return PAGE_CLEAN;
}

648
/*
N
Nick Piggin 已提交
649 650
 * Same as remove_mapping, but if the page is removed from the mapping, it
 * gets returned with a refcount of 0.
651
 */
652 653
static int __remove_mapping(struct address_space *mapping, struct page *page,
			    bool reclaimed)
654
{
655
	unsigned long flags;
656
	int refcount;
657

658 659
	BUG_ON(!PageLocked(page));
	BUG_ON(mapping != page_mapping(page));
660

661
	spin_lock_irqsave(&mapping->tree_lock, flags);
662
	/*
N
Nick Piggin 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
	 * 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
682
	 * load is not satisfied before that of page->_refcount.
N
Nick Piggin 已提交
683 684 685
	 *
	 * Note that if SetPageDirty is always performed via set_page_dirty,
	 * and thus under tree_lock, then this ordering is not required.
686
	 */
687 688 689 690 691
	if (unlikely(PageTransHuge(page)) && PageSwapCache(page))
		refcount = 1 + HPAGE_PMD_NR;
	else
		refcount = 2;
	if (!page_ref_freeze(page, refcount))
692
		goto cannot_free;
N
Nick Piggin 已提交
693 694
	/* note: atomic_cmpxchg in page_freeze_refs provides the smp_rmb */
	if (unlikely(PageDirty(page))) {
695
		page_ref_unfreeze(page, refcount);
696
		goto cannot_free;
N
Nick Piggin 已提交
697
	}
698 699 700

	if (PageSwapCache(page)) {
		swp_entry_t swap = { .val = page_private(page) };
701
		mem_cgroup_swapout(page, swap);
702
		__delete_from_swap_cache(page);
703
		spin_unlock_irqrestore(&mapping->tree_lock, flags);
704
		put_swap_page(page, swap);
N
Nick Piggin 已提交
705
	} else {
706
		void (*freepage)(struct page *);
707
		void *shadow = NULL;
708 709

		freepage = mapping->a_ops->freepage;
710 711 712 713 714 715 716 717 718
		/*
		 * 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.
719 720 721 722 723 724
		 *
		 * 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.
725 726
		 */
		if (reclaimed && page_is_file_cache(page) &&
727
		    !mapping_exiting(mapping) && !dax_mapping(mapping))
728
			shadow = workingset_eviction(mapping, page);
J
Johannes Weiner 已提交
729
		__delete_from_page_cache(page, shadow);
730
		spin_unlock_irqrestore(&mapping->tree_lock, flags);
731 732 733

		if (freepage != NULL)
			freepage(page);
734 735 736 737 738
	}

	return 1;

cannot_free:
739
	spin_unlock_irqrestore(&mapping->tree_lock, flags);
740 741 742
	return 0;
}

N
Nick Piggin 已提交
743 744 745 746 747 748 749 750
/*
 * 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)
{
751
	if (__remove_mapping(mapping, page, false)) {
N
Nick Piggin 已提交
752 753 754 755 756
		/*
		 * Unfreezing the refcount with 1 rather than 2 effectively
		 * drops the pagecache ref for us without requiring another
		 * atomic operation.
		 */
757
		page_ref_unfreeze(page, 1);
N
Nick Piggin 已提交
758 759 760 761 762
		return 1;
	}
	return 0;
}

L
Lee Schermerhorn 已提交
763 764 765 766 767 768 769 770 771 772 773
/**
 * 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)
{
774
	lru_cache_add(page);
L
Lee Schermerhorn 已提交
775 776 777
	put_page(page);		/* drop ref from isolate */
}

778 779 780
enum page_references {
	PAGEREF_RECLAIM,
	PAGEREF_RECLAIM_CLEAN,
781
	PAGEREF_KEEP,
782 783 784 785 786 787
	PAGEREF_ACTIVATE,
};

static enum page_references page_check_references(struct page *page,
						  struct scan_control *sc)
{
788
	int referenced_ptes, referenced_page;
789 790
	unsigned long vm_flags;

791 792
	referenced_ptes = page_referenced(page, 1, sc->target_mem_cgroup,
					  &vm_flags);
793
	referenced_page = TestClearPageReferenced(page);
794 795 796 797 798 799 800 801

	/*
	 * 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;

802
	if (referenced_ptes) {
803
		if (PageSwapBacked(page))
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
			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);

821
		if (referenced_page || referenced_ptes > 1)
822 823
			return PAGEREF_ACTIVATE;

824 825 826 827 828 829
		/*
		 * Activate file-backed executable pages after first usage.
		 */
		if (vm_flags & VM_EXEC)
			return PAGEREF_ACTIVATE;

830 831
		return PAGEREF_KEEP;
	}
832 833

	/* Reclaim if clean, defer dirty pages to writeback */
834
	if (referenced_page && !PageSwapBacked(page))
835 836 837
		return PAGEREF_RECLAIM_CLEAN;

	return PAGEREF_RECLAIM;
838 839
}

840 841 842 843
/* Check if a page is dirty or under writeback */
static void page_check_dirty_writeback(struct page *page,
				       bool *dirty, bool *writeback)
{
844 845
	struct address_space *mapping;

846 847 848 849
	/*
	 * Anonymous pages are not handled by flushers and must be written
	 * from reclaim context. Do not stall reclaim based on them
	 */
S
Shaohua Li 已提交
850 851
	if (!page_is_file_cache(page) ||
	    (PageAnon(page) && !PageSwapBacked(page))) {
852 853 854 855 856 857 858 859
		*dirty = false;
		*writeback = false;
		return;
	}

	/* By default assume that the page flags are accurate */
	*dirty = PageDirty(page);
	*writeback = PageWriteback(page);
860 861 862 863 864 865 866 867

	/* 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);
868 869
}

870 871 872 873 874 875
struct reclaim_stat {
	unsigned nr_dirty;
	unsigned nr_unqueued_dirty;
	unsigned nr_congested;
	unsigned nr_writeback;
	unsigned nr_immediate;
876 877 878
	unsigned nr_activate;
	unsigned nr_ref_keep;
	unsigned nr_unmap_fail;
879 880
};

L
Linus Torvalds 已提交
881
/*
A
Andrew Morton 已提交
882
 * shrink_page_list() returns the number of reclaimed pages
L
Linus Torvalds 已提交
883
 */
A
Andrew Morton 已提交
884
static unsigned long shrink_page_list(struct list_head *page_list,
M
Mel Gorman 已提交
885
				      struct pglist_data *pgdat,
886
				      struct scan_control *sc,
887
				      enum ttu_flags ttu_flags,
888
				      struct reclaim_stat *stat,
889
				      bool force_reclaim)
L
Linus Torvalds 已提交
890 891
{
	LIST_HEAD(ret_pages);
892
	LIST_HEAD(free_pages);
L
Linus Torvalds 已提交
893
	int pgactivate = 0;
894 895 896 897 898 899
	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;
900 901
	unsigned nr_ref_keep = 0;
	unsigned nr_unmap_fail = 0;
L
Linus Torvalds 已提交
902 903 904 905 906 907 908

	cond_resched();

	while (!list_empty(page_list)) {
		struct address_space *mapping;
		struct page *page;
		int may_enter_fs;
909
		enum page_references references = PAGEREF_RECLAIM_CLEAN;
910
		bool dirty, writeback;
L
Linus Torvalds 已提交
911 912 913 914 915 916

		cond_resched();

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

N
Nick Piggin 已提交
917
		if (!trylock_page(page))
L
Linus Torvalds 已提交
918 919
			goto keep;

920
		VM_BUG_ON_PAGE(PageActive(page), page);
L
Linus Torvalds 已提交
921 922

		sc->nr_scanned++;
923

924
		if (unlikely(!page_evictable(page)))
M
Minchan Kim 已提交
925
			goto activate_locked;
L
Lee Schermerhorn 已提交
926

927
		if (!sc->may_unmap && page_mapped(page))
928 929
			goto keep_locked;

L
Linus Torvalds 已提交
930
		/* Double the slab pressure for mapped and swapcache pages */
S
Shaohua Li 已提交
931 932
		if ((page_mapped(page) || PageSwapCache(page)) &&
		    !(PageAnon(page) && !PageSwapBacked(page)))
L
Linus Torvalds 已提交
933 934
			sc->nr_scanned++;

935 936 937
		may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
			(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));

938
		/*
939
		 * The number of dirty pages determines if a node is marked
940 941 942 943 944 945 946 947 948 949 950
		 * 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++;

951 952 953 954 955 956
		/*
		 * 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.
		 */
957
		mapping = page_mapping(page);
958
		if (((dirty || writeback) && mapping &&
959
		     inode_write_congested(mapping->host)) ||
960
		    (writeback && PageReclaim(page)))
961 962
			nr_congested++;

963 964 965 966 967 968 969 970 971 972 973
		/*
		 * 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
974 975
		 *    note that the LRU is being scanned too quickly and the
		 *    caller can stall after page list has been processed.
976
		 *
977
		 * 2) Global or new memcg reclaim encounters a page that is
978 979 980
		 *    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
981
		 *    reclaim and continue scanning.
982
		 *
983 984
		 *    Require may_enter_fs because we would wait on fs, which
		 *    may not have submitted IO yet. And the loop driver might
985 986 987 988 989
		 *    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.
		 *
990
		 * 3) Legacy memcg encounters a page that is already marked
991 992 993 994
		 *    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.
995 996 997 998 999 1000 1001 1002 1003
		 *
		 * 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.
1004
		 */
1005
		if (PageWriteback(page)) {
1006 1007 1008
			/* Case 1 above */
			if (current_is_kswapd() &&
			    PageReclaim(page) &&
M
Mel Gorman 已提交
1009
			    test_bit(PGDAT_WRITEBACK, &pgdat->flags)) {
1010
				nr_immediate++;
1011
				goto activate_locked;
1012 1013

			/* Case 2 above */
1014
			} else if (sane_reclaim(sc) ||
1015
			    !PageReclaim(page) || !may_enter_fs) {
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
				/*
				 * 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);
1028
				nr_writeback++;
1029
				goto activate_locked;
1030 1031 1032

			/* Case 3 above */
			} else {
1033
				unlock_page(page);
1034
				wait_on_page_writeback(page);
1035 1036 1037
				/* then go back and try same page again */
				list_add_tail(&page->lru, page_list);
				continue;
1038
			}
1039
		}
L
Linus Torvalds 已提交
1040

1041 1042 1043
		if (!force_reclaim)
			references = page_check_references(page, sc);

1044 1045
		switch (references) {
		case PAGEREF_ACTIVATE:
L
Linus Torvalds 已提交
1046
			goto activate_locked;
1047
		case PAGEREF_KEEP:
1048
			nr_ref_keep++;
1049
			goto keep_locked;
1050 1051 1052 1053
		case PAGEREF_RECLAIM:
		case PAGEREF_RECLAIM_CLEAN:
			; /* try to reclaim the page below */
		}
L
Linus Torvalds 已提交
1054 1055 1056 1057

		/*
		 * Anonymous process memory has backing store?
		 * Try to allocate it some swap space here.
S
Shaohua Li 已提交
1058
		 * Lazyfree page could be freed directly
L
Linus Torvalds 已提交
1059
		 */
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
		if (PageAnon(page) && PageSwapBacked(page)) {
			if (!PageSwapCache(page)) {
				if (!(sc->gfp_mask & __GFP_IO))
					goto keep_locked;
				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;
				}
				if (!add_to_swap(page)) {
					if (!PageTransHuge(page))
						goto activate_locked;
					/* Fallback to swap normal pages */
					if (split_huge_page_to_list(page,
								    page_list))
						goto activate_locked;
1085 1086 1087
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
					count_vm_event(THP_SWPOUT_FALLBACK);
#endif
1088 1089 1090
					if (!add_to_swap(page))
						goto activate_locked;
				}
1091

1092
				may_enter_fs = 1;
L
Linus Torvalds 已提交
1093

1094 1095 1096
				/* Adding to swap updated mapping */
				mapping = page_mapping(page);
			}
1097 1098 1099 1100
		} else if (unlikely(PageTransHuge(page))) {
			/* Split file THP */
			if (split_huge_page_to_list(page, page_list))
				goto keep_locked;
1101
		}
L
Linus Torvalds 已提交
1102 1103 1104 1105 1106

		/*
		 * The page is mapped into the page tables of one or more
		 * processes. Try to unmap it here.
		 */
S
Shaohua Li 已提交
1107
		if (page_mapped(page)) {
1108 1109 1110 1111 1112
			enum ttu_flags flags = ttu_flags | TTU_BATCH_FLUSH;

			if (unlikely(PageTransHuge(page)))
				flags |= TTU_SPLIT_HUGE_PMD;
			if (!try_to_unmap(page, flags)) {
1113
				nr_unmap_fail++;
L
Linus Torvalds 已提交
1114 1115 1116 1117 1118
				goto activate_locked;
			}
		}

		if (PageDirty(page)) {
1119
			/*
1120 1121 1122 1123 1124 1125 1126 1127
			 * 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).
1128
			 */
1129
			if (page_is_file_cache(page) &&
1130 1131
			    (!current_is_kswapd() || !PageReclaim(page) ||
			     !test_bit(PGDAT_DIRTY, &pgdat->flags))) {
1132 1133 1134 1135 1136 1137
				/*
				 * Immediately reclaim when written back.
				 * Similar in principal to deactivate_page()
				 * except we already have the page isolated
				 * and know it's dirty
				 */
1138
				inc_node_page_state(page, NR_VMSCAN_IMMEDIATE);
1139 1140
				SetPageReclaim(page);

1141
				goto activate_locked;
1142 1143
			}

1144
			if (references == PAGEREF_RECLAIM_CLEAN)
L
Linus Torvalds 已提交
1145
				goto keep_locked;
1146
			if (!may_enter_fs)
L
Linus Torvalds 已提交
1147
				goto keep_locked;
1148
			if (!sc->may_writepage)
L
Linus Torvalds 已提交
1149 1150
				goto keep_locked;

1151 1152 1153 1154 1155 1156
			/*
			 * 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();
1157
			switch (pageout(page, mapping, sc)) {
L
Linus Torvalds 已提交
1158 1159 1160 1161 1162
			case PAGE_KEEP:
				goto keep_locked;
			case PAGE_ACTIVATE:
				goto activate_locked;
			case PAGE_SUCCESS:
1163
				if (PageWriteback(page))
1164
					goto keep;
1165
				if (PageDirty(page))
L
Linus Torvalds 已提交
1166
					goto keep;
1167

L
Linus Torvalds 已提交
1168 1169 1170 1171
				/*
				 * A synchronous write - probably a ramdisk.  Go
				 * ahead and try to reclaim the page.
				 */
N
Nick Piggin 已提交
1172
				if (!trylock_page(page))
L
Linus Torvalds 已提交
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
					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 已提交
1192
		 * will do this, as well as the blockdev mapping.
L
Linus Torvalds 已提交
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
		 * 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.
		 */
1203
		if (page_has_private(page)) {
L
Linus Torvalds 已提交
1204 1205
			if (!try_to_release_page(page, sc->gfp_mask))
				goto activate_locked;
N
Nick Piggin 已提交
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
			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 已提交
1222 1223
		}

S
Shaohua Li 已提交
1224 1225 1226 1227 1228 1229 1230 1231
		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 已提交
1232

S
Shaohua Li 已提交
1233
			count_vm_event(PGLAZYFREED);
1234
			count_memcg_page_event(page, PGLAZYFREED);
S
Shaohua Li 已提交
1235 1236
		} else if (!mapping || !__remove_mapping(mapping, page, true))
			goto keep_locked;
N
Nick Piggin 已提交
1237 1238 1239 1240 1241 1242 1243
		/*
		 * 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.
		 */
1244
		__ClearPageLocked(page);
N
Nick Piggin 已提交
1245
free_it:
1246
		nr_reclaimed++;
1247 1248 1249 1250 1251

		/*
		 * Is there need to periodically free_page_list? It would
		 * appear not as the counts should be low
		 */
1252 1253 1254 1255 1256
		if (unlikely(PageTransHuge(page))) {
			mem_cgroup_uncharge(page);
			(*get_compound_page_dtor(page))(page);
		} else
			list_add(&page->lru, &free_pages);
L
Linus Torvalds 已提交
1257 1258 1259
		continue;

activate_locked:
1260
		/* Not a candidate for swapping, so reclaim swap space. */
M
Minchan Kim 已提交
1261 1262
		if (PageSwapCache(page) && (mem_cgroup_swap_full(page) ||
						PageMlocked(page)))
1263
			try_to_free_swap(page);
1264
		VM_BUG_ON_PAGE(PageActive(page), page);
M
Minchan Kim 已提交
1265 1266 1267
		if (!PageMlocked(page)) {
			SetPageActive(page);
			pgactivate++;
1268
			count_memcg_page_event(page, PGACTIVATE);
M
Minchan Kim 已提交
1269
		}
L
Linus Torvalds 已提交
1270 1271 1272 1273
keep_locked:
		unlock_page(page);
keep:
		list_add(&page->lru, &ret_pages);
1274
		VM_BUG_ON_PAGE(PageLRU(page) || PageUnevictable(page), page);
L
Linus Torvalds 已提交
1275
	}
1276

1277
	mem_cgroup_uncharge_list(&free_pages);
1278
	try_to_unmap_flush();
1279
	free_unref_page_list(&free_pages);
1280

L
Linus Torvalds 已提交
1281
	list_splice(&ret_pages, page_list);
1282
	count_vm_events(PGACTIVATE, pgactivate);
1283

1284 1285 1286 1287 1288 1289
	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;
1290 1291 1292
		stat->nr_activate = pgactivate;
		stat->nr_ref_keep = nr_ref_keep;
		stat->nr_unmap_fail = nr_unmap_fail;
1293
	}
1294
	return nr_reclaimed;
L
Linus Torvalds 已提交
1295 1296
}

1297 1298 1299 1300 1301 1302 1303 1304
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,
	};
1305
	unsigned long ret;
1306 1307 1308 1309
	struct page *page, *next;
	LIST_HEAD(clean_pages);

	list_for_each_entry_safe(page, next, page_list, lru) {
1310
		if (page_is_file_cache(page) && !PageDirty(page) &&
1311
		    !__PageMovable(page)) {
1312 1313 1314 1315 1316
			ClearPageActive(page);
			list_move(&page->lru, &clean_pages);
		}
	}

M
Mel Gorman 已提交
1317
	ret = shrink_page_list(&clean_pages, zone->zone_pgdat, &sc,
S
Shaohua Li 已提交
1318
			TTU_IGNORE_ACCESS, NULL, true);
1319
	list_splice(&clean_pages, page_list);
M
Mel Gorman 已提交
1320
	mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_FILE, -ret);
1321 1322 1323
	return ret;
}

A
Andy Whitcroft 已提交
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
/*
 * 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.
 */
1334
int __isolate_lru_page(struct page *page, isolate_mode_t mode)
A
Andy Whitcroft 已提交
1335 1336 1337 1338 1339 1340 1341
{
	int ret = -EINVAL;

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

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

A
Andy Whitcroft 已提交
1346
	ret = -EBUSY;
K
KAMEZAWA Hiroyuki 已提交
1347

1348 1349 1350 1351 1352 1353 1354 1355
	/*
	 * 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
	 */
1356
	if (mode & ISOLATE_ASYNC_MIGRATE) {
1357 1358 1359 1360 1361 1362
		/* All the caller can do on PageWriteback is block */
		if (PageWriteback(page))
			return ret;

		if (PageDirty(page)) {
			struct address_space *mapping;
1363
			bool migrate_dirty;
1364 1365 1366 1367

			/*
			 * Only pages without mappings or that have a
			 * ->migratepage callback are possible to migrate
1368 1369 1370 1371 1372
			 * without blocking. However, we can be racing with
			 * truncation so it's necessary to lock the page
			 * to stabilise the mapping as truncation holds
			 * the page lock until after the page is removed
			 * from the page cache.
1373
			 */
1374 1375 1376
			if (!trylock_page(page))
				return ret;

1377
			mapping = page_mapping(page);
1378 1379 1380
			migrate_dirty = mapping && mapping->a_ops->migratepage;
			unlock_page(page);
			if (!migrate_dirty)
1381 1382 1383
				return ret;
		}
	}
1384

1385 1386 1387
	if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
		return ret;

A
Andy Whitcroft 已提交
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
	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;
}

1401 1402 1403 1404 1405 1406

/*
 * 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,
1407
			enum lru_list lru, unsigned long *nr_zone_taken)
1408 1409 1410 1411 1412 1413 1414 1415 1416
{
	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
1417
		mem_cgroup_update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
1418
#endif
1419 1420
	}

1421 1422
}

L
Linus Torvalds 已提交
1423
/*
1424
 * zone_lru_lock is heavily contended.  Some of the functions that
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429 1430 1431 1432
 * 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.
 *
1433
 * @nr_to_scan:	The number of eligible pages to look through on the list.
1434
 * @lruvec:	The LRU vector to pull pages from.
L
Linus Torvalds 已提交
1435
 * @dst:	The temp list to put pages on to.
H
Hugh Dickins 已提交
1436
 * @nr_scanned:	The number of pages that were scanned.
1437
 * @sc:		The scan_control struct for this reclaim session
A
Andy Whitcroft 已提交
1438
 * @mode:	One of the LRU isolation modes
1439
 * @lru:	LRU list id for isolating
L
Linus Torvalds 已提交
1440 1441 1442
 *
 * returns how many pages were moved onto *@dst.
 */
1443
static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
1444
		struct lruvec *lruvec, struct list_head *dst,
1445
		unsigned long *nr_scanned, struct scan_control *sc,
1446
		isolate_mode_t mode, enum lru_list lru)
L
Linus Torvalds 已提交
1447
{
H
Hugh Dickins 已提交
1448
	struct list_head *src = &lruvec->lists[lru];
1449
	unsigned long nr_taken = 0;
M
Mel Gorman 已提交
1450
	unsigned long nr_zone_taken[MAX_NR_ZONES] = { 0 };
1451
	unsigned long nr_skipped[MAX_NR_ZONES] = { 0, };
1452
	unsigned long skipped = 0;
1453
	unsigned long scan, total_scan, nr_pages;
1454
	LIST_HEAD(pages_skipped);
L
Linus Torvalds 已提交
1455

1456 1457 1458 1459
	scan = 0;
	for (total_scan = 0;
	     scan < nr_to_scan && nr_taken < nr_to_scan && !list_empty(src);
	     total_scan++) {
A
Andy Whitcroft 已提交
1460 1461
		struct page *page;

L
Linus Torvalds 已提交
1462 1463 1464
		page = lru_to_page(src);
		prefetchw_prev_lru_page(page, src, flags);

1465
		VM_BUG_ON_PAGE(!PageLRU(page), page);
N
Nick Piggin 已提交
1466

1467 1468
		if (page_zonenum(page) > sc->reclaim_idx) {
			list_move(&page->lru, &pages_skipped);
1469
			nr_skipped[page_zonenum(page)]++;
1470 1471 1472
			continue;
		}

1473 1474 1475 1476 1477 1478 1479
		/*
		 * 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++;
1480
		switch (__isolate_lru_page(page, mode)) {
A
Andy Whitcroft 已提交
1481
		case 0:
M
Mel Gorman 已提交
1482 1483 1484
			nr_pages = hpage_nr_pages(page);
			nr_taken += nr_pages;
			nr_zone_taken[page_zonenum(page)] += nr_pages;
A
Andy Whitcroft 已提交
1485 1486 1487 1488 1489 1490 1491
			list_move(&page->lru, dst);
			break;

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

A
Andy Whitcroft 已提交
1493 1494 1495
		default:
			BUG();
		}
L
Linus Torvalds 已提交
1496 1497
	}

1498 1499 1500 1501 1502 1503 1504
	/*
	 * 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.
	 */
1505 1506 1507
	if (!list_empty(&pages_skipped)) {
		int zid;

1508
		list_splice(&pages_skipped, src);
1509 1510 1511 1512 1513
		for (zid = 0; zid < MAX_NR_ZONES; zid++) {
			if (!nr_skipped[zid])
				continue;

			__count_zid_vm_events(PGSCAN_SKIP, zid, nr_skipped[zid]);
1514
			skipped += nr_skipped[zid];
1515 1516
		}
	}
1517
	*nr_scanned = total_scan;
1518
	trace_mm_vmscan_lru_isolate(sc->reclaim_idx, sc->order, nr_to_scan,
1519
				    total_scan, skipped, nr_taken, mode, lru);
1520
	update_lru_sizes(lruvec, lru, nr_zone_taken);
L
Linus Torvalds 已提交
1521 1522 1523
	return nr_taken;
}

1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
/**
 * 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 已提交
1535 1536 1537
 * 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.
1538 1539 1540 1541 1542
 *
 * The vmstat statistic corresponding to the list on which the page was
 * found will be decremented.
 *
 * Restrictions:
1543
 *
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
 * (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;

1554
	VM_BUG_ON_PAGE(!page_count(page), page);
1555
	WARN_RATELIMIT(PageTail(page), "trying to isolate tail page");
1556

1557 1558
	if (PageLRU(page)) {
		struct zone *zone = page_zone(page);
1559
		struct lruvec *lruvec;
1560

1561
		spin_lock_irq(zone_lru_lock(zone));
M
Mel Gorman 已提交
1562
		lruvec = mem_cgroup_page_lruvec(page, zone->zone_pgdat);
1563
		if (PageLRU(page)) {
L
Lee Schermerhorn 已提交
1564
			int lru = page_lru(page);
1565
			get_page(page);
1566
			ClearPageLRU(page);
1567 1568
			del_page_from_lru_list(page, lruvec, lru);
			ret = 0;
1569
		}
1570
		spin_unlock_irq(zone_lru_lock(zone));
1571 1572 1573 1574
	}
	return ret;
}

1575
/*
F
Fengguang Wu 已提交
1576 1577 1578 1579 1580
 * 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.
1581
 */
M
Mel Gorman 已提交
1582
static int too_many_isolated(struct pglist_data *pgdat, int file,
1583 1584 1585 1586 1587 1588 1589
		struct scan_control *sc)
{
	unsigned long inactive, isolated;

	if (current_is_kswapd())
		return 0;

1590
	if (!sane_reclaim(sc))
1591 1592 1593
		return 0;

	if (file) {
M
Mel Gorman 已提交
1594 1595
		inactive = node_page_state(pgdat, NR_INACTIVE_FILE);
		isolated = node_page_state(pgdat, NR_ISOLATED_FILE);
1596
	} else {
M
Mel Gorman 已提交
1597 1598
		inactive = node_page_state(pgdat, NR_INACTIVE_ANON);
		isolated = node_page_state(pgdat, NR_ISOLATED_ANON);
1599 1600
	}

1601 1602 1603 1604 1605
	/*
	 * 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.
	 */
1606
	if ((sc->gfp_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
1607 1608
		inactive >>= 3;

1609 1610 1611
	return isolated > inactive;
}

1612
static noinline_for_stack void
H
Hugh Dickins 已提交
1613
putback_inactive_pages(struct lruvec *lruvec, struct list_head *page_list)
1614
{
1615
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
M
Mel Gorman 已提交
1616
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1617
	LIST_HEAD(pages_to_free);
1618 1619 1620 1621 1622

	/*
	 * Put back any unfreeable pages.
	 */
	while (!list_empty(page_list)) {
1623
		struct page *page = lru_to_page(page_list);
1624
		int lru;
1625

1626
		VM_BUG_ON_PAGE(PageLRU(page), page);
1627
		list_del(&page->lru);
1628
		if (unlikely(!page_evictable(page))) {
M
Mel Gorman 已提交
1629
			spin_unlock_irq(&pgdat->lru_lock);
1630
			putback_lru_page(page);
M
Mel Gorman 已提交
1631
			spin_lock_irq(&pgdat->lru_lock);
1632 1633
			continue;
		}
1634

M
Mel Gorman 已提交
1635
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
1636

1637
		SetPageLRU(page);
1638
		lru = page_lru(page);
1639 1640
		add_page_to_lru_list(page, lruvec, lru);

1641 1642
		if (is_active_lru(lru)) {
			int file = is_file_lru(lru);
1643 1644
			int numpages = hpage_nr_pages(page);
			reclaim_stat->recent_rotated[file] += numpages;
1645
		}
1646 1647 1648
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
1649
			del_page_from_lru_list(page, lruvec, lru);
1650 1651

			if (unlikely(PageCompound(page))) {
M
Mel Gorman 已提交
1652
				spin_unlock_irq(&pgdat->lru_lock);
1653
				mem_cgroup_uncharge(page);
1654
				(*get_compound_page_dtor(page))(page);
M
Mel Gorman 已提交
1655
				spin_lock_irq(&pgdat->lru_lock);
1656 1657
			} else
				list_add(&page->lru, &pages_to_free);
1658 1659 1660
		}
	}

1661 1662 1663 1664
	/*
	 * To save our caller's stack, now use input list for pages to free.
	 */
	list_splice(&pages_to_free, page_list);
1665 1666
}

1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
/*
 * 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 已提交
1680
/*
1681
 * shrink_inactive_list() is a helper for shrink_node().  It returns the number
A
Andrew Morton 已提交
1682
 * of reclaimed pages
L
Linus Torvalds 已提交
1683
 */
1684
static noinline_for_stack unsigned long
1685
shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
1686
		     struct scan_control *sc, enum lru_list lru)
L
Linus Torvalds 已提交
1687 1688
{
	LIST_HEAD(page_list);
1689
	unsigned long nr_scanned;
1690
	unsigned long nr_reclaimed = 0;
1691
	unsigned long nr_taken;
1692
	struct reclaim_stat stat = {};
1693
	isolate_mode_t isolate_mode = 0;
1694
	int file = is_file_lru(lru);
M
Mel Gorman 已提交
1695
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1696
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1697
	bool stalled = false;
1698

M
Mel Gorman 已提交
1699
	while (unlikely(too_many_isolated(pgdat, file, sc))) {
1700 1701 1702 1703 1704 1705
		if (stalled)
			return 0;

		/* wait a bit for the reclaimer. */
		msleep(100);
		stalled = true;
1706 1707 1708 1709 1710 1711

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

L
Linus Torvalds 已提交
1712
	lru_add_drain();
1713 1714

	if (!sc->may_unmap)
1715
		isolate_mode |= ISOLATE_UNMAPPED;
1716

M
Mel Gorman 已提交
1717
	spin_lock_irq(&pgdat->lru_lock);
1718

1719 1720
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &page_list,
				     &nr_scanned, sc, isolate_mode, lru);
1721

M
Mel Gorman 已提交
1722
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1723
	reclaim_stat->recent_scanned[file] += nr_taken;
1724

1725 1726
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1727
			__count_vm_events(PGSCAN_KSWAPD, nr_scanned);
1728 1729 1730 1731
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_KSWAPD,
				   nr_scanned);
	} else {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1732
			__count_vm_events(PGSCAN_DIRECT, nr_scanned);
1733 1734
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_DIRECT,
				   nr_scanned);
1735
	}
M
Mel Gorman 已提交
1736
	spin_unlock_irq(&pgdat->lru_lock);
1737

1738
	if (nr_taken == 0)
1739
		return 0;
A
Andy Whitcroft 已提交
1740

S
Shaohua Li 已提交
1741
	nr_reclaimed = shrink_page_list(&page_list, pgdat, sc, 0,
1742
				&stat, false);
1743

M
Mel Gorman 已提交
1744
	spin_lock_irq(&pgdat->lru_lock);
1745

1746 1747
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1748
			__count_vm_events(PGSTEAL_KSWAPD, nr_reclaimed);
1749 1750 1751 1752
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_KSWAPD,
				   nr_reclaimed);
	} else {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1753
			__count_vm_events(PGSTEAL_DIRECT, nr_reclaimed);
1754 1755
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_DIRECT,
				   nr_reclaimed);
Y
Ying Han 已提交
1756
	}
N
Nick Piggin 已提交
1757

1758
	putback_inactive_pages(lruvec, &page_list);
1759

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

M
Mel Gorman 已提交
1762
	spin_unlock_irq(&pgdat->lru_lock);
1763

1764
	mem_cgroup_uncharge_list(&page_list);
1765
	free_unref_page_list(&page_list);
1766

1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
	/*
	 * If dirty pages are scanned that are not queued for IO, it
	 * 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.
	 */
	if (stat.nr_unqueued_dirty == nr_taken)
		wakeup_flusher_threads(WB_REASON_VMSCAN);

1781 1782 1783 1784 1785 1786 1787 1788
	sc->nr.dirty += stat.nr_dirty;
	sc->nr.congested += stat.nr_congested;
	sc->nr.unqueued_dirty += stat.nr_unqueued_dirty;
	sc->nr.writeback += stat.nr_writeback;
	sc->nr.immediate += stat.nr_immediate;
	sc->nr.taken += nr_taken;
	if (file)
		sc->nr.file_taken += nr_taken;
1789

M
Mel Gorman 已提交
1790 1791
	trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
			nr_scanned, nr_reclaimed,
1792 1793 1794 1795
			stat.nr_dirty,  stat.nr_writeback,
			stat.nr_congested, stat.nr_immediate,
			stat.nr_activate, stat.nr_ref_keep,
			stat.nr_unmap_fail,
1796
			sc->priority, file);
1797
	return nr_reclaimed;
L
Linus Torvalds 已提交
1798 1799 1800 1801 1802 1803 1804 1805 1806
}

/*
 * 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
1807
 * appropriate to hold zone_lru_lock across the whole operation.  But if
L
Linus Torvalds 已提交
1808
 * the pages are mapped, the processing is slow (page_referenced()) so we
1809
 * should drop zone_lru_lock around each page.  It's impossible to balance
L
Linus Torvalds 已提交
1810 1811 1812 1813
 * 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.
 *
1814
 * The downside is that we have to touch page->_refcount against each page.
L
Linus Torvalds 已提交
1815
 * But we had to alter page->flags anyway.
1816 1817
 *
 * Returns the number of pages moved to the given lru.
L
Linus Torvalds 已提交
1818
 */
1819

1820
static unsigned move_active_pages_to_lru(struct lruvec *lruvec,
1821
				     struct list_head *list,
1822
				     struct list_head *pages_to_free,
1823 1824
				     enum lru_list lru)
{
M
Mel Gorman 已提交
1825
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1826
	struct page *page;
1827
	int nr_pages;
1828
	int nr_moved = 0;
1829 1830 1831

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

1834
		VM_BUG_ON_PAGE(PageLRU(page), page);
1835 1836
		SetPageLRU(page);

1837
		nr_pages = hpage_nr_pages(page);
M
Mel Gorman 已提交
1838
		update_lru_size(lruvec, lru, page_zonenum(page), nr_pages);
1839
		list_move(&page->lru, &lruvec->lists[lru]);
1840

1841 1842 1843
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
1844
			del_page_from_lru_list(page, lruvec, lru);
1845 1846

			if (unlikely(PageCompound(page))) {
M
Mel Gorman 已提交
1847
				spin_unlock_irq(&pgdat->lru_lock);
1848
				mem_cgroup_uncharge(page);
1849
				(*get_compound_page_dtor(page))(page);
M
Mel Gorman 已提交
1850
				spin_lock_irq(&pgdat->lru_lock);
1851 1852
			} else
				list_add(&page->lru, pages_to_free);
1853 1854
		} else {
			nr_moved += nr_pages;
1855 1856
		}
	}
1857

1858
	if (!is_active_lru(lru)) {
1859
		__count_vm_events(PGDEACTIVATE, nr_moved);
1860 1861 1862
		count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE,
				   nr_moved);
	}
1863 1864

	return nr_moved;
1865
}
1866

H
Hugh Dickins 已提交
1867
static void shrink_active_list(unsigned long nr_to_scan,
1868
			       struct lruvec *lruvec,
1869
			       struct scan_control *sc,
1870
			       enum lru_list lru)
L
Linus Torvalds 已提交
1871
{
1872
	unsigned long nr_taken;
H
Hugh Dickins 已提交
1873
	unsigned long nr_scanned;
1874
	unsigned long vm_flags;
L
Linus Torvalds 已提交
1875
	LIST_HEAD(l_hold);	/* The pages which were snipped off */
1876
	LIST_HEAD(l_active);
1877
	LIST_HEAD(l_inactive);
L
Linus Torvalds 已提交
1878
	struct page *page;
1879
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1880 1881
	unsigned nr_deactivate, nr_activate;
	unsigned nr_rotated = 0;
1882
	isolate_mode_t isolate_mode = 0;
1883
	int file = is_file_lru(lru);
M
Mel Gorman 已提交
1884
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
L
Linus Torvalds 已提交
1885 1886

	lru_add_drain();
1887 1888

	if (!sc->may_unmap)
1889
		isolate_mode |= ISOLATE_UNMAPPED;
1890

M
Mel Gorman 已提交
1891
	spin_lock_irq(&pgdat->lru_lock);
1892

1893 1894
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &l_hold,
				     &nr_scanned, sc, isolate_mode, lru);
1895

M
Mel Gorman 已提交
1896
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1897
	reclaim_stat->recent_scanned[file] += nr_taken;
1898

M
Mel Gorman 已提交
1899
	__count_vm_events(PGREFILL, nr_scanned);
1900
	count_memcg_events(lruvec_memcg(lruvec), PGREFILL, nr_scanned);
1901

M
Mel Gorman 已提交
1902
	spin_unlock_irq(&pgdat->lru_lock);
L
Linus Torvalds 已提交
1903 1904 1905 1906 1907

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

1909
		if (unlikely(!page_evictable(page))) {
L
Lee Schermerhorn 已提交
1910 1911 1912 1913
			putback_lru_page(page);
			continue;
		}

1914 1915 1916 1917 1918 1919 1920 1921
		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);
			}
		}

1922 1923
		if (page_referenced(page, 0, sc->target_mem_cgroup,
				    &vm_flags)) {
1924
			nr_rotated += hpage_nr_pages(page);
1925 1926 1927 1928 1929 1930 1931 1932 1933
			/*
			 * 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.
			 */
1934
			if ((vm_flags & VM_EXEC) && page_is_file_cache(page)) {
1935 1936 1937 1938
				list_add(&page->lru, &l_active);
				continue;
			}
		}
1939

1940
		ClearPageActive(page);	/* we are de-activating */
L
Linus Torvalds 已提交
1941 1942 1943
		list_add(&page->lru, &l_inactive);
	}

1944
	/*
1945
	 * Move pages back to the lru list.
1946
	 */
M
Mel Gorman 已提交
1947
	spin_lock_irq(&pgdat->lru_lock);
1948
	/*
1949 1950 1951
	 * 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
1952
	 * get_scan_count.
1953
	 */
1954
	reclaim_stat->recent_rotated[file] += nr_rotated;
1955

1956 1957
	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 已提交
1958 1959
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
	spin_unlock_irq(&pgdat->lru_lock);
1960

1961
	mem_cgroup_uncharge_list(&l_hold);
1962
	free_unref_page_list(&l_hold);
1963 1964
	trace_mm_vmscan_lru_shrink_active(pgdat->node_id, nr_taken, nr_activate,
			nr_deactivate, nr_rotated, sc->priority, file);
L
Linus Torvalds 已提交
1965 1966
}

1967 1968 1969
/*
 * The inactive anon list should be small enough that the VM never has
 * to do too much work.
1970
 *
1971 1972 1973
 * 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.
1974
 *
1975 1976
 * Both inactive lists should also be large enough that each inactive
 * page has a chance to be referenced again before it is reclaimed.
1977
 *
1978 1979
 * If that fails and refaulting is observed, the inactive list grows.
 *
1980
 * The inactive_ratio is the target ratio of ACTIVE to INACTIVE pages
1981
 * on this LRU, maintained by the pageout code. An inactive_ratio
1982
 * of 3 means 3:1 or 25% of the pages are kept on the inactive list.
1983
 *
1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
 * 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
1994
 */
1995
static bool inactive_list_is_low(struct lruvec *lruvec, bool file,
1996 1997
				 struct mem_cgroup *memcg,
				 struct scan_control *sc, bool actual_reclaim)
1998
{
1999
	enum lru_list active_lru = file * LRU_FILE + LRU_ACTIVE;
2000 2001 2002 2003 2004
	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;
2005
	unsigned long gb;
2006

2007 2008 2009 2010 2011 2012
	/*
	 * If we don't have swap space, anonymous page deactivation
	 * is pointless.
	 */
	if (!file && !total_swap_pages)
		return false;
2013

2014 2015
	inactive = lruvec_lru_size(lruvec, inactive_lru, sc->reclaim_idx);
	active = lruvec_lru_size(lruvec, active_lru, sc->reclaim_idx);
2016

2017
	if (memcg)
2018
		refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
2019
	else
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035
		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;
	}
2036

2037 2038 2039 2040 2041
	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);
2042

2043
	return inactive * inactive_ratio < active;
2044 2045
}

2046
static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
2047 2048
				 struct lruvec *lruvec, struct mem_cgroup *memcg,
				 struct scan_control *sc)
2049
{
2050
	if (is_active_lru(lru)) {
2051 2052
		if (inactive_list_is_low(lruvec, is_file_lru(lru),
					 memcg, sc, true))
2053
			shrink_active_list(nr_to_scan, lruvec, sc, lru);
2054 2055 2056
		return 0;
	}

2057
	return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);
2058 2059
}

2060 2061 2062 2063 2064 2065 2066
enum scan_balance {
	SCAN_EQUAL,
	SCAN_FRACT,
	SCAN_ANON,
	SCAN_FILE,
};

2067 2068 2069 2070 2071 2072
/*
 * 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 已提交
2073 2074
 * 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
2075
 */
2076
static void get_scan_count(struct lruvec *lruvec, struct mem_cgroup *memcg,
2077 2078
			   struct scan_control *sc, unsigned long *nr,
			   unsigned long *lru_pages)
2079
{
2080
	int swappiness = mem_cgroup_swappiness(memcg);
2081 2082 2083
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
	u64 fraction[2];
	u64 denominator = 0;	/* gcc */
M
Mel Gorman 已提交
2084
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2085
	unsigned long anon_prio, file_prio;
2086
	enum scan_balance scan_balance;
2087
	unsigned long anon, file;
2088
	unsigned long ap, fp;
H
Hugh Dickins 已提交
2089
	enum lru_list lru;
2090 2091

	/* If we have no swap space, do not bother scanning anon pages. */
2092
	if (!sc->may_swap || mem_cgroup_get_nr_swap_pages(memcg) <= 0) {
2093
		scan_balance = SCAN_FILE;
2094 2095
		goto out;
	}
2096

2097 2098 2099 2100 2101 2102 2103
	/*
	 * 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.
	 */
2104
	if (!global_reclaim(sc) && !swappiness) {
2105
		scan_balance = SCAN_FILE;
2106 2107 2108 2109 2110 2111 2112 2113
		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).
	 */
2114
	if (!sc->priority && swappiness) {
2115
		scan_balance = SCAN_EQUAL;
2116 2117 2118
		goto out;
	}

2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
	/*
	 * 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 已提交
2129 2130 2131 2132
		unsigned long pgdatfile;
		unsigned long pgdatfree;
		int z;
		unsigned long total_high_wmark = 0;
2133

M
Mel Gorman 已提交
2134 2135 2136 2137 2138 2139
		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];
2140
			if (!managed_zone(zone))
M
Mel Gorman 已提交
2141 2142 2143 2144
				continue;

			total_high_wmark += high_wmark_pages(zone);
		}
2145

M
Mel Gorman 已提交
2146
		if (unlikely(pgdatfile + pgdatfree <= total_high_wmark)) {
2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157
			/*
			 * 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;
			}
2158 2159 2160
		}
	}

2161
	/*
2162 2163 2164 2165 2166 2167 2168
	 * 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.
2169
	 */
2170
	if (!inactive_list_is_low(lruvec, true, memcg, sc, false) &&
2171
	    lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
2172
		scan_balance = SCAN_FILE;
2173 2174 2175
		goto out;
	}

2176 2177
	scan_balance = SCAN_FRACT;

2178 2179 2180 2181
	/*
	 * With swappiness at 100, anonymous and file have the same priority.
	 * This scanning priority is essentially the inverse of IO cost.
	 */
2182
	anon_prio = swappiness;
H
Hugh Dickins 已提交
2183
	file_prio = 200 - anon_prio;
2184

2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
	/*
	 * 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]
	 */
2196

2197 2198 2199 2200
	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);
2201

M
Mel Gorman 已提交
2202
	spin_lock_irq(&pgdat->lru_lock);
2203 2204 2205
	if (unlikely(reclaim_stat->recent_scanned[0] > anon / 4)) {
		reclaim_stat->recent_scanned[0] /= 2;
		reclaim_stat->recent_rotated[0] /= 2;
2206 2207
	}

2208 2209 2210
	if (unlikely(reclaim_stat->recent_scanned[1] > file / 4)) {
		reclaim_stat->recent_scanned[1] /= 2;
		reclaim_stat->recent_rotated[1] /= 2;
2211 2212 2213
	}

	/*
2214 2215 2216
	 * 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.
2217
	 */
2218
	ap = anon_prio * (reclaim_stat->recent_scanned[0] + 1);
2219
	ap /= reclaim_stat->recent_rotated[0] + 1;
2220

2221
	fp = file_prio * (reclaim_stat->recent_scanned[1] + 1);
2222
	fp /= reclaim_stat->recent_rotated[1] + 1;
M
Mel Gorman 已提交
2223
	spin_unlock_irq(&pgdat->lru_lock);
2224

2225 2226 2227 2228
	fraction[0] = ap;
	fraction[1] = fp;
	denominator = ap + fp + 1;
out:
2229 2230 2231 2232 2233
	*lru_pages = 0;
	for_each_evictable_lru(lru) {
		int file = is_file_lru(lru);
		unsigned long size;
		unsigned long scan;
2234

2235 2236 2237 2238 2239 2240 2241 2242
		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);
2243

2244 2245 2246 2247 2248
		switch (scan_balance) {
		case SCAN_EQUAL:
			/* Scan lists relative to size */
			break;
		case SCAN_FRACT:
2249
			/*
2250 2251
			 * Scan types proportional to swappiness and
			 * their relative recent reclaim efficiency.
2252
			 */
2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266
			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();
2267
		}
2268 2269 2270

		*lru_pages += size;
		nr[lru] = scan;
2271
	}
2272
}
2273

2274
/*
2275
 * This is a basic per-node page freer.  Used by both kswapd and direct reclaim.
2276
 */
2277
static void shrink_node_memcg(struct pglist_data *pgdat, struct mem_cgroup *memcg,
2278
			      struct scan_control *sc, unsigned long *lru_pages)
2279
{
2280
	struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
2281
	unsigned long nr[NR_LRU_LISTS];
2282
	unsigned long targets[NR_LRU_LISTS];
2283 2284 2285 2286 2287
	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;
2288
	bool scan_adjusted;
2289

2290
	get_scan_count(lruvec, memcg, sc, nr, lru_pages);
2291

2292 2293 2294
	/* Record the original scan target for proportional adjustments later */
	memcpy(targets, nr, sizeof(nr));

2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
	/*
	 * 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);

2309 2310 2311
	blk_start_plug(&plug);
	while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
					nr[LRU_INACTIVE_FILE]) {
2312 2313 2314
		unsigned long nr_anon, nr_file, percentage;
		unsigned long nr_scanned;

2315 2316 2317 2318 2319 2320
		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,
2321
							    lruvec, memcg, sc);
2322 2323
			}
		}
2324

2325 2326
		cond_resched();

2327 2328 2329 2330 2331
		if (nr_reclaimed < nr_to_reclaim || scan_adjusted)
			continue;

		/*
		 * For kswapd and memcg, reclaim at least the number of pages
2332
		 * requested. Ensure that the anon and file LRUs are scanned
2333 2334 2335 2336 2337 2338 2339
		 * 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];

2340 2341 2342 2343 2344 2345 2346 2347 2348
		/*
		 * 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;

2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
		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;
2380 2381 2382 2383 2384 2385 2386 2387
	}
	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.
	 */
2388
	if (inactive_list_is_low(lruvec, false, memcg, sc, true))
2389 2390 2391 2392
		shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
				   sc, LRU_ACTIVE_ANON);
}

M
Mel Gorman 已提交
2393
/* Use reclaim/compaction for costly allocs or under memory pressure */
2394
static bool in_reclaim_compaction(struct scan_control *sc)
M
Mel Gorman 已提交
2395
{
2396
	if (IS_ENABLED(CONFIG_COMPACTION) && sc->order &&
M
Mel Gorman 已提交
2397
			(sc->order > PAGE_ALLOC_COSTLY_ORDER ||
2398
			 sc->priority < DEF_PRIORITY - 2))
M
Mel Gorman 已提交
2399 2400 2401 2402 2403
		return true;

	return false;
}

2404
/*
M
Mel Gorman 已提交
2405 2406 2407 2408 2409
 * 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.
2410
 */
2411
static inline bool should_continue_reclaim(struct pglist_data *pgdat,
2412 2413 2414 2415 2416 2417
					unsigned long nr_reclaimed,
					unsigned long nr_scanned,
					struct scan_control *sc)
{
	unsigned long pages_for_compaction;
	unsigned long inactive_lru_pages;
2418
	int z;
2419 2420

	/* If not in reclaim/compaction mode, stop */
2421
	if (!in_reclaim_compaction(sc))
2422 2423
		return false;

2424
	/* Consider stopping depending on scan and reclaim activity */
2425
	if (sc->gfp_mask & __GFP_RETRY_MAYFAIL) {
2426
		/*
2427
		 * For __GFP_RETRY_MAYFAIL allocations, stop reclaiming if the
2428 2429
		 * full LRU list has been scanned and we are still failing
		 * to reclaim pages. This full LRU scan is potentially
2430
		 * expensive but a __GFP_RETRY_MAYFAIL caller really wants to succeed
2431 2432 2433 2434 2435
		 */
		if (!nr_reclaimed && !nr_scanned)
			return false;
	} else {
		/*
2436
		 * For non-__GFP_RETRY_MAYFAIL allocations which can presumably
2437 2438 2439 2440 2441 2442 2443 2444 2445
		 * 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;
	}
2446 2447 2448 2449 2450

	/*
	 * If we have not reclaimed enough pages for compaction and the
	 * inactive lists are large enough, continue reclaiming
	 */
2451
	pages_for_compaction = compact_gap(sc->order);
2452
	inactive_lru_pages = node_page_state(pgdat, NR_INACTIVE_FILE);
2453
	if (get_nr_swap_pages() > 0)
2454
		inactive_lru_pages += node_page_state(pgdat, NR_INACTIVE_ANON);
2455 2456 2457 2458 2459
	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 */
2460 2461
	for (z = 0; z <= sc->reclaim_idx; z++) {
		struct zone *zone = &pgdat->node_zones[z];
2462
		if (!managed_zone(zone))
2463 2464 2465
			continue;

		switch (compaction_suitable(zone, sc->order, 0, sc->reclaim_idx)) {
2466
		case COMPACT_SUCCESS:
2467 2468 2469 2470 2471 2472
		case COMPACT_CONTINUE:
			return false;
		default:
			/* check next zone */
			;
		}
2473
	}
2474
	return true;
2475 2476
}

2477
static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc)
L
Linus Torvalds 已提交
2478
{
2479
	struct reclaim_state *reclaim_state = current->reclaim_state;
2480
	unsigned long nr_reclaimed, nr_scanned;
2481
	bool reclaimable = false;
L
Linus Torvalds 已提交
2482

2483 2484 2485
	do {
		struct mem_cgroup *root = sc->target_mem_cgroup;
		struct mem_cgroup_reclaim_cookie reclaim = {
2486
			.pgdat = pgdat,
2487 2488
			.priority = sc->priority,
		};
2489
		unsigned long node_lru_pages = 0;
2490
		struct mem_cgroup *memcg;
2491

2492 2493
		memset(&sc->nr, 0, sizeof(sc->nr));

2494 2495
		nr_reclaimed = sc->nr_reclaimed;
		nr_scanned = sc->nr_scanned;
L
Linus Torvalds 已提交
2496

2497 2498
		memcg = mem_cgroup_iter(root, NULL, &reclaim);
		do {
2499
			unsigned long lru_pages;
2500
			unsigned long reclaimed;
2501
			unsigned long scanned;
2502

2503
			if (mem_cgroup_low(root, memcg)) {
2504 2505
				if (!sc->memcg_low_reclaim) {
					sc->memcg_low_skipped = 1;
2506
					continue;
2507
				}
2508
				mem_cgroup_event(memcg, MEMCG_LOW);
2509 2510
			}

2511
			reclaimed = sc->nr_reclaimed;
2512
			scanned = sc->nr_scanned;
2513 2514
			shrink_node_memcg(pgdat, memcg, sc, &lru_pages);
			node_lru_pages += lru_pages;
2515

2516
			if (memcg)
2517
				shrink_slab(sc->gfp_mask, pgdat->node_id,
2518
					    memcg, sc->priority);
2519

2520 2521 2522 2523 2524
			/* Record the group's reclaim efficiency */
			vmpressure(sc->gfp_mask, memcg, false,
				   sc->nr_scanned - scanned,
				   sc->nr_reclaimed - reclaimed);

2525
			/*
2526 2527
			 * Direct reclaim and kswapd have to scan all memory
			 * cgroups to fulfill the overall scan target for the
2528
			 * node.
2529 2530 2531 2532 2533
			 *
			 * 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.
2534
			 */
2535 2536
			if (!global_reclaim(sc) &&
					sc->nr_reclaimed >= sc->nr_to_reclaim) {
2537 2538 2539
				mem_cgroup_iter_break(root, memcg);
				break;
			}
2540
		} while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));
2541

2542
		if (global_reclaim(sc))
2543
			shrink_slab(sc->gfp_mask, pgdat->node_id, NULL,
2544
				    sc->priority);
2545 2546 2547 2548

		if (reclaim_state) {
			sc->nr_reclaimed += reclaim_state->reclaimed_slab;
			reclaim_state->reclaimed_slab = 0;
2549 2550
		}

2551 2552
		/* Record the subtree's reclaim efficiency */
		vmpressure(sc->gfp_mask, sc->target_mem_cgroup, true,
2553 2554 2555
			   sc->nr_scanned - nr_scanned,
			   sc->nr_reclaimed - nr_reclaimed);

2556 2557 2558
		if (sc->nr_reclaimed - nr_reclaimed)
			reclaimable = true;

2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
		/*
		 * 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.
		 *
		 * Once a node is flagged PGDAT_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.
		 */
		if (sc->nr.writeback && sc->nr.writeback == sc->nr.taken)
			set_bit(PGDAT_WRITEBACK, &pgdat->flags);

		/*
		 * Legacy memcg will stall in page writeback so avoid forcibly
		 * stalling here.
		 */
		if (sane_reclaim(sc)) {
			/*
			 * Tag a node as congested if all the dirty pages
			 * scanned were backed by a congested BDI and
			 * wait_iff_congested will stall.
			 */
			if (sc->nr.dirty && sc->nr.dirty == sc->nr.congested)
				set_bit(PGDAT_CONGESTED, &pgdat->flags);

			/* Allow kswapd to start writing pages during reclaim.*/
			if (sc->nr.unqueued_dirty == sc->nr.file_taken)
				set_bit(PGDAT_DIRTY, &pgdat->flags);

			/*
			 * 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 they are written so also forcibly stall.
			 */
			if (sc->nr.immediate)
				congestion_wait(BLK_RW_ASYNC, HZ/10);
		}

		/*
		 * Stall direct reclaim for IO completions if underlying BDIs
		 * and node is congested. Allow kswapd to continue until it
		 * starts encountering unqueued dirty pages or cycling through
		 * the LRU too quickly.
		 */
		if (!sc->hibernation_mode && !current_is_kswapd() &&
		    current_may_throttle())
			wait_iff_congested(pgdat, BLK_RW_ASYNC, HZ/10);

2614
	} while (should_continue_reclaim(pgdat, sc->nr_reclaimed - nr_reclaimed,
2615
					 sc->nr_scanned - nr_scanned, sc));
2616

2617 2618 2619 2620 2621 2622 2623 2624 2625
	/*
	 * 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;

2626
	return reclaimable;
2627 2628
}

2629
/*
2630 2631 2632
 * 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.
2633
 */
2634
static inline bool compaction_ready(struct zone *zone, struct scan_control *sc)
2635
{
M
Mel Gorman 已提交
2636
	unsigned long watermark;
2637
	enum compact_result suitable;
2638

2639 2640 2641 2642 2643 2644 2645
	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;
2646

2647
	/*
2648 2649 2650 2651 2652 2653 2654
	 * 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.
2655
	 */
2656
	watermark = high_wmark_pages(zone) + compact_gap(sc->order);
2657

2658
	return zone_watermark_ok_safe(zone, 0, watermark, sc->reclaim_idx);
2659 2660
}

L
Linus Torvalds 已提交
2661 2662 2663 2664 2665 2666 2667 2668
/*
 * 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 已提交
2669
static void shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
L
Linus Torvalds 已提交
2670
{
2671
	struct zoneref *z;
2672
	struct zone *zone;
2673 2674
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
2675
	gfp_t orig_mask;
2676
	pg_data_t *last_pgdat = NULL;
2677

2678 2679 2680 2681 2682
	/*
	 * 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
	 */
2683
	orig_mask = sc->gfp_mask;
2684
	if (buffer_heads_over_limit) {
2685
		sc->gfp_mask |= __GFP_HIGHMEM;
2686
		sc->reclaim_idx = gfp_zone(sc->gfp_mask);
2687
	}
2688

2689
	for_each_zone_zonelist_nodemask(zone, z, zonelist,
2690
					sc->reclaim_idx, sc->nodemask) {
2691 2692 2693 2694
		/*
		 * Take care memory controller reclaiming has small influence
		 * to global LRU.
		 */
2695
		if (global_reclaim(sc)) {
2696 2697
			if (!cpuset_zone_allowed(zone,
						 GFP_KERNEL | __GFP_HARDWALL))
2698
				continue;
2699

2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710
			/*
			 * 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 &&
2711
			    compaction_ready(zone, sc)) {
2712 2713
				sc->compaction_ready = true;
				continue;
2714
			}
2715

2716 2717 2718 2719 2720 2721 2722 2723 2724
			/*
			 * 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;

2725 2726 2727 2728 2729 2730 2731
			/*
			 * 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;
2732
			nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone->zone_pgdat,
2733 2734 2735 2736
						sc->order, sc->gfp_mask,
						&nr_soft_scanned);
			sc->nr_reclaimed += nr_soft_reclaimed;
			sc->nr_scanned += nr_soft_scanned;
2737
			/* need some check for avoid more shrink_zone() */
2738
		}
2739

2740 2741 2742 2743
		/* See comment about same check for global reclaim above */
		if (zone->zone_pgdat == last_pgdat)
			continue;
		last_pgdat = zone->zone_pgdat;
2744
		shrink_node(zone->zone_pgdat, sc);
L
Linus Torvalds 已提交
2745
	}
2746

2747 2748 2749 2750 2751
	/*
	 * 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 已提交
2752
}
2753

2754 2755 2756 2757 2758 2759 2760 2761 2762 2763
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)
2764
			refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
2765 2766 2767 2768 2769 2770 2771 2772
		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 已提交
2773 2774 2775 2776 2777 2778 2779 2780
/*
 * 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
2781 2782 2783 2784
 * 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.
2785 2786 2787
 *
 * returns:	0, if no pages reclaimed
 * 		else, the number of pages reclaimed
L
Linus Torvalds 已提交
2788
 */
2789
static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
2790
					  struct scan_control *sc)
L
Linus Torvalds 已提交
2791
{
2792
	int initial_priority = sc->priority;
2793 2794 2795
	pg_data_t *last_pgdat;
	struct zoneref *z;
	struct zone *zone;
2796
retry:
2797 2798
	delayacct_freepages_start();

2799
	if (global_reclaim(sc))
2800
		__count_zid_vm_events(ALLOCSTALL, sc->reclaim_idx, 1);
L
Linus Torvalds 已提交
2801

2802
	do {
2803 2804
		vmpressure_prio(sc->gfp_mask, sc->target_mem_cgroup,
				sc->priority);
2805
		sc->nr_scanned = 0;
M
Michal Hocko 已提交
2806
		shrink_zones(zonelist, sc);
2807

2808
		if (sc->nr_reclaimed >= sc->nr_to_reclaim)
2809 2810 2811 2812
			break;

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

2814 2815 2816 2817 2818 2819
		/*
		 * If we're getting trouble reclaiming, start doing
		 * writepage even in laptop mode.
		 */
		if (sc->priority < DEF_PRIORITY - 2)
			sc->may_writepage = 1;
2820
	} while (--sc->priority >= 0);
2821

2822 2823 2824 2825 2826 2827 2828 2829 2830
	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);
	}

2831 2832
	delayacct_freepages_end();

2833 2834 2835
	if (sc->nr_reclaimed)
		return sc->nr_reclaimed;

2836
	/* Aborted reclaim to try compaction? don't OOM, then */
2837
	if (sc->compaction_ready)
2838 2839
		return 1;

2840
	/* Untapped cgroup reserves?  Don't OOM, retry. */
2841
	if (sc->memcg_low_skipped) {
2842
		sc->priority = initial_priority;
2843 2844
		sc->memcg_low_reclaim = 1;
		sc->memcg_low_skipped = 0;
2845 2846 2847
		goto retry;
	}

2848
	return 0;
L
Linus Torvalds 已提交
2849 2850
}

2851
static bool allow_direct_reclaim(pg_data_t *pgdat)
2852 2853 2854 2855 2856 2857 2858
{
	struct zone *zone;
	unsigned long pfmemalloc_reserve = 0;
	unsigned long free_pages = 0;
	int i;
	bool wmark_ok;

2859 2860 2861
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

2862 2863
	for (i = 0; i <= ZONE_NORMAL; i++) {
		zone = &pgdat->node_zones[i];
2864 2865 2866 2867
		if (!managed_zone(zone))
			continue;

		if (!zone_reclaimable_pages(zone))
2868 2869
			continue;

2870 2871 2872 2873
		pfmemalloc_reserve += min_wmark_pages(zone);
		free_pages += zone_page_state(zone, NR_FREE_PAGES);
	}

2874 2875 2876 2877
	/* If there are no reserves (unexpected config) then do not throttle */
	if (!pfmemalloc_reserve)
		return true;

2878 2879 2880 2881
	wmark_ok = free_pages > pfmemalloc_reserve / 2;

	/* kswapd must be awake if processes are being throttled */
	if (!wmark_ok && waitqueue_active(&pgdat->kswapd_wait)) {
2882
		pgdat->kswapd_classzone_idx = min(pgdat->kswapd_classzone_idx,
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893
						(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
2894 2895 2896 2897
 * 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.
2898
 */
2899
static bool throttle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
2900 2901
					nodemask_t *nodemask)
{
2902
	struct zoneref *z;
2903
	struct zone *zone;
2904
	pg_data_t *pgdat = NULL;
2905 2906 2907 2908 2909 2910 2911 2912 2913

	/*
	 * 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)
2914 2915 2916 2917 2918 2919 2920 2921
		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;
2922

2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937
	/*
	 * 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,
2938
					gfp_zone(gfp_mask), nodemask) {
2939 2940 2941 2942 2943
		if (zone_idx(zone) > ZONE_NORMAL)
			continue;

		/* Throttle based on the first usable node */
		pgdat = zone->zone_pgdat;
2944
		if (allow_direct_reclaim(pgdat))
2945 2946 2947 2948 2949 2950
			goto out;
		break;
	}

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

2953 2954 2955
	/* Account for the throttling */
	count_vm_event(PGSCAN_DIRECT_THROTTLE);

2956 2957 2958 2959 2960 2961 2962 2963 2964 2965
	/*
	 * 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,
2966
			allow_direct_reclaim(pgdat), HZ);
2967 2968

		goto check_pending;
2969 2970 2971 2972
	}

	/* Throttle until kswapd wakes the process */
	wait_event_killable(zone->zone_pgdat->pfmemalloc_wait,
2973
		allow_direct_reclaim(pgdat));
2974 2975 2976 2977 2978 2979 2980

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

out:
	return false;
2981 2982
}

2983
unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
2984
				gfp_t gfp_mask, nodemask_t *nodemask)
2985
{
2986
	unsigned long nr_reclaimed;
2987
	struct scan_control sc = {
2988
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
2989
		.gfp_mask = current_gfp_context(gfp_mask),
2990
		.reclaim_idx = gfp_zone(gfp_mask),
2991 2992 2993
		.order = order,
		.nodemask = nodemask,
		.priority = DEF_PRIORITY,
2994
		.may_writepage = !laptop_mode,
2995
		.may_unmap = 1,
2996
		.may_swap = 1,
2997 2998
	};

2999
	/*
3000 3001 3002
	 * 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.
3003
	 */
3004
	if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
3005 3006
		return 1;

3007 3008
	trace_mm_vmscan_direct_reclaim_begin(order,
				sc.may_writepage,
3009
				sc.gfp_mask,
3010
				sc.reclaim_idx);
3011

3012
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3013 3014 3015 3016

	trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3017 3018
}

A
Andrew Morton 已提交
3019
#ifdef CONFIG_MEMCG
3020

3021
unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
3022
						gfp_t gfp_mask, bool noswap,
3023
						pg_data_t *pgdat,
3024
						unsigned long *nr_scanned)
3025 3026
{
	struct scan_control sc = {
3027
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
3028
		.target_mem_cgroup = memcg,
3029 3030
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3031
		.reclaim_idx = MAX_NR_ZONES - 1,
3032 3033
		.may_swap = !noswap,
	};
3034
	unsigned long lru_pages;
3035

3036 3037
	sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
			(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
3038

3039
	trace_mm_vmscan_memcg_softlimit_reclaim_begin(sc.order,
3040
						      sc.may_writepage,
3041 3042
						      sc.gfp_mask,
						      sc.reclaim_idx);
3043

3044 3045 3046
	/*
	 * NOTE: Although we can get the priority field, using it
	 * here is not a good idea, since it limits the pages we can scan.
3047
	 * if we don't reclaim here, the shrink_node from balance_pgdat
3048 3049 3050
	 * will pick up pages from other mem cgroup's as well. We hack
	 * the priority and make it zero.
	 */
3051
	shrink_node_memcg(pgdat, memcg, &sc, &lru_pages);
3052 3053 3054

	trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);

3055
	*nr_scanned = sc.nr_scanned;
3056 3057 3058
	return sc.nr_reclaimed;
}

3059
unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
3060
					   unsigned long nr_pages,
K
KOSAKI Motohiro 已提交
3061
					   gfp_t gfp_mask,
3062
					   bool may_swap)
3063
{
3064
	struct zonelist *zonelist;
3065
	unsigned long nr_reclaimed;
3066
	int nid;
3067
	unsigned int noreclaim_flag;
3068
	struct scan_control sc = {
3069
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3070
		.gfp_mask = (current_gfp_context(gfp_mask) & GFP_RECLAIM_MASK) |
3071
				(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
3072
		.reclaim_idx = MAX_NR_ZONES - 1,
3073 3074 3075 3076
		.target_mem_cgroup = memcg,
		.priority = DEF_PRIORITY,
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3077
		.may_swap = may_swap,
3078
	};
3079

3080 3081 3082 3083 3084
	/*
	 * 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.
	 */
3085
	nid = mem_cgroup_select_victim_node(memcg);
3086

3087
	zonelist = &NODE_DATA(nid)->node_zonelists[ZONELIST_FALLBACK];
3088 3089 3090

	trace_mm_vmscan_memcg_reclaim_begin(0,
					    sc.may_writepage,
3091 3092
					    sc.gfp_mask,
					    sc.reclaim_idx);
3093

3094
	noreclaim_flag = memalloc_noreclaim_save();
3095
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3096
	memalloc_noreclaim_restore(noreclaim_flag);
3097 3098 3099 3100

	trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3101 3102 3103
}
#endif

3104
static void age_active_anon(struct pglist_data *pgdat,
3105
				struct scan_control *sc)
3106
{
3107
	struct mem_cgroup *memcg;
3108

3109 3110 3111 3112 3113
	if (!total_swap_pages)
		return;

	memcg = mem_cgroup_iter(NULL, NULL, NULL);
	do {
3114
		struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
3115

3116
		if (inactive_list_is_low(lruvec, false, memcg, sc, true))
3117
			shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
3118
					   sc, LRU_ACTIVE_ANON);
3119 3120 3121

		memcg = mem_cgroup_iter(NULL, memcg, NULL);
	} while (memcg);
3122 3123
}

3124 3125 3126 3127 3128
/*
 * 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)
3129
{
3130 3131 3132
	int i;
	unsigned long mark = -1;
	struct zone *zone;
3133

3134 3135
	for (i = 0; i <= classzone_idx; i++) {
		zone = pgdat->node_zones + i;
3136

3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153
		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;
3154 3155
}

3156 3157 3158 3159 3160 3161 3162 3163
/* 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);
}

3164 3165 3166 3167 3168 3169
/*
 * 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
 */
3170
static bool prepare_kswapd_sleep(pg_data_t *pgdat, int order, int classzone_idx)
3171
{
3172
	/*
3173
	 * The throttled processes are normally woken up in balance_pgdat() as
3174
	 * soon as allow_direct_reclaim() is true. But there is a potential
3175 3176 3177 3178 3179 3180 3181 3182 3183
	 * 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().
3184
	 */
3185 3186
	if (waitqueue_active(&pgdat->pfmemalloc_wait))
		wake_up_all(&pgdat->pfmemalloc_wait);
3187

3188 3189 3190 3191
	/* Hopeless node, leave it to direct reclaim */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

3192 3193 3194
	if (pgdat_balanced(pgdat, order, classzone_idx)) {
		clear_pgdat_congested(pgdat);
		return true;
3195 3196
	}

3197
	return false;
3198 3199
}

3200
/*
3201 3202
 * kswapd shrinks a node of pages that are at or below the highest usable
 * zone that is currently unbalanced.
3203 3204
 *
 * Returns true if kswapd scanned at least the requested number of pages to
3205 3206
 * 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.
3207
 */
3208
static bool kswapd_shrink_node(pg_data_t *pgdat,
3209
			       struct scan_control *sc)
3210
{
3211 3212
	struct zone *zone;
	int z;
3213

3214 3215
	/* Reclaim a number of pages proportional to the number of zones */
	sc->nr_to_reclaim = 0;
3216
	for (z = 0; z <= sc->reclaim_idx; z++) {
3217
		zone = pgdat->node_zones + z;
3218
		if (!managed_zone(zone))
3219
			continue;
3220

3221 3222
		sc->nr_to_reclaim += max(high_wmark_pages(zone), SWAP_CLUSTER_MAX);
	}
3223 3224

	/*
3225 3226
	 * Historically care was taken to put equal pressure on all zones but
	 * now pressure is applied based on node LRU order.
3227
	 */
3228
	shrink_node(pgdat, sc);
3229

3230
	/*
3231 3232 3233 3234 3235
	 * 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.
3236
	 */
3237
	if (sc->order && sc->nr_reclaimed >= compact_gap(sc->order))
3238
		sc->order = 0;
3239

3240
	return sc->nr_scanned >= sc->nr_to_reclaim;
3241 3242
}

L
Linus Torvalds 已提交
3243
/*
3244 3245 3246
 * 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 已提交
3247
 *
3248
 * Returns the order kswapd finished reclaiming at.
L
Linus Torvalds 已提交
3249 3250
 *
 * kswapd scans the zones in the highmem->normal->dma direction.  It skips
3251
 * zones which have free_pages > high_wmark_pages(zone), but once a zone is
3252 3253 3254
 * 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 已提交
3255
 */
3256
static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
L
Linus Torvalds 已提交
3257 3258
{
	int i;
3259 3260
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
3261
	struct zone *zone;
3262 3263
	struct scan_control sc = {
		.gfp_mask = GFP_KERNEL,
3264
		.order = order,
3265
		.priority = DEF_PRIORITY,
3266
		.may_writepage = !laptop_mode,
3267
		.may_unmap = 1,
3268
		.may_swap = 1,
3269
	};
3270
	count_vm_event(PAGEOUTRUN);
L
Linus Torvalds 已提交
3271

3272
	do {
3273
		unsigned long nr_reclaimed = sc.nr_reclaimed;
3274 3275
		bool raise_priority = true;

3276
		sc.reclaim_idx = classzone_idx;
L
Linus Torvalds 已提交
3277

3278
		/*
3279 3280 3281 3282 3283 3284 3285 3286
		 * 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.
3287 3288 3289 3290
		 */
		if (buffer_heads_over_limit) {
			for (i = MAX_NR_ZONES - 1; i >= 0; i--) {
				zone = pgdat->node_zones + i;
3291
				if (!managed_zone(zone))
3292
					continue;
3293

3294
				sc.reclaim_idx = i;
A
Andrew Morton 已提交
3295
				break;
L
Linus Torvalds 已提交
3296 3297
			}
		}
3298

3299
		/*
3300 3301 3302
		 * 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.
3303
		 */
3304 3305
		if (pgdat_balanced(pgdat, sc.order, classzone_idx))
			goto out;
A
Andrew Morton 已提交
3306

3307 3308 3309 3310 3311 3312
		/*
		 * 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.
		 */
3313
		age_active_anon(pgdat, &sc);
3314

3315 3316 3317 3318
		/*
		 * If we're getting trouble reclaiming, start doing writepage
		 * even in laptop mode.
		 */
3319
		if (sc.priority < DEF_PRIORITY - 2)
3320 3321
			sc.may_writepage = 1;

3322 3323 3324
		/* Call soft limit reclaim before calling shrink_node. */
		sc.nr_scanned = 0;
		nr_soft_scanned = 0;
3325
		nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(pgdat, sc.order,
3326 3327 3328
						sc.gfp_mask, &nr_soft_scanned);
		sc.nr_reclaimed += nr_soft_reclaimed;

L
Linus Torvalds 已提交
3329
		/*
3330 3331 3332
		 * 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 已提交
3333
		 */
3334
		if (kswapd_shrink_node(pgdat, &sc))
3335
			raise_priority = false;
3336 3337 3338 3339 3340 3341 3342

		/*
		 * 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) &&
3343
				allow_direct_reclaim(pgdat))
3344
			wake_up_all(&pgdat->pfmemalloc_wait);
3345

3346 3347 3348
		/* Check if kswapd should be suspending */
		if (try_to_freeze() || kthread_should_stop())
			break;
3349

3350
		/*
3351 3352
		 * Raise priority if scanning rate is too low or there was no
		 * progress in reclaiming pages
3353
		 */
3354 3355
		nr_reclaimed = sc.nr_reclaimed - nr_reclaimed;
		if (raise_priority || !nr_reclaimed)
3356
			sc.priority--;
3357
	} while (sc.priority >= 1);
L
Linus Torvalds 已提交
3358

3359 3360 3361
	if (!sc.nr_reclaimed)
		pgdat->kswapd_failures++;

3362
out:
3363
	snapshot_refaults(NULL, pgdat);
3364
	/*
3365 3366 3367 3368
	 * 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.
3369
	 */
3370
	return sc.order;
L
Linus Torvalds 已提交
3371 3372
}

3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388
/*
 * 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);
}

3389 3390
static void kswapd_try_to_sleep(pg_data_t *pgdat, int alloc_order, int reclaim_order,
				unsigned int classzone_idx)
3391 3392 3393 3394 3395 3396 3397 3398 3399
{
	long remaining = 0;
	DEFINE_WAIT(wait);

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

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

3400 3401 3402 3403 3404 3405 3406
	/*
	 * 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.
	 */
3407
	if (prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419
		/*
		 * 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.
		 */
3420
		wakeup_kcompactd(pgdat, alloc_order, classzone_idx);
3421

3422
		remaining = schedule_timeout(HZ/10);
3423 3424 3425 3426 3427 3428 3429

		/*
		 * 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) {
3430
			pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);
3431 3432 3433
			pgdat->kswapd_order = max(pgdat->kswapd_order, reclaim_order);
		}

3434 3435 3436 3437 3438 3439 3440 3441
		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.
	 */
3442 3443
	if (!remaining &&
	    prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454
		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);
3455 3456 3457 3458

		if (!kthread_should_stop())
			schedule();

3459 3460 3461 3462 3463 3464 3465 3466 3467 3468
		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 已提交
3469 3470
/*
 * The background pageout daemon, started as a kernel thread
3471
 * from the init process.
L
Linus Torvalds 已提交
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
 *
 * 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)
{
3484 3485
	unsigned int alloc_order, reclaim_order;
	unsigned int classzone_idx = MAX_NR_ZONES - 1;
L
Linus Torvalds 已提交
3486 3487
	pg_data_t *pgdat = (pg_data_t*)p;
	struct task_struct *tsk = current;
3488

L
Linus Torvalds 已提交
3489 3490 3491
	struct reclaim_state reclaim_state = {
		.reclaimed_slab = 0,
	};
3492
	const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
L
Linus Torvalds 已提交
3493

R
Rusty Russell 已提交
3494
	if (!cpumask_empty(cpumask))
3495
		set_cpus_allowed_ptr(tsk, cpumask);
L
Linus Torvalds 已提交
3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509
	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).
	 */
3510
	tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
3511
	set_freezable();
L
Linus Torvalds 已提交
3512

3513 3514
	pgdat->kswapd_order = 0;
	pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
L
Linus Torvalds 已提交
3515
	for ( ; ; ) {
3516
		bool ret;
3517

3518 3519 3520
		alloc_order = reclaim_order = pgdat->kswapd_order;
		classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);

3521 3522 3523
kswapd_try_sleep:
		kswapd_try_to_sleep(pgdat, alloc_order, reclaim_order,
					classzone_idx);
3524

3525 3526
		/* Read the new order and classzone_idx */
		alloc_order = reclaim_order = pgdat->kswapd_order;
3527
		classzone_idx = kswapd_classzone_idx(pgdat, 0);
3528
		pgdat->kswapd_order = 0;
3529
		pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
L
Linus Torvalds 已提交
3530

3531 3532 3533 3534 3535 3536 3537 3538
		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
		 */
3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549
		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).
		 */
3550 3551
		trace_mm_vmscan_kswapd_wake(pgdat->node_id, classzone_idx,
						alloc_order);
3552
		fs_reclaim_acquire(GFP_KERNEL);
3553
		reclaim_order = balance_pgdat(pgdat, alloc_order, classzone_idx);
3554
		fs_reclaim_release(GFP_KERNEL);
3555 3556
		if (reclaim_order < alloc_order)
			goto kswapd_try_sleep;
L
Linus Torvalds 已提交
3557
	}
3558

3559
	tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
3560
	current->reclaim_state = NULL;
3561

L
Linus Torvalds 已提交
3562 3563 3564 3565
	return 0;
}

/*
3566 3567 3568 3569 3570
 * A zone is low on free memory or too fragmented for high-order memory.  If
 * kswapd should reclaim (direct reclaim is deferred), wake it up for the zone's
 * pgdat.  It will wake up kcompactd after reclaiming memory.  If kswapd reclaim
 * has failed or is not needed, still wake up kcompactd if only compaction is
 * needed.
L
Linus Torvalds 已提交
3571
 */
3572 3573
void wakeup_kswapd(struct zone *zone, gfp_t gfp_flags, int order,
		   enum zone_type classzone_idx)
L
Linus Torvalds 已提交
3574 3575 3576
{
	pg_data_t *pgdat;

3577
	if (!managed_zone(zone))
L
Linus Torvalds 已提交
3578 3579
		return;

3580
	if (!cpuset_zone_allowed(zone, gfp_flags))
L
Linus Torvalds 已提交
3581
		return;
3582
	pgdat = zone->zone_pgdat;
3583 3584
	pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat,
							   classzone_idx);
3585
	pgdat->kswapd_order = max(pgdat->kswapd_order, order);
3586
	if (!waitqueue_active(&pgdat->kswapd_wait))
L
Linus Torvalds 已提交
3587
		return;
3588

3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600
	/* Hopeless node, leave it to direct reclaim if possible */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES ||
	    pgdat_balanced(pgdat, order, classzone_idx)) {
		/*
		 * There may be plenty of free memory available, but it's too
		 * fragmented for high-order allocations.  Wake up kcompactd
		 * and rely on compaction_suitable() to determine if it's
		 * needed.  If it fails, it will defer subsequent attempts to
		 * ratelimit its work.
		 */
		if (!(gfp_flags & __GFP_DIRECT_RECLAIM))
			wakeup_kcompactd(pgdat, order, classzone_idx);
3601
		return;
3602
	}
3603

3604 3605
	trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, classzone_idx, order,
				      gfp_flags);
3606
	wake_up_interruptible(&pgdat->kswapd_wait);
L
Linus Torvalds 已提交
3607 3608
}

3609
#ifdef CONFIG_HIBERNATION
L
Linus Torvalds 已提交
3610
/*
3611
 * Try to free `nr_to_reclaim' of memory, system-wide, and return the number of
3612 3613 3614 3615 3616
 * 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 已提交
3617
 */
3618
unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
L
Linus Torvalds 已提交
3619
{
3620 3621
	struct reclaim_state reclaim_state;
	struct scan_control sc = {
3622
		.nr_to_reclaim = nr_to_reclaim,
3623
		.gfp_mask = GFP_HIGHUSER_MOVABLE,
3624
		.reclaim_idx = MAX_NR_ZONES - 1,
3625
		.priority = DEF_PRIORITY,
3626
		.may_writepage = 1,
3627 3628
		.may_unmap = 1,
		.may_swap = 1,
3629
		.hibernation_mode = 1,
L
Linus Torvalds 已提交
3630
	};
3631
	struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
3632 3633
	struct task_struct *p = current;
	unsigned long nr_reclaimed;
3634
	unsigned int noreclaim_flag;
L
Linus Torvalds 已提交
3635

3636
	noreclaim_flag = memalloc_noreclaim_save();
3637
	fs_reclaim_acquire(sc.gfp_mask);
3638 3639
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
3640

3641
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3642

3643
	p->reclaim_state = NULL;
3644
	fs_reclaim_release(sc.gfp_mask);
3645
	memalloc_noreclaim_restore(noreclaim_flag);
3646

3647
	return nr_reclaimed;
L
Linus Torvalds 已提交
3648
}
3649
#endif /* CONFIG_HIBERNATION */
L
Linus Torvalds 已提交
3650 3651 3652 3653 3654

/* 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. */
3655
static int kswapd_cpu_online(unsigned int cpu)
L
Linus Torvalds 已提交
3656
{
3657
	int nid;
L
Linus Torvalds 已提交
3658

3659 3660 3661
	for_each_node_state(nid, N_MEMORY) {
		pg_data_t *pgdat = NODE_DATA(nid);
		const struct cpumask *mask;
3662

3663
		mask = cpumask_of_node(pgdat->node_id);
3664

3665 3666 3667
		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 已提交
3668
	}
3669
	return 0;
L
Linus Torvalds 已提交
3670 3671
}

3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686
/*
 * 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 */
3687
		BUG_ON(system_state < SYSTEM_RUNNING);
3688 3689
		pr_err("Failed to start kswapd on node %d\n", nid);
		ret = PTR_ERR(pgdat->kswapd);
3690
		pgdat->kswapd = NULL;
3691 3692 3693 3694
	}
	return ret;
}

3695
/*
3696
 * Called by memory hotplug when all memory in a node is offlined.  Caller must
3697
 * hold mem_hotplug_begin/end().
3698 3699 3700 3701 3702
 */
void kswapd_stop(int nid)
{
	struct task_struct *kswapd = NODE_DATA(nid)->kswapd;

3703
	if (kswapd) {
3704
		kthread_stop(kswapd);
3705 3706
		NODE_DATA(nid)->kswapd = NULL;
	}
3707 3708
}

L
Linus Torvalds 已提交
3709 3710
static int __init kswapd_init(void)
{
3711
	int nid, ret;
3712

L
Linus Torvalds 已提交
3713
	swap_setup();
3714
	for_each_node_state(nid, N_MEMORY)
3715
 		kswapd_run(nid);
3716 3717 3718 3719
	ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
					"mm/vmscan:online", kswapd_cpu_online,
					NULL);
	WARN_ON(ret < 0);
L
Linus Torvalds 已提交
3720 3721 3722 3723
	return 0;
}

module_init(kswapd_init)
3724 3725 3726

#ifdef CONFIG_NUMA
/*
3727
 * Node reclaim mode
3728
 *
3729
 * If non-zero call node_reclaim when the number of free pages falls below
3730 3731
 * the watermarks.
 */
3732
int node_reclaim_mode __read_mostly;
3733

3734
#define RECLAIM_OFF 0
3735
#define RECLAIM_ZONE (1<<0)	/* Run shrink_inactive_list on the zone */
3736
#define RECLAIM_WRITE (1<<1)	/* Writeout pages during reclaim */
3737
#define RECLAIM_UNMAP (1<<2)	/* Unmap pages during reclaim */
3738

3739
/*
3740
 * Priority for NODE_RECLAIM. This determines the fraction of pages
3741 3742 3743
 * of a node considered for each zone_reclaim. 4 scans 1/16th of
 * a zone.
 */
3744
#define NODE_RECLAIM_PRIORITY 4
3745

3746
/*
3747
 * Percentage of pages in a zone that must be unmapped for node_reclaim to
3748 3749 3750 3751
 * occur.
 */
int sysctl_min_unmapped_ratio = 1;

3752 3753 3754 3755 3756 3757
/*
 * 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;

3758
static inline unsigned long node_unmapped_file_pages(struct pglist_data *pgdat)
3759
{
3760 3761 3762
	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);
3763 3764 3765 3766 3767 3768 3769 3770 3771 3772

	/*
	 * 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 */
3773
static unsigned long node_pagecache_reclaimable(struct pglist_data *pgdat)
3774
{
3775 3776
	unsigned long nr_pagecache_reclaimable;
	unsigned long delta = 0;
3777 3778

	/*
3779
	 * If RECLAIM_UNMAP is set, then all file pages are considered
3780
	 * potentially reclaimable. Otherwise, we have to worry about
3781
	 * pages like swapcache and node_unmapped_file_pages() provides
3782 3783
	 * a better estimate
	 */
3784 3785
	if (node_reclaim_mode & RECLAIM_UNMAP)
		nr_pagecache_reclaimable = node_page_state(pgdat, NR_FILE_PAGES);
3786
	else
3787
		nr_pagecache_reclaimable = node_unmapped_file_pages(pgdat);
3788 3789

	/* If we can't clean pages, remove dirty pages from consideration */
3790 3791
	if (!(node_reclaim_mode & RECLAIM_WRITE))
		delta += node_page_state(pgdat, NR_FILE_DIRTY);
3792 3793 3794 3795 3796 3797 3798 3799

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

	return nr_pagecache_reclaimable - delta;
}

3800
/*
3801
 * Try to free up some pages from this node through reclaim.
3802
 */
3803
static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
3804
{
3805
	/* Minimum pages needed in order to stay on node */
3806
	const unsigned long nr_pages = 1 << order;
3807 3808
	struct task_struct *p = current;
	struct reclaim_state reclaim_state;
3809
	unsigned int noreclaim_flag;
3810
	struct scan_control sc = {
3811
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3812
		.gfp_mask = current_gfp_context(gfp_mask),
3813
		.order = order,
3814 3815 3816
		.priority = NODE_RECLAIM_PRIORITY,
		.may_writepage = !!(node_reclaim_mode & RECLAIM_WRITE),
		.may_unmap = !!(node_reclaim_mode & RECLAIM_UNMAP),
3817
		.may_swap = 1,
3818
		.reclaim_idx = gfp_zone(gfp_mask),
3819
	};
3820 3821

	cond_resched();
3822
	/*
3823
	 * We need to be able to allocate from the reserves for RECLAIM_UNMAP
3824
	 * and we also need to be able to write out pages for RECLAIM_WRITE
3825
	 * and RECLAIM_UNMAP.
3826
	 */
3827 3828
	noreclaim_flag = memalloc_noreclaim_save();
	p->flags |= PF_SWAPWRITE;
3829
	fs_reclaim_acquire(sc.gfp_mask);
3830 3831
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
3832

3833
	if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
3834
		/*
3835
		 * Free memory by calling shrink node with increasing
3836 3837 3838
		 * priorities until we have enough memory freed.
		 */
		do {
3839
			shrink_node(pgdat, &sc);
3840
		} while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
3841
	}
3842

3843
	p->reclaim_state = NULL;
3844
	fs_reclaim_release(gfp_mask);
3845 3846
	current->flags &= ~PF_SWAPWRITE;
	memalloc_noreclaim_restore(noreclaim_flag);
3847
	return sc.nr_reclaimed >= nr_pages;
3848
}
3849

3850
int node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
3851
{
3852
	int ret;
3853 3854

	/*
3855
	 * Node reclaim reclaims unmapped file backed pages and
3856
	 * slab pages if we are over the defined limits.
3857
	 *
3858 3859
	 * A small portion of unmapped file backed pages is needed for
	 * file I/O otherwise pages read by file I/O will be immediately
3860 3861
	 * thrown out if the node is overallocated. So we do not reclaim
	 * if less than a specified percentage of the node is used by
3862
	 * unmapped file backed pages.
3863
	 */
3864
	if (node_pagecache_reclaimable(pgdat) <= pgdat->min_unmapped_pages &&
3865
	    node_page_state(pgdat, NR_SLAB_RECLAIMABLE) <= pgdat->min_slab_pages)
3866
		return NODE_RECLAIM_FULL;
3867 3868

	/*
3869
	 * Do not scan if the allocation should not be delayed.
3870
	 */
3871
	if (!gfpflags_allow_blocking(gfp_mask) || (current->flags & PF_MEMALLOC))
3872
		return NODE_RECLAIM_NOSCAN;
3873 3874

	/*
3875
	 * Only run node reclaim on the local node or on nodes that do not
3876 3877 3878 3879
	 * have associated processors. This will favor the local processor
	 * over remote processors and spread off node memory allocations
	 * as wide as possible.
	 */
3880 3881
	if (node_state(pgdat->node_id, N_CPU) && pgdat->node_id != numa_node_id())
		return NODE_RECLAIM_NOSCAN;
3882

3883 3884
	if (test_and_set_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags))
		return NODE_RECLAIM_NOSCAN;
3885

3886 3887
	ret = __node_reclaim(pgdat, gfp_mask, order);
	clear_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags);
3888

3889 3890 3891
	if (!ret)
		count_vm_event(PGSCAN_ZONE_RECLAIM_FAILED);

3892
	return ret;
3893
}
3894
#endif
L
Lee Schermerhorn 已提交
3895 3896 3897 3898 3899 3900

/*
 * 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
3901
 * lists vs unevictable list.
L
Lee Schermerhorn 已提交
3902 3903
 *
 * Reasons page might not be evictable:
3904
 * (1) page's mapping marked unevictable
N
Nick Piggin 已提交
3905
 * (2) page is part of an mlocked VMA
3906
 *
L
Lee Schermerhorn 已提交
3907
 */
3908
int page_evictable(struct page *page)
L
Lee Schermerhorn 已提交
3909
{
3910 3911 3912 3913 3914 3915 3916
	int ret;

	/* Prevent address_space of inode and swap cache from being freed */
	rcu_read_lock();
	ret = !mapping_unevictable(page_mapping(page)) && !PageMlocked(page);
	rcu_read_unlock();
	return ret;
L
Lee Schermerhorn 已提交
3917
}
3918

3919
#ifdef CONFIG_SHMEM
3920
/**
3921 3922 3923
 * 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
3924
 *
3925
 * Checks pages for evictability and moves them to the appropriate lru list.
3926 3927
 *
 * This function is only used for SysV IPC SHM_UNLOCK.
3928
 */
3929
void check_move_unevictable_pages(struct page **pages, int nr_pages)
3930
{
3931
	struct lruvec *lruvec;
3932
	struct pglist_data *pgdat = NULL;
3933 3934 3935
	int pgscanned = 0;
	int pgrescued = 0;
	int i;
3936

3937 3938
	for (i = 0; i < nr_pages; i++) {
		struct page *page = pages[i];
3939
		struct pglist_data *pagepgdat = page_pgdat(page);
3940

3941
		pgscanned++;
3942 3943 3944 3945 3946
		if (pagepgdat != pgdat) {
			if (pgdat)
				spin_unlock_irq(&pgdat->lru_lock);
			pgdat = pagepgdat;
			spin_lock_irq(&pgdat->lru_lock);
3947
		}
3948
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
3949

3950 3951
		if (!PageLRU(page) || !PageUnevictable(page))
			continue;
3952

3953
		if (page_evictable(page)) {
3954 3955
			enum lru_list lru = page_lru_base_type(page);

3956
			VM_BUG_ON_PAGE(PageActive(page), page);
3957
			ClearPageUnevictable(page);
3958 3959
			del_page_from_lru_list(page, lruvec, LRU_UNEVICTABLE);
			add_page_to_lru_list(page, lruvec, lru);
3960
			pgrescued++;
3961
		}
3962
	}
3963

3964
	if (pgdat) {
3965 3966
		__count_vm_events(UNEVICTABLE_PGRESCUED, pgrescued);
		__count_vm_events(UNEVICTABLE_PGSCANNED, pgscanned);
3967
		spin_unlock_irq(&pgdat->lru_lock);
3968 3969
	}
}
3970
#endif /* CONFIG_SHMEM */