4 * (C) Copyright 1995 Linus Torvalds
5 * (C) Copyright 2002 Christoph Hellwig
8 #include <linux/capability.h>
9 #include <linux/mman.h>
11 #include <linux/swap.h>
12 #include <linux/swapops.h>
13 #include <linux/pagemap.h>
14 #include <linux/mempolicy.h>
15 #include <linux/syscalls.h>
16 #include <linux/sched.h>
17 #include <linux/module.h>
18 #include <linux/rmap.h>
19 #include <linux/mmzone.h>
20 #include <linux/hugetlb.h>
24 int can_do_mlock(void)
26 if (capable(CAP_IPC_LOCK
))
28 if (current
->signal
->rlim
[RLIMIT_MEMLOCK
].rlim_cur
!= 0)
32 EXPORT_SYMBOL(can_do_mlock
);
35 * Mlocked pages are marked with PageMlocked() flag for efficient testing
36 * in vmscan and, possibly, the fault path; and to support semi-accurate
39 * An mlocked page [PageMlocked(page)] is unevictable. As such, it will
40 * be placed on the LRU "unevictable" list, rather than the [in]active lists.
41 * The unevictable list is an LRU sibling list to the [in]active lists.
42 * PageUnevictable is set to indicate the unevictable state.
44 * When lazy mlocking via vmscan, it is important to ensure that the
45 * vma's VM_LOCKED status is not concurrently being modified, otherwise we
46 * may have mlocked a page that is being munlocked. So lazy mlock must take
47 * the mmap_sem for read, and verify that the vma really is locked
52 * LRU accounting for clear_page_mlock()
54 void __clear_page_mlock(struct page
*page
)
56 VM_BUG_ON(!PageLocked(page
));
58 if (!page
->mapping
) { /* truncated ? */
62 dec_zone_page_state(page
, NR_MLOCK
);
63 count_vm_event(UNEVICTABLE_PGCLEARED
);
64 if (!isolate_lru_page(page
)) {
65 putback_lru_page(page
);
68 * We lost the race. the page already moved to evictable list.
70 if (PageUnevictable(page
))
71 count_vm_event(UNEVICTABLE_PGSTRANDED
);
76 * Mark page as mlocked if not already.
77 * If page on LRU, isolate and putback to move to unevictable list.
79 void mlock_vma_page(struct page
*page
)
81 BUG_ON(!PageLocked(page
));
83 if (!TestSetPageMlocked(page
)) {
84 inc_zone_page_state(page
, NR_MLOCK
);
85 count_vm_event(UNEVICTABLE_PGMLOCKED
);
86 if (!isolate_lru_page(page
))
87 putback_lru_page(page
);
92 * called from munlock()/munmap() path with page supposedly on the LRU.
94 * Note: unlike mlock_vma_page(), we can't just clear the PageMlocked
95 * [in try_to_munlock()] and then attempt to isolate the page. We must
96 * isolate the page to keep others from messing with its unevictable
97 * and mlocked state while trying to munlock. However, we pre-clear the
98 * mlocked state anyway as we might lose the isolation race and we might
99 * not get another chance to clear PageMlocked. If we successfully
100 * isolate the page and try_to_munlock() detects other VM_LOCKED vmas
101 * mapping the page, it will restore the PageMlocked state, unless the page
102 * is mapped in a non-linear vma. So, we go ahead and ClearPageMlocked(),
103 * perhaps redundantly.
104 * If we lose the isolation race, and the page is mapped by other VM_LOCKED
105 * vmas, we'll detect this in vmscan--via try_to_munlock() or try_to_unmap()
106 * either of which will restore the PageMlocked state by calling
107 * mlock_vma_page() above, if it can grab the vma's mmap sem.
109 void munlock_vma_page(struct page
*page
)
111 BUG_ON(!PageLocked(page
));
113 if (TestClearPageMlocked(page
)) {
114 dec_zone_page_state(page
, NR_MLOCK
);
115 if (!isolate_lru_page(page
)) {
116 int ret
= try_to_munlock(page
);
118 * did try_to_unlock() succeed or punt?
120 if (ret
== SWAP_SUCCESS
|| ret
== SWAP_AGAIN
)
121 count_vm_event(UNEVICTABLE_PGMUNLOCKED
);
123 putback_lru_page(page
);
126 * We lost the race. let try_to_unmap() deal
127 * with it. At least we get the page state and
128 * mlock stats right. However, page is still on
129 * the noreclaim list. We'll fix that up when
130 * the page is eventually freed or we scan the
133 if (PageUnevictable(page
))
134 count_vm_event(UNEVICTABLE_PGSTRANDED
);
136 count_vm_event(UNEVICTABLE_PGMUNLOCKED
);
141 /* Is the vma a continuation of the stack vma above it? */
142 static inline int vma_stack_continue(struct vm_area_struct
*vma
, unsigned long addr
)
144 return vma
&& (vma
->vm_end
== addr
) && (vma
->vm_flags
& VM_GROWSDOWN
);
147 static inline int stack_guard_page(struct vm_area_struct
*vma
, unsigned long addr
)
149 return (vma
->vm_flags
& VM_GROWSDOWN
) &&
150 (vma
->vm_start
== addr
) &&
151 !vma_stack_continue(vma
->vm_prev
, addr
);
155 * __mlock_vma_pages_range() - mlock a range of pages in the vma.
157 * @start: start address
160 * This takes care of making the pages present too.
162 * return 0 on success, negative error code on error.
164 * vma->vm_mm->mmap_sem must be held for at least read.
166 static long __mlock_vma_pages_range(struct vm_area_struct
*vma
,
167 unsigned long start
, unsigned long end
)
169 struct mm_struct
*mm
= vma
->vm_mm
;
170 unsigned long addr
= start
;
171 struct page
*pages
[16]; /* 16 gives a reasonable batch */
172 int nr_pages
= (end
- start
) / PAGE_SIZE
;
176 VM_BUG_ON(start
& ~PAGE_MASK
);
177 VM_BUG_ON(end
& ~PAGE_MASK
);
178 VM_BUG_ON(start
< vma
->vm_start
);
179 VM_BUG_ON(end
> vma
->vm_end
);
180 VM_BUG_ON(!rwsem_is_locked(&mm
->mmap_sem
));
182 gup_flags
= FOLL_TOUCH
| FOLL_GET
;
183 if (vma
->vm_flags
& VM_WRITE
)
184 gup_flags
|= FOLL_WRITE
;
186 /* We don't try to access the guard page of a stack vma */
187 if (stack_guard_page(vma
, start
)) {
192 while (nr_pages
> 0) {
198 * get_user_pages makes pages present if we are
199 * setting mlock. and this extra reference count will
200 * disable migration of this page. However, page may
201 * still be truncated out from under us.
203 ret
= __get_user_pages(current
, mm
, addr
,
204 min_t(int, nr_pages
, ARRAY_SIZE(pages
)),
205 gup_flags
, pages
, NULL
);
207 * This can happen for, e.g., VM_NONLINEAR regions before
208 * a page has been allocated and mapped at a given offset,
209 * or for addresses that map beyond end of a file.
210 * We'll mlock the pages if/when they get faulted in.
215 lru_add_drain(); /* push cached pages to LRU */
217 for (i
= 0; i
< ret
; i
++) {
218 struct page
*page
= pages
[i
];
222 * That preliminary check is mainly to avoid
223 * the pointless overhead of lock_page on the
224 * ZERO_PAGE: which might bounce very badly if
225 * there is contention. However, we're still
226 * dirtying its cacheline with get/put_page:
227 * we'll add another __get_user_pages flag to
228 * avoid it if that case turns out to matter.
232 * Because we lock page here and migration is
233 * blocked by the elevated reference, we need
234 * only check for file-cache page truncation.
237 mlock_vma_page(page
);
240 put_page(page
); /* ref from get_user_pages() */
243 addr
+= ret
* PAGE_SIZE
;
248 return ret
; /* 0 or negative error code */
252 * convert get_user_pages() return value to posix mlock() error
254 static int __mlock_posix_error_return(long retval
)
256 if (retval
== -EFAULT
)
258 else if (retval
== -ENOMEM
)
264 * mlock_vma_pages_range() - mlock pages in specified vma range.
265 * @vma - the vma containing the specfied address range
266 * @start - starting address in @vma to mlock
267 * @end - end address [+1] in @vma to mlock
269 * For mmap()/mremap()/expansion of mlocked vma.
271 * return 0 on success for "normal" vmas.
273 * return number of pages [> 0] to be removed from locked_vm on success
276 long mlock_vma_pages_range(struct vm_area_struct
*vma
,
277 unsigned long start
, unsigned long end
)
279 int nr_pages
= (end
- start
) / PAGE_SIZE
;
280 BUG_ON(!(vma
->vm_flags
& VM_LOCKED
));
283 * filter unlockable vmas
285 if (vma
->vm_flags
& (VM_IO
| VM_PFNMAP
))
288 if (!((vma
->vm_flags
& (VM_DONTEXPAND
| VM_RESERVED
)) ||
289 is_vm_hugetlb_page(vma
) ||
290 vma
== get_gate_vma(current
))) {
292 __mlock_vma_pages_range(vma
, start
, end
);
294 /* Hide errors from mmap() and other callers */
299 * User mapped kernel pages or huge pages:
300 * make these pages present to populate the ptes, but
301 * fall thru' to reset VM_LOCKED--no need to unlock, and
302 * return nr_pages so these don't get counted against task's
303 * locked limit. huge pages are already counted against
306 make_pages_present(start
, end
);
309 vma
->vm_flags
&= ~VM_LOCKED
; /* and don't come back! */
310 return nr_pages
; /* error or pages NOT mlocked */
314 * munlock_vma_pages_range() - munlock all pages in the vma range.'
315 * @vma - vma containing range to be munlock()ed.
316 * @start - start address in @vma of the range
317 * @end - end of range in @vma.
319 * For mremap(), munmap() and exit().
321 * Called with @vma VM_LOCKED.
323 * Returns with VM_LOCKED cleared. Callers must be prepared to
326 * We don't save and restore VM_LOCKED here because pages are
327 * still on lru. In unmap path, pages might be scanned by reclaim
328 * and re-mlocked by try_to_{munlock|unmap} before we unmap and
329 * free them. This will result in freeing mlocked pages.
331 void munlock_vma_pages_range(struct vm_area_struct
*vma
,
332 unsigned long start
, unsigned long end
)
337 vma
->vm_flags
&= ~VM_LOCKED
;
339 for (addr
= start
; addr
< end
; addr
+= PAGE_SIZE
) {
342 * Although FOLL_DUMP is intended for get_dump_page(),
343 * it just so happens that its special treatment of the
344 * ZERO_PAGE (returning an error instead of doing get_page)
345 * suits munlock very well (and if somehow an abnormal page
346 * has sneaked into the range, we won't oops here: great).
348 page
= follow_page(vma
, addr
, FOLL_GET
| FOLL_DUMP
);
349 if (page
&& !IS_ERR(page
)) {
352 * Like in __mlock_vma_pages_range(),
353 * because we lock page here and migration is
354 * blocked by the elevated reference, we need
355 * only check for file-cache page truncation.
358 munlock_vma_page(page
);
367 * mlock_fixup - handle mlock[all]/munlock[all] requests.
369 * Filters out "special" vmas -- VM_LOCKED never gets set for these, and
370 * munlock is a no-op. However, for some special vmas, we go ahead and
371 * populate the ptes via make_pages_present().
373 * For vmas that pass the filters, merge/split as appropriate.
375 static int mlock_fixup(struct vm_area_struct
*vma
, struct vm_area_struct
**prev
,
376 unsigned long start
, unsigned long end
, unsigned int newflags
)
378 struct mm_struct
*mm
= vma
->vm_mm
;
382 int lock
= newflags
& VM_LOCKED
;
384 if (newflags
== vma
->vm_flags
||
385 (vma
->vm_flags
& (VM_IO
| VM_PFNMAP
)))
386 goto out
; /* don't set VM_LOCKED, don't count */
388 if ((vma
->vm_flags
& (VM_DONTEXPAND
| VM_RESERVED
)) ||
389 is_vm_hugetlb_page(vma
) ||
390 vma
== get_gate_vma(current
)) {
392 make_pages_present(start
, end
);
393 goto out
; /* don't set VM_LOCKED, don't count */
396 pgoff
= vma
->vm_pgoff
+ ((start
- vma
->vm_start
) >> PAGE_SHIFT
);
397 *prev
= vma_merge(mm
, *prev
, start
, end
, newflags
, vma
->anon_vma
,
398 vma
->vm_file
, pgoff
, vma_policy(vma
));
404 if (start
!= vma
->vm_start
) {
405 ret
= split_vma(mm
, vma
, start
, 1);
410 if (end
!= vma
->vm_end
) {
411 ret
= split_vma(mm
, vma
, end
, 0);
418 * Keep track of amount of locked VM.
420 nr_pages
= (end
- start
) >> PAGE_SHIFT
;
422 nr_pages
= -nr_pages
;
423 mm
->locked_vm
+= nr_pages
;
426 * vm_flags is protected by the mmap_sem held in write mode.
427 * It's okay if try_to_unmap_one unmaps a page just after we
428 * set VM_LOCKED, __mlock_vma_pages_range will bring it back.
432 vma
->vm_flags
= newflags
;
433 ret
= __mlock_vma_pages_range(vma
, start
, end
);
435 ret
= __mlock_posix_error_return(ret
);
437 munlock_vma_pages_range(vma
, start
, end
);
445 static int do_mlock(unsigned long start
, size_t len
, int on
)
447 unsigned long nstart
, end
, tmp
;
448 struct vm_area_struct
* vma
, * prev
;
451 len
= PAGE_ALIGN(len
);
457 vma
= find_vma_prev(current
->mm
, start
, &prev
);
458 if (!vma
|| vma
->vm_start
> start
)
461 if (start
> vma
->vm_start
)
464 for (nstart
= start
; ; ) {
465 unsigned int newflags
;
467 /* Here we know that vma->vm_start <= nstart < vma->vm_end. */
469 newflags
= vma
->vm_flags
| VM_LOCKED
;
471 newflags
&= ~VM_LOCKED
;
476 error
= mlock_fixup(vma
, &prev
, nstart
, tmp
, newflags
);
480 if (nstart
< prev
->vm_end
)
481 nstart
= prev
->vm_end
;
486 if (!vma
|| vma
->vm_start
!= nstart
) {
494 SYSCALL_DEFINE2(mlock
, unsigned long, start
, size_t, len
)
496 unsigned long locked
;
497 unsigned long lock_limit
;
503 lru_add_drain_all(); /* flush pagevec */
505 down_write(¤t
->mm
->mmap_sem
);
506 len
= PAGE_ALIGN(len
+ (start
& ~PAGE_MASK
));
509 locked
= len
>> PAGE_SHIFT
;
510 locked
+= current
->mm
->locked_vm
;
512 lock_limit
= current
->signal
->rlim
[RLIMIT_MEMLOCK
].rlim_cur
;
513 lock_limit
>>= PAGE_SHIFT
;
515 /* check against resource limits */
516 if ((locked
<= lock_limit
) || capable(CAP_IPC_LOCK
))
517 error
= do_mlock(start
, len
, 1);
518 up_write(¤t
->mm
->mmap_sem
);
522 SYSCALL_DEFINE2(munlock
, unsigned long, start
, size_t, len
)
526 down_write(¤t
->mm
->mmap_sem
);
527 len
= PAGE_ALIGN(len
+ (start
& ~PAGE_MASK
));
529 ret
= do_mlock(start
, len
, 0);
530 up_write(¤t
->mm
->mmap_sem
);
534 static int do_mlockall(int flags
)
536 struct vm_area_struct
* vma
, * prev
= NULL
;
537 unsigned int def_flags
= 0;
539 if (flags
& MCL_FUTURE
)
540 def_flags
= VM_LOCKED
;
541 current
->mm
->def_flags
= def_flags
;
542 if (flags
== MCL_FUTURE
)
545 for (vma
= current
->mm
->mmap
; vma
; vma
= prev
->vm_next
) {
546 unsigned int newflags
;
548 newflags
= vma
->vm_flags
| VM_LOCKED
;
549 if (!(flags
& MCL_CURRENT
))
550 newflags
&= ~VM_LOCKED
;
553 mlock_fixup(vma
, &prev
, vma
->vm_start
, vma
->vm_end
, newflags
);
559 SYSCALL_DEFINE1(mlockall
, int, flags
)
561 unsigned long lock_limit
;
564 if (!flags
|| (flags
& ~(MCL_CURRENT
| MCL_FUTURE
)))
571 lru_add_drain_all(); /* flush pagevec */
573 down_write(¤t
->mm
->mmap_sem
);
575 lock_limit
= current
->signal
->rlim
[RLIMIT_MEMLOCK
].rlim_cur
;
576 lock_limit
>>= PAGE_SHIFT
;
579 if (!(flags
& MCL_CURRENT
) || (current
->mm
->total_vm
<= lock_limit
) ||
580 capable(CAP_IPC_LOCK
))
581 ret
= do_mlockall(flags
);
582 up_write(¤t
->mm
->mmap_sem
);
587 SYSCALL_DEFINE0(munlockall
)
591 down_write(¤t
->mm
->mmap_sem
);
592 ret
= do_mlockall(0);
593 up_write(¤t
->mm
->mmap_sem
);
598 * Objects with different lifetime than processes (SHM_LOCK and SHM_HUGETLB
599 * shm segments) get accounted against the user_struct instead.
601 static DEFINE_SPINLOCK(shmlock_user_lock
);
603 int user_shm_lock(size_t size
, struct user_struct
*user
)
605 unsigned long lock_limit
, locked
;
608 locked
= (size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
609 lock_limit
= current
->signal
->rlim
[RLIMIT_MEMLOCK
].rlim_cur
;
610 if (lock_limit
== RLIM_INFINITY
)
612 lock_limit
>>= PAGE_SHIFT
;
613 spin_lock(&shmlock_user_lock
);
615 locked
+ user
->locked_shm
> lock_limit
&& !capable(CAP_IPC_LOCK
))
618 user
->locked_shm
+= locked
;
621 spin_unlock(&shmlock_user_lock
);
625 void user_shm_unlock(size_t size
, struct user_struct
*user
)
627 spin_lock(&shmlock_user_lock
);
628 user
->locked_shm
-= (size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
629 spin_unlock(&shmlock_user_lock
);
633 int account_locked_memory(struct mm_struct
*mm
, struct rlimit
*rlim
,
636 unsigned long lim
, vm
, pgsz
;
639 pgsz
= PAGE_ALIGN(size
) >> PAGE_SHIFT
;
641 down_write(&mm
->mmap_sem
);
643 lim
= rlim
[RLIMIT_AS
].rlim_cur
>> PAGE_SHIFT
;
644 vm
= mm
->total_vm
+ pgsz
;
648 lim
= rlim
[RLIMIT_MEMLOCK
].rlim_cur
>> PAGE_SHIFT
;
649 vm
= mm
->locked_vm
+ pgsz
;
653 mm
->total_vm
+= pgsz
;
654 mm
->locked_vm
+= pgsz
;
658 up_write(&mm
->mmap_sem
);
662 void refund_locked_memory(struct mm_struct
*mm
, size_t size
)
664 unsigned long pgsz
= PAGE_ALIGN(size
) >> PAGE_SHIFT
;
666 down_write(&mm
->mmap_sem
);
668 mm
->total_vm
-= pgsz
;
669 mm
->locked_vm
-= pgsz
;
671 up_write(&mm
->mmap_sem
);