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

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

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

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

#include <linux/swapops.h>
56
#include <linux/balloon_compaction.h>
Linus Torvalds's avatar
Linus Torvalds committed
57

58 59
#include "internal.h"

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

Linus Torvalds's avatar
Linus Torvalds committed
63
struct scan_control {
64 65 66
	/* How many pages shrink_list() should reclaim */
	unsigned long nr_to_reclaim;

Linus Torvalds's avatar
Linus Torvalds committed
67
	/* This context's GFP mask */
Al Viro's avatar
Al Viro committed
68
	gfp_t gfp_mask;
Linus Torvalds's avatar
Linus Torvalds committed
69

70
	/* Allocation order */
Andy Whitcroft's avatar
Andy Whitcroft committed
71
	int order;
72

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return nr;
}

222 223 224 225 226 227 228
unsigned long pgdat_reclaimable_pages(struct pglist_data *pgdat)
{
	unsigned long nr;

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

	if (get_nr_swap_pages() > 0)
231 232 233
		nr += node_page_state_snapshot(pgdat, NR_ACTIVE_ANON) +
		      node_page_state_snapshot(pgdat, NR_INACTIVE_ANON) +
		      node_page_state_snapshot(pgdat, NR_ISOLATED_ANON);
234 235 236 237

	return nr;
}

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

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

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

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

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

	return lru_size;
270 271 272

}

Linus Torvalds's avatar
Linus Torvalds committed
273
/*
274
 * Add a shrinker callback to be called from the vm.
Linus Torvalds's avatar
Linus Torvalds committed
275
 */
276
int register_shrinker(struct shrinker *shrinker)
Linus Torvalds's avatar
Linus Torvalds committed
277
{
278 279 280 281 282 283 284 285 286
	size_t size = sizeof(*shrinker->nr_deferred);

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

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

287 288 289
	down_write(&shrinker_rwsem);
	list_add_tail(&shrinker->list, &shrinker_list);
	up_write(&shrinker_rwsem);
290
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
291
}
292
EXPORT_SYMBOL(register_shrinker);
Linus Torvalds's avatar
Linus Torvalds committed
293 294 295 296

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

#define SHRINK_BATCH 128
307

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

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

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

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

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

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

	trace_mm_shrink_slab_start(shrinker, shrinkctl, nr,
372 373
				   nr_scanned, nr_eligible,
				   freeable, delta, total_scan);
374

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

395
		shrinkctl->nr_to_scan = nr_to_scan;
396
		shrinkctl->nr_scanned = nr_to_scan;
397 398 399 400
		ret = shrinker->scan_objects(shrinker, shrinkctl);
		if (ret == SHRINK_STOP)
			break;
		freed += ret;
401

402 403 404
		count_vm_events(SLABS_SCANNED, shrinkctl->nr_scanned);
		total_scan -= shrinkctl->nr_scanned;
		scanned += shrinkctl->nr_scanned;
405 406 407 408

		cond_resched();
	}

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

424
	trace_mm_shrink_slab_end(shrinker, nid, freed, nr, new_nr, total_scan);
425
	return freed;
426 427
}

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

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

467 468
	if (nr_scanned == 0)
		nr_scanned = SWAP_CLUSTER_MAX;
Linus Torvalds's avatar
Linus Torvalds committed
469

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

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

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

497 498
		if (!(shrinker->flags & SHRINKER_NUMA_AWARE))
			sc.nid = 0;
Linus Torvalds's avatar
Linus Torvalds committed
499

500
		freed += do_shrink_slab(&sc, shrinker, nr_scanned, nr_eligible);
Linus Torvalds's avatar
Linus Torvalds committed
501
	}
502

Linus Torvalds's avatar
Linus Torvalds committed
503
	up_read(&shrinker_rwsem);
504 505
out:
	cond_resched();
Dave Chinner's avatar
Dave Chinner committed
506
	return freed;
Linus Torvalds's avatar
Linus Torvalds committed
507 508
}

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

	do {
		struct mem_cgroup *memcg = NULL;

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

void drop_slab(void)
{
	int nid;

	for_each_online_node(nid)
		drop_slab_node(nid);
}

Linus Torvalds's avatar
Linus Torvalds committed
532 533
static inline int is_page_cache_freeable(struct page *page)
{
534 535 536 537 538
	/*
	 * A freeable page cache page is referenced only by the caller
	 * that isolated the page, the page cache radix tree and
	 * optional buffer heads at page->private.
	 */
539 540 541
	int radix_pins = PageTransHuge(page) && PageSwapCache(page) ?
		HPAGE_PMD_NR : 1;
	return page_count(page) - page_has_private(page) == 1 + radix_pins;
Linus Torvalds's avatar
Linus Torvalds committed
542 543
}

544
static int may_write_to_inode(struct inode *inode, struct scan_control *sc)
Linus Torvalds's avatar
Linus Torvalds committed
545
{
546
	if (current->flags & PF_SWAPWRITE)
Linus Torvalds's avatar
Linus Torvalds committed
547
		return 1;
548
	if (!inode_write_congested(inode))
Linus Torvalds's avatar
Linus Torvalds committed
549
		return 1;
550
	if (inode_to_bdi(inode) == current->backing_dev_info)
Linus Torvalds's avatar
Linus Torvalds committed
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
		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)
{
570
	lock_page(page);
571 572
	if (page_mapping(page) == mapping)
		mapping_set_error(mapping, error);
Linus Torvalds's avatar
Linus Torvalds committed
573 574 575
	unlock_page(page);
}

576 577 578 579 580 581 582 583 584 585 586 587
/* 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;

Linus Torvalds's avatar
Linus Torvalds committed
588
/*
589 590
 * pageout is called by shrink_page_list() for each dirty page.
 * Calls ->writepage().
Linus Torvalds's avatar
Linus Torvalds committed
591
 */
592
static pageout_t pageout(struct page *page, struct address_space *mapping,
593
			 struct scan_control *sc)
Linus Torvalds's avatar
Linus Torvalds committed
594 595 596 597 598 599 600 601
{
	/*
	 * 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.
	 *
602
	 * If this process is currently in __generic_file_write_iter() against
Linus Torvalds's avatar
Linus Torvalds committed
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
	 * 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.
		 */
618
		if (page_has_private(page)) {
Linus Torvalds's avatar
Linus Torvalds committed
619 620
			if (try_to_free_buffers(page)) {
				ClearPageDirty(page);
621
				pr_info("%s: orphaned page\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
622 623 624 625 626 627 628
				return PAGE_CLEAN;
			}
		}
		return PAGE_KEEP;
	}
	if (mapping->a_ops->writepage == NULL)
		return PAGE_ACTIVATE;
629
	if (!may_write_to_inode(mapping->host, sc))
Linus Torvalds's avatar
Linus Torvalds committed
630 631 632 633 634 635 636
		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,
637 638
			.range_start = 0,
			.range_end = LLONG_MAX,
Linus Torvalds's avatar
Linus Torvalds committed
639 640 641 642 643 644 645
			.for_reclaim = 1,
		};

		SetPageReclaim(page);
		res = mapping->a_ops->writepage(page, &wbc);
		if (res < 0)
			handle_write_error(mapping, page, res);
646
		if (res == AOP_WRITEPAGE_ACTIVATE) {
Linus Torvalds's avatar
Linus Torvalds committed
647 648 649
			ClearPageReclaim(page);
			return PAGE_ACTIVATE;
		}
650

Linus Torvalds's avatar
Linus Torvalds committed
651 652 653 654
		if (!PageWriteback(page)) {
			/* synchronous write or broken a_ops? */
			ClearPageReclaim(page);
		}
655
		trace_mm_vmscan_writepage(page);
656
		inc_node_page_state(page, NR_VMSCAN_WRITE);
Linus Torvalds's avatar
Linus Torvalds committed
657 658 659 660 661 662
		return PAGE_SUCCESS;
	}

	return PAGE_CLEAN;
}

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

673 674
	BUG_ON(!PageLocked(page));
	BUG_ON(mapping != page_mapping(page));
675

676
	spin_lock_irqsave(&mapping->tree_lock, flags);
677
	/*
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
	 * 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
697
	 * load is not satisfied before that of page->_refcount.
698 699 700
	 *
	 * Note that if SetPageDirty is always performed via set_page_dirty,
	 * and thus under tree_lock, then this ordering is not required.
701
	 */
702 703 704 705 706
	if (unlikely(PageTransHuge(page)) && PageSwapCache(page))
		refcount = 1 + HPAGE_PMD_NR;
	else
		refcount = 2;
	if (!page_ref_freeze(page, refcount))
707
		goto cannot_free;
708 709
	/* note: atomic_cmpxchg in page_freeze_refs provides the smp_rmb */
	if (unlikely(PageDirty(page))) {
710
		page_ref_unfreeze(page, refcount);
711
		goto cannot_free;
712
	}
713 714 715

	if (PageSwapCache(page)) {
		swp_entry_t swap = { .val = page_private(page) };
716
		mem_cgroup_swapout(page, swap);
717
		__delete_from_swap_cache(page);
718
		spin_unlock_irqrestore(&mapping->tree_lock, flags);
719
		put_swap_page(page, swap);
720
	} else {
721
		void (*freepage)(struct page *);
722
		void *shadow = NULL;
723 724

		freepage = mapping->a_ops->freepage;
725 726 727 728 729 730 731 732 733
		/*
		 * 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.
734 735 736 737 738 739
		 *
		 * 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.
740 741
		 */
		if (reclaimed && page_is_file_cache(page) &&
742
		    !mapping_exiting(mapping) && !dax_mapping(mapping))
743
			shadow = workingset_eviction(mapping, page);
744
		__delete_from_page_cache(page, shadow);
745
		spin_unlock_irqrestore(&mapping->tree_lock, flags);
746 747 748

		if (freepage != NULL)
			freepage(page);
749 750 751 752 753
	}

	return 1;

cannot_free:
754
	spin_unlock_irqrestore(&mapping->tree_lock, flags);
755 756 757
	return 0;
}

758 759 760 761 762 763 764 765
/*
 * 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)
{
766
	if (__remove_mapping(mapping, page, false)) {
767 768 769 770 771
		/*
		 * Unfreezing the refcount with 1 rather than 2 effectively
		 * drops the pagecache ref for us without requiring another
		 * atomic operation.
		 */
772
		page_ref_unfreeze(page, 1);
773 774 775 776 777
		return 1;
	}
	return 0;
}

778 779 780 781 782 783 784 785 786 787 788
/**
 * 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)
{
789
	bool is_unevictable;
790
	int was_unevictable = PageUnevictable(page);
791

792
	VM_BUG_ON_PAGE(PageLRU(page), page);
793 794 795 796

redo:
	ClearPageUnevictable(page);

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

	/*
	 * page's status can change while we move it among lru. If an evictable
	 * page is on unevictable list, it never be freed. To avoid that,
	 * check after we added it to the list, again.
	 */
831
	if (is_unevictable && page_evictable(page)) {
832 833 834 835 836 837 838 839 840 841
		if (!isolate_lru_page(page)) {
			put_page(page);
			goto redo;
		}
		/* This means someone else dropped this page from LRU
		 * So, it will be freed or putback to LRU again. There is
		 * nothing to do here.
		 */
	}

842
	if (was_unevictable && !is_unevictable)
843
		count_vm_event(UNEVICTABLE_PGRESCUED);
844
	else if (!was_unevictable && is_unevictable)
845 846
		count_vm_event(UNEVICTABLE_PGCULLED);

847 848 849
	put_page(page);		/* drop ref from isolate */
}

850 851 852
enum page_references {
	PAGEREF_RECLAIM,
	PAGEREF_RECLAIM_CLEAN,
853
	PAGEREF_KEEP,
854 855 856 857 858 859
	PAGEREF_ACTIVATE,
};

static enum page_references page_check_references(struct page *page,
						  struct scan_control *sc)
{
860
	int referenced_ptes, referenced_page;
861 862
	unsigned long vm_flags;

863 864
	referenced_ptes = page_referenced(page, 1, sc->target_mem_cgroup,
					  &vm_flags);
865
	referenced_page = TestClearPageReferenced(page);
866 867 868 869 870 871 872 873

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

874
	if (referenced_ptes) {
875
		if (PageSwapBacked(page))
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
			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);

893
		if (referenced_page || referenced_ptes > 1)
894 895
			return PAGEREF_ACTIVATE;

896 897 898 899 900 901
		/*
		 * Activate file-backed executable pages after first usage.
		 */
		if (vm_flags & VM_EXEC)
			return PAGEREF_ACTIVATE;

902 903
		return PAGEREF_KEEP;
	}
904 905

	/* Reclaim if clean, defer dirty pages to writeback */
906
	if (referenced_page && !PageSwapBacked(page))
907 908 909
		return PAGEREF_RECLAIM_CLEAN;

	return PAGEREF_RECLAIM;
910 911
}

912 913 914 915
/* Check if a page is dirty or under writeback */
static void page_check_dirty_writeback(struct page *page,
				       bool *dirty, bool *writeback)
{
916 917
	struct address_space *mapping;

918 919 920 921
	/*
	 * Anonymous pages are not handled by flushers and must be written
	 * from reclaim context. Do not stall reclaim based on them
	 */
Shaohua Li's avatar
Shaohua Li committed
922 923
	if (!page_is_file_cache(page) ||
	    (PageAnon(page) && !PageSwapBacked(page))) {
924 925 926 927 928 929 930 931
		*dirty = false;
		*writeback = false;
		return;
	}

	/* By default assume that the page flags are accurate */
	*dirty = PageDirty(page);
	*writeback = PageWriteback(page);
932 933 934 935 936 937 938 939

	/* 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);
940 941
}

942 943 944 945 946 947
struct reclaim_stat {
	unsigned nr_dirty;
	unsigned nr_unqueued_dirty;
	unsigned nr_congested;
	unsigned nr_writeback;
	unsigned nr_immediate;
948 949 950
	unsigned nr_activate;
	unsigned nr_ref_keep;
	unsigned nr_unmap_fail;
951 952
};

Linus Torvalds's avatar
Linus Torvalds committed
953
/*
954
 * shrink_page_list() returns the number of reclaimed pages
Linus Torvalds's avatar
Linus Torvalds committed
955
 */
956
static unsigned long shrink_page_list(struct list_head *page_list,
957
				      struct pglist_data *pgdat,
958
				      struct scan_control *sc,
959
				      enum ttu_flags ttu_flags,
960
				      struct reclaim_stat *stat,
961
				      bool force_reclaim)
Linus Torvalds's avatar
Linus Torvalds committed
962 963
{
	LIST_HEAD(ret_pages);
964
	LIST_HEAD(free_pages);
Linus Torvalds's avatar
Linus Torvalds committed
965
	int pgactivate = 0;
966 967 968 969 970 971
	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;
972 973
	unsigned nr_ref_keep = 0;
	unsigned nr_unmap_fail = 0;
Linus Torvalds's avatar
Linus Torvalds committed
974 975 976 977 978 979 980

	cond_resched();

	while (!list_empty(page_list)) {
		struct address_space *mapping;
		struct page *page;
		int may_enter_fs;
981
		enum page_references references = PAGEREF_RECLAIM_CLEAN;
982
		bool dirty, writeback;
Linus Torvalds's avatar
Linus Torvalds committed
983 984 985 986 987 988

		cond_resched();

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

Nick Piggin's avatar
Nick Piggin committed
989
		if (!trylock_page(page))
Linus Torvalds's avatar
Linus Torvalds committed
990 991
			goto keep;

992
		VM_BUG_ON_PAGE(PageActive(page), page);
Linus Torvalds's avatar
Linus Torvalds committed
993 994

		sc->nr_scanned++;
995

996
		if (unlikely(!page_evictable(page)))
Minchan Kim's avatar
Minchan Kim committed
997
			goto activate_locked;
998

999
		if (!sc->may_unmap && page_mapped(page))
1000 1001
			goto keep_locked;

Linus Torvalds's avatar
Linus Torvalds committed
1002
		/* Double the slab pressure for mapped and swapcache pages */
Shaohua Li's avatar
Shaohua Li committed
1003 1004
		if ((page_mapped(page) || PageSwapCache(page)) &&
		    !(PageAnon(page) && !PageSwapBacked(page)))
Linus Torvalds's avatar
Linus Torvalds committed
1005 1006
			sc->nr_scanned++;

1007 1008 1009
		may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
			(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));

1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
		/*
		 * The number of dirty pages determines if a zone is marked
		 * reclaim_congested which affects wait_iff_congested. kswapd
		 * will stall and start writing pages if the tail of the LRU
		 * is all dirty unqueued pages.
		 */
		page_check_dirty_writeback(page, &dirty, &writeback);
		if (dirty || writeback)
			nr_dirty++;

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

1023 1024 1025 1026 1027 1028
		/*
		 * 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.
		 */
1029
		mapping = page_mapping(page);
1030
		if (((dirty || writeback) && mapping &&
1031
		     inode_write_congested(mapping->host)) ||
1032
		    (writeback && PageReclaim(page)))
1033 1034
			nr_congested++;

1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
		/*
		 * 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
1046 1047
		 *    note that the LRU is being scanned too quickly and the
		 *    caller can stall after page list has been processed.
1048
		 *
1049
		 * 2) Global or new memcg reclaim encounters a page that is
1050 1051 1052
		 *    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
1053
		 *    reclaim and continue scanning.
1054
		 *
1055 1056
		 *    Require may_enter_fs because we would wait on fs, which
		 *    may not have submitted IO yet. And the loop driver might
1057 1058 1059 1060 1061
		 *    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.
		 *
1062
		 * 3) Legacy memcg encounters a page that is already marked
1063 1064 1065 1066
		 *    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.
1067 1068 1069 1070 1071 1072 1073 1074 1075
		 *
		 * 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.
1076
		 */
1077
		if (PageWriteback(page)) {
1078 1079 1080
			/* Case 1 above */
			if (current_is_kswapd() &&
			    PageReclaim(page) &&
1081
			    test_bit(PGDAT_WRITEBACK, &pgdat->flags)) {
1082
				nr_immediate++;
1083
				goto activate_locked;
1084 1085

			/* Case 2 above */
1086
			} else if (sane_reclaim(sc) ||
1087
			    !PageReclaim(page) || !may_enter_fs) {
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
				/*
				 * 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);
1100
				nr_writeback++;
1101
				goto activate_locked;
1102 1103 1104

			/* Case 3 above */
			} else {
1105
				unlock_page(page);
1106
				wait_on_page_writeback(page);
1107 1108 1109
				/* then go back and try same page again */
				list_add_tail(&page->lru, page_list);
				continue;
1110
			}
1111
		}
Linus Torvalds's avatar
Linus Torvalds committed
1112

1113 1114 1115
		if (!force_reclaim)
			references = page_check_references(page, sc);

1116 1117
		switch (references) {
		case PAGEREF_ACTIVATE:
Linus Torvalds's avatar
Linus Torvalds committed
1118
			goto activate_locked;
1119
		case PAGEREF_KEEP:
1120
			nr_ref_keep++;
1121
			goto keep_locked;
1122 1123 1124 1125
		case PAGEREF_RECLAIM:
		case PAGEREF_RECLAIM_CLEAN:
			; /* try to reclaim the page below */
		}
Linus Torvalds's avatar
Linus Torvalds committed
1126 1127 1128 1129

		/*
		 * Anonymous process memory has backing store?
		 * Try to allocate it some swap space here.
Shaohua Li's avatar
Shaohua Li committed
1130
		 * Lazyfree page could be freed directly
Linus Torvalds's avatar
Linus Torvalds committed
1131
		 */
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
		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;
1157 1158 1159
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
					count_vm_event(THP_SWPOUT_FALLBACK);
#endif
1160 1161 1162
					if (!add_to_swap(page))
						goto activate_locked;
				}
1163

1164
				may_enter_fs = 1;
Linus Torvalds's avatar
Linus Torvalds committed
1165

1166 1167 1168
				/* Adding to swap updated mapping */
				mapping = page_mapping(page);
			}
1169 1170 1171 1172
		} else if (unlikely(PageTransHuge(page))) {
			/* Split file THP */
			if (split_huge_page_to_list(page, page_list))
				goto keep_locked;
1173
		}
Linus Torvalds's avatar
Linus Torvalds committed
1174 1175 1176 1177 1178

		/*
		 * The page is mapped into the page tables of one or more
		 * processes. Try to unmap it here.
		 */
Shaohua Li's avatar
Shaohua Li committed
1179
		if (page_mapped(page)) {
1180 1181 1182 1183 1184
			enum ttu_flags flags = ttu_flags | TTU_BATCH_FLUSH;

			if (unlikely(PageTransHuge(page)))
				flags |= TTU_SPLIT_HUGE_PMD;
			if (!try_to_unmap(page, flags)) {
1185
				nr_unmap_fail++;
Linus Torvalds's avatar
Linus Torvalds committed
1186 1187 1188 1189 1190
				goto activate_locked;
			}
		}

		if (PageDirty(page)) {
1191
			/*
1192 1193 1194 1195 1196 1197 1198 1199
			 * 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).
1200
			 */
1201
			if (page_is_file_cache(page) &&
1202 1203
			    (!current_is_kswapd() || !PageReclaim(page) ||
			     !test_bit(PGDAT_DIRTY, &pgdat->flags))) {
1204 1205 1206 1207 1208 1209
				/*
				 * Immediately reclaim when written back.
				 * Similar in principal to deactivate_page()
				 * except we already have the page isolated
				 * and know it's dirty
				 */
1210
				inc_node_page_state(page, NR_VMSCAN_IMMEDIATE);
1211 1212
				SetPageReclaim(page);

1213
				goto activate_locked;
1214 1215
			}

1216
			if (references == PAGEREF_RECLAIM_CLEAN)
Linus Torvalds's avatar
Linus Torvalds committed
1217
				goto keep_locked;
1218
			if (!may_enter_fs)
Linus Torvalds's avatar
Linus Torvalds committed
1219
				goto keep_locked;
1220
			if (!sc->may_writepage)
Linus Torvalds's avatar
Linus Torvalds committed
1221 1222
				goto keep_locked;

1223 1224 1225 1226 1227 1228
			/*
			 * 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();
1229
			switch (pageout(page, mapping, sc)) {
Linus Torvalds's avatar
Linus Torvalds committed
1230 1231 1232 1233 1234
			case PAGE_KEEP:
				goto keep_locked;
			case PAGE_ACTIVATE:
				goto activate_locked;
			case PAGE_SUCCESS:
1235
				if (PageWriteback(page))
1236
					goto keep;
1237
				if (PageDirty(page))
Linus Torvalds's avatar
Linus Torvalds committed
1238
					goto keep;
1239

Linus Torvalds's avatar
Linus Torvalds committed
1240 1241 1242 1243
				/*
				 * A synchronous write - probably a ramdisk.  Go
				 * ahead and try to reclaim the page.
				 */
Nick Piggin's avatar
Nick Piggin committed
1244
				if (!trylock_page(page))
Linus Torvalds's avatar
Linus Torvalds committed
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
					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
1264
		 * will do this, as well as the blockdev mapping.
Linus Torvalds's avatar
Linus Torvalds committed
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
		 * 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.
		 */
1275
		if (page_has_private(page)) {
Linus Torvalds's avatar
Linus Torvalds committed
1276 1277
			if (!try_to_release_page(page, sc->gfp_mask))
				goto activate_locked;
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
			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;
				}
			}
Linus Torvalds's avatar
Linus Torvalds committed
1294 1295
		}

Shaohua Li's avatar
Shaohua Li committed
1296 1297 1298 1299 1300 1301 1302 1303
		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;
			}
Linus Torvalds's avatar
Linus Torvalds committed
1304

Shaohua Li's avatar
Shaohua Li committed
1305
			count_vm_event(PGLAZYFREED);
1306
			count_memcg_page_event(page, PGLAZYFREED);
Shaohua Li's avatar
Shaohua Li committed
1307 1308
		} else if (!mapping || !__remove_mapping(mapping, page, true))
			goto keep_locked;
Nick Piggin's avatar
Nick Piggin committed
1309 1310 1311 1312 1313 1314 1315
		/*
		 * 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.
		 */
1316
		__ClearPageLocked(page);
1317
free_it:
1318
		nr_reclaimed++;
1319 1320 1321 1322 1323

		/*
		 * Is there need to periodically free_page_list? It would
		 * appear not as the counts should be low
		 */
1324 1325 1326 1327 1328
		if (unlikely(PageTransHuge(page))) {
			mem_cgroup_uncharge(page);
			(*get_compound_page_dtor(page))(page);
		} else
			list_add(&page->lru, &free_pages);
Linus Torvalds's avatar
Linus Torvalds committed
1329 1330 1331
		continue;

activate_locked:
1332
		/* Not a candidate for swapping, so reclaim swap space. */
Minchan Kim's avatar
Minchan Kim committed
1333 1334
		if (PageSwapCache(page) && (mem_cgroup_swap_full(page) ||
						PageMlocked(page)))
1335
			try_to_free_swap(page);
1336
		VM_BUG_ON_PAGE(PageActive(page), page);
Minchan Kim's avatar
Minchan Kim committed
1337 1338 1339
		if (!PageMlocked(page)) {
			SetPageActive(page);
			pgactivate++;
1340
			count_memcg_page_event(page, PGACTIVATE);
Minchan Kim's avatar
Minchan Kim committed
1341
		}
Linus Torvalds's avatar
Linus Torvalds committed
1342 1343 1344 1345
keep_locked:
		unlock_page(page);
keep:
		list_add(&page->lru, &ret_pages);
1346
		VM_BUG_ON_PAGE(PageLRU(page) || PageUnevictable(page), page);
Linus Torvalds's avatar
Linus Torvalds committed
1347
	}
1348

1349
	mem_cgroup_uncharge_list(&free_pages);
1350
	try_to_unmap_flush();
1351
	free_hot_cold_page_list(&free_pages, true);
1352

Linus Torvalds's avatar
Linus Torvalds committed
1353
	list_splice(&ret_pages, page_list);
1354
	count_vm_events(PGACTIVATE, pgactivate);
1355

1356 1357 1358 1359 1360 1361
	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;
1362 1363 1364
		stat->nr_activate = pgactivate;
		stat->nr_ref_keep = nr_ref_keep;
		stat->nr_unmap_fail = nr_unmap_fail;
1365
	}
1366
	return nr_reclaimed;
Linus Torvalds's avatar
Linus Torvalds committed
1367 1368
}

1369 1370 1371 1372 1373 1374 1375 1376
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,
	};
1377
	unsigned long ret;
1378 1379 1380 1381
	struct page *page, *next;
	LIST_HEAD(clean_pages);

	list_for_each_entry_safe(page, next, page_list, lru) {
1382
		if (page_is_file_cache(page) && !PageDirty(page) &&
1383
		    !__PageMovable(page)) {
1384 1385 1386 1387 1388
			ClearPageActive(page);
			list_move(&page->lru, &clean_pages);
		}
	}

1389
	ret = shrink_page_list(&clean_pages, zone->zone_pgdat, &sc,
1390
			TTU_IGNORE_ACCESS, NULL, true);
1391
	list_splice(&clean_pages, page_list);
1392
	mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_FILE, -ret);
1393 1394 1395
	return ret;
}

Andy Whitcroft's avatar
Andy Whitcroft committed
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
/*
 * 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.
 */
1406
int __isolate_lru_page(struct page *page, isolate_mode_t mode)
Andy Whitcroft's avatar
Andy Whitcroft committed
1407 1408 1409 1410 1411 1412 1413
{
	int ret = -EINVAL;

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

Minchan Kim's avatar
Minchan Kim committed
1414 1415
	/* Compaction should not handle unevictable pages but CMA can do so */
	if (PageUnevictable(page) && !(mode & ISOLATE_UNEVICTABLE))
1416 1417
		return ret;

Andy Whitcroft's avatar
Andy Whitcroft committed
1418
	ret = -EBUSY;
KAMEZAWA Hiroyuki's avatar
KAMEZAWA Hiroyuki committed
1419

1420 1421 1422 1423 1424 1425 1426 1427
	/*
	 * 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
	 */
1428
	if (mode & ISOLATE_ASYNC_MIGRATE) {
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
		/* All the caller can do on PageWriteback is block */
		if (PageWriteback(page))
			return ret;

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

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

1447 1448 1449
	if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
		return ret;

Andy Whitcroft's avatar
Andy Whitcroft committed
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
	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;
}

1463 1464 1465 1466 1467 1468

/*
 * 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,
1469
			enum lru_list lru, unsigned long *nr_zone_taken)
1470 1471 1472 1473 1474 1475 1476 1477 1478
{
	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
1479
		mem_cgroup_update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
1480
#endif
1481 1482
	}

1483 1484
}

Linus Torvalds's avatar
Linus Torvalds committed
1485
/*
1486
 * zone_lru_lock is heavily contended.  Some of the functions that
Linus Torvalds's avatar
Linus Torvalds committed
1487 1488 1489 1490 1491 1492 1493 1494
 * 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.
 *
1495
 * @nr_to_scan:	The number of eligible pages to look through on the list.
1496
 * @lruvec:	The LRU vector to pull pages from.
Linus Torvalds's avatar
Linus Torvalds committed
1497
 * @dst:	The temp list to put pages on to.
Hugh Dickins's avatar
Hugh Dickins committed
1498
 * @nr_scanned:	The number of pages that were scanned.
1499
 * @sc:		The scan_control struct for this reclaim session
Andy Whitcroft's avatar
Andy Whitcroft committed
1500
 * @mode:	One of the LRU isolation modes
1501
 * @lru:	LRU list id for isolating
Linus Torvalds's avatar
Linus Torvalds committed
1502 1503 1504
 *
 * returns how many pages were moved onto *@dst.
 */
1505
static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
1506
		struct lruvec *lruvec, struct list_head *dst,
1507
		unsigned long *nr_scanned, struct scan_control *sc,
1508
		isolate_mode_t mode, enum lru_list lru)
Linus Torvalds's avatar
Linus Torvalds committed
1509
{
1510
	struct list_head *src = &lruvec->lists[lru];
1511
	unsigned long nr_taken = 0;
1512
	unsigned long nr_zone_taken[MAX_NR_ZONES] = { 0 };
1513
	unsigned long nr_skipped[MAX_NR_ZONES] = { 0, };
1514
	unsigned long skipped = 0;
1515
	unsigned long scan, total_scan, nr_pages;
1516
	LIST_HEAD(pages_skipped);
Linus Torvalds's avatar
Linus Torvalds committed
1517

1518 1519 1520 1521
	scan = 0;
	for (total_scan = 0;
	     scan < nr_to_scan && nr_taken < nr_to_scan && !list_empty(src);
	     total_scan++) {
Andy Whitcroft's avatar
Andy Whitcroft committed
1522 1523
		struct page *page;

Linus Torvalds's avatar
Linus Torvalds committed
1524 1525 1526
		page = lru_to_page(src);
		prefetchw_prev_lru_page(page, src, flags);

1527
		VM_BUG_ON_PAGE(!PageLRU(page), page);
Nick Piggin's avatar
Nick Piggin committed
1528

1529 1530
		if (page_zonenum(page) > sc->reclaim_idx) {
			list_move(&page->lru, &pages_skipped);
1531
			nr_skipped[page_zonenum(page)]++;
1532 1533 1534
			continue;
		}

1535 1536 1537 1538 1539 1540 1541
		/*
		 * 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++;
1542
		switch (__isolate_lru_page(page, mode)) {
Andy Whitcroft's avatar
Andy Whitcroft committed
1543
		case 0:
1544 1545 1546
			nr_pages = hpage_nr_pages(page);
			nr_taken += nr_pages;
			nr_zone_taken[page_zonenum(page)] += nr_pages;
Andy Whitcroft's avatar
Andy Whitcroft committed
1547 1548 1549 1550 1551 1552 1553
			list_move(&page->lru, dst);
			break;

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

Andy Whitcroft's avatar
Andy Whitcroft committed
1555 1556 1557
		default:
			BUG();
		}
Linus Torvalds's avatar
Linus Torvalds committed
1558 1559
	}

1560 1561 1562 1563 1564 1565 1566
	/*
	 * 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.
	 */
1567 1568 1569
	if (!list_empty(&pages_skipped)) {
		int zid;

1570
		list_splice(&pages_skipped, src);
1571 1572 1573 1574 1575
		for (zid = 0; zid < MAX_NR_ZONES; zid++) {
			if (!nr_skipped[zid])
				continue;

			__count_zid_vm_events(PGSCAN_SKIP, zid, nr_skipped[zid]);
1576
			skipped += nr_skipped[zid];
1577 1578
		}
	}
1579
	*nr_scanned = total_scan;
1580
	trace_mm_vmscan_lru_isolate(sc->reclaim_idx, sc->order, nr_to_scan,
1581
				    total_scan, skipped, nr_taken, mode, lru);
1582
	update_lru_sizes(lruvec, lru, nr_zone_taken);
Linus Torvalds's avatar
Linus Torvalds committed
1583 1584 1585
	return nr_taken;
}

1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
/**
 * 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
1597 1598 1599
 * 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.
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
 *
 * The vmstat statistic corresponding to the list on which the page was
 * found will be decremented.
 *
 * Restrictions:
 * (1) Must be called with an elevated refcount on the page. This is a
 *     fundamentnal difference from isolate_lru_pages (which is called
 *     without a stable reference).
 * (2) the lru_lock must not be held.
 * (3) interrupts must be enabled.
 */
int isolate_lru_page(struct page *page)
{
	int ret = -EBUSY;

1615
	VM_BUG_ON_PAGE(!page_count(page), page);
1616
	WARN_RATELIMIT(PageTail(page), "trying to isolate tail page");
1617

1618 1619
	if (PageLRU(page)) {
		struct zone *zone = page_zone(page);
1620
		struct lruvec *lruvec;
1621

1622
		spin_lock_irq(zone_lru_lock(zone));
1623
		lruvec = mem_cgroup_page_lruvec(page, zone->zone_pgdat);
1624
		if (PageLRU(page)) {
1625
			int lru = page_lru(page);
1626
			get_page(page);
1627
			ClearPageLRU(page);
1628 1629
			del_page_from_lru_list(page, lruvec, lru);
			ret = 0;
1630
		}
1631
		spin_unlock_irq(zone_lru_lock(zone));
1632 1633 1634 1635
	}
	return ret;
}

1636
/*
1637 1638 1639 1640 1641
 * 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.
1642
 */
1643
static int too_many_isolated(struct pglist_data *pgdat, int file,
1644 1645 1646 1647 1648 1649 1650
		struct scan_control *sc)
{
	unsigned long inactive, isolated;

	if (current_is_kswapd())
		return 0;

1651
	if (!sane_reclaim(sc))
1652 1653 1654
		return 0;

	if (file) {
1655 1656
		inactive = node_page_state(pgdat, NR_INACTIVE_FILE);
		isolated = node_page_state(pgdat, NR_ISOLATED_FILE);
1657
	} else {
1658 1659
		inactive = node_page_state(pgdat, NR_INACTIVE_ANON);
		isolated = node_page_state(pgdat, NR_ISOLATED_ANON);
1660 1661
	}

1662 1663 1664 1665 1666
	/*
	 * 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.
	 */
1667
	if ((sc->gfp_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
1668 1669
		inactive >>= 3;

1670 1671 1672
	return isolated > inactive;
}

1673
static noinline_for_stack void
1674
putback_inactive_pages(struct lruvec *lruvec, struct list_head *page_list)
1675
{
1676
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1677
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1678
	LIST_HEAD(pages_to_free);
1679 1680 1681 1682 1683

	/*
	 * Put back any unfreeable pages.
	 */
	while (!list_empty(page_list)) {
1684
		struct page *page = lru_to_page(page_list);
1685
		int lru;
1686

1687
		VM_BUG_ON_PAGE(PageLRU(page), page);
1688
		list_del(&page->lru);
1689
		if (unlikely(!page_evictable(page))) {
1690
			spin_unlock_irq(&pgdat->lru_lock);
1691
			putback_lru_page(page);
1692
			spin_lock_irq(&pgdat->lru_lock);
1693 1694
			continue;
		}
1695

1696
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
1697

1698
		SetPageLRU(page);
1699
		lru = page_lru(page);
1700 1701
		add_page_to_lru_list(page, lruvec, lru);

1702 1703
		if (is_active_lru(lru)) {
			int file = is_file_lru(lru);
1704 1705
			int numpages = hpage_nr_pages(page);
			reclaim_stat->recent_rotated[file] += numpages;
1706
		}
1707 1708 1709
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
1710
			del_page_from_lru_list(page, lruvec, lru);
1711 1712

			if (unlikely(PageCompound(page))) {
1713
				spin_unlock_irq(&pgdat->lru_lock);
1714
				mem_cgroup_uncharge(page);
1715
				(*get_compound_page_dtor(page))(page);
1716
				spin_lock_irq(&pgdat->lru_lock);
1717 1718
			} else
				list_add(&page->lru, &pages_to_free);
1719 1720 1721
		}
	}

1722 1723 1724 1725
	/*
	 * To save our caller's stack, now use input list for pages to free.
	 */
	list_splice(&pages_to_free, page_list);
1726 1727
}

1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
/*
 * 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);
}

Linus Torvalds's avatar
Linus Torvalds committed
1741
/*
1742
 * shrink_inactive_list() is a helper for shrink_node().  It returns the number
1743
 * of reclaimed pages
Linus Torvalds's avatar
Linus Torvalds committed
1744
 */
1745
static noinline_for_stack unsigned long
1746
shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
1747
		     struct scan_control *sc, enum lru_list lru)
Linus Torvalds's avatar
Linus Torvalds committed
1748 1749
{
	LIST_HEAD(page_list);
1750
	unsigned long nr_scanned;
1751
	unsigned long nr_reclaimed = 0;
1752
	unsigned long nr_taken;
1753
	struct reclaim_stat stat = {};
1754
	isolate_mode_t isolate_mode = 0;
1755
	int file = is_file_lru(lru);
1756
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1757
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1758
	bool stalled = false;
1759

1760
	while (unlikely(too_many_isolated(pgdat, file, sc))) {
1761 1762 1763 1764 1765 1766
		if (stalled)
			return 0;

		/* wait a bit for the reclaimer. */
		msleep(100);
		stalled = true;
1767 1768 1769 1770 1771 1772

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

Linus Torvalds's avatar
Linus Torvalds committed
1773
	lru_add_drain();
1774 1775

	if (!sc->may_unmap)
1776
		isolate_mode |= ISOLATE_UNMAPPED;
1777

1778
	spin_lock_irq(&pgdat->lru_lock);
1779

1780 1781
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &page_list,
				     &nr_scanned, sc, isolate_mode, lru);
1782

1783
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1784
	reclaim_stat->recent_scanned[file] += nr_taken;
1785

1786 1787
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
1788
			__count_vm_events(PGSCAN_KSWAPD, nr_scanned);
1789 1790 1791 1792
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_KSWAPD,
				   nr_scanned);
	} else {
		if (global_reclaim(sc))
1793
			__count_vm_events(PGSCAN_DIRECT, nr_scanned);
1794 1795
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_DIRECT,
				   nr_scanned);
1796
	}
1797
	spin_unlock_irq(&pgdat->lru_lock);
1798

1799
	if (nr_taken == 0)
1800
		return 0;
Andy Whitcroft's avatar
Andy Whitcroft committed
1801

1802
	nr_reclaimed = shrink_page_list(&page_list, pgdat, sc, 0,
1803
				&stat, false);
1804

1805
	spin_lock_irq(&pgdat->lru_lock);
1806

1807 1808
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
1809
			__count_vm_events(PGSTEAL_KSWAPD, nr_reclaimed);
1810 1811 1812 1813
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_KSWAPD,
				   nr_reclaimed);
	} else {
		if (global_reclaim(sc))
1814
			__count_vm_events(PGSTEAL_DIRECT, nr_reclaimed);
1815 1816
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_DIRECT,
				   nr_reclaimed);
1817
	}
Nick Piggin's avatar
Nick Piggin committed
1818

1819
	putback_inactive_pages(lruvec, &page_list);
1820

1821
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
1822

1823
	spin_unlock_irq(&pgdat->lru_lock);
1824

1825
	mem_cgroup_uncharge_list(&page_list);
1826
	free_hot_cold_page_list(&page_list, true);
1827

1828 1829 1830 1831 1832 1833 1834 1835 1836 1837
	/*
	 * 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.
	 *
1838 1839 1840
	 * Once a zone is flagged ZONE_WRITEBACK, kswapd will count the number
	 * of pages under pages flagged for immediate reclaim and stall if any
	 * are encountered in the nr_immediate check below.
1841
	 */
1842
	if (stat.nr_writeback && stat.nr_writeback == nr_taken)
1843
		set_bit(PGDAT_WRITEBACK, &pgdat->flags);
1844

1845
	/*
1846 1847
	 * Legacy memcg will stall in page writeback so avoid forcibly
	 * stalling here.
1848
	 */
1849
	if (sane_reclaim(sc)) {
1850 1851 1852 1853
		/*
		 * Tag a zone as congested if all the dirty pages scanned were
		 * backed by a congested BDI and wait_iff_congested will stall.
		 */
1854
		if (stat.nr_dirty && stat.nr_dirty == stat.nr_congested)
1855
			set_bit(PGDAT_CONGESTED, &pgdat->flags);
1856

1857 1858
		/*
		 * If dirty pages are scanned that are not queued for IO, it
1859 1860 1861 1862 1863 1864 1865 1866 1867
		 * implies that flushers are not doing their job. This can
		 * happen when memory pressure pushes dirty pages to the end of
		 * the LRU before the dirty limits are breached and the dirty
		 * data has expired. It can also happen when the proportion of
		 * dirty pages grows not through writes but through memory
		 * pressure reclaiming all the clean cache. And in some cases,
		 * the flushers simply cannot keep up with the allocation
		 * rate. Nudge the flusher threads in case they are asleep, but
		 * also allow kswapd to start writing pages during reclaim.
1868
		 */
1869
		if (stat.nr_unqueued_dirty == nr_taken) {
1870
			wakeup_flusher_threads(WB_REASON_VMSCAN);
1871
			set_bit(PGDAT_DIRTY, &pgdat->flags);
1872
		}
1873 1874

		/*
1875 1876 1877
		 * 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
1878 1879
		 * they are written so also forcibly stall.
		 */
1880
		if (stat.nr_immediate && current_may_throttle())
1881
			congestion_wait(BLK_RW_ASYNC, HZ/10);
1882
	}
1883

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

1893 1894
	trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
			nr_scanned, nr_reclaimed,
1895 1896 1897 1898
			stat.nr_dirty,  stat.nr_writeback,
			stat.nr_congested, stat.nr_immediate,
			stat.nr_activate, stat.nr_ref_keep,
			stat.nr_unmap_fail,
1899
			sc->priority, file);
1900
	return nr_reclaimed;
Linus Torvalds's avatar
Linus Torvalds committed
1901 1902 1903 1904 1905 1906 1907 1908 1909
}

/*
 * 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
1910
 * appropriate to hold zone_lru_lock across the whole operation.  But if
Linus Torvalds's avatar
Linus Torvalds committed
1911
 * the pages are mapped, the processing is slow (page_referenced()) so we
1912
 * should drop zone_lru_lock around each page.  It's impossible to balance
Linus Torvalds's avatar
Linus Torvalds committed
1913 1914 1915 1916
 * 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.
 *
1917
 * The downside is that we have to touch page->_refcount against each page.
Linus Torvalds's avatar
Linus Torvalds committed
1918
 * But we had to alter page->flags anyway.
1919 1920
 *
 * Returns the number of pages moved to the given lru.
Linus Torvalds's avatar
Linus Torvalds committed
1921
 */
1922

1923
static unsigned move_active_pages_to_lru(struct lruvec *lruvec,
1924
				     struct list_head *list,
1925
				     struct list_head *pages_to_free,
1926 1927
				     enum lru_list lru)
{
1928
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1929
	struct page *page;
1930
	int nr_pages;
1931
	int nr_moved = 0;
1932 1933 1934

	while (!list_empty(list)) {
		page = lru_to_page(list);
1935
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
1936

1937
		VM_BUG_ON_PAGE(PageLRU(page), page);
1938 1939
		SetPageLRU(page);

1940
		nr_pages = hpage_nr_pages(page);
1941
		update_lru_size(lruvec, lru, page_zonenum(page), nr_pages);
1942
		list_move(&page->lru, &lruvec->lists[lru]);
1943

1944 1945 1946
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
1947
			del_page_from_lru_list(page, lruvec, lru);
1948 1949

			if (unlikely(PageCompound(page))) {
1950
				spin_unlock_irq(&pgdat->lru_lock);
1951
				mem_cgroup_uncharge(page);
1952
				(*get_compound_page_dtor(page))(page);
1953
				spin_lock_irq(&pgdat->lru_lock);
1954 1955
			} else
				list_add(&page->lru, pages_to_free);
1956 1957
		} else {
			nr_moved += nr_pages;
1958 1959
		}
	}
1960

1961
	if (!is_active_lru(lru)) {
1962
		__count_vm_events(PGDEACTIVATE, nr_moved);
1963 1964 1965
		count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE,
				   nr_moved);
	}
1966 1967

	return nr_moved;
1968
}
1969

Hugh Dickins's avatar
Hugh Dickins committed
1970
static void shrink_active_list(unsigned long nr_to_scan,
1971
			       struct lruvec *lruvec,
1972
			       struct scan_control *sc,
1973
			       enum lru_list lru)
Linus Torvalds's avatar
Linus Torvalds committed
1974
{
1975
	unsigned long nr_taken;
Hugh Dickins's avatar
Hugh Dickins committed
1976
	unsigned long nr_scanned;
1977
	unsigned long vm_flags;
Linus Torvalds's avatar
Linus Torvalds committed
1978
	LIST_HEAD(l_hold);	/* The pages which were snipped off */
1979
	LIST_HEAD(l_active);
1980
	LIST_HEAD(l_inactive);
Linus Torvalds's avatar
Linus Torvalds committed
1981
	struct page *page;
1982
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1983 1984
	unsigned nr_deactivate, nr_activate;
	unsigned nr_rotated = 0;
1985
	isolate_mode_t isolate_mode = 0;
1986
	int file = is_file_lru(lru);
1987
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
Linus Torvalds's avatar
Linus Torvalds committed
1988 1989

	lru_add_drain();
1990 1991

	if (!sc->may_unmap)
1992
		isolate_mode |= ISOLATE_UNMAPPED;
1993

1994
	spin_lock_irq(&pgdat->lru_lock);
1995

1996 1997
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &l_hold,
				     &nr_scanned, sc, isolate_mode, lru);
1998

1999
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
2000
	reclaim_stat->recent_scanned[file] += nr_taken;
2001

2002
	__count_vm_events(PGREFILL, nr_scanned);
2003
	count_memcg_events(lruvec_memcg(lruvec), PGREFILL, nr_scanned);
2004

2005
	spin_unlock_irq(&pgdat->lru_lock);
Linus Torvalds's avatar
Linus Torvalds committed
2006 2007 2008 2009 2010

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

2012
		if (unlikely(!page_evictable(page))) {
2013 2014 2015 2016
			putback_lru_page(page);
			continue;
		}

2017 2018 2019 2020 2021 2022 2023 2024
		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);
			}
		}

2025 2026
		if (page_referenced(page, 0, sc->target_mem_cgroup,
				    &vm_flags)) {
2027
			nr_rotated += hpage_nr_pages(page);
2028 2029 2030 2031 2032 2033 2034 2035 2036
			/*
			 * 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.
			 */
2037
			if ((vm_flags & VM_EXEC) && page_is_file_cache(page)) {
2038 2039 2040 2041
				list_add(&page->lru, &l_active);
				continue;
			}
		}
2042

2043
		ClearPageActive(page);	/* we are de-activating */
Linus Torvalds's avatar
Linus Torvalds committed
2044 2045 2046
		list_add(&page->lru, &l_inactive);
	}

2047
	/*
2048
	 * Move pages back to the lru list.
2049
	 */
2050
	spin_lock_irq(&pgdat->lru_lock);
2051
	/*
2052 2053 2054
	 * 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
2055
	 * get_scan_count.
2056
	 */
2057
	reclaim_stat->recent_rotated[file] += nr_rotated;
2058

2059 2060
	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);
2061 2062
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
	spin_unlock_irq(&pgdat->lru_lock);
2063

2064
	mem_cgroup_uncharge_list(&l_hold);
2065
	free_hot_cold_page_list(&l_hold, true);
2066 2067
	trace_mm_vmscan_lru_shrink_active(pgdat->node_id, nr_taken, nr_activate,
			nr_deactivate, nr_rotated, sc->priority, file);
Linus Torvalds's avatar
Linus Torvalds committed
2068 2069
}

2070 2071 2072
/*
 * The inactive anon list should be small enough that the VM never has
 * to do too much work.
2073
 *
2074 2075 2076
 * 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.
2077
 *
2078 2079
 * Both inactive lists should also be large enough that each inactive
 * page has a chance to be referenced again before it is reclaimed.
2080
 *
2081 2082
 * If that fails and refaulting is observed, the inactive list grows.
 *
2083 2084 2085
 * The inactive_ratio is the target ratio of ACTIVE to INACTIVE pages
 * on this LRU, maintained by the pageout code. A zone->inactive_ratio
 * of 3 means 3:1 or 25% of the pages are kept on the inactive list.
2086
 *
2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
 * 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
2097
 */
2098
static bool inactive_list_is_low(struct lruvec *lruvec, bool file,
2099 2100
				 struct mem_cgroup *memcg,
				 struct scan_control *sc, bool actual_reclaim)
2101
{
2102
	enum lru_list active_lru = file * LRU_FILE + LRU_ACTIVE;
2103 2104 2105 2106 2107
	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;
2108
	unsigned long gb;
2109

2110 2111 2112 2113 2114 2115
	/*
	 * If we don't have swap space, anonymous page deactivation
	 * is pointless.
	 */
	if (!file && !total_swap_pages)
		return false;
2116

2117 2118
	inactive = lruvec_lru_size(lruvec, inactive_lru, sc->reclaim_idx);
	active = lruvec_lru_size(lruvec, active_lru, sc->reclaim_idx);
2119

2120
	if (memcg)
2121
		refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
2122
	else
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138
		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;
	}
2139

2140 2141 2142 2143 2144
	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);
2145

2146
	return inactive * inactive_ratio < active;
2147 2148
}

2149
static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
2150 2151
				 struct lruvec *lruvec, struct mem_cgroup *memcg,
				 struct scan_control *sc)
2152
{
2153
	if (is_active_lru(lru)) {
2154 2155
		if (inactive_list_is_low(lruvec, is_file_lru(lru),
					 memcg, sc, true))
2156
			shrink_active_list(nr_to_scan, lruvec, sc, lru);
2157 2158 2159
		return 0;
	}

2160
	return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);
2161 2162
}

2163 2164 2165 2166 2167 2168 2169
enum scan_balance {
	SCAN_EQUAL,
	SCAN_FRACT,
	SCAN_ANON,
	SCAN_FILE,
};

2170 2171 2172 2173 2174 2175
/*
 * 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.
 *
2176 2177
 * 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
2178
 */
2179
static void get_scan_count(struct lruvec *lruvec, struct mem_cgroup *memcg,
2180 2181
			   struct scan_control *sc, unsigned long *nr,
			   unsigned long *lru_pages)
2182
{
2183
	int swappiness = mem_cgroup_swappiness(memcg);
2184 2185 2186
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
	u64 fraction[2];
	u64 denominator = 0;	/* gcc */
2187
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2188
	unsigned long anon_prio, file_prio;
2189
	enum scan_balance scan_balance;
2190
	unsigned long anon, file;
2191
	unsigned long ap, fp;
Hugh Dickins's avatar
Hugh Dickins committed
2192
	enum lru_list lru;
2193 2194

	/* If we have no swap space, do not bother scanning anon pages. */
2195
	if (!sc->may_swap || mem_cgroup_get_nr_swap_pages(memcg) <= 0) {
2196
		scan_balance = SCAN_FILE;
2197 2198
		goto out;
	}
2199

2200 2201 2202 2203 2204 2205 2206
	/*
	 * 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.
	 */
2207
	if (!global_reclaim(sc) && !swappiness) {
2208
		scan_balance = SCAN_FILE;
2209 2210 2211 2212 2213 2214 2215 2216
		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).
	 */
2217
	if (!sc->priority && swappiness) {
2218
		scan_balance = SCAN_EQUAL;
2219 2220 2221
		goto out;
	}

2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
	/*
	 * 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)) {
2232 2233 2234 2235
		unsigned long pgdatfile;
		unsigned long pgdatfree;
		int z;
		unsigned long total_high_wmark = 0;
2236

2237 2238 2239 2240 2241 2242
		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];
2243
			if (!managed_zone(zone))
2244 2245 2246 2247
				continue;

			total_high_wmark += high_wmark_pages(zone);
		}
2248

2249
		if (unlikely(pgdatfile + pgdatfree <= total_high_wmark)) {
2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
			/*
			 * 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;
			}
2261 2262 2263
		}
	}

2264
	/*
2265 2266 2267 2268 2269 2270 2271
	 * 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.
2272
	 */
2273
	if (!inactive_list_is_low(lruvec, true, memcg, sc, false) &&
2274
	    lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
2275
		scan_balance = SCAN_FILE;
2276 2277 2278
		goto out;
	}

2279 2280
	scan_balance = SCAN_FRACT;

2281 2282 2283 2284
	/*
	 * With swappiness at 100, anonymous and file have the same priority.
	 * This scanning priority is essentially the inverse of IO cost.
	 */
2285
	anon_prio = swappiness;
2286
	file_prio = 200 - anon_prio;
2287

2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298
	/*
	 * 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]
	 */
2299

2300 2301 2302 2303
	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);
2304

2305
	spin_lock_irq(&pgdat->lru_lock);
2306 2307 2308
	if (unlikely(reclaim_stat->recent_scanned[0] > anon / 4)) {
		reclaim_stat->recent_scanned[0] /= 2;
		reclaim_stat->recent_rotated[0] /= 2;
2309 2310
	}

2311 2312 2313
	if (unlikely(reclaim_stat->recent_scanned[1] > file / 4)) {
		reclaim_stat->recent_scanned[1] /= 2;
		reclaim_stat->recent_rotated[1] /= 2;
2314 2315 2316
	}

	/*
2317 2318 2319
	 * 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.
2320
	 */
2321
	ap = anon_prio * (reclaim_stat->recent_scanned[0] + 1);
2322
	ap /= reclaim_stat->recent_rotated[0] + 1;
2323

2324
	fp = file_prio * (reclaim_stat->recent_scanned[1] + 1);
2325
	fp /= reclaim_stat->recent_rotated[1] + 1;
2326
	spin_unlock_irq(&pgdat->lru_lock);
2327

2328 2329 2330 2331
	fraction[0] = ap;
	fraction[1] = fp;
	denominator = ap + fp + 1;
out:
2332 2333 2334 2335 2336
	*lru_pages = 0;
	for_each_evictable_lru(lru) {
		int file = is_file_lru(lru);
		unsigned long size;
		unsigned long scan;
2337

2338 2339 2340 2341 2342 2343 2344 2345
		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);
2346

2347 2348 2349 2350 2351
		switch (scan_balance) {
		case SCAN_EQUAL:
			/* Scan lists relative to size */
			break;
		case SCAN_FRACT:
2352
			/*
2353 2354
			 * Scan types proportional to swappiness and
			 * their relative recent reclaim efficiency.
2355
			 */
2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369
			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();
2370
		}
2371 2372 2373

		*lru_pages += size;
		nr[lru] = scan;
2374
	}
2375
}
2376

2377
/*
2378
 * This is a basic per-node page freer.  Used by both kswapd and direct reclaim.
2379
 */
2380
static void shrink_node_memcg(struct pglist_data *pgdat, struct mem_cgroup *memcg,
2381
			      struct scan_control *sc, unsigned long *lru_pages)
2382
{
2383
	struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
2384
	unsigned long nr[NR_LRU_LISTS];
2385
	unsigned long targets[NR_LRU_LISTS];
2386 2387 2388 2389 2390
	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;
2391
	bool scan_adjusted;
2392

2393
	get_scan_count(lruvec, memcg, sc, nr, lru_pages);
2394

2395 2396 2397
	/* Record the original scan target for proportional adjustments later */
	memcpy(targets, nr, sizeof(nr));

2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411
	/*
	 * 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);

2412 2413 2414
	blk_start_plug(&plug);
	while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
					nr[LRU_INACTIVE_FILE]) {
2415 2416 2417
		unsigned long nr_anon, nr_file, percentage;
		unsigned long nr_scanned;

2418 2419 2420 2421 2422 2423
		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,
2424
							    lruvec, memcg, sc);
2425 2426
			}
		}
2427

2428 2429
		cond_resched();

2430 2431 2432 2433 2434
		if (nr_reclaimed < nr_to_reclaim || scan_adjusted)
			continue;

		/*
		 * For kswapd and memcg, reclaim at least the number of pages
2435
		 * requested. Ensure that the anon and file LRUs are scanned
2436 2437 2438 2439 2440 2441 2442
		 * 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];

2443 2444 2445 2446 2447 2448 2449 2450 2451
		/*
		 * 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;

2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
		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;
2483 2484 2485 2486 2487 2488 2489 2490
	}
	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.
	 */
2491
	if (inactive_list_is_low(lruvec, false, memcg, sc, true))
2492 2493 2494 2495
		shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
				   sc, LRU_ACTIVE_ANON);
}

2496
/* Use reclaim/compaction for costly allocs or under memory pressure */
2497
static bool in_reclaim_compaction(struct scan_control *sc)
2498
{
2499
	if (IS_ENABLED(CONFIG_COMPACTION) && sc->order &&
2500
			(sc->order > PAGE_ALLOC_COSTLY_ORDER ||
2501
			 sc->priority < DEF_PRIORITY - 2))
2502 2503 2504 2505 2506
		return true;

	return false;
}

2507
/*
2508 2509 2510 2511 2512
 * 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.
2513
 */
2514
static inline bool should_continue_reclaim(struct pglist_data *pgdat,
2515 2516 2517 2518 2519 2520
					unsigned long nr_reclaimed,
					unsigned long nr_scanned,
					struct scan_control *sc)
{
	unsigned long pages_for_compaction;
	unsigned long inactive_lru_pages;
2521
	int z;
2522 2523

	/* If not in reclaim/compaction mode, stop */
2524
	if (!in_reclaim_compaction(sc))
2525 2526
		return false;

2527
	/* Consider stopping depending on scan and reclaim activity */
2528
	if (sc->gfp_mask & __GFP_RETRY_MAYFAIL) {
2529
		/*
2530
		 * For __GFP_RETRY_MAYFAIL allocations, stop reclaiming if the
2531 2532
		 * full LRU list has been scanned and we are still failing
		 * to reclaim pages. This full LRU scan is potentially
2533
		 * expensive but a __GFP_RETRY_MAYFAIL caller really wants to succeed
2534 2535 2536 2537 2538
		 */
		if (!nr_reclaimed && !nr_scanned)
			return false;
	} else {
		/*
2539
		 * For non-__GFP_RETRY_MAYFAIL allocations which can presumably
2540 2541 2542 2543 2544 2545 2546 2547 2548
		 * 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;
	}
2549 2550 2551 2552 2553

	/*
	 * If we have not reclaimed enough pages for compaction and the
	 * inactive lists are large enough, continue reclaiming
	 */
2554
	pages_for_compaction = compact_gap(sc->order);
2555
	inactive_lru_pages = node_page_state(pgdat, NR_INACTIVE_FILE);
2556
	if (get_nr_swap_pages() > 0)
2557
		inactive_lru_pages += node_page_state(pgdat, NR_INACTIVE_ANON);
2558 2559 2560 2561 2562
	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 */
2563 2564
	for (z = 0; z <= sc->reclaim_idx; z++) {
		struct zone *zone = &pgdat->node_zones[z];
2565
		if (!managed_zone(zone))
2566 2567 2568
			continue;

		switch (compaction_suitable(zone, sc->order, 0, sc->reclaim_idx)) {
2569
		case COMPACT_SUCCESS:
2570 2571 2572 2573 2574 2575
		case COMPACT_CONTINUE:
			return false;
		default:
			/* check next zone */
			;
		}
2576
	}
2577
	return true;
2578 2579
}

2580
static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc)
Linus Torvalds's avatar
Linus Torvalds committed
2581
{
2582
	struct reclaim_state *reclaim_state = current->reclaim_state;
2583
	unsigned long nr_reclaimed, nr_scanned;
2584
	bool reclaimable = false;
Linus Torvalds's avatar
Linus Torvalds committed
2585

2586 2587 2588
	do {
		struct mem_cgroup *root = sc->target_mem_cgroup;
		struct mem_cgroup_reclaim_cookie reclaim = {
2589
			.pgdat = pgdat,
2590 2591
			.priority = sc->priority,
		};
2592
		unsigned long node_lru_pages = 0;
2593
		struct mem_cgroup *memcg;
2594

2595 2596
		nr_reclaimed = sc->nr_reclaimed;
		nr_scanned = sc->nr_scanned;
Linus Torvalds's avatar
Linus Torvalds committed
2597

2598 2599
		memcg = mem_cgroup_iter(root, NULL, &reclaim);
		do {
2600
			unsigned long lru_pages;
2601
			unsigned long reclaimed;
2602
			unsigned long scanned;
2603

2604
			if (mem_cgroup_low(root, memcg)) {
2605 2606
				if (!sc->memcg_low_reclaim) {
					sc->memcg_low_skipped = 1;
2607
					continue;
2608
				}
2609
				mem_cgroup_event(memcg, MEMCG_LOW);
2610 2611
			}

2612
			reclaimed = sc->nr_reclaimed;
2613
			scanned = sc->nr_scanned;
2614

2615 2616
			shrink_node_memcg(pgdat, memcg, sc, &lru_pages);
			node_lru_pages += lru_pages;
2617

2618
			if (memcg)
2619
				shrink_slab(sc->gfp_mask, pgdat->node_id,
2620 2621 2622
					    memcg, sc->nr_scanned - scanned,
					    lru_pages);

2623 2624 2625 2626 2627
			/* Record the group's reclaim efficiency */
			vmpressure(sc->gfp_mask, memcg, false,
				   sc->nr_scanned - scanned,
				   sc->nr_reclaimed - reclaimed);

2628
			/*
2629 2630
			 * Direct reclaim and kswapd have to scan all memory
			 * cgroups to fulfill the overall scan target for the
2631
			 * node.
2632 2633 2634 2635 2636
			 *
			 * 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.
2637
			 */
2638 2639
			if (!global_reclaim(sc) &&
					sc->nr_reclaimed >= sc->nr_to_reclaim) {
2640 2641 2642
				mem_cgroup_iter_break(root, memcg);
				break;
			}
2643
		} while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));
2644

2645 2646 2647 2648
		/*
		 * Shrink the slab caches in the same proportion that
		 * the eligible LRU pages were scanned.
		 */
2649
		if (global_reclaim(sc))
2650
			shrink_slab(sc->gfp_mask, pgdat->node_id, NULL,
2651
				    sc->nr_scanned - nr_scanned,
2652
				    node_lru_pages);
2653 2654 2655 2656

		if (reclaim_state) {
			sc->nr_reclaimed += reclaim_state->reclaimed_slab;
			reclaim_state->reclaimed_slab = 0;
2657 2658
		}

2659 2660
		/* Record the subtree's reclaim efficiency */
		vmpressure(sc->gfp_mask, sc->target_mem_cgroup, true,
2661 2662 2663
			   sc->nr_scanned - nr_scanned,
			   sc->nr_reclaimed - nr_reclaimed);

2664 2665 2666
		if (sc->nr_reclaimed - nr_reclaimed)
			reclaimable = true;

2667
	} while (should_continue_reclaim(pgdat, sc->nr_reclaimed - nr_reclaimed,
2668
					 sc->nr_scanned - nr_scanned, sc));
2669

2670 2671 2672 2673 2674 2675 2676 2677 2678
	/*
	 * 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;

2679
	return reclaimable;
2680 2681
}

2682
/*
2683 2684 2685
 * 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.
2686
 */
2687
static inline bool compaction_ready(struct zone *zone, struct scan_control *sc)
2688
{
2689
	unsigned long watermark;
2690
	enum compact_result suitable;
2691

2692 2693 2694 2695 2696 2697 2698
	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;
2699

2700
	/*
2701 2702 2703 2704 2705 2706 2707
	 * 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.
2708
	 */
2709
	watermark = high_wmark_pages(zone) + compact_gap(sc->order);
2710

2711
	return zone_watermark_ok_safe(zone, 0, watermark, sc->reclaim_idx);
2712 2713
}

Linus Torvalds's avatar
Linus Torvalds committed
2714 2715 2716 2717 2718 2719 2720 2721
/*
 * 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.
 */
2722
static void shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
Linus Torvalds's avatar
Linus Torvalds committed
2723
{
2724
	struct zoneref *z;
2725
	struct zone *zone;
2726 2727
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
2728
	gfp_t orig_mask;
2729
	pg_data_t *last_pgdat = NULL;
2730

2731 2732 2733 2734 2735
	/*
	 * 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
	 */
2736
	orig_mask = sc->gfp_mask;
2737
	if (buffer_heads_over_limit) {
2738
		sc->gfp_mask |= __GFP_HIGHMEM;
2739
		sc->reclaim_idx = gfp_zone(sc->gfp_mask);
2740
	}
2741

2742
	for_each_zone_zonelist_nodemask(zone, z, zonelist,
2743
					sc->reclaim_idx, sc->nodemask) {
2744 2745 2746 2747
		/*
		 * Take care memory controller reclaiming has small influence
		 * to global LRU.
		 */
2748
		if (global_reclaim(sc)) {
2749 2750
			if (!cpuset_zone_allowed(zone,
						 GFP_KERNEL | __GFP_HARDWALL))
2751
				continue;
2752

2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763
			/*
			 * 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 &&
2764
			    compaction_ready(zone, sc)) {
2765 2766
				sc->compaction_ready = true;
				continue;
2767
			}
2768

2769 2770 2771 2772 2773 2774 2775 2776 2777
			/*
			 * 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;

2778 2779 2780 2781 2782 2783 2784
			/*
			 * 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;
2785
			nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone->zone_pgdat,
2786 2787 2788 2789
						sc->order, sc->gfp_mask,
						&nr_soft_scanned);
			sc->nr_reclaimed += nr_soft_reclaimed;
			sc->nr_scanned += nr_soft_scanned;
2790
			/* need some check for avoid more shrink_zone() */
2791
		}
2792

2793 2794 2795 2796
		/* See comment about same check for global reclaim above */
		if (zone->zone_pgdat == last_pgdat)
			continue;
		last_pgdat = zone->zone_pgdat;
2797
		shrink_node(zone->zone_pgdat, sc);
Linus Torvalds's avatar
Linus Torvalds committed
2798
	}
2799

2800 2801 2802 2803 2804
	/*
	 * Restore to original mask to avoid the impact on the caller if we
	 * promoted it to __GFP_HIGHMEM.
	 */
	sc->gfp_mask = orig_mask;
Linus Torvalds's avatar
Linus Torvalds committed
2805
}
2806

2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
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)
2817
			refaults = memcg_page_state(memcg, WORKINGSET_ACTIVATE);
2818 2819 2820 2821 2822 2823 2824 2825
		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)));
}

Linus Torvalds's avatar
Linus Torvalds committed
2826 2827 2828 2829 2830 2831 2832 2833
/*
 * 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
2834 2835 2836 2837
 * 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.
2838 2839 2840
 *
 * returns:	0, if no pages reclaimed
 * 		else, the number of pages reclaimed
Linus Torvalds's avatar
Linus Torvalds committed
2841
 */
2842
static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
2843
					  struct scan_control *sc)
Linus Torvalds's avatar
Linus Torvalds committed
2844
{
2845
	int initial_priority = sc->priority;
2846 2847 2848
	pg_data_t *last_pgdat;
	struct zoneref *z;
	struct zone *zone;
2849
retry:
2850 2851
	delayacct_freepages_start();

2852
	if (global_reclaim(sc))
2853
		__count_zid_vm_events(ALLOCSTALL, sc->reclaim_idx, 1);
Linus Torvalds's avatar
Linus Torvalds committed
2854

2855
	do {
2856 2857
		vmpressure_prio(sc->gfp_mask, sc->target_mem_cgroup,
				sc->priority);
2858
		sc->nr_scanned = 0;
2859
		shrink_zones(zonelist, sc);
2860

2861
		if (sc->nr_reclaimed >= sc->nr_to_reclaim)
2862 2863 2864 2865
			break;

		if (sc->compaction_ready)
			break;
Linus Torvalds's avatar
Linus Torvalds committed
2866

2867 2868 2869 2870 2871 2872
		/*
		 * If we're getting trouble reclaiming, start doing
		 * writepage even in laptop mode.
		 */
		if (sc->priority < DEF_PRIORITY - 2)
			sc->may_writepage = 1;
2873
	} while (--sc->priority >= 0);
2874

2875 2876 2877 2878 2879 2880 2881 2882 2883
	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);
	}

2884 2885
	delayacct_freepages_end();

2886 2887 2888
	if (sc->nr_reclaimed)
		return sc->nr_reclaimed;

2889
	/* Aborted reclaim to try compaction? don't OOM, then */
2890
	if (sc->compaction_ready)
2891 2892
		return 1;

2893
	/* Untapped cgroup reserves?  Don't OOM, retry. */
2894
	if (sc->memcg_low_skipped) {
2895
		sc->priority = initial_priority;
2896 2897
		sc->memcg_low_reclaim = 1;
		sc->memcg_low_skipped = 0;
2898 2899 2900
		goto retry;
	}

2901
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
2902 2903
}

2904
static bool allow_direct_reclaim(pg_data_t *pgdat)
2905 2906 2907 2908 2909 2910 2911
{
	struct zone *zone;
	unsigned long pfmemalloc_reserve = 0;
	unsigned long free_pages = 0;
	int i;
	bool wmark_ok;

2912 2913 2914
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

2915 2916
	for (i = 0; i <= ZONE_NORMAL; i++) {
		zone = &pgdat->node_zones[i];
2917 2918 2919 2920
		if (!managed_zone(zone))
			continue;

		if (!zone_reclaimable_pages(zone))
2921 2922
			continue;

2923 2924 2925 2926
		pfmemalloc_reserve += min_wmark_pages(zone);
		free_pages += zone_page_state(zone, NR_FREE_PAGES);
	}

2927 2928 2929 2930
	/* If there are no reserves (unexpected config) then do not throttle */
	if (!pfmemalloc_reserve)
		return true;

2931 2932 2933 2934
	wmark_ok = free_pages > pfmemalloc_reserve / 2;

	/* kswapd must be awake if processes are being throttled */
	if (!wmark_ok && waitqueue_active(&pgdat->kswapd_wait)) {
2935
		pgdat->kswapd_classzone_idx = min(pgdat->kswapd_classzone_idx,
2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
						(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
2947 2948 2949 2950
 * 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.
2951
 */
2952
static bool throttle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
2953 2954
					nodemask_t *nodemask)
{
2955
	struct zoneref *z;
2956
	struct zone *zone;
2957
	pg_data_t *pgdat = NULL;
2958 2959 2960 2961 2962 2963 2964 2965 2966

	/*
	 * 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)
2967 2968 2969 2970 2971 2972 2973 2974
		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;
2975

2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
	/*
	 * 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,
2991
					gfp_zone(gfp_mask), nodemask) {
2992 2993 2994 2995 2996
		if (zone_idx(zone) > ZONE_NORMAL)
			continue;

		/* Throttle based on the first usable node */
		pgdat = zone->zone_pgdat;
2997
		if (allow_direct_reclaim(pgdat))
2998 2999 3000 3001 3002 3003
			goto out;
		break;
	}

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

3006 3007 3008
	/* Account for the throttling */
	count_vm_event(PGSCAN_DIRECT_THROTTLE);

3009 3010 3011 3012 3013 3014 3015 3016 3017 3018
	/*
	 * 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,
3019
			allow_direct_reclaim(pgdat), HZ);
3020 3021

		goto check_pending;
3022 3023 3024 3025
	}

	/* Throttle until kswapd wakes the process */
	wait_event_killable(zone->zone_pgdat->pfmemalloc_wait,
3026
		allow_direct_reclaim(pgdat));
3027 3028 3029 3030 3031 3032 3033

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

out:
	return false;
3034 3035
}

3036
unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
3037
				gfp_t gfp_mask, nodemask_t *nodemask)
3038
{
3039
	unsigned long nr_reclaimed;
3040
	struct scan_control sc = {
3041
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
3042
		.gfp_mask = current_gfp_context(gfp_mask),
3043
		.reclaim_idx = gfp_zone(gfp_mask),
3044 3045 3046
		.order = order,
		.nodemask = nodemask,
		.priority = DEF_PRIORITY,
3047
		.may_writepage = !laptop_mode,
3048
		.may_unmap = 1,
3049
		.may_swap = 1,
3050 3051
	};

3052
	/*
3053 3054 3055
	 * 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.
3056
	 */
3057
	if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
3058 3059
		return 1;

3060 3061
	trace_mm_vmscan_direct_reclaim_begin(order,
				sc.may_writepage,
3062
				sc.gfp_mask,
3063
				sc.reclaim_idx);
3064

3065
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3066 3067 3068 3069

	trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3070 3071
}

3072
#ifdef CONFIG_MEMCG
3073

3074
unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
3075
						gfp_t gfp_mask, bool noswap,
3076
						pg_data_t *pgdat,
3077
						unsigned long *nr_scanned)
3078 3079
{
	struct scan_control sc = {
3080
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
3081
		.target_mem_cgroup = memcg,
3082 3083
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3084
		.reclaim_idx = MAX_NR_ZONES - 1,
3085 3086
		.may_swap = !noswap,
	};
3087
	unsigned long lru_pages;
3088

3089 3090
	sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
			(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
3091

3092
	trace_mm_vmscan_memcg_softlimit_reclaim_begin(sc.order,
3093
						      sc.may_writepage,
3094 3095
						      sc.gfp_mask,
						      sc.reclaim_idx);
3096

3097 3098 3099
	/*
	 * NOTE: Although we can get the priority field, using it
	 * here is not a good idea, since it limits the pages we can scan.
3100
	 * if we don't reclaim here, the shrink_node from balance_pgdat
3101 3102 3103
	 * will pick up pages from other mem cgroup's as well. We hack
	 * the priority and make it zero.
	 */
3104
	shrink_node_memcg(pgdat, memcg, &sc, &lru_pages);
3105 3106 3107

	trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);

3108
	*nr_scanned = sc.nr_scanned;
3109 3110 3111
	return sc.nr_reclaimed;
}

3112
unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
3113
					   unsigned long nr_pages,
KOSAKI Motohiro's avatar
KOSAKI Motohiro committed
3114
					   gfp_t gfp_mask,
3115
					   bool may_swap)
3116
{
3117
	struct zonelist *zonelist;
3118
	unsigned long nr_reclaimed;
3119
	int nid;
3120
	unsigned int noreclaim_flag;
3121
	struct scan_control sc = {
3122
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3123
		.gfp_mask = (current_gfp_context(gfp_mask) & GFP_RECLAIM_MASK) |
3124
				(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
3125
		.reclaim_idx = MAX_NR_ZONES - 1,
3126 3127 3128 3129
		.target_mem_cgroup = memcg,
		.priority = DEF_PRIORITY,
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3130
		.may_swap = may_swap,
3131
	};
3132

3133 3134 3135 3136 3137
	/*
	 * 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.
	 */
3138
	nid = mem_cgroup_select_victim_node(memcg);
3139

3140
	zonelist = &NODE_DATA(nid)->node_zonelists[ZONELIST_FALLBACK];
3141 3142 3143

	trace_mm_vmscan_memcg_reclaim_begin(0,
					    sc.may_writepage,
3144 3145
					    sc.gfp_mask,
					    sc.reclaim_idx);
3146

3147
	noreclaim_flag = memalloc_noreclaim_save();
3148
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3149
	memalloc_noreclaim_restore(noreclaim_flag);
3150 3151 3152 3153

	trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3154 3155 3156
}
#endif

3157
static void age_active_anon(struct pglist_data *pgdat,
3158
				struct scan_control *sc)
3159
{
3160
	struct mem_cgroup *memcg;
3161

3162 3163 3164 3165 3166
	if (!total_swap_pages)
		return;

	memcg = mem_cgroup_iter(NULL, NULL, NULL);
	do {
3167
		struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
3168

3169
		if (inactive_list_is_low(lruvec, false, memcg, sc, true))
3170
			shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
3171
					   sc, LRU_ACTIVE_ANON);
3172 3173 3174

		memcg = mem_cgroup_iter(NULL, memcg, NULL);
	} while (memcg);
3175 3176
}

3177 3178 3179 3180 3181
/*
 * 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)
3182
{
3183 3184 3185
	int i;
	unsigned long mark = -1;
	struct zone *zone;
3186

3187 3188
	for (i = 0; i <= classzone_idx; i++) {
		zone = pgdat->node_zones + i;
3189

3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206
		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;
3207 3208
}

3209 3210 3211 3212 3213 3214 3215 3216
/* 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);
}

3217 3218 3219 3220 3221 3222
/*
 * 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
 */
3223
static bool prepare_kswapd_sleep(pg_data_t *pgdat, int order, int classzone_idx)
3224
{
3225
	/*
3226
	 * The throttled processes are normally woken up in balance_pgdat() as
3227
	 * soon as allow_direct_reclaim() is true. But there is a potential
3228 3229 3230 3231 3232 3233 3234 3235 3236
	 * 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().
3237
	 */
3238 3239
	if (waitqueue_active(&pgdat->pfmemalloc_wait))
		wake_up_all(&pgdat->pfmemalloc_wait);
3240

3241 3242 3243 3244
	/* Hopeless node, leave it to direct reclaim */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

3245 3246 3247
	if (pgdat_balanced(pgdat, order, classzone_idx)) {
		clear_pgdat_congested(pgdat);
		return true;
3248 3249
	}

3250
	return false;
3251 3252
}

3253
/*
3254 3255
 * kswapd shrinks a node of pages that are at or below the highest usable
 * zone that is currently unbalanced.
3256 3257
 *
 * Returns true if kswapd scanned at least the requested number of pages to
3258 3259
 * 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.
3260
 */
3261
static bool kswapd_shrink_node(pg_data_t *pgdat,
3262
			       struct scan_control *sc)
3263
{
3264 3265
	struct zone *zone;
	int z;
3266

3267 3268
	/* Reclaim a number of pages proportional to the number of zones */
	sc->nr_to_reclaim = 0;
3269
	for (z = 0; z <= sc->reclaim_idx; z++) {
3270
		zone = pgdat->node_zones + z;
3271
		if (!managed_zone(zone))
3272
			continue;
3273

3274 3275
		sc->nr_to_reclaim += max(high_wmark_pages(zone), SWAP_CLUSTER_MAX);
	}
3276 3277

	/*
3278 3279
	 * Historically care was taken to put equal pressure on all zones but
	 * now pressure is applied based on node LRU order.
3280
	 */
3281
	shrink_node(pgdat, sc);
3282

3283
	/*
3284 3285 3286 3287 3288
	 * 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.
3289
	 */
3290
	if (sc->order && sc->nr_reclaimed >= compact_gap(sc->order))
3291
		sc->order = 0;
3292

3293
	return sc->nr_scanned >= sc->nr_to_reclaim;
3294 3295
}

Linus Torvalds's avatar
Linus Torvalds committed
3296
/*
3297 3298 3299
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
3300
 *
3301
 * Returns the order kswapd finished reclaiming at.
Linus Torvalds's avatar
Linus Torvalds committed
3302 3303
 *
 * kswapd scans the zones in the highmem->normal->dma direction.  It skips
3304
 * zones which have free_pages > high_wmark_pages(zone), but once a zone is
3305 3306 3307
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
3308
 */
3309
static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
Linus Torvalds's avatar
Linus Torvalds committed
3310 3311
{
	int i;
3312 3313
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
3314
	struct zone *zone;
3315 3316
	struct scan_control sc = {
		.gfp_mask = GFP_KERNEL,
3317
		.order = order,
3318
		.priority = DEF_PRIORITY,
3319
		.may_writepage = !laptop_mode,
3320
		.may_unmap = 1,
3321
		.may_swap = 1,
3322
	};
3323
	count_vm_event(PAGEOUTRUN);
Linus Torvalds's avatar
Linus Torvalds committed
3324

3325
	do {
3326
		unsigned long nr_reclaimed = sc.nr_reclaimed;
3327 3328
		bool raise_priority = true;

3329
		sc.reclaim_idx = classzone_idx;
Linus Torvalds's avatar
Linus Torvalds committed
3330

3331
		/*
3332 3333 3334 3335 3336 3337 3338 3339
		 * 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.
3340 3341 3342 3343
		 */
		if (buffer_heads_over_limit) {
			for (i = MAX_NR_ZONES - 1; i >= 0; i--) {
				zone = pgdat->node_zones + i;
3344
				if (!managed_zone(zone))
3345
					continue;
3346

3347
				sc.reclaim_idx = i;
3348
				break;
Linus Torvalds's avatar
Linus Torvalds committed
3349 3350
			}
		}
3351

3352
		/*
3353 3354 3355
		 * 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.
3356
		 */
3357 3358
		if (pgdat_balanced(pgdat, sc.order, classzone_idx))
			goto out;
3359

3360 3361 3362 3363 3364 3365
		/*
		 * 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.
		 */
3366
		age_active_anon(pgdat, &sc);
3367

3368 3369 3370 3371
		/*
		 * If we're getting trouble reclaiming, start doing writepage
		 * even in laptop mode.
		 */
3372
		if (sc.priority < DEF_PRIORITY - 2)
3373 3374
			sc.may_writepage = 1;

3375 3376 3377
		/* Call soft limit reclaim before calling shrink_node. */
		sc.nr_scanned = 0;
		nr_soft_scanned = 0;
3378
		nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(pgdat, sc.order,
3379 3380 3381
						sc.gfp_mask, &nr_soft_scanned);
		sc.nr_reclaimed += nr_soft_reclaimed;

Linus Torvalds's avatar
Linus Torvalds committed
3382
		/*
3383 3384 3385
		 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
3386
		 */
3387
		if (kswapd_shrink_node(pgdat, &sc))
3388
			raise_priority = false;
3389 3390 3391 3392 3393 3394 3395

		/*
		 * 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) &&
3396
				allow_direct_reclaim(pgdat))
3397
			wake_up_all(&pgdat->pfmemalloc_wait);
3398

3399 3400 3401
		/* Check if kswapd should be suspending */
		if (try_to_freeze() || kthread_should_stop())
			break;
3402

3403
		/*
3404 3405
		 * Raise priority if scanning rate is too low or there was no
		 * progress in reclaiming pages
3406
		 */
3407 3408
		nr_reclaimed = sc.nr_reclaimed - nr_reclaimed;
		if (raise_priority || !nr_reclaimed)
3409
			sc.priority--;
3410
	} while (sc.priority >= 1);
Linus Torvalds's avatar
Linus Torvalds committed
3411

3412 3413 3414
	if (!sc.nr_reclaimed)
		pgdat->kswapd_failures++;

3415
out:
3416
	snapshot_refaults(NULL, pgdat);
3417
	/*
3418 3419 3420 3421
	 * 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.
3422
	 */
3423
	return sc.order;
Linus Torvalds's avatar
Linus Torvalds committed
3424 3425
}

3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441
/*
 * 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);
}

3442 3443
static void kswapd_try_to_sleep(pg_data_t *pgdat, int alloc_order, int reclaim_order,
				unsigned int classzone_idx)
3444 3445 3446 3447 3448 3449 3450 3451 3452
{
	long remaining = 0;
	DEFINE_WAIT(wait);

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

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

3453 3454 3455 3456 3457 3458 3459
	/*
	 * 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.
	 */
3460
	if (prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472
		/*
		 * 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.
		 */
3473
		wakeup_kcompactd(pgdat, alloc_order, classzone_idx);
3474

3475
		remaining = schedule_timeout(HZ/10);
3476 3477 3478 3479 3480 3481 3482

		/*
		 * 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) {
3483
			pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);
3484 3485 3486
			pgdat->kswapd_order = max(pgdat->kswapd_order, reclaim_order);
		}

3487 3488 3489 3490 3491 3492 3493 3494
		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.
	 */
3495 3496
	if (!remaining &&
	    prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507
		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);
3508 3509 3510 3511

		if (!kthread_should_stop())
			schedule();

3512 3513 3514 3515 3516 3517 3518 3519 3520 3521
		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);
}

Linus Torvalds's avatar
Linus Torvalds committed
3522 3523
/*
 * The background pageout daemon, started as a kernel thread
3524
 * from the init process.
Linus Torvalds's avatar
Linus Torvalds committed
3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
 *
 * 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)
{
3537 3538
	unsigned int alloc_order, reclaim_order;
	unsigned int classzone_idx = MAX_NR_ZONES - 1;
Linus Torvalds's avatar
Linus Torvalds committed
3539 3540
	pg_data_t *pgdat = (pg_data_t*)p;
	struct task_struct *tsk = current;
3541

Linus Torvalds's avatar
Linus Torvalds committed
3542 3543 3544
	struct reclaim_state reclaim_state = {
		.reclaimed_slab = 0,
	};
3545
	const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
Linus Torvalds's avatar
Linus Torvalds committed
3546

Rusty Russell's avatar
Rusty Russell committed
3547
	if (!cpumask_empty(cpumask))
3548
		set_cpus_allowed_ptr(tsk, cpumask);
Linus Torvalds's avatar
Linus Torvalds committed
3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562
	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).
	 */
3563
	tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
3564
	set_freezable();
Linus Torvalds's avatar
Linus Torvalds committed
3565

3566 3567
	pgdat->kswapd_order = 0;
	pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
Linus Torvalds's avatar
Linus Torvalds committed
3568
	for ( ; ; ) {
3569
		bool ret;
3570

3571 3572 3573
		alloc_order = reclaim_order = pgdat->kswapd_order;
		classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);

3574 3575 3576
kswapd_try_sleep:
		kswapd_try_to_sleep(pgdat, alloc_order, reclaim_order,
					classzone_idx);
3577

3578 3579
		/* Read the new order and classzone_idx */
		alloc_order = reclaim_order = pgdat->kswapd_order;
3580
		classzone_idx = kswapd_classzone_idx(pgdat, 0);
3581
		pgdat->kswapd_order = 0;
3582
		pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
Linus Torvalds's avatar
Linus Torvalds committed
3583

3584 3585 3586 3587 3588 3589 3590 3591
		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
		 */
3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602
		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).
		 */
3603 3604
		trace_mm_vmscan_kswapd_wake(pgdat->node_id, classzone_idx,
						alloc_order);
3605
		fs_reclaim_acquire(GFP_KERNEL);
3606
		reclaim_order = balance_pgdat(pgdat, alloc_order, classzone_idx);
3607
		fs_reclaim_release(GFP_KERNEL);
3608 3609
		if (reclaim_order < alloc_order)
			goto kswapd_try_sleep;
Linus Torvalds's avatar
Linus Torvalds committed
3610
	}
3611

3612
	tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
3613
	current->reclaim_state = NULL;
3614

Linus Torvalds's avatar
Linus Torvalds committed
3615 3616 3617 3618 3619 3620
	return 0;
}

/*
 * A zone is low on free memory, so wake its kswapd task to service it.
 */
3621
void wakeup_kswapd(struct zone *zone, int order, enum zone_type classzone_idx)
Linus Torvalds's avatar
Linus Torvalds committed
3622 3623 3624
{
	pg_data_t *pgdat;

3625
	if (!managed_zone(zone))
Linus Torvalds's avatar
Linus Torvalds committed
3626 3627
		return;

3628
	if (!cpuset_zone_allowed(zone, GFP_KERNEL | __GFP_HARDWALL))
Linus Torvalds's avatar
Linus Torvalds committed
3629
		return;
3630
	pgdat = zone->zone_pgdat;
3631 3632
	pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat,
							   classzone_idx);
3633
	pgdat->kswapd_order = max(pgdat->kswapd_order, order);
3634
	if (!waitqueue_active(&pgdat->kswapd_wait))
Linus Torvalds's avatar
Linus Torvalds committed
3635
		return;
3636

3637 3638 3639 3640
	/* Hopeless node, leave it to direct reclaim */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return;

3641 3642
	if (pgdat_balanced(pgdat, order, classzone_idx))
		return;
3643

3644
	trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, classzone_idx, order);
3645
	wake_up_interruptible(&pgdat->kswapd_wait);
Linus Torvalds's avatar
Linus Torvalds committed
3646 3647
}

3648
#ifdef CONFIG_HIBERNATION
Linus Torvalds's avatar
Linus Torvalds committed
3649
/*
3650
 * Try to free `nr_to_reclaim' of memory, system-wide, and return the number of
3651 3652 3653 3654 3655
 * 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
Linus Torvalds's avatar
Linus Torvalds committed
3656
 */
3657
unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
Linus Torvalds's avatar
Linus Torvalds committed
3658
{
3659 3660
	struct reclaim_state reclaim_state;
	struct scan_control sc = {
3661
		.nr_to_reclaim = nr_to_reclaim,
3662
		.gfp_mask = GFP_HIGHUSER_MOVABLE,
3663
		.reclaim_idx = MAX_NR_ZONES - 1,
3664
		.priority = DEF_PRIORITY,
3665
		.may_writepage = 1,
3666 3667
		.may_unmap = 1,
		.may_swap = 1,
3668
		.hibernation_mode = 1,
Linus Torvalds's avatar
Linus Torvalds committed
3669
	};
3670
	struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
3671 3672
	struct task_struct *p = current;
	unsigned long nr_reclaimed;
3673
	unsigned int noreclaim_flag;
Linus Torvalds's avatar
Linus Torvalds committed
3674

3675
	noreclaim_flag = memalloc_noreclaim_save();
3676
	fs_reclaim_acquire(sc.gfp_mask);
3677 3678
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
3679

3680
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3681

3682
	p->reclaim_state = NULL;
3683
	fs_reclaim_release(sc.gfp_mask);
3684
	memalloc_noreclaim_restore(noreclaim_flag);
3685

3686
	return nr_reclaimed;
Linus Torvalds's avatar
Linus Torvalds committed
3687
}
3688
#endif /* CONFIG_HIBERNATION */
Linus Torvalds's avatar
Linus Torvalds committed
3689 3690 3691 3692 3693

/* 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. */
3694
static int kswapd_cpu_online(unsigned int cpu)
Linus Torvalds's avatar
Linus Torvalds committed
3695
{
3696
	int nid;
Linus Torvalds's avatar
Linus Torvalds committed
3697

3698 3699 3700
	for_each_node_state(nid, N_MEMORY) {
		pg_data_t *pgdat = NODE_DATA(nid);
		const struct cpumask *mask;
3701

3702
		mask = cpumask_of_node(pgdat->node_id);
3703

3704 3705 3706
		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);
Linus Torvalds's avatar
Linus Torvalds committed
3707
	}
3708
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3709 3710
}

3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725
/*
 * 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 */
3726
		BUG_ON(system_state < SYSTEM_RUNNING);
3727 3728
		pr_err("Failed to start kswapd on node %d\n", nid);
		ret = PTR_ERR(pgdat->kswapd);
3729
		pgdat->kswapd = NULL;
3730 3731 3732 3733
	}
	return ret;
}

3734
/*
3735
 * Called by memory hotplug when all memory in a node is offlined.  Caller must
3736
 * hold mem_hotplug_begin/end().
3737 3738 3739 3740 3741
 */
void kswapd_stop(int nid)
{
	struct task_struct *kswapd = NODE_DATA(nid)->kswapd;

3742
	if (kswapd) {
3743
		kthread_stop(kswapd);
3744 3745
		NODE_DATA(nid)->kswapd = NULL;
	}
3746 3747
}

Linus Torvalds's avatar
Linus Torvalds committed
3748 3749
static int __init kswapd_init(void)
{
3750
	int nid, ret;
3751

Linus Torvalds's avatar
Linus Torvalds committed
3752
	swap_setup();
3753
	for_each_node_state(nid, N_MEMORY)
3754
 		kswapd_run(nid);
3755 3756 3757 3758
	ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
					"mm/vmscan:online", kswapd_cpu_online,
					NULL);
	WARN_ON(ret < 0);
Linus Torvalds's avatar
Linus Torvalds committed
3759 3760 3761 3762
	return 0;
}

module_init(kswapd_init)
3763 3764 3765

#ifdef CONFIG_NUMA
/*
3766
 * Node reclaim mode
3767
 *
3768
 * If non-zero call node_reclaim when the number of free pages falls below
3769 3770
 * the watermarks.
 */
3771
int node_reclaim_mode __read_mostly;
3772

3773
#define RECLAIM_OFF 0
3774
#define RECLAIM_ZONE (1<<0)	/* Run shrink_inactive_list on the zone */
3775
#define RECLAIM_WRITE (1<<1)	/* Writeout pages during reclaim */
3776
#define RECLAIM_UNMAP (1<<2)	/* Unmap pages during reclaim */
3777

3778
/*
3779
 * Priority for NODE_RECLAIM. This determines the fraction of pages
3780 3781 3782
 * of a node considered for each zone_reclaim. 4 scans 1/16th of
 * a zone.
 */
3783
#define NODE_RECLAIM_PRIORITY 4
3784

3785
/*
3786
 * Percentage of pages in a zone that must be unmapped for node_reclaim to
3787 3788 3789 3790
 * occur.
 */
int sysctl_min_unmapped_ratio = 1;

3791 3792 3793 3794 3795 3796
/*
 * 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;

3797
static inline unsigned long node_unmapped_file_pages(struct pglist_data *pgdat)
3798
{
3799 3800 3801
	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);
3802 3803 3804 3805 3806 3807 3808 3809 3810 3811

	/*
	 * 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 */
3812
static unsigned long node_pagecache_reclaimable(struct pglist_data *pgdat)
3813
{
3814 3815
	unsigned long nr_pagecache_reclaimable;
	unsigned long delta = 0;
3816 3817

	/*
3818
	 * If RECLAIM_UNMAP is set, then all file pages are considered
3819
	 * potentially reclaimable. Otherwise, we have to worry about
3820
	 * pages like swapcache and node_unmapped_file_pages() provides
3821 3822
	 * a better estimate
	 */
3823 3824
	if (node_reclaim_mode & RECLAIM_UNMAP)
		nr_pagecache_reclaimable = node_page_state(pgdat, NR_FILE_PAGES);
3825
	else
3826
		nr_pagecache_reclaimable = node_unmapped_file_pages(pgdat);
3827 3828

	/* If we can't clean pages, remove dirty pages from consideration */
3829 3830
	if (!(node_reclaim_mode & RECLAIM_WRITE))
		delta += node_page_state(pgdat, NR_FILE_DIRTY);
3831 3832 3833 3834 3835 3836 3837 3838

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

	return nr_pagecache_reclaimable - delta;
}

3839
/*
3840
 * Try to free up some pages from this node through reclaim.
3841
 */
3842
static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
3843
{
3844
	/* Minimum pages needed in order to stay on node */
3845
	const unsigned long nr_pages = 1 << order;
3846 3847
	struct task_struct *p = current;
	struct reclaim_state reclaim_state;
3848
	unsigned int noreclaim_flag;
3849
	struct scan_control sc = {
3850
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3851
		.gfp_mask = current_gfp_context(gfp_mask),
3852
		.order = order,
3853 3854 3855
		.priority = NODE_RECLAIM_PRIORITY,
		.may_writepage = !!(node_reclaim_mode & RECLAIM_WRITE),
		.may_unmap = !!(node_reclaim_mode & RECLAIM_UNMAP),
3856
		.may_swap = 1,
3857
		.reclaim_idx = gfp_zone(gfp_mask),
3858
	};
3859 3860

	cond_resched();
3861
	/*
3862
	 * We need to be able to allocate from the reserves for RECLAIM_UNMAP
3863
	 * and we also need to be able to write out pages for RECLAIM_WRITE
3864
	 * and RECLAIM_UNMAP.
3865
	 */
3866 3867
	noreclaim_flag = memalloc_noreclaim_save();
	p->flags |= PF_SWAPWRITE;
3868
	fs_reclaim_acquire(sc.gfp_mask);
3869 3870
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
3871

3872
	if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
3873 3874 3875 3876 3877
		/*
		 * Free memory by calling shrink zone with increasing
		 * priorities until we have enough memory freed.
		 */
		do {
3878
			shrink_node(pgdat, &sc);
3879
		} while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
3880
	}
3881

3882
	p->reclaim_state = NULL;
3883
	fs_reclaim_release(gfp_mask);
3884 3885
	current->flags &= ~PF_SWAPWRITE;
	memalloc_noreclaim_restore(noreclaim_flag);
3886
	return sc.nr_reclaimed >= nr_pages;
3887
}
3888

3889
int node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
3890
{
3891
	int ret;
3892 3893

	/*
3894
	 * Node reclaim reclaims unmapped file backed pages and
3895
	 * slab pages if we are over the defined limits.
3896
	 *
3897 3898
	 * A small portion of unmapped file backed pages is needed for
	 * file I/O otherwise pages read by file I/O will be immediately
3899 3900
	 * thrown out if the node is overallocated. So we do not reclaim
	 * if less than a specified percentage of the node is used by
3901
	 * unmapped file backed pages.
3902
	 */
3903
	if (node_pagecache_reclaimable(pgdat) <= pgdat->min_unmapped_pages &&
3904
	    node_page_state(pgdat, NR_SLAB_RECLAIMABLE) <= pgdat->min_slab_pages)
3905
		return NODE_RECLAIM_FULL;
3906 3907

	/*
3908
	 * Do not scan if the allocation should not be delayed.
3909
	 */
3910
	if (!gfpflags_allow_blocking(gfp_mask) || (current->flags & PF_MEMALLOC))
3911
		return NODE_RECLAIM_NOSCAN;
3912 3913

	/*
3914
	 * Only run node reclaim on the local node or on nodes that do not
3915 3916 3917 3918
	 * have associated processors. This will favor the local processor
	 * over remote processors and spread off node memory allocations
	 * as wide as possible.
	 */
3919 3920
	if (node_state(pgdat->node_id, N_CPU) && pgdat->node_id != numa_node_id())
		return NODE_RECLAIM_NOSCAN;
3921

3922 3923
	if (test_and_set_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags))
		return NODE_RECLAIM_NOSCAN;
3924

3925 3926
	ret = __node_reclaim(pgdat, gfp_mask, order);
	clear_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags);
3927

3928 3929 3930
	if (!ret)
		count_vm_event(PGSCAN_ZONE_RECLAIM_FAILED);

3931
	return ret;
3932
}
3933
#endif
3934 3935 3936 3937 3938 3939

/*
 * 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
3940
 * lists vs unevictable list.
3941 3942
 *
 * Reasons page might not be evictable:
3943
 * (1) page's mapping marked unevictable
3944
 * (2) page is part of an mlocked VMA
3945
 *
3946
 */
3947
int page_evictable(struct page *page)
3948
{
3949
	return !mapping_unevictable(page_mapping(page)) && !PageMlocked(page);
3950
}
3951

3952
#ifdef CONFIG_SHMEM
3953
/**
3954 3955 3956
 * 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
3957
 *
3958
 * Checks pages for evictability and moves them to the appropriate lru list.
3959 3960
 *
 * This function is only used for SysV IPC SHM_UNLOCK.
3961
 */
3962
void check_move_unevictable_pages(struct page **pages, int nr_pages)
3963
{
3964
	struct lruvec *lruvec;
3965
	struct pglist_data *pgdat = NULL;
3966 3967 3968
	int pgscanned = 0;
	int pgrescued = 0;
	int i;
3969

3970 3971
	for (i = 0; i < nr_pages; i++) {
		struct page *page = pages[i];
3972
		struct pglist_data *pagepgdat = page_pgdat(page);
3973

3974
		pgscanned++;
3975 3976 3977 3978 3979
		if (pagepgdat != pgdat) {
			if (pgdat)
				spin_unlock_irq(&pgdat->lru_lock);
			pgdat = pagepgdat;
			spin_lock_irq(&pgdat->lru_lock);
3980
		}
3981
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
3982

3983 3984
		if (!PageLRU(page) || !PageUnevictable(page))
			continue;
3985

3986
		if (page_evictable(page)) {
3987 3988
			enum lru_list lru = page_lru_base_type(page);

3989
			VM_BUG_ON_PAGE(PageActive(page), page);
3990
			ClearPageUnevictable(page);
3991 3992
			del_page_from_lru_list(page, lruvec, LRU_UNEVICTABLE);
			add_page_to_lru_list(page, lruvec, lru);
3993
			pgrescued++;
3994
		}
3995
	}
3996

3997
	if (pgdat) {
3998 3999
		__count_vm_events(UNEVICTABLE_PGRESCUED, pgrescued);
		__count_vm_events(UNEVICTABLE_PGSCANNED, pgscanned);
4000
		spin_unlock_irq(&pgdat->lru_lock);
4001 4002
	}
}
4003
#endif /* CONFIG_SHMEM */