]> bbs.cooldavid.org Git - net-next-2.6.git/blame - mm/vmalloc.c
[PATCH] Fix potential OOPs in blkdev_open()
[net-next-2.6.git] / mm / vmalloc.c
CommitLineData
1da177e4
LT
1/*
2 * linux/mm/vmalloc.c
3 *
4 * Copyright (C) 1993 Linus Torvalds
5 * Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
6 * SMP-safe vmalloc/vfree/ioremap, Tigran Aivazian <tigran@veritas.com>, May 2000
7 * Major rework to support vmap/vunmap, Christoph Hellwig, SGI, August 2002
930fc45a 8 * Numa awareness, Christoph Lameter, SGI, June 2005
1da177e4
LT
9 */
10
11#include <linux/mm.h>
12#include <linux/module.h>
13#include <linux/highmem.h>
14#include <linux/slab.h>
15#include <linux/spinlock.h>
16#include <linux/interrupt.h>
17
18#include <linux/vmalloc.h>
19
20#include <asm/uaccess.h>
21#include <asm/tlbflush.h>
22
23
24DEFINE_RWLOCK(vmlist_lock);
25struct vm_struct *vmlist;
26
b221385b
AB
27static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
28 int node);
29
1da177e4
LT
30static void vunmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end)
31{
32 pte_t *pte;
33
34 pte = pte_offset_kernel(pmd, addr);
35 do {
36 pte_t ptent = ptep_get_and_clear(&init_mm, addr, pte);
37 WARN_ON(!pte_none(ptent) && !pte_present(ptent));
38 } while (pte++, addr += PAGE_SIZE, addr != end);
39}
40
41static inline void vunmap_pmd_range(pud_t *pud, unsigned long addr,
42 unsigned long end)
43{
44 pmd_t *pmd;
45 unsigned long next;
46
47 pmd = pmd_offset(pud, addr);
48 do {
49 next = pmd_addr_end(addr, end);
50 if (pmd_none_or_clear_bad(pmd))
51 continue;
52 vunmap_pte_range(pmd, addr, next);
53 } while (pmd++, addr = next, addr != end);
54}
55
56static inline void vunmap_pud_range(pgd_t *pgd, unsigned long addr,
57 unsigned long end)
58{
59 pud_t *pud;
60 unsigned long next;
61
62 pud = pud_offset(pgd, addr);
63 do {
64 next = pud_addr_end(addr, end);
65 if (pud_none_or_clear_bad(pud))
66 continue;
67 vunmap_pmd_range(pud, addr, next);
68 } while (pud++, addr = next, addr != end);
69}
70
71void unmap_vm_area(struct vm_struct *area)
72{
73 pgd_t *pgd;
74 unsigned long next;
75 unsigned long addr = (unsigned long) area->addr;
76 unsigned long end = addr + area->size;
77
78 BUG_ON(addr >= end);
79 pgd = pgd_offset_k(addr);
80 flush_cache_vunmap(addr, end);
81 do {
82 next = pgd_addr_end(addr, end);
83 if (pgd_none_or_clear_bad(pgd))
84 continue;
85 vunmap_pud_range(pgd, addr, next);
86 } while (pgd++, addr = next, addr != end);
87 flush_tlb_kernel_range((unsigned long) area->addr, end);
88}
89
90static int vmap_pte_range(pmd_t *pmd, unsigned long addr,
91 unsigned long end, pgprot_t prot, struct page ***pages)
92{
93 pte_t *pte;
94
872fec16 95 pte = pte_alloc_kernel(pmd, addr);
1da177e4
LT
96 if (!pte)
97 return -ENOMEM;
98 do {
99 struct page *page = **pages;
100 WARN_ON(!pte_none(*pte));
101 if (!page)
102 return -ENOMEM;
103 set_pte_at(&init_mm, addr, pte, mk_pte(page, prot));
104 (*pages)++;
105 } while (pte++, addr += PAGE_SIZE, addr != end);
106 return 0;
107}
108
109static inline int vmap_pmd_range(pud_t *pud, unsigned long addr,
110 unsigned long end, pgprot_t prot, struct page ***pages)
111{
112 pmd_t *pmd;
113 unsigned long next;
114
115 pmd = pmd_alloc(&init_mm, pud, addr);
116 if (!pmd)
117 return -ENOMEM;
118 do {
119 next = pmd_addr_end(addr, end);
120 if (vmap_pte_range(pmd, addr, next, prot, pages))
121 return -ENOMEM;
122 } while (pmd++, addr = next, addr != end);
123 return 0;
124}
125
126static inline int vmap_pud_range(pgd_t *pgd, unsigned long addr,
127 unsigned long end, pgprot_t prot, struct page ***pages)
128{
129 pud_t *pud;
130 unsigned long next;
131
132 pud = pud_alloc(&init_mm, pgd, addr);
133 if (!pud)
134 return -ENOMEM;
135 do {
136 next = pud_addr_end(addr, end);
137 if (vmap_pmd_range(pud, addr, next, prot, pages))
138 return -ENOMEM;
139 } while (pud++, addr = next, addr != end);
140 return 0;
141}
142
143int map_vm_area(struct vm_struct *area, pgprot_t prot, struct page ***pages)
144{
145 pgd_t *pgd;
146 unsigned long next;
147 unsigned long addr = (unsigned long) area->addr;
148 unsigned long end = addr + area->size - PAGE_SIZE;
149 int err;
150
151 BUG_ON(addr >= end);
152 pgd = pgd_offset_k(addr);
1da177e4
LT
153 do {
154 next = pgd_addr_end(addr, end);
155 err = vmap_pud_range(pgd, addr, next, prot, pages);
156 if (err)
157 break;
158 } while (pgd++, addr = next, addr != end);
1da177e4
LT
159 flush_cache_vmap((unsigned long) area->addr, end);
160 return err;
161}
162
930fc45a
CL
163struct vm_struct *__get_vm_area_node(unsigned long size, unsigned long flags,
164 unsigned long start, unsigned long end, int node)
1da177e4
LT
165{
166 struct vm_struct **p, *tmp, *area;
167 unsigned long align = 1;
168 unsigned long addr;
169
170 if (flags & VM_IOREMAP) {
171 int bit = fls(size);
172
173 if (bit > IOREMAP_MAX_ORDER)
174 bit = IOREMAP_MAX_ORDER;
175 else if (bit < PAGE_SHIFT)
176 bit = PAGE_SHIFT;
177
178 align = 1ul << bit;
179 }
180 addr = ALIGN(start, align);
181 size = PAGE_ALIGN(size);
182
930fc45a 183 area = kmalloc_node(sizeof(*area), GFP_KERNEL, node);
1da177e4
LT
184 if (unlikely(!area))
185 return NULL;
186
187 if (unlikely(!size)) {
188 kfree (area);
189 return NULL;
190 }
191
192 /*
193 * We always allocate a guard page.
194 */
195 size += PAGE_SIZE;
196
197 write_lock(&vmlist_lock);
198 for (p = &vmlist; (tmp = *p) != NULL ;p = &tmp->next) {
199 if ((unsigned long)tmp->addr < addr) {
200 if((unsigned long)tmp->addr + tmp->size >= addr)
201 addr = ALIGN(tmp->size +
202 (unsigned long)tmp->addr, align);
203 continue;
204 }
205 if ((size + addr) < addr)
206 goto out;
207 if (size + addr <= (unsigned long)tmp->addr)
208 goto found;
209 addr = ALIGN(tmp->size + (unsigned long)tmp->addr, align);
210 if (addr > end - size)
211 goto out;
212 }
213
214found:
215 area->next = *p;
216 *p = area;
217
218 area->flags = flags;
219 area->addr = (void *)addr;
220 area->size = size;
221 area->pages = NULL;
222 area->nr_pages = 0;
223 area->phys_addr = 0;
224 write_unlock(&vmlist_lock);
225
226 return area;
227
228out:
229 write_unlock(&vmlist_lock);
230 kfree(area);
231 if (printk_ratelimit())
232 printk(KERN_WARNING "allocation failed: out of vmalloc space - use vmalloc=<size> to increase size.\n");
233 return NULL;
234}
235
930fc45a
CL
236struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
237 unsigned long start, unsigned long end)
238{
239 return __get_vm_area_node(size, flags, start, end, -1);
240}
241
1da177e4
LT
242/**
243 * get_vm_area - reserve a contingous kernel virtual area
1da177e4
LT
244 * @size: size of the area
245 * @flags: %VM_IOREMAP for I/O mappings or VM_ALLOC
246 *
247 * Search an area of @size in the kernel virtual mapping area,
248 * and reserved it for out purposes. Returns the area descriptor
249 * on success or %NULL on failure.
250 */
251struct vm_struct *get_vm_area(unsigned long size, unsigned long flags)
252{
253 return __get_vm_area(size, flags, VMALLOC_START, VMALLOC_END);
254}
255
930fc45a
CL
256struct vm_struct *get_vm_area_node(unsigned long size, unsigned long flags, int node)
257{
258 return __get_vm_area_node(size, flags, VMALLOC_START, VMALLOC_END, node);
259}
260
83342314
NP
261/* Caller must hold vmlist_lock */
262static struct vm_struct *__find_vm_area(void *addr)
263{
264 struct vm_struct *tmp;
265
266 for (tmp = vmlist; tmp != NULL; tmp = tmp->next) {
267 if (tmp->addr == addr)
268 break;
269 }
270
271 return tmp;
272}
273
7856dfeb 274/* Caller must hold vmlist_lock */
d24afc57 275static struct vm_struct *__remove_vm_area(void *addr)
1da177e4
LT
276{
277 struct vm_struct **p, *tmp;
278
1da177e4
LT
279 for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {
280 if (tmp->addr == addr)
281 goto found;
282 }
1da177e4
LT
283 return NULL;
284
285found:
286 unmap_vm_area(tmp);
287 *p = tmp->next;
1da177e4
LT
288
289 /*
290 * Remove the guard page.
291 */
292 tmp->size -= PAGE_SIZE;
293 return tmp;
294}
295
7856dfeb
AK
296/**
297 * remove_vm_area - find and remove a contingous kernel virtual area
7856dfeb
AK
298 * @addr: base address
299 *
300 * Search for the kernel VM area starting at @addr, and remove it.
301 * This function returns the found VM area, but using it is NOT safe
302 * on SMP machines, except for its size or flags.
303 */
304struct vm_struct *remove_vm_area(void *addr)
305{
306 struct vm_struct *v;
307 write_lock(&vmlist_lock);
308 v = __remove_vm_area(addr);
309 write_unlock(&vmlist_lock);
310 return v;
311}
312
1da177e4
LT
313void __vunmap(void *addr, int deallocate_pages)
314{
315 struct vm_struct *area;
316
317 if (!addr)
318 return;
319
320 if ((PAGE_SIZE-1) & (unsigned long)addr) {
321 printk(KERN_ERR "Trying to vfree() bad address (%p)\n", addr);
322 WARN_ON(1);
323 return;
324 }
325
326 area = remove_vm_area(addr);
327 if (unlikely(!area)) {
328 printk(KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
329 addr);
330 WARN_ON(1);
331 return;
332 }
333
9a11b49a
IM
334 debug_check_no_locks_freed(addr, area->size);
335
1da177e4
LT
336 if (deallocate_pages) {
337 int i;
338
339 for (i = 0; i < area->nr_pages; i++) {
5aae277e 340 BUG_ON(!area->pages[i]);
1da177e4
LT
341 __free_page(area->pages[i]);
342 }
343
8757d5fa 344 if (area->flags & VM_VPAGES)
1da177e4
LT
345 vfree(area->pages);
346 else
347 kfree(area->pages);
348 }
349
350 kfree(area);
351 return;
352}
353
354/**
355 * vfree - release memory allocated by vmalloc()
1da177e4
LT
356 * @addr: memory base address
357 *
358 * Free the virtually contiguous memory area starting at @addr, as
80e93eff
PE
359 * obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
360 * NULL, no operation is performed.
1da177e4 361 *
80e93eff 362 * Must not be called in interrupt context.
1da177e4
LT
363 */
364void vfree(void *addr)
365{
366 BUG_ON(in_interrupt());
367 __vunmap(addr, 1);
368}
1da177e4
LT
369EXPORT_SYMBOL(vfree);
370
371/**
372 * vunmap - release virtual mapping obtained by vmap()
1da177e4
LT
373 * @addr: memory base address
374 *
375 * Free the virtually contiguous memory area starting at @addr,
376 * which was created from the page array passed to vmap().
377 *
80e93eff 378 * Must not be called in interrupt context.
1da177e4
LT
379 */
380void vunmap(void *addr)
381{
382 BUG_ON(in_interrupt());
383 __vunmap(addr, 0);
384}
1da177e4
LT
385EXPORT_SYMBOL(vunmap);
386
387/**
388 * vmap - map an array of pages into virtually contiguous space
1da177e4
LT
389 * @pages: array of page pointers
390 * @count: number of pages to map
391 * @flags: vm_area->flags
392 * @prot: page protection for the mapping
393 *
394 * Maps @count pages from @pages into contiguous kernel virtual
395 * space.
396 */
397void *vmap(struct page **pages, unsigned int count,
398 unsigned long flags, pgprot_t prot)
399{
400 struct vm_struct *area;
401
402 if (count > num_physpages)
403 return NULL;
404
405 area = get_vm_area((count << PAGE_SHIFT), flags);
406 if (!area)
407 return NULL;
408 if (map_vm_area(area, prot, &pages)) {
409 vunmap(area->addr);
410 return NULL;
411 }
412
413 return area->addr;
414}
1da177e4
LT
415EXPORT_SYMBOL(vmap);
416
930fc45a
CL
417void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
418 pgprot_t prot, int node)
1da177e4
LT
419{
420 struct page **pages;
421 unsigned int nr_pages, array_size, i;
422
423 nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
424 array_size = (nr_pages * sizeof(struct page *));
425
426 area->nr_pages = nr_pages;
427 /* Please note that the recursion is strictly bounded. */
8757d5fa 428 if (array_size > PAGE_SIZE) {
930fc45a 429 pages = __vmalloc_node(array_size, gfp_mask, PAGE_KERNEL, node);
8757d5fa 430 area->flags |= VM_VPAGES;
286e1ea3
AM
431 } else {
432 pages = kmalloc_node(array_size,
433 (gfp_mask & ~(__GFP_HIGHMEM | __GFP_ZERO)),
434 node);
435 }
1da177e4
LT
436 area->pages = pages;
437 if (!area->pages) {
438 remove_vm_area(area->addr);
439 kfree(area);
440 return NULL;
441 }
442 memset(area->pages, 0, array_size);
443
444 for (i = 0; i < area->nr_pages; i++) {
930fc45a
CL
445 if (node < 0)
446 area->pages[i] = alloc_page(gfp_mask);
447 else
448 area->pages[i] = alloc_pages_node(node, gfp_mask, 0);
1da177e4
LT
449 if (unlikely(!area->pages[i])) {
450 /* Successfully allocated i pages, free them in __vunmap() */
451 area->nr_pages = i;
452 goto fail;
453 }
454 }
455
456 if (map_vm_area(area, prot, &pages))
457 goto fail;
458 return area->addr;
459
460fail:
461 vfree(area->addr);
462 return NULL;
463}
464
930fc45a
CL
465void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask, pgprot_t prot)
466{
467 return __vmalloc_area_node(area, gfp_mask, prot, -1);
468}
469
1da177e4 470/**
930fc45a 471 * __vmalloc_node - allocate virtually contiguous memory
1da177e4
LT
472 * @size: allocation size
473 * @gfp_mask: flags for the page level allocator
474 * @prot: protection mask for the allocated pages
d44e0780 475 * @node: node to use for allocation or -1
1da177e4
LT
476 *
477 * Allocate enough pages to cover @size from the page level
478 * allocator with @gfp_mask flags. Map them into contiguous
479 * kernel virtual space, using a pagetable protection of @prot.
480 */
b221385b
AB
481static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
482 int node)
1da177e4
LT
483{
484 struct vm_struct *area;
485
486 size = PAGE_ALIGN(size);
487 if (!size || (size >> PAGE_SHIFT) > num_physpages)
488 return NULL;
489
930fc45a 490 area = get_vm_area_node(size, VM_ALLOC, node);
1da177e4
LT
491 if (!area)
492 return NULL;
493
930fc45a 494 return __vmalloc_area_node(area, gfp_mask, prot, node);
1da177e4
LT
495}
496
930fc45a
CL
497void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
498{
499 return __vmalloc_node(size, gfp_mask, prot, -1);
500}
1da177e4
LT
501EXPORT_SYMBOL(__vmalloc);
502
503/**
504 * vmalloc - allocate virtually contiguous memory
1da177e4 505 * @size: allocation size
1da177e4
LT
506 * Allocate enough pages to cover @size from the page level
507 * allocator and map them into contiguous kernel virtual space.
508 *
c1c8897f 509 * For tight control over page level allocator and protection flags
1da177e4
LT
510 * use __vmalloc() instead.
511 */
512void *vmalloc(unsigned long size)
513{
83342314 514 return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
1da177e4 515}
1da177e4
LT
516EXPORT_SYMBOL(vmalloc);
517
83342314 518/**
ead04089
REB
519 * vmalloc_user - allocate zeroed virtually contiguous memory for userspace
520 * @size: allocation size
83342314 521 *
ead04089
REB
522 * The resulting memory area is zeroed so it can be mapped to userspace
523 * without leaking data.
83342314
NP
524 */
525void *vmalloc_user(unsigned long size)
526{
527 struct vm_struct *area;
528 void *ret;
529
530 ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
531 write_lock(&vmlist_lock);
532 area = __find_vm_area(ret);
533 area->flags |= VM_USERMAP;
534 write_unlock(&vmlist_lock);
535
536 return ret;
537}
538EXPORT_SYMBOL(vmalloc_user);
539
930fc45a
CL
540/**
541 * vmalloc_node - allocate memory on a specific node
930fc45a 542 * @size: allocation size
d44e0780 543 * @node: numa node
930fc45a
CL
544 *
545 * Allocate enough pages to cover @size from the page level
546 * allocator and map them into contiguous kernel virtual space.
547 *
c1c8897f 548 * For tight control over page level allocator and protection flags
930fc45a
CL
549 * use __vmalloc() instead.
550 */
551void *vmalloc_node(unsigned long size, int node)
552{
83342314 553 return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL, node);
930fc45a
CL
554}
555EXPORT_SYMBOL(vmalloc_node);
556
4dc3b16b
PP
557#ifndef PAGE_KERNEL_EXEC
558# define PAGE_KERNEL_EXEC PAGE_KERNEL
559#endif
560
1da177e4
LT
561/**
562 * vmalloc_exec - allocate virtually contiguous, executable memory
1da177e4
LT
563 * @size: allocation size
564 *
565 * Kernel-internal function to allocate enough pages to cover @size
566 * the page level allocator and map them into contiguous and
567 * executable kernel virtual space.
568 *
c1c8897f 569 * For tight control over page level allocator and protection flags
1da177e4
LT
570 * use __vmalloc() instead.
571 */
572
1da177e4
LT
573void *vmalloc_exec(unsigned long size)
574{
575 return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
576}
577
578/**
579 * vmalloc_32 - allocate virtually contiguous memory (32bit addressable)
1da177e4
LT
580 * @size: allocation size
581 *
582 * Allocate enough 32bit PA addressable pages to cover @size from the
583 * page level allocator and map them into contiguous kernel virtual space.
584 */
585void *vmalloc_32(unsigned long size)
586{
587 return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
588}
1da177e4
LT
589EXPORT_SYMBOL(vmalloc_32);
590
83342314 591/**
ead04089 592 * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
83342314 593 * @size: allocation size
ead04089
REB
594 *
595 * The resulting memory area is 32bit addressable and zeroed so it can be
596 * mapped to userspace without leaking data.
83342314
NP
597 */
598void *vmalloc_32_user(unsigned long size)
599{
600 struct vm_struct *area;
601 void *ret;
602
603 ret = __vmalloc(size, GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL);
604 write_lock(&vmlist_lock);
605 area = __find_vm_area(ret);
606 area->flags |= VM_USERMAP;
607 write_unlock(&vmlist_lock);
608
609 return ret;
610}
611EXPORT_SYMBOL(vmalloc_32_user);
612
1da177e4
LT
613long vread(char *buf, char *addr, unsigned long count)
614{
615 struct vm_struct *tmp;
616 char *vaddr, *buf_start = buf;
617 unsigned long n;
618
619 /* Don't allow overflow */
620 if ((unsigned long) addr + count < count)
621 count = -(unsigned long) addr;
622
623 read_lock(&vmlist_lock);
624 for (tmp = vmlist; tmp; tmp = tmp->next) {
625 vaddr = (char *) tmp->addr;
626 if (addr >= vaddr + tmp->size - PAGE_SIZE)
627 continue;
628 while (addr < vaddr) {
629 if (count == 0)
630 goto finished;
631 *buf = '\0';
632 buf++;
633 addr++;
634 count--;
635 }
636 n = vaddr + tmp->size - PAGE_SIZE - addr;
637 do {
638 if (count == 0)
639 goto finished;
640 *buf = *addr;
641 buf++;
642 addr++;
643 count--;
644 } while (--n > 0);
645 }
646finished:
647 read_unlock(&vmlist_lock);
648 return buf - buf_start;
649}
650
651long vwrite(char *buf, char *addr, unsigned long count)
652{
653 struct vm_struct *tmp;
654 char *vaddr, *buf_start = buf;
655 unsigned long n;
656
657 /* Don't allow overflow */
658 if ((unsigned long) addr + count < count)
659 count = -(unsigned long) addr;
660
661 read_lock(&vmlist_lock);
662 for (tmp = vmlist; tmp; tmp = tmp->next) {
663 vaddr = (char *) tmp->addr;
664 if (addr >= vaddr + tmp->size - PAGE_SIZE)
665 continue;
666 while (addr < vaddr) {
667 if (count == 0)
668 goto finished;
669 buf++;
670 addr++;
671 count--;
672 }
673 n = vaddr + tmp->size - PAGE_SIZE - addr;
674 do {
675 if (count == 0)
676 goto finished;
677 *addr = *buf;
678 buf++;
679 addr++;
680 count--;
681 } while (--n > 0);
682 }
683finished:
684 read_unlock(&vmlist_lock);
685 return buf - buf_start;
686}
83342314
NP
687
688/**
689 * remap_vmalloc_range - map vmalloc pages to userspace
83342314
NP
690 * @vma: vma to cover (map full range of vma)
691 * @addr: vmalloc memory
692 * @pgoff: number of pages into addr before first page to map
693 * @returns: 0 for success, -Exxx on failure
694 *
695 * This function checks that addr is a valid vmalloc'ed area, and
696 * that it is big enough to cover the vma. Will return failure if
697 * that criteria isn't met.
698 *
699 * Similar to remap_pfn_range (see mm/memory.c)
700 */
701int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
702 unsigned long pgoff)
703{
704 struct vm_struct *area;
705 unsigned long uaddr = vma->vm_start;
706 unsigned long usize = vma->vm_end - vma->vm_start;
707 int ret;
708
709 if ((PAGE_SIZE-1) & (unsigned long)addr)
710 return -EINVAL;
711
712 read_lock(&vmlist_lock);
713 area = __find_vm_area(addr);
714 if (!area)
715 goto out_einval_locked;
716
717 if (!(area->flags & VM_USERMAP))
718 goto out_einval_locked;
719
720 if (usize + (pgoff << PAGE_SHIFT) > area->size - PAGE_SIZE)
721 goto out_einval_locked;
722 read_unlock(&vmlist_lock);
723
724 addr += pgoff << PAGE_SHIFT;
725 do {
726 struct page *page = vmalloc_to_page(addr);
727 ret = vm_insert_page(vma, uaddr, page);
728 if (ret)
729 return ret;
730
731 uaddr += PAGE_SIZE;
732 addr += PAGE_SIZE;
733 usize -= PAGE_SIZE;
734 } while (usize > 0);
735
736 /* Prevent "things" like memory migration? VM_flags need a cleanup... */
737 vma->vm_flags |= VM_RESERVED;
738
739 return ret;
740
741out_einval_locked:
742 read_unlock(&vmlist_lock);
743 return -EINVAL;
744}
745EXPORT_SYMBOL(remap_vmalloc_range);
746