Blame view
mm/mlock.c
15.5 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 3 4 5 6 |
/* * linux/mm/mlock.c * * (C) Copyright 1995 Linus Torvalds * (C) Copyright 2002 Christoph Hellwig */ |
c59ede7b7 [PATCH] move capa... |
7 |
#include <linux/capability.h> |
1da177e4c Linux-2.6.12-rc2 |
8 9 |
#include <linux/mman.h> #include <linux/mm.h> |
b291f0003 mlock: mlocked pa... |
10 11 12 |
#include <linux/swap.h> #include <linux/swapops.h> #include <linux/pagemap.h> |
1da177e4c Linux-2.6.12-rc2 |
13 14 |
#include <linux/mempolicy.h> #include <linux/syscalls.h> |
e8edc6e03 Detach sched.h fr... |
15 16 |
#include <linux/sched.h> #include <linux/module.h> |
b291f0003 mlock: mlocked pa... |
17 18 19 20 21 |
#include <linux/rmap.h> #include <linux/mmzone.h> #include <linux/hugetlb.h> #include "internal.h" |
1da177e4c Linux-2.6.12-rc2 |
22 |
|
e8edc6e03 Detach sched.h fr... |
23 24 25 26 |
int can_do_mlock(void) { if (capable(CAP_IPC_LOCK)) return 1; |
59e99e5b9 mm: use rlimit he... |
27 |
if (rlimit(RLIMIT_MEMLOCK) != 0) |
e8edc6e03 Detach sched.h fr... |
28 29 30 31 |
return 1; return 0; } EXPORT_SYMBOL(can_do_mlock); |
1da177e4c Linux-2.6.12-rc2 |
32 |
|
b291f0003 mlock: mlocked pa... |
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
/* * Mlocked pages are marked with PageMlocked() flag for efficient testing * in vmscan and, possibly, the fault path; and to support semi-accurate * statistics. * * An mlocked page [PageMlocked(page)] is unevictable. As such, it will * be placed on the LRU "unevictable" list, rather than the [in]active lists. * The unevictable list is an LRU sibling list to the [in]active lists. * PageUnevictable is set to indicate the unevictable state. * * When lazy mlocking via vmscan, it is important to ensure that the * vma's VM_LOCKED status is not concurrently being modified, otherwise we * may have mlocked a page that is being munlocked. So lazy mlock must take * the mmap_sem for read, and verify that the vma really is locked * (see mm/rmap.c). */ /* * LRU accounting for clear_page_mlock() */ void __clear_page_mlock(struct page *page) { VM_BUG_ON(!PageLocked(page)); if (!page->mapping) { /* truncated ? */ return; } |
5344b7e64 vmstat: mlocked p... |
60 61 |
dec_zone_page_state(page, NR_MLOCK); count_vm_event(UNEVICTABLE_PGCLEARED); |
b291f0003 mlock: mlocked pa... |
62 63 64 65 |
if (!isolate_lru_page(page)) { putback_lru_page(page); } else { /* |
8891d6da1 mm: remove lru_ad... |
66 |
* We lost the race. the page already moved to evictable list. |
b291f0003 mlock: mlocked pa... |
67 |
*/ |
8891d6da1 mm: remove lru_ad... |
68 |
if (PageUnevictable(page)) |
5344b7e64 vmstat: mlocked p... |
69 |
count_vm_event(UNEVICTABLE_PGSTRANDED); |
b291f0003 mlock: mlocked pa... |
70 71 72 73 74 75 76 77 78 79 |
} } /* * Mark page as mlocked if not already. * If page on LRU, isolate and putback to move to unevictable list. */ void mlock_vma_page(struct page *page) { BUG_ON(!PageLocked(page)); |
5344b7e64 vmstat: mlocked p... |
80 81 82 83 84 85 |
if (!TestSetPageMlocked(page)) { inc_zone_page_state(page, NR_MLOCK); count_vm_event(UNEVICTABLE_PGMLOCKED); if (!isolate_lru_page(page)) putback_lru_page(page); } |
b291f0003 mlock: mlocked pa... |
86 |
} |
6927c1dd9 mlock: replace st... |
87 88 89 |
/** * munlock_vma_page - munlock a vma page * @page - page to be unlocked |
b291f0003 mlock: mlocked pa... |
90 |
* |
6927c1dd9 mlock: replace st... |
91 92 93 94 95 96 97 98 99 100 |
* called from munlock()/munmap() path with page supposedly on the LRU. * When we munlock a page, because the vma where we found the page is being * munlock()ed or munmap()ed, we want to check whether other vmas hold the * page locked so that we can leave it on the unevictable lru list and not * bother vmscan with it. However, to walk the page's rmap list in * try_to_munlock() we must isolate the page from the LRU. If some other * task has removed the page from the LRU, we won't be able to do that. * So we clear the PageMlocked as we might not get another chance. If we * can't isolate the page, we leave it for putback_lru_page() and vmscan * [page_referenced()/try_to_unmap()] to deal with. |
b291f0003 mlock: mlocked pa... |
101 |
*/ |
73848b468 ksm: fix mlockfre... |
102 |
void munlock_vma_page(struct page *page) |
b291f0003 mlock: mlocked pa... |
103 104 |
{ BUG_ON(!PageLocked(page)); |
5344b7e64 vmstat: mlocked p... |
105 106 107 108 109 110 111 |
if (TestClearPageMlocked(page)) { dec_zone_page_state(page, NR_MLOCK); if (!isolate_lru_page(page)) { int ret = try_to_munlock(page); /* * did try_to_unlock() succeed or punt? */ |
53f79acb6 mm: mlocking in t... |
112 |
if (ret != SWAP_MLOCK) |
5344b7e64 vmstat: mlocked p... |
113 114 115 116 117 |
count_vm_event(UNEVICTABLE_PGMUNLOCKED); putback_lru_page(page); } else { /* |
6927c1dd9 mlock: replace st... |
118 119 120 121 122 123 |
* Some other task has removed the page from the LRU. * putback_lru_page() will take care of removing the * page from the unevictable list, if necessary. * vmscan [page_referenced()] will move the page back * to the unevictable list if some other vma has it * mlocked. |
5344b7e64 vmstat: mlocked p... |
124 125 126 127 128 129 |
*/ if (PageUnevictable(page)) count_vm_event(UNEVICTABLE_PGSTRANDED); else count_vm_event(UNEVICTABLE_PGMUNLOCKED); } |
b291f0003 mlock: mlocked pa... |
130 131 |
} } |
ba470de43 mmap: handle mloc... |
132 |
/** |
408e82b78 mm: munlock use f... |
133 |
* __mlock_vma_pages_range() - mlock a range of pages in the vma. |
ba470de43 mmap: handle mloc... |
134 135 136 |
* @vma: target vma * @start: start address * @end: end address |
ba470de43 mmap: handle mloc... |
137 |
* |
408e82b78 mm: munlock use f... |
138 |
* This takes care of making the pages present too. |
b291f0003 mlock: mlocked pa... |
139 |
* |
ba470de43 mmap: handle mloc... |
140 |
* return 0 on success, negative error code on error. |
b291f0003 mlock: mlocked pa... |
141 |
* |
ba470de43 mmap: handle mloc... |
142 |
* vma->vm_mm->mmap_sem must be held for at least read. |
b291f0003 mlock: mlocked pa... |
143 |
*/ |
ba470de43 mmap: handle mloc... |
144 |
static long __mlock_vma_pages_range(struct vm_area_struct *vma, |
53a7706d5 mlock: do not hol... |
145 146 |
unsigned long start, unsigned long end, int *nonblocking) |
b291f0003 mlock: mlocked pa... |
147 148 149 |
{ struct mm_struct *mm = vma->vm_mm; unsigned long addr = start; |
b291f0003 mlock: mlocked pa... |
150 |
int nr_pages = (end - start) / PAGE_SIZE; |
408e82b78 mm: munlock use f... |
151 |
int gup_flags; |
ba470de43 mmap: handle mloc... |
152 153 154 155 156 |
VM_BUG_ON(start & ~PAGE_MASK); VM_BUG_ON(end & ~PAGE_MASK); VM_BUG_ON(start < vma->vm_start); VM_BUG_ON(end > vma->vm_end); |
408e82b78 mm: munlock use f... |
157 |
VM_BUG_ON(!rwsem_is_locked(&mm->mmap_sem)); |
b291f0003 mlock: mlocked pa... |
158 |
|
a1fde08c7 VM: skip the stac... |
159 |
gup_flags = FOLL_TOUCH | FOLL_MLOCK; |
5ecfda041 mlock: avoid dirt... |
160 161 162 163 164 165 |
/* * We want to touch writable mappings with a write fault in order * to break COW, except for shared mappings because these don't COW * and we would not want to dirty them for nothing. */ if ((vma->vm_flags & (VM_WRITE | VM_SHARED)) == VM_WRITE) |
58fa879e1 mm: FOLL flags fo... |
166 |
gup_flags |= FOLL_WRITE; |
b291f0003 mlock: mlocked pa... |
167 |
|
fdf4c587a mlock: operate on... |
168 169 170 171 172 173 |
/* * We want mlock to succeed for regions that have any permissions * other than PROT_NONE. */ if (vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC)) gup_flags |= FOLL_FORCE; |
53a7706d5 mlock: do not hol... |
174 175 |
return __get_user_pages(current, mm, addr, nr_pages, gup_flags, NULL, NULL, nonblocking); |
9978ad583 mlock: make mlock... |
176 177 178 179 180 181 182 183 184 185 186 187 |
} /* * convert get_user_pages() return value to posix mlock() error */ static int __mlock_posix_error_return(long retval) { if (retval == -EFAULT) retval = -ENOMEM; else if (retval == -ENOMEM) retval = -EAGAIN; return retval; |
b291f0003 mlock: mlocked pa... |
188 |
} |
ba470de43 mmap: handle mloc... |
189 190 191 192 193 194 195 196 197 198 199 200 |
/** * mlock_vma_pages_range() - mlock pages in specified vma range. * @vma - the vma containing the specfied address range * @start - starting address in @vma to mlock * @end - end address [+1] in @vma to mlock * * For mmap()/mremap()/expansion of mlocked vma. * * return 0 on success for "normal" vmas. * * return number of pages [> 0] to be removed from locked_vm on success * of "special" vmas. |
b291f0003 mlock: mlocked pa... |
201 |
*/ |
ba470de43 mmap: handle mloc... |
202 |
long mlock_vma_pages_range(struct vm_area_struct *vma, |
b291f0003 mlock: mlocked pa... |
203 204 205 206 207 208 209 210 211 212 213 214 215 |
unsigned long start, unsigned long end) { int nr_pages = (end - start) / PAGE_SIZE; BUG_ON(!(vma->vm_flags & VM_LOCKED)); /* * filter unlockable vmas */ if (vma->vm_flags & (VM_IO | VM_PFNMAP)) goto no_mlock; if (!((vma->vm_flags & (VM_DONTEXPAND | VM_RESERVED)) || is_vm_hugetlb_page(vma) || |
31db58b3a mm: arch: make ge... |
216 |
vma == get_gate_vma(current->mm))) { |
8edb08caf mlock: downgrade ... |
217 |
|
53a7706d5 mlock: do not hol... |
218 |
__mlock_vma_pages_range(vma, start, end, NULL); |
d5b562330 mm: fix error cas... |
219 220 221 |
/* Hide errors from mmap() and other callers */ return 0; |
8edb08caf mlock: downgrade ... |
222 |
} |
b291f0003 mlock: mlocked pa... |
223 224 225 226 227 228 229 230 231 232 233 234 235 |
/* * User mapped kernel pages or huge pages: * make these pages present to populate the ptes, but * fall thru' to reset VM_LOCKED--no need to unlock, and * return nr_pages so these don't get counted against task's * locked limit. huge pages are already counted against * locked vm limit. */ make_pages_present(start, end); no_mlock: vma->vm_flags &= ~VM_LOCKED; /* and don't come back! */ |
ba470de43 mmap: handle mloc... |
236 |
return nr_pages; /* error or pages NOT mlocked */ |
b291f0003 mlock: mlocked pa... |
237 |
} |
b291f0003 mlock: mlocked pa... |
238 |
/* |
ba470de43 mmap: handle mloc... |
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 |
* munlock_vma_pages_range() - munlock all pages in the vma range.' * @vma - vma containing range to be munlock()ed. * @start - start address in @vma of the range * @end - end of range in @vma. * * For mremap(), munmap() and exit(). * * Called with @vma VM_LOCKED. * * Returns with VM_LOCKED cleared. Callers must be prepared to * deal with this. * * We don't save and restore VM_LOCKED here because pages are * still on lru. In unmap path, pages might be scanned by reclaim * and re-mlocked by try_to_{munlock|unmap} before we unmap and * free them. This will result in freeing mlocked pages. |
b291f0003 mlock: mlocked pa... |
255 |
*/ |
ba470de43 mmap: handle mloc... |
256 |
void munlock_vma_pages_range(struct vm_area_struct *vma, |
408e82b78 mm: munlock use f... |
257 |
unsigned long start, unsigned long end) |
b291f0003 mlock: mlocked pa... |
258 |
{ |
408e82b78 mm: munlock use f... |
259 260 261 |
unsigned long addr; lru_add_drain(); |
b291f0003 mlock: mlocked pa... |
262 |
vma->vm_flags &= ~VM_LOCKED; |
408e82b78 mm: munlock use f... |
263 264 |
for (addr = start; addr < end; addr += PAGE_SIZE) { |
6e919717c mm: m(un)lock avo... |
265 266 267 268 269 270 271 272 273 274 |
struct page *page; /* * Although FOLL_DUMP is intended for get_dump_page(), * it just so happens that its special treatment of the * ZERO_PAGE (returning an error instead of doing get_page) * suits munlock very well (and if somehow an abnormal page * has sneaked into the range, we won't oops here: great). */ page = follow_page(vma, addr, FOLL_GET | FOLL_DUMP); if (page && !IS_ERR(page)) { |
408e82b78 mm: munlock use f... |
275 |
lock_page(page); |
6e919717c mm: m(un)lock avo... |
276 277 278 279 280 281 |
/* * Like in __mlock_vma_pages_range(), * because we lock page here and migration is * blocked by the elevated reference, we need * only check for file-cache page truncation. */ |
408e82b78 mm: munlock use f... |
282 283 284 285 286 287 288 |
if (page->mapping) munlock_vma_page(page); unlock_page(page); put_page(page); } cond_resched(); } |
b291f0003 mlock: mlocked pa... |
289 290 291 292 293 294 295 296 297 298 299 |
} /* * mlock_fixup - handle mlock[all]/munlock[all] requests. * * Filters out "special" vmas -- VM_LOCKED never gets set for these, and * munlock is a no-op. However, for some special vmas, we go ahead and * populate the ptes via make_pages_present(). * * For vmas that pass the filters, merge/split as appropriate. */ |
1da177e4c Linux-2.6.12-rc2 |
300 |
static int mlock_fixup(struct vm_area_struct *vma, struct vm_area_struct **prev, |
ca16d140a mm: don't access ... |
301 |
unsigned long start, unsigned long end, vm_flags_t newflags) |
1da177e4c Linux-2.6.12-rc2 |
302 |
{ |
b291f0003 mlock: mlocked pa... |
303 |
struct mm_struct *mm = vma->vm_mm; |
1da177e4c Linux-2.6.12-rc2 |
304 |
pgoff_t pgoff; |
b291f0003 mlock: mlocked pa... |
305 |
int nr_pages; |
1da177e4c Linux-2.6.12-rc2 |
306 |
int ret = 0; |
ca16d140a mm: don't access ... |
307 |
int lock = !!(newflags & VM_LOCKED); |
1da177e4c Linux-2.6.12-rc2 |
308 |
|
fed067da4 mlock: only hold ... |
309 |
if (newflags == vma->vm_flags || (vma->vm_flags & VM_SPECIAL) || |
31db58b3a mm: arch: make ge... |
310 |
is_vm_hugetlb_page(vma) || vma == get_gate_vma(current->mm)) |
b291f0003 mlock: mlocked pa... |
311 |
goto out; /* don't set VM_LOCKED, don't count */ |
1da177e4c Linux-2.6.12-rc2 |
312 313 314 315 316 317 318 |
pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT); *prev = vma_merge(mm, *prev, start, end, newflags, vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma)); if (*prev) { vma = *prev; goto success; } |
1da177e4c Linux-2.6.12-rc2 |
319 320 321 322 323 324 325 326 327 328 329 330 331 332 |
if (start != vma->vm_start) { ret = split_vma(mm, vma, start, 1); if (ret) goto out; } if (end != vma->vm_end) { ret = split_vma(mm, vma, end, 0); if (ret) goto out; } success: /* |
b291f0003 mlock: mlocked pa... |
333 334 335 336 337 338 339 340 |
* Keep track of amount of locked VM. */ nr_pages = (end - start) >> PAGE_SHIFT; if (!lock) nr_pages = -nr_pages; mm->locked_vm += nr_pages; /* |
1da177e4c Linux-2.6.12-rc2 |
341 342 |
* vm_flags is protected by the mmap_sem held in write mode. * It's okay if try_to_unmap_one unmaps a page just after we |
b291f0003 mlock: mlocked pa... |
343 |
* set VM_LOCKED, __mlock_vma_pages_range will bring it back. |
1da177e4c Linux-2.6.12-rc2 |
344 |
*/ |
1da177e4c Linux-2.6.12-rc2 |
345 |
|
fed067da4 mlock: only hold ... |
346 |
if (lock) |
408e82b78 mm: munlock use f... |
347 |
vma->vm_flags = newflags; |
fed067da4 mlock: only hold ... |
348 |
else |
408e82b78 mm: munlock use f... |
349 |
munlock_vma_pages_range(vma, start, end); |
1da177e4c Linux-2.6.12-rc2 |
350 |
|
1da177e4c Linux-2.6.12-rc2 |
351 |
out: |
b291f0003 mlock: mlocked pa... |
352 |
*prev = vma; |
1da177e4c Linux-2.6.12-rc2 |
353 354 355 356 357 358 359 360 |
return ret; } static int do_mlock(unsigned long start, size_t len, int on) { unsigned long nstart, end, tmp; struct vm_area_struct * vma, * prev; int error; |
fed067da4 mlock: only hold ... |
361 362 |
VM_BUG_ON(start & ~PAGE_MASK); VM_BUG_ON(len != PAGE_ALIGN(len)); |
1da177e4c Linux-2.6.12-rc2 |
363 364 365 366 367 368 369 370 371 372 373 374 375 |
end = start + len; if (end < start) return -EINVAL; if (end == start) return 0; vma = find_vma_prev(current->mm, start, &prev); if (!vma || vma->vm_start > start) return -ENOMEM; if (start > vma->vm_start) prev = vma; for (nstart = start ; ; ) { |
ca16d140a mm: don't access ... |
376 |
vm_flags_t newflags; |
1da177e4c Linux-2.6.12-rc2 |
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 |
/* Here we know that vma->vm_start <= nstart < vma->vm_end. */ newflags = vma->vm_flags | VM_LOCKED; if (!on) newflags &= ~VM_LOCKED; tmp = vma->vm_end; if (tmp > end) tmp = end; error = mlock_fixup(vma, &prev, nstart, tmp, newflags); if (error) break; nstart = tmp; if (nstart < prev->vm_end) nstart = prev->vm_end; if (nstart >= end) break; vma = prev->vm_next; if (!vma || vma->vm_start != nstart) { error = -ENOMEM; break; } } return error; } |
fed067da4 mlock: only hold ... |
404 405 406 407 408 |
static int do_mlock_pages(unsigned long start, size_t len, int ignore_errors) { struct mm_struct *mm = current->mm; unsigned long end, nstart, nend; struct vm_area_struct *vma = NULL; |
53a7706d5 mlock: do not hol... |
409 |
int locked = 0; |
fed067da4 mlock: only hold ... |
410 411 412 413 414 |
int ret = 0; VM_BUG_ON(start & ~PAGE_MASK); VM_BUG_ON(len != PAGE_ALIGN(len)); end = start + len; |
fed067da4 mlock: only hold ... |
415 416 417 418 419 |
for (nstart = start; nstart < end; nstart = nend) { /* * We want to fault in pages for [nstart; end) address range. * Find first corresponding VMA. */ |
53a7706d5 mlock: do not hol... |
420 421 422 |
if (!locked) { locked = 1; down_read(&mm->mmap_sem); |
fed067da4 mlock: only hold ... |
423 |
vma = find_vma(mm, nstart); |
53a7706d5 mlock: do not hol... |
424 |
} else if (nstart >= vma->vm_end) |
fed067da4 mlock: only hold ... |
425 426 427 428 429 430 431 432 433 434 435 436 437 |
vma = vma->vm_next; if (!vma || vma->vm_start >= end) break; /* * Set [nstart; nend) to intersection of desired address * range with the first VMA. Also, skip undesirable VMA types. */ nend = min(end, vma->vm_end); if (vma->vm_flags & (VM_IO | VM_PFNMAP)) continue; if (nstart < vma->vm_start) nstart = vma->vm_start; /* |
53a7706d5 mlock: do not hol... |
438 439 440 |
* Now fault in a range of pages. __mlock_vma_pages_range() * double checks the vma flags, so that it won't mlock pages * if the vma was already munlocked. |
fed067da4 mlock: only hold ... |
441 |
*/ |
53a7706d5 mlock: do not hol... |
442 443 444 445 446 447 |
ret = __mlock_vma_pages_range(vma, nstart, nend, &locked); if (ret < 0) { if (ignore_errors) { ret = 0; continue; /* continue at next VMA */ } |
5fdb20021 mm: move VM_LOCKE... |
448 449 450 |
ret = __mlock_posix_error_return(ret); break; } |
53a7706d5 mlock: do not hol... |
451 452 |
nend = nstart + ret * PAGE_SIZE; ret = 0; |
fed067da4 mlock: only hold ... |
453 |
} |
53a7706d5 mlock: do not hol... |
454 455 |
if (locked) up_read(&mm->mmap_sem); |
fed067da4 mlock: only hold ... |
456 457 |
return ret; /* 0 or negative error code */ } |
6a6160a7b [CVE-2009-0029] S... |
458 |
SYSCALL_DEFINE2(mlock, unsigned long, start, size_t, len) |
1da177e4c Linux-2.6.12-rc2 |
459 460 461 462 463 464 465 |
{ unsigned long locked; unsigned long lock_limit; int error = -ENOMEM; if (!can_do_mlock()) return -EPERM; |
8891d6da1 mm: remove lru_ad... |
466 |
lru_add_drain_all(); /* flush pagevec */ |
1da177e4c Linux-2.6.12-rc2 |
467 468 469 470 471 472 |
down_write(¤t->mm->mmap_sem); len = PAGE_ALIGN(len + (start & ~PAGE_MASK)); start &= PAGE_MASK; locked = len >> PAGE_SHIFT; locked += current->mm->locked_vm; |
59e99e5b9 mm: use rlimit he... |
473 |
lock_limit = rlimit(RLIMIT_MEMLOCK); |
1da177e4c Linux-2.6.12-rc2 |
474 475 476 477 478 479 |
lock_limit >>= PAGE_SHIFT; /* check against resource limits */ if ((locked <= lock_limit) || capable(CAP_IPC_LOCK)) error = do_mlock(start, len, 1); up_write(¤t->mm->mmap_sem); |
fed067da4 mlock: only hold ... |
480 481 |
if (!error) error = do_mlock_pages(start, len, 0); |
1da177e4c Linux-2.6.12-rc2 |
482 483 |
return error; } |
6a6160a7b [CVE-2009-0029] S... |
484 |
SYSCALL_DEFINE2(munlock, unsigned long, start, size_t, len) |
1da177e4c Linux-2.6.12-rc2 |
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 |
{ int ret; down_write(¤t->mm->mmap_sem); len = PAGE_ALIGN(len + (start & ~PAGE_MASK)); start &= PAGE_MASK; ret = do_mlock(start, len, 0); up_write(¤t->mm->mmap_sem); return ret; } static int do_mlockall(int flags) { struct vm_area_struct * vma, * prev = NULL; unsigned int def_flags = 0; if (flags & MCL_FUTURE) def_flags = VM_LOCKED; current->mm->def_flags = def_flags; if (flags == MCL_FUTURE) goto out; for (vma = current->mm->mmap; vma ; vma = prev->vm_next) { |
ca16d140a mm: don't access ... |
508 |
vm_flags_t newflags; |
1da177e4c Linux-2.6.12-rc2 |
509 510 511 512 513 514 515 516 517 518 519 |
newflags = vma->vm_flags | VM_LOCKED; if (!(flags & MCL_CURRENT)) newflags &= ~VM_LOCKED; /* Ignore errors */ mlock_fixup(vma, &prev, vma->vm_start, vma->vm_end, newflags); } out: return 0; } |
3480b2574 [CVE-2009-0029] S... |
520 |
SYSCALL_DEFINE1(mlockall, int, flags) |
1da177e4c Linux-2.6.12-rc2 |
521 522 523 524 525 526 527 528 529 530 |
{ unsigned long lock_limit; int ret = -EINVAL; if (!flags || (flags & ~(MCL_CURRENT | MCL_FUTURE))) goto out; ret = -EPERM; if (!can_do_mlock()) goto out; |
8891d6da1 mm: remove lru_ad... |
531 |
lru_add_drain_all(); /* flush pagevec */ |
1da177e4c Linux-2.6.12-rc2 |
532 |
down_write(¤t->mm->mmap_sem); |
59e99e5b9 mm: use rlimit he... |
533 |
lock_limit = rlimit(RLIMIT_MEMLOCK); |
1da177e4c Linux-2.6.12-rc2 |
534 535 536 537 538 539 540 |
lock_limit >>= PAGE_SHIFT; ret = -ENOMEM; if (!(flags & MCL_CURRENT) || (current->mm->total_vm <= lock_limit) || capable(CAP_IPC_LOCK)) ret = do_mlockall(flags); up_write(¤t->mm->mmap_sem); |
fed067da4 mlock: only hold ... |
541 542 543 544 |
if (!ret && (flags & MCL_CURRENT)) { /* Ignore errors */ do_mlock_pages(0, TASK_SIZE, 1); } |
1da177e4c Linux-2.6.12-rc2 |
545 546 547 |
out: return ret; } |
3480b2574 [CVE-2009-0029] S... |
548 |
SYSCALL_DEFINE0(munlockall) |
1da177e4c Linux-2.6.12-rc2 |
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 |
{ int ret; down_write(¤t->mm->mmap_sem); ret = do_mlockall(0); up_write(¤t->mm->mmap_sem); return ret; } /* * Objects with different lifetime than processes (SHM_LOCK and SHM_HUGETLB * shm segments) get accounted against the user_struct instead. */ static DEFINE_SPINLOCK(shmlock_user_lock); int user_shm_lock(size_t size, struct user_struct *user) { unsigned long lock_limit, locked; int allowed = 0; locked = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; |
59e99e5b9 mm: use rlimit he... |
570 |
lock_limit = rlimit(RLIMIT_MEMLOCK); |
5ed44a401 do not limit lock... |
571 572 |
if (lock_limit == RLIM_INFINITY) allowed = 1; |
1da177e4c Linux-2.6.12-rc2 |
573 574 |
lock_limit >>= PAGE_SHIFT; spin_lock(&shmlock_user_lock); |
5ed44a401 do not limit lock... |
575 576 |
if (!allowed && locked + user->locked_shm > lock_limit && !capable(CAP_IPC_LOCK)) |
1da177e4c Linux-2.6.12-rc2 |
577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 |
goto out; get_uid(user); user->locked_shm += locked; allowed = 1; out: spin_unlock(&shmlock_user_lock); return allowed; } void user_shm_unlock(size_t size, struct user_struct *user) { spin_lock(&shmlock_user_lock); user->locked_shm -= (size + PAGE_SIZE - 1) >> PAGE_SHIFT; spin_unlock(&shmlock_user_lock); free_uid(user); } |