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

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

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

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

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

59 60
#include "internal.h"

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

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

68 69 70 71 72
	/*
	 * Nodemask of nodes allowed by the caller. If NULL, all nodes
	 * are scanned.
	 */
	nodemask_t	*nodemask;
73

74 75 76 77 78
	/*
	 * 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;
79

80
	/* Writepage batching in laptop mode; RECLAIM_WRITE */
81 82 83 84 85 86 87 88
	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;

89 90 91 92 93 94 95
	/*
	 * 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;
96

97 98 99 100 101
	unsigned int hibernation_mode:1;

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

G
Greg Thelen 已提交
102 103 104 105 106 107 108 109 110 111 112 113
	/* Allocation order */
	s8 order;

	/* Scan (total_size >> priority) pages at once */
	s8 priority;

	/* The highest zone to isolate pages for reclaim from */
	s8 reclaim_idx;

	/* This context's GFP mask */
	gfp_t gfp_mask;

114 115 116 117 118
	/* Incremented by the number of inactive pages that were scanned */
	unsigned long nr_scanned;

	/* Number of pages freed so far during a call to shrink_zones() */
	unsigned long nr_reclaimed;
119 120 121 122 123 124 125 126 127 128

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

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

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

/*
 * From 0 .. 100.  Higher means more swappy.
 */
int vm_swappiness = 60;
163 164 165 166 167
/*
 * The total number of pages which are beyond the high watermark within all
 * zones.
 */
unsigned long vm_total_pages;
L
Linus Torvalds 已提交
168 169 170 171

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

172
#ifdef CONFIG_MEMCG_KMEM
173 174 175 176 177 178 179 180 181 182 183 184 185 186

/*
 * We allow subsystems to populate their shrinker-related
 * LRU lists before register_shrinker_prepared() is called
 * for the shrinker, since we don't want to impose
 * restrictions on their internal registration order.
 * In this case shrink_slab_memcg() may find corresponding
 * bit is set in the shrinkers map.
 *
 * This value is used by the function to detect registering
 * shrinkers and to skip do_shrink_slab() calls for them.
 */
#define SHRINKER_REGISTERING ((struct shrinker *)~0UL)

187 188 189 190 191 192 193 194 195
static DEFINE_IDR(shrinker_idr);
static int shrinker_nr_max;

static int prealloc_memcg_shrinker(struct shrinker *shrinker)
{
	int id, ret = -ENOMEM;

	down_write(&shrinker_rwsem);
	/* This may call shrinker, so it must use down_read_trylock() */
196
	id = idr_alloc(&shrinker_idr, SHRINKER_REGISTERING, 0, 0, GFP_KERNEL);
197 198 199
	if (id < 0)
		goto unlock;

200 201 202 203 204 205
	if (id >= shrinker_nr_max) {
		if (memcg_expand_shrinker_maps(id)) {
			idr_remove(&shrinker_idr, id);
			goto unlock;
		}

206
		shrinker_nr_max = id + 1;
207
	}
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
	shrinker->id = id;
	ret = 0;
unlock:
	up_write(&shrinker_rwsem);
	return ret;
}

static void unregister_memcg_shrinker(struct shrinker *shrinker)
{
	int id = shrinker->id;

	BUG_ON(id < 0);

	down_write(&shrinker_rwsem);
	idr_remove(&shrinker_idr, id);
	up_write(&shrinker_rwsem);
}
#else /* CONFIG_MEMCG_KMEM */
static int prealloc_memcg_shrinker(struct shrinker *shrinker)
{
	return 0;
}

static void unregister_memcg_shrinker(struct shrinker *shrinker)
{
}
#endif /* CONFIG_MEMCG_KMEM */

A
Andrew Morton 已提交
236
#ifdef CONFIG_MEMCG
237 238
static bool global_reclaim(struct scan_control *sc)
{
239
	return !sc->target_mem_cgroup;
240
}
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261

/**
 * 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
262
	if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
263 264 265 266
		return true;
#endif
	return false;
}
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289

static void set_memcg_congestion(pg_data_t *pgdat,
				struct mem_cgroup *memcg,
				bool congested)
{
	struct mem_cgroup_per_node *mn;

	if (!memcg)
		return;

	mn = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
	WRITE_ONCE(mn->congested, congested);
}

static bool memcg_congested(pg_data_t *pgdat,
			struct mem_cgroup *memcg)
{
	struct mem_cgroup_per_node *mn;

	mn = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
	return READ_ONCE(mn->congested);

}
290
#else
291 292 293 294
static bool global_reclaim(struct scan_control *sc)
{
	return true;
}
295 296 297 298 299

static bool sane_reclaim(struct scan_control *sc)
{
	return true;
}
300 301 302 303 304 305 306 307 308 309 310 311

static inline void set_memcg_congestion(struct pglist_data *pgdat,
				struct mem_cgroup *memcg, bool congested)
{
}

static inline bool memcg_congested(struct pglist_data *pgdat,
			struct mem_cgroup *memcg)
{
	return false;

}
312 313
#endif

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
/*
 * 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;
}

332 333 334 335 336 337 338
/**
 * 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)
339
{
340 341 342
	unsigned long lru_size;
	int zid;

343
	if (!mem_cgroup_disabled())
344 345 346
		lru_size = mem_cgroup_get_lru_size(lruvec, lru);
	else
		lru_size = node_page_state(lruvec_pgdat(lruvec), NR_LRU_BASE + lru);
347

348 349 350
	for (zid = zone_idx + 1; zid < MAX_NR_ZONES; zid++) {
		struct zone *zone = &lruvec_pgdat(lruvec)->node_zones[zid];
		unsigned long size;
351

352 353 354 355 356 357 358 359 360 361 362 363
		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;
364 365 366

}

L
Linus Torvalds 已提交
367
/*
G
Glauber Costa 已提交
368
 * Add a shrinker callback to be called from the vm.
L
Linus Torvalds 已提交
369
 */
370
int prealloc_shrinker(struct shrinker *shrinker)
L
Linus Torvalds 已提交
371
{
G
Glauber Costa 已提交
372 373 374 375 376 377 378 379
	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;
380 381 382 383 384 385

	if (shrinker->flags & SHRINKER_MEMCG_AWARE) {
		if (prealloc_memcg_shrinker(shrinker))
			goto free_deferred;
	}

386
	return 0;
387 388 389 390 391

free_deferred:
	kfree(shrinker->nr_deferred);
	shrinker->nr_deferred = NULL;
	return -ENOMEM;
392 393 394 395
}

void free_prealloced_shrinker(struct shrinker *shrinker)
{
396 397 398 399 400 401
	if (!shrinker->nr_deferred)
		return;

	if (shrinker->flags & SHRINKER_MEMCG_AWARE)
		unregister_memcg_shrinker(shrinker);

402 403 404
	kfree(shrinker->nr_deferred);
	shrinker->nr_deferred = NULL;
}
G
Glauber Costa 已提交
405

406 407
void register_shrinker_prepared(struct shrinker *shrinker)
{
408 409
	down_write(&shrinker_rwsem);
	list_add_tail(&shrinker->list, &shrinker_list);
410
#ifdef CONFIG_MEMCG_KMEM
411 412
	if (shrinker->flags & SHRINKER_MEMCG_AWARE)
		idr_replace(&shrinker_idr, shrinker, shrinker->id);
413
#endif
414
	up_write(&shrinker_rwsem);
415 416 417 418 419 420 421 422 423
}

int register_shrinker(struct shrinker *shrinker)
{
	int err = prealloc_shrinker(shrinker);

	if (err)
		return err;
	register_shrinker_prepared(shrinker);
G
Glauber Costa 已提交
424
	return 0;
L
Linus Torvalds 已提交
425
}
426
EXPORT_SYMBOL(register_shrinker);
L
Linus Torvalds 已提交
427 428 429 430

/*
 * Remove one
 */
431
void unregister_shrinker(struct shrinker *shrinker)
L
Linus Torvalds 已提交
432
{
433 434
	if (!shrinker->nr_deferred)
		return;
435 436
	if (shrinker->flags & SHRINKER_MEMCG_AWARE)
		unregister_memcg_shrinker(shrinker);
L
Linus Torvalds 已提交
437 438 439
	down_write(&shrinker_rwsem);
	list_del(&shrinker->list);
	up_write(&shrinker_rwsem);
440
	kfree(shrinker->nr_deferred);
441
	shrinker->nr_deferred = NULL;
L
Linus Torvalds 已提交
442
}
443
EXPORT_SYMBOL(unregister_shrinker);
L
Linus Torvalds 已提交
444 445

#define SHRINK_BATCH 128
G
Glauber Costa 已提交
446

447
static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
448
				    struct shrinker *shrinker, int priority)
G
Glauber Costa 已提交
449 450 451 452
{
	unsigned long freed = 0;
	unsigned long long delta;
	long total_scan;
453
	long freeable;
G
Glauber Costa 已提交
454 455 456 457 458
	long nr;
	long new_nr;
	int nid = shrinkctl->nid;
	long batch_size = shrinker->batch ? shrinker->batch
					  : SHRINK_BATCH;
459
	long scanned = 0, next_deferred;
G
Glauber Costa 已提交
460

461 462 463
	if (!(shrinker->flags & SHRINKER_NUMA_AWARE))
		nid = 0;

464
	freeable = shrinker->count_objects(shrinker, shrinkctl);
465 466
	if (freeable == 0 || freeable == SHRINK_EMPTY)
		return freeable;
G
Glauber Costa 已提交
467 468 469 470 471 472 473 474 475

	/*
	 * 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;
476 477 478
	delta = freeable >> priority;
	delta *= 4;
	do_div(delta, shrinker->seeks);
479

G
Glauber Costa 已提交
480 481
	total_scan += delta;
	if (total_scan < 0) {
482
		pr_err("shrink_slab: %pF negative objects to delete nr=%ld\n",
D
Dave Chinner 已提交
483
		       shrinker->scan_objects, total_scan);
484
		total_scan = freeable;
485 486 487
		next_deferred = nr;
	} else
		next_deferred = total_scan;
G
Glauber Costa 已提交
488 489 490 491 492 493 494

	/*
	 * 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 >>>
495
	 * freeable. This is bad for sustaining a working set in
G
Glauber Costa 已提交
496 497 498 499 500
	 * memory.
	 *
	 * Hence only allow the shrinker to scan the entire cache when
	 * a large delta change is calculated directly.
	 */
501 502
	if (delta < freeable / 4)
		total_scan = min(total_scan, freeable / 2);
G
Glauber Costa 已提交
503 504 505 506 507 508

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

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

515 516 517 518 519 520 521 522 523 524 525
	/*
	 * 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
526
	 * than the total number of objects on slab (freeable), we must be
527 528 529 530
	 * scanning at high prio and therefore should try to reclaim as much as
	 * possible.
	 */
	while (total_scan >= batch_size ||
531
	       total_scan >= freeable) {
D
Dave Chinner 已提交
532
		unsigned long ret;
533
		unsigned long nr_to_scan = min(batch_size, total_scan);
G
Glauber Costa 已提交
534

535
		shrinkctl->nr_to_scan = nr_to_scan;
536
		shrinkctl->nr_scanned = nr_to_scan;
D
Dave Chinner 已提交
537 538 539 540
		ret = shrinker->scan_objects(shrinker, shrinkctl);
		if (ret == SHRINK_STOP)
			break;
		freed += ret;
G
Glauber Costa 已提交
541

542 543 544
		count_vm_events(SLABS_SCANNED, shrinkctl->nr_scanned);
		total_scan -= shrinkctl->nr_scanned;
		scanned += shrinkctl->nr_scanned;
G
Glauber Costa 已提交
545 546 547 548

		cond_resched();
	}

549 550 551 552
	if (next_deferred >= scanned)
		next_deferred -= scanned;
	else
		next_deferred = 0;
G
Glauber Costa 已提交
553 554 555 556 557
	/*
	 * 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.
	 */
558 559
	if (next_deferred > 0)
		new_nr = atomic_long_add_return(next_deferred,
G
Glauber Costa 已提交
560 561 562 563
						&shrinker->nr_deferred[nid]);
	else
		new_nr = atomic_long_read(&shrinker->nr_deferred[nid]);

564
	trace_mm_shrink_slab_end(shrinker, nid, freed, nr, new_nr, total_scan);
G
Glauber Costa 已提交
565
	return freed;
566 567
}

568 569 570 571 572
#ifdef CONFIG_MEMCG_KMEM
static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
			struct mem_cgroup *memcg, int priority)
{
	struct memcg_shrinker_map *map;
573 574
	unsigned long ret, freed = 0;
	int i;
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595

	if (!memcg_kmem_enabled() || !mem_cgroup_online(memcg))
		return 0;

	if (!down_read_trylock(&shrinker_rwsem))
		return 0;

	map = rcu_dereference_protected(memcg->nodeinfo[nid]->shrinker_map,
					true);
	if (unlikely(!map))
		goto unlock;

	for_each_set_bit(i, map->map, shrinker_nr_max) {
		struct shrink_control sc = {
			.gfp_mask = gfp_mask,
			.nid = nid,
			.memcg = memcg,
		};
		struct shrinker *shrinker;

		shrinker = idr_find(&shrinker_idr, i);
596 597 598
		if (unlikely(!shrinker || shrinker == SHRINKER_REGISTERING)) {
			if (!shrinker)
				clear_bit(i, map->map);
599 600 601 602
			continue;
		}

		ret = do_shrink_slab(&sc, shrinker, priority);
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
		if (ret == SHRINK_EMPTY) {
			clear_bit(i, map->map);
			/*
			 * After the shrinker reported that it had no objects to
			 * free, but before we cleared the corresponding bit in
			 * the memcg shrinker map, a new object might have been
			 * added. To make sure, we have the bit set in this
			 * case, we invoke the shrinker one more time and reset
			 * the bit if it reports that it is not empty anymore.
			 * The memory barrier here pairs with the barrier in
			 * memcg_set_shrinker_bit():
			 *
			 * list_lru_add()     shrink_slab_memcg()
			 *   list_add_tail()    clear_bit()
			 *   <MB>               <MB>
			 *   set_bit()          do_shrink_slab()
			 */
			smp_mb__after_atomic();
			ret = do_shrink_slab(&sc, shrinker, priority);
			if (ret == SHRINK_EMPTY)
				ret = 0;
			else
				memcg_set_shrinker_bit(memcg, nid, i);
		}
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
		freed += ret;

		if (rwsem_is_contended(&shrinker_rwsem)) {
			freed = freed ? : 1;
			break;
		}
	}
unlock:
	up_read(&shrinker_rwsem);
	return freed;
}
#else /* CONFIG_MEMCG_KMEM */
static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
			struct mem_cgroup *memcg, int priority)
{
	return 0;
}
#endif /* CONFIG_MEMCG_KMEM */

646
/**
647
 * shrink_slab - shrink slab caches
648 649
 * @gfp_mask: allocation context
 * @nid: node whose slab caches to target
650
 * @memcg: memory cgroup whose slab caches to target
651
 * @priority: the reclaim priority
L
Linus Torvalds 已提交
652
 *
653
 * Call the shrink functions to age shrinkable caches.
L
Linus Torvalds 已提交
654
 *
655 656
 * @nid is passed along to shrinkers with SHRINKER_NUMA_AWARE set,
 * unaware shrinkers will receive a node id of 0 instead.
L
Linus Torvalds 已提交
657
 *
658 659
 * @memcg specifies the memory cgroup to target. Unaware shrinkers
 * are called only if it is the root cgroup.
660
 *
661 662
 * @priority is sc->priority, we take the number of objects and >> by priority
 * in order to get the scan target.
663
 *
664
 * Returns the number of reclaimed slab objects.
L
Linus Torvalds 已提交
665
 */
666 667
static unsigned long shrink_slab(gfp_t gfp_mask, int nid,
				 struct mem_cgroup *memcg,
668
				 int priority)
L
Linus Torvalds 已提交
669
{
670
	unsigned long ret, freed = 0;
L
Linus Torvalds 已提交
671 672
	struct shrinker *shrinker;

673
	if (!mem_cgroup_is_root(memcg))
674
		return shrink_slab_memcg(gfp_mask, nid, memcg, priority);
675

676
	if (!down_read_trylock(&shrinker_rwsem))
677
		goto out;
L
Linus Torvalds 已提交
678 679

	list_for_each_entry(shrinker, &shrinker_list, list) {
680 681 682
		struct shrink_control sc = {
			.gfp_mask = gfp_mask,
			.nid = nid,
683
			.memcg = memcg,
684
		};
685

686 687 688 689
		ret = do_shrink_slab(&sc, shrinker, priority);
		if (ret == SHRINK_EMPTY)
			ret = 0;
		freed += ret;
690 691 692 693 694 695 696 697 698
		/*
		 * Bail out if someone want to register a new shrinker to
		 * prevent the regsitration from being stalled for long periods
		 * by parallel ongoing shrinking.
		 */
		if (rwsem_is_contended(&shrinker_rwsem)) {
			freed = freed ? : 1;
			break;
		}
L
Linus Torvalds 已提交
699
	}
700

L
Linus Torvalds 已提交
701
	up_read(&shrinker_rwsem);
702 703
out:
	cond_resched();
D
Dave Chinner 已提交
704
	return freed;
L
Linus Torvalds 已提交
705 706
}

707 708 709 710 711 712 713 714
void drop_slab_node(int nid)
{
	unsigned long freed;

	do {
		struct mem_cgroup *memcg = NULL;

		freed = 0;
715
		memcg = mem_cgroup_iter(NULL, NULL, NULL);
716
		do {
717
			freed += shrink_slab(GFP_KERNEL, nid, memcg, 0);
718 719 720 721 722 723 724 725 726 727 728 729
		} while ((memcg = mem_cgroup_iter(NULL, memcg, NULL)) != NULL);
	} while (freed > 10);
}

void drop_slab(void)
{
	int nid;

	for_each_online_node(nid)
		drop_slab_node(nid);
}

L
Linus Torvalds 已提交
730 731
static inline int is_page_cache_freeable(struct page *page)
{
732 733 734 735 736
	/*
	 * 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.
	 */
737 738 739
	int radix_pins = PageTransHuge(page) && PageSwapCache(page) ?
		HPAGE_PMD_NR : 1;
	return page_count(page) - page_has_private(page) == 1 + radix_pins;
L
Linus Torvalds 已提交
740 741
}

742
static int may_write_to_inode(struct inode *inode, struct scan_control *sc)
L
Linus Torvalds 已提交
743
{
744
	if (current->flags & PF_SWAPWRITE)
L
Linus Torvalds 已提交
745
		return 1;
746
	if (!inode_write_congested(inode))
L
Linus Torvalds 已提交
747
		return 1;
748
	if (inode_to_bdi(inode) == current->backing_dev_info)
L
Linus Torvalds 已提交
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
		return 1;
	return 0;
}

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

774 775 776 777 778 779 780 781 782 783 784 785
/* possible outcome of pageout() */
typedef enum {
	/* failed to write page out, page is locked */
	PAGE_KEEP,
	/* move page to the active list, page is locked */
	PAGE_ACTIVATE,
	/* page has been sent to the disk successfully, page is unlocked */
	PAGE_SUCCESS,
	/* page is clean and locked */
	PAGE_CLEAN,
} pageout_t;

L
Linus Torvalds 已提交
786
/*
A
Andrew Morton 已提交
787 788
 * pageout is called by shrink_page_list() for each dirty page.
 * Calls ->writepage().
L
Linus Torvalds 已提交
789
 */
790
static pageout_t pageout(struct page *page, struct address_space *mapping,
791
			 struct scan_control *sc)
L
Linus Torvalds 已提交
792 793 794 795 796 797 798 799
{
	/*
	 * 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.
	 *
800
	 * If this process is currently in __generic_file_write_iter() against
L
Linus Torvalds 已提交
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
	 * 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.
		 */
816
		if (page_has_private(page)) {
L
Linus Torvalds 已提交
817 818
			if (try_to_free_buffers(page)) {
				ClearPageDirty(page);
819
				pr_info("%s: orphaned page\n", __func__);
L
Linus Torvalds 已提交
820 821 822 823 824 825 826
				return PAGE_CLEAN;
			}
		}
		return PAGE_KEEP;
	}
	if (mapping->a_ops->writepage == NULL)
		return PAGE_ACTIVATE;
827
	if (!may_write_to_inode(mapping->host, sc))
L
Linus Torvalds 已提交
828 829 830 831 832 833 834
		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,
835 836
			.range_start = 0,
			.range_end = LLONG_MAX,
L
Linus Torvalds 已提交
837 838 839 840 841 842 843
			.for_reclaim = 1,
		};

		SetPageReclaim(page);
		res = mapping->a_ops->writepage(page, &wbc);
		if (res < 0)
			handle_write_error(mapping, page, res);
844
		if (res == AOP_WRITEPAGE_ACTIVATE) {
L
Linus Torvalds 已提交
845 846 847
			ClearPageReclaim(page);
			return PAGE_ACTIVATE;
		}
848

L
Linus Torvalds 已提交
849 850 851 852
		if (!PageWriteback(page)) {
			/* synchronous write or broken a_ops? */
			ClearPageReclaim(page);
		}
853
		trace_mm_vmscan_writepage(page);
854
		inc_node_page_state(page, NR_VMSCAN_WRITE);
L
Linus Torvalds 已提交
855 856 857 858 859 860
		return PAGE_SUCCESS;
	}

	return PAGE_CLEAN;
}

861
/*
N
Nick Piggin 已提交
862 863
 * Same as remove_mapping, but if the page is removed from the mapping, it
 * gets returned with a refcount of 0.
864
 */
865 866
static int __remove_mapping(struct address_space *mapping, struct page *page,
			    bool reclaimed)
867
{
868
	unsigned long flags;
869
	int refcount;
870

871 872
	BUG_ON(!PageLocked(page));
	BUG_ON(mapping != page_mapping(page));
873

M
Matthew Wilcox 已提交
874
	xa_lock_irqsave(&mapping->i_pages, flags);
875
	/*
N
Nick Piggin 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
	 * 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
895
	 * load is not satisfied before that of page->_refcount.
N
Nick Piggin 已提交
896 897
	 *
	 * Note that if SetPageDirty is always performed via set_page_dirty,
M
Matthew Wilcox 已提交
898
	 * and thus under the i_pages lock, then this ordering is not required.
899
	 */
900 901 902 903 904
	if (unlikely(PageTransHuge(page)) && PageSwapCache(page))
		refcount = 1 + HPAGE_PMD_NR;
	else
		refcount = 2;
	if (!page_ref_freeze(page, refcount))
905
		goto cannot_free;
906
	/* note: atomic_cmpxchg in page_ref_freeze provides the smp_rmb */
N
Nick Piggin 已提交
907
	if (unlikely(PageDirty(page))) {
908
		page_ref_unfreeze(page, refcount);
909
		goto cannot_free;
N
Nick Piggin 已提交
910
	}
911 912 913

	if (PageSwapCache(page)) {
		swp_entry_t swap = { .val = page_private(page) };
914
		mem_cgroup_swapout(page, swap);
915
		__delete_from_swap_cache(page);
M
Matthew Wilcox 已提交
916
		xa_unlock_irqrestore(&mapping->i_pages, flags);
917
		put_swap_page(page, swap);
N
Nick Piggin 已提交
918
	} else {
919
		void (*freepage)(struct page *);
920
		void *shadow = NULL;
921 922

		freepage = mapping->a_ops->freepage;
923 924 925 926 927 928 929 930 931
		/*
		 * 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.
932 933 934 935 936
		 *
		 * 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
M
Matthew Wilcox 已提交
937
		 * same address_space.
938 939
		 */
		if (reclaimed && page_is_file_cache(page) &&
940
		    !mapping_exiting(mapping) && !dax_mapping(mapping))
941
			shadow = workingset_eviction(mapping, page);
J
Johannes Weiner 已提交
942
		__delete_from_page_cache(page, shadow);
M
Matthew Wilcox 已提交
943
		xa_unlock_irqrestore(&mapping->i_pages, flags);
944 945 946

		if (freepage != NULL)
			freepage(page);
947 948 949 950 951
	}

	return 1;

cannot_free:
M
Matthew Wilcox 已提交
952
	xa_unlock_irqrestore(&mapping->i_pages, flags);
953 954 955
	return 0;
}

N
Nick Piggin 已提交
956 957 958 959 960 961 962 963
/*
 * 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)
{
964
	if (__remove_mapping(mapping, page, false)) {
N
Nick Piggin 已提交
965 966 967 968 969
		/*
		 * Unfreezing the refcount with 1 rather than 2 effectively
		 * drops the pagecache ref for us without requiring another
		 * atomic operation.
		 */
970
		page_ref_unfreeze(page, 1);
N
Nick Piggin 已提交
971 972 973 974 975
		return 1;
	}
	return 0;
}

L
Lee Schermerhorn 已提交
976 977 978 979 980 981 982 983 984 985 986
/**
 * 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)
{
987
	lru_cache_add(page);
L
Lee Schermerhorn 已提交
988 989 990
	put_page(page);		/* drop ref from isolate */
}

991 992 993
enum page_references {
	PAGEREF_RECLAIM,
	PAGEREF_RECLAIM_CLEAN,
994
	PAGEREF_KEEP,
995 996 997 998 999 1000
	PAGEREF_ACTIVATE,
};

static enum page_references page_check_references(struct page *page,
						  struct scan_control *sc)
{
1001
	int referenced_ptes, referenced_page;
1002 1003
	unsigned long vm_flags;

1004 1005
	referenced_ptes = page_referenced(page, 1, sc->target_mem_cgroup,
					  &vm_flags);
1006
	referenced_page = TestClearPageReferenced(page);
1007 1008 1009 1010 1011 1012 1013 1014

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

1015
	if (referenced_ptes) {
1016
		if (PageSwapBacked(page))
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
			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);

1034
		if (referenced_page || referenced_ptes > 1)
1035 1036
			return PAGEREF_ACTIVATE;

1037 1038 1039 1040 1041 1042
		/*
		 * Activate file-backed executable pages after first usage.
		 */
		if (vm_flags & VM_EXEC)
			return PAGEREF_ACTIVATE;

1043 1044
		return PAGEREF_KEEP;
	}
1045 1046

	/* Reclaim if clean, defer dirty pages to writeback */
1047
	if (referenced_page && !PageSwapBacked(page))
1048 1049 1050
		return PAGEREF_RECLAIM_CLEAN;

	return PAGEREF_RECLAIM;
1051 1052
}

1053 1054 1055 1056
/* Check if a page is dirty or under writeback */
static void page_check_dirty_writeback(struct page *page,
				       bool *dirty, bool *writeback)
{
1057 1058
	struct address_space *mapping;

1059 1060 1061 1062
	/*
	 * Anonymous pages are not handled by flushers and must be written
	 * from reclaim context. Do not stall reclaim based on them
	 */
S
Shaohua Li 已提交
1063 1064
	if (!page_is_file_cache(page) ||
	    (PageAnon(page) && !PageSwapBacked(page))) {
1065 1066 1067 1068 1069 1070 1071 1072
		*dirty = false;
		*writeback = false;
		return;
	}

	/* By default assume that the page flags are accurate */
	*dirty = PageDirty(page);
	*writeback = PageWriteback(page);
1073 1074 1075 1076 1077 1078 1079 1080

	/* 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);
1081 1082
}

L
Linus Torvalds 已提交
1083
/*
A
Andrew Morton 已提交
1084
 * shrink_page_list() returns the number of reclaimed pages
L
Linus Torvalds 已提交
1085
 */
A
Andrew Morton 已提交
1086
static unsigned long shrink_page_list(struct list_head *page_list,
M
Mel Gorman 已提交
1087
				      struct pglist_data *pgdat,
1088
				      struct scan_control *sc,
1089
				      enum ttu_flags ttu_flags,
1090
				      struct reclaim_stat *stat,
1091
				      bool force_reclaim)
L
Linus Torvalds 已提交
1092 1093
{
	LIST_HEAD(ret_pages);
1094
	LIST_HEAD(free_pages);
L
Linus Torvalds 已提交
1095
	int pgactivate = 0;
1096 1097 1098 1099 1100 1101
	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;
1102 1103
	unsigned nr_ref_keep = 0;
	unsigned nr_unmap_fail = 0;
L
Linus Torvalds 已提交
1104 1105 1106 1107 1108 1109 1110

	cond_resched();

	while (!list_empty(page_list)) {
		struct address_space *mapping;
		struct page *page;
		int may_enter_fs;
1111
		enum page_references references = PAGEREF_RECLAIM_CLEAN;
1112
		bool dirty, writeback;
L
Linus Torvalds 已提交
1113 1114 1115 1116 1117 1118

		cond_resched();

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

N
Nick Piggin 已提交
1119
		if (!trylock_page(page))
L
Linus Torvalds 已提交
1120 1121
			goto keep;

1122
		VM_BUG_ON_PAGE(PageActive(page), page);
L
Linus Torvalds 已提交
1123 1124

		sc->nr_scanned++;
1125

1126
		if (unlikely(!page_evictable(page)))
M
Minchan Kim 已提交
1127
			goto activate_locked;
L
Lee Schermerhorn 已提交
1128

1129
		if (!sc->may_unmap && page_mapped(page))
1130 1131
			goto keep_locked;

L
Linus Torvalds 已提交
1132
		/* Double the slab pressure for mapped and swapcache pages */
S
Shaohua Li 已提交
1133 1134
		if ((page_mapped(page) || PageSwapCache(page)) &&
		    !(PageAnon(page) && !PageSwapBacked(page)))
L
Linus Torvalds 已提交
1135 1136
			sc->nr_scanned++;

1137 1138 1139
		may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
			(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));

1140
		/*
1141
		 * The number of dirty pages determines if a node is marked
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
		 * 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++;

1153 1154 1155 1156 1157 1158
		/*
		 * 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.
		 */
1159
		mapping = page_mapping(page);
1160
		if (((dirty || writeback) && mapping &&
1161
		     inode_write_congested(mapping->host)) ||
1162
		    (writeback && PageReclaim(page)))
1163 1164
			nr_congested++;

1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
		/*
		 * 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
1176 1177
		 *    note that the LRU is being scanned too quickly and the
		 *    caller can stall after page list has been processed.
1178
		 *
1179
		 * 2) Global or new memcg reclaim encounters a page that is
1180 1181 1182
		 *    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
1183
		 *    reclaim and continue scanning.
1184
		 *
1185 1186
		 *    Require may_enter_fs because we would wait on fs, which
		 *    may not have submitted IO yet. And the loop driver might
1187 1188 1189 1190 1191
		 *    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.
		 *
1192
		 * 3) Legacy memcg encounters a page that is already marked
1193 1194 1195 1196
		 *    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.
1197 1198 1199 1200 1201 1202 1203 1204 1205
		 *
		 * 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.
1206
		 */
1207
		if (PageWriteback(page)) {
1208 1209 1210
			/* Case 1 above */
			if (current_is_kswapd() &&
			    PageReclaim(page) &&
M
Mel Gorman 已提交
1211
			    test_bit(PGDAT_WRITEBACK, &pgdat->flags)) {
1212
				nr_immediate++;
1213
				goto activate_locked;
1214 1215

			/* Case 2 above */
1216
			} else if (sane_reclaim(sc) ||
1217
			    !PageReclaim(page) || !may_enter_fs) {
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
				/*
				 * 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);
1230
				nr_writeback++;
1231
				goto activate_locked;
1232 1233 1234

			/* Case 3 above */
			} else {
1235
				unlock_page(page);
1236
				wait_on_page_writeback(page);
1237 1238 1239
				/* then go back and try same page again */
				list_add_tail(&page->lru, page_list);
				continue;
1240
			}
1241
		}
L
Linus Torvalds 已提交
1242

1243 1244 1245
		if (!force_reclaim)
			references = page_check_references(page, sc);

1246 1247
		switch (references) {
		case PAGEREF_ACTIVATE:
L
Linus Torvalds 已提交
1248
			goto activate_locked;
1249
		case PAGEREF_KEEP:
1250
			nr_ref_keep++;
1251
			goto keep_locked;
1252 1253 1254 1255
		case PAGEREF_RECLAIM:
		case PAGEREF_RECLAIM_CLEAN:
			; /* try to reclaim the page below */
		}
L
Linus Torvalds 已提交
1256 1257 1258 1259

		/*
		 * Anonymous process memory has backing store?
		 * Try to allocate it some swap space here.
S
Shaohua Li 已提交
1260
		 * Lazyfree page could be freed directly
L
Linus Torvalds 已提交
1261
		 */
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
		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;
1287 1288 1289
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
					count_vm_event(THP_SWPOUT_FALLBACK);
#endif
1290 1291 1292
					if (!add_to_swap(page))
						goto activate_locked;
				}
1293

1294
				may_enter_fs = 1;
L
Linus Torvalds 已提交
1295

1296 1297 1298
				/* Adding to swap updated mapping */
				mapping = page_mapping(page);
			}
1299 1300 1301 1302
		} else if (unlikely(PageTransHuge(page))) {
			/* Split file THP */
			if (split_huge_page_to_list(page, page_list))
				goto keep_locked;
1303
		}
L
Linus Torvalds 已提交
1304 1305 1306 1307 1308

		/*
		 * The page is mapped into the page tables of one or more
		 * processes. Try to unmap it here.
		 */
S
Shaohua Li 已提交
1309
		if (page_mapped(page)) {
1310 1311 1312 1313 1314
			enum ttu_flags flags = ttu_flags | TTU_BATCH_FLUSH;

			if (unlikely(PageTransHuge(page)))
				flags |= TTU_SPLIT_HUGE_PMD;
			if (!try_to_unmap(page, flags)) {
1315
				nr_unmap_fail++;
L
Linus Torvalds 已提交
1316 1317 1318 1319 1320
				goto activate_locked;
			}
		}

		if (PageDirty(page)) {
1321
			/*
1322 1323 1324 1325 1326 1327 1328 1329
			 * 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).
1330
			 */
1331
			if (page_is_file_cache(page) &&
1332 1333
			    (!current_is_kswapd() || !PageReclaim(page) ||
			     !test_bit(PGDAT_DIRTY, &pgdat->flags))) {
1334 1335 1336 1337 1338 1339
				/*
				 * Immediately reclaim when written back.
				 * Similar in principal to deactivate_page()
				 * except we already have the page isolated
				 * and know it's dirty
				 */
1340
				inc_node_page_state(page, NR_VMSCAN_IMMEDIATE);
1341 1342
				SetPageReclaim(page);

1343
				goto activate_locked;
1344 1345
			}

1346
			if (references == PAGEREF_RECLAIM_CLEAN)
L
Linus Torvalds 已提交
1347
				goto keep_locked;
1348
			if (!may_enter_fs)
L
Linus Torvalds 已提交
1349
				goto keep_locked;
1350
			if (!sc->may_writepage)
L
Linus Torvalds 已提交
1351 1352
				goto keep_locked;

1353 1354 1355 1356 1357 1358
			/*
			 * 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();
1359
			switch (pageout(page, mapping, sc)) {
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364
			case PAGE_KEEP:
				goto keep_locked;
			case PAGE_ACTIVATE:
				goto activate_locked;
			case PAGE_SUCCESS:
1365
				if (PageWriteback(page))
1366
					goto keep;
1367
				if (PageDirty(page))
L
Linus Torvalds 已提交
1368
					goto keep;
1369

L
Linus Torvalds 已提交
1370 1371 1372 1373
				/*
				 * A synchronous write - probably a ramdisk.  Go
				 * ahead and try to reclaim the page.
				 */
N
Nick Piggin 已提交
1374
				if (!trylock_page(page))
L
Linus Torvalds 已提交
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
					goto keep;
				if (PageDirty(page) || PageWriteback(page))
					goto keep_locked;
				mapping = page_mapping(page);
			case PAGE_CLEAN:
				; /* try to free the page below */
			}
		}

		/*
		 * If the page has buffers, try to free the buffer mappings
		 * associated with this page. If we succeed we try to free
		 * the page as well.
		 *
		 * We do this even if the page is PageDirty().
		 * try_to_release_page() does not perform I/O, but it is
		 * possible for a page to have PageDirty set, but it is actually
		 * clean (all its buffers are clean).  This happens if the
		 * buffers were written out directly, with submit_bh(). ext3
L
Lee Schermerhorn 已提交
1394
		 * will do this, as well as the blockdev mapping.
L
Linus Torvalds 已提交
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
		 * 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.
		 */
1405
		if (page_has_private(page)) {
L
Linus Torvalds 已提交
1406 1407
			if (!try_to_release_page(page, sc->gfp_mask))
				goto activate_locked;
N
Nick Piggin 已提交
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
			if (!mapping && page_count(page) == 1) {
				unlock_page(page);
				if (put_page_testzero(page))
					goto free_it;
				else {
					/*
					 * rare race with speculative reference.
					 * the speculative reference will free
					 * this page shortly, so we may
					 * increment nr_reclaimed here (and
					 * leave it off the LRU).
					 */
					nr_reclaimed++;
					continue;
				}
			}
L
Linus Torvalds 已提交
1424 1425
		}

S
Shaohua Li 已提交
1426 1427 1428 1429 1430 1431 1432 1433
		if (PageAnon(page) && !PageSwapBacked(page)) {
			/* follow __remove_mapping for reference */
			if (!page_ref_freeze(page, 1))
				goto keep_locked;
			if (PageDirty(page)) {
				page_ref_unfreeze(page, 1);
				goto keep_locked;
			}
L
Linus Torvalds 已提交
1434

S
Shaohua Li 已提交
1435
			count_vm_event(PGLAZYFREED);
1436
			count_memcg_page_event(page, PGLAZYFREED);
S
Shaohua Li 已提交
1437 1438
		} else if (!mapping || !__remove_mapping(mapping, page, true))
			goto keep_locked;
N
Nick Piggin 已提交
1439 1440 1441 1442 1443 1444 1445
		/*
		 * 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.
		 */
1446
		__ClearPageLocked(page);
N
Nick Piggin 已提交
1447
free_it:
1448
		nr_reclaimed++;
1449 1450 1451 1452 1453

		/*
		 * Is there need to periodically free_page_list? It would
		 * appear not as the counts should be low
		 */
1454 1455 1456 1457 1458
		if (unlikely(PageTransHuge(page))) {
			mem_cgroup_uncharge(page);
			(*get_compound_page_dtor(page))(page);
		} else
			list_add(&page->lru, &free_pages);
L
Linus Torvalds 已提交
1459 1460 1461
		continue;

activate_locked:
1462
		/* Not a candidate for swapping, so reclaim swap space. */
M
Minchan Kim 已提交
1463 1464
		if (PageSwapCache(page) && (mem_cgroup_swap_full(page) ||
						PageMlocked(page)))
1465
			try_to_free_swap(page);
1466
		VM_BUG_ON_PAGE(PageActive(page), page);
M
Minchan Kim 已提交
1467 1468 1469
		if (!PageMlocked(page)) {
			SetPageActive(page);
			pgactivate++;
1470
			count_memcg_page_event(page, PGACTIVATE);
M
Minchan Kim 已提交
1471
		}
L
Linus Torvalds 已提交
1472 1473 1474 1475
keep_locked:
		unlock_page(page);
keep:
		list_add(&page->lru, &ret_pages);
1476
		VM_BUG_ON_PAGE(PageLRU(page) || PageUnevictable(page), page);
L
Linus Torvalds 已提交
1477
	}
1478

1479
	mem_cgroup_uncharge_list(&free_pages);
1480
	try_to_unmap_flush();
1481
	free_unref_page_list(&free_pages);
1482

L
Linus Torvalds 已提交
1483
	list_splice(&ret_pages, page_list);
1484
	count_vm_events(PGACTIVATE, pgactivate);
1485

1486 1487 1488 1489 1490 1491
	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;
1492 1493 1494
		stat->nr_activate = pgactivate;
		stat->nr_ref_keep = nr_ref_keep;
		stat->nr_unmap_fail = nr_unmap_fail;
1495
	}
1496
	return nr_reclaimed;
L
Linus Torvalds 已提交
1497 1498
}

1499 1500 1501 1502 1503 1504 1505 1506
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,
	};
1507
	unsigned long ret;
1508 1509 1510 1511
	struct page *page, *next;
	LIST_HEAD(clean_pages);

	list_for_each_entry_safe(page, next, page_list, lru) {
1512
		if (page_is_file_cache(page) && !PageDirty(page) &&
1513
		    !__PageMovable(page)) {
1514 1515 1516 1517 1518
			ClearPageActive(page);
			list_move(&page->lru, &clean_pages);
		}
	}

M
Mel Gorman 已提交
1519
	ret = shrink_page_list(&clean_pages, zone->zone_pgdat, &sc,
S
Shaohua Li 已提交
1520
			TTU_IGNORE_ACCESS, NULL, true);
1521
	list_splice(&clean_pages, page_list);
M
Mel Gorman 已提交
1522
	mod_node_page_state(zone->zone_pgdat, NR_ISOLATED_FILE, -ret);
1523 1524 1525
	return ret;
}

A
Andy Whitcroft 已提交
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
/*
 * 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.
 */
1536
int __isolate_lru_page(struct page *page, isolate_mode_t mode)
A
Andy Whitcroft 已提交
1537 1538 1539 1540 1541 1542 1543
{
	int ret = -EINVAL;

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

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

A
Andy Whitcroft 已提交
1548
	ret = -EBUSY;
K
KAMEZAWA Hiroyuki 已提交
1549

1550 1551 1552 1553 1554 1555 1556 1557
	/*
	 * 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
	 */
1558
	if (mode & ISOLATE_ASYNC_MIGRATE) {
1559 1560 1561 1562 1563 1564
		/* All the caller can do on PageWriteback is block */
		if (PageWriteback(page))
			return ret;

		if (PageDirty(page)) {
			struct address_space *mapping;
1565
			bool migrate_dirty;
1566 1567 1568 1569

			/*
			 * Only pages without mappings or that have a
			 * ->migratepage callback are possible to migrate
1570 1571 1572 1573 1574
			 * without blocking. However, we can be racing with
			 * truncation so it's necessary to lock the page
			 * to stabilise the mapping as truncation holds
			 * the page lock until after the page is removed
			 * from the page cache.
1575
			 */
1576 1577 1578
			if (!trylock_page(page))
				return ret;

1579
			mapping = page_mapping(page);
1580
			migrate_dirty = !mapping || mapping->a_ops->migratepage;
1581 1582
			unlock_page(page);
			if (!migrate_dirty)
1583 1584 1585
				return ret;
		}
	}
1586

1587 1588 1589
	if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
		return ret;

A
Andy Whitcroft 已提交
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602
	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;
}

1603 1604 1605 1606 1607 1608

/*
 * 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,
1609
			enum lru_list lru, unsigned long *nr_zone_taken)
1610 1611 1612 1613 1614 1615 1616 1617 1618
{
	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
1619
		mem_cgroup_update_lru_size(lruvec, lru, zid, -nr_zone_taken[zid]);
1620
#endif
1621 1622
	}

1623 1624
}

L
Linus Torvalds 已提交
1625
/*
1626
 * zone_lru_lock is heavily contended.  Some of the functions that
L
Linus Torvalds 已提交
1627 1628 1629 1630 1631 1632 1633 1634
 * 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.
 *
1635
 * @nr_to_scan:	The number of eligible pages to look through on the list.
1636
 * @lruvec:	The LRU vector to pull pages from.
L
Linus Torvalds 已提交
1637
 * @dst:	The temp list to put pages on to.
H
Hugh Dickins 已提交
1638
 * @nr_scanned:	The number of pages that were scanned.
1639
 * @sc:		The scan_control struct for this reclaim session
A
Andy Whitcroft 已提交
1640
 * @mode:	One of the LRU isolation modes
1641
 * @lru:	LRU list id for isolating
L
Linus Torvalds 已提交
1642 1643 1644
 *
 * returns how many pages were moved onto *@dst.
 */
1645
static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
1646
		struct lruvec *lruvec, struct list_head *dst,
1647
		unsigned long *nr_scanned, struct scan_control *sc,
1648
		isolate_mode_t mode, enum lru_list lru)
L
Linus Torvalds 已提交
1649
{
H
Hugh Dickins 已提交
1650
	struct list_head *src = &lruvec->lists[lru];
1651
	unsigned long nr_taken = 0;
M
Mel Gorman 已提交
1652
	unsigned long nr_zone_taken[MAX_NR_ZONES] = { 0 };
1653
	unsigned long nr_skipped[MAX_NR_ZONES] = { 0, };
1654
	unsigned long skipped = 0;
1655
	unsigned long scan, total_scan, nr_pages;
1656
	LIST_HEAD(pages_skipped);
L
Linus Torvalds 已提交
1657

1658 1659 1660 1661
	scan = 0;
	for (total_scan = 0;
	     scan < nr_to_scan && nr_taken < nr_to_scan && !list_empty(src);
	     total_scan++) {
A
Andy Whitcroft 已提交
1662 1663
		struct page *page;

L
Linus Torvalds 已提交
1664 1665 1666
		page = lru_to_page(src);
		prefetchw_prev_lru_page(page, src, flags);

1667
		VM_BUG_ON_PAGE(!PageLRU(page), page);
N
Nick Piggin 已提交
1668

1669 1670
		if (page_zonenum(page) > sc->reclaim_idx) {
			list_move(&page->lru, &pages_skipped);
1671
			nr_skipped[page_zonenum(page)]++;
1672 1673 1674
			continue;
		}

1675 1676 1677 1678 1679 1680 1681
		/*
		 * 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++;
1682
		switch (__isolate_lru_page(page, mode)) {
A
Andy Whitcroft 已提交
1683
		case 0:
M
Mel Gorman 已提交
1684 1685 1686
			nr_pages = hpage_nr_pages(page);
			nr_taken += nr_pages;
			nr_zone_taken[page_zonenum(page)] += nr_pages;
A
Andy Whitcroft 已提交
1687 1688 1689 1690 1691 1692 1693
			list_move(&page->lru, dst);
			break;

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

A
Andy Whitcroft 已提交
1695 1696 1697
		default:
			BUG();
		}
L
Linus Torvalds 已提交
1698 1699
	}

1700 1701 1702 1703 1704 1705 1706
	/*
	 * 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.
	 */
1707 1708 1709
	if (!list_empty(&pages_skipped)) {
		int zid;

1710
		list_splice(&pages_skipped, src);
1711 1712 1713 1714 1715
		for (zid = 0; zid < MAX_NR_ZONES; zid++) {
			if (!nr_skipped[zid])
				continue;

			__count_zid_vm_events(PGSCAN_SKIP, zid, nr_skipped[zid]);
1716
			skipped += nr_skipped[zid];
1717 1718
		}
	}
1719
	*nr_scanned = total_scan;
1720
	trace_mm_vmscan_lru_isolate(sc->reclaim_idx, sc->order, nr_to_scan,
1721
				    total_scan, skipped, nr_taken, mode, lru);
1722
	update_lru_sizes(lruvec, lru, nr_zone_taken);
L
Linus Torvalds 已提交
1723 1724 1725
	return nr_taken;
}

1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
/**
 * isolate_lru_page - tries to isolate a page from its LRU list
 * @page: page to isolate from its LRU list
 *
 * Isolates a @page from an LRU list, clears PageLRU and adjusts the
 * vmstat statistic corresponding to whatever LRU list the page was on.
 *
 * Returns 0 if the page was removed from an LRU list.
 * Returns -EBUSY if the page was not on an LRU list.
 *
 * The returned page will have PageLRU() cleared.  If it was found on
L
Lee Schermerhorn 已提交
1737 1738 1739
 * 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.
1740 1741 1742 1743 1744
 *
 * The vmstat statistic corresponding to the list on which the page was
 * found will be decremented.
 *
 * Restrictions:
1745
 *
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
 * (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;

1756
	VM_BUG_ON_PAGE(!page_count(page), page);
1757
	WARN_RATELIMIT(PageTail(page), "trying to isolate tail page");
1758

1759 1760
	if (PageLRU(page)) {
		struct zone *zone = page_zone(page);
1761
		struct lruvec *lruvec;
1762

1763
		spin_lock_irq(zone_lru_lock(zone));
M
Mel Gorman 已提交
1764
		lruvec = mem_cgroup_page_lruvec(page, zone->zone_pgdat);
1765
		if (PageLRU(page)) {
L
Lee Schermerhorn 已提交
1766
			int lru = page_lru(page);
1767
			get_page(page);
1768
			ClearPageLRU(page);
1769 1770
			del_page_from_lru_list(page, lruvec, lru);
			ret = 0;
1771
		}
1772
		spin_unlock_irq(zone_lru_lock(zone));
1773 1774 1775 1776
	}
	return ret;
}

1777
/*
F
Fengguang Wu 已提交
1778 1779 1780 1781 1782
 * 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.
1783
 */
M
Mel Gorman 已提交
1784
static int too_many_isolated(struct pglist_data *pgdat, int file,
1785 1786 1787 1788 1789 1790 1791
		struct scan_control *sc)
{
	unsigned long inactive, isolated;

	if (current_is_kswapd())
		return 0;

1792
	if (!sane_reclaim(sc))
1793 1794 1795
		return 0;

	if (file) {
M
Mel Gorman 已提交
1796 1797
		inactive = node_page_state(pgdat, NR_INACTIVE_FILE);
		isolated = node_page_state(pgdat, NR_ISOLATED_FILE);
1798
	} else {
M
Mel Gorman 已提交
1799 1800
		inactive = node_page_state(pgdat, NR_INACTIVE_ANON);
		isolated = node_page_state(pgdat, NR_ISOLATED_ANON);
1801 1802
	}

1803 1804 1805 1806 1807
	/*
	 * 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.
	 */
1808
	if ((sc->gfp_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
1809 1810
		inactive >>= 3;

1811 1812 1813
	return isolated > inactive;
}

1814
static noinline_for_stack void
H
Hugh Dickins 已提交
1815
putback_inactive_pages(struct lruvec *lruvec, struct list_head *page_list)
1816
{
1817
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
M
Mel Gorman 已提交
1818
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1819
	LIST_HEAD(pages_to_free);
1820 1821 1822 1823 1824

	/*
	 * Put back any unfreeable pages.
	 */
	while (!list_empty(page_list)) {
1825
		struct page *page = lru_to_page(page_list);
1826
		int lru;
1827

1828
		VM_BUG_ON_PAGE(PageLRU(page), page);
1829
		list_del(&page->lru);
1830
		if (unlikely(!page_evictable(page))) {
M
Mel Gorman 已提交
1831
			spin_unlock_irq(&pgdat->lru_lock);
1832
			putback_lru_page(page);
M
Mel Gorman 已提交
1833
			spin_lock_irq(&pgdat->lru_lock);
1834 1835
			continue;
		}
1836

M
Mel Gorman 已提交
1837
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
1838

1839
		SetPageLRU(page);
1840
		lru = page_lru(page);
1841 1842
		add_page_to_lru_list(page, lruvec, lru);

1843 1844
		if (is_active_lru(lru)) {
			int file = is_file_lru(lru);
1845 1846
			int numpages = hpage_nr_pages(page);
			reclaim_stat->recent_rotated[file] += numpages;
1847
		}
1848 1849 1850
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
1851
			del_page_from_lru_list(page, lruvec, lru);
1852 1853

			if (unlikely(PageCompound(page))) {
M
Mel Gorman 已提交
1854
				spin_unlock_irq(&pgdat->lru_lock);
1855
				mem_cgroup_uncharge(page);
1856
				(*get_compound_page_dtor(page))(page);
M
Mel Gorman 已提交
1857
				spin_lock_irq(&pgdat->lru_lock);
1858 1859
			} else
				list_add(&page->lru, &pages_to_free);
1860 1861 1862
		}
	}

1863 1864 1865 1866
	/*
	 * To save our caller's stack, now use input list for pages to free.
	 */
	list_splice(&pages_to_free, page_list);
1867 1868
}

1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881
/*
 * If a kernel thread (such as nfsd for loop-back mounts) services
 * a backing device by writing to the page cache it sets PF_LESS_THROTTLE.
 * In that case we should only throttle if the backing device it is
 * writing to is congested.  In other cases it is safe to throttle.
 */
static int current_may_throttle(void)
{
	return !(current->flags & PF_LESS_THROTTLE) ||
		current->backing_dev_info == NULL ||
		bdi_write_congested(current->backing_dev_info);
}

L
Linus Torvalds 已提交
1882
/*
1883
 * shrink_inactive_list() is a helper for shrink_node().  It returns the number
A
Andrew Morton 已提交
1884
 * of reclaimed pages
L
Linus Torvalds 已提交
1885
 */
1886
static noinline_for_stack unsigned long
1887
shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
1888
		     struct scan_control *sc, enum lru_list lru)
L
Linus Torvalds 已提交
1889 1890
{
	LIST_HEAD(page_list);
1891
	unsigned long nr_scanned;
1892
	unsigned long nr_reclaimed = 0;
1893
	unsigned long nr_taken;
1894
	struct reclaim_stat stat = {};
1895
	isolate_mode_t isolate_mode = 0;
1896
	int file = is_file_lru(lru);
M
Mel Gorman 已提交
1897
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
1898
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
1899
	bool stalled = false;
1900

M
Mel Gorman 已提交
1901
	while (unlikely(too_many_isolated(pgdat, file, sc))) {
1902 1903 1904 1905 1906 1907
		if (stalled)
			return 0;

		/* wait a bit for the reclaimer. */
		msleep(100);
		stalled = true;
1908 1909 1910 1911 1912 1913

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

L
Linus Torvalds 已提交
1914
	lru_add_drain();
1915 1916

	if (!sc->may_unmap)
1917
		isolate_mode |= ISOLATE_UNMAPPED;
1918

M
Mel Gorman 已提交
1919
	spin_lock_irq(&pgdat->lru_lock);
1920

1921 1922
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &page_list,
				     &nr_scanned, sc, isolate_mode, lru);
1923

M
Mel Gorman 已提交
1924
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
1925
	reclaim_stat->recent_scanned[file] += nr_taken;
1926

1927 1928
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1929
			__count_vm_events(PGSCAN_KSWAPD, nr_scanned);
1930 1931 1932 1933
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_KSWAPD,
				   nr_scanned);
	} else {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1934
			__count_vm_events(PGSCAN_DIRECT, nr_scanned);
1935 1936
		count_memcg_events(lruvec_memcg(lruvec), PGSCAN_DIRECT,
				   nr_scanned);
1937
	}
M
Mel Gorman 已提交
1938
	spin_unlock_irq(&pgdat->lru_lock);
1939

1940
	if (nr_taken == 0)
1941
		return 0;
A
Andy Whitcroft 已提交
1942

S
Shaohua Li 已提交
1943
	nr_reclaimed = shrink_page_list(&page_list, pgdat, sc, 0,
1944
				&stat, false);
1945

M
Mel Gorman 已提交
1946
	spin_lock_irq(&pgdat->lru_lock);
1947

1948 1949
	if (current_is_kswapd()) {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1950
			__count_vm_events(PGSTEAL_KSWAPD, nr_reclaimed);
1951 1952 1953 1954
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_KSWAPD,
				   nr_reclaimed);
	} else {
		if (global_reclaim(sc))
M
Mel Gorman 已提交
1955
			__count_vm_events(PGSTEAL_DIRECT, nr_reclaimed);
1956 1957
		count_memcg_events(lruvec_memcg(lruvec), PGSTEAL_DIRECT,
				   nr_reclaimed);
Y
Ying Han 已提交
1958
	}
N
Nick Piggin 已提交
1959

1960
	putback_inactive_pages(lruvec, &page_list);
1961

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

M
Mel Gorman 已提交
1964
	spin_unlock_irq(&pgdat->lru_lock);
1965

1966
	mem_cgroup_uncharge_list(&page_list);
1967
	free_unref_page_list(&page_list);
1968

1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
	/*
	 * If dirty pages are scanned that are not queued for IO, it
	 * implies that flushers are not doing their job. This can
	 * happen when memory pressure pushes dirty pages to the end of
	 * the LRU before the dirty limits are breached and the dirty
	 * data has expired. It can also happen when the proportion of
	 * dirty pages grows not through writes but through memory
	 * pressure reclaiming all the clean cache. And in some cases,
	 * the flushers simply cannot keep up with the allocation
	 * rate. Nudge the flusher threads in case they are asleep.
	 */
	if (stat.nr_unqueued_dirty == nr_taken)
		wakeup_flusher_threads(WB_REASON_VMSCAN);

1983 1984 1985 1986 1987 1988 1989 1990
	sc->nr.dirty += stat.nr_dirty;
	sc->nr.congested += stat.nr_congested;
	sc->nr.unqueued_dirty += stat.nr_unqueued_dirty;
	sc->nr.writeback += stat.nr_writeback;
	sc->nr.immediate += stat.nr_immediate;
	sc->nr.taken += nr_taken;
	if (file)
		sc->nr.file_taken += nr_taken;
1991

M
Mel Gorman 已提交
1992
	trace_mm_vmscan_lru_shrink_inactive(pgdat->node_id,
1993
			nr_scanned, nr_reclaimed, &stat, sc->priority, file);
1994
	return nr_reclaimed;
L
Linus Torvalds 已提交
1995 1996 1997 1998 1999 2000 2001 2002 2003
}

/*
 * 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
2004
 * appropriate to hold zone_lru_lock across the whole operation.  But if
L
Linus Torvalds 已提交
2005
 * the pages are mapped, the processing is slow (page_referenced()) so we
2006
 * should drop zone_lru_lock around each page.  It's impossible to balance
L
Linus Torvalds 已提交
2007 2008 2009 2010
 * 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.
 *
2011
 * The downside is that we have to touch page->_refcount against each page.
L
Linus Torvalds 已提交
2012
 * But we had to alter page->flags anyway.
2013 2014
 *
 * Returns the number of pages moved to the given lru.
L
Linus Torvalds 已提交
2015
 */
2016

2017
static unsigned move_active_pages_to_lru(struct lruvec *lruvec,
2018
				     struct list_head *list,
2019
				     struct list_head *pages_to_free,
2020 2021
				     enum lru_list lru)
{
M
Mel Gorman 已提交
2022
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2023
	struct page *page;
2024
	int nr_pages;
2025
	int nr_moved = 0;
2026 2027 2028

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

2031
		VM_BUG_ON_PAGE(PageLRU(page), page);
2032 2033
		SetPageLRU(page);

2034
		nr_pages = hpage_nr_pages(page);
M
Mel Gorman 已提交
2035
		update_lru_size(lruvec, lru, page_zonenum(page), nr_pages);
2036
		list_move(&page->lru, &lruvec->lists[lru]);
2037

2038 2039 2040
		if (put_page_testzero(page)) {
			__ClearPageLRU(page);
			__ClearPageActive(page);
2041
			del_page_from_lru_list(page, lruvec, lru);
2042 2043

			if (unlikely(PageCompound(page))) {
M
Mel Gorman 已提交
2044
				spin_unlock_irq(&pgdat->lru_lock);
2045
				mem_cgroup_uncharge(page);
2046
				(*get_compound_page_dtor(page))(page);
M
Mel Gorman 已提交
2047
				spin_lock_irq(&pgdat->lru_lock);
2048 2049
			} else
				list_add(&page->lru, pages_to_free);
2050 2051
		} else {
			nr_moved += nr_pages;
2052 2053
		}
	}
2054

2055
	if (!is_active_lru(lru)) {
2056
		__count_vm_events(PGDEACTIVATE, nr_moved);
2057 2058 2059
		count_memcg_events(lruvec_memcg(lruvec), PGDEACTIVATE,
				   nr_moved);
	}
2060 2061

	return nr_moved;
2062
}
2063

H
Hugh Dickins 已提交
2064
static void shrink_active_list(unsigned long nr_to_scan,
2065
			       struct lruvec *lruvec,
2066
			       struct scan_control *sc,
2067
			       enum lru_list lru)
L
Linus Torvalds 已提交
2068
{
2069
	unsigned long nr_taken;
H
Hugh Dickins 已提交
2070
	unsigned long nr_scanned;
2071
	unsigned long vm_flags;
L
Linus Torvalds 已提交
2072
	LIST_HEAD(l_hold);	/* The pages which were snipped off */
2073
	LIST_HEAD(l_active);
2074
	LIST_HEAD(l_inactive);
L
Linus Torvalds 已提交
2075
	struct page *page;
2076
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
2077 2078
	unsigned nr_deactivate, nr_activate;
	unsigned nr_rotated = 0;
2079
	isolate_mode_t isolate_mode = 0;
2080
	int file = is_file_lru(lru);
M
Mel Gorman 已提交
2081
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
L
Linus Torvalds 已提交
2082 2083

	lru_add_drain();
2084 2085

	if (!sc->may_unmap)
2086
		isolate_mode |= ISOLATE_UNMAPPED;
2087

M
Mel Gorman 已提交
2088
	spin_lock_irq(&pgdat->lru_lock);
2089

2090 2091
	nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &l_hold,
				     &nr_scanned, sc, isolate_mode, lru);
2092

M
Mel Gorman 已提交
2093
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, nr_taken);
2094
	reclaim_stat->recent_scanned[file] += nr_taken;
2095

M
Mel Gorman 已提交
2096
	__count_vm_events(PGREFILL, nr_scanned);
2097
	count_memcg_events(lruvec_memcg(lruvec), PGREFILL, nr_scanned);
2098

M
Mel Gorman 已提交
2099
	spin_unlock_irq(&pgdat->lru_lock);
L
Linus Torvalds 已提交
2100 2101 2102 2103 2104

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

2106
		if (unlikely(!page_evictable(page))) {
L
Lee Schermerhorn 已提交
2107 2108 2109 2110
			putback_lru_page(page);
			continue;
		}

2111 2112 2113 2114 2115 2116 2117 2118
		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);
			}
		}

2119 2120
		if (page_referenced(page, 0, sc->target_mem_cgroup,
				    &vm_flags)) {
2121
			nr_rotated += hpage_nr_pages(page);
2122 2123 2124 2125 2126 2127 2128 2129 2130
			/*
			 * 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.
			 */
2131
			if ((vm_flags & VM_EXEC) && page_is_file_cache(page)) {
2132 2133 2134 2135
				list_add(&page->lru, &l_active);
				continue;
			}
		}
2136

2137
		ClearPageActive(page);	/* we are de-activating */
L
Linus Torvalds 已提交
2138 2139 2140
		list_add(&page->lru, &l_inactive);
	}

2141
	/*
2142
	 * Move pages back to the lru list.
2143
	 */
M
Mel Gorman 已提交
2144
	spin_lock_irq(&pgdat->lru_lock);
2145
	/*
2146 2147 2148
	 * 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
2149
	 * get_scan_count.
2150
	 */
2151
	reclaim_stat->recent_rotated[file] += nr_rotated;
2152

2153 2154
	nr_activate = move_active_pages_to_lru(lruvec, &l_active, &l_hold, lru);
	nr_deactivate = move_active_pages_to_lru(lruvec, &l_inactive, &l_hold, lru - LRU_ACTIVE);
M
Mel Gorman 已提交
2155 2156
	__mod_node_page_state(pgdat, NR_ISOLATED_ANON + file, -nr_taken);
	spin_unlock_irq(&pgdat->lru_lock);
2157

2158
	mem_cgroup_uncharge_list(&l_hold);
2159
	free_unref_page_list(&l_hold);
2160 2161
	trace_mm_vmscan_lru_shrink_active(pgdat->node_id, nr_taken, nr_activate,
			nr_deactivate, nr_rotated, sc->priority, file);
L
Linus Torvalds 已提交
2162 2163
}

2164 2165 2166
/*
 * The inactive anon list should be small enough that the VM never has
 * to do too much work.
2167
 *
2168 2169 2170
 * 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.
2171
 *
2172 2173
 * Both inactive lists should also be large enough that each inactive
 * page has a chance to be referenced again before it is reclaimed.
2174
 *
2175 2176
 * If that fails and refaulting is observed, the inactive list grows.
 *
2177
 * The inactive_ratio is the target ratio of ACTIVE to INACTIVE pages
2178
 * on this LRU, maintained by the pageout code. An inactive_ratio
2179
 * of 3 means 3:1 or 25% of the pages are kept on the inactive list.
2180
 *
2181 2182 2183 2184 2185 2186 2187 2188 2189 2190
 * 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
2191
 */
2192
static bool inactive_list_is_low(struct lruvec *lruvec, bool file,
2193
				 struct scan_control *sc, bool actual_reclaim)
2194
{
2195
	enum lru_list active_lru = file * LRU_FILE + LRU_ACTIVE;
2196 2197 2198 2199 2200
	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;
2201
	unsigned long gb;
2202

2203 2204 2205 2206 2207 2208
	/*
	 * If we don't have swap space, anonymous page deactivation
	 * is pointless.
	 */
	if (!file && !total_swap_pages)
		return false;
2209

2210 2211
	inactive = lruvec_lru_size(lruvec, inactive_lru, sc->reclaim_idx);
	active = lruvec_lru_size(lruvec, active_lru, sc->reclaim_idx);
2212

2213 2214 2215 2216 2217
	/*
	 * 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.
	 */
2218
	refaults = lruvec_page_state(lruvec, WORKINGSET_ACTIVATE);
2219 2220 2221 2222 2223 2224 2225 2226 2227
	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;
	}
2228

2229 2230 2231 2232 2233
	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);
2234

2235
	return inactive * inactive_ratio < active;
2236 2237
}

2238
static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
2239
				 struct lruvec *lruvec, struct scan_control *sc)
2240
{
2241
	if (is_active_lru(lru)) {
2242
		if (inactive_list_is_low(lruvec, is_file_lru(lru), sc, true))
2243
			shrink_active_list(nr_to_scan, lruvec, sc, lru);
2244 2245 2246
		return 0;
	}

2247
	return shrink_inactive_list(nr_to_scan, lruvec, sc, lru);
2248 2249
}

2250 2251 2252 2253 2254 2255 2256
enum scan_balance {
	SCAN_EQUAL,
	SCAN_FRACT,
	SCAN_ANON,
	SCAN_FILE,
};

2257 2258 2259 2260 2261 2262
/*
 * Determine how aggressively the anon and file LRU lists should be
 * scanned.  The relative value of each set of LRU lists is determined
 * by looking at the fraction of the pages scanned we did rotate back
 * onto the active list instead of evict.
 *
W
Wanpeng Li 已提交
2263 2264
 * 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
2265
 */
2266
static void get_scan_count(struct lruvec *lruvec, struct mem_cgroup *memcg,
2267 2268
			   struct scan_control *sc, unsigned long *nr,
			   unsigned long *lru_pages)
2269
{
2270
	int swappiness = mem_cgroup_swappiness(memcg);
2271 2272 2273
	struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
	u64 fraction[2];
	u64 denominator = 0;	/* gcc */
M
Mel Gorman 已提交
2274
	struct pglist_data *pgdat = lruvec_pgdat(lruvec);
2275
	unsigned long anon_prio, file_prio;
2276
	enum scan_balance scan_balance;
2277
	unsigned long anon, file;
2278
	unsigned long ap, fp;
H
Hugh Dickins 已提交
2279
	enum lru_list lru;
2280 2281

	/* If we have no swap space, do not bother scanning anon pages. */
2282
	if (!sc->may_swap || mem_cgroup_get_nr_swap_pages(memcg) <= 0) {
2283
		scan_balance = SCAN_FILE;
2284 2285
		goto out;
	}
2286

2287 2288 2289 2290 2291 2292 2293
	/*
	 * 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.
	 */
2294
	if (!global_reclaim(sc) && !swappiness) {
2295
		scan_balance = SCAN_FILE;
2296 2297 2298 2299 2300 2301 2302 2303
		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).
	 */
2304
	if (!sc->priority && swappiness) {
2305
		scan_balance = SCAN_EQUAL;
2306 2307 2308
		goto out;
	}

2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
	/*
	 * Prevent the reclaimer from falling into the cache trap: as
	 * cache pages start out inactive, every cache fault will tip
	 * the scan balance towards the file LRU.  And as the file LRU
	 * shrinks, so does the window for rotation from references.
	 * This means we have a runaway feedback loop where a tiny
	 * thrashing file LRU becomes infinitely more attractive than
	 * anon pages.  Try to detect this based on file LRU size.
	 */
	if (global_reclaim(sc)) {
M
Mel Gorman 已提交
2319 2320 2321 2322
		unsigned long pgdatfile;
		unsigned long pgdatfree;
		int z;
		unsigned long total_high_wmark = 0;
2323

M
Mel Gorman 已提交
2324 2325 2326 2327 2328 2329
		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];
2330
			if (!managed_zone(zone))
M
Mel Gorman 已提交
2331 2332 2333 2334
				continue;

			total_high_wmark += high_wmark_pages(zone);
		}
2335

M
Mel Gorman 已提交
2336
		if (unlikely(pgdatfile + pgdatfree <= total_high_wmark)) {
2337 2338 2339 2340 2341
			/*
			 * Force SCAN_ANON if there are enough inactive
			 * anonymous pages on the LRU in eligible zones.
			 * Otherwise, the small LRU gets thrashed.
			 */
2342
			if (!inactive_list_is_low(lruvec, false, sc, false) &&
2343 2344 2345 2346 2347
			    lruvec_lru_size(lruvec, LRU_INACTIVE_ANON, sc->reclaim_idx)
					>> sc->priority) {
				scan_balance = SCAN_ANON;
				goto out;
			}
2348 2349 2350
		}
	}

2351
	/*
2352 2353 2354 2355 2356 2357 2358
	 * 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.
2359
	 */
2360
	if (!inactive_list_is_low(lruvec, true, sc, false) &&
2361
	    lruvec_lru_size(lruvec, LRU_INACTIVE_FILE, sc->reclaim_idx) >> sc->priority) {
2362
		scan_balance = SCAN_FILE;
2363 2364 2365
		goto out;
	}

2366 2367
	scan_balance = SCAN_FRACT;

2368 2369 2370 2371
	/*
	 * With swappiness at 100, anonymous and file have the same priority.
	 * This scanning priority is essentially the inverse of IO cost.
	 */
2372
	anon_prio = swappiness;
H
Hugh Dickins 已提交
2373
	file_prio = 200 - anon_prio;
2374

2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
	/*
	 * 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]
	 */
2386

2387 2388 2389 2390
	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);
2391

M
Mel Gorman 已提交
2392
	spin_lock_irq(&pgdat->lru_lock);
2393 2394 2395
	if (unlikely(reclaim_stat->recent_scanned[0] > anon / 4)) {
		reclaim_stat->recent_scanned[0] /= 2;
		reclaim_stat->recent_rotated[0] /= 2;
2396 2397
	}

2398 2399 2400
	if (unlikely(reclaim_stat->recent_scanned[1] > file / 4)) {
		reclaim_stat->recent_scanned[1] /= 2;
		reclaim_stat->recent_rotated[1] /= 2;
2401 2402 2403
	}

	/*
2404 2405 2406
	 * 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.
2407
	 */
2408
	ap = anon_prio * (reclaim_stat->recent_scanned[0] + 1);
2409
	ap /= reclaim_stat->recent_rotated[0] + 1;
2410

2411
	fp = file_prio * (reclaim_stat->recent_scanned[1] + 1);
2412
	fp /= reclaim_stat->recent_rotated[1] + 1;
M
Mel Gorman 已提交
2413
	spin_unlock_irq(&pgdat->lru_lock);
2414

2415 2416 2417 2418
	fraction[0] = ap;
	fraction[1] = fp;
	denominator = ap + fp + 1;
out:
2419 2420 2421 2422 2423
	*lru_pages = 0;
	for_each_evictable_lru(lru) {
		int file = is_file_lru(lru);
		unsigned long size;
		unsigned long scan;
2424

2425 2426 2427 2428 2429 2430 2431 2432
		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);
2433

2434 2435 2436 2437 2438
		switch (scan_balance) {
		case SCAN_EQUAL:
			/* Scan lists relative to size */
			break;
		case SCAN_FRACT:
2439
			/*
2440 2441
			 * Scan types proportional to swappiness and
			 * their relative recent reclaim efficiency.
2442 2443
			 * Make sure we don't miss the last page
			 * because of a round-off error.
2444
			 */
2445 2446
			scan = DIV64_U64_ROUND_UP(scan * fraction[file],
						  denominator);
2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
			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();
2459
		}
2460 2461 2462

		*lru_pages += size;
		nr[lru] = scan;
2463
	}
2464
}
2465

2466
/*
2467
 * This is a basic per-node page freer.  Used by both kswapd and direct reclaim.
2468
 */
2469
static void shrink_node_memcg(struct pglist_data *pgdat, struct mem_cgroup *memcg,
2470
			      struct scan_control *sc, unsigned long *lru_pages)
2471
{
2472
	struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
2473
	unsigned long nr[NR_LRU_LISTS];
2474
	unsigned long targets[NR_LRU_LISTS];
2475 2476 2477 2478 2479
	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;
2480
	bool scan_adjusted;
2481

2482
	get_scan_count(lruvec, memcg, sc, nr, lru_pages);
2483

2484 2485 2486
	/* Record the original scan target for proportional adjustments later */
	memcpy(targets, nr, sizeof(nr));

2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500
	/*
	 * 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);

2501 2502 2503
	blk_start_plug(&plug);
	while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
					nr[LRU_INACTIVE_FILE]) {
2504 2505 2506
		unsigned long nr_anon, nr_file, percentage;
		unsigned long nr_scanned;

2507 2508 2509 2510 2511 2512
		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,
2513
							    lruvec, sc);
2514 2515
			}
		}
2516

2517 2518
		cond_resched();

2519 2520 2521 2522 2523
		if (nr_reclaimed < nr_to_reclaim || scan_adjusted)
			continue;

		/*
		 * For kswapd and memcg, reclaim at least the number of pages
2524
		 * requested. Ensure that the anon and file LRUs are scanned
2525 2526 2527 2528 2529 2530 2531
		 * 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];

2532 2533 2534 2535 2536 2537 2538 2539 2540
		/*
		 * 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;

2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571
		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;
2572 2573 2574 2575 2576 2577 2578 2579
	}
	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.
	 */
2580
	if (inactive_list_is_low(lruvec, false, sc, true))
2581 2582 2583 2584
		shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
				   sc, LRU_ACTIVE_ANON);
}

M
Mel Gorman 已提交
2585
/* Use reclaim/compaction for costly allocs or under memory pressure */
2586
static bool in_reclaim_compaction(struct scan_control *sc)
M
Mel Gorman 已提交
2587
{
2588
	if (IS_ENABLED(CONFIG_COMPACTION) && sc->order &&
M
Mel Gorman 已提交
2589
			(sc->order > PAGE_ALLOC_COSTLY_ORDER ||
2590
			 sc->priority < DEF_PRIORITY - 2))
M
Mel Gorman 已提交
2591 2592 2593 2594 2595
		return true;

	return false;
}

2596
/*
M
Mel Gorman 已提交
2597 2598 2599 2600 2601
 * 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.
2602
 */
2603
static inline bool should_continue_reclaim(struct pglist_data *pgdat,
2604 2605 2606 2607 2608 2609
					unsigned long nr_reclaimed,
					unsigned long nr_scanned,
					struct scan_control *sc)
{
	unsigned long pages_for_compaction;
	unsigned long inactive_lru_pages;
2610
	int z;
2611 2612

	/* If not in reclaim/compaction mode, stop */
2613
	if (!in_reclaim_compaction(sc))
2614 2615
		return false;

2616
	/* Consider stopping depending on scan and reclaim activity */
2617
	if (sc->gfp_mask & __GFP_RETRY_MAYFAIL) {
2618
		/*
2619
		 * For __GFP_RETRY_MAYFAIL allocations, stop reclaiming if the
2620 2621
		 * full LRU list has been scanned and we are still failing
		 * to reclaim pages. This full LRU scan is potentially
2622
		 * expensive but a __GFP_RETRY_MAYFAIL caller really wants to succeed
2623 2624 2625 2626 2627
		 */
		if (!nr_reclaimed && !nr_scanned)
			return false;
	} else {
		/*
2628
		 * For non-__GFP_RETRY_MAYFAIL allocations which can presumably
2629 2630 2631 2632 2633 2634 2635 2636 2637
		 * 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;
	}
2638 2639 2640 2641 2642

	/*
	 * If we have not reclaimed enough pages for compaction and the
	 * inactive lists are large enough, continue reclaiming
	 */
2643
	pages_for_compaction = compact_gap(sc->order);
2644
	inactive_lru_pages = node_page_state(pgdat, NR_INACTIVE_FILE);
2645
	if (get_nr_swap_pages() > 0)
2646
		inactive_lru_pages += node_page_state(pgdat, NR_INACTIVE_ANON);
2647 2648 2649 2650 2651
	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 */
2652 2653
	for (z = 0; z <= sc->reclaim_idx; z++) {
		struct zone *zone = &pgdat->node_zones[z];
2654
		if (!managed_zone(zone))
2655 2656 2657
			continue;

		switch (compaction_suitable(zone, sc->order, 0, sc->reclaim_idx)) {
2658
		case COMPACT_SUCCESS:
2659 2660 2661 2662 2663 2664
		case COMPACT_CONTINUE:
			return false;
		default:
			/* check next zone */
			;
		}
2665
	}
2666
	return true;
2667 2668
}

2669 2670 2671 2672 2673 2674
static bool pgdat_memcg_congested(pg_data_t *pgdat, struct mem_cgroup *memcg)
{
	return test_bit(PGDAT_CONGESTED, &pgdat->flags) ||
		(memcg && memcg_congested(pgdat, memcg));
}

2675
static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc)
L
Linus Torvalds 已提交
2676
{
2677
	struct reclaim_state *reclaim_state = current->reclaim_state;
2678
	unsigned long nr_reclaimed, nr_scanned;
2679
	bool reclaimable = false;
L
Linus Torvalds 已提交
2680

2681 2682 2683
	do {
		struct mem_cgroup *root = sc->target_mem_cgroup;
		struct mem_cgroup_reclaim_cookie reclaim = {
2684
			.pgdat = pgdat,
2685 2686
			.priority = sc->priority,
		};
2687
		unsigned long node_lru_pages = 0;
2688
		struct mem_cgroup *memcg;
2689

2690 2691
		memset(&sc->nr, 0, sizeof(sc->nr));

2692 2693
		nr_reclaimed = sc->nr_reclaimed;
		nr_scanned = sc->nr_scanned;
L
Linus Torvalds 已提交
2694

2695 2696
		memcg = mem_cgroup_iter(root, NULL, &reclaim);
		do {
2697
			unsigned long lru_pages;
2698
			unsigned long reclaimed;
2699
			unsigned long scanned;
2700

R
Roman Gushchin 已提交
2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714
			switch (mem_cgroup_protected(root, memcg)) {
			case MEMCG_PROT_MIN:
				/*
				 * Hard protection.
				 * If there is no reclaimable memory, OOM.
				 */
				continue;
			case MEMCG_PROT_LOW:
				/*
				 * Soft protection.
				 * Respect the protection only as long as
				 * there is an unprotected supply
				 * of reclaimable memory from other cgroups.
				 */
2715 2716
				if (!sc->memcg_low_reclaim) {
					sc->memcg_low_skipped = 1;
2717
					continue;
2718
				}
2719
				memcg_memory_event(memcg, MEMCG_LOW);
R
Roman Gushchin 已提交
2720 2721 2722
				break;
			case MEMCG_PROT_NONE:
				break;
2723 2724
			}

2725
			reclaimed = sc->nr_reclaimed;
2726
			scanned = sc->nr_scanned;
2727 2728
			shrink_node_memcg(pgdat, memcg, sc, &lru_pages);
			node_lru_pages += lru_pages;
2729

2730 2731
			shrink_slab(sc->gfp_mask, pgdat->node_id,
				    memcg, sc->priority);
2732

2733 2734 2735 2736 2737
			/* Record the group's reclaim efficiency */
			vmpressure(sc->gfp_mask, memcg, false,
				   sc->nr_scanned - scanned,
				   sc->nr_reclaimed - reclaimed);

2738
			/*
2739 2740
			 * Direct reclaim and kswapd have to scan all memory
			 * cgroups to fulfill the overall scan target for the
2741
			 * node.
2742 2743 2744 2745 2746
			 *
			 * 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.
2747
			 */
2748 2749
			if (!global_reclaim(sc) &&
					sc->nr_reclaimed >= sc->nr_to_reclaim) {
2750 2751 2752
				mem_cgroup_iter_break(root, memcg);
				break;
			}
2753
		} while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));
2754

2755 2756 2757
		if (reclaim_state) {
			sc->nr_reclaimed += reclaim_state->reclaimed_slab;
			reclaim_state->reclaimed_slab = 0;
2758 2759
		}

2760 2761
		/* Record the subtree's reclaim efficiency */
		vmpressure(sc->gfp_mask, sc->target_mem_cgroup, true,
2762 2763 2764
			   sc->nr_scanned - nr_scanned,
			   sc->nr_reclaimed - nr_reclaimed);

2765 2766 2767
		if (sc->nr_reclaimed - nr_reclaimed)
			reclaimable = true;

2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787
		if (current_is_kswapd()) {
			/*
			 * If reclaim is isolating dirty pages under writeback,
			 * it implies that the long-lived page allocation rate
			 * is exceeding the page laundering rate. Either the
			 * global limits are not being effective at throttling
			 * processes due to the page distribution throughout
			 * zones or there is heavy usage of a slow backing
			 * device. The only option is to throttle from reclaim
			 * context which is not ideal as there is no guarantee
			 * the dirtying process is throttled in the same way
			 * balance_dirty_pages() manages.
			 *
			 * Once a node is flagged PGDAT_WRITEBACK, kswapd will
			 * count the number of pages under pages flagged for
			 * immediate reclaim and stall if any are encountered
			 * in the nr_immediate check below.
			 */
			if (sc->nr.writeback && sc->nr.writeback == sc->nr.taken)
				set_bit(PGDAT_WRITEBACK, &pgdat->flags);
2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810

			/*
			 * Tag a node as congested if all the dirty pages
			 * scanned were backed by a congested BDI and
			 * wait_iff_congested will stall.
			 */
			if (sc->nr.dirty && sc->nr.dirty == sc->nr.congested)
				set_bit(PGDAT_CONGESTED, &pgdat->flags);

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

			/*
			 * If kswapd scans pages marked marked for immediate
			 * reclaim and under writeback (nr_immediate), it
			 * implies that pages are cycling through the LRU
			 * faster than they are written so also forcibly stall.
			 */
			if (sc->nr.immediate)
				congestion_wait(BLK_RW_ASYNC, HZ/10);
		}

2811 2812 2813 2814 2815 2816 2817 2818
		/*
		 * Legacy memcg will stall in page writeback so avoid forcibly
		 * stalling in wait_iff_congested().
		 */
		if (!global_reclaim(sc) && sane_reclaim(sc) &&
		    sc->nr.dirty && sc->nr.dirty == sc->nr.congested)
			set_memcg_congestion(pgdat, root, true);

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

2829
	} while (should_continue_reclaim(pgdat, sc->nr_reclaimed - nr_reclaimed,
2830
					 sc->nr_scanned - nr_scanned, sc));
2831

2832 2833 2834 2835 2836 2837 2838 2839 2840
	/*
	 * 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;

2841
	return reclaimable;
2842 2843
}

2844
/*
2845 2846 2847
 * 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.
2848
 */
2849
static inline bool compaction_ready(struct zone *zone, struct scan_control *sc)
2850
{
M
Mel Gorman 已提交
2851
	unsigned long watermark;
2852
	enum compact_result suitable;
2853

2854 2855 2856 2857 2858 2859 2860
	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;
2861

2862
	/*
2863 2864 2865 2866 2867 2868 2869
	 * 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.
2870
	 */
2871
	watermark = high_wmark_pages(zone) + compact_gap(sc->order);
2872

2873
	return zone_watermark_ok_safe(zone, 0, watermark, sc->reclaim_idx);
2874 2875
}

L
Linus Torvalds 已提交
2876 2877 2878 2879 2880 2881 2882 2883
/*
 * This is the direct reclaim path, for page-allocating processes.  We only
 * try to reclaim pages from zones which will satisfy the caller's allocation
 * request.
 *
 * If a zone is deemed to be full of pinned pages then just give it a light
 * scan then give up on it.
 */
M
Michal Hocko 已提交
2884
static void shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
L
Linus Torvalds 已提交
2885
{
2886
	struct zoneref *z;
2887
	struct zone *zone;
2888 2889
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
2890
	gfp_t orig_mask;
2891
	pg_data_t *last_pgdat = NULL;
2892

2893 2894 2895 2896 2897
	/*
	 * 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
	 */
2898
	orig_mask = sc->gfp_mask;
2899
	if (buffer_heads_over_limit) {
2900
		sc->gfp_mask |= __GFP_HIGHMEM;
2901
		sc->reclaim_idx = gfp_zone(sc->gfp_mask);
2902
	}
2903

2904
	for_each_zone_zonelist_nodemask(zone, z, zonelist,
2905
					sc->reclaim_idx, sc->nodemask) {
2906 2907 2908 2909
		/*
		 * Take care memory controller reclaiming has small influence
		 * to global LRU.
		 */
2910
		if (global_reclaim(sc)) {
2911 2912
			if (!cpuset_zone_allowed(zone,
						 GFP_KERNEL | __GFP_HARDWALL))
2913
				continue;
2914

2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925
			/*
			 * 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 &&
2926
			    compaction_ready(zone, sc)) {
2927 2928
				sc->compaction_ready = true;
				continue;
2929
			}
2930

2931 2932 2933 2934 2935 2936 2937 2938 2939
			/*
			 * 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;

2940 2941 2942 2943 2944 2945 2946
			/*
			 * 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;
2947
			nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone->zone_pgdat,
2948 2949 2950 2951
						sc->order, sc->gfp_mask,
						&nr_soft_scanned);
			sc->nr_reclaimed += nr_soft_reclaimed;
			sc->nr_scanned += nr_soft_scanned;
2952
			/* need some check for avoid more shrink_zone() */
2953
		}
2954

2955 2956 2957 2958
		/* See comment about same check for global reclaim above */
		if (zone->zone_pgdat == last_pgdat)
			continue;
		last_pgdat = zone->zone_pgdat;
2959
		shrink_node(zone->zone_pgdat, sc);
L
Linus Torvalds 已提交
2960
	}
2961

2962 2963 2964 2965 2966
	/*
	 * Restore to original mask to avoid the impact on the caller if we
	 * promoted it to __GFP_HIGHMEM.
	 */
	sc->gfp_mask = orig_mask;
L
Linus Torvalds 已提交
2967
}
2968

2969 2970 2971 2972 2973 2974 2975 2976 2977 2978
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;

		lruvec = mem_cgroup_lruvec(pgdat, memcg);
2979
		refaults = lruvec_page_state(lruvec, WORKINGSET_ACTIVATE);
2980 2981 2982 2983
		lruvec->refaults = refaults;
	} while ((memcg = mem_cgroup_iter(root_memcg, memcg, NULL)));
}

L
Linus Torvalds 已提交
2984 2985 2986 2987 2988 2989 2990 2991
/*
 * 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
2992 2993 2994 2995
 * 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.
2996 2997 2998
 *
 * returns:	0, if no pages reclaimed
 * 		else, the number of pages reclaimed
L
Linus Torvalds 已提交
2999
 */
3000
static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
3001
					  struct scan_control *sc)
L
Linus Torvalds 已提交
3002
{
3003
	int initial_priority = sc->priority;
3004 3005 3006
	pg_data_t *last_pgdat;
	struct zoneref *z;
	struct zone *zone;
3007
retry:
3008 3009
	delayacct_freepages_start();

3010
	if (global_reclaim(sc))
3011
		__count_zid_vm_events(ALLOCSTALL, sc->reclaim_idx, 1);
L
Linus Torvalds 已提交
3012

3013
	do {
3014 3015
		vmpressure_prio(sc->gfp_mask, sc->target_mem_cgroup,
				sc->priority);
3016
		sc->nr_scanned = 0;
M
Michal Hocko 已提交
3017
		shrink_zones(zonelist, sc);
3018

3019
		if (sc->nr_reclaimed >= sc->nr_to_reclaim)
3020 3021 3022 3023
			break;

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

3025 3026 3027 3028 3029 3030
		/*
		 * If we're getting trouble reclaiming, start doing
		 * writepage even in laptop mode.
		 */
		if (sc->priority < DEF_PRIORITY - 2)
			sc->may_writepage = 1;
3031
	} while (--sc->priority >= 0);
3032

3033 3034 3035 3036 3037 3038 3039
	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);
3040
		set_memcg_congestion(last_pgdat, sc->target_mem_cgroup, false);
3041 3042
	}

3043 3044
	delayacct_freepages_end();

3045 3046 3047
	if (sc->nr_reclaimed)
		return sc->nr_reclaimed;

3048
	/* Aborted reclaim to try compaction? don't OOM, then */
3049
	if (sc->compaction_ready)
3050 3051
		return 1;

3052
	/* Untapped cgroup reserves?  Don't OOM, retry. */
3053
	if (sc->memcg_low_skipped) {
3054
		sc->priority = initial_priority;
3055 3056
		sc->memcg_low_reclaim = 1;
		sc->memcg_low_skipped = 0;
3057 3058 3059
		goto retry;
	}

3060
	return 0;
L
Linus Torvalds 已提交
3061 3062
}

3063
static bool allow_direct_reclaim(pg_data_t *pgdat)
3064 3065 3066 3067 3068 3069 3070
{
	struct zone *zone;
	unsigned long pfmemalloc_reserve = 0;
	unsigned long free_pages = 0;
	int i;
	bool wmark_ok;

3071 3072 3073
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

3074 3075
	for (i = 0; i <= ZONE_NORMAL; i++) {
		zone = &pgdat->node_zones[i];
3076 3077 3078 3079
		if (!managed_zone(zone))
			continue;

		if (!zone_reclaimable_pages(zone))
3080 3081
			continue;

3082 3083 3084 3085
		pfmemalloc_reserve += min_wmark_pages(zone);
		free_pages += zone_page_state(zone, NR_FREE_PAGES);
	}

3086 3087 3088 3089
	/* If there are no reserves (unexpected config) then do not throttle */
	if (!pfmemalloc_reserve)
		return true;

3090 3091 3092 3093
	wmark_ok = free_pages > pfmemalloc_reserve / 2;

	/* kswapd must be awake if processes are being throttled */
	if (!wmark_ok && waitqueue_active(&pgdat->kswapd_wait)) {
3094
		pgdat->kswapd_classzone_idx = min(pgdat->kswapd_classzone_idx,
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
						(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
3106 3107 3108 3109
 * 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.
3110
 */
3111
static bool throttle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
3112 3113
					nodemask_t *nodemask)
{
3114
	struct zoneref *z;
3115
	struct zone *zone;
3116
	pg_data_t *pgdat = NULL;
3117 3118 3119 3120 3121 3122 3123 3124 3125

	/*
	 * 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)
3126 3127 3128 3129 3130 3131 3132 3133
		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;
3134

3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149
	/*
	 * 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,
3150
					gfp_zone(gfp_mask), nodemask) {
3151 3152 3153 3154 3155
		if (zone_idx(zone) > ZONE_NORMAL)
			continue;

		/* Throttle based on the first usable node */
		pgdat = zone->zone_pgdat;
3156
		if (allow_direct_reclaim(pgdat))
3157 3158 3159 3160 3161 3162
			goto out;
		break;
	}

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

3165 3166 3167
	/* Account for the throttling */
	count_vm_event(PGSCAN_DIRECT_THROTTLE);

3168 3169 3170 3171 3172 3173 3174 3175 3176 3177
	/*
	 * 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,
3178
			allow_direct_reclaim(pgdat), HZ);
3179 3180

		goto check_pending;
3181 3182 3183 3184
	}

	/* Throttle until kswapd wakes the process */
	wait_event_killable(zone->zone_pgdat->pfmemalloc_wait,
3185
		allow_direct_reclaim(pgdat));
3186 3187 3188 3189 3190 3191 3192

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

out:
	return false;
3193 3194
}

3195
unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
3196
				gfp_t gfp_mask, nodemask_t *nodemask)
3197
{
3198
	unsigned long nr_reclaimed;
3199
	struct scan_control sc = {
3200
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
3201
		.gfp_mask = current_gfp_context(gfp_mask),
3202
		.reclaim_idx = gfp_zone(gfp_mask),
3203 3204 3205
		.order = order,
		.nodemask = nodemask,
		.priority = DEF_PRIORITY,
3206
		.may_writepage = !laptop_mode,
3207
		.may_unmap = 1,
3208
		.may_swap = 1,
3209 3210
	};

G
Greg Thelen 已提交
3211 3212 3213 3214 3215 3216 3217 3218
	/*
	 * scan_control uses s8 fields for order, priority, and reclaim_idx.
	 * Confirm they are large enough for max values.
	 */
	BUILD_BUG_ON(MAX_ORDER > S8_MAX);
	BUILD_BUG_ON(DEF_PRIORITY > S8_MAX);
	BUILD_BUG_ON(MAX_NR_ZONES > S8_MAX);

3219
	/*
3220 3221 3222
	 * 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.
3223
	 */
3224
	if (throttle_direct_reclaim(sc.gfp_mask, zonelist, nodemask))
3225 3226
		return 1;

3227 3228
	trace_mm_vmscan_direct_reclaim_begin(order,
				sc.may_writepage,
3229
				sc.gfp_mask,
3230
				sc.reclaim_idx);
3231

3232
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3233 3234 3235 3236

	trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3237 3238
}

A
Andrew Morton 已提交
3239
#ifdef CONFIG_MEMCG
3240

3241
unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
3242
						gfp_t gfp_mask, bool noswap,
3243
						pg_data_t *pgdat,
3244
						unsigned long *nr_scanned)
3245 3246
{
	struct scan_control sc = {
3247
		.nr_to_reclaim = SWAP_CLUSTER_MAX,
3248
		.target_mem_cgroup = memcg,
3249 3250
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3251
		.reclaim_idx = MAX_NR_ZONES - 1,
3252 3253
		.may_swap = !noswap,
	};
3254
	unsigned long lru_pages;
3255

3256 3257
	sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
			(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
3258

3259
	trace_mm_vmscan_memcg_softlimit_reclaim_begin(sc.order,
3260
						      sc.may_writepage,
3261 3262
						      sc.gfp_mask,
						      sc.reclaim_idx);
3263

3264 3265 3266
	/*
	 * NOTE: Although we can get the priority field, using it
	 * here is not a good idea, since it limits the pages we can scan.
3267
	 * if we don't reclaim here, the shrink_node from balance_pgdat
3268 3269 3270
	 * will pick up pages from other mem cgroup's as well. We hack
	 * the priority and make it zero.
	 */
3271
	shrink_node_memcg(pgdat, memcg, &sc, &lru_pages);
3272 3273 3274

	trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);

3275
	*nr_scanned = sc.nr_scanned;
3276 3277 3278
	return sc.nr_reclaimed;
}

3279
unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
3280
					   unsigned long nr_pages,
K
KOSAKI Motohiro 已提交
3281
					   gfp_t gfp_mask,
3282
					   bool may_swap)
3283
{
3284
	struct zonelist *zonelist;
3285
	unsigned long nr_reclaimed;
3286
	int nid;
3287
	unsigned int noreclaim_flag;
3288
	struct scan_control sc = {
3289
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
3290
		.gfp_mask = (current_gfp_context(gfp_mask) & GFP_RECLAIM_MASK) |
3291
				(GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
3292
		.reclaim_idx = MAX_NR_ZONES - 1,
3293 3294 3295 3296
		.target_mem_cgroup = memcg,
		.priority = DEF_PRIORITY,
		.may_writepage = !laptop_mode,
		.may_unmap = 1,
3297
		.may_swap = may_swap,
3298
	};
3299

3300 3301 3302 3303 3304
	/*
	 * 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.
	 */
3305
	nid = mem_cgroup_select_victim_node(memcg);
3306

3307
	zonelist = &NODE_DATA(nid)->node_zonelists[ZONELIST_FALLBACK];
3308 3309 3310

	trace_mm_vmscan_memcg_reclaim_begin(0,
					    sc.may_writepage,
3311 3312
					    sc.gfp_mask,
					    sc.reclaim_idx);
3313

3314
	noreclaim_flag = memalloc_noreclaim_save();
3315
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3316
	memalloc_noreclaim_restore(noreclaim_flag);
3317 3318 3319 3320

	trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);

	return nr_reclaimed;
3321 3322 3323
}
#endif

3324
static void age_active_anon(struct pglist_data *pgdat,
3325
				struct scan_control *sc)
3326
{
3327
	struct mem_cgroup *memcg;
3328

3329 3330 3331 3332 3333
	if (!total_swap_pages)
		return;

	memcg = mem_cgroup_iter(NULL, NULL, NULL);
	do {
3334
		struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
3335

3336
		if (inactive_list_is_low(lruvec, false, sc, true))
3337
			shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
3338
					   sc, LRU_ACTIVE_ANON);
3339 3340 3341

		memcg = mem_cgroup_iter(NULL, memcg, NULL);
	} while (memcg);
3342 3343
}

3344 3345 3346 3347 3348
/*
 * 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)
3349
{
3350 3351 3352
	int i;
	unsigned long mark = -1;
	struct zone *zone;
3353

3354 3355
	for (i = 0; i <= classzone_idx; i++) {
		zone = pgdat->node_zones + i;
3356

3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373
		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;
3374 3375
}

3376 3377 3378 3379 3380 3381 3382 3383
/* 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);
}

3384 3385 3386 3387 3388 3389
/*
 * 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
 */
3390
static bool prepare_kswapd_sleep(pg_data_t *pgdat, int order, int classzone_idx)
3391
{
3392
	/*
3393
	 * The throttled processes are normally woken up in balance_pgdat() as
3394
	 * soon as allow_direct_reclaim() is true. But there is a potential
3395 3396 3397 3398 3399 3400 3401 3402 3403
	 * 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().
3404
	 */
3405 3406
	if (waitqueue_active(&pgdat->pfmemalloc_wait))
		wake_up_all(&pgdat->pfmemalloc_wait);
3407

3408 3409 3410 3411
	/* Hopeless node, leave it to direct reclaim */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES)
		return true;

3412 3413 3414
	if (pgdat_balanced(pgdat, order, classzone_idx)) {
		clear_pgdat_congested(pgdat);
		return true;
3415 3416
	}

3417
	return false;
3418 3419
}

3420
/*
3421 3422
 * kswapd shrinks a node of pages that are at or below the highest usable
 * zone that is currently unbalanced.
3423 3424
 *
 * Returns true if kswapd scanned at least the requested number of pages to
3425 3426
 * 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.
3427
 */
3428
static bool kswapd_shrink_node(pg_data_t *pgdat,
3429
			       struct scan_control *sc)
3430
{
3431 3432
	struct zone *zone;
	int z;
3433

3434 3435
	/* Reclaim a number of pages proportional to the number of zones */
	sc->nr_to_reclaim = 0;
3436
	for (z = 0; z <= sc->reclaim_idx; z++) {
3437
		zone = pgdat->node_zones + z;
3438
		if (!managed_zone(zone))
3439
			continue;
3440

3441 3442
		sc->nr_to_reclaim += max(high_wmark_pages(zone), SWAP_CLUSTER_MAX);
	}
3443 3444

	/*
3445 3446
	 * Historically care was taken to put equal pressure on all zones but
	 * now pressure is applied based on node LRU order.
3447
	 */
3448
	shrink_node(pgdat, sc);
3449

3450
	/*
3451 3452 3453 3454 3455
	 * 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.
3456
	 */
3457
	if (sc->order && sc->nr_reclaimed >= compact_gap(sc->order))
3458
		sc->order = 0;
3459

3460
	return sc->nr_scanned >= sc->nr_to_reclaim;
3461 3462
}

L
Linus Torvalds 已提交
3463
/*
3464 3465 3466
 * For kswapd, balance_pgdat() will reclaim pages across a node from zones
 * that are eligible for use by the caller until at least one zone is
 * balanced.
L
Linus Torvalds 已提交
3467
 *
3468
 * Returns the order kswapd finished reclaiming at.
L
Linus Torvalds 已提交
3469 3470
 *
 * kswapd scans the zones in the highmem->normal->dma direction.  It skips
3471
 * zones which have free_pages > high_wmark_pages(zone), but once a zone is
3472 3473 3474
 * found to have free_pages <= high_wmark_pages(zone), any page is that zone
 * or lower is eligible for reclaim until at least one usable zone is
 * balanced.
L
Linus Torvalds 已提交
3475
 */
3476
static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
L
Linus Torvalds 已提交
3477 3478
{
	int i;
3479 3480
	unsigned long nr_soft_reclaimed;
	unsigned long nr_soft_scanned;
3481
	struct zone *zone;
3482 3483
	struct scan_control sc = {
		.gfp_mask = GFP_KERNEL,
3484
		.order = order,
3485
		.priority = DEF_PRIORITY,
3486
		.may_writepage = !laptop_mode,
3487
		.may_unmap = 1,
3488
		.may_swap = 1,
3489
	};
3490 3491 3492

	__fs_reclaim_acquire();

3493
	count_vm_event(PAGEOUTRUN);
L
Linus Torvalds 已提交
3494

3495
	do {
3496
		unsigned long nr_reclaimed = sc.nr_reclaimed;
3497
		bool raise_priority = true;
3498
		bool ret;
3499

3500
		sc.reclaim_idx = classzone_idx;
L
Linus Torvalds 已提交
3501

3502
		/*
3503 3504 3505 3506 3507 3508 3509 3510
		 * 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.
3511 3512 3513 3514
		 */
		if (buffer_heads_over_limit) {
			for (i = MAX_NR_ZONES - 1; i >= 0; i--) {
				zone = pgdat->node_zones + i;
3515
				if (!managed_zone(zone))
3516
					continue;
3517

3518
				sc.reclaim_idx = i;
A
Andrew Morton 已提交
3519
				break;
L
Linus Torvalds 已提交
3520 3521
			}
		}
3522

3523
		/*
3524 3525 3526
		 * 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.
3527
		 */
3528 3529
		if (pgdat_balanced(pgdat, sc.order, classzone_idx))
			goto out;
A
Andrew Morton 已提交
3530

3531 3532 3533 3534 3535 3536
		/*
		 * 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.
		 */
3537
		age_active_anon(pgdat, &sc);
3538

3539 3540 3541 3542
		/*
		 * If we're getting trouble reclaiming, start doing writepage
		 * even in laptop mode.
		 */
3543
		if (sc.priority < DEF_PRIORITY - 2)
3544 3545
			sc.may_writepage = 1;

3546 3547 3548
		/* Call soft limit reclaim before calling shrink_node. */
		sc.nr_scanned = 0;
		nr_soft_scanned = 0;
3549
		nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(pgdat, sc.order,
3550 3551 3552
						sc.gfp_mask, &nr_soft_scanned);
		sc.nr_reclaimed += nr_soft_reclaimed;

L
Linus Torvalds 已提交
3553
		/*
3554 3555 3556
		 * There should be no need to raise the scanning priority if
		 * enough pages are already being scanned that that high
		 * watermark would be met at 100% efficiency.
L
Linus Torvalds 已提交
3557
		 */
3558
		if (kswapd_shrink_node(pgdat, &sc))
3559
			raise_priority = false;
3560 3561 3562 3563 3564 3565 3566

		/*
		 * 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) &&
3567
				allow_direct_reclaim(pgdat))
3568
			wake_up_all(&pgdat->pfmemalloc_wait);
3569

3570
		/* Check if kswapd should be suspending */
3571 3572 3573 3574
		__fs_reclaim_release();
		ret = try_to_freeze();
		__fs_reclaim_acquire();
		if (ret || kthread_should_stop())
3575
			break;
3576

3577
		/*
3578 3579
		 * Raise priority if scanning rate is too low or there was no
		 * progress in reclaiming pages
3580
		 */
3581 3582
		nr_reclaimed = sc.nr_reclaimed - nr_reclaimed;
		if (raise_priority || !nr_reclaimed)
3583
			sc.priority--;
3584
	} while (sc.priority >= 1);
L
Linus Torvalds 已提交
3585

3586 3587 3588
	if (!sc.nr_reclaimed)
		pgdat->kswapd_failures++;

3589
out:
3590
	snapshot_refaults(NULL, pgdat);
3591
	__fs_reclaim_release();
3592
	/*
3593 3594 3595 3596
	 * 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.
3597
	 */
3598
	return sc.order;
L
Linus Torvalds 已提交
3599 3600
}

3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616
/*
 * 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);
}

3617 3618
static void kswapd_try_to_sleep(pg_data_t *pgdat, int alloc_order, int reclaim_order,
				unsigned int classzone_idx)
3619 3620 3621 3622 3623 3624 3625 3626 3627
{
	long remaining = 0;
	DEFINE_WAIT(wait);

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

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

3628 3629 3630 3631 3632 3633 3634
	/*
	 * 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.
	 */
3635
	if (prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647
		/*
		 * 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.
		 */
3648
		wakeup_kcompactd(pgdat, alloc_order, classzone_idx);
3649

3650
		remaining = schedule_timeout(HZ/10);
3651 3652 3653 3654 3655 3656 3657

		/*
		 * 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) {
3658
			pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);
3659 3660 3661
			pgdat->kswapd_order = max(pgdat->kswapd_order, reclaim_order);
		}

3662 3663 3664 3665 3666 3667 3668 3669
		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.
	 */
3670 3671
	if (!remaining &&
	    prepare_kswapd_sleep(pgdat, reclaim_order, classzone_idx)) {
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682
		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);
3683 3684 3685 3686

		if (!kthread_should_stop())
			schedule();

3687 3688 3689 3690 3691 3692 3693 3694 3695 3696
		set_pgdat_percpu_threshold(pgdat, calculate_pressure_threshold);
	} else {
		if (remaining)
			count_vm_event(KSWAPD_LOW_WMARK_HIT_QUICKLY);
		else
			count_vm_event(KSWAPD_HIGH_WMARK_HIT_QUICKLY);
	}
	finish_wait(&pgdat->kswapd_wait, &wait);
}

L
Linus Torvalds 已提交
3697 3698
/*
 * The background pageout daemon, started as a kernel thread
3699
 * from the init process.
L
Linus Torvalds 已提交
3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711
 *
 * 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)
{
3712 3713
	unsigned int alloc_order, reclaim_order;
	unsigned int classzone_idx = MAX_NR_ZONES - 1;
L
Linus Torvalds 已提交
3714 3715
	pg_data_t *pgdat = (pg_data_t*)p;
	struct task_struct *tsk = current;
3716

L
Linus Torvalds 已提交
3717 3718 3719
	struct reclaim_state reclaim_state = {
		.reclaimed_slab = 0,
	};
3720
	const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
L
Linus Torvalds 已提交
3721

R
Rusty Russell 已提交
3722
	if (!cpumask_empty(cpumask))
3723
		set_cpus_allowed_ptr(tsk, cpumask);
L
Linus Torvalds 已提交
3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737
	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).
	 */
3738
	tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
3739
	set_freezable();
L
Linus Torvalds 已提交
3740

3741 3742
	pgdat->kswapd_order = 0;
	pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
L
Linus Torvalds 已提交
3743
	for ( ; ; ) {
3744
		bool ret;
3745

3746 3747 3748
		alloc_order = reclaim_order = pgdat->kswapd_order;
		classzone_idx = kswapd_classzone_idx(pgdat, classzone_idx);

3749 3750 3751
kswapd_try_sleep:
		kswapd_try_to_sleep(pgdat, alloc_order, reclaim_order,
					classzone_idx);
3752

3753 3754
		/* Read the new order and classzone_idx */
		alloc_order = reclaim_order = pgdat->kswapd_order;
3755
		classzone_idx = kswapd_classzone_idx(pgdat, 0);
3756
		pgdat->kswapd_order = 0;
3757
		pgdat->kswapd_classzone_idx = MAX_NR_ZONES;
L
Linus Torvalds 已提交
3758

3759 3760 3761 3762 3763 3764 3765 3766
		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
		 */
3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777
		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).
		 */
3778 3779
		trace_mm_vmscan_kswapd_wake(pgdat->node_id, classzone_idx,
						alloc_order);
3780 3781 3782
		reclaim_order = balance_pgdat(pgdat, alloc_order, classzone_idx);
		if (reclaim_order < alloc_order)
			goto kswapd_try_sleep;
L
Linus Torvalds 已提交
3783
	}
3784

3785
	tsk->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD);
3786
	current->reclaim_state = NULL;
3787

L
Linus Torvalds 已提交
3788 3789 3790 3791
	return 0;
}

/*
3792 3793 3794 3795 3796
 * A zone is low on free memory or too fragmented for high-order memory.  If
 * kswapd should reclaim (direct reclaim is deferred), wake it up for the zone's
 * pgdat.  It will wake up kcompactd after reclaiming memory.  If kswapd reclaim
 * has failed or is not needed, still wake up kcompactd if only compaction is
 * needed.
L
Linus Torvalds 已提交
3797
 */
3798 3799
void wakeup_kswapd(struct zone *zone, gfp_t gfp_flags, int order,
		   enum zone_type classzone_idx)
L
Linus Torvalds 已提交
3800 3801 3802
{
	pg_data_t *pgdat;

3803
	if (!managed_zone(zone))
L
Linus Torvalds 已提交
3804 3805
		return;

3806
	if (!cpuset_zone_allowed(zone, gfp_flags))
L
Linus Torvalds 已提交
3807
		return;
3808
	pgdat = zone->zone_pgdat;
3809 3810
	pgdat->kswapd_classzone_idx = kswapd_classzone_idx(pgdat,
							   classzone_idx);
3811
	pgdat->kswapd_order = max(pgdat->kswapd_order, order);
3812
	if (!waitqueue_active(&pgdat->kswapd_wait))
L
Linus Torvalds 已提交
3813
		return;
3814

3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
	/* Hopeless node, leave it to direct reclaim if possible */
	if (pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES ||
	    pgdat_balanced(pgdat, order, classzone_idx)) {
		/*
		 * There may be plenty of free memory available, but it's too
		 * fragmented for high-order allocations.  Wake up kcompactd
		 * and rely on compaction_suitable() to determine if it's
		 * needed.  If it fails, it will defer subsequent attempts to
		 * ratelimit its work.
		 */
		if (!(gfp_flags & __GFP_DIRECT_RECLAIM))
			wakeup_kcompactd(pgdat, order, classzone_idx);
3827
		return;
3828
	}
3829

3830 3831
	trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, classzone_idx, order,
				      gfp_flags);
3832
	wake_up_interruptible(&pgdat->kswapd_wait);
L
Linus Torvalds 已提交
3833 3834
}

3835
#ifdef CONFIG_HIBERNATION
L
Linus Torvalds 已提交
3836
/*
3837
 * Try to free `nr_to_reclaim' of memory, system-wide, and return the number of
3838 3839 3840 3841 3842
 * freed pages.
 *
 * Rather than trying to age LRUs the aim is to preserve the overall
 * LRU order by reclaiming preferentially
 * inactive > active > active referenced > active mapped
L
Linus Torvalds 已提交
3843
 */
3844
unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
L
Linus Torvalds 已提交
3845
{
3846 3847
	struct reclaim_state reclaim_state;
	struct scan_control sc = {
3848
		.nr_to_reclaim = nr_to_reclaim,
3849
		.gfp_mask = GFP_HIGHUSER_MOVABLE,
3850
		.reclaim_idx = MAX_NR_ZONES - 1,
3851
		.priority = DEF_PRIORITY,
3852
		.may_writepage = 1,
3853 3854
		.may_unmap = 1,
		.may_swap = 1,
3855
		.hibernation_mode = 1,
L
Linus Torvalds 已提交
3856
	};
3857
	struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
3858 3859
	struct task_struct *p = current;
	unsigned long nr_reclaimed;
3860
	unsigned int noreclaim_flag;
L
Linus Torvalds 已提交
3861

3862
	fs_reclaim_acquire(sc.gfp_mask);
3863
	noreclaim_flag = memalloc_noreclaim_save();
3864 3865
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
3866

3867
	nr_reclaimed = do_try_to_free_pages(zonelist, &sc);
3868

3869
	p->reclaim_state = NULL;
3870
	memalloc_noreclaim_restore(noreclaim_flag);
3871
	fs_reclaim_release(sc.gfp_mask);
3872

3873
	return nr_reclaimed;
L
Linus Torvalds 已提交
3874
}
3875
#endif /* CONFIG_HIBERNATION */
L
Linus Torvalds 已提交
3876 3877 3878 3879 3880

/* 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. */
3881
static int kswapd_cpu_online(unsigned int cpu)
L
Linus Torvalds 已提交
3882
{
3883
	int nid;
L
Linus Torvalds 已提交
3884

3885 3886 3887
	for_each_node_state(nid, N_MEMORY) {
		pg_data_t *pgdat = NODE_DATA(nid);
		const struct cpumask *mask;
3888

3889
		mask = cpumask_of_node(pgdat->node_id);
3890

3891 3892 3893
		if (cpumask_any_and(cpu_online_mask, mask) < nr_cpu_ids)
			/* One of our CPUs online: restore mask */
			set_cpus_allowed_ptr(pgdat->kswapd, mask);
L
Linus Torvalds 已提交
3894
	}
3895
	return 0;
L
Linus Torvalds 已提交
3896 3897
}

3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912
/*
 * 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 */
3913
		BUG_ON(system_state < SYSTEM_RUNNING);
3914 3915
		pr_err("Failed to start kswapd on node %d\n", nid);
		ret = PTR_ERR(pgdat->kswapd);
3916
		pgdat->kswapd = NULL;
3917 3918 3919 3920
	}
	return ret;
}

3921
/*
3922
 * Called by memory hotplug when all memory in a node is offlined.  Caller must
3923
 * hold mem_hotplug_begin/end().
3924 3925 3926 3927 3928
 */
void kswapd_stop(int nid)
{
	struct task_struct *kswapd = NODE_DATA(nid)->kswapd;

3929
	if (kswapd) {
3930
		kthread_stop(kswapd);
3931 3932
		NODE_DATA(nid)->kswapd = NULL;
	}
3933 3934
}

L
Linus Torvalds 已提交
3935 3936
static int __init kswapd_init(void)
{
3937
	int nid, ret;
3938

L
Linus Torvalds 已提交
3939
	swap_setup();
3940
	for_each_node_state(nid, N_MEMORY)
3941
 		kswapd_run(nid);
3942 3943 3944 3945
	ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
					"mm/vmscan:online", kswapd_cpu_online,
					NULL);
	WARN_ON(ret < 0);
L
Linus Torvalds 已提交
3946 3947 3948 3949
	return 0;
}

module_init(kswapd_init)
3950 3951 3952

#ifdef CONFIG_NUMA
/*
3953
 * Node reclaim mode
3954
 *
3955
 * If non-zero call node_reclaim when the number of free pages falls below
3956 3957
 * the watermarks.
 */
3958
int node_reclaim_mode __read_mostly;
3959

3960
#define RECLAIM_OFF 0
3961
#define RECLAIM_ZONE (1<<0)	/* Run shrink_inactive_list on the zone */
3962
#define RECLAIM_WRITE (1<<1)	/* Writeout pages during reclaim */
3963
#define RECLAIM_UNMAP (1<<2)	/* Unmap pages during reclaim */
3964

3965
/*
3966
 * Priority for NODE_RECLAIM. This determines the fraction of pages
3967 3968 3969
 * of a node considered for each zone_reclaim. 4 scans 1/16th of
 * a zone.
 */
3970
#define NODE_RECLAIM_PRIORITY 4
3971

3972
/*
3973
 * Percentage of pages in a zone that must be unmapped for node_reclaim to
3974 3975 3976 3977
 * occur.
 */
int sysctl_min_unmapped_ratio = 1;

3978 3979 3980 3981 3982 3983
/*
 * 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;

3984
static inline unsigned long node_unmapped_file_pages(struct pglist_data *pgdat)
3985
{
3986 3987 3988
	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);
3989 3990 3991 3992 3993 3994 3995 3996 3997 3998

	/*
	 * 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 */
3999
static unsigned long node_pagecache_reclaimable(struct pglist_data *pgdat)
4000
{
4001 4002
	unsigned long nr_pagecache_reclaimable;
	unsigned long delta = 0;
4003 4004

	/*
4005
	 * If RECLAIM_UNMAP is set, then all file pages are considered
4006
	 * potentially reclaimable. Otherwise, we have to worry about
4007
	 * pages like swapcache and node_unmapped_file_pages() provides
4008 4009
	 * a better estimate
	 */
4010 4011
	if (node_reclaim_mode & RECLAIM_UNMAP)
		nr_pagecache_reclaimable = node_page_state(pgdat, NR_FILE_PAGES);
4012
	else
4013
		nr_pagecache_reclaimable = node_unmapped_file_pages(pgdat);
4014 4015

	/* If we can't clean pages, remove dirty pages from consideration */
4016 4017
	if (!(node_reclaim_mode & RECLAIM_WRITE))
		delta += node_page_state(pgdat, NR_FILE_DIRTY);
4018 4019 4020 4021 4022 4023 4024 4025

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

	return nr_pagecache_reclaimable - delta;
}

4026
/*
4027
 * Try to free up some pages from this node through reclaim.
4028
 */
4029
static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
4030
{
4031
	/* Minimum pages needed in order to stay on node */
4032
	const unsigned long nr_pages = 1 << order;
4033 4034
	struct task_struct *p = current;
	struct reclaim_state reclaim_state;
4035
	unsigned int noreclaim_flag;
4036
	struct scan_control sc = {
4037
		.nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
4038
		.gfp_mask = current_gfp_context(gfp_mask),
4039
		.order = order,
4040 4041 4042
		.priority = NODE_RECLAIM_PRIORITY,
		.may_writepage = !!(node_reclaim_mode & RECLAIM_WRITE),
		.may_unmap = !!(node_reclaim_mode & RECLAIM_UNMAP),
4043
		.may_swap = 1,
4044
		.reclaim_idx = gfp_zone(gfp_mask),
4045
	};
4046 4047

	cond_resched();
4048
	fs_reclaim_acquire(sc.gfp_mask);
4049
	/*
4050
	 * We need to be able to allocate from the reserves for RECLAIM_UNMAP
4051
	 * and we also need to be able to write out pages for RECLAIM_WRITE
4052
	 * and RECLAIM_UNMAP.
4053
	 */
4054 4055
	noreclaim_flag = memalloc_noreclaim_save();
	p->flags |= PF_SWAPWRITE;
4056 4057
	reclaim_state.reclaimed_slab = 0;
	p->reclaim_state = &reclaim_state;
4058

4059
	if (node_pagecache_reclaimable(pgdat) > pgdat->min_unmapped_pages) {
4060
		/*
4061
		 * Free memory by calling shrink node with increasing
4062 4063 4064
		 * priorities until we have enough memory freed.
		 */
		do {
4065
			shrink_node(pgdat, &sc);
4066
		} while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
4067
	}
4068

4069
	p->reclaim_state = NULL;
4070 4071
	current->flags &= ~PF_SWAPWRITE;
	memalloc_noreclaim_restore(noreclaim_flag);
4072
	fs_reclaim_release(sc.gfp_mask);
4073
	return sc.nr_reclaimed >= nr_pages;
4074
}
4075

4076
int node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned int order)
4077
{
4078
	int ret;
4079 4080

	/*
4081
	 * Node reclaim reclaims unmapped file backed pages and
4082
	 * slab pages if we are over the defined limits.
4083
	 *
4084 4085
	 * A small portion of unmapped file backed pages is needed for
	 * file I/O otherwise pages read by file I/O will be immediately
4086 4087
	 * thrown out if the node is overallocated. So we do not reclaim
	 * if less than a specified percentage of the node is used by
4088
	 * unmapped file backed pages.
4089
	 */
4090
	if (node_pagecache_reclaimable(pgdat) <= pgdat->min_unmapped_pages &&
4091
	    node_page_state(pgdat, NR_SLAB_RECLAIMABLE) <= pgdat->min_slab_pages)
4092
		return NODE_RECLAIM_FULL;
4093 4094

	/*
4095
	 * Do not scan if the allocation should not be delayed.
4096
	 */
4097
	if (!gfpflags_allow_blocking(gfp_mask) || (current->flags & PF_MEMALLOC))
4098
		return NODE_RECLAIM_NOSCAN;
4099 4100

	/*
4101
	 * Only run node reclaim on the local node or on nodes that do not
4102 4103 4104 4105
	 * have associated processors. This will favor the local processor
	 * over remote processors and spread off node memory allocations
	 * as wide as possible.
	 */
4106 4107
	if (node_state(pgdat->node_id, N_CPU) && pgdat->node_id != numa_node_id())
		return NODE_RECLAIM_NOSCAN;
4108

4109 4110
	if (test_and_set_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags))
		return NODE_RECLAIM_NOSCAN;
4111

4112 4113
	ret = __node_reclaim(pgdat, gfp_mask, order);
	clear_bit(PGDAT_RECLAIM_LOCKED, &pgdat->flags);
4114

4115 4116 4117
	if (!ret)
		count_vm_event(PGSCAN_ZONE_RECLAIM_FAILED);

4118
	return ret;
4119
}
4120
#endif
L
Lee Schermerhorn 已提交
4121 4122 4123 4124 4125 4126

/*
 * 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
4127
 * lists vs unevictable list.
L
Lee Schermerhorn 已提交
4128 4129
 *
 * Reasons page might not be evictable:
4130
 * (1) page's mapping marked unevictable
N
Nick Piggin 已提交
4131
 * (2) page is part of an mlocked VMA
4132
 *
L
Lee Schermerhorn 已提交
4133
 */
4134
int page_evictable(struct page *page)
L
Lee Schermerhorn 已提交
4135
{
4136 4137 4138 4139 4140 4141 4142
	int ret;

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

4145
#ifdef CONFIG_SHMEM
4146
/**
4147 4148 4149
 * 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
4150
 *
4151
 * Checks pages for evictability and moves them to the appropriate lru list.
4152 4153
 *
 * This function is only used for SysV IPC SHM_UNLOCK.
4154
 */
4155
void check_move_unevictable_pages(struct page **pages, int nr_pages)
4156
{
4157
	struct lruvec *lruvec;
4158
	struct pglist_data *pgdat = NULL;
4159 4160 4161
	int pgscanned = 0;
	int pgrescued = 0;
	int i;
4162

4163 4164
	for (i = 0; i < nr_pages; i++) {
		struct page *page = pages[i];
4165
		struct pglist_data *pagepgdat = page_pgdat(page);
4166

4167
		pgscanned++;
4168 4169 4170 4171 4172
		if (pagepgdat != pgdat) {
			if (pgdat)
				spin_unlock_irq(&pgdat->lru_lock);
			pgdat = pagepgdat;
			spin_lock_irq(&pgdat->lru_lock);
4173
		}
4174
		lruvec = mem_cgroup_page_lruvec(page, pgdat);
4175

4176 4177
		if (!PageLRU(page) || !PageUnevictable(page))
			continue;
4178

4179
		if (page_evictable(page)) {
4180 4181
			enum lru_list lru = page_lru_base_type(page);

4182
			VM_BUG_ON_PAGE(PageActive(page), page);
4183
			ClearPageUnevictable(page);
4184 4185
			del_page_from_lru_list(page, lruvec, LRU_UNEVICTABLE);
			add_page_to_lru_list(page, lruvec, lru);
4186
			pgrescued++;
4187
		}
4188
	}
4189

4190
	if (pgdat) {
4191 4192
		__count_vm_events(UNEVICTABLE_PGRESCUED, pgrescued);
		__count_vm_events(UNEVICTABLE_PGSCANNED, pgscanned);
4193
		spin_unlock_irq(&pgdat->lru_lock);
4194 4195
	}
}
4196
#endif /* CONFIG_SHMEM */