Spelling fix: "control" instead of "cotrol"
[linux-2.6.git] / mm / vmalloc.c
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  */
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
24 DEFINE_RWLOCK(vmlist_lock);
25 struct vm_struct *vmlist;
26
27 static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
28                             int node);
29
30 static 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
41 static 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
56 static 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
71 void 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
90 static 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
95         pte = pte_alloc_kernel(pmd, addr);
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
109 static 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
126 static 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
143 int 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);
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);
159         flush_cache_vmap((unsigned long) area->addr, end);
160         return err;
161 }
162
163 struct vm_struct *__get_vm_area_node(unsigned long size, unsigned long flags,
164                                 unsigned long start, unsigned long end, int node)
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
183         area = kmalloc_node(sizeof(*area), GFP_KERNEL, node);
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
214 found:
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
228 out:
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
236 struct 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
242 /**
243  *      get_vm_area  -  reserve a contingous kernel virtual area
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  */
251 struct 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
256 struct 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
261 /* Caller must hold vmlist_lock */
262 static 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
274 /* Caller must hold vmlist_lock */
275 static struct vm_struct *__remove_vm_area(void *addr)
276 {
277         struct vm_struct **p, *tmp;
278
279         for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {
280                  if (tmp->addr == addr)
281                          goto found;
282         }
283         return NULL;
284
285 found:
286         unmap_vm_area(tmp);
287         *p = tmp->next;
288
289         /*
290          * Remove the guard page.
291          */
292         tmp->size -= PAGE_SIZE;
293         return tmp;
294 }
295
296 /**
297  *      remove_vm_area  -  find and remove a contingous kernel virtual area
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  */
304 struct 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
313 void __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
334         debug_check_no_locks_freed(addr, area->size);
335
336         if (deallocate_pages) {
337                 int i;
338
339                 for (i = 0; i < area->nr_pages; i++) {
340                         BUG_ON(!area->pages[i]);
341                         __free_page(area->pages[i]);
342                 }
343
344                 if (area->flags & VM_VPAGES)
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()
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);
370
371 /**
372  *      vunmap  -  release virtual mapping obtained by vmap()
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  *
378  *      Must not be called in interrupt context.
379  */
380 void vunmap(void *addr)
381 {
382         BUG_ON(in_interrupt());
383         __vunmap(addr, 0);
384 }
385 EXPORT_SYMBOL(vunmap);
386
387 /**
388  *      vmap  -  map an array of pages into virtually contiguous space
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  */
397 void *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 }
415 EXPORT_SYMBOL(vmap);
416
417 void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
418                                 pgprot_t prot, int node)
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. */
428         if (array_size > PAGE_SIZE) {
429                 pages = __vmalloc_node(array_size, gfp_mask, PAGE_KERNEL, node);
430                 area->flags |= VM_VPAGES;
431         } else
432                 pages = kmalloc_node(array_size, (gfp_mask & ~__GFP_HIGHMEM), node);
433         area->pages = pages;
434         if (!area->pages) {
435                 remove_vm_area(area->addr);
436                 kfree(area);
437                 return NULL;
438         }
439         memset(area->pages, 0, array_size);
440
441         for (i = 0; i < area->nr_pages; i++) {
442                 if (node < 0)
443                         area->pages[i] = alloc_page(gfp_mask);
444                 else
445                         area->pages[i] = alloc_pages_node(node, gfp_mask, 0);
446                 if (unlikely(!area->pages[i])) {
447                         /* Successfully allocated i pages, free them in __vunmap() */
448                         area->nr_pages = i;
449                         goto fail;
450                 }
451         }
452
453         if (map_vm_area(area, prot, &pages))
454                 goto fail;
455         return area->addr;
456
457 fail:
458         vfree(area->addr);
459         return NULL;
460 }
461
462 void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask, pgprot_t prot)
463 {
464         return __vmalloc_area_node(area, gfp_mask, prot, -1);
465 }
466
467 /**
468  *      __vmalloc_node  -  allocate virtually contiguous memory
469  *      @size:          allocation size
470  *      @gfp_mask:      flags for the page level allocator
471  *      @prot:          protection mask for the allocated pages
472  *      @node:          node to use for allocation or -1
473  *
474  *      Allocate enough pages to cover @size from the page level
475  *      allocator with @gfp_mask flags.  Map them into contiguous
476  *      kernel virtual space, using a pagetable protection of @prot.
477  */
478 static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
479                             int node)
480 {
481         struct vm_struct *area;
482
483         size = PAGE_ALIGN(size);
484         if (!size || (size >> PAGE_SHIFT) > num_physpages)
485                 return NULL;
486
487         area = get_vm_area_node(size, VM_ALLOC, node);
488         if (!area)
489                 return NULL;
490
491         return __vmalloc_area_node(area, gfp_mask, prot, node);
492 }
493
494 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
495 {
496         return __vmalloc_node(size, gfp_mask, prot, -1);
497 }
498 EXPORT_SYMBOL(__vmalloc);
499
500 /**
501  *      vmalloc  -  allocate virtually contiguous memory
502  *      @size:          allocation size
503  *      Allocate enough pages to cover @size from the page level
504  *      allocator and map them into contiguous kernel virtual space.
505  *
506  *      For tight control over page level allocator and protection flags
507  *      use __vmalloc() instead.
508  */
509 void *vmalloc(unsigned long size)
510 {
511         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
512 }
513 EXPORT_SYMBOL(vmalloc);
514
515 /**
516  * vmalloc_user - allocate zeroed virtually contiguous memory for userspace
517  * @size: allocation size
518  *
519  * The resulting memory area is zeroed so it can be mapped to userspace
520  * without leaking data.
521  */
522 void *vmalloc_user(unsigned long size)
523 {
524         struct vm_struct *area;
525         void *ret;
526
527         ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
528         write_lock(&vmlist_lock);
529         area = __find_vm_area(ret);
530         area->flags |= VM_USERMAP;
531         write_unlock(&vmlist_lock);
532
533         return ret;
534 }
535 EXPORT_SYMBOL(vmalloc_user);
536
537 /**
538  *      vmalloc_node  -  allocate memory on a specific node
539  *      @size:          allocation size
540  *      @node:          numa node
541  *
542  *      Allocate enough pages to cover @size from the page level
543  *      allocator and map them into contiguous kernel virtual space.
544  *
545  *      For tight control over page level allocator and protection flags
546  *      use __vmalloc() instead.
547  */
548 void *vmalloc_node(unsigned long size, int node)
549 {
550         return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL, node);
551 }
552 EXPORT_SYMBOL(vmalloc_node);
553
554 #ifndef PAGE_KERNEL_EXEC
555 # define PAGE_KERNEL_EXEC PAGE_KERNEL
556 #endif
557
558 /**
559  *      vmalloc_exec  -  allocate virtually contiguous, executable memory
560  *      @size:          allocation size
561  *
562  *      Kernel-internal function to allocate enough pages to cover @size
563  *      the page level allocator and map them into contiguous and
564  *      executable kernel virtual space.
565  *
566  *      For tight control over page level allocator and protection flags
567  *      use __vmalloc() instead.
568  */
569
570 void *vmalloc_exec(unsigned long size)
571 {
572         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
573 }
574
575 /**
576  *      vmalloc_32  -  allocate virtually contiguous memory (32bit addressable)
577  *      @size:          allocation size
578  *
579  *      Allocate enough 32bit PA addressable pages to cover @size from the
580  *      page level allocator and map them into contiguous kernel virtual space.
581  */
582 void *vmalloc_32(unsigned long size)
583 {
584         return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
585 }
586 EXPORT_SYMBOL(vmalloc_32);
587
588 /**
589  * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
590  *      @size:          allocation size
591  *
592  * The resulting memory area is 32bit addressable and zeroed so it can be
593  * mapped to userspace without leaking data.
594  */
595 void *vmalloc_32_user(unsigned long size)
596 {
597         struct vm_struct *area;
598         void *ret;
599
600         ret = __vmalloc(size, GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL);
601         write_lock(&vmlist_lock);
602         area = __find_vm_area(ret);
603         area->flags |= VM_USERMAP;
604         write_unlock(&vmlist_lock);
605
606         return ret;
607 }
608 EXPORT_SYMBOL(vmalloc_32_user);
609
610 long vread(char *buf, char *addr, unsigned long count)
611 {
612         struct vm_struct *tmp;
613         char *vaddr, *buf_start = buf;
614         unsigned long n;
615
616         /* Don't allow overflow */
617         if ((unsigned long) addr + count < count)
618                 count = -(unsigned long) addr;
619
620         read_lock(&vmlist_lock);
621         for (tmp = vmlist; tmp; tmp = tmp->next) {
622                 vaddr = (char *) tmp->addr;
623                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
624                         continue;
625                 while (addr < vaddr) {
626                         if (count == 0)
627                                 goto finished;
628                         *buf = '\0';
629                         buf++;
630                         addr++;
631                         count--;
632                 }
633                 n = vaddr + tmp->size - PAGE_SIZE - addr;
634                 do {
635                         if (count == 0)
636                                 goto finished;
637                         *buf = *addr;
638                         buf++;
639                         addr++;
640                         count--;
641                 } while (--n > 0);
642         }
643 finished:
644         read_unlock(&vmlist_lock);
645         return buf - buf_start;
646 }
647
648 long vwrite(char *buf, char *addr, unsigned long count)
649 {
650         struct vm_struct *tmp;
651         char *vaddr, *buf_start = buf;
652         unsigned long n;
653
654         /* Don't allow overflow */
655         if ((unsigned long) addr + count < count)
656                 count = -(unsigned long) addr;
657
658         read_lock(&vmlist_lock);
659         for (tmp = vmlist; tmp; tmp = tmp->next) {
660                 vaddr = (char *) tmp->addr;
661                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
662                         continue;
663                 while (addr < vaddr) {
664                         if (count == 0)
665                                 goto finished;
666                         buf++;
667                         addr++;
668                         count--;
669                 }
670                 n = vaddr + tmp->size - PAGE_SIZE - addr;
671                 do {
672                         if (count == 0)
673                                 goto finished;
674                         *addr = *buf;
675                         buf++;
676                         addr++;
677                         count--;
678                 } while (--n > 0);
679         }
680 finished:
681         read_unlock(&vmlist_lock);
682         return buf - buf_start;
683 }
684
685 /**
686  *      remap_vmalloc_range  -  map vmalloc pages to userspace
687  *      @vma:           vma to cover (map full range of vma)
688  *      @addr:          vmalloc memory
689  *      @pgoff:         number of pages into addr before first page to map
690  *      @returns:       0 for success, -Exxx on failure
691  *
692  *      This function checks that addr is a valid vmalloc'ed area, and
693  *      that it is big enough to cover the vma. Will return failure if
694  *      that criteria isn't met.
695  *
696  *      Similar to remap_pfn_range (see mm/memory.c)
697  */
698 int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
699                                                 unsigned long pgoff)
700 {
701         struct vm_struct *area;
702         unsigned long uaddr = vma->vm_start;
703         unsigned long usize = vma->vm_end - vma->vm_start;
704         int ret;
705
706         if ((PAGE_SIZE-1) & (unsigned long)addr)
707                 return -EINVAL;
708
709         read_lock(&vmlist_lock);
710         area = __find_vm_area(addr);
711         if (!area)
712                 goto out_einval_locked;
713
714         if (!(area->flags & VM_USERMAP))
715                 goto out_einval_locked;
716
717         if (usize + (pgoff << PAGE_SHIFT) > area->size - PAGE_SIZE)
718                 goto out_einval_locked;
719         read_unlock(&vmlist_lock);
720
721         addr += pgoff << PAGE_SHIFT;
722         do {
723                 struct page *page = vmalloc_to_page(addr);
724                 ret = vm_insert_page(vma, uaddr, page);
725                 if (ret)
726                         return ret;
727
728                 uaddr += PAGE_SIZE;
729                 addr += PAGE_SIZE;
730                 usize -= PAGE_SIZE;
731         } while (usize > 0);
732
733         /* Prevent "things" like memory migration? VM_flags need a cleanup... */
734         vma->vm_flags |= VM_RESERVED;
735
736         return ret;
737
738 out_einval_locked:
739         read_unlock(&vmlist_lock);
740         return -EINVAL;
741 }
742 EXPORT_SYMBOL(remap_vmalloc_range);
743