[PATCH] mm: fix oom roll-back of __vmalloc_area_node
[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 vunmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end)
28 {
29         pte_t *pte;
30
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 }
37
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;
43
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 }
52
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;
58
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 }
67
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;
74
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 }
86
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;
91
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 }
105
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;
111
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 }
122
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;
128
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 }
139
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;
147
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 }
159
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;
166
167         if (flags & VM_IOREMAP) {
168                 int bit = fls(size);
169
170                 if (bit > IOREMAP_MAX_ORDER)
171                         bit = IOREMAP_MAX_ORDER;
172                 else if (bit < PAGE_SHIFT)
173                         bit = PAGE_SHIFT;
174
175                 align = 1ul << bit;
176         }
177         addr = ALIGN(start, align);
178         size = PAGE_ALIGN(size);
179
180         area = kmalloc_node(sizeof(*area), GFP_KERNEL, node);
181         if (unlikely(!area))
182                 return NULL;
183
184         if (unlikely(!size)) {
185                 kfree (area);
186                 return NULL;
187         }
188
189         /*
190          * We always allocate a guard page.
191          */
192         size += PAGE_SIZE;
193
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         }
210
211 found:
212         area->next = *p;
213         *p = area;
214
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);
222
223         return area;
224
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 }
232
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 }
238
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 }
253
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 }
258
259 /* Caller must hold vmlist_lock */
260 static struct vm_struct *__find_vm_area(void *addr)
261 {
262         struct vm_struct *tmp;
263
264         for (tmp = vmlist; tmp != NULL; tmp = tmp->next) {
265                  if (tmp->addr == addr)
266                         break;
267         }
268
269         return tmp;
270 }
271
272 /* Caller must hold vmlist_lock */
273 struct vm_struct *__remove_vm_area(void *addr)
274 {
275         struct vm_struct **p, *tmp;
276
277         for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {
278                  if (tmp->addr == addr)
279                          goto found;
280         }
281         return NULL;
282
283 found:
284         unmap_vm_area(tmp);
285         *p = tmp->next;
286
287         /*
288          * Remove the guard page.
289          */
290         tmp->size -= PAGE_SIZE;
291         return tmp;
292 }
293
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 }
311
312 void __vunmap(void *addr, int deallocate_pages)
313 {
314         struct vm_struct *area;
315
316         if (!addr)
317                 return;
318
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         }
324
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         }
332
333         debug_check_no_locks_freed(addr, area->size);
334
335         if (deallocate_pages) {
336                 int i;
337
338                 for (i = 0; i < area->nr_pages; i++) {
339                         BUG_ON(!area->pages[i]);
340                         __free_page(area->pages[i]);
341                 }
342
343                 if (area->flags & VM_VPAGES)
344                         vfree(area->pages);
345                 else
346                         kfree(area->pages);
347         }
348
349         kfree(area);
350         return;
351 }
352
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);
370
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);
387
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;
403
404         if (count > num_physpages)
405                 return NULL;
406
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         }
414
415         return area->addr;
416 }
417 EXPORT_SYMBOL(vmap);
418
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;
424
425         nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
426         array_size = (nr_pages * sizeof(struct page *));
427
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);
442
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         }
454
455         if (map_vm_area(area, prot, &pages))
456                 goto fail;
457         return area->addr;
458
459 fail:
460         vfree(area->addr);
461         return NULL;
462 }
463
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 }
468
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;
485
486         size = PAGE_ALIGN(size);
487         if (!size || (size >> PAGE_SHIFT) > num_physpages)
488                 return NULL;
489
490         area = get_vm_area_node(size, VM_ALLOC, node);
491         if (!area)
492                 return NULL;
493
494         return __vmalloc_area_node(area, gfp_mask, prot, node);
495 }
496 EXPORT_SYMBOL(__vmalloc_node);
497
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);
503
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);
520
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;
532
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);
538
539         return ret;
540 }
541 EXPORT_SYMBOL(vmalloc_user);
542
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);
560
561 #ifndef PAGE_KERNEL_EXEC
562 # define PAGE_KERNEL_EXEC PAGE_KERNEL
563 #endif
564
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  */
577
578 void *vmalloc_exec(unsigned long size)
579 {
580         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
581 }
582
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);
596
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;
608
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);
614
615         return ret;
616 }
617 EXPORT_SYMBOL(vmalloc_32_user);
618
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;
624
625         /* Don't allow overflow */
626         if ((unsigned long) addr + count < count)
627                 count = -(unsigned long) addr;
628
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 }
656
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;
662
663         /* Don't allow overflow */
664         if ((unsigned long) addr + count < count)
665                 count = -(unsigned long) addr;
666
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 }
693
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;
715
716         if ((PAGE_SIZE-1) & (unsigned long)addr)
717                 return -EINVAL;
718
719         read_lock(&vmlist_lock);
720         area = __find_vm_area(addr);
721         if (!area)
722                 goto out_einval_locked;
723
724         if (!(area->flags & VM_USERMAP))
725                 goto out_einval_locked;
726
727         if (usize + (pgoff << PAGE_SHIFT) > area->size - PAGE_SIZE)
728                 goto out_einval_locked;
729         read_unlock(&vmlist_lock);
730
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;
737
738                 uaddr += PAGE_SIZE;
739                 addr += PAGE_SIZE;
740                 usize -= PAGE_SIZE;
741         } while (usize > 0);
742
743         /* Prevent "things" like memory migration? VM_flags need a cleanup... */
744         vma->vm_flags |= VM_RESERVED;
745
746         return ret;
747
748 out_einval_locked:
749         read_unlock(&vmlist_lock);
750         return -EINVAL;
751 }
752 EXPORT_SYMBOL(remap_vmalloc_range);
753