Branch data Line data Source code
1 : : /*
2 : : * linux/mm/swap.c
3 : : *
4 : : * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
5 : : */
6 : :
7 : : /*
8 : : * This file contains the default values for the operation of the
9 : : * Linux VM subsystem. Fine-tuning documentation can be found in
10 : : * Documentation/sysctl/vm.txt.
11 : : * Started 18.12.91
12 : : * Swap aging added 23.2.95, Stephen Tweedie.
13 : : * Buffermem limits added 12.3.98, Rik van Riel.
14 : : */
15 : :
16 : : #include <linux/mm.h>
17 : : #include <linux/sched.h>
18 : : #include <linux/kernel_stat.h>
19 : : #include <linux/swap.h>
20 : : #include <linux/mman.h>
21 : : #include <linux/pagemap.h>
22 : : #include <linux/pagevec.h>
23 : : #include <linux/init.h>
24 : : #include <linux/export.h>
25 : : #include <linux/mm_inline.h>
26 : : #include <linux/percpu_counter.h>
27 : : #include <linux/percpu.h>
28 : : #include <linux/cpu.h>
29 : : #include <linux/notifier.h>
30 : : #include <linux/backing-dev.h>
31 : : #include <linux/memcontrol.h>
32 : : #include <linux/gfp.h>
33 : : #include <linux/uio.h>
34 : :
35 : : #include "internal.h"
36 : :
37 : : #define CREATE_TRACE_POINTS
38 : : #include <trace/events/pagemap.h>
39 : :
40 : : /* How many pages do we try to swap or page in/out together? */
41 : : int page_cluster;
42 : :
43 : : static DEFINE_PER_CPU(struct pagevec, lru_add_pvec);
44 : : static DEFINE_PER_CPU(struct pagevec, lru_rotate_pvecs);
45 : : static DEFINE_PER_CPU(struct pagevec, lru_deactivate_pvecs);
46 : :
47 : : /*
48 : : * This path almost never happens for VM activity - pages are normally
49 : : * freed via pagevecs. But it gets used by networking.
50 : : */
51 : 0 : static void __page_cache_release(struct page *page)
52 : : {
53 [ + + ]: 12544 : if (PageLRU(page)) {
54 : 9930 : struct zone *zone = page_zone(page);
55 : : struct lruvec *lruvec;
56 : : unsigned long flags;
57 : :
58 : 9930 : spin_lock_irqsave(&zone->lru_lock, flags);
59 : : lruvec = mem_cgroup_page_lruvec(page, zone);
60 : : VM_BUG_ON_PAGE(!PageLRU(page), page);
61 : : __ClearPageLRU(page);
62 : : del_page_from_lru_list(page, lruvec, page_off_lru(page));
63 : : spin_unlock_irqrestore(&zone->lru_lock, flags);
64 : : }
65 : 12544 : }
66 : :
67 : : static void __put_single_page(struct page *page)
68 : : {
69 : 12531 : __page_cache_release(page);
70 : 12531 : free_hot_cold_page(page, 0);
71 : : }
72 : :
73 : : static void __put_compound_page(struct page *page)
74 : : {
75 : : compound_page_dtor *dtor;
76 : :
77 : 13 : __page_cache_release(page);
78 : : dtor = get_compound_page_dtor(page);
79 : 13 : (*dtor)(page);
80 : : }
81 : :
82 : 0 : static void put_compound_page(struct page *page)
83 : : {
84 : : struct page *page_head;
85 : :
86 [ + - ]: 21390 : if (likely(!PageTail(page))) {
87 [ + + ]: 21390 : if (put_page_testzero(page)) {
88 : : /*
89 : : * By the time all refcounts have been released
90 : : * split_huge_page cannot run anymore from under us.
91 : : */
92 [ + - ]: 13 : if (PageHead(page))
93 : : __put_compound_page(page);
94 : : else
95 : : __put_single_page(page);
96 : : }
97 : : return;
98 : : }
99 : :
100 : : /* __split_huge_page_refcount can run under us */
101 : : page_head = compound_head(page);
102 : :
103 : : /*
104 : : * THP can not break up slab pages so avoid taking
105 : : * compound_lock() and skip the tail page refcounting (in
106 : : * _mapcount) too. Slab performs non-atomic bit ops on
107 : : * page->flags for better performance. In particular
108 : : * slab_unlock() in slub used to be a hot path. It is still
109 : : * hot on arches that do not support
110 : : * this_cpu_cmpxchg_double().
111 : : *
112 : : * If "page" is part of a slab or hugetlbfs page it cannot be
113 : : * splitted and the head page cannot change from under us. And
114 : : * if "page" is part of a THP page under splitting, if the
115 : : * head page pointed by the THP tail isn't a THP head anymore,
116 : : * we'll find PageTail clear after smp_rmb() and we'll treat
117 : : * it as a single page.
118 : : */
119 [ # # ]: 0 : if (!__compound_tail_refcounted(page_head)) {
120 : : /*
121 : : * If "page" is a THP tail, we must read the tail page
122 : : * flags after the head page flags. The
123 : : * split_huge_page side enforces write memory barriers
124 : : * between clearing PageTail and before the head page
125 : : * can be freed and reallocated.
126 : : */
127 : 0 : smp_rmb();
128 [ # # ]: 0 : if (likely(PageTail(page))) {
129 : : /*
130 : : * __split_huge_page_refcount cannot race
131 : : * here.
132 : : */
133 : : VM_BUG_ON_PAGE(!PageHead(page_head), page_head);
134 : : VM_BUG_ON_PAGE(page_mapcount(page) != 0, page);
135 [ # # ]: 0 : if (put_page_testzero(page_head)) {
136 : : /*
137 : : * If this is the tail of a slab
138 : : * compound page, the tail pin must
139 : : * not be the last reference held on
140 : : * the page, because the PG_slab
141 : : * cannot be cleared before all tail
142 : : * pins (which skips the _mapcount
143 : : * tail refcounting) have been
144 : : * released. For hugetlbfs the tail
145 : : * pin may be the last reference on
146 : : * the page instead, because
147 : : * PageHeadHuge will not go away until
148 : : * the compound page enters the buddy
149 : : * allocator.
150 : : */
151 : : VM_BUG_ON_PAGE(PageSlab(page_head), page_head);
152 : : __put_compound_page(page_head);
153 : : }
154 : : return;
155 : : } else
156 : : /*
157 : : * __split_huge_page_refcount run before us,
158 : : * "page" was a THP tail. The split page_head
159 : : * has been freed and reallocated as slab or
160 : : * hugetlbfs page of smaller order (only
161 : : * possible if reallocated as slab on x86).
162 : : */
163 : : goto out_put_single;
164 : : }
165 : :
166 [ # # ][ # # ]: 0 : if (likely(page != page_head && get_page_unless_zero(page_head))) {
167 : : unsigned long flags;
168 : :
169 : : /*
170 : : * page_head wasn't a dangling pointer but it may not
171 : : * be a head page anymore by the time we obtain the
172 : : * lock. That is ok as long as it can't be freed from
173 : : * under us.
174 : : */
175 : : flags = compound_lock_irqsave(page_head);
176 [ # # ]: 0 : if (unlikely(!PageTail(page))) {
177 : : /* __split_huge_page_refcount run before us */
178 : : compound_unlock_irqrestore(page_head, flags);
179 [ # # ]: 0 : if (put_page_testzero(page_head)) {
180 : : /*
181 : : * The head page may have been freed
182 : : * and reallocated as a compound page
183 : : * of smaller order and then freed
184 : : * again. All we know is that it
185 : : * cannot have become: a THP page, a
186 : : * compound page of higher order, a
187 : : * tail page. That is because we
188 : : * still hold the refcount of the
189 : : * split THP tail and page_head was
190 : : * the THP head before the split.
191 : : */
192 [ # # ]: 0 : if (PageHead(page_head))
193 : : __put_compound_page(page_head);
194 : : else
195 : : __put_single_page(page_head);
196 : : }
197 : : out_put_single:
198 [ # # ]: 0 : if (put_page_testzero(page))
199 : : __put_single_page(page);
200 : : return;
201 : : }
202 : : VM_BUG_ON_PAGE(page_head != page->first_page, page);
203 : : /*
204 : : * We can release the refcount taken by
205 : : * get_page_unless_zero() now that
206 : : * __split_huge_page_refcount() is blocked on the
207 : : * compound_lock.
208 : : */
209 : : if (put_page_testzero(page_head))
210 : : VM_BUG_ON_PAGE(1, page_head);
211 : : /* __split_huge_page_refcount will wait now */
212 : : VM_BUG_ON_PAGE(page_mapcount(page) <= 0, page);
213 : 0 : atomic_dec(&page->_mapcount);
214 : : VM_BUG_ON_PAGE(atomic_read(&page_head->_count) <= 0, page_head);
215 : : VM_BUG_ON_PAGE(atomic_read(&page->_count) != 0, page);
216 : : compound_unlock_irqrestore(page_head, flags);
217 : :
218 [ # # ]: 0 : if (put_page_testzero(page_head)) {
219 [ # # ]: 0 : if (PageHead(page_head))
220 : : __put_compound_page(page_head);
221 : : else
222 : : __put_single_page(page_head);
223 : : }
224 : : } else {
225 : : /* page_head is a dangling pointer */
226 : : VM_BUG_ON_PAGE(PageTail(page), page);
227 : : goto out_put_single;
228 : : }
229 : : }
230 : :
231 : 0 : void put_page(struct page *page)
232 : : {
233 [ + + ]: 42946438 : if (unlikely(PageCompound(page)))
234 : 21390 : put_compound_page(page);
235 [ + + ]: 42928251 : else if (put_page_testzero(page))
236 : : __put_single_page(page);
237 : 3203 : }
238 : : EXPORT_SYMBOL(put_page);
239 : :
240 : : /*
241 : : * This function is exported but must not be called by anything other
242 : : * than get_page(). It implements the slow path of get_page().
243 : : */
244 : 0 : bool __get_page_tail(struct page *page)
245 : : {
246 : : /*
247 : : * This takes care of get_page() if run on a tail page
248 : : * returned by one of the get_user_pages/follow_page variants.
249 : : * get_user_pages/follow_page itself doesn't need the compound
250 : : * lock because it runs __get_page_tail_foll() under the
251 : : * proper PT lock that already serializes against
252 : : * split_huge_page().
253 : : */
254 : : unsigned long flags;
255 : : bool got;
256 : : struct page *page_head = compound_head(page);
257 : :
258 : : /* Ref to put_compound_page() comment. */
259 [ # # ]: 0 : if (!__compound_tail_refcounted(page_head)) {
260 : 0 : smp_rmb();
261 [ # # ]: 0 : if (likely(PageTail(page))) {
262 : : /*
263 : : * This is a hugetlbfs page or a slab
264 : : * page. __split_huge_page_refcount
265 : : * cannot race here.
266 : : */
267 : : VM_BUG_ON_PAGE(!PageHead(page_head), page_head);
268 : : __get_page_tail_foll(page, true);
269 : : return true;
270 : : } else {
271 : : /*
272 : : * __split_huge_page_refcount run
273 : : * before us, "page" was a THP
274 : : * tail. The split page_head has been
275 : : * freed and reallocated as slab or
276 : : * hugetlbfs page of smaller order
277 : : * (only possible if reallocated as
278 : : * slab on x86).
279 : : */
280 : : return false;
281 : : }
282 : : }
283 : :
284 : : got = false;
285 [ # # ][ # # ]: 0 : if (likely(page != page_head && get_page_unless_zero(page_head))) {
286 : : /*
287 : : * page_head wasn't a dangling pointer but it
288 : : * may not be a head page anymore by the time
289 : : * we obtain the lock. That is ok as long as it
290 : : * can't be freed from under us.
291 : : */
292 : : flags = compound_lock_irqsave(page_head);
293 : : /* here __split_huge_page_refcount won't run anymore */
294 [ # # ]: 0 : if (likely(PageTail(page))) {
295 : : __get_page_tail_foll(page, false);
296 : : got = true;
297 : : }
298 : : compound_unlock_irqrestore(page_head, flags);
299 [ # # ]: 0 : if (unlikely(!got))
300 : 0 : put_page(page_head);
301 : : }
302 : 0 : return got;
303 : : }
304 : : EXPORT_SYMBOL(__get_page_tail);
305 : :
306 : : /**
307 : : * put_pages_list() - release a list of pages
308 : : * @pages: list of pages threaded on page->lru
309 : : *
310 : : * Release a list of pages which are strung together on page.lru. Currently
311 : : * used by read_cache_pages() and related error recovery code.
312 : : */
313 : 0 : void put_pages_list(struct list_head *pages)
314 : : {
315 [ - + ]: 118720 : while (!list_empty(pages)) {
316 : : struct page *victim;
317 : :
318 : 0 : victim = list_entry(pages->prev, struct page, lru);
319 : : list_del(&victim->lru);
320 : 0 : page_cache_release(victim);
321 : : }
322 : 118720 : }
323 : : EXPORT_SYMBOL(put_pages_list);
324 : :
325 : : /*
326 : : * get_kernel_pages() - pin kernel pages in memory
327 : : * @kiov: An array of struct kvec structures
328 : : * @nr_segs: number of segments to pin
329 : : * @write: pinning for read/write, currently ignored
330 : : * @pages: array that receives pointers to the pages pinned.
331 : : * Should be at least nr_segs long.
332 : : *
333 : : * Returns number of pages pinned. This may be fewer than the number
334 : : * requested. If nr_pages is 0 or negative, returns 0. If no pages
335 : : * were pinned, returns -errno. Each page returned must be released
336 : : * with a put_page() call when it is finished with.
337 : : */
338 : 0 : int get_kernel_pages(const struct kvec *kiov, int nr_segs, int write,
339 : : struct page **pages)
340 : : {
341 : : int seg;
342 : :
343 [ # # ]: 0 : for (seg = 0; seg < nr_segs; seg++) {
344 [ # # ][ # # ]: 0 : if (WARN_ON(kiov[seg].iov_len != PAGE_SIZE))
345 : : return seg;
346 : :
347 : 0 : pages[seg] = kmap_to_page(kiov[seg].iov_base);
348 : : page_cache_get(pages[seg]);
349 : : }
350 : :
351 : : return seg;
352 : : }
353 : : EXPORT_SYMBOL_GPL(get_kernel_pages);
354 : :
355 : : /*
356 : : * get_kernel_page() - pin a kernel page in memory
357 : : * @start: starting kernel address
358 : : * @write: pinning for read/write, currently ignored
359 : : * @pages: array that receives pointer to the page pinned.
360 : : * Must be at least nr_segs long.
361 : : *
362 : : * Returns 1 if page is pinned. If the page was not pinned, returns
363 : : * -errno. The page returned must be released with a put_page() call
364 : : * when it is finished with.
365 : : */
366 : 0 : int get_kernel_page(unsigned long start, int write, struct page **pages)
367 : : {
368 : 0 : const struct kvec kiov = {
369 : 0 : .iov_base = (void *)start,
370 : : .iov_len = PAGE_SIZE
371 : : };
372 : :
373 : 0 : return get_kernel_pages(&kiov, 1, write, pages);
374 : : }
375 : : EXPORT_SYMBOL_GPL(get_kernel_page);
376 : :
377 : 0 : static void pagevec_lru_move_fn(struct pagevec *pvec,
378 : : void (*move_fn)(struct page *page, struct lruvec *lruvec, void *arg),
379 : : void *arg)
380 : : {
381 : : int i;
382 : : struct zone *zone = NULL;
383 : : struct lruvec *lruvec;
384 : : unsigned long flags = 0;
385 : :
386 [ + + ]: 23581145 : for (i = 0; i < pagevec_count(pvec); i++) {
387 : 21029947 : struct page *page = pvec->pages[i];
388 : 21029947 : struct zone *pagezone = page_zone(page);
389 : :
390 [ + + ]: 21029947 : if (pagezone != zone) {
391 [ + + ]: 2596560 : if (zone)
392 : : spin_unlock_irqrestore(&zone->lru_lock, flags);
393 : : zone = pagezone;
394 : 2596561 : spin_lock_irqsave(&zone->lru_lock, flags);
395 : : }
396 : :
397 : 21029997 : lruvec = mem_cgroup_page_lruvec(page, zone);
398 : 21029997 : (*move_fn)(page, lruvec, arg);
399 : : }
400 [ + + ]: 2551198 : if (zone)
401 : : spin_unlock_irqrestore(&zone->lru_lock, flags);
402 : 2551199 : release_pages(pvec->pages, pvec->nr, pvec->cold);
403 : : pagevec_reinit(pvec);
404 : 2551157 : }
405 : :
406 : 0 : static void pagevec_move_tail_fn(struct page *page, struct lruvec *lruvec,
407 : : void *arg)
408 : : {
409 : : int *pgmoved = arg;
410 : :
411 [ + - ][ + + ]: 57 : if (PageLRU(page) && !PageActive(page) && !PageUnevictable(page)) {
[ + ]
412 : : enum lru_list lru = page_lru_base_type(page);
413 : 56 : list_move_tail(&page->lru, &lruvec->lists[lru]);
414 : 56 : (*pgmoved)++;
415 : : }
416 : 0 : }
417 : :
418 : : /*
419 : : * pagevec_move_tail() must be called with IRQ disabled.
420 : : * Otherwise this may cause nasty races.
421 : : */
422 : 0 : static void pagevec_move_tail(struct pagevec *pvec)
423 : : {
424 : 48 : int pgmoved = 0;
425 : :
426 : 48 : pagevec_lru_move_fn(pvec, pagevec_move_tail_fn, &pgmoved);
427 : 48 : __count_vm_events(PGROTATED, pgmoved);
428 : 48 : }
429 : :
430 : : /*
431 : : * Writeback is about to end against a page which has been marked for immediate
432 : : * reclaim. If it still appears to be reclaimable, move it to the tail of the
433 : : * inactive list.
434 : : */
435 : 0 : void rotate_reclaimable_page(struct page *page)
436 : : {
437 [ + - ][ + - ]: 58 : if (!PageLocked(page) && !PageDirty(page) && !PageActive(page) &&
[ + + ][ + - ]
438 [ + - ]: 57 : !PageUnevictable(page) && PageLRU(page)) {
439 : : struct pagevec *pvec;
440 : : unsigned long flags;
441 : :
442 : : page_cache_get(page);
443 : : local_irq_save(flags);
444 : 114 : pvec = &__get_cpu_var(lru_rotate_pvecs);
445 [ - + ]: 57 : if (!pagevec_add(pvec, page))
446 : 0 : pagevec_move_tail(pvec);
447 [ - + ]: 57 : local_irq_restore(flags);
448 : : }
449 : 58 : }
450 : :
451 : : static void update_page_reclaim_stat(struct lruvec *lruvec,
452 : : int file, int rotated)
453 : : {
454 : : struct zone_reclaim_stat *reclaim_stat = &lruvec->reclaim_stat;
455 : :
456 : 307 : reclaim_stat->recent_scanned[file]++;
457 [ + + ]: 20168773 : if (rotated)
458 : 19696741 : reclaim_stat->recent_rotated[file]++;
459 : : }
460 : :
461 : 0 : static void __activate_page(struct page *page, struct lruvec *lruvec,
462 : : void *arg)
463 : : {
464 [ + - ][ + + ]: 859139 : if (PageLRU(page) && !PageActive(page) && !PageUnevictable(page)) {
[ + - ]
465 : : int file = page_is_file_cache(page);
466 : 847970 : int lru = page_lru_base_type(page);
467 : :
468 : : del_page_from_lru_list(page, lruvec, lru);
469 : : SetPageActive(page);
470 : 847969 : lru += LRU_ACTIVE;
471 : 847969 : add_page_to_lru_list(page, lruvec, lru);
472 : 847969 : trace_mm_lru_activate(page, page_to_pfn(page));
473 : :
474 : : __count_vm_event(PGACTIVATE);
475 : : update_page_reclaim_stat(lruvec, file, 1);
476 : : }
477 : 859139 : }
478 : :
479 : : #ifdef CONFIG_SMP
480 : : static DEFINE_PER_CPU(struct pagevec, activate_page_pvecs);
481 : :
482 : 0 : static void activate_page_drain(int cpu)
483 : : {
484 : 3768001 : struct pagevec *pvec = &per_cpu(activate_page_pvecs, cpu);
485 : :
486 [ + + ]: 3768001 : if (pagevec_count(pvec))
487 : 42204 : pagevec_lru_move_fn(pvec, __activate_page, NULL);
488 : 0 : }
489 : :
490 : : static bool need_activate_page_drain(int cpu)
491 : : {
492 : 951 : return pagevec_count(&per_cpu(activate_page_pvecs, cpu)) != 0;
493 : : }
494 : :
495 : 0 : void activate_page(struct page *page)
496 : : {
497 [ + ][ + ][ + ]: 859123 : if (PageLRU(page) && !PageActive(page) && !PageUnevictable(page)) {
498 : 859129 : struct pagevec *pvec = &get_cpu_var(activate_page_pvecs);
499 : :
500 : : page_cache_get(page);
501 [ + + ]: 859129 : if (!pagevec_add(pvec, page))
502 : 51426 : pagevec_lru_move_fn(pvec, __activate_page, NULL);
503 : 859129 : put_cpu_var(activate_page_pvecs);
504 : : }
505 : 859124 : }
506 : :
507 : : #else
508 : : static inline void activate_page_drain(int cpu)
509 : : {
510 : : }
511 : :
512 : : static bool need_activate_page_drain(int cpu)
513 : : {
514 : : return false;
515 : : }
516 : :
517 : : void activate_page(struct page *page)
518 : : {
519 : : struct zone *zone = page_zone(page);
520 : :
521 : : spin_lock_irq(&zone->lru_lock);
522 : : __activate_page(page, mem_cgroup_page_lruvec(page, zone), NULL);
523 : : spin_unlock_irq(&zone->lru_lock);
524 : : }
525 : : #endif
526 : :
527 : 0 : static void __lru_cache_activate_page(struct page *page)
528 : : {
529 : 823325 : struct pagevec *pvec = &get_cpu_var(lru_add_pvec);
530 : : int i;
531 : :
532 : : /*
533 : : * Search backwards on the optimistic assumption that the page being
534 : : * activated has just been added to this pagevec. Note that only
535 : : * the local pagevec is examined as a !PageLRU page could be in the
536 : : * process of being released, reclaimed, migrated or on a remote
537 : : * pagevec that is currently being drained. Furthermore, marking
538 : : * a remote pagevec's page PageActive potentially hits a race where
539 : : * a page is marked PageActive just after it is added to the inactive
540 : : * list causing accounting errors and BUG_ON checks to trigger.
541 : : */
542 [ + + ]: 2563663 : for (i = pagevec_count(pvec) - 1; i >= 0; i--) {
543 : 2561478 : struct page *pagevec_page = pvec->pages[i];
544 : :
545 [ + + ]: 2561478 : if (pagevec_page == page) {
546 : : SetPageActive(page);
547 : : break;
548 : : }
549 : : }
550 : :
551 : 823370 : put_cpu_var(lru_add_pvec);
552 : 823356 : }
553 : :
554 : : /*
555 : : * Mark a page as having seen activity.
556 : : *
557 : : * inactive,unreferenced -> inactive,referenced
558 : : * inactive,referenced -> active,unreferenced
559 : : * active,unreferenced -> active,referenced
560 : : */
561 : 0 : void mark_page_accessed(struct page *page)
562 : : {
563 [ + + ][ + + ]: 55641218 : if (!PageActive(page) && !PageUnevictable(page) &&
[ + + ]
564 : : PageReferenced(page)) {
565 : :
566 : : /*
567 : : * If the page is on the LRU, queue it for activation via
568 : : * activate_page_pvecs. Otherwise, assume the page is on a
569 : : * pagevec, mark it active and it'll be moved to the active
570 : : * LRU on the next drain.
571 : : */
572 [ + + ]: 1682473 : if (PageLRU(page))
573 : 859127 : activate_page(page);
574 : : else
575 : 823346 : __lru_cache_activate_page(page);
576 : : ClearPageReferenced(page);
577 [ + + ]: 53958745 : } else if (!PageReferenced(page)) {
578 : : SetPageReferenced(page);
579 : : }
580 : 118 : }
581 : : EXPORT_SYMBOL(mark_page_accessed);
582 : :
583 : : /*
584 : : * Queue the page for addition to the LRU via pagevec. The decision on whether
585 : : * to add the page to the [in]active [file|anon] list is deferred until the
586 : : * pagevec is drained. This gives a chance for the caller of __lru_cache_add()
587 : : * have the page added to the active list using mark_page_accessed().
588 : : */
589 : 0 : void __lru_cache_add(struct page *page)
590 : : {
591 : 20157000 : struct pagevec *pvec = &get_cpu_var(lru_add_pvec);
592 : :
593 : : page_cache_get(page);
594 [ + + ]: 20158185 : if (!pagevec_space(pvec))
595 : : __pagevec_lru_add(pvec);
596 : : pagevec_add(pvec, page);
597 : 20158207 : put_cpu_var(lru_add_pvec);
598 : 20157736 : }
599 : : EXPORT_SYMBOL(__lru_cache_add);
600 : :
601 : : /**
602 : : * lru_cache_add - add a page to a page list
603 : : * @page: the page to be added to the LRU.
604 : : */
605 : 0 : void lru_cache_add(struct page *page)
606 : : {
607 : : VM_BUG_ON_PAGE(PageActive(page) && PageUnevictable(page), page);
608 : : VM_BUG_ON_PAGE(PageLRU(page), page);
609 : 18028263 : __lru_cache_add(page);
610 : 18028429 : }
611 : :
612 : : /**
613 : : * add_page_to_unevictable_list - add a page to the unevictable list
614 : : * @page: the page to be added to the unevictable list
615 : : *
616 : : * Add page directly to its zone's unevictable list. To avoid races with
617 : : * tasks that might be making the page evictable, through eg. munlock,
618 : : * munmap or exit, while it's not on the lru, we want to add the page
619 : : * while it's locked or otherwise "invisible" to other tasks. This is
620 : : * difficult to do when using the pagevec cache, so bypass that.
621 : : */
622 : 0 : void add_page_to_unevictable_list(struct page *page)
623 : : {
624 : 10059 : struct zone *zone = page_zone(page);
625 : : struct lruvec *lruvec;
626 : :
627 : : spin_lock_irq(&zone->lru_lock);
628 : : lruvec = mem_cgroup_page_lruvec(page, zone);
629 : : ClearPageActive(page);
630 : : SetPageUnevictable(page);
631 : : SetPageLRU(page);
632 : : add_page_to_lru_list(page, lruvec, LRU_UNEVICTABLE);
633 : : spin_unlock_irq(&zone->lru_lock);
634 : 10059 : }
635 : :
636 : : /*
637 : : * If the page can not be invalidated, it is moved to the
638 : : * inactive list to speed up its reclaim. It is moved to the
639 : : * head of the list, rather than the tail, to give the flusher
640 : : * threads some time to write it out, as this is much more
641 : : * effective than the single-page writeout from reclaim.
642 : : *
643 : : * If the page isn't page_mapped and dirty/writeback, the page
644 : : * could reclaim asap using PG_reclaim.
645 : : *
646 : : * 1. active, mapped page -> none
647 : : * 2. active, dirty/writeback page -> inactive, head, PG_reclaim
648 : : * 3. inactive, mapped page -> none
649 : : * 4. inactive, dirty/writeback page -> inactive, head, PG_reclaim
650 : : * 5. inactive, clean -> inactive, tail
651 : : * 6. Others -> none
652 : : *
653 : : * In 4, why it moves inactive's head, the VM expects the page would
654 : : * be write it out by flusher threads as this is much more effective
655 : : * than the single-page writeout from reclaim.
656 : : */
657 : 0 : static void lru_deactivate_fn(struct page *page, struct lruvec *lruvec,
658 : : void *arg)
659 : : {
660 : : int lru, file;
661 : : bool active;
662 : :
663 [ + + ]: 2354 : if (!PageLRU(page))
664 : : return;
665 : :
666 [ + - ]: 2335 : if (PageUnevictable(page))
667 : : return;
668 : :
669 : : /* Some processes are using the page */
670 [ + + ]: 2335 : if (page_mapped(page))
671 : : return;
672 : :
673 : 307 : active = PageActive(page);
674 : : file = page_is_file_cache(page);
675 : 307 : lru = page_lru_base_type(page);
676 : :
677 : 307 : del_page_from_lru_list(page, lruvec, lru + active);
678 : : ClearPageActive(page);
679 : : ClearPageReferenced(page);
680 : : add_page_to_lru_list(page, lruvec, lru);
681 : :
682 [ + - ][ + + ]: 307 : if (PageWriteback(page) || PageDirty(page)) {
683 : : /*
684 : : * PG_reclaim could be raced with end_page_writeback
685 : : * It can make readahead confusing. But race window
686 : : * is _really_ small and it's non-critical problem.
687 : : */
688 : : SetPageReclaim(page);
689 : : } else {
690 : : /*
691 : : * The page's writeback ends up during pagevec
692 : : * We moves tha page into tail of inactive.
693 : : */
694 : 198 : list_move_tail(&page->lru, &lruvec->lists[lru]);
695 : : __count_vm_event(PGROTATED);
696 : : }
697 : :
698 [ + + ]: 2661 : if (active)
699 : : __count_vm_event(PGDEACTIVATE);
700 : : update_page_reclaim_stat(lruvec, file, 0);
701 : : }
702 : :
703 : : /*
704 : : * Drain pages out of the cpu's pagevecs.
705 : : * Either "cpu" is the current CPU, and preemption has already been
706 : : * disabled; or "cpu" is being hot-unplugged, and is already dead.
707 : : */
708 : 0 : void lru_add_drain_cpu(int cpu)
709 : : {
710 : 11304262 : struct pagevec *pvec = &per_cpu(lru_add_pvec, cpu);
711 : :
712 [ + + ]: 3768316 : if (pagevec_count(pvec))
713 : : __pagevec_lru_add(pvec);
714 : :
715 : 3767973 : pvec = &per_cpu(lru_rotate_pvecs, cpu);
716 [ + + ]: 7536289 : if (pagevec_count(pvec)) {
717 : : unsigned long flags;
718 : :
719 : : /* No harm done if a racing interrupt already did this */
720 : : local_irq_save(flags);
721 : 48 : pagevec_move_tail(pvec);
722 [ - + ]: 48 : local_irq_restore(flags);
723 : : }
724 : :
725 : 3767973 : pvec = &per_cpu(lru_deactivate_pvecs, cpu);
726 [ + + ]: 3767973 : if (pagevec_count(pvec))
727 : 351 : pagevec_lru_move_fn(pvec, lru_deactivate_fn, NULL);
728 : :
729 : 3767973 : activate_page_drain(cpu);
730 : 3768459 : }
731 : :
732 : : /**
733 : : * deactivate_page - forcefully deactivate a page
734 : : * @page: page to deactivate
735 : : *
736 : : * This function hints the VM that @page is a good reclaim candidate,
737 : : * for example if its invalidation fails due to the page being dirty
738 : : * or under writeback.
739 : : */
740 : 0 : void deactivate_page(struct page *page)
741 : : {
742 : : /*
743 : : * In a workload with many unevictable page such as mprotect, unevictable
744 : : * page deactivation for accelerating reclaim is pointless.
745 : : */
746 [ + - ]: 2354 : if (PageUnevictable(page))
747 : 0 : return;
748 : :
749 [ + - ]: 2354 : if (likely(get_page_unless_zero(page))) {
750 : 2354 : struct pagevec *pvec = &get_cpu_var(lru_deactivate_pvecs);
751 : :
752 [ + + ]: 2354 : if (!pagevec_add(pvec, page))
753 : 80 : pagevec_lru_move_fn(pvec, lru_deactivate_fn, NULL);
754 : 2354 : put_cpu_var(lru_deactivate_pvecs);
755 : : }
756 : : }
757 : :
758 : 0 : void lru_add_drain(void)
759 : : {
760 : 3768285 : lru_add_drain_cpu(get_cpu());
761 : 3768365 : put_cpu();
762 : 3211809 : }
763 : :
764 : 0 : static void lru_add_drain_per_cpu(struct work_struct *dummy)
765 : : {
766 : : lru_add_drain();
767 : 65 : }
768 : :
769 : : static DEFINE_PER_CPU(struct work_struct, lru_add_drain_work);
770 : :
771 : 0 : void lru_add_drain_all(void)
772 : : {
773 : : static DEFINE_MUTEX(lock);
774 : : static struct cpumask has_work;
775 : : int cpu;
776 : :
777 : 203 : mutex_lock(&lock);
778 : 203 : get_online_cpus();
779 : : cpumask_clear(&has_work);
780 : :
781 [ + + ]: 1624 : for_each_online_cpu(cpu) {
782 : 1015 : struct work_struct *work = &per_cpu(lru_add_drain_work, cpu);
783 : :
784 [ + + ][ + - ]: 1015 : if (pagevec_count(&per_cpu(lru_add_pvec, cpu)) ||
785 [ + - ]: 951 : pagevec_count(&per_cpu(lru_rotate_pvecs, cpu)) ||
786 [ + + ]: 951 : pagevec_count(&per_cpu(lru_deactivate_pvecs, cpu)) ||
787 : : need_activate_page_drain(cpu)) {
788 : 130 : INIT_WORK(work, lru_add_drain_per_cpu);
789 : : schedule_work_on(cpu, work);
790 : : cpumask_set_cpu(cpu, &has_work);
791 : : }
792 : : }
793 : :
794 [ + + ]: 268 : for_each_cpu(cpu, &has_work)
795 : 65 : flush_work(&per_cpu(lru_add_drain_work, cpu));
796 : :
797 : 203 : put_online_cpus();
798 : 203 : mutex_unlock(&lock);
799 : 203 : }
800 : :
801 : : /*
802 : : * Batched page_cache_release(). Decrement the reference count on all the
803 : : * passed pages. If it fell to zero then remove the page from the LRU and
804 : : * free it.
805 : : *
806 : : * Avoid taking zone->lru_lock if possible, but if it is taken, retain it
807 : : * for the remainder of the operation.
808 : : *
809 : : * The locking in this function is against shrink_inactive_list(): we recheck
810 : : * the page count inside the lock to see whether shrink_inactive_list()
811 : : * grabbed the page via the LRU. If it did, give up: shrink_inactive_list()
812 : : * will free it.
813 : : */
814 : 0 : void release_pages(struct page **pages, int nr, int cold)
815 : : {
816 : : int i;
817 : 8067730 : LIST_HEAD(pages_to_free);
818 : : struct zone *zone = NULL;
819 : : struct lruvec *lruvec;
820 : : unsigned long uninitialized_var(flags);
821 : :
822 [ + + ]: 99637505 : for (i = 0; i < nr; i++) {
823 : 91568772 : struct page *page = pages[i];
824 : :
825 [ + + ]: 91568772 : if (unlikely(PageCompound(page))) {
826 [ - + ]: 9751 : if (zone) {
827 : : spin_unlock_irqrestore(&zone->lru_lock, flags);
828 : : zone = NULL;
829 : : }
830 : 9751 : put_compound_page(page);
831 : 0 : continue;
832 : : }
833 : :
834 [ + + ]: 91572880 : if (!put_page_testzero(page))
835 : 69045685 : continue;
836 : :
837 [ + + ]: 22527195 : if (PageLRU(page)) {
838 : 20036668 : struct zone *pagezone = page_zone(page);
839 : :
840 [ + + ]: 20036668 : if (pagezone != zone) {
841 [ + + ]: 4761275 : if (zone)
842 : : spin_unlock_irqrestore(&zone->lru_lock,
843 : : flags);
844 : : zone = pagezone;
845 : 4761274 : spin_lock_irqsave(&zone->lru_lock, flags);
846 : : }
847 : :
848 : : lruvec = mem_cgroup_page_lruvec(page, zone);
849 : : VM_BUG_ON_PAGE(!PageLRU(page), page);
850 : : __ClearPageLRU(page);
851 : : del_page_from_lru_list(page, lruvec, page_off_lru(page));
852 : : }
853 : :
854 : : /* Clear Active bit in case of parallel mark_page_accessed */
855 : : ClearPageActive(page);
856 : :
857 : 22529463 : list_add(&page->lru, &pages_to_free);
858 : : }
859 [ + + ]: 8068733 : if (zone)
860 : : spin_unlock_irqrestore(&zone->lru_lock, flags);
861 : :
862 : 8068745 : free_hot_cold_page_list(&pages_to_free, cold);
863 : 8068389 : }
864 : : EXPORT_SYMBOL(release_pages);
865 : :
866 : : /*
867 : : * The pages which we're about to release may be in the deferred lru-addition
868 : : * queues. That would prevent them from really being freed right now. That's
869 : : * OK from a correctness point of view but is inefficient - those pages may be
870 : : * cache-warm and we want to give them back to the page allocator ASAP.
871 : : *
872 : : * So __pagevec_release() will drain those queues here. __pagevec_lru_add()
873 : : * and __pagevec_lru_add_active() call release_pages() directly to avoid
874 : : * mutual recursion.
875 : : */
876 : 0 : void __pagevec_release(struct pagevec *pvec)
877 : : {
878 : : lru_add_drain();
879 : 556496 : release_pages(pvec->pages, pagevec_count(pvec), pvec->cold);
880 : : pagevec_reinit(pvec);
881 : 556140 : }
882 : : EXPORT_SYMBOL(__pagevec_release);
883 : :
884 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
885 : : /* used by __split_huge_page_refcount() */
886 : : void lru_add_page_tail(struct page *page, struct page *page_tail,
887 : : struct lruvec *lruvec, struct list_head *list)
888 : : {
889 : : const int file = 0;
890 : :
891 : : VM_BUG_ON_PAGE(!PageHead(page), page);
892 : : VM_BUG_ON_PAGE(PageCompound(page_tail), page);
893 : : VM_BUG_ON_PAGE(PageLRU(page_tail), page);
894 : : VM_BUG_ON(NR_CPUS != 1 &&
895 : : !spin_is_locked(&lruvec_zone(lruvec)->lru_lock));
896 : :
897 : : if (!list)
898 : : SetPageLRU(page_tail);
899 : :
900 : : if (likely(PageLRU(page)))
901 : : list_add_tail(&page_tail->lru, &page->lru);
902 : : else if (list) {
903 : : /* page reclaim is reclaiming a huge page */
904 : : get_page(page_tail);
905 : : list_add_tail(&page_tail->lru, list);
906 : : } else {
907 : : struct list_head *list_head;
908 : : /*
909 : : * Head page has not yet been counted, as an hpage,
910 : : * so we must account for each subpage individually.
911 : : *
912 : : * Use the standard add function to put page_tail on the list,
913 : : * but then correct its position so they all end up in order.
914 : : */
915 : : add_page_to_lru_list(page_tail, lruvec, page_lru(page_tail));
916 : : list_head = page_tail->lru.prev;
917 : : list_move_tail(&page_tail->lru, list_head);
918 : : }
919 : :
920 : : if (!PageUnevictable(page))
921 : : update_page_reclaim_stat(lruvec, file, PageActive(page_tail));
922 : : }
923 : : #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
924 : :
925 : 0 : static void __pagevec_lru_add_fn(struct page *page, struct lruvec *lruvec,
926 : : void *arg)
927 : : {
928 : : int file = page_is_file_cache(page);
929 : : int active = PageActive(page);
930 : : enum lru_list lru = page_lru(page);
931 : :
932 : : VM_BUG_ON_PAGE(PageLRU(page), page);
933 : :
934 : : SetPageLRU(page);
935 : : add_page_to_lru_list(page, lruvec, lru);
936 : : update_page_reclaim_stat(lruvec, file, active);
937 [ + + ][ + + ]: 20168773 : trace_mm_lru_insertion(page, page_to_pfn(page), lru, trace_pagemap_flags(page));
[ + ][ + + ]
[ + + ][ + ]
938 : 7 : }
939 : :
940 : : /*
941 : : * Add the passed pages to the LRU, then drop the caller's refcount
942 : : * on them. Reinitialises the caller's pagevec.
943 : : */
944 : 0 : void __pagevec_lru_add(struct pagevec *pvec)
945 : : {
946 : 2457035 : pagevec_lru_move_fn(pvec, __pagevec_lru_add_fn, NULL);
947 : 1031 : }
948 : : EXPORT_SYMBOL(__pagevec_lru_add);
949 : :
950 : : /**
951 : : * pagevec_lookup - gang pagecache lookup
952 : : * @pvec: Where the resulting pages are placed
953 : : * @mapping: The address_space to search
954 : : * @start: The starting page index
955 : : * @nr_pages: The maximum number of pages
956 : : *
957 : : * pagevec_lookup() will search for and return a group of up to @nr_pages pages
958 : : * in the mapping. The pages are placed in @pvec. pagevec_lookup() takes a
959 : : * reference against the pages in @pvec.
960 : : *
961 : : * The search returns a group of mapping-contiguous pages with ascending
962 : : * indexes. There may be holes in the indices due to not-present pages.
963 : : *
964 : : * pagevec_lookup() returns the number of pages which were found.
965 : : */
966 : 0 : unsigned pagevec_lookup(struct pagevec *pvec, struct address_space *mapping,
967 : : pgoff_t start, unsigned nr_pages)
968 : : {
969 : 456255 : pvec->nr = find_get_pages(mapping, start, nr_pages, pvec->pages);
970 : 456264 : return pagevec_count(pvec);
971 : : }
972 : : EXPORT_SYMBOL(pagevec_lookup);
973 : :
974 : 0 : unsigned pagevec_lookup_tag(struct pagevec *pvec, struct address_space *mapping,
975 : : pgoff_t *index, int tag, unsigned nr_pages)
976 : : {
977 : 2115933 : pvec->nr = find_get_pages_tag(mapping, index, tag,
978 : 2115933 : nr_pages, pvec->pages);
979 : 2096017 : return pagevec_count(pvec);
980 : : }
981 : : EXPORT_SYMBOL(pagevec_lookup_tag);
982 : :
983 : : /*
984 : : * Perform any setup for the swap system
985 : : */
986 : 0 : void __init swap_setup(void)
987 : : {
988 : 0 : unsigned long megs = totalram_pages >> (20 - PAGE_SHIFT);
989 : : #ifdef CONFIG_SWAP
990 : : int i;
991 : :
992 [ # # ]: 0 : if (bdi_init(swapper_spaces[0].backing_dev_info))
993 : 0 : panic("Failed to init swap bdi");
994 [ # # ]: 0 : for (i = 0; i < MAX_SWAPFILES; i++) {
995 : 0 : spin_lock_init(&swapper_spaces[i].tree_lock);
996 : 0 : INIT_LIST_HEAD(&swapper_spaces[i].i_mmap_nonlinear);
997 : : }
998 : : #endif
999 : :
1000 : : /* Use a smaller cluster for small-memory machines */
1001 [ # # ]: 0 : if (megs < 16)
1002 : 0 : page_cluster = 2;
1003 : : else
1004 : 0 : page_cluster = 3;
1005 : : /*
1006 : : * Right now other parts of the system means that we
1007 : : * _really_ don't want to cluster much more
1008 : : */
1009 : 0 : }
|
