blob: 7dbc17c18050167b592bfee38aae325b70d6f805 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/mm/vmscan.c
3 *
4 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
5 *
6 * Swap reorganised 29.12.95, Stephen Tweedie.
7 * kswapd added: 7.1.96 sct
8 * Removed kswapd_ctl limits, and swap out as many pages as needed
9 * to bring the system back to freepages.high: 2.4.97, Rik van Riel.
10 * Zone aware kswapd started 02/00, Kanoj Sarcar (kanoj@sgi.com).
11 * Multiqueue VM started 5.8.00, Rik van Riel.
12 */
13
14#include <linux/mm.h>
15#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/kernel_stat.h>
18#include <linux/swap.h>
19#include <linux/pagemap.h>
20#include <linux/init.h>
21#include <linux/highmem.h>
Andrew Mortone129b5c2006-09-27 01:50:00 -070022#include <linux/vmstat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/file.h>
24#include <linux/writeback.h>
25#include <linux/blkdev.h>
26#include <linux/buffer_head.h> /* for try_to_release_page(),
27 buffer_heads_over_limit */
28#include <linux/mm_inline.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/backing-dev.h>
30#include <linux/rmap.h>
31#include <linux/topology.h>
32#include <linux/cpu.h>
33#include <linux/cpuset.h>
Mel Gorman3e7d3442011-01-13 15:45:56 -080034#include <linux/compaction.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/notifier.h>
36#include <linux/rwsem.h>
Rafael J. Wysocki248a0302006-03-22 00:09:04 -080037#include <linux/delay.h>
Yasunori Goto3218ae12006-06-27 02:53:33 -070038#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080039#include <linux/freezer.h>
Balbir Singh66e17072008-02-07 00:13:56 -080040#include <linux/memcontrol.h>
Keika Kobayashi873b4772008-07-25 01:48:52 -070041#include <linux/delayacct.h>
Lee Schermerhornaf936a12008-10-18 20:26:53 -070042#include <linux/sysctl.h>
KOSAKI Motohiro929bea72011-04-14 15:22:12 -070043#include <linux/oom.h>
Linus Torvalds268bb0c2011-05-20 12:50:29 -070044#include <linux/prefetch.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#include <asm/tlbflush.h>
47#include <asm/div64.h>
48
49#include <linux/swapops.h>
50
Nick Piggin0f8053a2006-03-22 00:08:33 -080051#include "internal.h"
52
Mel Gorman33906bc2010-08-09 17:19:16 -070053#define CREATE_TRACE_POINTS
54#include <trace/events/vmscan.h>
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056struct scan_control {
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 /* Incremented by the number of inactive pages that were scanned */
58 unsigned long nr_scanned;
59
Rik van Riela79311c2009-01-06 14:40:01 -080060 /* Number of pages freed so far during a call to shrink_zones() */
61 unsigned long nr_reclaimed;
62
KOSAKI Motohiro22fba332009-12-14 17:59:10 -080063 /* How many pages shrink_list() should reclaim */
64 unsigned long nr_to_reclaim;
65
KOSAKI Motohiro7b517552009-12-14 17:59:12 -080066 unsigned long hibernation_mode;
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 /* This context's GFP mask */
Al Viro6daa0e22005-10-21 03:18:50 -040069 gfp_t gfp_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71 int may_writepage;
72
Johannes Weinera6dc60f2009-03-31 15:19:30 -070073 /* Can mapped pages be reclaimed? */
74 int may_unmap;
Christoph Lameterf1fd1062006-01-18 17:42:30 -080075
KOSAKI Motohiro2e2e4252009-04-21 12:24:57 -070076 /* Can pages be swapped as part of reclaim? */
77 int may_swap;
78
Andy Whitcroft5ad333e2007-07-17 04:03:16 -070079 int order;
Balbir Singh66e17072008-02-07 00:13:56 -080080
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -070081 /* Scan (total_size >> priority) pages at once */
82 int priority;
83
KOSAKI Motohiro5f53e762010-05-24 14:32:37 -070084 /*
Johannes Weinerf16015f2012-01-12 17:17:52 -080085 * The memory cgroup that hit its limit and as a result is the
86 * primary target of this reclaim invocation.
87 */
88 struct mem_cgroup *target_mem_cgroup;
Balbir Singh66e17072008-02-07 00:13:56 -080089
KAMEZAWA Hiroyuki327c0e92009-03-31 15:23:31 -070090 /*
91 * Nodemask of nodes allowed by the caller. If NULL, all nodes
92 * are scanned.
93 */
94 nodemask_t *nodemask;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095};
96
Johannes Weinerf16015f2012-01-12 17:17:52 -080097struct mem_cgroup_zone {
98 struct mem_cgroup *mem_cgroup;
99 struct zone *zone;
100};
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102#define lru_to_page(_head) (list_entry((_head)->prev, struct page, lru))
103
104#ifdef ARCH_HAS_PREFETCH
105#define prefetch_prev_lru_page(_page, _base, _field) \
106 do { \
107 if ((_page)->lru.prev != _base) { \
108 struct page *prev; \
109 \
110 prev = lru_to_page(&(_page->lru)); \
111 prefetch(&prev->_field); \
112 } \
113 } while (0)
114#else
115#define prefetch_prev_lru_page(_page, _base, _field) do { } while (0)
116#endif
117
118#ifdef ARCH_HAS_PREFETCHW
119#define prefetchw_prev_lru_page(_page, _base, _field) \
120 do { \
121 if ((_page)->lru.prev != _base) { \
122 struct page *prev; \
123 \
124 prev = lru_to_page(&(_page->lru)); \
125 prefetchw(&prev->_field); \
126 } \
127 } while (0)
128#else
129#define prefetchw_prev_lru_page(_page, _base, _field) do { } while (0)
130#endif
131
132/*
133 * From 0 .. 100. Higher means more swappy.
134 */
135int vm_swappiness = 60;
Andrew Mortonbd1e22b2006-06-23 02:03:47 -0700136long vm_total_pages; /* The total number of pages which the VM controls */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
138static LIST_HEAD(shrinker_list);
139static DECLARE_RWSEM(shrinker_rwsem);
140
Balbir Singh00f0b822008-03-04 14:28:39 -0800141#ifdef CONFIG_CGROUP_MEM_RES_CTLR
Johannes Weiner89b5fae2012-01-12 17:17:50 -0800142static bool global_reclaim(struct scan_control *sc)
143{
Johannes Weinerf16015f2012-01-12 17:17:52 -0800144 return !sc->target_mem_cgroup;
Johannes Weiner89b5fae2012-01-12 17:17:50 -0800145}
KAMEZAWA Hiroyuki91a45472008-02-07 00:14:29 -0800146#else
Johannes Weiner89b5fae2012-01-12 17:17:50 -0800147static bool global_reclaim(struct scan_control *sc)
148{
149 return true;
150}
KAMEZAWA Hiroyuki91a45472008-02-07 00:14:29 -0800151#endif
152
Johannes Weinerf16015f2012-01-12 17:17:52 -0800153static struct zone_reclaim_stat *get_reclaim_stat(struct mem_cgroup_zone *mz)
KOSAKI Motohiro6e901572009-01-07 18:08:15 -0800154{
Hugh Dickinsc12af162012-05-29 15:06:52 -0700155 if (!mem_cgroup_disabled())
Johannes Weinerf16015f2012-01-12 17:17:52 -0800156 return mem_cgroup_get_reclaim_stat(mz->mem_cgroup, mz->zone);
KOSAKI Motohiro3e2f41f2009-01-07 18:08:20 -0800157
Johannes Weinerf16015f2012-01-12 17:17:52 -0800158 return &mz->zone->reclaim_stat;
KOSAKI Motohiro6e901572009-01-07 18:08:15 -0800159}
160
Lisa Due0935212013-09-11 14:22:36 -0700161unsigned long zone_reclaimable_pages(struct zone *zone)
162{
163 int nr;
164
165 nr = zone_page_state(zone, NR_ACTIVE_FILE) +
166 zone_page_state(zone, NR_INACTIVE_FILE);
167
168 if (get_nr_swap_pages() > 0)
169 nr += zone_page_state(zone, NR_ACTIVE_ANON) +
170 zone_page_state(zone, NR_INACTIVE_ANON);
171
172 return nr;
173}
174
175bool zone_reclaimable(struct zone *zone)
176{
177 return zone->pages_scanned < zone_reclaimable_pages(zone) * 6;
178}
179
Johannes Weinerf16015f2012-01-12 17:17:52 -0800180static unsigned long zone_nr_lru_pages(struct mem_cgroup_zone *mz,
181 enum lru_list lru)
Lisa Due0935212013-09-11 14:22:36 -0700182
KOSAKI Motohiroc9f299d2009-01-07 18:08:16 -0800183{
Hugh Dickinsc12af162012-05-29 15:06:52 -0700184 if (!mem_cgroup_disabled())
Johannes Weinerf16015f2012-01-12 17:17:52 -0800185 return mem_cgroup_zone_nr_lru_pages(mz->mem_cgroup,
186 zone_to_nid(mz->zone),
187 zone_idx(mz->zone),
188 BIT(lru));
KOSAKI Motohiroa3d8e052009-01-07 18:08:19 -0800189
Johannes Weinerf16015f2012-01-12 17:17:52 -0800190 return zone_page_state(mz->zone, NR_LRU_BASE + lru);
KOSAKI Motohiroc9f299d2009-01-07 18:08:16 -0800191}
192
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194/*
195 * Add a shrinker callback to be called from the vm
196 */
Rusty Russell8e1f9362007-07-17 04:03:17 -0700197void register_shrinker(struct shrinker *shrinker)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
Konstantin Khlebnikov83aeead2011-12-08 14:33:54 -0800199 atomic_long_set(&shrinker->nr_in_batch, 0);
Rusty Russell8e1f9362007-07-17 04:03:17 -0700200 down_write(&shrinker_rwsem);
201 list_add_tail(&shrinker->list, &shrinker_list);
202 up_write(&shrinker_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
Rusty Russell8e1f9362007-07-17 04:03:17 -0700204EXPORT_SYMBOL(register_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206/*
207 * Remove one
208 */
Rusty Russell8e1f9362007-07-17 04:03:17 -0700209void unregister_shrinker(struct shrinker *shrinker)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
211 down_write(&shrinker_rwsem);
212 list_del(&shrinker->list);
213 up_write(&shrinker_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
Rusty Russell8e1f9362007-07-17 04:03:17 -0700215EXPORT_SYMBOL(unregister_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Ying Han1495f232011-05-24 17:12:27 -0700217static inline int do_shrinker_shrink(struct shrinker *shrinker,
218 struct shrink_control *sc,
219 unsigned long nr_to_scan)
220{
221 sc->nr_to_scan = nr_to_scan;
222 return (*shrinker->shrink)(shrinker, sc);
223}
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225#define SHRINK_BATCH 128
226/*
227 * Call the shrink functions to age shrinkable caches
228 *
229 * Here we assume it costs one seek to replace a lru page and that it also
230 * takes a seek to recreate a cache object. With this in mind we age equal
231 * percentages of the lru and ageable caches. This should balance the seeks
232 * generated by these structures.
233 *
Simon Arlott183ff222007-10-20 01:27:18 +0200234 * If the vm encountered mapped pages on the LRU it increase the pressure on
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 * slab to avoid swapping.
236 *
237 * We do weird things to avoid (scanned*seeks*entries) overflowing 32 bits.
238 *
239 * `lru_pages' represents the number of on-LRU pages in all the zones which
240 * are eligible for the caller's allocation attempt. It is used for balancing
241 * slab reclaim versus page reclaim.
akpm@osdl.orgb15e0902005-06-21 17:14:35 -0700242 *
243 * Returns the number of slab objects which we shrunk.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 */
Ying Hana09ed5e2011-05-24 17:12:26 -0700245unsigned long shrink_slab(struct shrink_control *shrink,
Ying Han1495f232011-05-24 17:12:27 -0700246 unsigned long nr_pages_scanned,
Ying Hana09ed5e2011-05-24 17:12:26 -0700247 unsigned long lru_pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248{
249 struct shrinker *shrinker;
Andrew Morton69e05942006-03-22 00:08:19 -0800250 unsigned long ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Ying Han1495f232011-05-24 17:12:27 -0700252 if (nr_pages_scanned == 0)
253 nr_pages_scanned = SWAP_CLUSTER_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Minchan Kimf06590b2011-05-24 17:11:11 -0700255 if (!down_read_trylock(&shrinker_rwsem)) {
256 /* Assume we'll be able to shrink next time */
257 ret = 1;
258 goto out;
259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 list_for_each_entry(shrinker, &shrinker_list, list) {
262 unsigned long long delta;
Konstantin Khlebnikov635697c2011-12-08 14:33:51 -0800263 long total_scan;
264 long max_pass;
Dave Chinner09576072011-07-08 14:14:34 +1000265 int shrink_ret = 0;
Dave Chinneracf92b42011-07-08 14:14:35 +1000266 long nr;
267 long new_nr;
Dave Chinnere9299f52011-07-08 14:14:37 +1000268 long batch_size = shrinker->batch ? shrinker->batch
269 : SHRINK_BATCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Konstantin Khlebnikov635697c2011-12-08 14:33:51 -0800271 max_pass = do_shrinker_shrink(shrinker, shrink, 0);
272 if (max_pass <= 0)
273 continue;
274
Dave Chinneracf92b42011-07-08 14:14:35 +1000275 /*
276 * copy the current shrinker scan count into a local variable
277 * and zero it so that other concurrent shrinker invocations
278 * don't also do this scanning work.
279 */
Konstantin Khlebnikov83aeead2011-12-08 14:33:54 -0800280 nr = atomic_long_xchg(&shrinker->nr_in_batch, 0);
Dave Chinneracf92b42011-07-08 14:14:35 +1000281
282 total_scan = nr;
Ying Han1495f232011-05-24 17:12:27 -0700283 delta = (4 * nr_pages_scanned) / shrinker->seeks;
Andrea Arcangeliea164d72005-11-28 13:44:15 -0800284 delta *= max_pass;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 do_div(delta, lru_pages + 1);
Dave Chinneracf92b42011-07-08 14:14:35 +1000286 total_scan += delta;
287 if (total_scan < 0) {
David Rientjes88c3bd72009-03-31 15:23:29 -0700288 printk(KERN_ERR "shrink_slab: %pF negative objects to "
289 "delete nr=%ld\n",
Dave Chinneracf92b42011-07-08 14:14:35 +1000290 shrinker->shrink, total_scan);
291 total_scan = max_pass;
Andrea Arcangeliea164d72005-11-28 13:44:15 -0800292 }
293
294 /*
Dave Chinner3567b592011-07-08 14:14:36 +1000295 * We need to avoid excessive windup on filesystem shrinkers
296 * due to large numbers of GFP_NOFS allocations causing the
297 * shrinkers to return -1 all the time. This results in a large
298 * nr being built up so when a shrink that can do some work
299 * comes along it empties the entire cache due to nr >>>
300 * max_pass. This is bad for sustaining a working set in
301 * memory.
302 *
303 * Hence only allow the shrinker to scan the entire cache when
304 * a large delta change is calculated directly.
305 */
306 if (delta < max_pass / 4)
307 total_scan = min(total_scan, max_pass / 2);
308
309 /*
Andrea Arcangeliea164d72005-11-28 13:44:15 -0800310 * Avoid risking looping forever due to too large nr value:
311 * never try to free more than twice the estimate number of
312 * freeable entries.
313 */
Dave Chinneracf92b42011-07-08 14:14:35 +1000314 if (total_scan > max_pass * 2)
315 total_scan = max_pass * 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Dave Chinneracf92b42011-07-08 14:14:35 +1000317 trace_mm_shrink_slab_start(shrinker, shrink, nr,
Dave Chinner09576072011-07-08 14:14:34 +1000318 nr_pages_scanned, lru_pages,
319 max_pass, delta, total_scan);
320
Dave Chinnere9299f52011-07-08 14:14:37 +1000321 while (total_scan >= batch_size) {
akpm@osdl.orgb15e0902005-06-21 17:14:35 -0700322 int nr_before;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Ying Han1495f232011-05-24 17:12:27 -0700324 nr_before = do_shrinker_shrink(shrinker, shrink, 0);
325 shrink_ret = do_shrinker_shrink(shrinker, shrink,
Dave Chinnere9299f52011-07-08 14:14:37 +1000326 batch_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 if (shrink_ret == -1)
328 break;
akpm@osdl.orgb15e0902005-06-21 17:14:35 -0700329 if (shrink_ret < nr_before)
330 ret += nr_before - shrink_ret;
Dave Chinnere9299f52011-07-08 14:14:37 +1000331 count_vm_events(SLABS_SCANNED, batch_size);
332 total_scan -= batch_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 cond_resched();
335 }
336
Dave Chinneracf92b42011-07-08 14:14:35 +1000337 /*
338 * move the unused scan count back into the shrinker in a
339 * manner that handles concurrent updates. If we exhausted the
340 * scan, there is no need to do an update.
341 */
Konstantin Khlebnikov83aeead2011-12-08 14:33:54 -0800342 if (total_scan > 0)
343 new_nr = atomic_long_add_return(total_scan,
344 &shrinker->nr_in_batch);
345 else
346 new_nr = atomic_long_read(&shrinker->nr_in_batch);
Dave Chinneracf92b42011-07-08 14:14:35 +1000347
348 trace_mm_shrink_slab_end(shrinker, shrink_ret, nr, new_nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 }
350 up_read(&shrinker_rwsem);
Minchan Kimf06590b2011-05-24 17:11:11 -0700351out:
352 cond_resched();
akpm@osdl.orgb15e0902005-06-21 17:14:35 -0700353 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356static inline int is_page_cache_freeable(struct page *page)
357{
Johannes Weinerceddc3a2009-09-21 17:03:00 -0700358 /*
359 * A freeable page cache page is referenced only by the caller
360 * that isolated the page, the page cache radix tree and
361 * optional buffer heads at page->private.
362 */
Johannes Weineredcf4742009-09-21 17:02:59 -0700363 return page_count(page) - page_has_private(page) == 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364}
365
KOSAKI Motohiro7d3579e2010-10-26 14:21:42 -0700366static int may_write_to_queue(struct backing_dev_info *bdi,
367 struct scan_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
Christoph Lameter930d9152006-01-08 01:00:47 -0800369 if (current->flags & PF_SWAPWRITE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 return 1;
371 if (!bdi_write_congested(bdi))
372 return 1;
373 if (bdi == current->backing_dev_info)
374 return 1;
375 return 0;
376}
377
378/*
379 * We detected a synchronous write error writing a page out. Probably
380 * -ENOSPC. We need to propagate that into the address_space for a subsequent
381 * fsync(), msync() or close().
382 *
383 * The tricky part is that after writepage we cannot touch the mapping: nothing
384 * prevents it from being freed up. But we have a ref on the page and once
385 * that page is locked, the mapping is pinned.
386 *
387 * We're allowed to run sleeping lock_page() here because we know the caller has
388 * __GFP_FS.
389 */
390static void handle_write_error(struct address_space *mapping,
391 struct page *page, int error)
392{
Jens Axboe7eaceac2011-03-10 08:52:07 +0100393 lock_page(page);
Guillaume Chazarain3e9f45b2007-05-08 00:23:25 -0700394 if (page_mapping(page) == mapping)
395 mapping_set_error(mapping, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 unlock_page(page);
397}
398
Christoph Lameter04e62a22006-06-23 02:03:38 -0700399/* possible outcome of pageout() */
400typedef enum {
401 /* failed to write page out, page is locked */
402 PAGE_KEEP,
403 /* move page to the active list, page is locked */
404 PAGE_ACTIVATE,
405 /* page has been sent to the disk successfully, page is unlocked */
406 PAGE_SUCCESS,
407 /* page is clean and locked */
408 PAGE_CLEAN,
409} pageout_t;
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411/*
Andrew Morton1742f192006-03-22 00:08:21 -0800412 * pageout is called by shrink_page_list() for each dirty page.
413 * Calls ->writepage().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 */
Andy Whitcroftc661b072007-08-22 14:01:26 -0700415static pageout_t pageout(struct page *page, struct address_space *mapping,
KOSAKI Motohiro7d3579e2010-10-26 14:21:42 -0700416 struct scan_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417{
418 /*
419 * If the page is dirty, only perform writeback if that write
420 * will be non-blocking. To prevent this allocation from being
421 * stalled by pagecache activity. But note that there may be
422 * stalls if we need to run get_block(). We could test
423 * PagePrivate for that.
424 *
Vincent Li6aceb532009-12-14 17:58:49 -0800425 * If this process is currently in __generic_file_aio_write() against
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 * this page's queue, we can perform writeback even if that
427 * will block.
428 *
429 * If the page is swapcache, write it back even if that would
430 * block, for some throttling. This happens by accident, because
431 * swap_backing_dev_info is bust: it doesn't reflect the
432 * congestion state of the swapdevs. Easy to fix, if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 */
434 if (!is_page_cache_freeable(page))
435 return PAGE_KEEP;
436 if (!mapping) {
437 /*
438 * Some data journaling orphaned pages can have
439 * page->mapping == NULL while being dirty with clean buffers.
440 */
David Howells266cf652009-04-03 16:42:36 +0100441 if (page_has_private(page)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 if (try_to_free_buffers(page)) {
443 ClearPageDirty(page);
Harvey Harrisond40cee22008-04-30 00:55:07 -0700444 printk("%s: orphaned page\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 return PAGE_CLEAN;
446 }
447 }
448 return PAGE_KEEP;
449 }
450 if (mapping->a_ops->writepage == NULL)
451 return PAGE_ACTIVATE;
Mel Gorman0e093d992010-10-26 14:21:45 -0700452 if (!may_write_to_queue(mapping->backing_dev_info, sc))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return PAGE_KEEP;
454
455 if (clear_page_dirty_for_io(page)) {
456 int res;
457 struct writeback_control wbc = {
458 .sync_mode = WB_SYNC_NONE,
459 .nr_to_write = SWAP_CLUSTER_MAX,
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -0700460 .range_start = 0,
461 .range_end = LLONG_MAX,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 .for_reclaim = 1,
463 };
464
465 SetPageReclaim(page);
466 res = mapping->a_ops->writepage(page, &wbc);
467 if (res < 0)
468 handle_write_error(mapping, page, res);
Zach Brown994fc28c2005-12-15 14:28:17 -0800469 if (res == AOP_WRITEPAGE_ACTIVATE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 ClearPageReclaim(page);
471 return PAGE_ACTIVATE;
472 }
Andy Whitcroftc661b072007-08-22 14:01:26 -0700473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (!PageWriteback(page)) {
475 /* synchronous write or broken a_ops? */
476 ClearPageReclaim(page);
Vinayak Menon8ba7f622014-11-17 20:26:19 +0530477 if (PageError(page) && PageSwapCache(page)) {
478 ClearPageError(page);
479 /*
480 * We lock the page here because it is required
481 * to free the swp space later in
482 * shrink_page_list. But the page may be
483 * unclocked by functions like
484 * handle_write_error.
485 */
486 __set_page_locked(page);
Olav Haugand0a58562013-11-04 10:46:16 -0800487 return PAGE_ACTIVATE;
Vinayak Menon8ba7f622014-11-17 20:26:19 +0530488 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 }
Mel Gorman626ebe72012-05-29 15:06:20 -0700490 trace_mm_vmscan_writepage(page, trace_reclaim_flags(page));
Andrew Mortone129b5c2006-09-27 01:50:00 -0700491 inc_zone_page_state(page, NR_VMSCAN_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 return PAGE_SUCCESS;
493 }
494
495 return PAGE_CLEAN;
496}
497
Andrew Mortona649fd92006-10-17 00:09:36 -0700498/*
Nick Piggine2867812008-07-25 19:45:30 -0700499 * Same as remove_mapping, but if the page is removed from the mapping, it
500 * gets returned with a refcount of 0.
Andrew Mortona649fd92006-10-17 00:09:36 -0700501 */
Nick Piggine2867812008-07-25 19:45:30 -0700502static int __remove_mapping(struct address_space *mapping, struct page *page)
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800503{
Nick Piggin28e4d962006-09-25 23:31:23 -0700504 BUG_ON(!PageLocked(page));
505 BUG_ON(mapping != page_mapping(page));
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800506
Nick Piggin19fd6232008-07-25 19:45:32 -0700507 spin_lock_irq(&mapping->tree_lock);
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800508 /*
Nick Piggin0fd0e6b2006-09-27 01:50:02 -0700509 * The non racy check for a busy page.
510 *
511 * Must be careful with the order of the tests. When someone has
512 * a ref to the page, it may be possible that they dirty it then
513 * drop the reference. So if PageDirty is tested before page_count
514 * here, then the following race may occur:
515 *
516 * get_user_pages(&page);
517 * [user mapping goes away]
518 * write_to(page);
519 * !PageDirty(page) [good]
520 * SetPageDirty(page);
521 * put_page(page);
522 * !page_count(page) [good, discard it]
523 *
524 * [oops, our write_to data is lost]
525 *
526 * Reversing the order of the tests ensures such a situation cannot
527 * escape unnoticed. The smp_rmb is needed to ensure the page->flags
528 * load is not satisfied before that of page->_count.
529 *
530 * Note that if SetPageDirty is always performed via set_page_dirty,
531 * and thus under tree_lock, then this ordering is not required.
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800532 */
Nick Piggine2867812008-07-25 19:45:30 -0700533 if (!page_freeze_refs(page, 2))
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800534 goto cannot_free;
Nick Piggine2867812008-07-25 19:45:30 -0700535 /* note: atomic_cmpxchg in page_freeze_refs provides the smp_rmb */
536 if (unlikely(PageDirty(page))) {
537 page_unfreeze_refs(page, 2);
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800538 goto cannot_free;
Nick Piggine2867812008-07-25 19:45:30 -0700539 }
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800540
541 if (PageSwapCache(page)) {
542 swp_entry_t swap = { .val = page_private(page) };
543 __delete_from_swap_cache(page);
Nick Piggin19fd6232008-07-25 19:45:32 -0700544 spin_unlock_irq(&mapping->tree_lock);
KAMEZAWA Hiroyukicb4b86b2009-06-16 15:32:52 -0700545 swapcache_free(swap, page);
Nick Piggine2867812008-07-25 19:45:30 -0700546 } else {
Linus Torvalds6072d132010-12-01 13:35:19 -0500547 void (*freepage)(struct page *);
548
549 freepage = mapping->a_ops->freepage;
550
Minchan Kime64a7822011-03-22 16:32:44 -0700551 __delete_from_page_cache(page);
Nick Piggin19fd6232008-07-25 19:45:32 -0700552 spin_unlock_irq(&mapping->tree_lock);
Daisuke Nishimurae767e052009-05-28 14:34:28 -0700553 mem_cgroup_uncharge_cache_page(page);
Linus Torvalds6072d132010-12-01 13:35:19 -0500554
555 if (freepage != NULL)
556 freepage(page);
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800557 }
558
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800559 return 1;
560
561cannot_free:
Nick Piggin19fd6232008-07-25 19:45:32 -0700562 spin_unlock_irq(&mapping->tree_lock);
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800563 return 0;
564}
565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566/*
Nick Piggine2867812008-07-25 19:45:30 -0700567 * Attempt to detach a locked page from its ->mapping. If it is dirty or if
568 * someone else has a ref on the page, abort and return 0. If it was
569 * successfully detached, return 1. Assumes the caller has a single ref on
570 * this page.
571 */
572int remove_mapping(struct address_space *mapping, struct page *page)
573{
574 if (__remove_mapping(mapping, page)) {
575 /*
576 * Unfreezing the refcount with 1 rather than 2 effectively
577 * drops the pagecache ref for us without requiring another
578 * atomic operation.
579 */
580 page_unfreeze_refs(page, 1);
581 return 1;
582 }
583 return 0;
584}
585
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700586/**
587 * putback_lru_page - put previously isolated page onto appropriate LRU list
588 * @page: page to be put back to appropriate lru list
589 *
590 * Add previously isolated @page to appropriate LRU list.
591 * Page may still be unevictable for other reasons.
592 *
593 * lru_lock must not be held, interrupts must be enabled.
594 */
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700595void putback_lru_page(struct page *page)
596{
597 int lru;
598 int active = !!TestClearPageActive(page);
Lee Schermerhornbbfd28e2008-10-18 20:26:40 -0700599 int was_unevictable = PageUnevictable(page);
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700600
601 VM_BUG_ON(PageLRU(page));
602
603redo:
604 ClearPageUnevictable(page);
605
606 if (page_evictable(page, NULL)) {
607 /*
608 * For evictable pages, we can use the cache.
609 * In event of a race, worst case is we end up with an
610 * unevictable page on [in]active list.
611 * We know how to handle that.
612 */
Johannes Weiner401a8e12009-09-21 17:02:58 -0700613 lru = active + page_lru_base_type(page);
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700614 lru_cache_add_lru(page, lru);
615 } else {
616 /*
617 * Put unevictable pages directly on zone's unevictable
618 * list.
619 */
620 lru = LRU_UNEVICTABLE;
621 add_page_to_unevictable_list(page);
Johannes Weiner6a7b9542009-10-26 16:50:00 -0700622 /*
Minchan Kim21ee9f32011-10-31 17:09:28 -0700623 * When racing with an mlock or AS_UNEVICTABLE clearing
624 * (page is unlocked) make sure that if the other thread
625 * does not observe our setting of PG_lru and fails
Hugh Dickins24513262012-01-20 14:34:21 -0800626 * isolation/check_move_unevictable_pages,
Minchan Kim21ee9f32011-10-31 17:09:28 -0700627 * we see PG_mlocked/AS_UNEVICTABLE cleared below and move
Johannes Weiner6a7b9542009-10-26 16:50:00 -0700628 * the page back to the evictable list.
629 *
Minchan Kim21ee9f32011-10-31 17:09:28 -0700630 * The other side is TestClearPageMlocked() or shmem_lock().
Johannes Weiner6a7b9542009-10-26 16:50:00 -0700631 */
632 smp_mb();
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700633 }
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700634
635 /*
636 * page's status can change while we move it among lru. If an evictable
637 * page is on unevictable list, it never be freed. To avoid that,
638 * check after we added it to the list, again.
639 */
640 if (lru == LRU_UNEVICTABLE && page_evictable(page, NULL)) {
641 if (!isolate_lru_page(page)) {
642 put_page(page);
643 goto redo;
644 }
645 /* This means someone else dropped this page from LRU
646 * So, it will be freed or putback to LRU again. There is
647 * nothing to do here.
648 */
649 }
650
Lee Schermerhornbbfd28e2008-10-18 20:26:40 -0700651 if (was_unevictable && lru != LRU_UNEVICTABLE)
652 count_vm_event(UNEVICTABLE_PGRESCUED);
653 else if (!was_unevictable && lru == LRU_UNEVICTABLE)
654 count_vm_event(UNEVICTABLE_PGCULLED);
655
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700656 put_page(page); /* drop ref from isolate */
657}
658
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800659enum page_references {
660 PAGEREF_RECLAIM,
661 PAGEREF_RECLAIM_CLEAN,
Johannes Weiner64574742010-03-05 13:42:22 -0800662 PAGEREF_KEEP,
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800663 PAGEREF_ACTIVATE,
664};
665
666static enum page_references page_check_references(struct page *page,
667 struct scan_control *sc)
668{
Johannes Weiner64574742010-03-05 13:42:22 -0800669 int referenced_ptes, referenced_page;
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800670 unsigned long vm_flags;
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800671
Johannes Weiner2e3d11f2012-05-29 15:06:25 -0700672 referenced_ptes = page_referenced(page, 1, sc->target_mem_cgroup,
673 &vm_flags);
Johannes Weiner64574742010-03-05 13:42:22 -0800674 referenced_page = TestClearPageReferenced(page);
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800675
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800676 /*
677 * Mlock lost the isolation race with us. Let try_to_unmap()
678 * move the page to the unevictable list.
679 */
680 if (vm_flags & VM_LOCKED)
681 return PAGEREF_RECLAIM;
682
Johannes Weiner64574742010-03-05 13:42:22 -0800683 if (referenced_ptes) {
Michal Hockoe3693772012-05-29 15:06:45 -0700684 if (PageSwapBacked(page))
Johannes Weiner64574742010-03-05 13:42:22 -0800685 return PAGEREF_ACTIVATE;
686 /*
687 * All mapped pages start out with page table
688 * references from the instantiating fault, so we need
689 * to look twice if a mapped file page is used more
690 * than once.
691 *
692 * Mark it and spare it for another trip around the
693 * inactive list. Another page table reference will
694 * lead to its activation.
695 *
696 * Note: the mark is set for activated pages as well
697 * so that recently deactivated but used pages are
698 * quickly recovered.
699 */
700 SetPageReferenced(page);
701
Konstantin Khlebnikov34dbc672012-01-10 15:06:59 -0800702 if (referenced_page || referenced_ptes > 1)
Johannes Weiner64574742010-03-05 13:42:22 -0800703 return PAGEREF_ACTIVATE;
704
Konstantin Khlebnikovc909e992012-01-10 15:07:03 -0800705 /*
706 * Activate file-backed executable pages after first usage.
707 */
708 if (vm_flags & VM_EXEC)
709 return PAGEREF_ACTIVATE;
710
Johannes Weiner64574742010-03-05 13:42:22 -0800711 return PAGEREF_KEEP;
712 }
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800713
714 /* Reclaim if clean, defer dirty pages to writeback */
KOSAKI Motohiro2e302442010-10-26 14:21:46 -0700715 if (referenced_page && !PageSwapBacked(page))
Johannes Weiner64574742010-03-05 13:42:22 -0800716 return PAGEREF_RECLAIM_CLEAN;
717
718 return PAGEREF_RECLAIM;
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800719}
720
Nick Piggine2867812008-07-25 19:45:30 -0700721/*
Andrew Morton1742f192006-03-22 00:08:21 -0800722 * shrink_page_list() returns the number of reclaimed pages
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 */
Andrew Morton1742f192006-03-22 00:08:21 -0800724static unsigned long shrink_page_list(struct list_head *page_list,
Konstantin Khlebnikov65f4b2c2012-05-29 15:06:59 -0700725 struct zone *zone,
Mel Gormanf84f6e22011-10-31 17:07:51 -0700726 struct scan_control *sc,
Minchan Kimaab50f12012-10-08 16:31:55 -0700727 enum ttu_flags ttu_flags,
Mel Gorman92df3a72011-10-31 17:07:56 -0700728 unsigned long *ret_nr_dirty,
Minchan Kimaab50f12012-10-08 16:31:55 -0700729 unsigned long *ret_nr_writeback,
730 bool force_reclaim)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
732 LIST_HEAD(ret_pages);
Mel Gormanabe4c3b2010-08-09 17:19:31 -0700733 LIST_HEAD(free_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 int pgactivate = 0;
Mel Gorman0e093d992010-10-26 14:21:45 -0700735 unsigned long nr_dirty = 0;
736 unsigned long nr_congested = 0;
Andrew Morton05ff5132006-03-22 00:08:20 -0800737 unsigned long nr_reclaimed = 0;
Mel Gorman92df3a72011-10-31 17:07:56 -0700738 unsigned long nr_writeback = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
740 cond_resched();
741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 while (!list_empty(page_list)) {
743 struct address_space *mapping;
744 struct page *page;
745 int may_enter_fs;
Minchan Kimaab50f12012-10-08 16:31:55 -0700746 enum page_references references = PAGEREF_RECLAIM_CLEAN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 cond_resched();
749
750 page = lru_to_page(page_list);
751 list_del(&page->lru);
752
Nick Piggin529ae9a2008-08-02 12:01:03 +0200753 if (!trylock_page(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 goto keep;
755
Nick Piggin725d7042006-09-25 23:30:55 -0700756 VM_BUG_ON(PageActive(page));
Konstantin Khlebnikov65f4b2c2012-05-29 15:06:59 -0700757 VM_BUG_ON(page_zone(page) != zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759 sc->nr_scanned++;
Christoph Lameter80e43422006-02-11 17:55:53 -0800760
Nick Pigginb291f002008-10-18 20:26:44 -0700761 if (unlikely(!page_evictable(page, NULL)))
762 goto cull_mlocked;
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700763
Johannes Weinera6dc60f2009-03-31 15:19:30 -0700764 if (!sc->may_unmap && page_mapped(page))
Christoph Lameter80e43422006-02-11 17:55:53 -0800765 goto keep_locked;
766
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 /* Double the slab pressure for mapped and swapcache pages */
768 if (page_mapped(page) || PageSwapCache(page))
769 sc->nr_scanned++;
770
Andy Whitcroftc661b072007-08-22 14:01:26 -0700771 may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
772 (PageSwapCache(page) && (sc->gfp_mask & __GFP_IO));
773
774 if (PageWriteback(page)) {
Mel Gorman92df3a72011-10-31 17:07:56 -0700775 nr_writeback++;
Mel Gormanf65a6ed2012-05-29 15:06:19 -0700776 unlock_page(page);
777 goto keep;
Andy Whitcroftc661b072007-08-22 14:01:26 -0700778 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Minchan Kimaab50f12012-10-08 16:31:55 -0700780 if (!force_reclaim)
781 references = page_check_references(page, sc);
782
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800783 switch (references) {
784 case PAGEREF_ACTIVATE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 goto activate_locked;
Johannes Weiner64574742010-03-05 13:42:22 -0800786 case PAGEREF_KEEP:
787 goto keep_locked;
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800788 case PAGEREF_RECLAIM:
789 case PAGEREF_RECLAIM_CLEAN:
790 ; /* try to reclaim the page below */
791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 /*
794 * Anonymous process memory has backing store?
795 * Try to allocate it some swap space here.
796 */
Nick Pigginb291f002008-10-18 20:26:44 -0700797 if (PageAnon(page) && !PageSwapCache(page)) {
Hugh Dickins63eb6b92008-11-19 15:36:37 -0800798 if (!(sc->gfp_mask & __GFP_IO))
799 goto keep_locked;
Hugh Dickinsac47b002009-01-06 14:39:39 -0800800 if (!add_to_swap(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 goto activate_locked;
Hugh Dickins63eb6b92008-11-19 15:36:37 -0800802 may_enter_fs = 1;
Nick Pigginb291f002008-10-18 20:26:44 -0700803 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805 mapping = page_mapping(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807 /*
808 * The page is mapped into the page tables of one or more
809 * processes. Try to unmap it here.
810 */
811 if (page_mapped(page) && mapping) {
Minchan Kimaab50f12012-10-08 16:31:55 -0700812 switch (try_to_unmap(page, ttu_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 case SWAP_FAIL:
814 goto activate_locked;
815 case SWAP_AGAIN:
816 goto keep_locked;
Nick Pigginb291f002008-10-18 20:26:44 -0700817 case SWAP_MLOCK:
818 goto cull_mlocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 case SWAP_SUCCESS:
820 ; /* try to free the page below */
821 }
822 }
823
824 if (PageDirty(page)) {
Mel Gorman0e093d992010-10-26 14:21:45 -0700825 nr_dirty++;
826
Mel Gormanee728862011-10-31 17:07:38 -0700827 /*
828 * Only kswapd can writeback filesystem pages to
Mel Gormanf84f6e22011-10-31 17:07:51 -0700829 * avoid risk of stack overflow but do not writeback
830 * unless under significant pressure.
Mel Gormanee728862011-10-31 17:07:38 -0700831 */
Mel Gormanf84f6e22011-10-31 17:07:51 -0700832 if (page_is_file_cache(page) &&
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -0700833 (!current_is_kswapd() ||
834 sc->priority >= DEF_PRIORITY - 2)) {
Mel Gorman49ea7eb2011-10-31 17:07:59 -0700835 /*
836 * Immediately reclaim when written back.
837 * Similar in principal to deactivate_page()
838 * except we already have the page isolated
839 * and know it's dirty
840 */
841 inc_zone_page_state(page, NR_VMSCAN_IMMEDIATE);
842 SetPageReclaim(page);
843
Mel Gormanee728862011-10-31 17:07:38 -0700844 goto keep_locked;
845 }
846
Johannes Weinerdfc8d632010-03-05 13:42:19 -0800847 if (references == PAGEREF_RECLAIM_CLEAN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 goto keep_locked;
Andrew Morton4dd4b922008-03-24 12:29:52 -0700849 if (!may_enter_fs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 goto keep_locked;
Christoph Lameter52a83632006-02-01 03:05:28 -0800851 if (!sc->may_writepage)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 goto keep_locked;
853
854 /* Page is dirty, try to write it out here */
KOSAKI Motohiro7d3579e2010-10-26 14:21:42 -0700855 switch (pageout(page, mapping, sc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 case PAGE_KEEP:
Mel Gorman0e093d992010-10-26 14:21:45 -0700857 nr_congested++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 goto keep_locked;
859 case PAGE_ACTIVATE:
860 goto activate_locked;
861 case PAGE_SUCCESS:
KOSAKI Motohiro7d3579e2010-10-26 14:21:42 -0700862 if (PageWriteback(page))
Mel Gormanf65a6ed2012-05-29 15:06:19 -0700863 goto keep;
KOSAKI Motohiro7d3579e2010-10-26 14:21:42 -0700864 if (PageDirty(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 goto keep;
KOSAKI Motohiro7d3579e2010-10-26 14:21:42 -0700866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 /*
868 * A synchronous write - probably a ramdisk. Go
869 * ahead and try to reclaim the page.
870 */
Nick Piggin529ae9a2008-08-02 12:01:03 +0200871 if (!trylock_page(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 goto keep;
873 if (PageDirty(page) || PageWriteback(page))
874 goto keep_locked;
875 mapping = page_mapping(page);
876 case PAGE_CLEAN:
877 ; /* try to free the page below */
878 }
879 }
880
881 /*
882 * If the page has buffers, try to free the buffer mappings
883 * associated with this page. If we succeed we try to free
884 * the page as well.
885 *
886 * We do this even if the page is PageDirty().
887 * try_to_release_page() does not perform I/O, but it is
888 * possible for a page to have PageDirty set, but it is actually
889 * clean (all its buffers are clean). This happens if the
890 * buffers were written out directly, with submit_bh(). ext3
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700891 * will do this, as well as the blockdev mapping.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 * try_to_release_page() will discover that cleanness and will
893 * drop the buffers and mark the page clean - it can be freed.
894 *
895 * Rarely, pages can have buffers and no ->mapping. These are
896 * the pages which were not successfully invalidated in
897 * truncate_complete_page(). We try to drop those buffers here
898 * and if that worked, and the page is no longer mapped into
899 * process address space (page_count == 1) it can be freed.
900 * Otherwise, leave the page on the LRU so it is swappable.
901 */
David Howells266cf652009-04-03 16:42:36 +0100902 if (page_has_private(page)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 if (!try_to_release_page(page, sc->gfp_mask))
904 goto activate_locked;
Nick Piggine2867812008-07-25 19:45:30 -0700905 if (!mapping && page_count(page) == 1) {
906 unlock_page(page);
907 if (put_page_testzero(page))
908 goto free_it;
909 else {
910 /*
911 * rare race with speculative reference.
912 * the speculative reference will free
913 * this page shortly, so we may
914 * increment nr_reclaimed here (and
915 * leave it off the LRU).
916 */
917 nr_reclaimed++;
918 continue;
919 }
920 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 }
922
Nick Piggine2867812008-07-25 19:45:30 -0700923 if (!mapping || !__remove_mapping(mapping, page))
Christoph Lameter49d2e9c2006-01-08 01:00:48 -0800924 goto keep_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
Nick Piggina978d6f2008-10-18 20:26:58 -0700926 /*
927 * At this point, we have no other references and there is
928 * no way to pick any more up (removed from LRU, removed
929 * from pagecache). Can use non-atomic bitops now (and
930 * we obviously don't have to worry about waking up a process
931 * waiting on the page lock, because there are no references.
932 */
933 __clear_page_locked(page);
Nick Piggine2867812008-07-25 19:45:30 -0700934free_it:
Andrew Morton05ff5132006-03-22 00:08:20 -0800935 nr_reclaimed++;
Mel Gormanabe4c3b2010-08-09 17:19:31 -0700936
937 /*
938 * Is there need to periodically free_page_list? It would
939 * appear not as the counts should be low
940 */
941 list_add(&page->lru, &free_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 continue;
943
Nick Pigginb291f002008-10-18 20:26:44 -0700944cull_mlocked:
Hugh Dickins63d6c5a2009-01-06 14:39:38 -0800945 if (PageSwapCache(page))
946 try_to_free_swap(page);
Nick Pigginb291f002008-10-18 20:26:44 -0700947 unlock_page(page);
948 putback_lru_page(page);
949 continue;
950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951activate_locked:
Rik van Riel68a223942008-10-18 20:26:23 -0700952 /* Not a candidate for swapping, so reclaim swap space. */
953 if (PageSwapCache(page) && vm_swap_full())
Hugh Dickinsa2c43ee2009-01-06 14:39:36 -0800954 try_to_free_swap(page);
Lee Schermerhorn894bc312008-10-18 20:26:39 -0700955 VM_BUG_ON(PageActive(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 SetPageActive(page);
957 pgactivate++;
958keep_locked:
959 unlock_page(page);
960keep:
961 list_add(&page->lru, &ret_pages);
Nick Pigginb291f002008-10-18 20:26:44 -0700962 VM_BUG_ON(PageLRU(page) || PageUnevictable(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 }
Mel Gormanabe4c3b2010-08-09 17:19:31 -0700964
Mel Gorman0e093d992010-10-26 14:21:45 -0700965 /*
966 * Tag a zone as congested if all the dirty pages encountered were
967 * backed by a congested BDI. In this case, reclaimers should just
968 * back off and wait for congestion to clear because further reclaim
969 * will encounter the same problem
970 */
Johannes Weiner89b5fae2012-01-12 17:17:50 -0800971 if (nr_dirty && nr_dirty == nr_congested && global_reclaim(sc))
Konstantin Khlebnikov65f4b2c2012-05-29 15:06:59 -0700972 zone_set_flag(zone, ZONE_CONGESTED);
Mel Gorman0e093d992010-10-26 14:21:45 -0700973
Konstantin Khlebnikovcc598502012-01-10 15:07:04 -0800974 free_hot_cold_page_list(&free_pages, 1);
Mel Gormanabe4c3b2010-08-09 17:19:31 -0700975
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 list_splice(&ret_pages, page_list);
Christoph Lameterf8891e52006-06-30 01:55:45 -0700977 count_vm_events(PGACTIVATE, pgactivate);
Mel Gorman92df3a72011-10-31 17:07:56 -0700978 *ret_nr_dirty += nr_dirty;
979 *ret_nr_writeback += nr_writeback;
Andrew Morton05ff5132006-03-22 00:08:20 -0800980 return nr_reclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981}
982
Minchan Kimaab50f12012-10-08 16:31:55 -0700983unsigned long reclaim_clean_pages_from_list(struct zone *zone,
984 struct list_head *page_list)
985{
986 struct scan_control sc = {
987 .gfp_mask = GFP_KERNEL,
988 .priority = DEF_PRIORITY,
989 .may_unmap = 1,
990 };
991 unsigned long ret, dummy1, dummy2;
992 struct page *page, *next;
993 LIST_HEAD(clean_pages);
994
995 list_for_each_entry_safe(page, next, page_list, lru) {
996 if (page_is_file_cache(page) && !PageDirty(page)) {
997 ClearPageActive(page);
998 list_move(&page->lru, &clean_pages);
999 }
1000 }
1001
1002 ret = shrink_page_list(&clean_pages, zone, &sc,
1003 TTU_UNMAP|TTU_IGNORE_ACCESS,
1004 &dummy1, &dummy2, true);
1005 list_splice(&clean_pages, page_list);
1006 __mod_zone_page_state(zone, NR_ISOLATED_FILE, -ret);
1007 return ret;
1008}
1009
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001010/*
1011 * Attempt to remove the specified page from its LRU. Only take this page
1012 * if it is of the appropriate PageActive status. Pages which are being
1013 * freed elsewhere are also ignored.
1014 *
1015 * page: page to consider
1016 * mode: one of the LRU isolation modes defined above
1017 *
1018 * returns 0 on success, -ve errno on failure.
1019 */
Konstantin Khlebnikov6d8a50e2012-05-29 15:06:54 -07001020int __isolate_lru_page(struct page *page, isolate_mode_t mode)
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001021{
1022 int ret = -EINVAL;
1023
1024 /* Only take pages on the LRU. */
1025 if (!PageLRU(page))
1026 return ret;
1027
Minchan Kimd05b4522012-10-08 16:33:48 -07001028 /* Compaction should not handle unevictable pages but CMA can do so */
1029 if (PageUnevictable(page) && !(mode & ISOLATE_UNEVICTABLE))
Lee Schermerhorn894bc312008-10-18 20:26:39 -07001030 return ret;
1031
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001032 ret = -EBUSY;
KAMEZAWA Hiroyuki08e552c2009-01-07 18:08:01 -08001033
Mel Gormanc8244932012-01-12 17:19:38 -08001034 /*
1035 * To minimise LRU disruption, the caller can indicate that it only
1036 * wants to isolate pages it will be able to operate on without
1037 * blocking - clean pages for the most part.
1038 *
1039 * ISOLATE_CLEAN means that only clean pages should be isolated. This
1040 * is used by reclaim when it is cannot write to backing storage
1041 *
1042 * ISOLATE_ASYNC_MIGRATE is used to indicate that it only wants to pages
1043 * that it is possible to migrate without blocking
1044 */
1045 if (mode & (ISOLATE_CLEAN|ISOLATE_ASYNC_MIGRATE)) {
1046 /* All the caller can do on PageWriteback is block */
1047 if (PageWriteback(page))
1048 return ret;
1049
1050 if (PageDirty(page)) {
1051 struct address_space *mapping;
1052
1053 /* ISOLATE_CLEAN means only clean pages */
1054 if (mode & ISOLATE_CLEAN)
1055 return ret;
1056
1057 /*
1058 * Only pages without mappings or that have a
1059 * ->migratepage callback are possible to migrate
1060 * without blocking
1061 */
1062 mapping = page_mapping(page);
1063 if (mapping && !mapping->a_ops->migratepage)
1064 return ret;
1065 }
1066 }
Minchan Kim39deaf82011-10-31 17:06:51 -07001067
Minchan Kimf80c0672011-10-31 17:06:55 -07001068 if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
1069 return ret;
1070
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001071 if (likely(get_page_unless_zero(page))) {
1072 /*
1073 * Be careful not to clear PageLRU until after we're
1074 * sure the page is not being freed elsewhere -- the
1075 * page release code relies on it.
1076 */
1077 ClearPageLRU(page);
1078 ret = 0;
1079 }
1080
1081 return ret;
1082}
1083
Christoph Lameter49d2e9c2006-01-08 01:00:48 -08001084/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 * zone->lru_lock is heavily contended. Some of the functions that
1086 * shrink the lists perform better by taking out a batch of pages
1087 * and working on them outside the LRU lock.
1088 *
1089 * For pagecache intensive workloads, this function is the hottest
1090 * spot in the kernel (apart from copy_*_user functions).
1091 *
1092 * Appropriate locks must be held before calling this function.
1093 *
1094 * @nr_to_scan: The number of pages to look through on the list.
Konstantin Khlebnikov3a15fe82012-05-29 15:06:58 -07001095 * @lruvec: The LRU vector to pull pages from.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 * @dst: The temp list to put pages on to.
Hugh Dickinsf6260122012-01-12 17:20:06 -08001097 * @nr_scanned: The number of pages that were scanned.
Rik van Rielfe2c2a12012-03-21 16:33:51 -07001098 * @sc: The scan_control struct for this reclaim session
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001099 * @mode: One of the LRU isolation modes
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001100 * @lru: LRU list id for isolating
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 *
1102 * returns how many pages were moved onto *@dst.
1103 */
Andrew Morton69e05942006-03-22 00:08:19 -08001104static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
Konstantin Khlebnikov3a15fe82012-05-29 15:06:58 -07001105 struct lruvec *lruvec, struct list_head *dst,
Rik van Rielfe2c2a12012-03-21 16:33:51 -07001106 unsigned long *nr_scanned, struct scan_control *sc,
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001107 isolate_mode_t mode, enum lru_list lru)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108{
Hugh Dickinsf6260122012-01-12 17:20:06 -08001109 struct list_head *src;
Andrew Morton69e05942006-03-22 00:08:19 -08001110 unsigned long nr_taken = 0;
Wu Fengguangc9b02d92006-03-22 00:08:23 -08001111 unsigned long scan;
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001112 int file = is_file_lru(lru);
Hugh Dickinsf6260122012-01-12 17:20:06 -08001113
Hugh Dickinsf6260122012-01-12 17:20:06 -08001114 src = &lruvec->lists[lru];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Wu Fengguangc9b02d92006-03-22 00:08:23 -08001116 for (scan = 0; scan < nr_to_scan && !list_empty(src); scan++) {
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001117 struct page *page;
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001118
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 page = lru_to_page(src);
1120 prefetchw_prev_lru_page(page, src, flags);
1121
Nick Piggin725d7042006-09-25 23:30:55 -07001122 VM_BUG_ON(!PageLRU(page));
Nick Piggin8d438f92006-03-22 00:07:59 -08001123
Konstantin Khlebnikov6d8a50e2012-05-29 15:06:54 -07001124 switch (__isolate_lru_page(page, mode)) {
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001125 case 0:
Konstantin Khlebnikov35b84732012-05-29 15:06:54 -07001126 mem_cgroup_lru_del_list(page, lru);
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001127 list_move(&page->lru, dst);
Rik van Riel2c888cf2011-01-13 15:47:13 -08001128 nr_taken += hpage_nr_pages(page);
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001129 break;
Nick Piggin46453a62006-03-22 00:07:58 -08001130
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07001131 case -EBUSY:
1132 /* else it is being freed elsewhere */
1133 list_move(&page->lru, src);
1134 continue;
1135
1136 default:
1137 BUG();
1138 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 }
1140
Hugh Dickinsf6260122012-01-12 17:20:06 -08001141 *nr_scanned = scan;
Mel Gormana8a94d12010-08-09 17:19:17 -07001142
Rik van Rielfe2c2a12012-03-21 16:33:51 -07001143 trace_mm_vmscan_lru_isolate(sc->order,
Mel Gormana8a94d12010-08-09 17:19:17 -07001144 nr_to_scan, scan,
1145 nr_taken,
Tao Maea4d3492012-01-12 17:19:20 -08001146 mode, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 return nr_taken;
1148}
1149
Nick Piggin62695a82008-10-18 20:26:09 -07001150/**
1151 * isolate_lru_page - tries to isolate a page from its LRU list
1152 * @page: page to isolate from its LRU list
1153 *
1154 * Isolates a @page from an LRU list, clears PageLRU and adjusts the
1155 * vmstat statistic corresponding to whatever LRU list the page was on.
1156 *
1157 * Returns 0 if the page was removed from an LRU list.
1158 * Returns -EBUSY if the page was not on an LRU list.
1159 *
1160 * The returned page will have PageLRU() cleared. If it was found on
Lee Schermerhorn894bc312008-10-18 20:26:39 -07001161 * the active list, it will have PageActive set. If it was found on
1162 * the unevictable list, it will have the PageUnevictable bit set. That flag
1163 * may need to be cleared by the caller before letting the page go.
Nick Piggin62695a82008-10-18 20:26:09 -07001164 *
1165 * The vmstat statistic corresponding to the list on which the page was
1166 * found will be decremented.
1167 *
1168 * Restrictions:
1169 * (1) Must be called with an elevated refcount on the page. This is a
1170 * fundamentnal difference from isolate_lru_pages (which is called
1171 * without a stable reference).
1172 * (2) the lru_lock must not be held.
1173 * (3) interrupts must be enabled.
1174 */
1175int isolate_lru_page(struct page *page)
1176{
1177 int ret = -EBUSY;
1178
Konstantin Khlebnikov0c917312011-05-24 17:12:21 -07001179 VM_BUG_ON(!page_count(page));
1180
Nick Piggin62695a82008-10-18 20:26:09 -07001181 if (PageLRU(page)) {
1182 struct zone *zone = page_zone(page);
1183
1184 spin_lock_irq(&zone->lru_lock);
Konstantin Khlebnikov0c917312011-05-24 17:12:21 -07001185 if (PageLRU(page)) {
Lee Schermerhorn894bc312008-10-18 20:26:39 -07001186 int lru = page_lru(page);
Nick Piggin62695a82008-10-18 20:26:09 -07001187 ret = 0;
Konstantin Khlebnikov0c917312011-05-24 17:12:21 -07001188 get_page(page);
Nick Piggin62695a82008-10-18 20:26:09 -07001189 ClearPageLRU(page);
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001190
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001191 del_page_from_lru_list(zone, page, lru);
Nick Piggin62695a82008-10-18 20:26:09 -07001192 }
1193 spin_unlock_irq(&zone->lru_lock);
1194 }
1195 return ret;
1196}
1197
Vinayak Menonc702aaa2014-12-26 19:29:41 +05301198static int __too_many_isolated(struct zone *zone, int file,
1199 struct scan_control *sc, int safe)
Rik van Riel35cd7812009-09-21 17:01:38 -07001200{
1201 unsigned long inactive, isolated;
1202
Rik van Riel35cd7812009-09-21 17:01:38 -07001203 if (file) {
Vinayak Menonc702aaa2014-12-26 19:29:41 +05301204 if (safe) {
1205 inactive = zone_page_state_snapshot(zone,
1206 NR_INACTIVE_FILE);
1207 isolated = zone_page_state_snapshot(zone,
1208 NR_ISOLATED_FILE);
1209 } else {
1210 inactive = zone_page_state(zone, NR_INACTIVE_FILE);
1211 isolated = zone_page_state(zone, NR_ISOLATED_FILE);
1212 }
Rik van Riel35cd7812009-09-21 17:01:38 -07001213 } else {
Vinayak Menonc702aaa2014-12-26 19:29:41 +05301214 if (safe) {
1215 inactive = zone_page_state_snapshot(zone,
1216 NR_INACTIVE_ANON);
1217 isolated = zone_page_state_snapshot(zone,
1218 NR_ISOLATED_ANON);
1219 } else {
1220 inactive = zone_page_state(zone, NR_INACTIVE_ANON);
1221 isolated = zone_page_state(zone, NR_ISOLATED_ANON);
1222 }
Rik van Riel35cd7812009-09-21 17:01:38 -07001223 }
1224
Fengguang Wu2f25e5a2012-12-18 14:23:31 -08001225 /*
1226 * GFP_NOIO/GFP_NOFS callers are allowed to isolate more pages, so they
1227 * won't get blocked by normal direct-reclaimers, forming a circular
1228 * deadlock.
1229 */
1230 if ((sc->gfp_mask & GFP_IOFS) == GFP_IOFS)
1231 inactive >>= 3;
1232
Rik van Riel35cd7812009-09-21 17:01:38 -07001233 return isolated > inactive;
1234}
1235
Vinayak Menonc702aaa2014-12-26 19:29:41 +05301236/*
1237 * Are there way too many processes in the direct reclaim path already?
1238 */
1239static int too_many_isolated(struct zone *zone, int file,
1240 struct scan_control *sc, int safe)
1241{
1242 if (current_is_kswapd())
1243 return 0;
1244
1245 if (!global_reclaim(sc))
1246 return 0;
1247
1248 if (unlikely(__too_many_isolated(zone, file, sc, 0))) {
1249 if (safe)
1250 return __too_many_isolated(zone, file, sc, safe);
1251 else
1252 return 1;
1253 }
1254
1255 return 0;
1256}
1257
Mel Gorman66635622010-08-09 17:19:30 -07001258static noinline_for_stack void
Hugh Dickins3f797682012-01-12 17:20:07 -08001259putback_inactive_pages(struct mem_cgroup_zone *mz,
1260 struct list_head *page_list)
Mel Gorman66635622010-08-09 17:19:30 -07001261{
Johannes Weinerf16015f2012-01-12 17:17:52 -08001262 struct zone_reclaim_stat *reclaim_stat = get_reclaim_stat(mz);
Hugh Dickins3f797682012-01-12 17:20:07 -08001263 struct zone *zone = mz->zone;
1264 LIST_HEAD(pages_to_free);
Mel Gorman66635622010-08-09 17:19:30 -07001265
Mel Gorman66635622010-08-09 17:19:30 -07001266 /*
1267 * Put back any unfreeable pages.
1268 */
Mel Gorman66635622010-08-09 17:19:30 -07001269 while (!list_empty(page_list)) {
Hugh Dickins3f797682012-01-12 17:20:07 -08001270 struct page *page = lru_to_page(page_list);
Mel Gorman66635622010-08-09 17:19:30 -07001271 int lru;
Hugh Dickins3f797682012-01-12 17:20:07 -08001272
Mel Gorman66635622010-08-09 17:19:30 -07001273 VM_BUG_ON(PageLRU(page));
1274 list_del(&page->lru);
1275 if (unlikely(!page_evictable(page, NULL))) {
1276 spin_unlock_irq(&zone->lru_lock);
1277 putback_lru_page(page);
1278 spin_lock_irq(&zone->lru_lock);
1279 continue;
1280 }
Linus Torvalds7a608572011-01-17 14:42:19 -08001281 SetPageLRU(page);
Mel Gorman66635622010-08-09 17:19:30 -07001282 lru = page_lru(page);
Linus Torvalds7a608572011-01-17 14:42:19 -08001283 add_page_to_lru_list(zone, page, lru);
Mel Gorman66635622010-08-09 17:19:30 -07001284 if (is_active_lru(lru)) {
1285 int file = is_file_lru(lru);
Rik van Riel9992af12011-01-13 15:47:13 -08001286 int numpages = hpage_nr_pages(page);
1287 reclaim_stat->recent_rotated[file] += numpages;
Mel Gorman66635622010-08-09 17:19:30 -07001288 }
Hugh Dickins2bcf8872012-01-12 17:19:56 -08001289 if (put_page_testzero(page)) {
1290 __ClearPageLRU(page);
1291 __ClearPageActive(page);
1292 del_page_from_lru_list(zone, page, lru);
1293
1294 if (unlikely(PageCompound(page))) {
1295 spin_unlock_irq(&zone->lru_lock);
1296 (*get_compound_page_dtor(page))(page);
1297 spin_lock_irq(&zone->lru_lock);
1298 } else
1299 list_add(&page->lru, &pages_to_free);
Mel Gorman66635622010-08-09 17:19:30 -07001300 }
1301 }
Mel Gorman66635622010-08-09 17:19:30 -07001302
Hugh Dickins3f797682012-01-12 17:20:07 -08001303 /*
1304 * To save our caller's stack, now use input list for pages to free.
1305 */
1306 list_splice(&pages_to_free, page_list);
Mel Gorman66635622010-08-09 17:19:30 -07001307}
1308
1309/*
Andrew Morton1742f192006-03-22 00:08:21 -08001310 * shrink_inactive_list() is a helper for shrink_zone(). It returns the number
1311 * of reclaimed pages
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 */
Mel Gorman66635622010-08-09 17:19:30 -07001313static noinline_for_stack unsigned long
Johannes Weinerf16015f2012-01-12 17:17:52 -08001314shrink_inactive_list(unsigned long nr_to_scan, struct mem_cgroup_zone *mz,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001315 struct scan_control *sc, enum lru_list lru)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316{
1317 LIST_HEAD(page_list);
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001318 unsigned long nr_scanned;
Andrew Morton05ff5132006-03-22 00:08:20 -08001319 unsigned long nr_reclaimed = 0;
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001320 unsigned long nr_taken;
Mel Gorman92df3a72011-10-31 17:07:56 -07001321 unsigned long nr_dirty = 0;
1322 unsigned long nr_writeback = 0;
Konstantin Khlebnikov6d8a50e2012-05-29 15:06:54 -07001323 isolate_mode_t isolate_mode = 0;
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001324 int file = is_file_lru(lru);
Vinayak Menonc702aaa2014-12-26 19:29:41 +05301325 int safe = 0;
Johannes Weinerf16015f2012-01-12 17:17:52 -08001326 struct zone *zone = mz->zone;
Hillf Dantond563c052012-03-21 16:34:02 -07001327 struct zone_reclaim_stat *reclaim_stat = get_reclaim_stat(mz);
Konstantin Khlebnikov3a15fe82012-05-29 15:06:58 -07001328 struct lruvec *lruvec = mem_cgroup_zone_lruvec(zone, mz->mem_cgroup);
KOSAKI Motohiro78dc5832009-06-16 15:31:40 -07001329
Vinayak Menonc702aaa2014-12-26 19:29:41 +05301330 while (unlikely(too_many_isolated(zone, file, sc, safe))) {
KOSAKI Motohiro58355c72009-10-26 16:49:35 -07001331 congestion_wait(BLK_RW_ASYNC, HZ/10);
Rik van Riel35cd7812009-09-21 17:01:38 -07001332
1333 /* We are about to die and free our memory. Return now. */
1334 if (fatal_signal_pending(current))
1335 return SWAP_CLUSTER_MAX;
Vinayak Menonc702aaa2014-12-26 19:29:41 +05301336
1337 safe = 1;
Rik van Riel35cd7812009-09-21 17:01:38 -07001338 }
1339
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 lru_add_drain();
Minchan Kimf80c0672011-10-31 17:06:55 -07001341
1342 if (!sc->may_unmap)
Hillf Danton61317282012-03-21 16:33:48 -07001343 isolate_mode |= ISOLATE_UNMAPPED;
Minchan Kimf80c0672011-10-31 17:06:55 -07001344 if (!sc->may_writepage)
Hillf Danton61317282012-03-21 16:33:48 -07001345 isolate_mode |= ISOLATE_CLEAN;
Minchan Kimf80c0672011-10-31 17:06:55 -07001346
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 spin_lock_irq(&zone->lru_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348
Konstantin Khlebnikov3a15fe82012-05-29 15:06:58 -07001349 nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &page_list,
1350 &nr_scanned, sc, isolate_mode, lru);
Konstantin Khlebnikov650e0952012-05-29 15:06:59 -07001351
1352 __mod_zone_page_state(zone, NR_LRU_BASE + lru, -nr_taken);
1353 __mod_zone_page_state(zone, NR_ISOLATED_ANON + file, nr_taken);
1354
Johannes Weiner89b5fae2012-01-12 17:17:50 -08001355 if (global_reclaim(sc)) {
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001356 zone->pages_scanned += nr_scanned;
KOSAKI Motohirob35ea172009-09-21 17:01:36 -07001357 if (current_is_kswapd())
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001358 __count_zone_vm_events(PGSCAN_KSWAPD, zone,
1359 nr_scanned);
1360 else
1361 __count_zone_vm_events(PGSCAN_DIRECT, zone,
1362 nr_scanned);
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001363 }
Hillf Dantond563c052012-03-21 16:34:02 -07001364 spin_unlock_irq(&zone->lru_lock);
KOSAKI Motohiroa7312862009-09-21 17:01:37 -07001365
Hillf Dantond563c052012-03-21 16:34:02 -07001366 if (nr_taken == 0)
Mel Gorman66635622010-08-09 17:19:30 -07001367 return 0;
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001368
Minchan Kimaab50f12012-10-08 16:31:55 -07001369 nr_reclaimed = shrink_page_list(&page_list, zone, sc, TTU_UNMAP,
1370 &nr_dirty, &nr_writeback, false);
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001371
Hugh Dickins3f797682012-01-12 17:20:07 -08001372 spin_lock_irq(&zone->lru_lock);
1373
Konstantin Khlebnikov650e0952012-05-29 15:06:59 -07001374 reclaim_stat->recent_scanned[file] += nr_taken;
Hillf Dantond563c052012-03-21 16:34:02 -07001375
Ying Han904249a2012-04-25 16:01:48 -07001376 if (global_reclaim(sc)) {
1377 if (current_is_kswapd())
1378 __count_zone_vm_events(PGSTEAL_KSWAPD, zone,
1379 nr_reclaimed);
1380 else
1381 __count_zone_vm_events(PGSTEAL_DIRECT, zone,
1382 nr_reclaimed);
1383 }
KOSAKI Motohiroe247dbc2010-08-09 17:19:28 -07001384
Hugh Dickins3f797682012-01-12 17:20:07 -08001385 putback_inactive_pages(mz, &page_list);
1386
Konstantin Khlebnikov650e0952012-05-29 15:06:59 -07001387 __mod_zone_page_state(zone, NR_ISOLATED_ANON + file, -nr_taken);
Hugh Dickins3f797682012-01-12 17:20:07 -08001388
1389 spin_unlock_irq(&zone->lru_lock);
1390
1391 free_hot_cold_page_list(&page_list, 1);
Mel Gormane11da5b2010-10-26 14:21:40 -07001392
Mel Gorman92df3a72011-10-31 17:07:56 -07001393 /*
1394 * If reclaim is isolating dirty pages under writeback, it implies
1395 * that the long-lived page allocation rate is exceeding the page
1396 * laundering rate. Either the global limits are not being effective
1397 * at throttling processes due to the page distribution throughout
1398 * zones or there is heavy usage of a slow backing device. The
1399 * only option is to throttle from reclaim context which is not ideal
1400 * as there is no guarantee the dirtying process is throttled in the
1401 * same way balance_dirty_pages() manages.
1402 *
1403 * This scales the number of dirty pages that must be under writeback
1404 * before throttling depending on priority. It is a simple backoff
1405 * function that has the most effect in the range DEF_PRIORITY to
1406 * DEF_PRIORITY-2 which is the priority reclaim is considered to be
1407 * in trouble and reclaim is considered to be in trouble.
1408 *
1409 * DEF_PRIORITY 100% isolated pages must be PageWriteback to throttle
1410 * DEF_PRIORITY-1 50% must be PageWriteback
1411 * DEF_PRIORITY-2 25% must be PageWriteback, kswapd in trouble
1412 * ...
1413 * DEF_PRIORITY-6 For SWAP_CLUSTER_MAX isolated pages, throttle if any
1414 * isolated page is PageWriteback
1415 */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001416 if (nr_writeback && nr_writeback >=
1417 (nr_taken >> (DEF_PRIORITY - sc->priority)))
Mel Gorman92df3a72011-10-31 17:07:56 -07001418 wait_iff_congested(zone, BLK_RW_ASYNC, HZ/10);
1419
Mel Gormane11da5b2010-10-26 14:21:40 -07001420 trace_mm_vmscan_lru_shrink_inactive(zone->zone_pgdat->node_id,
1421 zone_idx(zone),
1422 nr_scanned, nr_reclaimed,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001423 sc->priority,
Mel Gorman626ebe72012-05-29 15:06:20 -07001424 trace_shrink_flags(file));
Andrew Morton05ff5132006-03-22 00:08:20 -08001425 return nr_reclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426}
1427
Martin Bligh3bb1a852006-10-28 10:38:24 -07001428/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 * This moves pages from the active list to the inactive list.
1430 *
1431 * We move them the other way if the page is referenced by one or more
1432 * processes, from rmap.
1433 *
1434 * If the pages are mostly unmapped, the processing is fast and it is
1435 * appropriate to hold zone->lru_lock across the whole operation. But if
1436 * the pages are mapped, the processing is slow (page_referenced()) so we
1437 * should drop zone->lru_lock around each page. It's impossible to balance
1438 * this, so instead we remove the pages from the LRU while processing them.
1439 * It is safe to rely on PG_active against the non-LRU pages in here because
1440 * nobody will play with that bit on a non-LRU page.
1441 *
1442 * The downside is that we have to touch page->_count against each page.
1443 * But we had to alter page->flags anyway.
1444 */
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08001445
Wu Fengguang3eb41402009-06-16 15:33:13 -07001446static void move_active_pages_to_lru(struct zone *zone,
1447 struct list_head *list,
Hugh Dickins2bcf8872012-01-12 17:19:56 -08001448 struct list_head *pages_to_free,
Wu Fengguang3eb41402009-06-16 15:33:13 -07001449 enum lru_list lru)
1450{
1451 unsigned long pgmoved = 0;
Wu Fengguang3eb41402009-06-16 15:33:13 -07001452 struct page *page;
1453
Wu Fengguang3eb41402009-06-16 15:33:13 -07001454 while (!list_empty(list)) {
Johannes Weiner925b7672012-01-12 17:18:15 -08001455 struct lruvec *lruvec;
1456
Wu Fengguang3eb41402009-06-16 15:33:13 -07001457 page = lru_to_page(list);
Wu Fengguang3eb41402009-06-16 15:33:13 -07001458
1459 VM_BUG_ON(PageLRU(page));
1460 SetPageLRU(page);
1461
Johannes Weiner925b7672012-01-12 17:18:15 -08001462 lruvec = mem_cgroup_lru_add_list(zone, page, lru);
1463 list_move(&page->lru, &lruvec->lists[lru]);
Rik van Riel2c888cf2011-01-13 15:47:13 -08001464 pgmoved += hpage_nr_pages(page);
Wu Fengguang3eb41402009-06-16 15:33:13 -07001465
Hugh Dickins2bcf8872012-01-12 17:19:56 -08001466 if (put_page_testzero(page)) {
1467 __ClearPageLRU(page);
1468 __ClearPageActive(page);
1469 del_page_from_lru_list(zone, page, lru);
1470
1471 if (unlikely(PageCompound(page))) {
1472 spin_unlock_irq(&zone->lru_lock);
1473 (*get_compound_page_dtor(page))(page);
1474 spin_lock_irq(&zone->lru_lock);
1475 } else
1476 list_add(&page->lru, pages_to_free);
Wu Fengguang3eb41402009-06-16 15:33:13 -07001477 }
1478 }
1479 __mod_zone_page_state(zone, NR_LRU_BASE + lru, pgmoved);
1480 if (!is_active_lru(lru))
1481 __count_vm_events(PGDEACTIVATE, pgmoved);
1482}
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08001483
Hugh Dickinsf6260122012-01-12 17:20:06 -08001484static void shrink_active_list(unsigned long nr_to_scan,
Johannes Weinerf16015f2012-01-12 17:17:52 -08001485 struct mem_cgroup_zone *mz,
1486 struct scan_control *sc,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001487 enum lru_list lru)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488{
KOSAKI Motohiro44c241f2009-09-21 17:01:35 -07001489 unsigned long nr_taken;
Hugh Dickinsf6260122012-01-12 17:20:06 -08001490 unsigned long nr_scanned;
Wu Fengguang6fe6b7e2009-06-16 15:33:05 -07001491 unsigned long vm_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 LIST_HEAD(l_hold); /* The pages which were snipped off */
Wu Fengguang8cab4752009-06-16 15:33:12 -07001493 LIST_HEAD(l_active);
Christoph Lameterb69408e2008-10-18 20:26:14 -07001494 LIST_HEAD(l_inactive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 struct page *page;
Johannes Weinerf16015f2012-01-12 17:17:52 -08001496 struct zone_reclaim_stat *reclaim_stat = get_reclaim_stat(mz);
KOSAKI Motohiro44c241f2009-09-21 17:01:35 -07001497 unsigned long nr_rotated = 0;
Konstantin Khlebnikov6d8a50e2012-05-29 15:06:54 -07001498 isolate_mode_t isolate_mode = 0;
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001499 int file = is_file_lru(lru);
Johannes Weinerf16015f2012-01-12 17:17:52 -08001500 struct zone *zone = mz->zone;
Konstantin Khlebnikov3a15fe82012-05-29 15:06:58 -07001501 struct lruvec *lruvec = mem_cgroup_zone_lruvec(zone, mz->mem_cgroup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
1503 lru_add_drain();
Minchan Kimf80c0672011-10-31 17:06:55 -07001504
1505 if (!sc->may_unmap)
Hillf Danton61317282012-03-21 16:33:48 -07001506 isolate_mode |= ISOLATE_UNMAPPED;
Minchan Kimf80c0672011-10-31 17:06:55 -07001507 if (!sc->may_writepage)
Hillf Danton61317282012-03-21 16:33:48 -07001508 isolate_mode |= ISOLATE_CLEAN;
Minchan Kimf80c0672011-10-31 17:06:55 -07001509
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 spin_lock_irq(&zone->lru_lock);
Johannes Weiner925b7672012-01-12 17:18:15 -08001511
Konstantin Khlebnikov3a15fe82012-05-29 15:06:58 -07001512 nr_taken = isolate_lru_pages(nr_to_scan, lruvec, &l_hold,
1513 &nr_scanned, sc, isolate_mode, lru);
Johannes Weiner89b5fae2012-01-12 17:17:50 -08001514 if (global_reclaim(sc))
Hugh Dickinsf6260122012-01-12 17:20:06 -08001515 zone->pages_scanned += nr_scanned;
Johannes Weiner89b5fae2012-01-12 17:17:50 -08001516
Johannes Weinerb7c46d12009-09-21 17:02:56 -07001517 reclaim_stat->recent_scanned[file] += nr_taken;
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08001518
Hugh Dickinsf6260122012-01-12 17:20:06 -08001519 __count_zone_vm_events(PGREFILL, zone, nr_scanned);
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001520 __mod_zone_page_state(zone, NR_LRU_BASE + lru, -nr_taken);
KOSAKI Motohiroa7312862009-09-21 17:01:37 -07001521 __mod_zone_page_state(zone, NR_ISOLATED_ANON + file, nr_taken);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 spin_unlock_irq(&zone->lru_lock);
1523
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 while (!list_empty(&l_hold)) {
1525 cond_resched();
1526 page = lru_to_page(&l_hold);
1527 list_del(&page->lru);
Rik van Riel7e9cd482008-10-18 20:26:35 -07001528
Lee Schermerhorn894bc312008-10-18 20:26:39 -07001529 if (unlikely(!page_evictable(page, NULL))) {
1530 putback_lru_page(page);
1531 continue;
1532 }
1533
Mel Gormancc715d92012-03-21 16:34:00 -07001534 if (unlikely(buffer_heads_over_limit)) {
1535 if (page_has_private(page) && trylock_page(page)) {
1536 if (page_has_private(page))
1537 try_to_release_page(page, 0);
1538 unlock_page(page);
1539 }
1540 }
1541
Johannes Weiner2e3d11f2012-05-29 15:06:25 -07001542 if (page_referenced(page, 0, sc->target_mem_cgroup,
1543 &vm_flags)) {
Rik van Riel9992af12011-01-13 15:47:13 -08001544 nr_rotated += hpage_nr_pages(page);
Wu Fengguang8cab4752009-06-16 15:33:12 -07001545 /*
1546 * Identify referenced, file-backed active pages and
1547 * give them one more trip around the active list. So
1548 * that executable code get better chances to stay in
1549 * memory under moderate memory pressure. Anon pages
1550 * are not likely to be evicted by use-once streaming
1551 * IO, plus JVM can create lots of anon VM_EXEC pages,
1552 * so we ignore them here.
1553 */
Wu Fengguang41e20982009-10-26 16:49:53 -07001554 if ((vm_flags & VM_EXEC) && page_is_file_cache(page)) {
Wu Fengguang8cab4752009-06-16 15:33:12 -07001555 list_add(&page->lru, &l_active);
1556 continue;
1557 }
1558 }
Rik van Riel7e9cd482008-10-18 20:26:35 -07001559
KOSAKI Motohiro5205e562009-09-21 17:01:44 -07001560 ClearPageActive(page); /* we are de-activating */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 list_add(&page->lru, &l_inactive);
1562 }
1563
Andrew Mortonb5557492009-01-06 14:40:13 -08001564 /*
Wu Fengguang8cab4752009-06-16 15:33:12 -07001565 * Move pages back to the lru list.
Andrew Mortonb5557492009-01-06 14:40:13 -08001566 */
Johannes Weiner2a1dc502008-12-01 03:00:35 +01001567 spin_lock_irq(&zone->lru_lock);
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001568 /*
Wu Fengguang8cab4752009-06-16 15:33:12 -07001569 * Count referenced pages from currently used mappings as rotated,
1570 * even though only some of them are actually re-activated. This
1571 * helps balance scan pressure between file and anonymous pages in
1572 * get_scan_ratio.
Rik van Riel7e9cd482008-10-18 20:26:35 -07001573 */
Johannes Weinerb7c46d12009-09-21 17:02:56 -07001574 reclaim_stat->recent_rotated[file] += nr_rotated;
Rik van Riel556adec2008-10-18 20:26:34 -07001575
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001576 move_active_pages_to_lru(zone, &l_active, &l_hold, lru);
1577 move_active_pages_to_lru(zone, &l_inactive, &l_hold, lru - LRU_ACTIVE);
KOSAKI Motohiroa7312862009-09-21 17:01:37 -07001578 __mod_zone_page_state(zone, NR_ISOLATED_ANON + file, -nr_taken);
Christoph Lameterf8891e52006-06-30 01:55:45 -07001579 spin_unlock_irq(&zone->lru_lock);
Hugh Dickins2bcf8872012-01-12 17:19:56 -08001580
1581 free_hot_cold_page_list(&l_hold, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582}
1583
Minchan Kim74e3f3c2010-10-26 14:21:31 -07001584#ifdef CONFIG_SWAP
KOSAKI Motohiro14797e22009-01-07 18:08:18 -08001585static int inactive_anon_is_low_global(struct zone *zone)
KOSAKI Motohirof89eb902009-01-07 18:08:14 -08001586{
1587 unsigned long active, inactive;
1588
1589 active = zone_page_state(zone, NR_ACTIVE_ANON);
1590 inactive = zone_page_state(zone, NR_INACTIVE_ANON);
1591
1592 if (inactive * zone->inactive_ratio < active)
1593 return 1;
1594
1595 return 0;
1596}
1597
KOSAKI Motohiro14797e22009-01-07 18:08:18 -08001598/**
1599 * inactive_anon_is_low - check if anonymous pages need to be deactivated
1600 * @zone: zone to check
1601 * @sc: scan control of this context
1602 *
1603 * Returns true if the zone does not have enough inactive anon pages,
1604 * meaning some active anon pages need to be deactivated.
1605 */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001606static int inactive_anon_is_low(struct mem_cgroup_zone *mz)
KOSAKI Motohiro14797e22009-01-07 18:08:18 -08001607{
Minchan Kim74e3f3c2010-10-26 14:21:31 -07001608 /*
1609 * If we don't have swap space, anonymous page deactivation
1610 * is pointless.
1611 */
1612 if (!total_swap_pages)
1613 return 0;
1614
Hugh Dickinsc12af162012-05-29 15:06:52 -07001615 if (!mem_cgroup_disabled())
Johannes Weinerf16015f2012-01-12 17:17:52 -08001616 return mem_cgroup_inactive_anon_is_low(mz->mem_cgroup,
1617 mz->zone);
1618
1619 return inactive_anon_is_low_global(mz->zone);
KOSAKI Motohiro14797e22009-01-07 18:08:18 -08001620}
Minchan Kim74e3f3c2010-10-26 14:21:31 -07001621#else
Johannes Weinerf16015f2012-01-12 17:17:52 -08001622static inline int inactive_anon_is_low(struct mem_cgroup_zone *mz)
Minchan Kim74e3f3c2010-10-26 14:21:31 -07001623{
1624 return 0;
1625}
1626#endif
KOSAKI Motohiro14797e22009-01-07 18:08:18 -08001627
Rik van Riel56e49d22009-06-16 15:32:28 -07001628static int inactive_file_is_low_global(struct zone *zone)
1629{
1630 unsigned long active, inactive;
1631
1632 active = zone_page_state(zone, NR_ACTIVE_FILE);
1633 inactive = zone_page_state(zone, NR_INACTIVE_FILE);
1634
1635 return (active > inactive);
1636}
1637
1638/**
1639 * inactive_file_is_low - check if file pages need to be deactivated
Johannes Weinerf16015f2012-01-12 17:17:52 -08001640 * @mz: memory cgroup and zone to check
Rik van Riel56e49d22009-06-16 15:32:28 -07001641 *
1642 * When the system is doing streaming IO, memory pressure here
1643 * ensures that active file pages get deactivated, until more
1644 * than half of the file pages are on the inactive list.
1645 *
1646 * Once we get to that situation, protect the system's working
1647 * set from being evicted by disabling active file page aging.
1648 *
1649 * This uses a different ratio than the anonymous pages, because
1650 * the page cache uses a use-once replacement algorithm.
1651 */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001652static int inactive_file_is_low(struct mem_cgroup_zone *mz)
Rik van Riel56e49d22009-06-16 15:32:28 -07001653{
Hugh Dickinsc12af162012-05-29 15:06:52 -07001654 if (!mem_cgroup_disabled())
Johannes Weinerf16015f2012-01-12 17:17:52 -08001655 return mem_cgroup_inactive_file_is_low(mz->mem_cgroup,
1656 mz->zone);
Rik van Riel56e49d22009-06-16 15:32:28 -07001657
Johannes Weinerf16015f2012-01-12 17:17:52 -08001658 return inactive_file_is_low_global(mz->zone);
Rik van Riel56e49d22009-06-16 15:32:28 -07001659}
1660
Johannes Weinerf16015f2012-01-12 17:17:52 -08001661static int inactive_list_is_low(struct mem_cgroup_zone *mz, int file)
Rik van Rielb39415b2009-12-14 17:59:48 -08001662{
1663 if (file)
Johannes Weinerf16015f2012-01-12 17:17:52 -08001664 return inactive_file_is_low(mz);
Rik van Rielb39415b2009-12-14 17:59:48 -08001665 else
Johannes Weinerf16015f2012-01-12 17:17:52 -08001666 return inactive_anon_is_low(mz);
Rik van Rielb39415b2009-12-14 17:59:48 -08001667}
1668
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001669static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
Johannes Weinerf16015f2012-01-12 17:17:52 -08001670 struct mem_cgroup_zone *mz,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001671 struct scan_control *sc)
Christoph Lameterb69408e2008-10-18 20:26:14 -07001672{
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001673 int file = is_file_lru(lru);
1674
Rik van Rielb39415b2009-12-14 17:59:48 -08001675 if (is_active_lru(lru)) {
Johannes Weinerf16015f2012-01-12 17:17:52 -08001676 if (inactive_list_is_low(mz, file))
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001677 shrink_active_list(nr_to_scan, mz, sc, lru);
Rik van Riel556adec2008-10-18 20:26:34 -07001678 return 0;
1679 }
1680
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001681 return shrink_inactive_list(nr_to_scan, mz, sc, lru);
Christoph Lameterb69408e2008-10-18 20:26:14 -07001682}
1683
Konstantin Khlebnikov1e09e002012-05-29 15:06:57 -07001684static int vmscan_swappiness(struct scan_control *sc)
KAMEZAWA Hiroyuki1f4c0252011-07-26 16:08:21 -07001685{
Johannes Weiner89b5fae2012-01-12 17:17:50 -08001686 if (global_reclaim(sc))
KAMEZAWA Hiroyuki1f4c0252011-07-26 16:08:21 -07001687 return vm_swappiness;
Konstantin Khlebnikov1e09e002012-05-29 15:06:57 -07001688 return mem_cgroup_swappiness(sc->target_mem_cgroup);
KAMEZAWA Hiroyuki1f4c0252011-07-26 16:08:21 -07001689}
1690
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691/*
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001692 * Determine how aggressively the anon and file LRU lists should be
1693 * scanned. The relative value of each set of LRU lists is determined
1694 * by looking at the fraction of the pages scanned we did rotate back
1695 * onto the active list instead of evict.
1696 *
Shaohua Li76a33fc2010-05-24 14:32:36 -07001697 * nr[0] = anon pages to scan; nr[1] = file pages to scan
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001698 */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001699static void get_scan_count(struct mem_cgroup_zone *mz, struct scan_control *sc,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001700 unsigned long *nr)
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001701{
1702 unsigned long anon, file, free;
1703 unsigned long anon_prio, file_prio;
1704 unsigned long ap, fp;
Johannes Weinerf16015f2012-01-12 17:17:52 -08001705 struct zone_reclaim_stat *reclaim_stat = get_reclaim_stat(mz);
Shaohua Li76a33fc2010-05-24 14:32:36 -07001706 u64 fraction[2], denominator;
Hugh Dickins41113042012-01-12 17:20:01 -08001707 enum lru_list lru;
Shaohua Li76a33fc2010-05-24 14:32:36 -07001708 int noswap = 0;
Johannes Weinera4d3e9e2011-09-14 16:21:52 -07001709 bool force_scan = false;
KAMEZAWA Hiroyuki246e87a2011-05-26 16:25:34 -07001710
Johannes Weinerf11c0ca2011-10-31 17:07:27 -07001711 /*
1712 * If the zone or memcg is small, nr[l] can be 0. This
1713 * results in no scanning on this priority and a potential
1714 * priority drop. Global direct reclaim can go to the next
1715 * zone and tends to have no problems. Global kswapd is for
1716 * zone balancing and it needs to scan a minimum amount. When
1717 * reclaiming for a memcg, a priority drop can cause high
1718 * latencies, so it's better to scan a minimum amount there as
1719 * well.
1720 */
Lisa Due0935212013-09-11 14:22:36 -07001721 if (current_is_kswapd() && !zone_reclaimable(mz->zone))
Johannes Weinera4d3e9e2011-09-14 16:21:52 -07001722 force_scan = true;
Johannes Weiner89b5fae2012-01-12 17:17:50 -08001723 if (!global_reclaim(sc))
Johannes Weinera4d3e9e2011-09-14 16:21:52 -07001724 force_scan = true;
Shaohua Li76a33fc2010-05-24 14:32:36 -07001725
1726 /* If we have no swap space, do not bother scanning anon pages. */
Shaohua Li1abbca72013-02-22 16:34:38 -08001727 if (!sc->may_swap || (get_nr_swap_pages() <= 0)) {
Shaohua Li76a33fc2010-05-24 14:32:36 -07001728 noswap = 1;
1729 fraction[0] = 0;
1730 fraction[1] = 1;
1731 denominator = 1;
1732 goto out;
1733 }
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001734
Johannes Weinerf16015f2012-01-12 17:17:52 -08001735 anon = zone_nr_lru_pages(mz, LRU_ACTIVE_ANON) +
1736 zone_nr_lru_pages(mz, LRU_INACTIVE_ANON);
1737 file = zone_nr_lru_pages(mz, LRU_ACTIVE_FILE) +
1738 zone_nr_lru_pages(mz, LRU_INACTIVE_FILE);
Johannes Weinera4d3e9e2011-09-14 16:21:52 -07001739
Johannes Weiner89b5fae2012-01-12 17:17:50 -08001740 if (global_reclaim(sc)) {
Johannes Weinerf16015f2012-01-12 17:17:52 -08001741 free = zone_page_state(mz->zone, NR_FREE_PAGES);
KOSAKI Motohiroeeee9a82009-01-07 18:08:17 -08001742 /* If we have very few page cache pages,
1743 force-scan anon pages. */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001744 if (unlikely(file + free <= high_wmark_pages(mz->zone))) {
Shaohua Li76a33fc2010-05-24 14:32:36 -07001745 fraction[0] = 1;
1746 fraction[1] = 0;
1747 denominator = 1;
1748 goto out;
KOSAKI Motohiroeeee9a82009-01-07 18:08:17 -08001749 }
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001750 }
1751
1752 /*
KOSAKI Motohiro58c37f62010-08-09 17:19:51 -07001753 * With swappiness at 100, anonymous and file have the same priority.
1754 * This scanning priority is essentially the inverse of IO cost.
1755 */
Konstantin Khlebnikov1e09e002012-05-29 15:06:57 -07001756 anon_prio = vmscan_swappiness(sc);
1757 file_prio = 200 - vmscan_swappiness(sc);
KOSAKI Motohiro58c37f62010-08-09 17:19:51 -07001758
1759 /*
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001760 * OK, so we have swap space and a fair amount of page cache
1761 * pages. We use the recently rotated / recently scanned
1762 * ratios to determine how valuable each cache is.
1763 *
1764 * Because workloads change over time (and to avoid overflow)
1765 * we keep these statistics as a floating average, which ends
1766 * up weighing recent references more than old ones.
1767 *
1768 * anon in [0], file in [1]
1769 */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001770 spin_lock_irq(&mz->zone->lru_lock);
KOSAKI Motohiro6e901572009-01-07 18:08:15 -08001771 if (unlikely(reclaim_stat->recent_scanned[0] > anon / 4)) {
KOSAKI Motohiro6e901572009-01-07 18:08:15 -08001772 reclaim_stat->recent_scanned[0] /= 2;
1773 reclaim_stat->recent_rotated[0] /= 2;
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001774 }
1775
KOSAKI Motohiro6e901572009-01-07 18:08:15 -08001776 if (unlikely(reclaim_stat->recent_scanned[1] > file / 4)) {
KOSAKI Motohiro6e901572009-01-07 18:08:15 -08001777 reclaim_stat->recent_scanned[1] /= 2;
1778 reclaim_stat->recent_rotated[1] /= 2;
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001779 }
1780
1781 /*
Rik van Riel00d80892008-11-19 15:36:44 -08001782 * The amount of pressure on anon vs file pages is inversely
1783 * proportional to the fraction of recently scanned pages on
1784 * each list that were recently referenced and in active use.
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001785 */
Satoru Moriya1cc00392012-05-29 15:06:47 -07001786 ap = anon_prio * (reclaim_stat->recent_scanned[0] + 1);
KOSAKI Motohiro6e901572009-01-07 18:08:15 -08001787 ap /= reclaim_stat->recent_rotated[0] + 1;
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001788
Satoru Moriya1cc00392012-05-29 15:06:47 -07001789 fp = file_prio * (reclaim_stat->recent_scanned[1] + 1);
KOSAKI Motohiro6e901572009-01-07 18:08:15 -08001790 fp /= reclaim_stat->recent_rotated[1] + 1;
Johannes Weinerf16015f2012-01-12 17:17:52 -08001791 spin_unlock_irq(&mz->zone->lru_lock);
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001792
Shaohua Li76a33fc2010-05-24 14:32:36 -07001793 fraction[0] = ap;
1794 fraction[1] = fp;
1795 denominator = ap + fp + 1;
1796out:
Hugh Dickins41113042012-01-12 17:20:01 -08001797 for_each_evictable_lru(lru) {
1798 int file = is_file_lru(lru);
Shaohua Li76a33fc2010-05-24 14:32:36 -07001799 unsigned long scan;
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001800
Hugh Dickins41113042012-01-12 17:20:01 -08001801 scan = zone_nr_lru_pages(mz, lru);
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001802 if (sc->priority || noswap || !vmscan_swappiness(sc)) {
1803 scan >>= sc->priority;
Johannes Weinerf11c0ca2011-10-31 17:07:27 -07001804 if (!scan && force_scan)
1805 scan = SWAP_CLUSTER_MAX;
Shaohua Li76a33fc2010-05-24 14:32:36 -07001806 scan = div64_u64(scan * fraction[file], denominator);
1807 }
Hugh Dickins41113042012-01-12 17:20:01 -08001808 nr[lru] = scan;
Shaohua Li76a33fc2010-05-24 14:32:36 -07001809 }
Wu Fengguang6e08a362009-06-16 15:32:29 -07001810}
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001811
Mel Gorman626ebe72012-05-29 15:06:20 -07001812/* Use reclaim/compaction for costly allocs or under memory pressure */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001813static bool in_reclaim_compaction(struct scan_control *sc)
Mel Gorman626ebe72012-05-29 15:06:20 -07001814{
1815 if (COMPACTION_BUILD && sc->order &&
1816 (sc->order > PAGE_ALLOC_COSTLY_ORDER ||
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001817 sc->priority < DEF_PRIORITY - 2))
Mel Gorman626ebe72012-05-29 15:06:20 -07001818 return true;
1819
1820 return false;
1821}
1822
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001823/*
Mel Gorman626ebe72012-05-29 15:06:20 -07001824 * Reclaim/compaction is used for high-order allocation requests. It reclaims
1825 * order-0 pages before compacting the zone. should_continue_reclaim() returns
1826 * true if more pages should be reclaimed such that when the page allocator
1827 * calls try_to_compact_zone() that it will have enough free pages to succeed.
1828 * It will give up earlier than that if there is difficulty reclaiming pages.
Mel Gorman3e7d3442011-01-13 15:45:56 -08001829 */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001830static inline bool should_continue_reclaim(struct mem_cgroup_zone *mz,
Mel Gorman3e7d3442011-01-13 15:45:56 -08001831 unsigned long nr_reclaimed,
1832 unsigned long nr_scanned,
1833 struct scan_control *sc)
1834{
1835 unsigned long pages_for_compaction;
1836 unsigned long inactive_lru_pages;
1837
1838 /* If not in reclaim/compaction mode, stop */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001839 if (!in_reclaim_compaction(sc))
Mel Gorman3e7d3442011-01-13 15:45:56 -08001840 return false;
1841
Mel Gorman28765922011-02-25 14:44:20 -08001842 /* Consider stopping depending on scan and reclaim activity */
1843 if (sc->gfp_mask & __GFP_REPEAT) {
1844 /*
1845 * For __GFP_REPEAT allocations, stop reclaiming if the
1846 * full LRU list has been scanned and we are still failing
1847 * to reclaim pages. This full LRU scan is potentially
1848 * expensive but a __GFP_REPEAT caller really wants to succeed
1849 */
1850 if (!nr_reclaimed && !nr_scanned)
1851 return false;
1852 } else {
1853 /*
1854 * For non-__GFP_REPEAT allocations which can presumably
1855 * fail without consequence, stop if we failed to reclaim
1856 * any pages from the last SWAP_CLUSTER_MAX number of
1857 * pages that were scanned. This will return to the
1858 * caller faster at the risk reclaim/compaction and
1859 * the resulting allocation attempt fails
1860 */
1861 if (!nr_reclaimed)
1862 return false;
1863 }
Mel Gorman3e7d3442011-01-13 15:45:56 -08001864
1865 /*
1866 * If we have not reclaimed enough pages for compaction and the
1867 * inactive lists are large enough, continue reclaiming
1868 */
1869 pages_for_compaction = (2UL << sc->order);
Johannes Weinerf16015f2012-01-12 17:17:52 -08001870 inactive_lru_pages = zone_nr_lru_pages(mz, LRU_INACTIVE_FILE);
Shaohua Li1abbca72013-02-22 16:34:38 -08001871 if (get_nr_swap_pages() > 0)
Johannes Weinerf16015f2012-01-12 17:17:52 -08001872 inactive_lru_pages += zone_nr_lru_pages(mz, LRU_INACTIVE_ANON);
Mel Gorman3e7d3442011-01-13 15:45:56 -08001873 if (sc->nr_reclaimed < pages_for_compaction &&
1874 inactive_lru_pages > pages_for_compaction)
1875 return true;
1876
1877 /* If compaction would go ahead or the allocation would succeed, stop */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001878 switch (compaction_suitable(mz->zone, sc->order)) {
Mel Gorman3e7d3442011-01-13 15:45:56 -08001879 case COMPACT_PARTIAL:
1880 case COMPACT_CONTINUE:
1881 return false;
1882 default:
1883 return true;
1884 }
1885}
1886
1887/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 * This is a basic per-zone page freer. Used by both kswapd and direct reclaim.
1889 */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001890static void shrink_mem_cgroup_zone(struct mem_cgroup_zone *mz,
Johannes Weinerf16015f2012-01-12 17:17:52 -08001891 struct scan_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892{
Christoph Lameterb69408e2008-10-18 20:26:14 -07001893 unsigned long nr[NR_LRU_LISTS];
Christoph Lameter86959492006-03-22 00:08:18 -08001894 unsigned long nr_to_scan;
Hugh Dickins41113042012-01-12 17:20:01 -08001895 enum lru_list lru;
Johannes Weinerf0fdc5e2011-02-10 15:01:34 -08001896 unsigned long nr_reclaimed, nr_scanned;
KOSAKI Motohiro22fba332009-12-14 17:59:10 -08001897 unsigned long nr_to_reclaim = sc->nr_to_reclaim;
Shaohua Li3da367c2011-10-31 17:07:03 -07001898 struct blk_plug plug;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
Mel Gorman3e7d3442011-01-13 15:45:56 -08001900restart:
1901 nr_reclaimed = 0;
Johannes Weinerf0fdc5e2011-02-10 15:01:34 -08001902 nr_scanned = sc->nr_scanned;
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001903 get_scan_count(mz, sc, nr);
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08001904
Shaohua Li3da367c2011-10-31 17:07:03 -07001905 blk_start_plug(&plug);
Rik van Riel556adec2008-10-18 20:26:34 -07001906 while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
1907 nr[LRU_INACTIVE_FILE]) {
Hugh Dickins41113042012-01-12 17:20:01 -08001908 for_each_evictable_lru(lru) {
1909 if (nr[lru]) {
KOSAKI Motohiroece74b22009-12-14 17:59:14 -08001910 nr_to_scan = min_t(unsigned long,
Hugh Dickins41113042012-01-12 17:20:01 -08001911 nr[lru], SWAP_CLUSTER_MAX);
1912 nr[lru] -= nr_to_scan;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913
Hugh Dickins41113042012-01-12 17:20:01 -08001914 nr_reclaimed += shrink_list(lru, nr_to_scan,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001915 mz, sc);
Christoph Lameterb69408e2008-10-18 20:26:14 -07001916 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 }
Rik van Riela79311c2009-01-06 14:40:01 -08001918 /*
1919 * On large memory systems, scan >> priority can become
1920 * really large. This is fine for the starting priority;
1921 * we want to put equal scanning pressure on each zone.
1922 * However, if the VM has a harder time of freeing pages,
1923 * with multiple processes reclaiming pages, the total
1924 * freeing target can get unreasonably large.
1925 */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001926 if (nr_reclaimed >= nr_to_reclaim &&
1927 sc->priority < DEF_PRIORITY)
Rik van Riela79311c2009-01-06 14:40:01 -08001928 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 }
Shaohua Li3da367c2011-10-31 17:07:03 -07001930 blk_finish_plug(&plug);
Mel Gorman3e7d3442011-01-13 15:45:56 -08001931 sc->nr_reclaimed += nr_reclaimed;
KOSAKI Motohiro01dbe5c2009-01-06 14:40:02 -08001932
Rik van Riel556adec2008-10-18 20:26:34 -07001933 /*
1934 * Even if we did not try to evict anon pages at all, we want to
1935 * rebalance the anon lru active/inactive ratio.
1936 */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001937 if (inactive_anon_is_low(mz))
Konstantin Khlebnikov7f8a9202012-05-29 15:06:53 -07001938 shrink_active_list(SWAP_CLUSTER_MAX, mz,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001939 sc, LRU_ACTIVE_ANON);
Rik van Riel556adec2008-10-18 20:26:34 -07001940
Mel Gorman3e7d3442011-01-13 15:45:56 -08001941 /* reclaim/compaction might need reclaim to continue */
Johannes Weinerf16015f2012-01-12 17:17:52 -08001942 if (should_continue_reclaim(mz, nr_reclaimed,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001943 sc->nr_scanned - nr_scanned, sc))
Mel Gorman3e7d3442011-01-13 15:45:56 -08001944 goto restart;
1945
Andrew Morton232ea4d2007-02-28 20:13:21 -08001946 throttle_vm_writeout(sc->gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947}
1948
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001949static void shrink_zone(struct zone *zone, struct scan_control *sc)
Johannes Weinerf16015f2012-01-12 17:17:52 -08001950{
Johannes Weiner56600482012-01-12 17:17:59 -08001951 struct mem_cgroup *root = sc->target_mem_cgroup;
1952 struct mem_cgroup_reclaim_cookie reclaim = {
Johannes Weinerf16015f2012-01-12 17:17:52 -08001953 .zone = zone,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001954 .priority = sc->priority,
Johannes Weinerf16015f2012-01-12 17:17:52 -08001955 };
Johannes Weiner56600482012-01-12 17:17:59 -08001956 struct mem_cgroup *memcg;
Johannes Weinerf16015f2012-01-12 17:17:52 -08001957
Johannes Weiner56600482012-01-12 17:17:59 -08001958 memcg = mem_cgroup_iter(root, NULL, &reclaim);
1959 do {
1960 struct mem_cgroup_zone mz = {
1961 .mem_cgroup = memcg,
1962 .zone = zone,
1963 };
1964
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07001965 shrink_mem_cgroup_zone(&mz, sc);
Johannes Weiner56600482012-01-12 17:17:59 -08001966 /*
1967 * Limit reclaim has historically picked one memcg and
1968 * scanned it with decreasing priority levels until
1969 * nr_to_reclaim had been reclaimed. This priority
1970 * cycle is thus over after a single memcg.
Johannes Weinerb95a2f22012-01-12 17:18:06 -08001971 *
1972 * Direct reclaim and kswapd, on the other hand, have
1973 * to scan all memory cgroups to fulfill the overall
1974 * scan target for the zone.
Johannes Weiner56600482012-01-12 17:17:59 -08001975 */
1976 if (!global_reclaim(sc)) {
1977 mem_cgroup_iter_break(root, memcg);
1978 break;
1979 }
1980 memcg = mem_cgroup_iter(root, memcg, &reclaim);
1981 } while (memcg);
Johannes Weinerf16015f2012-01-12 17:17:52 -08001982}
1983
Mel Gormanfe4b1b22012-01-12 17:19:45 -08001984/* Returns true if compaction should go ahead for a high-order request */
1985static inline bool compaction_ready(struct zone *zone, struct scan_control *sc)
1986{
1987 unsigned long balance_gap, watermark;
1988 bool watermark_ok;
1989
1990 /* Do not consider compaction for orders reclaim is meant to satisfy */
1991 if (sc->order <= PAGE_ALLOC_COSTLY_ORDER)
1992 return false;
1993
1994 /*
1995 * Compaction takes time to run and there are potentially other
1996 * callers using the pages just freed. Continue reclaiming until
1997 * there is a buffer of free pages available to give compaction
1998 * a reasonable chance of completing and allocating the page
1999 */
2000 balance_gap = min(low_wmark_pages(zone),
2001 (zone->present_pages + KSWAPD_ZONE_BALANCE_GAP_RATIO-1) /
2002 KSWAPD_ZONE_BALANCE_GAP_RATIO);
2003 watermark = high_wmark_pages(zone) + balance_gap + (2UL << sc->order);
2004 watermark_ok = zone_watermark_ok_safe(zone, 0, watermark, 0, 0);
2005
2006 /*
2007 * If compaction is deferred, reclaim up to a point where
2008 * compaction will have a chance of success when re-enabled
2009 */
Rik van Rielaff62242012-03-21 16:33:52 -07002010 if (compaction_deferred(zone, sc->order))
Mel Gormanfe4b1b22012-01-12 17:19:45 -08002011 return watermark_ok;
2012
2013 /* If compaction is not ready to start, keep reclaiming */
2014 if (!compaction_suitable(zone, sc->order))
2015 return false;
2016
2017 return watermark_ok;
2018}
2019
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020/*
2021 * This is the direct reclaim path, for page-allocating processes. We only
2022 * try to reclaim pages from zones which will satisfy the caller's allocation
2023 * request.
2024 *
Mel Gorman41858962009-06-16 15:32:12 -07002025 * We reclaim from a zone even if that zone is over high_wmark_pages(zone).
2026 * Because:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 * a) The caller may be trying to free *extra* pages to satisfy a higher-order
2028 * allocation or
Mel Gorman41858962009-06-16 15:32:12 -07002029 * b) The target zone may be at high_wmark_pages(zone) but the lower zones
2030 * must go *over* high_wmark_pages(zone) to satisfy the `incremental min'
2031 * zone defense algorithm.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 * If a zone is deemed to be full of pinned pages then just give it a light
2034 * scan then give up on it.
Mel Gormane0c23272011-10-31 17:09:33 -07002035 *
2036 * This function returns true if a zone is being reclaimed for a costly
Mel Gormanfe4b1b22012-01-12 17:19:45 -08002037 * high-order allocation and compaction is ready to begin. This indicates to
Mel Gorman0cee34f2012-01-12 17:19:49 -08002038 * the caller that it should consider retrying the allocation instead of
2039 * further reclaim.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002041static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042{
Mel Gormandd1a2392008-04-28 02:12:17 -07002043 struct zoneref *z;
Mel Gorman54a6eb52008-04-28 02:12:16 -07002044 struct zone *zone;
Ying Hand149e3b2011-05-26 16:25:27 -07002045 unsigned long nr_soft_reclaimed;
2046 unsigned long nr_soft_scanned;
Mel Gorman0cee34f2012-01-12 17:19:49 -08002047 bool aborted_reclaim = false;
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08002048
Mel Gormancc715d92012-03-21 16:34:00 -07002049 /*
2050 * If the number of buffer_heads in the machine exceeds the maximum
2051 * allowed level, force direct reclaim to scan the highmem zone as
2052 * highmem pages could be pinning lowmem pages storing buffer_heads
2053 */
2054 if (buffer_heads_over_limit)
2055 sc->gfp_mask |= __GFP_HIGHMEM;
2056
Mel Gormand4debc62010-08-09 17:19:29 -07002057 for_each_zone_zonelist_nodemask(zone, z, zonelist,
2058 gfp_zone(sc->gfp_mask), sc->nodemask) {
Con Kolivasf3fe6512006-01-06 00:11:15 -08002059 if (!populated_zone(zone))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 continue;
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08002061 /*
2062 * Take care memory controller reclaiming has small influence
2063 * to global LRU.
2064 */
Johannes Weiner89b5fae2012-01-12 17:17:50 -08002065 if (global_reclaim(sc)) {
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08002066 if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
2067 continue;
Lisa Due0935212013-09-11 14:22:36 -07002068 if (sc->priority != DEF_PRIORITY &&
2069 !zone_reclaimable(zone))
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08002070 continue; /* Let kswapd poll it */
Rik van Riele0887c12011-10-31 17:09:31 -07002071 if (COMPACTION_BUILD) {
2072 /*
Mel Gormane0c23272011-10-31 17:09:33 -07002073 * If we already have plenty of memory free for
2074 * compaction in this zone, don't free any more.
2075 * Even though compaction is invoked for any
2076 * non-zero order, only frequent costly order
2077 * reclamation is disruptive enough to become a
Copot Alexandruc7cfa372012-03-21 16:34:10 -07002078 * noticeable problem, like transparent huge
2079 * page allocations.
Rik van Riele0887c12011-10-31 17:09:31 -07002080 */
Mel Gormanfe4b1b22012-01-12 17:19:45 -08002081 if (compaction_ready(zone, sc)) {
Mel Gorman0cee34f2012-01-12 17:19:49 -08002082 aborted_reclaim = true;
Rik van Riele0887c12011-10-31 17:09:31 -07002083 continue;
Mel Gormane0c23272011-10-31 17:09:33 -07002084 }
Rik van Riele0887c12011-10-31 17:09:31 -07002085 }
KAMEZAWA Hiroyukiac34a1a2011-06-27 16:18:12 -07002086 /*
2087 * This steals pages from memory cgroups over softlimit
2088 * and returns the number of reclaimed pages and
2089 * scanned pages. This works for global memory pressure
2090 * and balancing, not for a memcg's limit.
2091 */
2092 nr_soft_scanned = 0;
2093 nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone,
2094 sc->order, sc->gfp_mask,
2095 &nr_soft_scanned);
2096 sc->nr_reclaimed += nr_soft_reclaimed;
2097 sc->nr_scanned += nr_soft_scanned;
2098 /* need some check for avoid more shrink_zone() */
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08002099 }
Nick Piggin408d8542006-09-25 23:31:27 -07002100
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002101 shrink_zone(zone, sc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 }
Mel Gormane0c23272011-10-31 17:09:33 -07002103
Mel Gorman0cee34f2012-01-12 17:19:49 -08002104 return aborted_reclaim;
Minchan Kimd1908362010-09-22 13:05:01 -07002105}
2106
KOSAKI Motohiro929bea72011-04-14 15:22:12 -07002107/* All zones in zonelist are unreclaimable? */
Minchan Kimd1908362010-09-22 13:05:01 -07002108static bool all_unreclaimable(struct zonelist *zonelist,
2109 struct scan_control *sc)
2110{
2111 struct zoneref *z;
2112 struct zone *zone;
Minchan Kimd1908362010-09-22 13:05:01 -07002113
2114 for_each_zone_zonelist_nodemask(zone, z, zonelist,
2115 gfp_zone(sc->gfp_mask), sc->nodemask) {
2116 if (!populated_zone(zone))
2117 continue;
2118 if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
2119 continue;
Lisa Due0935212013-09-11 14:22:36 -07002120 if (zone_reclaimable(zone))
KOSAKI Motohiro929bea72011-04-14 15:22:12 -07002121 return false;
Minchan Kimd1908362010-09-22 13:05:01 -07002122 }
2123
KOSAKI Motohiro929bea72011-04-14 15:22:12 -07002124 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125}
Rik van Riel4f98a2f2008-10-18 20:26:32 -07002126
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127/*
2128 * This is the main entry point to direct page reclaim.
2129 *
2130 * If a full scan of the inactive list fails to free enough memory then we
2131 * are "out of memory" and something needs to be killed.
2132 *
2133 * If the caller is !__GFP_FS then the probability of a failure is reasonably
2134 * high - the zone may be full of dirty or under-writeback pages, which this
Jens Axboe5b0830c2009-09-23 19:37:09 +02002135 * caller can't do much about. We kick the writeback threads and take explicit
2136 * naps in the hope that some of these pages can be written. But if the
2137 * allocating task holds filesystem locks which prevent writeout this might not
2138 * work, and the allocation attempt will fail.
Nishanth Aravamudana41f24e2008-04-29 00:58:25 -07002139 *
2140 * returns: 0, if no pages reclaimed
2141 * else, the number of pages reclaimed
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 */
Mel Gormandac1d272008-04-28 02:12:12 -07002143static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
Ying Hana09ed5e2011-05-24 17:12:26 -07002144 struct scan_control *sc,
2145 struct shrink_control *shrink)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146{
Andrew Morton69e05942006-03-22 00:08:19 -08002147 unsigned long total_scanned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 struct reclaim_state *reclaim_state = current->reclaim_state;
Mel Gormandd1a2392008-04-28 02:12:17 -07002149 struct zoneref *z;
Mel Gorman54a6eb52008-04-28 02:12:16 -07002150 struct zone *zone;
KOSAKI Motohiro22fba332009-12-14 17:59:10 -08002151 unsigned long writeback_threshold;
Mel Gorman0cee34f2012-01-12 17:19:49 -08002152 bool aborted_reclaim;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
Keika Kobayashi873b4772008-07-25 01:48:52 -07002154 delayacct_freepages_start();
2155
Johannes Weiner89b5fae2012-01-12 17:17:50 -08002156 if (global_reclaim(sc))
KAMEZAWA Hiroyuki1cfb4192008-02-07 00:14:37 -08002157 count_vm_event(ALLOCSTALL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002159 do {
Balbir Singh66e17072008-02-07 00:13:56 -08002160 sc->nr_scanned = 0;
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002161 aborted_reclaim = shrink_zones(zonelist, sc);
Mel Gormane0c23272011-10-31 17:09:33 -07002162
Balbir Singh66e17072008-02-07 00:13:56 -08002163 /*
2164 * Don't shrink slabs when reclaiming memory from
2165 * over limit cgroups
2166 */
Johannes Weiner89b5fae2012-01-12 17:17:50 -08002167 if (global_reclaim(sc)) {
KOSAKI Motohiroc6a8a8c2010-08-09 17:19:14 -07002168 unsigned long lru_pages = 0;
Mel Gormand4debc62010-08-09 17:19:29 -07002169 for_each_zone_zonelist(zone, z, zonelist,
2170 gfp_zone(sc->gfp_mask)) {
KOSAKI Motohiroc6a8a8c2010-08-09 17:19:14 -07002171 if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
2172 continue;
2173
2174 lru_pages += zone_reclaimable_pages(zone);
2175 }
2176
Ying Han1495f232011-05-24 17:12:27 -07002177 shrink_slab(shrink, sc->nr_scanned, lru_pages);
KAMEZAWA Hiroyuki91a45472008-02-07 00:14:29 -08002178 if (reclaim_state) {
Rik van Riela79311c2009-01-06 14:40:01 -08002179 sc->nr_reclaimed += reclaim_state->reclaimed_slab;
KAMEZAWA Hiroyuki91a45472008-02-07 00:14:29 -08002180 reclaim_state->reclaimed_slab = 0;
2181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 }
Balbir Singh66e17072008-02-07 00:13:56 -08002183 total_scanned += sc->nr_scanned;
KOSAKI Motohirobb21c7c2010-06-04 14:15:05 -07002184 if (sc->nr_reclaimed >= sc->nr_to_reclaim)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186
2187 /*
2188 * Try to write back as many pages as we just scanned. This
2189 * tends to cause slow streaming writers to write data to the
2190 * disk smoothly, at the dirtying rate, which is nice. But
2191 * that's undesirable in laptop mode, where we *want* lumpy
2192 * writeout. So in laptop mode, write out the whole world.
2193 */
KOSAKI Motohiro22fba332009-12-14 17:59:10 -08002194 writeback_threshold = sc->nr_to_reclaim + sc->nr_to_reclaim / 2;
2195 if (total_scanned > writeback_threshold) {
Curt Wohlgemuth0e175a12011-10-07 21:54:10 -06002196 wakeup_flusher_threads(laptop_mode ? 0 : total_scanned,
2197 WB_REASON_TRY_TO_FREE_PAGES);
Balbir Singh66e17072008-02-07 00:13:56 -08002198 sc->may_writepage = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 }
2200
2201 /* Take a nap, wait for some writeback to complete */
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08002202 if (!sc->hibernation_mode && sc->nr_scanned &&
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002203 sc->priority < DEF_PRIORITY - 2) {
Mel Gorman0e093d992010-10-26 14:21:45 -07002204 struct zone *preferred_zone;
2205
2206 first_zones_zonelist(zonelist, gfp_zone(sc->gfp_mask),
David Rientjesf33261d2011-01-25 15:07:20 -08002207 &cpuset_current_mems_allowed,
2208 &preferred_zone);
Mel Gorman0e093d992010-10-26 14:21:45 -07002209 wait_iff_congested(preferred_zone, BLK_RW_ASYNC, HZ/10);
2210 }
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002211 } while (--sc->priority >= 0);
KOSAKI Motohirobb21c7c2010-06-04 14:15:05 -07002212
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213out:
Keika Kobayashi873b4772008-07-25 01:48:52 -07002214 delayacct_freepages_end();
2215
KOSAKI Motohirobb21c7c2010-06-04 14:15:05 -07002216 if (sc->nr_reclaimed)
2217 return sc->nr_reclaimed;
2218
KOSAKI Motohiro929bea72011-04-14 15:22:12 -07002219 /*
2220 * As hibernation is going on, kswapd is freezed so that it can't mark
2221 * the zone into all_unreclaimable. Thus bypassing all_unreclaimable
2222 * check.
2223 */
2224 if (oom_killer_disabled)
2225 return 0;
2226
Mel Gorman0cee34f2012-01-12 17:19:49 -08002227 /* Aborted reclaim to try compaction? don't OOM, then */
2228 if (aborted_reclaim)
Mel Gorman73350842012-01-12 17:19:33 -08002229 return 1;
2230
KOSAKI Motohirobb21c7c2010-06-04 14:15:05 -07002231 /* top priority shrink_zones still had more to do? don't OOM, then */
Johannes Weiner89b5fae2012-01-12 17:17:50 -08002232 if (global_reclaim(sc) && !all_unreclaimable(zonelist, sc))
KOSAKI Motohirobb21c7c2010-06-04 14:15:05 -07002233 return 1;
2234
2235 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236}
2237
Mel Gormandac1d272008-04-28 02:12:12 -07002238unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
KAMEZAWA Hiroyuki327c0e92009-03-31 15:23:31 -07002239 gfp_t gfp_mask, nodemask_t *nodemask)
Balbir Singh66e17072008-02-07 00:13:56 -08002240{
Mel Gorman33906bc2010-08-09 17:19:16 -07002241 unsigned long nr_reclaimed;
Balbir Singh66e17072008-02-07 00:13:56 -08002242 struct scan_control sc = {
2243 .gfp_mask = gfp_mask,
2244 .may_writepage = !laptop_mode,
KOSAKI Motohiro22fba332009-12-14 17:59:10 -08002245 .nr_to_reclaim = SWAP_CLUSTER_MAX,
Johannes Weinera6dc60f2009-03-31 15:19:30 -07002246 .may_unmap = 1,
KOSAKI Motohiro2e2e4252009-04-21 12:24:57 -07002247 .may_swap = 1,
Balbir Singh66e17072008-02-07 00:13:56 -08002248 .order = order,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002249 .priority = DEF_PRIORITY,
Johannes Weinerf16015f2012-01-12 17:17:52 -08002250 .target_mem_cgroup = NULL,
KAMEZAWA Hiroyuki327c0e92009-03-31 15:23:31 -07002251 .nodemask = nodemask,
Balbir Singh66e17072008-02-07 00:13:56 -08002252 };
Ying Hana09ed5e2011-05-24 17:12:26 -07002253 struct shrink_control shrink = {
2254 .gfp_mask = sc.gfp_mask,
2255 };
Balbir Singh66e17072008-02-07 00:13:56 -08002256
Mel Gorman33906bc2010-08-09 17:19:16 -07002257 trace_mm_vmscan_direct_reclaim_begin(order,
2258 sc.may_writepage,
2259 gfp_mask);
2260
Ying Hana09ed5e2011-05-24 17:12:26 -07002261 nr_reclaimed = do_try_to_free_pages(zonelist, &sc, &shrink);
Mel Gorman33906bc2010-08-09 17:19:16 -07002262
2263 trace_mm_vmscan_direct_reclaim_end(nr_reclaimed);
2264
2265 return nr_reclaimed;
Balbir Singh66e17072008-02-07 00:13:56 -08002266}
2267
Balbir Singh00f0b822008-03-04 14:28:39 -08002268#ifdef CONFIG_CGROUP_MEM_RES_CTLR
Balbir Singh66e17072008-02-07 00:13:56 -08002269
Johannes Weiner72835c82012-01-12 17:18:32 -08002270unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *memcg,
Balbir Singh4e416952009-09-23 15:56:39 -07002271 gfp_t gfp_mask, bool noswap,
Ying Han0ae5e892011-05-26 16:25:25 -07002272 struct zone *zone,
2273 unsigned long *nr_scanned)
Balbir Singh4e416952009-09-23 15:56:39 -07002274{
2275 struct scan_control sc = {
Ying Han0ae5e892011-05-26 16:25:25 -07002276 .nr_scanned = 0,
KOSAKI Motohirob8f5c562010-08-10 18:03:02 -07002277 .nr_to_reclaim = SWAP_CLUSTER_MAX,
Balbir Singh4e416952009-09-23 15:56:39 -07002278 .may_writepage = !laptop_mode,
2279 .may_unmap = 1,
2280 .may_swap = !noswap,
Balbir Singh4e416952009-09-23 15:56:39 -07002281 .order = 0,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002282 .priority = 0,
Johannes Weiner72835c82012-01-12 17:18:32 -08002283 .target_mem_cgroup = memcg,
Balbir Singh4e416952009-09-23 15:56:39 -07002284 };
Johannes Weiner56600482012-01-12 17:17:59 -08002285 struct mem_cgroup_zone mz = {
Johannes Weiner72835c82012-01-12 17:18:32 -08002286 .mem_cgroup = memcg,
Johannes Weiner56600482012-01-12 17:17:59 -08002287 .zone = zone,
2288 };
Ying Han0ae5e892011-05-26 16:25:25 -07002289
Balbir Singh4e416952009-09-23 15:56:39 -07002290 sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
2291 (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
KOSAKI Motohirobdce6d92010-08-09 17:19:56 -07002292
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002293 trace_mm_vmscan_memcg_softlimit_reclaim_begin(sc.order,
KOSAKI Motohirobdce6d92010-08-09 17:19:56 -07002294 sc.may_writepage,
2295 sc.gfp_mask);
2296
Balbir Singh4e416952009-09-23 15:56:39 -07002297 /*
2298 * NOTE: Although we can get the priority field, using it
2299 * here is not a good idea, since it limits the pages we can scan.
2300 * if we don't reclaim here, the shrink_zone from balance_pgdat
2301 * will pick up pages from other mem cgroup's as well. We hack
2302 * the priority and make it zero.
2303 */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002304 shrink_mem_cgroup_zone(&mz, &sc);
KOSAKI Motohirobdce6d92010-08-09 17:19:56 -07002305
2306 trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);
2307
Ying Han0ae5e892011-05-26 16:25:25 -07002308 *nr_scanned = sc.nr_scanned;
Balbir Singh4e416952009-09-23 15:56:39 -07002309 return sc.nr_reclaimed;
2310}
2311
Johannes Weiner72835c82012-01-12 17:18:32 -08002312unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
KOSAKI Motohiroa7885eb2009-01-07 18:08:24 -08002313 gfp_t gfp_mask,
Johannes Weiner185efc02011-09-14 16:21:58 -07002314 bool noswap)
Balbir Singh66e17072008-02-07 00:13:56 -08002315{
Balbir Singh4e416952009-09-23 15:56:39 -07002316 struct zonelist *zonelist;
KOSAKI Motohirobdce6d92010-08-09 17:19:56 -07002317 unsigned long nr_reclaimed;
Ying Han889976d2011-05-26 16:25:33 -07002318 int nid;
Balbir Singh66e17072008-02-07 00:13:56 -08002319 struct scan_control sc = {
Balbir Singh66e17072008-02-07 00:13:56 -08002320 .may_writepage = !laptop_mode,
Johannes Weinera6dc60f2009-03-31 15:19:30 -07002321 .may_unmap = 1,
KOSAKI Motohiro2e2e4252009-04-21 12:24:57 -07002322 .may_swap = !noswap,
KOSAKI Motohiro22fba332009-12-14 17:59:10 -08002323 .nr_to_reclaim = SWAP_CLUSTER_MAX,
Balbir Singh66e17072008-02-07 00:13:56 -08002324 .order = 0,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002325 .priority = DEF_PRIORITY,
Johannes Weiner72835c82012-01-12 17:18:32 -08002326 .target_mem_cgroup = memcg,
KAMEZAWA Hiroyuki327c0e92009-03-31 15:23:31 -07002327 .nodemask = NULL, /* we don't care the placement */
Ying Hana09ed5e2011-05-24 17:12:26 -07002328 .gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
2329 (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
2330 };
2331 struct shrink_control shrink = {
2332 .gfp_mask = sc.gfp_mask,
Balbir Singh66e17072008-02-07 00:13:56 -08002333 };
Balbir Singh66e17072008-02-07 00:13:56 -08002334
Ying Han889976d2011-05-26 16:25:33 -07002335 /*
2336 * Unlike direct reclaim via alloc_pages(), memcg's reclaim doesn't
2337 * take care of from where we get pages. So the node where we start the
2338 * scan does not need to be the current node.
2339 */
Johannes Weiner72835c82012-01-12 17:18:32 -08002340 nid = mem_cgroup_select_victim_node(memcg);
Ying Han889976d2011-05-26 16:25:33 -07002341
2342 zonelist = NODE_DATA(nid)->node_zonelists;
KOSAKI Motohirobdce6d92010-08-09 17:19:56 -07002343
2344 trace_mm_vmscan_memcg_reclaim_begin(0,
2345 sc.may_writepage,
2346 sc.gfp_mask);
2347
Ying Hana09ed5e2011-05-24 17:12:26 -07002348 nr_reclaimed = do_try_to_free_pages(zonelist, &sc, &shrink);
KOSAKI Motohirobdce6d92010-08-09 17:19:56 -07002349
2350 trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);
2351
2352 return nr_reclaimed;
Balbir Singh66e17072008-02-07 00:13:56 -08002353}
2354#endif
2355
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002356static void age_active_anon(struct zone *zone, struct scan_control *sc)
Johannes Weinerf16015f2012-01-12 17:17:52 -08002357{
Johannes Weinerb95a2f22012-01-12 17:18:06 -08002358 struct mem_cgroup *memcg;
Johannes Weinerf16015f2012-01-12 17:17:52 -08002359
Johannes Weinerb95a2f22012-01-12 17:18:06 -08002360 if (!total_swap_pages)
2361 return;
2362
2363 memcg = mem_cgroup_iter(NULL, NULL, NULL);
2364 do {
2365 struct mem_cgroup_zone mz = {
2366 .mem_cgroup = memcg,
2367 .zone = zone,
2368 };
2369
2370 if (inactive_anon_is_low(&mz))
2371 shrink_active_list(SWAP_CLUSTER_MAX, &mz,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002372 sc, LRU_ACTIVE_ANON);
Johannes Weinerb95a2f22012-01-12 17:18:06 -08002373
2374 memcg = mem_cgroup_iter(NULL, memcg, NULL);
2375 } while (memcg);
Johannes Weinerf16015f2012-01-12 17:17:52 -08002376}
2377
Johannes Weiner791355e2012-11-29 13:54:23 -08002378static bool zone_balanced(struct zone *zone, int order,
2379 unsigned long balance_gap, int classzone_idx)
2380{
2381 if (!zone_watermark_ok_safe(zone, order, high_wmark_pages(zone) +
2382 balance_gap, classzone_idx, 0))
2383 return false;
2384
2385 if (COMPACTION_BUILD && order && !compaction_suitable(zone, order))
2386 return false;
2387
2388 return true;
2389}
2390
Mel Gorman1741c872011-01-13 15:46:21 -08002391/*
2392 * pgdat_balanced is used when checking if a node is balanced for high-order
2393 * allocations. Only zones that meet watermarks and are in a zone allowed
2394 * by the callers classzone_idx are added to balanced_pages. The total of
2395 * balanced pages must be at least 25% of the zones allowed by classzone_idx
2396 * for the node to be considered balanced. Forcing all zones to be balanced
2397 * for high orders can cause excessive reclaim when there are imbalanced zones.
2398 * The choice of 25% is due to
2399 * o a 16M DMA zone that is balanced will not balance a zone on any
2400 * reasonable sized machine
2401 * o On all other machines, the top zone must be at least a reasonable
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002402 * percentage of the middle zones. For example, on 32-bit x86, highmem
Mel Gorman1741c872011-01-13 15:46:21 -08002403 * would need to be at least 256M for it to be balance a whole node.
2404 * Similarly, on x86-64 the Normal zone would need to be at least 1G
2405 * to balance a node on its own. These seemed like reasonable ratios.
2406 */
2407static bool pgdat_balanced(pg_data_t *pgdat, unsigned long balanced_pages,
2408 int classzone_idx)
2409{
2410 unsigned long present_pages = 0;
2411 int i;
2412
2413 for (i = 0; i <= classzone_idx; i++)
2414 present_pages += pgdat->node_zones[i].present_pages;
2415
Shaohua Li4746efd2011-07-19 08:49:26 -07002416 /* A special case here: if zone has no page, we think it's balanced */
2417 return balanced_pages >= (present_pages >> 2);
Mel Gorman1741c872011-01-13 15:46:21 -08002418}
2419
Mel Gormanf50de2d2009-12-14 17:58:53 -08002420/* is kswapd sleeping prematurely? */
Mel Gormandc83edd2011-01-13 15:46:26 -08002421static bool sleeping_prematurely(pg_data_t *pgdat, int order, long remaining,
2422 int classzone_idx)
Mel Gormanf50de2d2009-12-14 17:58:53 -08002423{
KOSAKI Motohirobb3ab592009-12-14 17:58:55 -08002424 int i;
Mel Gorman1741c872011-01-13 15:46:21 -08002425 unsigned long balanced = 0;
2426 bool all_zones_ok = true;
Mel Gormanf50de2d2009-12-14 17:58:53 -08002427
2428 /* If a direct reclaimer woke kswapd within HZ/10, it's premature */
2429 if (remaining)
Mel Gormandc83edd2011-01-13 15:46:26 -08002430 return true;
Mel Gormanf50de2d2009-12-14 17:58:53 -08002431
Mel Gorman0abdee22011-01-13 15:46:22 -08002432 /* Check the watermark levels */
Mel Gorman08951e52011-07-08 15:39:36 -07002433 for (i = 0; i <= classzone_idx; i++) {
KOSAKI Motohirobb3ab592009-12-14 17:58:55 -08002434 struct zone *zone = pgdat->node_zones + i;
2435
2436 if (!populated_zone(zone))
2437 continue;
2438
Mel Gorman355b09c2011-01-13 15:46:24 -08002439 /*
2440 * balance_pgdat() skips over all_unreclaimable after
2441 * DEF_PRIORITY. Effectively, it considers them balanced so
2442 * they must be considered balanced here as well if kswapd
2443 * is to sleep
2444 */
Lisa Due0935212013-09-11 14:22:36 -07002445 if (!zone_reclaimable(zone)) {
Mel Gorman355b09c2011-01-13 15:46:24 -08002446 balanced += zone->present_pages;
KOSAKI Motohirode3fab32010-01-15 17:01:25 -08002447 continue;
Mel Gorman355b09c2011-01-13 15:46:24 -08002448 }
KOSAKI Motohirode3fab32010-01-15 17:01:25 -08002449
Johannes Weiner791355e2012-11-29 13:54:23 -08002450 if (!zone_balanced(zone, order, 0, i))
Mel Gorman1741c872011-01-13 15:46:21 -08002451 all_zones_ok = false;
2452 else
2453 balanced += zone->present_pages;
KOSAKI Motohirobb3ab592009-12-14 17:58:55 -08002454 }
Mel Gormanf50de2d2009-12-14 17:58:53 -08002455
Mel Gorman1741c872011-01-13 15:46:21 -08002456 /*
2457 * For high-order requests, the balanced zones must contain at least
2458 * 25% of the nodes pages for kswapd to sleep. For order-0, all zones
2459 * must be balanced
2460 */
2461 if (order)
Johannes Weinerafc7e322011-05-24 17:11:09 -07002462 return !pgdat_balanced(pgdat, balanced, classzone_idx);
Mel Gorman1741c872011-01-13 15:46:21 -08002463 else
2464 return !all_zones_ok;
Mel Gormanf50de2d2009-12-14 17:58:53 -08002465}
2466
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467/*
2468 * For kswapd, balance_pgdat() will work across all this node's zones until
Mel Gorman41858962009-06-16 15:32:12 -07002469 * they are all at high_wmark_pages(zone).
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 *
Mel Gorman0abdee22011-01-13 15:46:22 -08002471 * Returns the final order kswapd was reclaiming at
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472 *
2473 * There is special handling here for zones which are full of pinned pages.
2474 * This can happen if the pages are all mlocked, or if they are all used by
2475 * device drivers (say, ZONE_DMA). Or if they are all in use by hugetlb.
2476 * What we do is to detect the case where all pages in the zone have been
2477 * scanned twice and there has been zero successful reclaim. Mark the zone as
2478 * dead and from now on, only perform a short scan. Basically we're polling
2479 * the zone for when the problem goes away.
2480 *
2481 * kswapd scans the zones in the highmem->normal->dma direction. It skips
Mel Gorman41858962009-06-16 15:32:12 -07002482 * zones which have free_pages > high_wmark_pages(zone), but once a zone is
2483 * found to have free_pages <= high_wmark_pages(zone), we scan that zone and the
2484 * lower zones regardless of the number of free pages in the lower zones. This
2485 * interoperates with the page allocator fallback scheme to ensure that aging
2486 * of pages is balanced across the zones.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 */
Mel Gorman99504742011-01-13 15:46:20 -08002488static unsigned long balance_pgdat(pg_data_t *pgdat, int order,
Mel Gormandc83edd2011-01-13 15:46:26 -08002489 int *classzone_idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 int all_zones_ok;
Mel Gorman1741c872011-01-13 15:46:21 -08002492 unsigned long balanced;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 int i;
Mel Gorman99504742011-01-13 15:46:20 -08002494 int end_zone = 0; /* Inclusive. 0 = ZONE_DMA */
Andrew Morton69e05942006-03-22 00:08:19 -08002495 unsigned long total_scanned;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 struct reclaim_state *reclaim_state = current->reclaim_state;
Ying Han0ae5e892011-05-26 16:25:25 -07002497 unsigned long nr_soft_reclaimed;
2498 unsigned long nr_soft_scanned;
Andrew Morton179e9632006-03-22 00:08:18 -08002499 struct scan_control sc = {
2500 .gfp_mask = GFP_KERNEL,
Johannes Weinera6dc60f2009-03-31 15:19:30 -07002501 .may_unmap = 1,
KOSAKI Motohiro2e2e4252009-04-21 12:24:57 -07002502 .may_swap = 1,
KOSAKI Motohiro22fba332009-12-14 17:59:10 -08002503 /*
2504 * kswapd doesn't want to be bailed out while reclaim. because
2505 * we want to put equal scanning pressure on each zone.
2506 */
2507 .nr_to_reclaim = ULONG_MAX,
Andy Whitcroft5ad333e2007-07-17 04:03:16 -07002508 .order = order,
Johannes Weinerf16015f2012-01-12 17:17:52 -08002509 .target_mem_cgroup = NULL,
Andrew Morton179e9632006-03-22 00:08:18 -08002510 };
Ying Hana09ed5e2011-05-24 17:12:26 -07002511 struct shrink_control shrink = {
2512 .gfp_mask = sc.gfp_mask,
2513 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514loop_again:
2515 total_scanned = 0;
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002516 sc.priority = DEF_PRIORITY;
Rik van Riela79311c2009-01-06 14:40:01 -08002517 sc.nr_reclaimed = 0;
Christoph Lameterc0bbbc72006-06-11 15:22:26 -07002518 sc.may_writepage = !laptop_mode;
Christoph Lameterf8891e52006-06-30 01:55:45 -07002519 count_vm_event(PAGEOUTRUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002521 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522 unsigned long lru_pages = 0;
KOSAKI Motohirobb3ab592009-12-14 17:58:55 -08002523 int has_under_min_watermark_zone = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524
2525 all_zones_ok = 1;
Mel Gorman1741c872011-01-13 15:46:21 -08002526 balanced = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07002528 /*
2529 * Scan in the highmem->dma direction for the highest
2530 * zone which needs scanning
2531 */
2532 for (i = pgdat->nr_zones - 1; i >= 0; i--) {
2533 struct zone *zone = pgdat->node_zones + i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07002535 if (!populated_zone(zone))
2536 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537
Lisa Due0935212013-09-11 14:22:36 -07002538 if (sc.priority != DEF_PRIORITY &&
2539 !zone_reclaimable(zone))
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07002540 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541
Rik van Riel556adec2008-10-18 20:26:34 -07002542 /*
2543 * Do some background aging of the anon list, to give
2544 * pages a chance to be referenced before reclaiming.
2545 */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002546 age_active_anon(zone, &sc);
Rik van Riel556adec2008-10-18 20:26:34 -07002547
Mel Gormancc715d92012-03-21 16:34:00 -07002548 /*
2549 * If the number of buffer_heads in the machine
2550 * exceeds the maximum allowed level and this node
2551 * has a highmem zone, force kswapd to reclaim from
2552 * it to relieve lowmem pressure.
2553 */
2554 if (buffer_heads_over_limit && is_highmem_idx(i)) {
2555 end_zone = i;
2556 break;
2557 }
2558
Johannes Weiner791355e2012-11-29 13:54:23 -08002559 if (!zone_balanced(zone, order, 0, 0)) {
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07002560 end_zone = i;
Andrew Mortone1dbeda2006-12-06 20:32:01 -08002561 break;
Shaohua Li439423f2011-08-25 15:59:12 -07002562 } else {
2563 /* If balanced, clear the congested flag */
2564 zone_clear_flag(zone, ZONE_CONGESTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566 }
Andrew Mortone1dbeda2006-12-06 20:32:01 -08002567 if (i < 0)
2568 goto out;
2569
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 for (i = 0; i <= end_zone; i++) {
2571 struct zone *zone = pgdat->node_zones + i;
2572
Wu Fengguangadea02a2009-09-21 17:01:42 -07002573 lru_pages += zone_reclaimable_pages(zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574 }
2575
2576 /*
2577 * Now scan the zone in the dma->highmem direction, stopping
2578 * at the last zone which needs scanning.
2579 *
2580 * We do this because the page allocator works in the opposite
2581 * direction. This prevents the page allocator from allocating
2582 * pages behind kswapd's direction of progress, which would
2583 * cause too much scanning of the lower zones.
2584 */
2585 for (i = 0; i <= end_zone; i++) {
2586 struct zone *zone = pgdat->node_zones + i;
Rik van Rielfe2c2a12012-03-21 16:33:51 -07002587 int nr_slab, testorder;
Mel Gorman8afdcec2011-03-22 16:33:04 -07002588 unsigned long balance_gap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589
Con Kolivasf3fe6512006-01-06 00:11:15 -08002590 if (!populated_zone(zone))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 continue;
2592
Lisa Due0935212013-09-11 14:22:36 -07002593 if (sc.priority != DEF_PRIORITY &&
2594 !zone_reclaimable(zone))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 continue;
2596
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 sc.nr_scanned = 0;
Balbir Singh4e416952009-09-23 15:56:39 -07002598
Ying Han0ae5e892011-05-26 16:25:25 -07002599 nr_soft_scanned = 0;
Balbir Singh4e416952009-09-23 15:56:39 -07002600 /*
2601 * Call soft limit reclaim before calling shrink_zone.
Balbir Singh4e416952009-09-23 15:56:39 -07002602 */
Ying Han0ae5e892011-05-26 16:25:25 -07002603 nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone,
2604 order, sc.gfp_mask,
2605 &nr_soft_scanned);
2606 sc.nr_reclaimed += nr_soft_reclaimed;
2607 total_scanned += nr_soft_scanned;
KOSAKI Motohiro00918b62010-08-10 18:03:05 -07002608
Rik van Riel32a43302007-10-16 01:24:50 -07002609 /*
Mel Gorman8afdcec2011-03-22 16:33:04 -07002610 * We put equal pressure on every zone, unless
2611 * one zone has way too many pages free
2612 * already. The "too many pages" is defined
2613 * as the high wmark plus a "gap" where the
2614 * gap is either the low watermark or 1%
2615 * of the zone, whichever is smaller.
Rik van Riel32a43302007-10-16 01:24:50 -07002616 */
Mel Gorman8afdcec2011-03-22 16:33:04 -07002617 balance_gap = min(low_wmark_pages(zone),
2618 (zone->present_pages +
2619 KSWAPD_ZONE_BALANCE_GAP_RATIO-1) /
2620 KSWAPD_ZONE_BALANCE_GAP_RATIO);
Rik van Rielfe2c2a12012-03-21 16:33:51 -07002621 /*
2622 * Kswapd reclaims only single pages with compaction
2623 * enabled. Trying too hard to reclaim until contiguous
2624 * free pages have become available can hurt performance
2625 * by evicting too much useful data from memory.
2626 * Do not reclaim more than needed for compaction.
2627 */
2628 testorder = order;
2629 if (COMPACTION_BUILD && order &&
2630 compaction_suitable(zone, order) !=
2631 COMPACT_SKIPPED)
2632 testorder = 0;
2633
Mel Gormancc715d92012-03-21 16:34:00 -07002634 if ((buffer_heads_over_limit && is_highmem_idx(i)) ||
Johannes Weiner791355e2012-11-29 13:54:23 -08002635 !zone_balanced(zone, testorder,
2636 balance_gap, end_zone)) {
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002637 shrink_zone(zone, &sc);
Andrea Arcangeli5a03b052011-01-13 15:47:11 -08002638
Mel Gormand7868da2011-07-08 15:39:38 -07002639 reclaim_state->reclaimed_slab = 0;
2640 nr_slab = shrink_slab(&shrink, sc.nr_scanned, lru_pages);
2641 sc.nr_reclaimed += reclaim_state->reclaimed_slab;
2642 total_scanned += sc.nr_scanned;
2643
Mel Gormand7868da2011-07-08 15:39:38 -07002644 }
2645
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 /*
2647 * If we've done a decent amount of scanning and
2648 * the reclaim ratio is low, start doing writepage
2649 * even in laptop mode
2650 */
2651 if (total_scanned > SWAP_CLUSTER_MAX * 2 &&
Rik van Riela79311c2009-01-06 14:40:01 -08002652 total_scanned > sc.nr_reclaimed + sc.nr_reclaimed / 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 sc.may_writepage = 1;
KOSAKI Motohirobb3ab592009-12-14 17:58:55 -08002654
Lisa Due0935212013-09-11 14:22:36 -07002655 if (!zone_reclaimable(zone)) {
Mel Gorman215ddd62011-07-08 15:39:40 -07002656 if (end_zone && end_zone == i)
2657 end_zone--;
Mel Gormand7868da2011-07-08 15:39:38 -07002658 continue;
Mel Gorman215ddd62011-07-08 15:39:40 -07002659 }
Mel Gormand7868da2011-07-08 15:39:38 -07002660
Johannes Weiner791355e2012-11-29 13:54:23 -08002661 if (!zone_balanced(zone, testorder, 0, end_zone)) {
Minchan Kim45973d72010-03-05 13:41:45 -08002662 all_zones_ok = 0;
2663 /*
2664 * We are still under min water mark. This
2665 * means that we have a GFP_ATOMIC allocation
2666 * failure risk. Hurry up!
2667 */
Mel Gorman88f5acf2011-01-13 15:45:41 -08002668 if (!zone_watermark_ok_safe(zone, order,
Minchan Kim45973d72010-03-05 13:41:45 -08002669 min_wmark_pages(zone), end_zone, 0))
2670 has_under_min_watermark_zone = 1;
Mel Gorman0e093d992010-10-26 14:21:45 -07002671 } else {
2672 /*
2673 * If a zone reaches its high watermark,
2674 * consider it to be no longer congested. It's
2675 * possible there are dirty pages backed by
2676 * congested BDIs but as pressure is relieved,
2677 * spectulatively avoid congestion waits
2678 */
2679 zone_clear_flag(zone, ZONE_CONGESTED);
Mel Gormandc83edd2011-01-13 15:46:26 -08002680 if (i <= *classzone_idx)
Mel Gorman1741c872011-01-13 15:46:21 -08002681 balanced += zone->present_pages;
Minchan Kim45973d72010-03-05 13:41:45 -08002682 }
KOSAKI Motohirobb3ab592009-12-14 17:58:55 -08002683
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 }
Mel Gormandc83edd2011-01-13 15:46:26 -08002685 if (all_zones_ok || (order && pgdat_balanced(pgdat, balanced, *classzone_idx)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 break; /* kswapd: all done */
2687 /*
2688 * OK, kswapd is getting into trouble. Take a nap, then take
2689 * another pass across the zones.
2690 */
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002691 if (total_scanned && (sc.priority < DEF_PRIORITY - 2)) {
KOSAKI Motohirobb3ab592009-12-14 17:58:55 -08002692 if (has_under_min_watermark_zone)
2693 count_vm_event(KSWAPD_SKIP_CONGESTION_WAIT);
2694 else
2695 congestion_wait(BLK_RW_ASYNC, HZ/10);
2696 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697
2698 /*
2699 * We do this so kswapd doesn't build up large priorities for
2700 * example when it is freeing in parallel with allocators. It
2701 * matches the direct reclaim path behaviour in terms of impact
2702 * on zone->*_priority.
2703 */
Rik van Riela79311c2009-01-06 14:40:01 -08002704 if (sc.nr_reclaimed >= SWAP_CLUSTER_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 break;
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07002706 } while (--sc.priority >= 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707out:
Mel Gorman99504742011-01-13 15:46:20 -08002708
2709 /*
2710 * order-0: All zones must meet high watermark for a balanced node
Mel Gorman1741c872011-01-13 15:46:21 -08002711 * high-order: Balanced zones must make up at least 25% of the node
2712 * for the node to be balanced
Mel Gorman99504742011-01-13 15:46:20 -08002713 */
Mel Gormandc83edd2011-01-13 15:46:26 -08002714 if (!(all_zones_ok || (order && pgdat_balanced(pgdat, balanced, *classzone_idx)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 cond_resched();
Rafael J. Wysocki83573762006-12-06 20:34:18 -08002716
2717 try_to_freeze();
2718
KOSAKI Motohiro73ce02e2009-01-06 14:40:33 -08002719 /*
2720 * Fragmentation may mean that the system cannot be
2721 * rebalanced for high-order allocations in all zones.
2722 * At this point, if nr_reclaimed < SWAP_CLUSTER_MAX,
2723 * it means the zones have been fully scanned and are still
2724 * not balanced. For high-order allocations, there is
2725 * little point trying all over again as kswapd may
2726 * infinite loop.
2727 *
2728 * Instead, recheck all watermarks at order-0 as they
2729 * are the most important. If watermarks are ok, kswapd will go
2730 * back to sleep. High-order users can still perform direct
2731 * reclaim if they wish.
2732 */
2733 if (sc.nr_reclaimed < SWAP_CLUSTER_MAX)
2734 order = sc.order = 0;
2735
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736 goto loop_again;
2737 }
2738
Mel Gorman99504742011-01-13 15:46:20 -08002739 /*
2740 * If kswapd was reclaiming at a higher order, it has the option of
2741 * sleeping without all zones being balanced. Before it does, it must
2742 * ensure that the watermarks for order-0 on *all* zones are met and
2743 * that the congestion flags are cleared. The congestion flag must
2744 * be cleared as kswapd is the only mechanism that clears the flag
2745 * and it is potentially going to sleep here.
2746 */
2747 if (order) {
Rik van Riel7be62de2012-03-21 16:33:52 -07002748 int zones_need_compaction = 1;
2749
Mel Gorman99504742011-01-13 15:46:20 -08002750 for (i = 0; i <= end_zone; i++) {
2751 struct zone *zone = pgdat->node_zones + i;
2752
2753 if (!populated_zone(zone))
2754 continue;
2755
Rik van Riel7be62de2012-03-21 16:33:52 -07002756 /* Check if the memory needs to be defragmented. */
2757 if (zone_watermark_ok(zone, order,
2758 low_wmark_pages(zone), *classzone_idx, 0))
2759 zones_need_compaction = 0;
2760
Mel Gorman99504742011-01-13 15:46:20 -08002761 /* If balanced, clear the congested flag */
2762 zone_clear_flag(zone, ZONE_CONGESTED);
2763 }
Rik van Riel7be62de2012-03-21 16:33:52 -07002764
2765 if (zones_need_compaction)
2766 compact_pgdat(pgdat, order);
Mel Gorman99504742011-01-13 15:46:20 -08002767 }
2768
Mel Gorman0abdee22011-01-13 15:46:22 -08002769 /*
2770 * Return the order we were reclaiming at so sleeping_prematurely()
2771 * makes a decision on the order we were last reclaiming at. However,
2772 * if another caller entered the allocator slow path while kswapd
2773 * was awake, order will remain at the higher level
2774 */
Mel Gormandc83edd2011-01-13 15:46:26 -08002775 *classzone_idx = end_zone;
Mel Gorman0abdee22011-01-13 15:46:22 -08002776 return order;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777}
2778
Mel Gormandc83edd2011-01-13 15:46:26 -08002779static void kswapd_try_to_sleep(pg_data_t *pgdat, int order, int classzone_idx)
KOSAKI Motohirof0bc0a62011-01-13 15:45:50 -08002780{
2781 long remaining = 0;
2782 DEFINE_WAIT(wait);
2783
2784 if (freezing(current) || kthread_should_stop())
2785 return;
2786
2787 prepare_to_wait(&pgdat->kswapd_wait, &wait, TASK_INTERRUPTIBLE);
2788
2789 /* Try to sleep for a short interval */
Mel Gormandc83edd2011-01-13 15:46:26 -08002790 if (!sleeping_prematurely(pgdat, order, remaining, classzone_idx)) {
KOSAKI Motohirof0bc0a62011-01-13 15:45:50 -08002791 remaining = schedule_timeout(HZ/10);
2792 finish_wait(&pgdat->kswapd_wait, &wait);
2793 prepare_to_wait(&pgdat->kswapd_wait, &wait, TASK_INTERRUPTIBLE);
2794 }
2795
2796 /*
2797 * After a short sleep, check if it was a premature sleep. If not, then
2798 * go fully to sleep until explicitly woken up.
2799 */
Mel Gormandc83edd2011-01-13 15:46:26 -08002800 if (!sleeping_prematurely(pgdat, order, remaining, classzone_idx)) {
KOSAKI Motohirof0bc0a62011-01-13 15:45:50 -08002801 trace_mm_vmscan_kswapd_sleep(pgdat->node_id);
2802
2803 /*
2804 * vmstat counters are not perfectly accurate and the estimated
2805 * value for counters such as NR_FREE_PAGES can deviate from the
2806 * true value by nr_online_cpus * threshold. To avoid the zone
2807 * watermarks being breached while under pressure, we reduce the
2808 * per-cpu vmstat threshold while kswapd is awake and restore
2809 * them before going back to sleep.
2810 */
2811 set_pgdat_percpu_threshold(pgdat, calculate_normal_threshold);
Aaditya Kumar8af68452012-07-17 15:48:07 -07002812
Mel Gorman9317a2b2012-10-08 16:32:47 -07002813 /*
2814 * Compaction records what page blocks it recently failed to
2815 * isolate pages from and skips them in the future scanning.
2816 * When kswapd is going to sleep, it is reasonable to assume
2817 * that pages and compaction may succeed so reset the cache.
2818 */
2819 reset_isolation_suitable(pgdat);
2820
Aaditya Kumar8af68452012-07-17 15:48:07 -07002821 if (!kthread_should_stop())
2822 schedule();
2823
KOSAKI Motohirof0bc0a62011-01-13 15:45:50 -08002824 set_pgdat_percpu_threshold(pgdat, calculate_pressure_threshold);
2825 } else {
2826 if (remaining)
2827 count_vm_event(KSWAPD_LOW_WMARK_HIT_QUICKLY);
2828 else
2829 count_vm_event(KSWAPD_HIGH_WMARK_HIT_QUICKLY);
2830 }
2831 finish_wait(&pgdat->kswapd_wait, &wait);
2832}
2833
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834/*
2835 * The background pageout daemon, started as a kernel thread
Rik van Riel4f98a2f2008-10-18 20:26:32 -07002836 * from the init process.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837 *
2838 * This basically trickles out pages so that we have _some_
2839 * free memory available even if there is no other activity
2840 * that frees anything up. This is needed for things like routing
2841 * etc, where we otherwise might have all activity going on in
2842 * asynchronous contexts that cannot page things out.
2843 *
2844 * If there are applications that are active memory-allocators
2845 * (most normal use), this basically shouldn't matter.
2846 */
2847static int kswapd(void *p)
2848{
Mel Gorman215ddd62011-07-08 15:39:40 -07002849 unsigned long order, new_order;
Alex,Shid2ebd0f62011-10-31 17:08:39 -07002850 unsigned balanced_order;
Mel Gorman215ddd62011-07-08 15:39:40 -07002851 int classzone_idx, new_classzone_idx;
Alex,Shid2ebd0f62011-10-31 17:08:39 -07002852 int balanced_classzone_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 pg_data_t *pgdat = (pg_data_t*)p;
2854 struct task_struct *tsk = current;
KOSAKI Motohirof0bc0a62011-01-13 15:45:50 -08002855
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 struct reclaim_state reclaim_state = {
2857 .reclaimed_slab = 0,
2858 };
Rusty Russella70f7302009-03-13 14:49:46 +10302859 const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860
Nick Piggincf40bd12009-01-21 08:12:39 +01002861 lockdep_set_current_reclaim_state(GFP_KERNEL);
2862
Rusty Russell174596a2009-01-01 10:12:29 +10302863 if (!cpumask_empty(cpumask))
Mike Travisc5f59f02008-04-04 18:11:10 -07002864 set_cpus_allowed_ptr(tsk, cpumask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865 current->reclaim_state = &reclaim_state;
2866
2867 /*
2868 * Tell the memory management that we're a "memory allocator",
2869 * and that if we need more memory we should get access to it
2870 * regardless (see "__alloc_pages()"). "kswapd" should
2871 * never get caught in the normal page freeing logic.
2872 *
2873 * (Kswapd normally doesn't need memory anyway, but sometimes
2874 * you need a small amount of memory in order to be able to
2875 * page out something else, and this flag essentially protects
2876 * us from recursively trying to free more memory as we're
2877 * trying to free the first piece of memory in the first place).
2878 */
Christoph Lameter930d9152006-01-08 01:00:47 -08002879 tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
Rafael J. Wysocki83144182007-07-17 04:03:35 -07002880 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
Mel Gorman215ddd62011-07-08 15:39:40 -07002882 order = new_order = 0;
Alex,Shid2ebd0f62011-10-31 17:08:39 -07002883 balanced_order = 0;
Mel Gorman215ddd62011-07-08 15:39:40 -07002884 classzone_idx = new_classzone_idx = pgdat->nr_zones - 1;
Alex,Shid2ebd0f62011-10-31 17:08:39 -07002885 balanced_classzone_idx = classzone_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 for ( ; ; ) {
David Rientjes8fe23e02009-12-14 17:58:33 -08002887 int ret;
Christoph Lameter3e1d1d22005-06-24 23:13:50 -07002888
Mel Gorman215ddd62011-07-08 15:39:40 -07002889 /*
2890 * If the last balance_pgdat was unsuccessful it's unlikely a
2891 * new request of a similar or harder type will succeed soon
2892 * so consider going to sleep on the basis we reclaimed at
2893 */
Alex,Shid2ebd0f62011-10-31 17:08:39 -07002894 if (balanced_classzone_idx >= new_classzone_idx &&
2895 balanced_order == new_order) {
Mel Gorman215ddd62011-07-08 15:39:40 -07002896 new_order = pgdat->kswapd_max_order;
2897 new_classzone_idx = pgdat->classzone_idx;
2898 pgdat->kswapd_max_order = 0;
2899 pgdat->classzone_idx = pgdat->nr_zones - 1;
2900 }
2901
Mel Gorman99504742011-01-13 15:46:20 -08002902 if (order < new_order || classzone_idx > new_classzone_idx) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 /*
2904 * Don't sleep if someone wants a larger 'order'
Mel Gorman99504742011-01-13 15:46:20 -08002905 * allocation or has tigher zone constraints
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 */
2907 order = new_order;
Mel Gorman99504742011-01-13 15:46:20 -08002908 classzone_idx = new_classzone_idx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909 } else {
Alex,Shid2ebd0f62011-10-31 17:08:39 -07002910 kswapd_try_to_sleep(pgdat, balanced_order,
2911 balanced_classzone_idx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 order = pgdat->kswapd_max_order;
Mel Gorman99504742011-01-13 15:46:20 -08002913 classzone_idx = pgdat->classzone_idx;
Alex,Shif0dfcde2011-10-31 17:08:45 -07002914 new_order = order;
2915 new_classzone_idx = classzone_idx;
Mel Gorman4d405022011-01-13 15:46:23 -08002916 pgdat->kswapd_max_order = 0;
Mel Gorman215ddd62011-07-08 15:39:40 -07002917 pgdat->classzone_idx = pgdat->nr_zones - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919
David Rientjes8fe23e02009-12-14 17:58:33 -08002920 ret = try_to_freeze();
2921 if (kthread_should_stop())
2922 break;
2923
2924 /*
2925 * We can speed up thawing tasks if we don't call balance_pgdat
2926 * after returning from the refrigerator
2927 */
Mel Gorman33906bc2010-08-09 17:19:16 -07002928 if (!ret) {
2929 trace_mm_vmscan_kswapd_wake(pgdat->node_id, order);
Alex,Shid2ebd0f62011-10-31 17:08:39 -07002930 balanced_classzone_idx = classzone_idx;
2931 balanced_order = balance_pgdat(pgdat, order,
2932 &balanced_classzone_idx);
Mel Gorman33906bc2010-08-09 17:19:16 -07002933 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934 }
Takamori Yamaguchib49d5c62012-11-08 15:53:39 -08002935
2936 current->reclaim_state = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 return 0;
2938}
2939
2940/*
2941 * A zone is low on free memory, so wake its kswapd task to service it.
2942 */
Mel Gorman99504742011-01-13 15:46:20 -08002943void wakeup_kswapd(struct zone *zone, int order, enum zone_type classzone_idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944{
2945 pg_data_t *pgdat;
2946
Con Kolivasf3fe6512006-01-06 00:11:15 -08002947 if (!populated_zone(zone))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948 return;
2949
Paul Jackson02a0e532006-12-13 00:34:25 -08002950 if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 return;
Mel Gorman88f5acf2011-01-13 15:45:41 -08002952 pgdat = zone->zone_pgdat;
Mel Gorman99504742011-01-13 15:46:20 -08002953 if (pgdat->kswapd_max_order < order) {
Mel Gorman88f5acf2011-01-13 15:45:41 -08002954 pgdat->kswapd_max_order = order;
Mel Gorman99504742011-01-13 15:46:20 -08002955 pgdat->classzone_idx = min(pgdat->classzone_idx, classzone_idx);
2956 }
Con Kolivas8d0986e2005-09-13 01:25:07 -07002957 if (!waitqueue_active(&pgdat->kswapd_wait))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 return;
Mel Gorman88f5acf2011-01-13 15:45:41 -08002959 if (zone_watermark_ok_safe(zone, order, low_wmark_pages(zone), 0, 0))
2960 return;
2961
2962 trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, zone_idx(zone), order);
Con Kolivas8d0986e2005-09-13 01:25:07 -07002963 wake_up_interruptible(&pgdat->kswapd_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964}
2965
Wu Fengguangadea02a2009-09-21 17:01:42 -07002966/*
2967 * The reclaimable count would be mostly accurate.
2968 * The less reclaimable pages may be
2969 * - mlocked pages, which will be moved to unevictable list when encountered
2970 * - mapped pages, which may require several travels to be reclaimed
2971 * - dirty pages, which is not "instantly" reclaimable
2972 */
2973unsigned long global_reclaimable_pages(void)
Rik van Riel4f98a2f2008-10-18 20:26:32 -07002974{
Wu Fengguangadea02a2009-09-21 17:01:42 -07002975 int nr;
2976
2977 nr = global_page_state(NR_ACTIVE_FILE) +
2978 global_page_state(NR_INACTIVE_FILE);
2979
Shaohua Li1abbca72013-02-22 16:34:38 -08002980 if (get_nr_swap_pages() > 0)
Wu Fengguangadea02a2009-09-21 17:01:42 -07002981 nr += global_page_state(NR_ACTIVE_ANON) +
2982 global_page_state(NR_INACTIVE_ANON);
2983
2984 return nr;
2985}
2986
Rafael J. Wysockic6f37f12009-05-24 22:16:31 +02002987#ifdef CONFIG_HIBERNATION
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988/*
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08002989 * Try to free `nr_to_reclaim' of memory, system-wide, and return the number of
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07002990 * freed pages.
2991 *
2992 * Rather than trying to age LRUs the aim is to preserve the overall
2993 * LRU order by reclaiming preferentially
2994 * inactive > active > active referenced > active mapped
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 */
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08002996unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997{
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07002998 struct reclaim_state reclaim_state;
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07002999 struct scan_control sc = {
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08003000 .gfp_mask = GFP_HIGHUSER_MOVABLE,
3001 .may_swap = 1,
3002 .may_unmap = 1,
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07003003 .may_writepage = 1,
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08003004 .nr_to_reclaim = nr_to_reclaim,
3005 .hibernation_mode = 1,
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08003006 .order = 0,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07003007 .priority = DEF_PRIORITY,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008 };
Ying Hana09ed5e2011-05-24 17:12:26 -07003009 struct shrink_control shrink = {
3010 .gfp_mask = sc.gfp_mask,
3011 };
3012 struct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08003013 struct task_struct *p = current;
3014 unsigned long nr_reclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08003016 p->flags |= PF_MEMALLOC;
3017 lockdep_set_current_reclaim_state(sc.gfp_mask);
3018 reclaim_state.reclaimed_slab = 0;
3019 p->reclaim_state = &reclaim_state;
Andrew Morton69e05942006-03-22 00:08:19 -08003020
Ying Hana09ed5e2011-05-24 17:12:26 -07003021 nr_reclaimed = do_try_to_free_pages(zonelist, &sc, &shrink);
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07003022
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08003023 p->reclaim_state = NULL;
3024 lockdep_clear_current_reclaim_state();
3025 p->flags &= ~PF_MEMALLOC;
Rafael J. Wysockid6277db2006-06-23 02:03:18 -07003026
KOSAKI Motohiro7b517552009-12-14 17:59:12 -08003027 return nr_reclaimed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028}
Rafael J. Wysockic6f37f12009-05-24 22:16:31 +02003029#endif /* CONFIG_HIBERNATION */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031/* It's optimal to keep kswapds on the same CPUs as their memory, but
3032 not required for correctness. So if the last cpu in a node goes
3033 away, we get changed to run anywhere: as the first one comes back,
3034 restore their cpu bindings. */
Chandra Seetharaman9c7b2162006-06-27 02:54:07 -07003035static int __devinit cpu_callback(struct notifier_block *nfb,
Andrew Morton69e05942006-03-22 00:08:19 -08003036 unsigned long action, void *hcpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037{
Yasunori Goto58c0a4a2007-10-16 01:25:40 -07003038 int nid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07003040 if (action == CPU_ONLINE || action == CPU_ONLINE_FROZEN) {
Yasunori Goto58c0a4a2007-10-16 01:25:40 -07003041 for_each_node_state(nid, N_HIGH_MEMORY) {
Mike Travisc5f59f02008-04-04 18:11:10 -07003042 pg_data_t *pgdat = NODE_DATA(nid);
Rusty Russella70f7302009-03-13 14:49:46 +10303043 const struct cpumask *mask;
3044
3045 mask = cpumask_of_node(pgdat->node_id);
Mike Travisc5f59f02008-04-04 18:11:10 -07003046
Rusty Russell3e597942009-01-01 10:12:24 +10303047 if (cpumask_any_and(cpu_online_mask, mask) < nr_cpu_ids)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 /* One of our CPUs online: restore mask */
Mike Travisc5f59f02008-04-04 18:11:10 -07003049 set_cpus_allowed_ptr(pgdat->kswapd, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 }
3051 }
3052 return NOTIFY_OK;
3053}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054
Yasunori Goto3218ae12006-06-27 02:53:33 -07003055/*
3056 * This kswapd start function will be called by init and node-hot-add.
3057 * On node-hot-add, kswapd will moved to proper cpus if cpus are hot-added.
3058 */
3059int kswapd_run(int nid)
3060{
3061 pg_data_t *pgdat = NODE_DATA(nid);
3062 int ret = 0;
3063
3064 if (pgdat->kswapd)
3065 return 0;
3066
3067 pgdat->kswapd = kthread_run(kswapd, pgdat, "kswapd%d", nid);
3068 if (IS_ERR(pgdat->kswapd)) {
3069 /* failure at boot is fatal */
3070 BUG_ON(system_state == SYSTEM_BOOTING);
3071 printk("Failed to start kswapd on node %d\n",nid);
3072 ret = -1;
3073 }
3074 return ret;
3075}
3076
David Rientjes8fe23e02009-12-14 17:58:33 -08003077/*
Jiang Liuec75cfe2012-07-11 14:01:52 -07003078 * Called by memory hotplug when all memory in a node is offlined. Caller must
3079 * hold lock_memory_hotplug().
David Rientjes8fe23e02009-12-14 17:58:33 -08003080 */
3081void kswapd_stop(int nid)
3082{
3083 struct task_struct *kswapd = NODE_DATA(nid)->kswapd;
3084
Jiang Liuec75cfe2012-07-11 14:01:52 -07003085 if (kswapd) {
David Rientjes8fe23e02009-12-14 17:58:33 -08003086 kthread_stop(kswapd);
Jiang Liuec75cfe2012-07-11 14:01:52 -07003087 NODE_DATA(nid)->kswapd = NULL;
3088 }
David Rientjes8fe23e02009-12-14 17:58:33 -08003089}
3090
Linus Torvalds1da177e2005-04-16 15:20:36 -07003091static int __init kswapd_init(void)
3092{
Yasunori Goto3218ae12006-06-27 02:53:33 -07003093 int nid;
Andrew Morton69e05942006-03-22 00:08:19 -08003094
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 swap_setup();
Christoph Lameter9422ffb2007-10-16 01:25:31 -07003096 for_each_node_state(nid, N_HIGH_MEMORY)
Yasunori Goto3218ae12006-06-27 02:53:33 -07003097 kswapd_run(nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098 hotcpu_notifier(cpu_callback, 0);
3099 return 0;
3100}
3101
3102module_init(kswapd_init)
Christoph Lameter9eeff232006-01-18 17:42:31 -08003103
3104#ifdef CONFIG_NUMA
3105/*
3106 * Zone reclaim mode
3107 *
3108 * If non-zero call zone_reclaim when the number of free pages falls below
3109 * the watermarks.
Christoph Lameter9eeff232006-01-18 17:42:31 -08003110 */
3111int zone_reclaim_mode __read_mostly;
3112
Christoph Lameter1b2ffb72006-02-01 03:05:34 -08003113#define RECLAIM_OFF 0
Fernando Luis Vazquez Cao7d034312008-07-29 22:33:41 -07003114#define RECLAIM_ZONE (1<<0) /* Run shrink_inactive_list on the zone */
Christoph Lameter1b2ffb72006-02-01 03:05:34 -08003115#define RECLAIM_WRITE (1<<1) /* Writeout pages during reclaim */
3116#define RECLAIM_SWAP (1<<2) /* Swap pages out during reclaim */
3117
Christoph Lameter9eeff232006-01-18 17:42:31 -08003118/*
Christoph Lametera92f7122006-02-01 03:05:32 -08003119 * Priority for ZONE_RECLAIM. This determines the fraction of pages
3120 * of a node considered for each zone_reclaim. 4 scans 1/16th of
3121 * a zone.
3122 */
3123#define ZONE_RECLAIM_PRIORITY 4
3124
Christoph Lameter9eeff232006-01-18 17:42:31 -08003125/*
Christoph Lameter96146342006-07-03 00:24:13 -07003126 * Percentage of pages in a zone that must be unmapped for zone_reclaim to
3127 * occur.
3128 */
3129int sysctl_min_unmapped_ratio = 1;
3130
3131/*
Christoph Lameter0ff38492006-09-25 23:31:52 -07003132 * If the number of slab pages in a zone grows beyond this percentage then
3133 * slab reclaim needs to occur.
3134 */
3135int sysctl_min_slab_ratio = 5;
3136
Mel Gorman90afa5d2009-06-16 15:33:20 -07003137static inline unsigned long zone_unmapped_file_pages(struct zone *zone)
3138{
3139 unsigned long file_mapped = zone_page_state(zone, NR_FILE_MAPPED);
3140 unsigned long file_lru = zone_page_state(zone, NR_INACTIVE_FILE) +
3141 zone_page_state(zone, NR_ACTIVE_FILE);
3142
3143 /*
3144 * It's possible for there to be more file mapped pages than
3145 * accounted for by the pages on the file LRU lists because
3146 * tmpfs pages accounted for as ANON can also be FILE_MAPPED
3147 */
3148 return (file_lru > file_mapped) ? (file_lru - file_mapped) : 0;
3149}
3150
3151/* Work out how many page cache pages we can reclaim in this reclaim_mode */
3152static long zone_pagecache_reclaimable(struct zone *zone)
3153{
3154 long nr_pagecache_reclaimable;
3155 long delta = 0;
3156
3157 /*
3158 * If RECLAIM_SWAP is set, then all file pages are considered
3159 * potentially reclaimable. Otherwise, we have to worry about
3160 * pages like swapcache and zone_unmapped_file_pages() provides
3161 * a better estimate
3162 */
3163 if (zone_reclaim_mode & RECLAIM_SWAP)
3164 nr_pagecache_reclaimable = zone_page_state(zone, NR_FILE_PAGES);
3165 else
3166 nr_pagecache_reclaimable = zone_unmapped_file_pages(zone);
3167
3168 /* If we can't clean pages, remove dirty pages from consideration */
3169 if (!(zone_reclaim_mode & RECLAIM_WRITE))
3170 delta += zone_page_state(zone, NR_FILE_DIRTY);
3171
3172 /* Watch for any possible underflows due to delta */
3173 if (unlikely(delta > nr_pagecache_reclaimable))
3174 delta = nr_pagecache_reclaimable;
3175
3176 return nr_pagecache_reclaimable - delta;
3177}
3178
Christoph Lameter0ff38492006-09-25 23:31:52 -07003179/*
Christoph Lameter9eeff232006-01-18 17:42:31 -08003180 * Try to free up some pages from this zone through reclaim.
3181 */
Andrew Morton179e9632006-03-22 00:08:18 -08003182static int __zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
Christoph Lameter9eeff232006-01-18 17:42:31 -08003183{
Christoph Lameter7fb2d462006-03-22 00:08:22 -08003184 /* Minimum pages needed in order to stay on node */
Andrew Morton69e05942006-03-22 00:08:19 -08003185 const unsigned long nr_pages = 1 << order;
Christoph Lameter9eeff232006-01-18 17:42:31 -08003186 struct task_struct *p = current;
3187 struct reclaim_state reclaim_state;
Andrew Morton179e9632006-03-22 00:08:18 -08003188 struct scan_control sc = {
3189 .may_writepage = !!(zone_reclaim_mode & RECLAIM_WRITE),
Johannes Weinera6dc60f2009-03-31 15:19:30 -07003190 .may_unmap = !!(zone_reclaim_mode & RECLAIM_SWAP),
KOSAKI Motohiro2e2e4252009-04-21 12:24:57 -07003191 .may_swap = 1,
KOSAKI Motohiro22fba332009-12-14 17:59:10 -08003192 .nr_to_reclaim = max_t(unsigned long, nr_pages,
3193 SWAP_CLUSTER_MAX),
Andrew Morton179e9632006-03-22 00:08:18 -08003194 .gfp_mask = gfp_mask,
Johannes Weinerbd2f6192009-03-31 15:19:38 -07003195 .order = order,
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07003196 .priority = ZONE_RECLAIM_PRIORITY,
Andrew Morton179e9632006-03-22 00:08:18 -08003197 };
Ying Hana09ed5e2011-05-24 17:12:26 -07003198 struct shrink_control shrink = {
3199 .gfp_mask = sc.gfp_mask,
3200 };
KOSAKI Motohiro15748042010-08-09 17:19:50 -07003201 unsigned long nr_slab_pages0, nr_slab_pages1;
Christoph Lameter9eeff232006-01-18 17:42:31 -08003202
Christoph Lameter9eeff232006-01-18 17:42:31 -08003203 cond_resched();
Christoph Lameterd4f77962006-02-24 13:04:22 -08003204 /*
3205 * We need to be able to allocate from the reserves for RECLAIM_SWAP
3206 * and we also need to be able to write out pages for RECLAIM_WRITE
3207 * and RECLAIM_SWAP.
3208 */
3209 p->flags |= PF_MEMALLOC | PF_SWAPWRITE;
KOSAKI Motohiro76ca5422010-03-05 13:41:47 -08003210 lockdep_set_current_reclaim_state(gfp_mask);
Christoph Lameter9eeff232006-01-18 17:42:31 -08003211 reclaim_state.reclaimed_slab = 0;
3212 p->reclaim_state = &reclaim_state;
Christoph Lameterc84db232006-02-01 03:05:29 -08003213
Mel Gorman90afa5d2009-06-16 15:33:20 -07003214 if (zone_pagecache_reclaimable(zone) > zone->min_unmapped_pages) {
Christoph Lameter0ff38492006-09-25 23:31:52 -07003215 /*
3216 * Free memory by calling shrink zone with increasing
3217 * priorities until we have enough memory freed.
3218 */
Christoph Lameter0ff38492006-09-25 23:31:52 -07003219 do {
Konstantin Khlebnikov038ada92012-05-29 15:06:57 -07003220 shrink_zone(zone, &sc);
3221 } while (sc.nr_reclaimed < nr_pages && --sc.priority >= 0);
Christoph Lameter0ff38492006-09-25 23:31:52 -07003222 }
Christoph Lameterc84db232006-02-01 03:05:29 -08003223
KOSAKI Motohiro15748042010-08-09 17:19:50 -07003224 nr_slab_pages0 = zone_page_state(zone, NR_SLAB_RECLAIMABLE);
3225 if (nr_slab_pages0 > zone->min_slab_pages) {
Christoph Lameter2a16e3f2006-02-01 03:05:35 -08003226 /*
Christoph Lameter7fb2d462006-03-22 00:08:22 -08003227 * shrink_slab() does not currently allow us to determine how
Christoph Lameter0ff38492006-09-25 23:31:52 -07003228 * many pages were freed in this zone. So we take the current
3229 * number of slab pages and shake the slab until it is reduced
3230 * by the same nr_pages that we used for reclaiming unmapped
3231 * pages.
Christoph Lameter2a16e3f2006-02-01 03:05:35 -08003232 *
Christoph Lameter0ff38492006-09-25 23:31:52 -07003233 * Note that shrink_slab will free memory on all zones and may
3234 * take a long time.
Christoph Lameter2a16e3f2006-02-01 03:05:35 -08003235 */
KOSAKI Motohiro4dc4b3d2010-08-09 17:19:54 -07003236 for (;;) {
3237 unsigned long lru_pages = zone_reclaimable_pages(zone);
3238
3239 /* No reclaimable slab or very low memory pressure */
Ying Han1495f232011-05-24 17:12:27 -07003240 if (!shrink_slab(&shrink, sc.nr_scanned, lru_pages))
KOSAKI Motohiro4dc4b3d2010-08-09 17:19:54 -07003241 break;
3242
3243 /* Freed enough memory */
3244 nr_slab_pages1 = zone_page_state(zone,
3245 NR_SLAB_RECLAIMABLE);
3246 if (nr_slab_pages1 + nr_pages <= nr_slab_pages0)
3247 break;
3248 }
Christoph Lameter83e33a42006-09-25 23:31:53 -07003249
3250 /*
3251 * Update nr_reclaimed by the number of slab pages we
3252 * reclaimed from this zone.
3253 */
KOSAKI Motohiro15748042010-08-09 17:19:50 -07003254 nr_slab_pages1 = zone_page_state(zone, NR_SLAB_RECLAIMABLE);
3255 if (nr_slab_pages1 < nr_slab_pages0)
3256 sc.nr_reclaimed += nr_slab_pages0 - nr_slab_pages1;
Christoph Lameter2a16e3f2006-02-01 03:05:35 -08003257 }
3258
Christoph Lameter9eeff232006-01-18 17:42:31 -08003259 p->reclaim_state = NULL;
Christoph Lameterd4f77962006-02-24 13:04:22 -08003260 current->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE);
KOSAKI Motohiro76ca5422010-03-05 13:41:47 -08003261 lockdep_clear_current_reclaim_state();
Rik van Riela79311c2009-01-06 14:40:01 -08003262 return sc.nr_reclaimed >= nr_pages;
Christoph Lameter9eeff232006-01-18 17:42:31 -08003263}
Andrew Morton179e9632006-03-22 00:08:18 -08003264
3265int zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
3266{
Andrew Morton179e9632006-03-22 00:08:18 -08003267 int node_id;
David Rientjesd773ed62007-10-16 23:26:01 -07003268 int ret;
Andrew Morton179e9632006-03-22 00:08:18 -08003269
3270 /*
Christoph Lameter0ff38492006-09-25 23:31:52 -07003271 * Zone reclaim reclaims unmapped file backed pages and
3272 * slab pages if we are over the defined limits.
Christoph Lameter34aa1332006-06-30 01:55:37 -07003273 *
Christoph Lameter96146342006-07-03 00:24:13 -07003274 * A small portion of unmapped file backed pages is needed for
3275 * file I/O otherwise pages read by file I/O will be immediately
3276 * thrown out if the zone is overallocated. So we do not reclaim
3277 * if less than a specified percentage of the zone is used by
3278 * unmapped file backed pages.
Andrew Morton179e9632006-03-22 00:08:18 -08003279 */
Mel Gorman90afa5d2009-06-16 15:33:20 -07003280 if (zone_pagecache_reclaimable(zone) <= zone->min_unmapped_pages &&
3281 zone_page_state(zone, NR_SLAB_RECLAIMABLE) <= zone->min_slab_pages)
Mel Gormanfa5e0842009-06-16 15:33:22 -07003282 return ZONE_RECLAIM_FULL;
Andrew Morton179e9632006-03-22 00:08:18 -08003283
Lisa Due0935212013-09-11 14:22:36 -07003284 if (!zone_reclaimable(zone))
Mel Gormanfa5e0842009-06-16 15:33:22 -07003285 return ZONE_RECLAIM_FULL;
David Rientjesd773ed62007-10-16 23:26:01 -07003286
Andrew Morton179e9632006-03-22 00:08:18 -08003287 /*
David Rientjesd773ed62007-10-16 23:26:01 -07003288 * Do not scan if the allocation should not be delayed.
Andrew Morton179e9632006-03-22 00:08:18 -08003289 */
David Rientjesd773ed62007-10-16 23:26:01 -07003290 if (!(gfp_mask & __GFP_WAIT) || (current->flags & PF_MEMALLOC))
Mel Gormanfa5e0842009-06-16 15:33:22 -07003291 return ZONE_RECLAIM_NOSCAN;
Andrew Morton179e9632006-03-22 00:08:18 -08003292
3293 /*
3294 * Only run zone reclaim on the local zone or on zones that do not
3295 * have associated processors. This will favor the local processor
3296 * over remote processors and spread off node memory allocations
3297 * as wide as possible.
3298 */
Christoph Lameter89fa3022006-09-25 23:31:55 -07003299 node_id = zone_to_nid(zone);
Christoph Lameter37c07082007-10-16 01:25:36 -07003300 if (node_state(node_id, N_CPU) && node_id != numa_node_id())
Mel Gormanfa5e0842009-06-16 15:33:22 -07003301 return ZONE_RECLAIM_NOSCAN;
David Rientjesd773ed62007-10-16 23:26:01 -07003302
3303 if (zone_test_and_set_flag(zone, ZONE_RECLAIM_LOCKED))
Mel Gormanfa5e0842009-06-16 15:33:22 -07003304 return ZONE_RECLAIM_NOSCAN;
3305
David Rientjesd773ed62007-10-16 23:26:01 -07003306 ret = __zone_reclaim(zone, gfp_mask, order);
3307 zone_clear_flag(zone, ZONE_RECLAIM_LOCKED);
3308
Mel Gorman24cf725182009-06-16 15:33:23 -07003309 if (!ret)
3310 count_vm_event(PGSCAN_ZONE_RECLAIM_FAILED);
3311
David Rientjesd773ed62007-10-16 23:26:01 -07003312 return ret;
Andrew Morton179e9632006-03-22 00:08:18 -08003313}
Christoph Lameter9eeff232006-01-18 17:42:31 -08003314#endif
Lee Schermerhorn894bc312008-10-18 20:26:39 -07003315
Lee Schermerhorn894bc312008-10-18 20:26:39 -07003316/*
3317 * page_evictable - test whether a page is evictable
3318 * @page: the page to test
3319 * @vma: the VMA in which the page is or will be mapped, may be NULL
3320 *
3321 * Test whether page is evictable--i.e., should be placed on active/inactive
Nick Pigginb291f002008-10-18 20:26:44 -07003322 * lists vs unevictable list. The vma argument is !NULL when called from the
3323 * fault path to determine how to instantate a new page.
Lee Schermerhorn894bc312008-10-18 20:26:39 -07003324 *
3325 * Reasons page might not be evictable:
Lee Schermerhornba9ddf42008-10-18 20:26:42 -07003326 * (1) page's mapping marked unevictable
Nick Pigginb291f002008-10-18 20:26:44 -07003327 * (2) page is part of an mlocked VMA
Lee Schermerhornba9ddf42008-10-18 20:26:42 -07003328 *
Lee Schermerhorn894bc312008-10-18 20:26:39 -07003329 */
3330int page_evictable(struct page *page, struct vm_area_struct *vma)
3331{
3332
Lee Schermerhornba9ddf42008-10-18 20:26:42 -07003333 if (mapping_unevictable(page_mapping(page)))
3334 return 0;
3335
Nick Pigginb291f002008-10-18 20:26:44 -07003336 if (PageMlocked(page) || (vma && is_mlocked_vma(vma, page)))
3337 return 0;
Lee Schermerhorn894bc312008-10-18 20:26:39 -07003338
3339 return 1;
3340}
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003341
Hugh Dickins850465792012-01-20 14:34:19 -08003342#ifdef CONFIG_SHMEM
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003343/**
Hugh Dickins24513262012-01-20 14:34:21 -08003344 * check_move_unevictable_pages - check pages for evictability and move to appropriate zone lru list
3345 * @pages: array of pages to check
3346 * @nr_pages: number of pages to check
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003347 *
Hugh Dickins24513262012-01-20 14:34:21 -08003348 * Checks pages for evictability and moves them to the appropriate lru list.
Hugh Dickins850465792012-01-20 14:34:19 -08003349 *
3350 * This function is only used for SysV IPC SHM_UNLOCK.
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003351 */
Hugh Dickins24513262012-01-20 14:34:21 -08003352void check_move_unevictable_pages(struct page **pages, int nr_pages)
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003353{
Johannes Weiner925b7672012-01-12 17:18:15 -08003354 struct lruvec *lruvec;
Hugh Dickins24513262012-01-20 14:34:21 -08003355 struct zone *zone = NULL;
3356 int pgscanned = 0;
3357 int pgrescued = 0;
3358 int i;
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003359
Hugh Dickins24513262012-01-20 14:34:21 -08003360 for (i = 0; i < nr_pages; i++) {
3361 struct page *page = pages[i];
3362 struct zone *pagezone;
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003363
Hugh Dickins24513262012-01-20 14:34:21 -08003364 pgscanned++;
3365 pagezone = page_zone(page);
3366 if (pagezone != zone) {
3367 if (zone)
3368 spin_unlock_irq(&zone->lru_lock);
3369 zone = pagezone;
3370 spin_lock_irq(&zone->lru_lock);
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003371 }
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003372
Hugh Dickins24513262012-01-20 14:34:21 -08003373 if (!PageLRU(page) || !PageUnevictable(page))
3374 continue;
3375
3376 if (page_evictable(page, NULL)) {
3377 enum lru_list lru = page_lru_base_type(page);
3378
3379 VM_BUG_ON(PageActive(page));
3380 ClearPageUnevictable(page);
3381 __dec_zone_state(zone, NR_UNEVICTABLE);
3382 lruvec = mem_cgroup_lru_move_lists(zone, page,
3383 LRU_UNEVICTABLE, lru);
3384 list_move(&page->lru, &lruvec->lists[lru]);
3385 __inc_zone_state(zone, NR_INACTIVE_ANON + lru);
3386 pgrescued++;
3387 }
Lee Schermerhorn89e004ea2008-10-18 20:26:43 -07003388 }
Hugh Dickins24513262012-01-20 14:34:21 -08003389
3390 if (zone) {
3391 __count_vm_events(UNEVICTABLE_PGRESCUED, pgrescued);
3392 __count_vm_events(UNEVICTABLE_PGSCANNED, pgscanned);
3393 spin_unlock_irq(&zone->lru_lock);
3394 }
Hugh Dickins850465792012-01-20 14:34:19 -08003395}
3396#endif /* CONFIG_SHMEM */
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003397
Johannes Weiner264e56d2011-10-31 17:09:13 -07003398static void warn_scan_unevictable_pages(void)
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003399{
Johannes Weiner264e56d2011-10-31 17:09:13 -07003400 printk_once(KERN_WARNING
KOSAKI Motohiro25bd91b2012-01-10 15:07:40 -08003401 "%s: The scan_unevictable_pages sysctl/node-interface has been "
Johannes Weiner264e56d2011-10-31 17:09:13 -07003402 "disabled for lack of a legitimate use case. If you have "
KOSAKI Motohiro25bd91b2012-01-10 15:07:40 -08003403 "one, please send an email to linux-mm@kvack.org.\n",
3404 current->comm);
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003405}
3406
3407/*
3408 * scan_unevictable_pages [vm] sysctl handler. On demand re-scan of
3409 * all nodes' unevictable lists for evictable pages
3410 */
3411unsigned long scan_unevictable_pages;
3412
3413int scan_unevictable_handler(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07003414 void __user *buffer,
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003415 size_t *length, loff_t *ppos)
3416{
Johannes Weiner264e56d2011-10-31 17:09:13 -07003417 warn_scan_unevictable_pages();
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07003418 proc_doulongvec_minmax(table, write, buffer, length, ppos);
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003419 scan_unevictable_pages = 0;
3420 return 0;
3421}
3422
Thadeu Lima de Souza Cascardoe4455ab2010-10-26 14:21:28 -07003423#ifdef CONFIG_NUMA
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003424/*
3425 * per node 'scan_unevictable_pages' attribute. On demand re-scan of
3426 * a specified node's per zone unevictable lists for evictable pages.
3427 */
3428
Kay Sievers10fbcf42011-12-21 14:48:43 -08003429static ssize_t read_scan_unevictable_node(struct device *dev,
3430 struct device_attribute *attr,
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003431 char *buf)
3432{
Johannes Weiner264e56d2011-10-31 17:09:13 -07003433 warn_scan_unevictable_pages();
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003434 return sprintf(buf, "0\n"); /* always zero; should fit... */
3435}
3436
Kay Sievers10fbcf42011-12-21 14:48:43 -08003437static ssize_t write_scan_unevictable_node(struct device *dev,
3438 struct device_attribute *attr,
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003439 const char *buf, size_t count)
3440{
Johannes Weiner264e56d2011-10-31 17:09:13 -07003441 warn_scan_unevictable_pages();
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003442 return 1;
3443}
3444
3445
Kay Sievers10fbcf42011-12-21 14:48:43 -08003446static DEVICE_ATTR(scan_unevictable_pages, S_IRUGO | S_IWUSR,
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003447 read_scan_unevictable_node,
3448 write_scan_unevictable_node);
3449
3450int scan_unevictable_register_node(struct node *node)
3451{
Kay Sievers10fbcf42011-12-21 14:48:43 -08003452 return device_create_file(&node->dev, &dev_attr_scan_unevictable_pages);
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003453}
3454
3455void scan_unevictable_unregister_node(struct node *node)
3456{
Kay Sievers10fbcf42011-12-21 14:48:43 -08003457 device_remove_file(&node->dev, &dev_attr_scan_unevictable_pages);
Lee Schermerhornaf936a12008-10-18 20:26:53 -07003458}
Thadeu Lima de Souza Cascardoe4455ab2010-10-26 14:21:28 -07003459#endif