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