X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=mm%2Fmlock.c;h=e3bc9cd77f2716951267594d7cf3904ca1413c05;hb=6a77f38946aaee1cd85eeec6cf4229b204c15071;hp=0cf446b5f38323c3b20c7242b52db103d16756aa;hpb=5273a3df6485dc2ad6aa7ddd441b9a21970f003b;p=linux-2.6.git diff --git a/mm/mlock.c b/mm/mlock.c index 0cf446b5f..e3bc9cd77 100644 --- a/mm/mlock.c +++ b/mm/mlock.c @@ -7,6 +7,8 @@ #include #include +#include +#include static int mlock_fixup(struct vm_area_struct * vma, @@ -20,22 +22,23 @@ static int mlock_fixup(struct vm_area_struct * vma, goto out; if (start != vma->vm_start) { - if (split_vma(mm, vma, start, 1)) { - ret = -EAGAIN; + ret = split_vma(mm, vma, start, 1); + if (ret) goto out; - } } if (end != vma->vm_end) { - if (split_vma(mm, vma, end, 0)) { - ret = -EAGAIN; + ret = split_vma(mm, vma, end, 0); + if (ret) goto out; - } } - - spin_lock(&mm->page_table_lock); + + /* + * 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 + * set VM_LOCKED, make_pages_present below will bring it back. + */ vma->vm_flags = newflags; - spin_unlock(&mm->page_table_lock); /* * Keep track of amount of locked VM. @@ -43,11 +46,15 @@ static int mlock_fixup(struct vm_area_struct * vma, pages = (end - start) >> PAGE_SHIFT; if (newflags & VM_LOCKED) { pages = -pages; - ret = make_pages_present(start, end); + if (!(newflags & VM_IO)) + ret = make_pages_present(start, end); } - vma->vm_mm->locked_vm -= pages; + // vma->vm_mm->locked_vm -= pages; + vx_vmlocked_sub(vma->vm_mm, pages); out: + if (ret == -ENOMEM) + ret = -EAGAIN; return ret; } @@ -57,8 +64,6 @@ static int do_mlock(unsigned long start, size_t len, int on) struct vm_area_struct * vma, * next; int error; - if (on && !capable(CAP_IPC_LOCK)) - return -EPERM; len = PAGE_ALIGN(len); end = start + len; if (end < start) @@ -100,23 +105,29 @@ static int do_mlock(unsigned long start, size_t len, int on) asmlinkage long sys_mlock(unsigned long start, size_t len) { - unsigned long locked; + unsigned long locked, grow; unsigned long lock_limit; int error = -ENOMEM; + if (!can_do_mlock()) + return -EPERM; + 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; + grow = len >> PAGE_SHIFT; + if (!vx_vmlocked_avail(current->mm, grow)) + goto out; + locked = current->mm->locked_vm + grow; - lock_limit = current->rlim[RLIMIT_MEMLOCK].rlim_cur; + lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur; lock_limit >>= PAGE_SHIFT; /* check against resource limits */ - if (locked <= lock_limit) + if ((locked <= lock_limit) || capable(CAP_IPC_LOCK)) error = do_mlock(start, len, 1); +out: up_write(¤t->mm->mmap_sem); return error; } @@ -135,19 +146,15 @@ asmlinkage long sys_munlock(unsigned long start, size_t len) static int do_mlockall(int flags) { - int error; - unsigned int def_flags; struct vm_area_struct * vma; + unsigned int def_flags = 0; - if (!capable(CAP_IPC_LOCK)) - return -EPERM; - - def_flags = 0; if (flags & MCL_FUTURE) def_flags = VM_LOCKED; current->mm->def_flags = def_flags; + if (flags == MCL_FUTURE) + goto out; - error = 0; for (vma = current->mm->mmap; vma ; vma = vma->vm_next) { unsigned int newflags; @@ -158,7 +165,8 @@ static int do_mlockall(int flags) /* Ignore errors */ mlock_fixup(vma, vma->vm_start, vma->vm_end, newflags); } - return error; +out: + return 0; } asmlinkage long sys_mlockall(int flags) @@ -166,18 +174,26 @@ asmlinkage long sys_mlockall(int flags) unsigned long lock_limit; int ret = -EINVAL; - down_write(¤t->mm->mmap_sem); if (!flags || (flags & ~(MCL_CURRENT | MCL_FUTURE))) goto out; - lock_limit = current->rlim[RLIMIT_MEMLOCK].rlim_cur; + ret = -EPERM; + if (!can_do_mlock()) + goto out; + + down_write(¤t->mm->mmap_sem); + + lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur; lock_limit >>= PAGE_SHIFT; ret = -ENOMEM; - if (current->mm->total_vm <= lock_limit) + if (!vx_vmlocked_avail(current->mm, current->mm->total_vm)) + goto out; + if (!(flags & MCL_CURRENT) || (current->mm->total_vm <= lock_limit) || + capable(CAP_IPC_LOCK)) ret = do_mlockall(flags); -out: up_write(¤t->mm->mmap_sem); +out: return ret; } @@ -190,3 +206,36 @@ asmlinkage long sys_munlockall(void) 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; + lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur; + lock_limit >>= PAGE_SHIFT; + spin_lock(&shmlock_user_lock); + if (locked + user->locked_shm > lock_limit && !capable(CAP_IPC_LOCK)) + 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); +}