ia64/linux-2.6.18-xen.hg

view mm/vmalloc.c @ 452:c7ed6fe5dca0

kexec: dont initialise regions in reserve_memory()

There is no need to initialise efi_memmap_res and boot_param_res in
reserve_memory() for the initial xen domain as it is done in
machine_kexec_setup_resources() using values from the kexec hypercall.

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