mlock.c 17.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 *	linux/mm/mlock.c
 *
 *  (C) Copyright 1995 Linus Torvalds
 *  (C) Copyright 2002 Christoph Hellwig
 */

8
#include <linux/capability.h>
L
Linus Torvalds 已提交
9 10
#include <linux/mman.h>
#include <linux/mm.h>
N
Nick Piggin 已提交
11 12 13
#include <linux/swap.h>
#include <linux/swapops.h>
#include <linux/pagemap.h>
L
Linus Torvalds 已提交
14 15
#include <linux/mempolicy.h>
#include <linux/syscalls.h>
A
Alexey Dobriyan 已提交
16 17
#include <linux/sched.h>
#include <linux/module.h>
N
Nick Piggin 已提交
18 19 20 21 22
#include <linux/rmap.h>
#include <linux/mmzone.h>
#include <linux/hugetlb.h>

#include "internal.h"
L
Linus Torvalds 已提交
23

A
Alexey Dobriyan 已提交
24 25 26 27 28 29 30 31 32
int can_do_mlock(void)
{
	if (capable(CAP_IPC_LOCK))
		return 1;
	if (current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur != 0)
		return 1;
	return 0;
}
EXPORT_SYMBOL(can_do_mlock);
L
Linus Torvalds 已提交
33

N
Nick Piggin 已提交
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 60 61 62
#ifdef CONFIG_UNEVICTABLE_LRU
/*
 * 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;
	}

N
Nick Piggin 已提交
63 64
	dec_zone_page_state(page, NR_MLOCK);
	count_vm_event(UNEVICTABLE_PGCLEARED);
N
Nick Piggin 已提交
65 66 67 68
	if (!isolate_lru_page(page)) {
		putback_lru_page(page);
	} else {
		/*
69
		 * We lost the race. the page already moved to evictable list.
N
Nick Piggin 已提交
70
		 */
71
		if (PageUnevictable(page))
N
Nick Piggin 已提交
72
			count_vm_event(UNEVICTABLE_PGSTRANDED);
N
Nick Piggin 已提交
73 74 75 76 77 78 79 80 81 82 83
	}
}

/*
 * 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));

N
Nick Piggin 已提交
84 85 86 87 88 89
	if (!TestSetPageMlocked(page)) {
		inc_zone_page_state(page, NR_MLOCK);
		count_vm_event(UNEVICTABLE_PGMLOCKED);
		if (!isolate_lru_page(page))
			putback_lru_page(page);
	}
N
Nick Piggin 已提交
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
}

/*
 * called from munlock()/munmap() path with page supposedly on the LRU.
 *
 * Note:  unlike mlock_vma_page(), we can't just clear the PageMlocked
 * [in try_to_munlock()] and then attempt to isolate the page.  We must
 * isolate the page to keep others from messing with its unevictable
 * and mlocked state while trying to munlock.  However, we pre-clear the
 * mlocked state anyway as we might lose the isolation race and we might
 * not get another chance to clear PageMlocked.  If we successfully
 * isolate the page and try_to_munlock() detects other VM_LOCKED vmas
 * mapping the page, it will restore the PageMlocked state, unless the page
 * is mapped in a non-linear vma.  So, we go ahead and SetPageMlocked(),
 * perhaps redundantly.
 * If we lose the isolation race, and the page is mapped by other VM_LOCKED
 * vmas, we'll detect this in vmscan--via try_to_munlock() or try_to_unmap()
 * either of which will restore the PageMlocked state by calling
 * mlock_vma_page() above, if it can grab the vma's mmap sem.
 */
static void munlock_vma_page(struct page *page)
{
	BUG_ON(!PageLocked(page));

N
Nick Piggin 已提交
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
	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?
			 */
			if (ret == SWAP_SUCCESS || ret == SWAP_AGAIN)
				count_vm_event(UNEVICTABLE_PGMUNLOCKED);

			putback_lru_page(page);
		} else {
			/*
			 * We lost the race.  let try_to_unmap() deal
			 * with it.  At least we get the page state and
			 * mlock stats right.  However, page is still on
			 * the noreclaim list.  We'll fix that up when
			 * the page is eventually freed or we scan the
			 * noreclaim list.
			 */
			if (PageUnevictable(page))
				count_vm_event(UNEVICTABLE_PGSTRANDED);
			else
				count_vm_event(UNEVICTABLE_PGMUNLOCKED);
		}
N
Nick Piggin 已提交
139 140 141
	}
}

142 143 144 145 146 147 148 149 150 151
/**
 * __mlock_vma_pages_range() -  mlock/munlock a range of pages in the vma.
 * @vma:   target vma
 * @start: start address
 * @end:   end address
 * @mlock: 0 indicate munlock, otherwise mlock.
 *
 * If @mlock == 0, unlock an mlocked range;
 * else mlock the range of pages.  This takes care of making the pages present ,
 * too.
N
Nick Piggin 已提交
152
 *
153
 * return 0 on success, negative error code on error.
N
Nick Piggin 已提交
154
 *
155
 * vma->vm_mm->mmap_sem must be held for at least read.
N
Nick Piggin 已提交
156
 */
157 158 159
static long __mlock_vma_pages_range(struct vm_area_struct *vma,
				   unsigned long start, unsigned long end,
				   int mlock)
N
Nick Piggin 已提交
160 161 162 163 164 165
{
	struct mm_struct *mm = vma->vm_mm;
	unsigned long addr = start;
	struct page *pages[16]; /* 16 gives a reasonable batch */
	int nr_pages = (end - start) / PAGE_SIZE;
	int ret;
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
	int gup_flags = 0;

	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);
	VM_BUG_ON((!rwsem_is_locked(&mm->mmap_sem)) &&
		  (atomic_read(&mm->mm_users) != 0));

	/*
	 * mlock:   don't page populate if page has PROT_NONE permission.
	 * munlock: the pages always do munlock althrough
	 *          its has PROT_NONE permission.
	 */
	if (!mlock)
		gup_flags |= GUP_FLAGS_IGNORE_VMA_PERMISSIONS;
N
Nick Piggin 已提交
182

183 184
	if (vma->vm_flags & VM_WRITE)
		gup_flags |= GUP_FLAGS_WRITE;
N
Nick Piggin 已提交
185 186 187 188 189 190 191 192 193 194 195 196

	while (nr_pages > 0) {
		int i;

		cond_resched();

		/*
		 * get_user_pages makes pages present if we are
		 * setting mlock. and this extra reference count will
		 * disable migration of this page.  However, page may
		 * still be truncated out from under us.
		 */
197
		ret = __get_user_pages(current, mm, addr,
N
Nick Piggin 已提交
198
				min_t(int, nr_pages, ARRAY_SIZE(pages)),
199
				gup_flags, pages, NULL);
N
Nick Piggin 已提交
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
		/*
		 * This can happen for, e.g., VM_NONLINEAR regions before
		 * a page has been allocated and mapped at a given offset,
		 * or for addresses that map beyond end of a file.
		 * We'll mlock the the pages if/when they get faulted in.
		 */
		if (ret < 0)
			break;
		if (ret == 0) {
			/*
			 * We know the vma is there, so the only time
			 * we cannot get a single page should be an
			 * error (ret < 0) case.
			 */
			WARN_ON(1);
			break;
		}

		lru_add_drain();	/* push cached pages to LRU */

		for (i = 0; i < ret; i++) {
			struct page *page = pages[i];

			lock_page(page);
			/*
			 * Because we lock page here and migration is blocked
			 * by the elevated reference, we need only check for
			 * page truncation (file-cache only).
			 */
229 230 231 232 233 234
			if (page->mapping) {
				if (mlock)
					mlock_vma_page(page);
				else
					munlock_vma_page(page);
			}
N
Nick Piggin 已提交
235 236 237 238 239 240 241 242 243 244
			unlock_page(page);
			put_page(page);		/* ref from get_user_pages() */

			/*
			 * here we assume that get_user_pages() has given us
			 * a list of virtually contiguous pages.
			 */
			addr += PAGE_SIZE;	/* for next get_user_pages() */
			nr_pages--;
		}
245
		ret = 0;
N
Nick Piggin 已提交
246 247
	}

248 249 250 251 252 253 254 255 256 257 258 259 260
	return ret;	/* count entire vma as locked_vm */
}

/*
 * 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;
N
Nick Piggin 已提交
261 262 263 264 265 266 267
}

#else /* CONFIG_UNEVICTABLE_LRU */

/*
 * Just make pages present if VM_LOCKED.  No-op if unlocking.
 */
268 269 270
static long __mlock_vma_pages_range(struct vm_area_struct *vma,
				   unsigned long start, unsigned long end,
				   int mlock)
N
Nick Piggin 已提交
271
{
272
	if (mlock && (vma->vm_flags & VM_LOCKED))
273 274 275 276 277 278
		return make_pages_present(start, end);
	return 0;
}

static inline int __mlock_posix_error_return(long retval)
{
N
Nick Piggin 已提交
279 280
	return 0;
}
281

N
Nick Piggin 已提交
282 283
#endif /* CONFIG_UNEVICTABLE_LRU */

284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
/**
 * 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.
 *
 * return negative error if vma spanning @start-@range disappears while
 * mmap semaphore is dropped.  Unlikely?
N
Nick Piggin 已提交
299
 */
300
long mlock_vma_pages_range(struct vm_area_struct *vma,
N
Nick Piggin 已提交
301 302
			unsigned long start, unsigned long end)
{
303
	struct mm_struct *mm = vma->vm_mm;
N
Nick Piggin 已提交
304 305 306 307 308 309 310 311 312 313 314
	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) ||
315
			vma == get_gate_vma(current))) {
316
		long error;
317
		downgrade_write(&mm->mmap_sem);
318 319

		error = __mlock_vma_pages_range(vma, start, end, 1);
320 321 322 323 324 325 326

		up_read(&mm->mmap_sem);
		/* vma can change or disappear */
		down_write(&mm->mmap_sem);
		vma = find_vma(mm, start);
		/* non-NULL vma must contain @start, but need to check @end */
		if (!vma ||  end > vma->vm_end)
327 328 329
			return -ENOMEM;

		return 0;	/* hide other errors from mmap(), et al */
330
	}
N
Nick Piggin 已提交
331 332 333 334 335 336 337 338 339 340 341 342 343

	/*
	 * 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! */
344
	return nr_pages;		/* error or pages NOT mlocked */
N
Nick Piggin 已提交
345 346 347 348
}


/*
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
 * 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.
N
Nick Piggin 已提交
365
 */
366 367
void munlock_vma_pages_range(struct vm_area_struct *vma,
			   unsigned long start, unsigned long end)
N
Nick Piggin 已提交
368 369
{
	vma->vm_flags &= ~VM_LOCKED;
370
	__mlock_vma_pages_range(vma, start, end, 0);
N
Nick Piggin 已提交
371 372 373 374 375 376 377 378 379 380 381
}

/*
 * 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.
 */
L
Linus Torvalds 已提交
382 383 384
static int mlock_fixup(struct vm_area_struct *vma, struct vm_area_struct **prev,
	unsigned long start, unsigned long end, unsigned int newflags)
{
N
Nick Piggin 已提交
385
	struct mm_struct *mm = vma->vm_mm;
L
Linus Torvalds 已提交
386
	pgoff_t pgoff;
N
Nick Piggin 已提交
387
	int nr_pages;
L
Linus Torvalds 已提交
388
	int ret = 0;
N
Nick Piggin 已提交
389
	int lock = newflags & VM_LOCKED;
L
Linus Torvalds 已提交
390

N
Nick Piggin 已提交
391 392 393 394 395 396 397 398 399 400
	if (newflags == vma->vm_flags ||
			(vma->vm_flags & (VM_IO | VM_PFNMAP)))
		goto out;	/* don't set VM_LOCKED,  don't count */

	if ((vma->vm_flags & (VM_DONTEXPAND | VM_RESERVED)) ||
			is_vm_hugetlb_page(vma) ||
			vma == get_gate_vma(current)) {
		if (lock)
			make_pages_present(start, end);
		goto out;	/* don't set VM_LOCKED,  don't count */
L
Linus Torvalds 已提交
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
	}

	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;
	}

	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:
N
Nick Piggin 已提交
424 425 426 427 428 429 430 431
	/*
	 * Keep track of amount of locked VM.
	 */
	nr_pages = (end - start) >> PAGE_SHIFT;
	if (!lock)
		nr_pages = -nr_pages;
	mm->locked_vm += nr_pages;

L
Linus Torvalds 已提交
432 433 434
	/*
	 * 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
N
Nick Piggin 已提交
435
	 * set VM_LOCKED, __mlock_vma_pages_range will bring it back.
L
Linus Torvalds 已提交
436 437 438
	 */
	vma->vm_flags = newflags;

N
Nick Piggin 已提交
439
	if (lock) {
440 441 442 443 444 445 446
		/*
		 * mmap_sem is currently held for write.  Downgrade the write
		 * lock to a read lock so that other faults, mmap scans, ...
		 * while we fault in all pages.
		 */
		downgrade_write(&mm->mmap_sem);

447
		ret = __mlock_vma_pages_range(vma, start, end, 1);
448

449 450 451 452 453 454 455 456 457 458 459 460
		/*
		 * Need to reacquire mmap sem in write mode, as our callers
		 * expect this.  We have no support for atomically upgrading
		 * a sem to write, so we need to check for ranges while sem
		 * is unlocked.
		 */
		up_read(&mm->mmap_sem);
		/* vma can change or disappear */
		down_write(&mm->mmap_sem);
		*prev = find_vma(mm, start);
		/* non-NULL *prev must contain @start, but need to check @end */
		if (!(*prev) || end > (*prev)->vm_end)
461
			ret = -ENOMEM;
462 463 464 465 466
		else if (ret > 0) {
			mm->locked_vm -= ret;
			ret = 0;
		} else
			ret = __mlock_posix_error_return(ret); /* translate if needed */
467 468 469 470 471 472 473 474
	} else {
		/*
		 * TODO:  for unlocking, pages will already be resident, so
		 * we don't need to wait for allocations/reclaim/pagein, ...
		 * However, unlocking a very large region can still take a
		 * while.  Should we downgrade the semaphore for both lock
		 * AND unlock ?
		 */
475
		__mlock_vma_pages_range(vma, start, end, 0);
476
	}
L
Linus Torvalds 已提交
477 478

out:
N
Nick Piggin 已提交
479
	*prev = vma;
L
Linus Torvalds 已提交
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
	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;

	len = PAGE_ALIGN(len);
	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 ; ; ) {
		unsigned int newflags;

		/* 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;
}

asmlinkage long sys_mlock(unsigned long start, size_t len)
{
	unsigned long locked;
	unsigned long lock_limit;
	int error = -ENOMEM;

	if (!can_do_mlock())
		return -EPERM;

541 542
	lru_add_drain_all();	/* flush pagevec */

L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
	down_write(&current->mm->mmap_sem);
	len = PAGE_ALIGN(len + (start & ~PAGE_MASK));
	start &= PAGE_MASK;

	locked = len >> PAGE_SHIFT;
	locked += current->mm->locked_vm;

	lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
	lock_limit >>= PAGE_SHIFT;

	/* check against resource limits */
	if ((locked <= lock_limit) || capable(CAP_IPC_LOCK))
		error = do_mlock(start, len, 1);
	up_write(&current->mm->mmap_sem);
	return error;
}

asmlinkage long sys_munlock(unsigned long start, size_t len)
{
	int ret;

	down_write(&current->mm->mmap_sem);
	len = PAGE_ALIGN(len + (start & ~PAGE_MASK));
	start &= PAGE_MASK;
	ret = do_mlock(start, len, 0);
	up_write(&current->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) {
		unsigned int newflags;

		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;
}

asmlinkage long sys_mlockall(int flags)
{
	unsigned long lock_limit;
	int ret = -EINVAL;

	if (!flags || (flags & ~(MCL_CURRENT | MCL_FUTURE)))
		goto out;

	ret = -EPERM;
	if (!can_do_mlock())
		goto out;

609 610
	lru_add_drain_all();	/* flush pagevec */

L
Linus Torvalds 已提交
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
	down_write(&current->mm->mmap_sem);

	lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
	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(&current->mm->mmap_sem);
out:
	return ret;
}

asmlinkage long sys_munlockall(void)
{
	int ret;

	down_write(&current->mm->mmap_sem);
	ret = do_mlockall(0);
	up_write(&current->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;
	lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
648 649
	if (lock_limit == RLIM_INFINITY)
		allowed = 1;
L
Linus Torvalds 已提交
650 651
	lock_limit >>= PAGE_SHIFT;
	spin_lock(&shmlock_user_lock);
652 653
	if (!allowed &&
	    locked + user->locked_shm > lock_limit && !capable(CAP_IPC_LOCK))
L
Linus Torvalds 已提交
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
		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);
}