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