blob: ace93454ce8ebe10f0b3cf5278aafd0a0d5fe4df [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * mm/mprotect.c
3 *
4 * (C) Copyright 1994 Linus Torvalds
5 * (C) Copyright 2002 Christoph Hellwig
6 *
Alan Cox046c6882009-01-05 14:06:29 +00007 * Address space accounting code <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * (C) Copyright 2002 Red Hat Inc, All Rights Reserved
9 */
10
11#include <linux/mm.h>
12#include <linux/hugetlb.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/shm.h>
14#include <linux/mman.h>
15#include <linux/fs.h>
16#include <linux/highmem.h>
17#include <linux/security.h>
18#include <linux/mempolicy.h>
19#include <linux/personality.h>
20#include <linux/syscalls.h>
Christoph Lameter06972122006-06-23 02:03:35 -070021#include <linux/swap.h>
22#include <linux/swapops.h>
Andrea Arcangelicddb8a52008-07-28 15:46:29 -070023#include <linux/mmu_notifier.h>
KOSAKI Motohiro64cdd542009-01-06 14:39:16 -080024#include <linux/migrate.h>
Ingo Molnarcdd6c482009-09-21 12:02:48 +020025#include <linux/perf_event.h>
Mel Gorman64a9a342014-01-21 15:51:02 -080026#include <linux/ksm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <asm/uaccess.h>
28#include <asm/pgtable.h>
29#include <asm/cacheflush.h>
30#include <asm/tlbflush.h>
31
Mel Gorman1ad9f622014-04-07 15:36:56 -070032/*
33 * For a prot_numa update we only hold mmap_sem for read so there is a
34 * potential race with faulting where a pmd was temporarily none. This
35 * function checks for a transhuge pmd under the appropriate lock. It
36 * returns a pte if it was successfully locked or NULL if it raced with
37 * a transhuge insertion.
38 */
39static pte_t *lock_pte_protection(struct vm_area_struct *vma, pmd_t *pmd,
40 unsigned long addr, int prot_numa, spinlock_t **ptl)
41{
42 pte_t *pte;
43 spinlock_t *pmdl;
44
45 /* !prot_numa is protected by mmap_sem held for write */
46 if (!prot_numa)
47 return pte_offset_map_lock(vma->vm_mm, pmd, addr, ptl);
48
49 pmdl = pmd_lock(vma->vm_mm, pmd);
50 if (unlikely(pmd_trans_huge(*pmd) || pmd_none(*pmd))) {
51 spin_unlock(pmdl);
52 return NULL;
53 }
54
55 pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, ptl);
56 spin_unlock(pmdl);
57 return pte;
58}
59
Mel Gorman4b10e7d2012-10-25 14:16:32 +020060static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
Peter Zijlstrac1e60982006-09-25 23:30:59 -070061 unsigned long addr, unsigned long end, pgprot_t newprot,
Mel Gorman0f19c172013-10-07 11:29:25 +010062 int dirty_accountable, int prot_numa)
Linus Torvalds1da177e2005-04-16 15:20:36 -070063{
Mel Gorman4b10e7d2012-10-25 14:16:32 +020064 struct mm_struct *mm = vma->vm_mm;
Christoph Lameter06972122006-06-23 02:03:35 -070065 pte_t *pte, oldpte;
Hugh Dickins705e87c2005-10-29 18:16:27 -070066 spinlock_t *ptl;
Peter Zijlstra7da4d642012-11-19 03:14:23 +010067 unsigned long pages = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Mel Gorman1ad9f622014-04-07 15:36:56 -070069 pte = lock_pte_protection(vma, pmd, addr, prot_numa, &ptl);
70 if (!pte)
71 return 0;
72
Zachary Amsden6606c3e2006-09-30 23:29:33 -070073 arch_enter_lazy_mmu_mode();
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 do {
Christoph Lameter06972122006-06-23 02:03:35 -070075 oldpte = *pte;
76 if (pte_present(oldpte)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 pte_t ptent;
Mel Gorman4b10e7d2012-10-25 14:16:32 +020078 bool updated = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Mel Gorman4b10e7d2012-10-25 14:16:32 +020080 if (!prot_numa) {
Mel Gorman0c5f83c2013-12-18 17:08:37 -080081 ptent = ptep_modify_prot_start(mm, addr, pte);
Mel Gorman16679182013-12-18 17:08:41 -080082 if (pte_numa(ptent))
83 ptent = pte_mknonnuma(ptent);
Mel Gorman4b10e7d2012-10-25 14:16:32 +020084 ptent = pte_modify(ptent, newprot);
Aneesh Kumar K.V9d85d582014-02-12 09:13:37 +053085 /*
86 * Avoid taking write faults for pages we
87 * know to be dirty.
88 */
Peter Feiner64e45502014-10-13 15:55:46 -070089 if (dirty_accountable && pte_dirty(ptent) &&
90 (pte_soft_dirty(ptent) ||
91 !(vma->vm_flags & VM_SOFTDIRTY)))
Aneesh Kumar K.V9d85d582014-02-12 09:13:37 +053092 ptent = pte_mkwrite(ptent);
93 ptep_modify_prot_commit(mm, addr, pte, ptent);
Mel Gorman4b10e7d2012-10-25 14:16:32 +020094 updated = true;
95 } else {
96 struct page *page;
97
98 page = vm_normal_page(vma, addr, oldpte);
Mel Gorman64a9a342014-01-21 15:51:02 -080099 if (page && !PageKsm(page)) {
Mel Gorman1bc115d2013-10-07 11:29:05 +0100100 if (!pte_numa(oldpte)) {
Aneesh Kumar K.V56eecdb2014-02-12 09:13:38 +0530101 ptep_set_numa(mm, addr, pte);
Mel Gorman4b10e7d2012-10-25 14:16:32 +0200102 updated = true;
103 }
104 }
105 }
Mel Gorman4b10e7d2012-10-25 14:16:32 +0200106 if (updated)
107 pages++;
Konstantin Khlebnikovce1744f2012-03-21 16:33:59 -0700108 } else if (IS_ENABLED(CONFIG_MIGRATION) && !pte_file(oldpte)) {
Christoph Lameter06972122006-06-23 02:03:35 -0700109 swp_entry_t entry = pte_to_swp_entry(oldpte);
110
111 if (is_write_migration_entry(entry)) {
Cyrill Gorcunovc3d16e12013-10-16 13:46:51 -0700112 pte_t newpte;
Christoph Lameter06972122006-06-23 02:03:35 -0700113 /*
114 * A protection check is difficult so
115 * just be safe and disable write
116 */
117 make_migration_entry_read(&entry);
Cyrill Gorcunovc3d16e12013-10-16 13:46:51 -0700118 newpte = swp_entry_to_pte(entry);
119 if (pte_swp_soft_dirty(oldpte))
120 newpte = pte_swp_mksoft_dirty(newpte);
121 set_pte_at(mm, addr, pte, newpte);
Mel Gormane920e142013-10-07 11:28:48 +0100122
123 pages++;
Christoph Lameter06972122006-06-23 02:03:35 -0700124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 }
126 } while (pte++, addr += PAGE_SIZE, addr != end);
Zachary Amsden6606c3e2006-09-30 23:29:33 -0700127 arch_leave_lazy_mmu_mode();
Hugh Dickins705e87c2005-10-29 18:16:27 -0700128 pte_unmap_unlock(pte - 1, ptl);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100129
130 return pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
132
Andrew Morton7d12efa2012-12-18 14:23:17 -0800133static inline unsigned long change_pmd_range(struct vm_area_struct *vma,
134 pud_t *pud, unsigned long addr, unsigned long end,
135 pgprot_t newprot, int dirty_accountable, int prot_numa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
137 pmd_t *pmd;
Rik van Riela5338092014-04-07 15:36:57 -0700138 struct mm_struct *mm = vma->vm_mm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 unsigned long next;
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100140 unsigned long pages = 0;
Mel Gorman72403b42013-11-12 15:08:32 -0800141 unsigned long nr_huge_updates = 0;
Rik van Riela5338092014-04-07 15:36:57 -0700142 unsigned long mni_start = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144 pmd = pmd_offset(pud, addr);
145 do {
Mel Gorman25cbbef2013-10-07 11:29:14 +0100146 unsigned long this_pages;
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 next = pmd_addr_end(addr, end);
Rik van Riel88a9ab62014-04-07 15:36:55 -0700149 if (!pmd_trans_huge(*pmd) && pmd_none_or_clear_bad(pmd))
150 continue;
Rik van Riela5338092014-04-07 15:36:57 -0700151
152 /* invoke the mmu notifier if the pmd is populated */
153 if (!mni_start) {
154 mni_start = addr;
155 mmu_notifier_invalidate_range_start(mm, mni_start, end);
156 }
157
Johannes Weinercd7548a2011-01-13 15:47:04 -0800158 if (pmd_trans_huge(*pmd)) {
159 if (next - addr != HPAGE_PMD_SIZE)
Kirill A. Shutemove1803772012-12-12 13:50:59 -0800160 split_huge_page_pmd(vma, addr, pmd);
Mel Gormanf123d742013-10-07 11:28:49 +0100161 else {
162 int nr_ptes = change_huge_pmd(vma, pmd, addr,
163 newprot, prot_numa);
164
165 if (nr_ptes) {
Mel Gorman72403b42013-11-12 15:08:32 -0800166 if (nr_ptes == HPAGE_PMD_NR) {
167 pages += HPAGE_PMD_NR;
168 nr_huge_updates++;
169 }
Mel Gorman1ad9f622014-04-07 15:36:56 -0700170
171 /* huge pmd was handled */
Mel Gormanf123d742013-10-07 11:28:49 +0100172 continue;
173 }
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100174 }
Rik van Riel88a9ab62014-04-07 15:36:55 -0700175 /* fall through, the trans huge pmd just split */
Johannes Weinercd7548a2011-01-13 15:47:04 -0800176 }
Mel Gorman25cbbef2013-10-07 11:29:14 +0100177 this_pages = change_pte_range(vma, pmd, addr, next, newprot,
Mel Gorman0f19c172013-10-07 11:29:25 +0100178 dirty_accountable, prot_numa);
Mel Gorman25cbbef2013-10-07 11:29:14 +0100179 pages += this_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 } while (pmd++, addr = next, addr != end);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100181
Rik van Riela5338092014-04-07 15:36:57 -0700182 if (mni_start)
183 mmu_notifier_invalidate_range_end(mm, mni_start, end);
184
Mel Gorman72403b42013-11-12 15:08:32 -0800185 if (nr_huge_updates)
186 count_vm_numa_events(NUMA_HUGE_PTE_UPDATES, nr_huge_updates);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100187 return pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188}
189
Andrew Morton7d12efa2012-12-18 14:23:17 -0800190static inline unsigned long change_pud_range(struct vm_area_struct *vma,
191 pgd_t *pgd, unsigned long addr, unsigned long end,
192 pgprot_t newprot, int dirty_accountable, int prot_numa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
194 pud_t *pud;
195 unsigned long next;
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100196 unsigned long pages = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 pud = pud_offset(pgd, addr);
199 do {
200 next = pud_addr_end(addr, end);
201 if (pud_none_or_clear_bad(pud))
202 continue;
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100203 pages += change_pmd_range(vma, pud, addr, next, newprot,
Mel Gorman4b10e7d2012-10-25 14:16:32 +0200204 dirty_accountable, prot_numa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 } while (pud++, addr = next, addr != end);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100206
207 return pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208}
209
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100210static unsigned long change_protection_range(struct vm_area_struct *vma,
Peter Zijlstrac1e60982006-09-25 23:30:59 -0700211 unsigned long addr, unsigned long end, pgprot_t newprot,
Mel Gorman4b10e7d2012-10-25 14:16:32 +0200212 int dirty_accountable, int prot_numa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
214 struct mm_struct *mm = vma->vm_mm;
215 pgd_t *pgd;
216 unsigned long next;
217 unsigned long start = addr;
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100218 unsigned long pages = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220 BUG_ON(addr >= end);
221 pgd = pgd_offset(mm, addr);
222 flush_cache_range(vma, addr, end);
Rik van Riel20841402013-12-18 17:08:44 -0800223 set_tlb_flush_pending(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 do {
225 next = pgd_addr_end(addr, end);
226 if (pgd_none_or_clear_bad(pgd))
227 continue;
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100228 pages += change_pud_range(vma, pgd, addr, next, newprot,
Mel Gorman4b10e7d2012-10-25 14:16:32 +0200229 dirty_accountable, prot_numa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 } while (pgd++, addr = next, addr != end);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100231
Ingo Molnar1233d582012-11-19 03:14:24 +0100232 /* Only flush the TLB if we actually modified any entries: */
233 if (pages)
234 flush_tlb_range(vma, start, end);
Rik van Riel20841402013-12-18 17:08:44 -0800235 clear_tlb_flush_pending(mm);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100236
237 return pages;
238}
239
240unsigned long change_protection(struct vm_area_struct *vma, unsigned long start,
241 unsigned long end, pgprot_t newprot,
Mel Gorman4b10e7d2012-10-25 14:16:32 +0200242 int dirty_accountable, int prot_numa)
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100243{
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100244 unsigned long pages;
245
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100246 if (is_vm_hugetlb_page(vma))
247 pages = hugetlb_change_protection(vma, start, end, newprot);
248 else
Mel Gorman4b10e7d2012-10-25 14:16:32 +0200249 pages = change_protection_range(vma, start, end, newprot, dirty_accountable, prot_numa);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100250
251 return pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252}
253
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700254int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,
256 unsigned long start, unsigned long end, unsigned long newflags)
257{
258 struct mm_struct *mm = vma->vm_mm;
259 unsigned long oldflags = vma->vm_flags;
260 long nrpages = (end - start) >> PAGE_SHIFT;
261 unsigned long charged = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 pgoff_t pgoff;
263 int error;
Peter Zijlstrac1e60982006-09-25 23:30:59 -0700264 int dirty_accountable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 if (newflags == oldflags) {
267 *pprev = vma;
268 return 0;
269 }
270
271 /*
272 * If we make a private mapping writable we increase our commit;
273 * but (without finer accounting) cannot reduce our commit if we
Mel Gorman5a6fe122009-02-10 14:02:27 +0000274 * make it unwritable again. hugetlb mapping were accounted for
275 * even if read-only so there is no need to account for them here
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 */
277 if (newflags & VM_WRITE) {
Mel Gorman5a6fe122009-02-10 14:02:27 +0000278 if (!(oldflags & (VM_ACCOUNT|VM_WRITE|VM_HUGETLB|
Andy Whitcroftcdfd4322008-07-23 21:27:28 -0700279 VM_SHARED|VM_NORESERVE))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 charged = nrpages;
Al Viro191c5422012-02-13 03:58:52 +0000281 if (security_vm_enough_memory_mm(mm, charged))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 return -ENOMEM;
283 newflags |= VM_ACCOUNT;
284 }
285 }
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 /*
288 * First try to merge with previous and/or next vma.
289 */
290 pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
291 *pprev = vma_merge(mm, *pprev, start, end, newflags,
292 vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma));
293 if (*pprev) {
294 vma = *pprev;
295 goto success;
296 }
297
298 *pprev = vma;
299
300 if (start != vma->vm_start) {
301 error = split_vma(mm, vma, start, 1);
302 if (error)
303 goto fail;
304 }
305
306 if (end != vma->vm_end) {
307 error = split_vma(mm, vma, end, 0);
308 if (error)
309 goto fail;
310 }
311
312success:
313 /*
314 * vm_flags and vm_page_prot are protected by the mmap_sem
315 * held in write mode.
316 */
317 vma->vm_flags = newflags;
Peter Feiner64e45502014-10-13 15:55:46 -0700318 dirty_accountable = vma_wants_writenotify(vma);
319 vma_set_page_prot(vma);
Peter Zijlstrad08b3852006-09-25 23:30:57 -0700320
Andrew Morton7d12efa2012-12-18 14:23:17 -0800321 change_protection(vma, start, end, vma->vm_page_prot,
322 dirty_accountable, 0);
Peter Zijlstra7da4d642012-11-19 03:14:23 +0100323
Hugh Dickinsab50b8e2005-10-29 18:15:56 -0700324 vm_stat_account(mm, oldflags, vma->vm_file, -nrpages);
325 vm_stat_account(mm, newflags, vma->vm_file, nrpages);
Pekka Enberg63bfd732010-11-08 21:29:07 +0200326 perf_event_mmap(vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 return 0;
328
329fail:
330 vm_unacct_memory(charged);
331 return error;
332}
333
Heiko Carstens6a6160a2009-01-14 14:14:15 +0100334SYSCALL_DEFINE3(mprotect, unsigned long, start, size_t, len,
335 unsigned long, prot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
337 unsigned long vm_flags, nstart, end, tmp, reqprot;
338 struct vm_area_struct *vma, *prev;
339 int error = -EINVAL;
340 const int grows = prot & (PROT_GROWSDOWN|PROT_GROWSUP);
341 prot &= ~(PROT_GROWSDOWN|PROT_GROWSUP);
342 if (grows == (PROT_GROWSDOWN|PROT_GROWSUP)) /* can't be both */
343 return -EINVAL;
344
345 if (start & ~PAGE_MASK)
346 return -EINVAL;
347 if (!len)
348 return 0;
349 len = PAGE_ALIGN(len);
350 end = start + len;
351 if (end <= start)
352 return -ENOMEM;
Dave Kleikampb845f312008-07-08 00:28:51 +1000353 if (!arch_validate_prot(prot))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return -EINVAL;
355
356 reqprot = prot;
357 /*
358 * Does the application expect PROT_READ to imply PROT_EXEC:
359 */
Hua Zhongb344e052006-06-23 02:03:23 -0700360 if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 prot |= PROT_EXEC;
362
363 vm_flags = calc_vm_prot_bits(prot);
364
365 down_write(&current->mm->mmap_sem);
366
Linus Torvalds097d5912012-03-06 18:23:36 -0800367 vma = find_vma(current->mm, start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 error = -ENOMEM;
369 if (!vma)
370 goto out;
Linus Torvalds097d5912012-03-06 18:23:36 -0800371 prev = vma->vm_prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if (unlikely(grows & PROT_GROWSDOWN)) {
373 if (vma->vm_start >= end)
374 goto out;
375 start = vma->vm_start;
376 error = -EINVAL;
377 if (!(vma->vm_flags & VM_GROWSDOWN))
378 goto out;
Andrew Morton7d12efa2012-12-18 14:23:17 -0800379 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (vma->vm_start > start)
381 goto out;
382 if (unlikely(grows & PROT_GROWSUP)) {
383 end = vma->vm_end;
384 error = -EINVAL;
385 if (!(vma->vm_flags & VM_GROWSUP))
386 goto out;
387 }
388 }
389 if (start > vma->vm_start)
390 prev = vma;
391
392 for (nstart = start ; ; ) {
393 unsigned long newflags;
394
Andrew Morton7d12efa2012-12-18 14:23:17 -0800395 /* Here we know that vma->vm_start <= nstart < vma->vm_end. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Andrew Morton7d12efa2012-12-18 14:23:17 -0800397 newflags = vm_flags;
398 newflags |= (vma->vm_flags & ~(VM_READ | VM_WRITE | VM_EXEC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Paolo 'Blaisorblade' Giarrusso7e2cff42005-09-21 09:55:39 -0700400 /* newflags >> 4 shift VM_MAY% in place of VM_% */
401 if ((newflags & ~(newflags >> 4)) & (VM_READ | VM_WRITE | VM_EXEC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 error = -EACCES;
403 goto out;
404 }
405
406 error = security_file_mprotect(vma, reqprot, prot);
407 if (error)
408 goto out;
409
410 tmp = vma->vm_end;
411 if (tmp > end)
412 tmp = end;
413 error = mprotect_fixup(vma, &prev, nstart, tmp, newflags);
414 if (error)
415 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 nstart = tmp;
417
418 if (nstart < prev->vm_end)
419 nstart = prev->vm_end;
420 if (nstart >= end)
421 goto out;
422
423 vma = prev->vm_next;
424 if (!vma || vma->vm_start != nstart) {
425 error = -ENOMEM;
426 goto out;
427 }
428 }
429out:
430 up_write(&current->mm->mmap_sem);
431 return error;
432}