Branch data Line data Source code
1 : : /*
2 : : * linux/mm/madvise.c
3 : : *
4 : : * Copyright (C) 1999 Linus Torvalds
5 : : * Copyright (C) 2002 Christoph Hellwig
6 : : */
7 : :
8 : : #include <linux/mman.h>
9 : : #include <linux/pagemap.h>
10 : : #include <linux/syscalls.h>
11 : : #include <linux/mempolicy.h>
12 : : #include <linux/page-isolation.h>
13 : : #include <linux/hugetlb.h>
14 : : #include <linux/falloc.h>
15 : : #include <linux/sched.h>
16 : : #include <linux/ksm.h>
17 : : #include <linux/fs.h>
18 : : #include <linux/file.h>
19 : : #include <linux/blkdev.h>
20 : : #include <linux/swap.h>
21 : : #include <linux/swapops.h>
22 : :
23 : : /*
24 : : * Any behaviour which results in changes to the vma->vm_flags needs to
25 : : * take mmap_sem for writing. Others, which simply traverse vmas, need
26 : : * to only take it for reading.
27 : : */
28 [ + + ][ - + ]: 2642 : static int madvise_need_mmap_write(int behavior)
29 : : {
30 : : switch (behavior) {
31 : : case MADV_REMOVE:
32 : : case MADV_WILLNEED:
33 : : case MADV_DONTNEED:
34 : : return 0;
35 : : default:
36 : : /* be safe, default to 1. list exceptions explicitly */
37 : 18 : return 1;
38 : : }
39 : : }
40 : :
41 : : /*
42 : : * We can potentially split a vm area into separate
43 : : * areas, each area with its own behavior.
44 : : */
45 : 0 : static long madvise_behavior(struct vm_area_struct *vma,
46 : : struct vm_area_struct **prev,
47 : : unsigned long start, unsigned long end, int behavior)
48 : : {
49 : 18 : struct mm_struct *mm = vma->vm_mm;
50 : : int error = 0;
51 : : pgoff_t pgoff;
52 : 18 : unsigned long new_flags = vma->vm_flags;
53 : :
54 [ + + + + : 18 : switch (behavior) {
+ + + -
- ]
55 : : case MADV_NORMAL:
56 : 2 : new_flags = new_flags & ~VM_RAND_READ & ~VM_SEQ_READ;
57 : 2 : break;
58 : : case MADV_SEQUENTIAL:
59 : 1 : new_flags = (new_flags & ~VM_RAND_READ) | VM_SEQ_READ;
60 : 1 : break;
61 : : case MADV_RANDOM:
62 : 1 : new_flags = (new_flags & ~VM_SEQ_READ) | VM_RAND_READ;
63 : 1 : break;
64 : : case MADV_DONTFORK:
65 : 1 : new_flags |= VM_DONTCOPY;
66 : 1 : break;
67 : : case MADV_DOFORK:
68 [ + - ]: 11 : if (vma->vm_flags & VM_IO) {
69 : : error = -EINVAL;
70 : : goto out;
71 : : }
72 : 11 : new_flags &= ~VM_DONTCOPY;
73 : 11 : break;
74 : : case MADV_DONTDUMP:
75 : 1 : new_flags |= VM_DONTDUMP;
76 : 1 : break;
77 : : case MADV_DODUMP:
78 [ + - ]: 1 : if (new_flags & VM_SPECIAL) {
79 : : error = -EINVAL;
80 : : goto out;
81 : : }
82 : 1 : new_flags &= ~VM_DONTDUMP;
83 : 1 : break;
84 : : case MADV_MERGEABLE:
85 : : case MADV_UNMERGEABLE:
86 : : error = ksm_madvise(vma, start, end, behavior, &new_flags);
87 : : if (error)
88 : : goto out;
89 : : break;
90 : : case MADV_HUGEPAGE:
91 : : case MADV_NOHUGEPAGE:
92 : : error = hugepage_madvise(vma, &new_flags, behavior);
93 : : if (error)
94 : : goto out;
95 : : break;
96 : : }
97 : :
98 [ + + ]: 18 : if (new_flags == vma->vm_flags) {
99 : 12 : *prev = vma;
100 : 12 : goto out;
101 : : }
102 : :
103 : 6 : pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
104 : 6 : *prev = vma_merge(mm, *prev, start, end, new_flags, vma->anon_vma,
105 : : vma->vm_file, pgoff, vma_policy(vma),
106 : : vma_get_anon_name(vma));
107 [ + + ]: 6 : if (*prev) {
108 : : vma = *prev;
109 : : goto success;
110 : : }
111 : :
112 : 5 : *prev = vma;
113 : :
114 [ - + ]: 5 : if (start != vma->vm_start) {
115 : 0 : error = split_vma(mm, vma, start, 1);
116 [ # # ]: 0 : if (error)
117 : : goto out;
118 : : }
119 : :
120 [ + + ]: 5 : if (end != vma->vm_end) {
121 : 1 : error = split_vma(mm, vma, end, 0);
122 [ + - ]: 1 : if (error)
123 : : goto out;
124 : : }
125 : :
126 : : success:
127 : : /*
128 : : * vm_flags is protected by the mmap_sem held in write mode.
129 : : */
130 : 6 : vma->vm_flags = new_flags;
131 : :
132 : : out:
133 [ - - ]: 18 : if (error == -ENOMEM)
134 : : error = -EAGAIN;
135 : 0 : return error;
136 : : }
137 : :
138 : : #ifdef CONFIG_SWAP
139 : 0 : static int swapin_walk_pmd_entry(pmd_t *pmd, unsigned long start,
140 : : unsigned long end, struct mm_walk *walk)
141 : : {
142 : : pte_t *orig_pte;
143 : 1 : struct vm_area_struct *vma = walk->private;
144 : : unsigned long index;
145 : :
146 [ + - ]: 1 : if (pmd_none_or_trans_huge_or_clear_bad(pmd))
147 : : return 0;
148 : :
149 [ + + ]: 6 : for (index = start; index != end; index += PAGE_SIZE) {
150 : : pte_t pte;
151 : : swp_entry_t entry;
152 : : struct page *page;
153 : : spinlock_t *ptl;
154 : :
155 : 5 : orig_pte = pte_offset_map_lock(vma->vm_mm, pmd, start, &ptl);
156 : 5 : pte = *(orig_pte + ((index - start) / PAGE_SIZE));
157 : 5 : pte_unmap_unlock(orig_pte, ptl);
158 : :
159 [ + + ][ - + ]: 6 : if (pte_present(pte) || pte_none(pte) || pte_file(pte))
[ # # ]
160 : 5 : continue;
161 : : entry = pte_to_swp_entry(pte);
162 [ # # ]: 0 : if (unlikely(non_swap_entry(entry)))
163 : 0 : continue;
164 : :
165 : 0 : page = read_swap_cache_async(entry, GFP_HIGHUSER_MOVABLE,
166 : : vma, index);
167 [ # # ]: 0 : if (page)
168 : 0 : page_cache_release(page);
169 : : }
170 : :
171 : : return 0;
172 : : }
173 : :
174 : 0 : static void force_swapin_readahead(struct vm_area_struct *vma,
175 : : unsigned long start, unsigned long end)
176 : : {
177 : 2 : struct mm_walk walk = {
178 : 1 : .mm = vma->vm_mm,
179 : : .pmd_entry = swapin_walk_pmd_entry,
180 : : .private = vma,
181 : : };
182 : :
183 : 1 : walk_page_range(start, end, &walk);
184 : :
185 : 1 : lru_add_drain(); /* Push any new pages onto the LRU now */
186 : 1 : }
187 : :
188 : 0 : static void force_shm_swapin_readahead(struct vm_area_struct *vma,
189 : : unsigned long start, unsigned long end,
190 : : struct address_space *mapping)
191 : : {
192 : : pgoff_t index;
193 : : struct page *page;
194 : : swp_entry_t swap;
195 : :
196 [ # # ]: 0 : for (; start < end; start += PAGE_SIZE) {
197 : 0 : index = ((start - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
198 : :
199 : 0 : page = find_get_page(mapping, index);
200 [ # # ]: 0 : if (!radix_tree_exceptional_entry(page)) {
201 [ # # ]: 0 : if (page)
202 : 0 : page_cache_release(page);
203 : 0 : continue;
204 : : }
205 : : swap = radix_to_swp_entry(page);
206 : 0 : page = read_swap_cache_async(swap, GFP_HIGHUSER_MOVABLE,
207 : : NULL, 0);
208 [ # # ]: 0 : if (page)
209 : 0 : page_cache_release(page);
210 : : }
211 : :
212 : 0 : lru_add_drain(); /* Push any new pages onto the LRU now */
213 : 0 : }
214 : : #endif /* CONFIG_SWAP */
215 : :
216 : : /*
217 : : * Schedule all required I/O operations. Do not wait for completion.
218 : : */
219 : 0 : static long madvise_willneed(struct vm_area_struct *vma,
220 : : struct vm_area_struct **prev,
221 : : unsigned long start, unsigned long end)
222 : : {
223 : 2 : struct file *file = vma->vm_file;
224 : :
225 : : #ifdef CONFIG_SWAP
226 [ + + ][ - + ]: 2 : if (!file || mapping_cap_swap_backed(file->f_mapping)) {
227 : 1 : *prev = vma;
228 [ + - ]: 1 : if (!file)
229 : 1 : force_swapin_readahead(vma, start, end);
230 : : else
231 : 0 : force_shm_swapin_readahead(vma, start, end,
232 : : file->f_mapping);
233 : : return 0;
234 : : }
235 : : #endif
236 : :
237 [ + - ]: 1 : if (!file)
238 : : return -EBADF;
239 : :
240 [ + - ]: 1 : if (file->f_mapping->a_ops->get_xip_mem) {
241 : : /* no bad return value, but ignore advice */
242 : : return 0;
243 : : }
244 : :
245 : 1 : *prev = vma;
246 : 1 : start = ((start - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
247 [ - + ]: 1 : if (end > vma->vm_end)
248 : : end = vma->vm_end;
249 : 1 : end = ((end - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
250 : :
251 : 1 : force_page_cache_readahead(file->f_mapping, file, start, end - start);
252 : 1 : return 0;
253 : : }
254 : :
255 : : /*
256 : : * Application no longer needs these pages. If the pages are dirty,
257 : : * it's OK to just throw them away. The app will be more careful about
258 : : * data it wants to keep. Be sure to free swap resources too. The
259 : : * zap_page_range call sets things up for shrink_active_list to actually free
260 : : * these pages later if no one else has touched them in the meantime,
261 : : * although we could add these pages to a global reuse list for
262 : : * shrink_active_list to pick up before reclaiming other pages.
263 : : *
264 : : * NB: This interface discards data rather than pushes it out to swap,
265 : : * as some implementations do. This has performance implications for
266 : : * applications like large transactional databases which want to discard
267 : : * pages in anonymous maps after committing to backing store the data
268 : : * that was kept in them. There is no reason to write this data out to
269 : : * the swap area if the application is discarding it.
270 : : *
271 : : * An interface that causes the system to free clean pages and flush
272 : : * dirty pages is already available as msync(MS_INVALIDATE).
273 : : */
274 : 0 : static long madvise_dontneed(struct vm_area_struct *vma,
275 : : struct vm_area_struct **prev,
276 : : unsigned long start, unsigned long end)
277 : : {
278 : 4875 : *prev = vma;
279 [ + + ]: 4875 : if (vma->vm_flags & (VM_LOCKED|VM_HUGETLB|VM_PFNMAP))
280 : : return -EINVAL;
281 : :
282 [ - + ]: 4874 : if (unlikely(vma->vm_flags & VM_NONLINEAR)) {
283 : 0 : struct zap_details details = {
284 : : .nonlinear_vma = vma,
285 : : .last_index = ULONG_MAX,
286 : : };
287 : 0 : zap_page_range(vma, start, end - start, &details);
288 : : } else
289 : 4874 : zap_page_range(vma, start, end - start, NULL);
290 : : return 0;
291 : : }
292 : :
293 : : /*
294 : : * Application wants to free up the pages and associated backing store.
295 : : * This is effectively punching a hole into the middle of a file.
296 : : *
297 : : * NOTE: Currently, only shmfs/tmpfs is supported for this operation.
298 : : * Other filesystems return -ENOSYS.
299 : : */
300 : 0 : static long madvise_remove(struct vm_area_struct *vma,
301 : : struct vm_area_struct **prev,
302 : : unsigned long start, unsigned long end)
303 : : {
304 : : loff_t offset;
305 : : int error;
306 : : struct file *f;
307 : :
308 : 1 : *prev = NULL; /* tell sys_madvise we drop mmap_sem */
309 : :
310 [ + - ]: 1 : if (vma->vm_flags & (VM_LOCKED|VM_NONLINEAR|VM_HUGETLB))
311 : : return -EINVAL;
312 : :
313 : 1 : f = vma->vm_file;
314 : :
315 [ + - ][ + - ]: 1 : if (!f || !f->f_mapping || !f->f_mapping->host) {
[ + - ]
316 : : return -EINVAL;
317 : : }
318 : :
319 [ + - ]: 1 : if ((vma->vm_flags & (VM_SHARED|VM_WRITE)) != (VM_SHARED|VM_WRITE))
320 : : return -EACCES;
321 : :
322 : 2 : offset = (loff_t)(start - vma->vm_start)
323 : 1 : + ((loff_t)vma->vm_pgoff << PAGE_SHIFT);
324 : :
325 : : /*
326 : : * Filesystem's fallocate may need to take i_mutex. We need to
327 : : * explicitly grab a reference because the vma (and hence the
328 : : * vma's reference to the file) can go away as soon as we drop
329 : : * mmap_sem.
330 : : */
331 : : get_file(f);
332 : 1 : up_read(¤t->mm->mmap_sem);
333 : 1 : error = do_fallocate(f,
334 : : FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
335 : 1 : offset, end - start);
336 : 1 : fput(f);
337 : 1 : down_read(¤t->mm->mmap_sem);
338 : 1 : return error;
339 : : }
340 : :
341 : : #ifdef CONFIG_MEMORY_FAILURE
342 : : /*
343 : : * Error injection support for memory error handling.
344 : : */
345 : : static int madvise_hwpoison(int bhv, unsigned long start, unsigned long end)
346 : : {
347 : : struct page *p;
348 : : if (!capable(CAP_SYS_ADMIN))
349 : : return -EPERM;
350 : : for (; start < end; start += PAGE_SIZE <<
351 : : compound_order(compound_head(p))) {
352 : : int ret;
353 : :
354 : : ret = get_user_pages_fast(start, 1, 0, &p);
355 : : if (ret != 1)
356 : : return ret;
357 : :
358 : : if (PageHWPoison(p)) {
359 : : put_page(p);
360 : : continue;
361 : : }
362 : : if (bhv == MADV_SOFT_OFFLINE) {
363 : : pr_info("Soft offlining page %#lx at %#lx\n",
364 : : page_to_pfn(p), start);
365 : : ret = soft_offline_page(p, MF_COUNT_INCREASED);
366 : : if (ret)
367 : : return ret;
368 : : continue;
369 : : }
370 : : pr_info("Injecting memory failure for page %#lx at %#lx\n",
371 : : page_to_pfn(p), start);
372 : : /* Ignore return value for now */
373 : : memory_failure(page_to_pfn(p), 0, MF_COUNT_INCREASED);
374 : : }
375 : : return 0;
376 : : }
377 : : #endif
378 : :
379 : : static long
380 : 0 : madvise_vma(struct vm_area_struct *vma, struct vm_area_struct **prev,
381 : : unsigned long start, unsigned long end, int behavior)
382 : : {
383 [ + + + + ]: 4896 : switch (behavior) {
384 : : case MADV_REMOVE:
385 : 1 : return madvise_remove(vma, prev, start, end);
386 : : case MADV_WILLNEED:
387 : 2 : return madvise_willneed(vma, prev, start, end);
388 : : case MADV_DONTNEED:
389 : 4875 : return madvise_dontneed(vma, prev, start, end);
390 : : default:
391 : 18 : return madvise_behavior(vma, prev, start, end, behavior);
392 : : }
393 : : }
394 : :
395 : : static int
396 [ + + ][ - + ]: 2645 : madvise_behavior_valid(int behavior)
397 : : {
398 : : switch (behavior) {
399 : : case MADV_DOFORK:
400 : : case MADV_DONTFORK:
401 : : case MADV_NORMAL:
402 : : case MADV_SEQUENTIAL:
403 : : case MADV_RANDOM:
404 : : case MADV_REMOVE:
405 : : case MADV_WILLNEED:
406 : : case MADV_DONTNEED:
407 : : #ifdef CONFIG_KSM
408 : : case MADV_MERGEABLE:
409 : : case MADV_UNMERGEABLE:
410 : : #endif
411 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
412 : : case MADV_HUGEPAGE:
413 : : case MADV_NOHUGEPAGE:
414 : : #endif
415 : : case MADV_DONTDUMP:
416 : : case MADV_DODUMP:
417 : : return 1;
418 : :
419 : : default:
420 : 1 : return 0;
421 : : }
422 : : }
423 : :
424 : : /*
425 : : * The madvise(2) system call.
426 : : *
427 : : * Applications can use madvise() to advise the kernel how it should
428 : : * handle paging I/O in this VM area. The idea is to help the kernel
429 : : * use appropriate read-ahead and caching techniques. The information
430 : : * provided is advisory only, and can be safely disregarded by the
431 : : * kernel without affecting the correct operation of the application.
432 : : *
433 : : * behavior values:
434 : : * MADV_NORMAL - the default behavior is to read clusters. This
435 : : * results in some read-ahead and read-behind.
436 : : * MADV_RANDOM - the system should read the minimum amount of data
437 : : * on any access, since it is unlikely that the appli-
438 : : * cation will need more than what it asks for.
439 : : * MADV_SEQUENTIAL - pages in the given range will probably be accessed
440 : : * once, so they can be aggressively read ahead, and
441 : : * can be freed soon after they are accessed.
442 : : * MADV_WILLNEED - the application is notifying the system to read
443 : : * some pages ahead.
444 : : * MADV_DONTNEED - the application is finished with the given range,
445 : : * so the kernel can free resources associated with it.
446 : : * MADV_REMOVE - the application wants to free up the given range of
447 : : * pages and associated backing store.
448 : : * MADV_DONTFORK - omit this area from child's address space when forking:
449 : : * typically, to avoid COWing pages pinned by get_user_pages().
450 : : * MADV_DOFORK - cancel MADV_DONTFORK: no longer omit this area when forking.
451 : : * MADV_MERGEABLE - the application recommends that KSM try to merge pages in
452 : : * this area with pages of identical content from other such areas.
453 : : * MADV_UNMERGEABLE- cancel MADV_MERGEABLE: no longer merge pages with others.
454 : : *
455 : : * return values:
456 : : * zero - success
457 : : * -EINVAL - start + len < 0, start is not page-aligned,
458 : : * "behavior" is not a valid value, or application
459 : : * is attempting to release locked or shared pages.
460 : : * -ENOMEM - addresses in the specified range are not currently
461 : : * mapped, or are outside the AS of the process.
462 : : * -EIO - an I/O error occurred while paging in data.
463 : : * -EBADF - map exists, but area maps something that isn't a file.
464 : : * -EAGAIN - a kernel resource was temporarily unavailable.
465 : : */
466 : 0 : SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior)
467 : : {
468 : : unsigned long end, tmp;
469 : : struct vm_area_struct *vma, *prev;
470 : : int unmapped_error = 0;
471 : : int error = -EINVAL;
472 : : int write;
473 : : size_t len;
474 : : struct blk_plug plug;
475 : :
476 : : #ifdef CONFIG_MEMORY_FAILURE
477 : : if (behavior == MADV_HWPOISON || behavior == MADV_SOFT_OFFLINE)
478 : : return madvise_hwpoison(behavior, start, start+len_in);
479 : : #endif
480 [ + + ]: 2645 : if (!madvise_behavior_valid(behavior))
481 : : return error;
482 : :
483 [ + + ]: 2644 : if (start & ~PAGE_MASK)
484 : : return error;
485 : 2643 : len = (len_in + ~PAGE_MASK) & PAGE_MASK;
486 : :
487 : : /* Check to see whether len was rounded up from small -ve to zero */
488 [ + - ]: 2643 : if (len_in && !len)
489 : : return error;
490 : :
491 : 2643 : end = start + len;
492 [ + - ]: 2643 : if (end < start)
493 : : return error;
494 : :
495 : : error = 0;
496 [ + + ]: 2643 : if (end == start)
497 : : return error;
498 : :
499 : 2642 : write = madvise_need_mmap_write(behavior);
500 [ + + ]: 2642 : if (write)
501 : 18 : down_write(¤t->mm->mmap_sem);
502 : : else
503 : 2624 : down_read(¤t->mm->mmap_sem);
504 : :
505 : : /*
506 : : * If the interval [start,end) covers some unmapped address
507 : : * ranges, just ignore them, but return -ENOMEM at the end.
508 : : * - different from the way of handling in mlock etc.
509 : : */
510 : 2643 : vma = find_vma_prev(current->mm, start, &prev);
511 [ + - ][ + + ]: 2643 : if (vma && start > vma->vm_start)
512 : 365 : prev = vma;
513 : :
514 : 4898 : blk_start_plug(&plug);
515 : : for (;;) {
516 : : /* Still start < end. */
517 : : error = -ENOMEM;
518 [ + - ]: 4898 : if (!vma)
519 : : goto out;
520 : :
521 : : /* Here start < (end|vma->vm_end). */
522 [ + + ]: 4898 : if (start < vma->vm_start) {
523 : : unmapped_error = -ENOMEM;
524 : : start = vma->vm_start;
525 [ + ]: 1 : if (start >= end)
526 : : goto out;
527 : : }
528 : :
529 : : /* Here vma->vm_start <= start < (end|vma->vm_end) */
530 : 4896 : tmp = vma->vm_end;
531 [ + + ]: 4896 : if (end < tmp)
532 : : tmp = end;
533 : :
534 : : /* Here vma->vm_start <= start < tmp <= (end|vma->vm_end). */
535 : 4896 : error = madvise_vma(vma, &prev, start, tmp, behavior);
536 [ + + ]: 4896 : if (error)
537 : : goto out;
538 : : start = tmp;
539 [ + + ][ + + ]: 4895 : if (prev && start < prev->vm_end)
540 : : start = prev->vm_end;
541 : : error = unmapped_error;
542 [ + + ]: 4895 : if (start >= end)
543 : : goto out;
544 [ + - ]: 2255 : if (prev)
545 : 2255 : vma = prev->vm_next;
546 : : else /* madvise_remove dropped mmap_sem */
547 : 0 : vma = find_vma(current->mm, start);
548 : : }
549 : : out:
550 : 2643 : blk_finish_plug(&plug);
551 [ + + ]: 2642 : if (write)
552 : 18 : up_write(¤t->mm->mmap_sem);
553 : : else
554 : 2624 : up_read(¤t->mm->mmap_sem);
555 : :
556 : : return error;
557 : : }
|
