mm/mlock.c

   1 /*
   2  *      linux/mm/mlock.c
   3  *
   4  *  (C) Copyright 1995 Linus Torvalds
   5  *  (C) Copyright 2002 Christoph Hellwig
   6  */
   7
   8 #include <linux/capability.h>
   9 #include <linux/mman.h>
  10 #include <linux/mm.h>
  11 #include <linux/mempolicy.h>
  12 #include <linux/syscalls.h>
  13 #include <linux/vs_base.h>
  14 #include <linux/vs_memory.h>
  15
  16
  17 static int mlock_fixup(struct vm_area_struct *vma, struct vm_area_struct **prev,
  18         unsigned long start, unsigned long end, unsigned int newflags)
  19 {
  20         struct mm_struct * mm = vma->vm_mm;
  21         pgoff_t pgoff;
  22         int pages;
  23         int ret = 0;
  24
  25         if (newflags == vma->vm_flags) {
  26                 *prev = vma;
  27                 goto out;
  28         }
  29
  30         pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
  31         *prev = vma_merge(mm, *prev, start, end, newflags, vma->anon_vma,
  32                           vma->vm_file, pgoff, vma_policy(vma));
  33         if (*prev) {
  34                 vma = *prev;
  35                 goto success;
  36         }
  37
  38         *prev = vma;
  39
  40         if (start != vma->vm_start) {
  41                 ret = split_vma(mm, vma, start, 1);
  42                 if (ret)
  43                         goto out;
  44         }
  45
  46         if (end != vma->vm_end) {
  47                 ret = split_vma(mm, vma, end, 0);
  48                 if (ret)
  49                         goto out;
  50         }
  51
  52 success:
  53         /*
  54          * vm_flags is protected by the mmap_sem held in write mode.
  55          * It's okay if try_to_unmap_one unmaps a page just after we
  56          * set VM_LOCKED, make_pages_present below will bring it back.
  57          */
  58         vma->vm_flags = newflags;
  59
  60         /*
  61          * Keep track of amount of locked VM.
  62          */
  63         pages = (end - start) >> PAGE_SHIFT;
  64         if (newflags & VM_LOCKED) {
  65                 pages = -pages;
  66                 if (!(newflags & VM_IO))
  67                         ret = make_pages_present(start, end);
  68         }
  69
  70         vx_vmlocked_sub(mm, pages);
  71 out:
  72         if (ret == -ENOMEM)
  73                 ret = -EAGAIN;
  74         return ret;
  75 }
  76
  77 static int do_mlock(unsigned long start, size_t len, int on)
  78 {
  79         unsigned long nstart, end, tmp;
  80         struct vm_area_struct * vma, * prev;
  81         int error;
  82
  83         len = PAGE_ALIGN(len);
  84         end = start + len;
  85         if (end < start)
  86                 return -EINVAL;
  87         if (end == start)
  88                 return 0;
  89         vma = find_vma_prev(current->mm, start, &prev);
  90         if (!vma || vma->vm_start > start)
  91                 return -ENOMEM;
  92
  93         if (start > vma->vm_start)
  94                 prev = vma;
  95
  96         for (nstart = start ; ; ) {
  97                 unsigned int newflags;
  98
  99                 /* Here we know that  vma->vm_start <= nstart < vma->vm_end. */
 100
 101                 newflags = vma->vm_flags | VM_LOCKED;
 102                 if (!on)
 103                         newflags &= ~VM_LOCKED;
 104
 105                 tmp = vma->vm_end;
 106                 if (tmp > end)
 107                         tmp = end;
 108                 error = mlock_fixup(vma, &prev, nstart, tmp, newflags);
 109                 if (error)
 110                         break;
 111                 nstart = tmp;
 112                 if (nstart < prev->vm_end)
 113                         nstart = prev->vm_end;
 114                 if (nstart >= end)
 115                         break;
 116
 117                 vma = prev->vm_next;
 118                 if (!vma || vma->vm_start != nstart) {
 119                         error = -ENOMEM;
 120                         break;
 121                 }
 122         }
 123         return error;
 124 }
 125
 126 asmlinkage long sys_mlock(unsigned long start, size_t len)
 127 {
 128         unsigned long locked, grow;
 129         unsigned long lock_limit;
 130         int error = -ENOMEM;
 131
 132         if (!can_do_mlock())
 133                 return -EPERM;
 134
 135         down_write(&current->mm->mmap_sem);
 136         len = PAGE_ALIGN(len + (start & ~PAGE_MASK));
 137         start &= PAGE_MASK;
 138
 139         grow = len >> PAGE_SHIFT;
 140         if (!vx_vmlocked_avail(current->mm, grow))
 141                 goto out;
 142         locked = current->mm->locked_vm + grow;
 143
 144         lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
 145         lock_limit >>= PAGE_SHIFT;
 146
 147         /* check against resource limits */
 148         if ((locked <= lock_limit) || capable(CAP_IPC_LOCK))
 149                 error = do_mlock(start, len, 1);
 150 out:
 151         up_write(&current->mm->mmap_sem);
 152         return error;
 153 }
 154
 155 asmlinkage long sys_munlock(unsigned long start, size_t len)
 156 {
 157         int ret;
 158
 159         down_write(&current->mm->mmap_sem);
 160         len = PAGE_ALIGN(len + (start & ~PAGE_MASK));
 161         start &= PAGE_MASK;
 162         ret = do_mlock(start, len, 0);
 163         up_write(&current->mm->mmap_sem);
 164         return ret;
 165 }
 166
 167 static int do_mlockall(int flags)
 168 {
 169         struct vm_area_struct * vma, * prev = NULL;
 170         unsigned int def_flags = 0;
 171
 172         if (flags & MCL_FUTURE)
 173                 def_flags = VM_LOCKED;
 174         current->mm->def_flags = def_flags;
 175         if (flags == MCL_FUTURE)
 176                 goto out;
 177
 178         for (vma = current->mm->mmap; vma ; vma = prev->vm_next) {
 179                 unsigned int newflags;
 180
 181                 newflags = vma->vm_flags | VM_LOCKED;
 182                 if (!(flags & MCL_CURRENT))
 183                         newflags &= ~VM_LOCKED;
 184
 185                 /* Ignore errors */
 186                 mlock_fixup(vma, &prev, vma->vm_start, vma->vm_end, newflags);
 187         }
 188 out:
 189         return 0;
 190 }
 191
 192 asmlinkage long sys_mlockall(int flags)
 193 {
 194         unsigned long lock_limit;
 195         int ret = -EINVAL;
 196
 197         if (!flags || (flags & ~(MCL_CURRENT | MCL_FUTURE)))
 198                 goto out;
 199
 200         ret = -EPERM;
 201         if (!can_do_mlock())
 202                 goto out;
 203
 204         down_write(&current->mm->mmap_sem);
 205
 206         lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
 207         lock_limit >>= PAGE_SHIFT;
 208
 209         ret = -ENOMEM;
 210         if (!vx_vmlocked_avail(current->mm, current->mm->total_vm))
 211                 goto out;
 212         if (!(flags & MCL_CURRENT) || (current->mm->total_vm <= lock_limit) ||
 213             capable(CAP_IPC_LOCK))
 214                 ret = do_mlockall(flags);
 215         up_write(&current->mm->mmap_sem);
 216 out:
 217         return ret;
 218 }
 219
 220 asmlinkage long sys_munlockall(void)
 221 {
 222         int ret;
 223
 224         down_write(&current->mm->mmap_sem);
 225         ret = do_mlockall(0);
 226         up_write(&current->mm->mmap_sem);
 227         return ret;
 228 }
 229
 230 /*
 231  * Objects with different lifetime than processes (SHM_LOCK and SHM_HUGETLB
 232  * shm segments) get accounted against the user_struct instead.
 233  */
 234 static DEFINE_SPINLOCK(shmlock_user_lock);
 235
 236 int user_shm_lock(size_t size, struct user_struct *user)
 237 {
 238         unsigned long lock_limit, locked;
 239         int allowed = 0;
 240
 241         locked = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
 242         lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
 243         lock_limit >>= PAGE_SHIFT;
 244         spin_lock(&shmlock_user_lock);
 245         if (locked + user->locked_shm > lock_limit && !capable(CAP_IPC_LOCK))
 246                 goto out;
 247         get_uid(user);
 248         user->locked_shm += locked;
 249         allowed = 1;
 250 out:
 251         spin_unlock(&shmlock_user_lock);
 252         return allowed;
 253 }
 254
 255 void user_shm_unlock(size_t size, struct user_struct *user)
 256 {
 257         spin_lock(&shmlock_user_lock);
 258         user->locked_shm -= (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
 259         spin_unlock(&shmlock_user_lock);
 260         free_uid(user);
 261 }