[PATCH] x86_64: Fixed guard page handling again in iounmap
[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  */
9
10 #include <linux/mm.h>
11 #include <linux/module.h>
12 #include <linux/highmem.h>
13 #include <linux/slab.h>
14 #include <linux/spinlock.h>
15 #include <linux/interrupt.h>
16
17 #include <linux/vmalloc.h>
18
19 #include <asm/uaccess.h>
20 #include <asm/tlbflush.h>
21
22
23 DEFINE_RWLOCK(vmlist_lock);
24 struct vm_struct *vmlist;
25
26 static void vunmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end)
27 {
28         pte_t *pte;
29
30         pte = pte_offset_kernel(pmd, addr);
31         do {
32                 pte_t ptent = ptep_get_and_clear(&init_mm, addr, pte);
33                 WARN_ON(!pte_none(ptent) && !pte_present(ptent));
34         } while (pte++, addr += PAGE_SIZE, addr != end);
35 }
36
37 static inline void vunmap_pmd_range(pud_t *pud, unsigned long addr,
38                                                 unsigned long end)
39 {
40         pmd_t *pmd;
41         unsigned long next;
42
43         pmd = pmd_offset(pud, addr);
44         do {
45                 next = pmd_addr_end(addr, end);
46                 if (pmd_none_or_clear_bad(pmd))
47                         continue;
48                 vunmap_pte_range(pmd, addr, next);
49         } while (pmd++, addr = next, addr != end);
50 }
51
52 static inline void vunmap_pud_range(pgd_t *pgd, unsigned long addr,
53                                                 unsigned long end)
54 {
55         pud_t *pud;
56         unsigned long next;
57
58         pud = pud_offset(pgd, addr);
59         do {
60                 next = pud_addr_end(addr, end);
61                 if (pud_none_or_clear_bad(pud))
62                         continue;
63                 vunmap_pmd_range(pud, addr, next);
64         } while (pud++, addr = next, addr != end);
65 }
66
67 void unmap_vm_area(struct vm_struct *area)
68 {
69         pgd_t *pgd;
70         unsigned long next;
71         unsigned long addr = (unsigned long) area->addr;
72         unsigned long end = addr + area->size;
73
74         BUG_ON(addr >= end);
75         pgd = pgd_offset_k(addr);
76         flush_cache_vunmap(addr, end);
77         do {
78                 next = pgd_addr_end(addr, end);
79                 if (pgd_none_or_clear_bad(pgd))
80                         continue;
81                 vunmap_pud_range(pgd, addr, next);
82         } while (pgd++, addr = next, addr != end);
83         flush_tlb_kernel_range((unsigned long) area->addr, end);
84 }
85
86 static int vmap_pte_range(pmd_t *pmd, unsigned long addr,
87                         unsigned long end, pgprot_t prot, struct page ***pages)
88 {
89         pte_t *pte;
90
91         pte = pte_alloc_kernel(&init_mm, pmd, addr);
92         if (!pte)
93                 return -ENOMEM;
94         do {
95                 struct page *page = **pages;
96                 WARN_ON(!pte_none(*pte));
97                 if (!page)
98                         return -ENOMEM;
99                 set_pte_at(&init_mm, addr, pte, mk_pte(page, prot));
100                 (*pages)++;
101         } while (pte++, addr += PAGE_SIZE, addr != end);
102         return 0;
103 }
104
105 static inline int vmap_pmd_range(pud_t *pud, unsigned long addr,
106                         unsigned long end, pgprot_t prot, struct page ***pages)
107 {
108         pmd_t *pmd;
109         unsigned long next;
110
111         pmd = pmd_alloc(&init_mm, pud, addr);
112         if (!pmd)
113                 return -ENOMEM;
114         do {
115                 next = pmd_addr_end(addr, end);
116                 if (vmap_pte_range(pmd, addr, next, prot, pages))
117                         return -ENOMEM;
118         } while (pmd++, addr = next, addr != end);
119         return 0;
120 }
121
122 static inline int vmap_pud_range(pgd_t *pgd, unsigned long addr,
123                         unsigned long end, pgprot_t prot, struct page ***pages)
124 {
125         pud_t *pud;
126         unsigned long next;
127
128         pud = pud_alloc(&init_mm, pgd, addr);
129         if (!pud)
130                 return -ENOMEM;
131         do {
132                 next = pud_addr_end(addr, end);
133                 if (vmap_pmd_range(pud, addr, next, prot, pages))
134                         return -ENOMEM;
135         } while (pud++, addr = next, addr != end);
136         return 0;
137 }
138
139 int map_vm_area(struct vm_struct *area, pgprot_t prot, struct page ***pages)
140 {
141         pgd_t *pgd;
142         unsigned long next;
143         unsigned long addr = (unsigned long) area->addr;
144         unsigned long end = addr + area->size - PAGE_SIZE;
145         int err;
146
147         BUG_ON(addr >= end);
148         pgd = pgd_offset_k(addr);
149         spin_lock(&init_mm.page_table_lock);
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         spin_unlock(&init_mm.page_table_lock);
157         flush_cache_vmap((unsigned long) area->addr, end);
158         return err;
159 }
160
161 #define IOREMAP_MAX_ORDER       (7 + PAGE_SHIFT)        /* 128 pages */
162
163 struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
164                                 unsigned long start, unsigned long end)
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(sizeof(*area), GFP_KERNEL);
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 /**
237  *      get_vm_area  -  reserve a contingous kernel virtual area
238  *
239  *      @size:          size of the area
240  *      @flags:         %VM_IOREMAP for I/O mappings or VM_ALLOC
241  *
242  *      Search an area of @size in the kernel virtual mapping area,
243  *      and reserved it for out purposes.  Returns the area descriptor
244  *      on success or %NULL on failure.
245  */
246 struct vm_struct *get_vm_area(unsigned long size, unsigned long flags)
247 {
248         return __get_vm_area(size, flags, VMALLOC_START, VMALLOC_END);
249 }
250
251 /* Caller must hold vmlist_lock */
252 struct vm_struct *__remove_vm_area(void *addr)
253 {
254         struct vm_struct **p, *tmp;
255
256         for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {
257                  if (tmp->addr == addr)
258                          goto found;
259         }
260         return NULL;
261
262 found:
263         unmap_vm_area(tmp);
264         *p = tmp->next;
265
266         /*
267          * Remove the guard page.
268          */
269         tmp->size -= PAGE_SIZE;
270         return tmp;
271 }
272
273 /**
274  *      remove_vm_area  -  find and remove a contingous kernel virtual area
275  *
276  *      @addr:          base address
277  *
278  *      Search for the kernel VM area starting at @addr, and remove it.
279  *      This function returns the found VM area, but using it is NOT safe
280  *      on SMP machines, except for its size or flags.
281  */
282 struct vm_struct *remove_vm_area(void *addr)
283 {
284         struct vm_struct *v;
285         write_lock(&vmlist_lock);
286         v = __remove_vm_area(addr);
287         write_unlock(&vmlist_lock);
288         return v;
289 }
290
291 void __vunmap(void *addr, int deallocate_pages)
292 {
293         struct vm_struct *area;
294
295         if (!addr)
296                 return;
297
298         if ((PAGE_SIZE-1) & (unsigned long)addr) {
299                 printk(KERN_ERR "Trying to vfree() bad address (%p)\n", addr);
300                 WARN_ON(1);
301                 return;
302         }
303
304         area = remove_vm_area(addr);
305         if (unlikely(!area)) {
306                 printk(KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
307                                 addr);
308                 WARN_ON(1);
309                 return;
310         }
311
312         if (deallocate_pages) {
313                 int i;
314
315                 for (i = 0; i < area->nr_pages; i++) {
316                         if (unlikely(!area->pages[i]))
317                                 BUG();
318                         __free_page(area->pages[i]);
319                 }
320
321                 if (area->nr_pages > PAGE_SIZE/sizeof(struct page *))
322                         vfree(area->pages);
323                 else
324                         kfree(area->pages);
325         }
326
327         kfree(area);
328         return;
329 }
330
331 /**
332  *      vfree  -  release memory allocated by vmalloc()
333  *
334  *      @addr:          memory base address
335  *
336  *      Free the virtually contiguous memory area starting at @addr, as
337  *      obtained from vmalloc(), vmalloc_32() or __vmalloc().
338  *
339  *      May not be called in interrupt context.
340  */
341 void vfree(void *addr)
342 {
343         BUG_ON(in_interrupt());
344         __vunmap(addr, 1);
345 }
346
347 EXPORT_SYMBOL(vfree);
348
349 /**
350  *      vunmap  -  release virtual mapping obtained by vmap()
351  *
352  *      @addr:          memory base address
353  *
354  *      Free the virtually contiguous memory area starting at @addr,
355  *      which was created from the page array passed to vmap().
356  *
357  *      May not be called in interrupt context.
358  */
359 void vunmap(void *addr)
360 {
361         BUG_ON(in_interrupt());
362         __vunmap(addr, 0);
363 }
364
365 EXPORT_SYMBOL(vunmap);
366
367 /**
368  *      vmap  -  map an array of pages into virtually contiguous space
369  *
370  *      @pages:         array of page pointers
371  *      @count:         number of pages to map
372  *      @flags:         vm_area->flags
373  *      @prot:          page protection for the mapping
374  *
375  *      Maps @count pages from @pages into contiguous kernel virtual
376  *      space.
377  */
378 void *vmap(struct page **pages, unsigned int count,
379                 unsigned long flags, pgprot_t prot)
380 {
381         struct vm_struct *area;
382
383         if (count > num_physpages)
384                 return NULL;
385
386         area = get_vm_area((count << PAGE_SHIFT), flags);
387         if (!area)
388                 return NULL;
389         if (map_vm_area(area, prot, &pages)) {
390                 vunmap(area->addr);
391                 return NULL;
392         }
393
394         return area->addr;
395 }
396
397 EXPORT_SYMBOL(vmap);
398
399 void *__vmalloc_area(struct vm_struct *area, unsigned int __nocast gfp_mask, pgprot_t prot)
400 {
401         struct page **pages;
402         unsigned int nr_pages, array_size, i;
403
404         nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
405         array_size = (nr_pages * sizeof(struct page *));
406
407         area->nr_pages = nr_pages;
408         /* Please note that the recursion is strictly bounded. */
409         if (array_size > PAGE_SIZE)
410                 pages = __vmalloc(array_size, gfp_mask, PAGE_KERNEL);
411         else
412                 pages = kmalloc(array_size, (gfp_mask & ~__GFP_HIGHMEM));
413         area->pages = pages;
414         if (!area->pages) {
415                 remove_vm_area(area->addr);
416                 kfree(area);
417                 return NULL;
418         }
419         memset(area->pages, 0, array_size);
420
421         for (i = 0; i < area->nr_pages; i++) {
422                 area->pages[i] = alloc_page(gfp_mask);
423                 if (unlikely(!area->pages[i])) {
424                         /* Successfully allocated i pages, free them in __vunmap() */
425                         area->nr_pages = i;
426                         goto fail;
427                 }
428         }
429
430         if (map_vm_area(area, prot, &pages))
431                 goto fail;
432         return area->addr;
433
434 fail:
435         vfree(area->addr);
436         return NULL;
437 }
438
439 /**
440  *      __vmalloc  -  allocate virtually contiguous memory
441  *
442  *      @size:          allocation size
443  *      @gfp_mask:      flags for the page level allocator
444  *      @prot:          protection mask for the allocated pages
445  *
446  *      Allocate enough pages to cover @size from the page level
447  *      allocator with @gfp_mask flags.  Map them into contiguous
448  *      kernel virtual space, using a pagetable protection of @prot.
449  */
450 void *__vmalloc(unsigned long size, unsigned int __nocast gfp_mask, pgprot_t prot)
451 {
452         struct vm_struct *area;
453
454         size = PAGE_ALIGN(size);
455         if (!size || (size >> PAGE_SHIFT) > num_physpages)
456                 return NULL;
457
458         area = get_vm_area(size, VM_ALLOC);
459         if (!area)
460                 return NULL;
461
462         return __vmalloc_area(area, gfp_mask, prot);
463 }
464
465 EXPORT_SYMBOL(__vmalloc);
466
467 /**
468  *      vmalloc  -  allocate virtually contiguous memory
469  *
470  *      @size:          allocation size
471  *
472  *      Allocate enough pages to cover @size from the page level
473  *      allocator and map them into contiguous kernel virtual space.
474  *
475  *      For tight cotrol over page level allocator and protection flags
476  *      use __vmalloc() instead.
477  */
478 void *vmalloc(unsigned long size)
479 {
480        return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
481 }
482
483 EXPORT_SYMBOL(vmalloc);
484
485 #ifndef PAGE_KERNEL_EXEC
486 # define PAGE_KERNEL_EXEC PAGE_KERNEL
487 #endif
488
489 /**
490  *      vmalloc_exec  -  allocate virtually contiguous, executable memory
491  *
492  *      @size:          allocation size
493  *
494  *      Kernel-internal function to allocate enough pages to cover @size
495  *      the page level allocator and map them into contiguous and
496  *      executable kernel virtual space.
497  *
498  *      For tight cotrol over page level allocator and protection flags
499  *      use __vmalloc() instead.
500  */
501
502 void *vmalloc_exec(unsigned long size)
503 {
504         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
505 }
506
507 /**
508  *      vmalloc_32  -  allocate virtually contiguous memory (32bit addressable)
509  *
510  *      @size:          allocation size
511  *
512  *      Allocate enough 32bit PA addressable pages to cover @size from the
513  *      page level allocator and map them into contiguous kernel virtual space.
514  */
515 void *vmalloc_32(unsigned long size)
516 {
517         return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
518 }
519
520 EXPORT_SYMBOL(vmalloc_32);
521
522 long vread(char *buf, char *addr, unsigned long count)
523 {
524         struct vm_struct *tmp;
525         char *vaddr, *buf_start = buf;
526         unsigned long n;
527
528         /* Don't allow overflow */
529         if ((unsigned long) addr + count < count)
530                 count = -(unsigned long) addr;
531
532         read_lock(&vmlist_lock);
533         for (tmp = vmlist; tmp; tmp = tmp->next) {
534                 vaddr = (char *) tmp->addr;
535                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
536                         continue;
537                 while (addr < vaddr) {
538                         if (count == 0)
539                                 goto finished;
540                         *buf = '\0';
541                         buf++;
542                         addr++;
543                         count--;
544                 }
545                 n = vaddr + tmp->size - PAGE_SIZE - addr;
546                 do {
547                         if (count == 0)
548                                 goto finished;
549                         *buf = *addr;
550                         buf++;
551                         addr++;
552                         count--;
553                 } while (--n > 0);
554         }
555 finished:
556         read_unlock(&vmlist_lock);
557         return buf - buf_start;
558 }
559
560 long vwrite(char *buf, char *addr, unsigned long count)
561 {
562         struct vm_struct *tmp;
563         char *vaddr, *buf_start = buf;
564         unsigned long n;
565
566         /* Don't allow overflow */
567         if ((unsigned long) addr + count < count)
568                 count = -(unsigned long) addr;
569
570         read_lock(&vmlist_lock);
571         for (tmp = vmlist; tmp; tmp = tmp->next) {
572                 vaddr = (char *) tmp->addr;
573                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
574                         continue;
575                 while (addr < vaddr) {
576                         if (count == 0)
577                                 goto finished;
578                         buf++;
579                         addr++;
580                         count--;
581                 }
582                 n = vaddr + tmp->size - PAGE_SIZE - addr;
583                 do {
584                         if (count == 0)
585                                 goto finished;
586                         *addr = *buf;
587                         buf++;
588                         addr++;
589                         count--;
590                 } while (--n > 0);
591         }
592 finished:
593         read_unlock(&vmlist_lock);
594         return buf - buf_start;
595 }