git.oblomov.eu Git - linux-2.6/blob - 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/vmalloc.h>
  12 #include <linux/mm.h>
  13 #include <linux/module.h>
  14 #include <linux/highmem.h>
  15 #include <linux/slab.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/debugobjects.h>
  21 #include <linux/kallsyms.h>
  22 #include <linux/list.h>
  23 #include <linux/rbtree.h>
  24 #include <linux/radix-tree.h>
  25 #include <linux/rcupdate.h>
  26
  27 #include <asm/atomic.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/tlbflush.h>
  30
  31
  32 /*** Page table manipulation functions ***/
  33
  34 static void vunmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end)
  35 {
  36         pte_t *pte;
  37
  38         pte = pte_offset_kernel(pmd, addr);
  39         do {
  40                 pte_t ptent = ptep_get_and_clear(&init_mm, addr, pte);
  41                 WARN_ON(!pte_none(ptent) && !pte_present(ptent));
  42         } while (pte++, addr += PAGE_SIZE, addr != end);
  43 }
  44
  45 static void vunmap_pmd_range(pud_t *pud, unsigned long addr, unsigned long end)
  46 {
  47         pmd_t *pmd;
  48         unsigned long next;
  49
  50         pmd = pmd_offset(pud, addr);
  51         do {
  52                 next = pmd_addr_end(addr, end);
  53                 if (pmd_none_or_clear_bad(pmd))
  54                         continue;
  55                 vunmap_pte_range(pmd, addr, next);
  56         } while (pmd++, addr = next, addr != end);
  57 }
  58
  59 static void vunmap_pud_range(pgd_t *pgd, unsigned long addr, unsigned long end)
  60 {
  61         pud_t *pud;
  62         unsigned long next;
  63
  64         pud = pud_offset(pgd, addr);
  65         do {
  66                 next = pud_addr_end(addr, end);
  67                 if (pud_none_or_clear_bad(pud))
  68                         continue;
  69                 vunmap_pmd_range(pud, addr, next);
  70         } while (pud++, addr = next, addr != end);
  71 }
  72
  73 static void vunmap_page_range(unsigned long addr, unsigned long end)
  74 {
  75         pgd_t *pgd;
  76         unsigned long next;
  77
  78         BUG_ON(addr >= end);
  79         pgd = pgd_offset_k(addr);
  80         do {
  81                 next = pgd_addr_end(addr, end);
  82                 if (pgd_none_or_clear_bad(pgd))
  83                         continue;
  84                 vunmap_pud_range(pgd, addr, next);
  85         } while (pgd++, addr = next, addr != end);
  86 }
  87
  88 static int vmap_pte_range(pmd_t *pmd, unsigned long addr,
  89                 unsigned long end, pgprot_t prot, struct page **pages, int *nr)
  90 {
  91         pte_t *pte;
  92
  93         /*
  94          * nr is a running index into the array which helps higher level
  95          * callers keep track of where we're up to.
  96          */
  97
  98         pte = pte_alloc_kernel(pmd, addr);
  99         if (!pte)
 100                 return -ENOMEM;
 101         do {
 102                 struct page *page = pages[*nr];
 103
 104                 if (WARN_ON(!pte_none(*pte)))
 105                         return -EBUSY;
 106                 if (WARN_ON(!page))
 107                         return -ENOMEM;
 108                 set_pte_at(&init_mm, addr, pte, mk_pte(page, prot));
 109                 (*nr)++;
 110         } while (pte++, addr += PAGE_SIZE, addr != end);
 111         return 0;
 112 }
 113
 114 static int vmap_pmd_range(pud_t *pud, unsigned long addr,
 115                 unsigned long end, pgprot_t prot, struct page **pages, int *nr)
 116 {
 117         pmd_t *pmd;
 118         unsigned long next;
 119
 120         pmd = pmd_alloc(&init_mm, pud, addr);
 121         if (!pmd)
 122                 return -ENOMEM;
 123         do {
 124                 next = pmd_addr_end(addr, end);
 125                 if (vmap_pte_range(pmd, addr, next, prot, pages, nr))
 126                         return -ENOMEM;
 127         } while (pmd++, addr = next, addr != end);
 128         return 0;
 129 }
 130
 131 static int vmap_pud_range(pgd_t *pgd, unsigned long addr,
 132                 unsigned long end, pgprot_t prot, struct page **pages, int *nr)
 133 {
 134         pud_t *pud;
 135         unsigned long next;
 136
 137         pud = pud_alloc(&init_mm, pgd, addr);
 138         if (!pud)
 139                 return -ENOMEM;
 140         do {
 141                 next = pud_addr_end(addr, end);
 142                 if (vmap_pmd_range(pud, addr, next, prot, pages, nr))
 143                         return -ENOMEM;
 144         } while (pud++, addr = next, addr != end);
 145         return 0;
 146 }
 147
 148 /*
 149  * Set up page tables in kva (addr, end). The ptes shall have prot "prot", and
 150  * will have pfns corresponding to the "pages" array.
 151  *
 152  * Ie. pte at addr+N*PAGE_SIZE shall point to pfn corresponding to pages[N]
 153  */
 154 static int vmap_page_range(unsigned long start, unsigned long end,
 155                                 pgprot_t prot, struct page **pages)
 156 {
 157         pgd_t *pgd;
 158         unsigned long next;
 159         unsigned long addr = start;
 160         int err = 0;
 161         int nr = 0;
 162
 163         BUG_ON(addr >= end);
 164         pgd = pgd_offset_k(addr);
 165         do {
 166                 next = pgd_addr_end(addr, end);
 167                 err = vmap_pud_range(pgd, addr, next, prot, pages, &nr);
 168                 if (err)
 169                         break;
 170         } while (pgd++, addr = next, addr != end);
 171         flush_cache_vmap(start, end);
 172
 173         if (unlikely(err))
 174                 return err;
 175         return nr;
 176 }
 177
 178 static inline int is_vmalloc_or_module_addr(const void *x)
 179 {
 180         /*
 181          * ARM, x86-64 and sparc64 put modules in a special place,
 182          * and fall back on vmalloc() if that fails. Others
 183          * just put it in the vmalloc space.
 184          */
 185 #if defined(CONFIG_MODULES) && defined(MODULES_VADDR)
 186         unsigned long addr = (unsigned long)x;
 187         if (addr >= MODULES_VADDR && addr < MODULES_END)
 188                 return 1;
 189 #endif
 190         return is_vmalloc_addr(x);
 191 }
 192
 193 /*
 194  * Walk a vmap address to the struct page it maps.
 195  */
 196 struct page *vmalloc_to_page(const void *vmalloc_addr)
 197 {
 198         unsigned long addr = (unsigned long) vmalloc_addr;
 199         struct page *page = NULL;
 200         pgd_t *pgd = pgd_offset_k(addr);
 201
 202         /*
 203          * XXX we might need to change this if we add VIRTUAL_BUG_ON for
 204          * architectures that do not vmalloc module space
 205          */
 206         VIRTUAL_BUG_ON(!is_vmalloc_or_module_addr(vmalloc_addr));
 207
 208         if (!pgd_none(*pgd)) {
 209                 pud_t *pud = pud_offset(pgd, addr);
 210                 if (!pud_none(*pud)) {
 211                         pmd_t *pmd = pmd_offset(pud, addr);
 212                         if (!pmd_none(*pmd)) {
 213                                 pte_t *ptep, pte;
 214
 215                                 ptep = pte_offset_map(pmd, addr);
 216                                 pte = *ptep;
 217                                 if (pte_present(pte))
 218                                         page = pte_page(pte);
 219                                 pte_unmap(ptep);
 220                         }
 221                 }
 222         }
 223         return page;
 224 }
 225 EXPORT_SYMBOL(vmalloc_to_page);
 226
 227 /*
 228  * Map a vmalloc()-space virtual address to the physical page frame number.
 229  */
 230 unsigned long vmalloc_to_pfn(const void *vmalloc_addr)
 231 {
 232         return page_to_pfn(vmalloc_to_page(vmalloc_addr));
 233 }
 234 EXPORT_SYMBOL(vmalloc_to_pfn);
 235
 236
 237 /*** Global kva allocator ***/
 238
 239 #define VM_LAZY_FREE    0x01
 240 #define VM_LAZY_FREEING 0x02
 241 #define VM_VM_AREA      0x04
 242
 243 struct vmap_area {
 244         unsigned long va_start;
 245         unsigned long va_end;
 246         unsigned long flags;
 247         struct rb_node rb_node;         /* address sorted rbtree */
 248         struct list_head list;          /* address sorted list */
 249         struct list_head purge_list;    /* "lazy purge" list */
 250         void *private;
 251         struct rcu_head rcu_head;
 252 };
 253
 254 static DEFINE_SPINLOCK(vmap_area_lock);
 255 static struct rb_root vmap_area_root = RB_ROOT;
 256 static LIST_HEAD(vmap_area_list);
 257
 258 static struct vmap_area *__find_vmap_area(unsigned long addr)
 259 {
 260         struct rb_node *n = vmap_area_root.rb_node;
 261
 262         while (n) {
 263                 struct vmap_area *va;
 264
 265                 va = rb_entry(n, struct vmap_area, rb_node);
 266                 if (addr < va->va_start)
 267                         n = n->rb_left;
 268                 else if (addr > va->va_start)
 269                         n = n->rb_right;
 270                 else
 271                         return va;
 272         }
 273
 274         return NULL;
 275 }
 276
 277 static void __insert_vmap_area(struct vmap_area *va)
 278 {
 279         struct rb_node **p = &vmap_area_root.rb_node;
 280         struct rb_node *parent = NULL;
 281         struct rb_node *tmp;
 282
 283         while (*p) {
 284                 struct vmap_area *tmp;
 285
 286                 parent = *p;
 287                 tmp = rb_entry(parent, struct vmap_area, rb_node);
 288                 if (va->va_start < tmp->va_end)
 289                         p = &(*p)->rb_left;
 290                 else if (va->va_end > tmp->va_start)
 291                         p = &(*p)->rb_right;
 292                 else
 293                         BUG();
 294         }
 295
 296         rb_link_node(&va->rb_node, parent, p);
 297         rb_insert_color(&va->rb_node, &vmap_area_root);
 298
 299         /* address-sort this list so it is usable like the vmlist */
 300         tmp = rb_prev(&va->rb_node);
 301         if (tmp) {
 302                 struct vmap_area *prev;
 303                 prev = rb_entry(tmp, struct vmap_area, rb_node);
 304                 list_add_rcu(&va->list, &prev->list);
 305         } else
 306                 list_add_rcu(&va->list, &vmap_area_list);
 307 }
 308
 309 static void purge_vmap_area_lazy(void);
 310
 311 /*
 312  * Allocate a region of KVA of the specified size and alignment, within the
 313  * vstart and vend.
 314  */
 315 static struct vmap_area *alloc_vmap_area(unsigned long size,
 316                                 unsigned long align,
 317                                 unsigned long vstart, unsigned long vend,
 318                                 int node, gfp_t gfp_mask)
 319 {
 320         struct vmap_area *va;
 321         struct rb_node *n;
 322         unsigned long addr;
 323         int purged = 0;
 324
 325         BUG_ON(size & ~PAGE_MASK);
 326
 327         va = kmalloc_node(sizeof(struct vmap_area),
 328                         gfp_mask & GFP_RECLAIM_MASK, node);
 329         if (unlikely(!va))
 330                 return ERR_PTR(-ENOMEM);
 331
 332 retry:
 333         addr = ALIGN(vstart, align);
 334
 335         spin_lock(&vmap_area_lock);
 336         /* XXX: could have a last_hole cache */
 337         n = vmap_area_root.rb_node;
 338         if (n) {
 339                 struct vmap_area *first = NULL;
 340
 341                 do {
 342                         struct vmap_area *tmp;
 343                         tmp = rb_entry(n, struct vmap_area, rb_node);
 344                         if (tmp->va_end >= addr) {
 345                                 if (!first && tmp->va_start < addr + size)
 346                                         first = tmp;
 347                                 n = n->rb_left;
 348                         } else {
 349                                 first = tmp;
 350                                 n = n->rb_right;
 351                         }
 352                 } while (n);
 353
 354                 if (!first)
 355                         goto found;
 356
 357                 if (first->va_end < addr) {
 358                         n = rb_next(&first->rb_node);
 359                         if (n)
 360                                 first = rb_entry(n, struct vmap_area, rb_node);
 361                         else
 362                                 goto found;
 363                 }
 364
 365                 while (addr + size > first->va_start && addr + size <= vend) {
 366                         addr = ALIGN(first->va_end + PAGE_SIZE, align);
 367
 368                         n = rb_next(&first->rb_node);
 369                         if (n)
 370                                 first = rb_entry(n, struct vmap_area, rb_node);
 371                         else
 372                                 goto found;
 373                 }
 374         }
 375 found:
 376         if (addr + size > vend) {
 377                 spin_unlock(&vmap_area_lock);
 378                 if (!purged) {
 379                         purge_vmap_area_lazy();
 380                         purged = 1;
 381                         goto retry;
 382                 }
 383                 if (printk_ratelimit())
 384                         printk(KERN_WARNING "vmap allocation failed: "
 385                                  "use vmalloc=<size> to increase size.\n");
 386                 return ERR_PTR(-EBUSY);
 387         }
 388
 389         BUG_ON(addr & (align-1));
 390
 391         va->va_start = addr;
 392         va->va_end = addr + size;
 393         va->flags = 0;
 394         __insert_vmap_area(va);
 395         spin_unlock(&vmap_area_lock);
 396
 397         return va;
 398 }
 399
 400 static void rcu_free_va(struct rcu_head *head)
 401 {
 402         struct vmap_area *va = container_of(head, struct vmap_area, rcu_head);
 403
 404         kfree(va);
 405 }
 406
 407 static void __free_vmap_area(struct vmap_area *va)
 408 {
 409         BUG_ON(RB_EMPTY_NODE(&va->rb_node));
 410         rb_erase(&va->rb_node, &vmap_area_root);
 411         RB_CLEAR_NODE(&va->rb_node);
 412         list_del_rcu(&va->list);
 413
 414         call_rcu(&va->rcu_head, rcu_free_va);
 415 }
 416
 417 /*
 418  * Free a region of KVA allocated by alloc_vmap_area
 419  */
 420 static void free_vmap_area(struct vmap_area *va)
 421 {
 422         spin_lock(&vmap_area_lock);
 423         __free_vmap_area(va);
 424         spin_unlock(&vmap_area_lock);
 425 }
 426
 427 /*
 428  * Clear the pagetable entries of a given vmap_area
 429  */
 430 static void unmap_vmap_area(struct vmap_area *va)
 431 {
 432         vunmap_page_range(va->va_start, va->va_end);
 433 }
 434
 435 /*
 436  * lazy_max_pages is the maximum amount of virtual address space we gather up
 437  * before attempting to purge with a TLB flush.
 438  *
 439  * There is a tradeoff here: a larger number will cover more kernel page tables
 440  * and take slightly longer to purge, but it will linearly reduce the number of
 441  * global TLB flushes that must be performed. It would seem natural to scale
 442  * this number up linearly with the number of CPUs (because vmapping activity
 443  * could also scale linearly with the number of CPUs), however it is likely
 444  * that in practice, workloads might be constrained in other ways that mean
 445  * vmap activity will not scale linearly with CPUs. Also, I want to be
 446  * conservative and not introduce a big latency on huge systems, so go with
 447  * a less aggressive log scale. It will still be an improvement over the old
 448  * code, and it will be simple to change the scale factor if we find that it
 449  * becomes a problem on bigger systems.
 450  */
 451 static unsigned long lazy_max_pages(void)
 452 {
 453         unsigned int log;
 454
 455         log = fls(num_online_cpus());
 456
 457         return log * (32UL * 1024 * 1024 / PAGE_SIZE);
 458 }
 459
 460 static atomic_t vmap_lazy_nr = ATOMIC_INIT(0);
 461
 462 /*
 463  * Purges all lazily-freed vmap areas.
 464  *
 465  * If sync is 0 then don't purge if there is already a purge in progress.
 466  * If force_flush is 1, then flush kernel TLBs between *start and *end even
 467  * if we found no lazy vmap areas to unmap (callers can use this to optimise
 468  * their own TLB flushing).
 469  * Returns with *start = min(*start, lowest purged address)
 470  *              *end = max(*end, highest purged address)
 471  */
 472 static void __purge_vmap_area_lazy(unsigned long *start, unsigned long *end,
 473                                         int sync, int force_flush)
 474 {
 475         static DEFINE_SPINLOCK(purge_lock);
 476         LIST_HEAD(valist);
 477         struct vmap_area *va;
 478         int nr = 0;
 479
 480         /*
 481          * If sync is 0 but force_flush is 1, we'll go sync anyway but callers
 482          * should not expect such behaviour. This just simplifies locking for
 483          * the case that isn't actually used at the moment anyway.
 484          */
 485         if (!sync && !force_flush) {
 486                 if (!spin_trylock(&purge_lock))
 487                         return;
 488         } else
 489                 spin_lock(&purge_lock);
 490
 491         rcu_read_lock();
 492         list_for_each_entry_rcu(va, &vmap_area_list, list) {
 493                 if (va->flags & VM_LAZY_FREE) {
 494                         if (va->va_start < *start)
 495                                 *start = va->va_start;
 496                         if (va->va_end > *end)
 497                                 *end = va->va_end;
 498                         nr += (va->va_end - va->va_start) >> PAGE_SHIFT;
 499                         unmap_vmap_area(va);
 500                         list_add_tail(&va->purge_list, &valist);
 501                         va->flags |= VM_LAZY_FREEING;
 502                         va->flags &= ~VM_LAZY_FREE;
 503                 }
 504         }
 505         rcu_read_unlock();
 506
 507         if (nr) {
 508                 BUG_ON(nr > atomic_read(&vmap_lazy_nr));
 509                 atomic_sub(nr, &vmap_lazy_nr);
 510         }
 511
 512         if (nr || force_flush)
 513                 flush_tlb_kernel_range(*start, *end);
 514
 515         if (nr) {
 516                 spin_lock(&vmap_area_lock);
 517                 list_for_each_entry(va, &valist, purge_list)
 518                         __free_vmap_area(va);
 519                 spin_unlock(&vmap_area_lock);
 520         }
 521         spin_unlock(&purge_lock);
 522 }
 523
 524 /*
 525  * Kick off a purge of the outstanding lazy areas. Don't bother if somebody
 526  * is already purging.
 527  */
 528 static void try_purge_vmap_area_lazy(void)
 529 {
 530         unsigned long start = ULONG_MAX, end = 0;
 531
 532         __purge_vmap_area_lazy(&start, &end, 0, 0);
 533 }
 534
 535 /*
 536  * Kick off a purge of the outstanding lazy areas.
 537  */
 538 static void purge_vmap_area_lazy(void)
 539 {
 540         unsigned long start = ULONG_MAX, end = 0;
 541
 542         __purge_vmap_area_lazy(&start, &end, 1, 0);
 543 }
 544
 545 /*
 546  * Free and unmap a vmap area, caller ensuring flush_cache_vunmap had been
 547  * called for the correct range previously.
 548  */
 549 static void free_unmap_vmap_area_noflush(struct vmap_area *va)
 550 {
 551         va->flags |= VM_LAZY_FREE;
 552         atomic_add((va->va_end - va->va_start) >> PAGE_SHIFT, &vmap_lazy_nr);
 553         if (unlikely(atomic_read(&vmap_lazy_nr) > lazy_max_pages()))
 554                 try_purge_vmap_area_lazy();
 555 }
 556
 557 /*
 558  * Free and unmap a vmap area
 559  */
 560 static void free_unmap_vmap_area(struct vmap_area *va)
 561 {
 562         flush_cache_vunmap(va->va_start, va->va_end);
 563         free_unmap_vmap_area_noflush(va);
 564 }
 565
 566 static struct vmap_area *find_vmap_area(unsigned long addr)
 567 {
 568         struct vmap_area *va;
 569
 570         spin_lock(&vmap_area_lock);
 571         va = __find_vmap_area(addr);
 572         spin_unlock(&vmap_area_lock);
 573
 574         return va;
 575 }
 576
 577 static void free_unmap_vmap_area_addr(unsigned long addr)
 578 {
 579         struct vmap_area *va;
 580
 581         va = find_vmap_area(addr);
 582         BUG_ON(!va);
 583         free_unmap_vmap_area(va);
 584 }
 585
 586
 587 /*** Per cpu kva allocator ***/
 588
 589 /*
 590  * vmap space is limited especially on 32 bit architectures. Ensure there is
 591  * room for at least 16 percpu vmap blocks per CPU.
 592  */
 593 /*
 594  * If we had a constant VMALLOC_START and VMALLOC_END, we'd like to be able
 595  * to #define VMALLOC_SPACE             (VMALLOC_END-VMALLOC_START). Guess
 596  * instead (we just need a rough idea)
 597  */
 598 #if BITS_PER_LONG == 32
 599 #define VMALLOC_SPACE           (128UL*1024*1024)
 600 #else
 601 #define VMALLOC_SPACE           (128UL*1024*1024*1024)
 602 #endif
 603
 604 #define VMALLOC_PAGES           (VMALLOC_SPACE / PAGE_SIZE)
 605 #define VMAP_MAX_ALLOC          BITS_PER_LONG   /* 256K with 4K pages */
 606 #define VMAP_BBMAP_BITS_MAX     1024    /* 4MB with 4K pages */
 607 #define VMAP_BBMAP_BITS_MIN     (VMAP_MAX_ALLOC*2)
 608 #define VMAP_MIN(x, y)          ((x) < (y) ? (x) : (y)) /* can't use min() */
 609 #define VMAP_MAX(x, y)          ((x) > (y) ? (x) : (y)) /* can't use max() */
 610 #define VMAP_BBMAP_BITS         VMAP_MIN(VMAP_BBMAP_BITS_MAX,           \
 611                                         VMAP_MAX(VMAP_BBMAP_BITS_MIN,   \
 612                                                 VMALLOC_PAGES / NR_CPUS / 16))
 613
 614 #define VMAP_BLOCK_SIZE         (VMAP_BBMAP_BITS * PAGE_SIZE)
 615
 616 static bool vmap_initialized __read_mostly = false;
 617
 618 struct vmap_block_queue {
 619         spinlock_t lock;
 620         struct list_head free;
 621         struct list_head dirty;
 622         unsigned int nr_dirty;
 623 };
 624
 625 struct vmap_block {
 626         spinlock_t lock;
 627         struct vmap_area *va;
 628         struct vmap_block_queue *vbq;
 629         unsigned long free, dirty;
 630         DECLARE_BITMAP(alloc_map, VMAP_BBMAP_BITS);
 631         DECLARE_BITMAP(dirty_map, VMAP_BBMAP_BITS);
 632         union {
 633                 struct {
 634                         struct list_head free_list;
 635                         struct list_head dirty_list;
 636                 };
 637                 struct rcu_head rcu_head;
 638         };
 639 };
 640
 641 /* Queue of free and dirty vmap blocks, for allocation and flushing purposes */
 642 static DEFINE_PER_CPU(struct vmap_block_queue, vmap_block_queue);
 643
 644 /*
 645  * Radix tree of vmap blocks, indexed by address, to quickly find a vmap block
 646  * in the free path. Could get rid of this if we change the API to return a
 647  * "cookie" from alloc, to be passed to free. But no big deal yet.
 648  */
 649 static DEFINE_SPINLOCK(vmap_block_tree_lock);
 650 static RADIX_TREE(vmap_block_tree, GFP_ATOMIC);
 651
 652 /*
 653  * We should probably have a fallback mechanism to allocate virtual memory
 654  * out of partially filled vmap blocks. However vmap block sizing should be
 655  * fairly reasonable according to the vmalloc size, so it shouldn't be a
 656  * big problem.
 657  */
 658
 659 static unsigned long addr_to_vb_idx(unsigned long addr)
 660 {
 661         addr -= VMALLOC_START & ~(VMAP_BLOCK_SIZE-1);
 662         addr /= VMAP_BLOCK_SIZE;
 663         return addr;
 664 }
 665
 666 static struct vmap_block *new_vmap_block(gfp_t gfp_mask)
 667 {
 668         struct vmap_block_queue *vbq;
 669         struct vmap_block *vb;
 670         struct vmap_area *va;
 671         unsigned long vb_idx;
 672         int node, err;
 673
 674         node = numa_node_id();
 675
 676         vb = kmalloc_node(sizeof(struct vmap_block),
 677                         gfp_mask & GFP_RECLAIM_MASK, node);
 678         if (unlikely(!vb))
 679                 return ERR_PTR(-ENOMEM);
 680
 681         va = alloc_vmap_area(VMAP_BLOCK_SIZE, VMAP_BLOCK_SIZE,
 682                                         VMALLOC_START, VMALLOC_END,
 683                                         node, gfp_mask);
 684         if (unlikely(IS_ERR(va))) {
 685                 kfree(vb);
 686                 return ERR_PTR(PTR_ERR(va));
 687         }
 688
 689         err = radix_tree_preload(gfp_mask);
 690         if (unlikely(err)) {
 691                 kfree(vb);
 692                 free_vmap_area(va);
 693                 return ERR_PTR(err);
 694         }
 695
 696         spin_lock_init(&vb->lock);
 697         vb->va = va;
 698         vb->free = VMAP_BBMAP_BITS;
 699         vb->dirty = 0;
 700         bitmap_zero(vb->alloc_map, VMAP_BBMAP_BITS);
 701         bitmap_zero(vb->dirty_map, VMAP_BBMAP_BITS);
 702         INIT_LIST_HEAD(&vb->free_list);
 703         INIT_LIST_HEAD(&vb->dirty_list);
 704
 705         vb_idx = addr_to_vb_idx(va->va_start);
 706         spin_lock(&vmap_block_tree_lock);
 707         err = radix_tree_insert(&vmap_block_tree, vb_idx, vb);
 708         spin_unlock(&vmap_block_tree_lock);
 709         BUG_ON(err);
 710         radix_tree_preload_end();
 711
 712         vbq = &get_cpu_var(vmap_block_queue);
 713         vb->vbq = vbq;
 714         spin_lock(&vbq->lock);
 715         list_add(&vb->free_list, &vbq->free);
 716         spin_unlock(&vbq->lock);
 717         put_cpu_var(vmap_cpu_blocks);
 718
 719         return vb;
 720 }
 721
 722 static void rcu_free_vb(struct rcu_head *head)
 723 {
 724         struct vmap_block *vb = container_of(head, struct vmap_block, rcu_head);
 725
 726         kfree(vb);
 727 }
 728
 729 static void free_vmap_block(struct vmap_block *vb)
 730 {
 731         struct vmap_block *tmp;
 732         unsigned long vb_idx;
 733
 734         spin_lock(&vb->vbq->lock);
 735         if (!list_empty(&vb->free_list))
 736                 list_del(&vb->free_list);
 737         if (!list_empty(&vb->dirty_list))
 738                 list_del(&vb->dirty_list);
 739         spin_unlock(&vb->vbq->lock);
 740
 741         vb_idx = addr_to_vb_idx(vb->va->va_start);
 742         spin_lock(&vmap_block_tree_lock);
 743         tmp = radix_tree_delete(&vmap_block_tree, vb_idx);
 744         spin_unlock(&vmap_block_tree_lock);
 745         BUG_ON(tmp != vb);
 746
 747         free_unmap_vmap_area_noflush(vb->va);
 748         call_rcu(&vb->rcu_head, rcu_free_vb);
 749 }
 750
 751 static void *vb_alloc(unsigned long size, gfp_t gfp_mask)
 752 {
 753         struct vmap_block_queue *vbq;
 754         struct vmap_block *vb;
 755         unsigned long addr = 0;
 756         unsigned int order;
 757
 758         BUG_ON(size & ~PAGE_MASK);
 759         BUG_ON(size > PAGE_SIZE*VMAP_MAX_ALLOC);
 760         order = get_order(size);
 761
 762 again:
 763         rcu_read_lock();
 764         vbq = &get_cpu_var(vmap_block_queue);
 765         list_for_each_entry_rcu(vb, &vbq->free, free_list) {
 766                 int i;
 767
 768                 spin_lock(&vb->lock);
 769                 i = bitmap_find_free_region(vb->alloc_map,
 770                                                 VMAP_BBMAP_BITS, order);
 771
 772                 if (i >= 0) {
 773                         addr = vb->va->va_start + (i << PAGE_SHIFT);
 774                         BUG_ON(addr_to_vb_idx(addr) !=
 775                                         addr_to_vb_idx(vb->va->va_start));
 776                         vb->free -= 1UL << order;
 777                         if (vb->free == 0) {
 778                                 spin_lock(&vbq->lock);
 779                                 list_del_init(&vb->free_list);
 780                                 spin_unlock(&vbq->lock);
 781                         }
 782                         spin_unlock(&vb->lock);
 783                         break;
 784                 }
 785                 spin_unlock(&vb->lock);
 786         }
 787         put_cpu_var(vmap_cpu_blocks);
 788         rcu_read_unlock();
 789
 790         if (!addr) {
 791                 vb = new_vmap_block(gfp_mask);
 792                 if (IS_ERR(vb))
 793                         return vb;
 794                 goto again;
 795         }
 796
 797         return (void *)addr;
 798 }
 799
 800 static void vb_free(const void *addr, unsigned long size)
 801 {
 802         unsigned long offset;
 803         unsigned long vb_idx;
 804         unsigned int order;
 805         struct vmap_block *vb;
 806
 807         BUG_ON(size & ~PAGE_MASK);
 808         BUG_ON(size > PAGE_SIZE*VMAP_MAX_ALLOC);
 809
 810         flush_cache_vunmap((unsigned long)addr, (unsigned long)addr + size);
 811
 812         order = get_order(size);
 813
 814         offset = (unsigned long)addr & (VMAP_BLOCK_SIZE - 1);
 815
 816         vb_idx = addr_to_vb_idx((unsigned long)addr);
 817         rcu_read_lock();
 818         vb = radix_tree_lookup(&vmap_block_tree, vb_idx);
 819         rcu_read_unlock();
 820         BUG_ON(!vb);
 821
 822         spin_lock(&vb->lock);
 823         bitmap_allocate_region(vb->dirty_map, offset >> PAGE_SHIFT, order);
 824         if (!vb->dirty) {
 825                 spin_lock(&vb->vbq->lock);
 826                 list_add(&vb->dirty_list, &vb->vbq->dirty);
 827                 spin_unlock(&vb->vbq->lock);
 828         }
 829         vb->dirty += 1UL << order;
 830         if (vb->dirty == VMAP_BBMAP_BITS) {
 831                 BUG_ON(vb->free || !list_empty(&vb->free_list));
 832                 spin_unlock(&vb->lock);
 833                 free_vmap_block(vb);
 834         } else
 835                 spin_unlock(&vb->lock);
 836 }
 837
 838 /**
 839  * vm_unmap_aliases - unmap outstanding lazy aliases in the vmap layer
 840  *
 841  * The vmap/vmalloc layer lazily flushes kernel virtual mappings primarily
 842  * to amortize TLB flushing overheads. What this means is that any page you
 843  * have now, may, in a former life, have been mapped into kernel virtual
 844  * address by the vmap layer and so there might be some CPUs with TLB entries
 845  * still referencing that page (additional to the regular 1:1 kernel mapping).
 846  *
 847  * vm_unmap_aliases flushes all such lazy mappings. After it returns, we can
 848  * be sure that none of the pages we have control over will have any aliases
 849  * from the vmap layer.
 850  */
 851 void vm_unmap_aliases(void)
 852 {
 853         unsigned long start = ULONG_MAX, end = 0;
 854         int cpu;
 855         int flush = 0;
 856
 857         if (unlikely(!vmap_initialized))
 858                 return;
 859
 860         for_each_possible_cpu(cpu) {
 861                 struct vmap_block_queue *vbq = &per_cpu(vmap_block_queue, cpu);
 862                 struct vmap_block *vb;
 863
 864                 rcu_read_lock();
 865                 list_for_each_entry_rcu(vb, &vbq->free, free_list) {
 866                         int i;
 867
 868                         spin_lock(&vb->lock);
 869                         i = find_first_bit(vb->dirty_map, VMAP_BBMAP_BITS);
 870                         while (i < VMAP_BBMAP_BITS) {
 871                                 unsigned long s, e;
 872                                 int j;
 873                                 j = find_next_zero_bit(vb->dirty_map,
 874                                         VMAP_BBMAP_BITS, i);
 875
 876                                 s = vb->va->va_start + (i << PAGE_SHIFT);
 877                                 e = vb->va->va_start + (j << PAGE_SHIFT);
 878                                 vunmap_page_range(s, e);
 879                                 flush = 1;
 880
 881                                 if (s < start)
 882                                         start = s;
 883                                 if (e > end)
 884                                         end = e;
 885
 886                                 i = j;
 887                                 i = find_next_bit(vb->dirty_map,
 888                                                         VMAP_BBMAP_BITS, i);
 889                         }
 890                         spin_unlock(&vb->lock);
 891                 }
 892                 rcu_read_unlock();
 893         }
 894
 895         __purge_vmap_area_lazy(&start, &end, 1, flush);
 896 }
 897 EXPORT_SYMBOL_GPL(vm_unmap_aliases);
 898
 899 /**
 900  * vm_unmap_ram - unmap linear kernel address space set up by vm_map_ram
 901  * @mem: the pointer returned by vm_map_ram
 902  * @count: the count passed to that vm_map_ram call (cannot unmap partial)
 903  */
 904 void vm_unmap_ram(const void *mem, unsigned int count)
 905 {
 906         unsigned long size = count << PAGE_SHIFT;
 907         unsigned long addr = (unsigned long)mem;
 908
 909         BUG_ON(!addr);
 910         BUG_ON(addr < VMALLOC_START);
 911         BUG_ON(addr > VMALLOC_END);
 912         BUG_ON(addr & (PAGE_SIZE-1));
 913
 914         debug_check_no_locks_freed(mem, size);
 915
 916         if (likely(count <= VMAP_MAX_ALLOC))
 917                 vb_free(mem, size);
 918         else
 919                 free_unmap_vmap_area_addr(addr);
 920 }
 921 EXPORT_SYMBOL(vm_unmap_ram);
 922
 923 /**
 924  * vm_map_ram - map pages linearly into kernel virtual address (vmalloc space)
 925  * @pages: an array of pointers to the pages to be mapped
 926  * @count: number of pages
 927  * @node: prefer to allocate data structures on this node
 928  * @prot: memory protection to use. PAGE_KERNEL for regular RAM
 929  *
 930  * Returns: a pointer to the address that has been mapped, or %NULL on failure
 931  */
 932 void *vm_map_ram(struct page **pages, unsigned int count, int node, pgprot_t prot)
 933 {
 934         unsigned long size = count << PAGE_SHIFT;
 935         unsigned long addr;
 936         void *mem;
 937
 938         if (likely(count <= VMAP_MAX_ALLOC)) {
 939                 mem = vb_alloc(size, GFP_KERNEL);
 940                 if (IS_ERR(mem))
 941                         return NULL;
 942                 addr = (unsigned long)mem;
 943         } else {
 944                 struct vmap_area *va;
 945                 va = alloc_vmap_area(size, PAGE_SIZE,
 946                                 VMALLOC_START, VMALLOC_END, node, GFP_KERNEL);
 947                 if (IS_ERR(va))
 948                         return NULL;
 949
 950                 addr = va->va_start;
 951                 mem = (void *)addr;
 952         }
 953         if (vmap_page_range(addr, addr + size, prot, pages) < 0) {
 954                 vm_unmap_ram(mem, count);
 955                 return NULL;
 956         }
 957         return mem;
 958 }
 959 EXPORT_SYMBOL(vm_map_ram);
 960
 961 void __init vmalloc_init(void)
 962 {
 963         int i;
 964
 965         for_each_possible_cpu(i) {
 966                 struct vmap_block_queue *vbq;
 967
 968                 vbq = &per_cpu(vmap_block_queue, i);
 969                 spin_lock_init(&vbq->lock);
 970                 INIT_LIST_HEAD(&vbq->free);
 971                 INIT_LIST_HEAD(&vbq->dirty);
 972                 vbq->nr_dirty = 0;
 973         }
 974
 975         vmap_initialized = true;
 976 }
 977
 978 void unmap_kernel_range(unsigned long addr, unsigned long size)
 979 {
 980         unsigned long end = addr + size;
 981         vunmap_page_range(addr, end);
 982         flush_tlb_kernel_range(addr, end);
 983 }
 984
 985 int map_vm_area(struct vm_struct *area, pgprot_t prot, struct page ***pages)
 986 {
 987         unsigned long addr = (unsigned long)area->addr;
 988         unsigned long end = addr + area->size - PAGE_SIZE;
 989         int err;
 990
 991         err = vmap_page_range(addr, end, prot, *pages);
 992         if (err > 0) {
 993                 *pages += err;
 994                 err = 0;
 995         }
 996
 997         return err;
 998 }
 999 EXPORT_SYMBOL_GPL(map_vm_area);
1000
1001 /*** Old vmalloc interfaces ***/
1002 DEFINE_RWLOCK(vmlist_lock);
1003 struct vm_struct *vmlist;
1004
1005 static struct vm_struct *__get_vm_area_node(unsigned long size,
1006                 unsigned long flags, unsigned long start, unsigned long end,
1007                 int node, gfp_t gfp_mask, void *caller)
1008 {
1009         static struct vmap_area *va;
1010         struct vm_struct *area;
1011         struct vm_struct *tmp, **p;
1012         unsigned long align = 1;
1013
1014         BUG_ON(in_interrupt());
1015         if (flags & VM_IOREMAP) {
1016                 int bit = fls(size);
1017
1018                 if (bit > IOREMAP_MAX_ORDER)
1019                         bit = IOREMAP_MAX_ORDER;
1020                 else if (bit < PAGE_SHIFT)
1021                         bit = PAGE_SHIFT;
1022
1023                 align = 1ul << bit;
1024         }
1025
1026         size = PAGE_ALIGN(size);
1027         if (unlikely(!size))
1028                 return NULL;
1029
1030         area = kmalloc_node(sizeof(*area), gfp_mask & GFP_RECLAIM_MASK, node);
1031         if (unlikely(!area))
1032                 return NULL;
1033
1034         /*
1035          * We always allocate a guard page.
1036          */
1037         size += PAGE_SIZE;
1038
1039         va = alloc_vmap_area(size, align, start, end, node, gfp_mask);
1040         if (IS_ERR(va)) {
1041                 kfree(area);
1042                 return NULL;
1043         }
1044
1045         area->flags = flags;
1046         area->addr = (void *)va->va_start;
1047         area->size = size;
1048         area->pages = NULL;
1049         area->nr_pages = 0;
1050         area->phys_addr = 0;
1051         area->caller = caller;
1052         va->private = area;
1053         va->flags |= VM_VM_AREA;
1054
1055         write_lock(&vmlist_lock);
1056         for (p = &vmlist; (tmp = *p) != NULL; p = &tmp->next) {
1057                 if (tmp->addr >= area->addr)
1058                         break;
1059         }
1060         area->next = *p;
1061         *p = area;
1062         write_unlock(&vmlist_lock);
1063
1064         return area;
1065 }
1066
1067 struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
1068                                 unsigned long start, unsigned long end)
1069 {
1070         return __get_vm_area_node(size, flags, start, end, -1, GFP_KERNEL,
1071                                                 __builtin_return_address(0));
1072 }
1073 EXPORT_SYMBOL_GPL(__get_vm_area);
1074
1075 /**
1076  *      get_vm_area  -  reserve a contiguous kernel virtual area
1077  *      @size:          size of the area
1078  *      @flags:         %VM_IOREMAP for I/O mappings or VM_ALLOC
1079  *
1080  *      Search an area of @size in the kernel virtual mapping area,
1081  *      and reserved it for out purposes.  Returns the area descriptor
1082  *      on success or %NULL on failure.
1083  */
1084 struct vm_struct *get_vm_area(unsigned long size, unsigned long flags)
1085 {
1086         return __get_vm_area_node(size, flags, VMALLOC_START, VMALLOC_END,
1087                                 -1, GFP_KERNEL, __builtin_return_address(0));
1088 }
1089
1090 struct vm_struct *get_vm_area_caller(unsigned long size, unsigned long flags,
1091                                 void *caller)
1092 {
1093         return __get_vm_area_node(size, flags, VMALLOC_START, VMALLOC_END,
1094                                                 -1, GFP_KERNEL, caller);
1095 }
1096
1097 struct vm_struct *get_vm_area_node(unsigned long size, unsigned long flags,
1098                                    int node, gfp_t gfp_mask)
1099 {
1100         return __get_vm_area_node(size, flags, VMALLOC_START, VMALLOC_END, node,
1101                                   gfp_mask, __builtin_return_address(0));
1102 }
1103
1104 static struct vm_struct *find_vm_area(const void *addr)
1105 {
1106         struct vmap_area *va;
1107
1108         va = find_vmap_area((unsigned long)addr);
1109         if (va && va->flags & VM_VM_AREA)
1110                 return va->private;
1111
1112         return NULL;
1113 }
1114
1115 /**
1116  *      remove_vm_area  -  find and remove a continuous kernel virtual area
1117  *      @addr:          base address
1118  *
1119  *      Search for the kernel VM area starting at @addr, and remove it.
1120  *      This function returns the found VM area, but using it is NOT safe
1121  *      on SMP machines, except for its size or flags.
1122  */
1123 struct vm_struct *remove_vm_area(const void *addr)
1124 {
1125         struct vmap_area *va;
1126
1127         va = find_vmap_area((unsigned long)addr);
1128         if (va && va->flags & VM_VM_AREA) {
1129                 struct vm_struct *vm = va->private;
1130                 struct vm_struct *tmp, **p;
1131                 free_unmap_vmap_area(va);
1132                 vm->size -= PAGE_SIZE;
1133
1134                 write_lock(&vmlist_lock);
1135                 for (p = &vmlist; (tmp = *p) != vm; p = &tmp->next)
1136                         ;
1137                 *p = tmp->next;
1138                 write_unlock(&vmlist_lock);
1139
1140                 return vm;
1141         }
1142         return NULL;
1143 }
1144
1145 static void __vunmap(const void *addr, int deallocate_pages)
1146 {
1147         struct vm_struct *area;
1148
1149         if (!addr)
1150                 return;
1151
1152         if ((PAGE_SIZE-1) & (unsigned long)addr) {
1153                 WARN(1, KERN_ERR "Trying to vfree() bad address (%p)\n", addr);
1154                 return;
1155         }
1156
1157         area = remove_vm_area(addr);
1158         if (unlikely(!area)) {
1159                 WARN(1, KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
1160                                 addr);
1161                 return;
1162         }
1163
1164         debug_check_no_locks_freed(addr, area->size);
1165         debug_check_no_obj_freed(addr, area->size);
1166
1167         if (deallocate_pages) {
1168                 int i;
1169
1170                 for (i = 0; i < area->nr_pages; i++) {
1171                         struct page *page = area->pages[i];
1172
1173                         BUG_ON(!page);
1174                         __free_page(page);
1175                 }
1176
1177                 if (area->flags & VM_VPAGES)
1178                         vfree(area->pages);
1179                 else
1180                         kfree(area->pages);
1181         }
1182
1183         kfree(area);
1184         return;
1185 }
1186
1187 /**
1188  *      vfree  -  release memory allocated by vmalloc()
1189  *      @addr:          memory base address
1190  *
1191  *      Free the virtually continuous memory area starting at @addr, as
1192  *      obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
1193  *      NULL, no operation is performed.
1194  *
1195  *      Must not be called in interrupt context.
1196  */
1197 void vfree(const void *addr)
1198 {
1199         BUG_ON(in_interrupt());
1200         __vunmap(addr, 1);
1201 }
1202 EXPORT_SYMBOL(vfree);
1203
1204 /**
1205  *      vunmap  -  release virtual mapping obtained by vmap()
1206  *      @addr:          memory base address
1207  *
1208  *      Free the virtually contiguous memory area starting at @addr,
1209  *      which was created from the page array passed to vmap().
1210  *
1211  *      Must not be called in interrupt context.
1212  */
1213 void vunmap(const void *addr)
1214 {
1215         BUG_ON(in_interrupt());
1216         __vunmap(addr, 0);
1217 }
1218 EXPORT_SYMBOL(vunmap);
1219
1220 /**
1221  *      vmap  -  map an array of pages into virtually contiguous space
1222  *      @pages:         array of page pointers
1223  *      @count:         number of pages to map
1224  *      @flags:         vm_area->flags
1225  *      @prot:          page protection for the mapping
1226  *
1227  *      Maps @count pages from @pages into contiguous kernel virtual
1228  *      space.
1229  */
1230 void *vmap(struct page **pages, unsigned int count,
1231                 unsigned long flags, pgprot_t prot)
1232 {
1233         struct vm_struct *area;
1234
1235         if (count > num_physpages)
1236                 return NULL;
1237
1238         area = get_vm_area_caller((count << PAGE_SHIFT), flags,
1239                                         __builtin_return_address(0));
1240         if (!area)
1241                 return NULL;
1242
1243         if (map_vm_area(area, prot, &pages)) {
1244                 vunmap(area->addr);
1245                 return NULL;
1246         }
1247
1248         return area->addr;
1249 }
1250 EXPORT_SYMBOL(vmap);
1251
1252 static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
1253                             int node, void *caller);
1254 static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
1255                                  pgprot_t prot, int node, void *caller)
1256 {
1257         struct page **pages;
1258         unsigned int nr_pages, array_size, i;
1259
1260         nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
1261         array_size = (nr_pages * sizeof(struct page *));
1262
1263         area->nr_pages = nr_pages;
1264         /* Please note that the recursion is strictly bounded. */
1265         if (array_size > PAGE_SIZE) {
1266                 pages = __vmalloc_node(array_size, gfp_mask | __GFP_ZERO,
1267                                 PAGE_KERNEL, node, caller);
1268                 area->flags |= VM_VPAGES;
1269         } else {
1270                 pages = kmalloc_node(array_size,
1271                                 (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO,
1272                                 node);
1273         }
1274         area->pages = pages;
1275         area->caller = caller;
1276         if (!area->pages) {
1277                 remove_vm_area(area->addr);
1278                 kfree(area);
1279                 return NULL;
1280         }
1281
1282         for (i = 0; i < area->nr_pages; i++) {
1283                 struct page *page;
1284
1285                 if (node < 0)
1286                         page = alloc_page(gfp_mask);
1287                 else
1288                         page = alloc_pages_node(node, gfp_mask, 0);
1289
1290                 if (unlikely(!page)) {
1291                         /* Successfully allocated i pages, free them in __vunmap() */
1292                         area->nr_pages = i;
1293                         goto fail;
1294                 }
1295                 area->pages[i] = page;
1296         }
1297
1298         if (map_vm_area(area, prot, &pages))
1299                 goto fail;
1300         return area->addr;
1301
1302 fail:
1303         vfree(area->addr);
1304         return NULL;
1305 }
1306
1307 void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask, pgprot_t prot)
1308 {
1309         return __vmalloc_area_node(area, gfp_mask, prot, -1,
1310                                         __builtin_return_address(0));
1311 }
1312
1313 /**
1314  *      __vmalloc_node  -  allocate virtually contiguous memory
1315  *      @size:          allocation size
1316  *      @gfp_mask:      flags for the page level allocator
1317  *      @prot:          protection mask for the allocated pages
1318  *      @node:          node to use for allocation or -1
1319  *      @caller:        caller's return address
1320  *
1321  *      Allocate enough pages to cover @size from the page level
1322  *      allocator with @gfp_mask flags.  Map them into contiguous
1323  *      kernel virtual space, using a pagetable protection of @prot.
1324  */
1325 static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
1326                                                 int node, void *caller)
1327 {
1328         struct vm_struct *area;
1329
1330         size = PAGE_ALIGN(size);
1331         if (!size || (size >> PAGE_SHIFT) > num_physpages)
1332                 return NULL;
1333
1334         area = __get_vm_area_node(size, VM_ALLOC, VMALLOC_START, VMALLOC_END,
1335                                                 node, gfp_mask, caller);
1336
1337         if (!area)
1338                 return NULL;
1339
1340         return __vmalloc_area_node(area, gfp_mask, prot, node, caller);
1341 }
1342
1343 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
1344 {
1345         return __vmalloc_node(size, gfp_mask, prot, -1,
1346                                 __builtin_return_address(0));
1347 }
1348 EXPORT_SYMBOL(__vmalloc);
1349
1350 /**
1351  *      vmalloc  -  allocate virtually contiguous memory
1352  *      @size:          allocation size
1353  *      Allocate enough pages to cover @size from the page level
1354  *      allocator and map them into contiguous kernel virtual space.
1355  *
1356  *      For tight control over page level allocator and protection flags
1357  *      use __vmalloc() instead.
1358  */
1359 void *vmalloc(unsigned long size)
1360 {
1361         return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL,
1362                                         -1, __builtin_return_address(0));
1363 }
1364 EXPORT_SYMBOL(vmalloc);
1365
1366 /**
1367  * vmalloc_user - allocate zeroed virtually contiguous memory for userspace
1368  * @size: allocation size
1369  *
1370  * The resulting memory area is zeroed so it can be mapped to userspace
1371  * without leaking data.
1372  */
1373 void *vmalloc_user(unsigned long size)
1374 {
1375         struct vm_struct *area;
1376         void *ret;
1377
1378         ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
1379         if (ret) {
1380                 area = find_vm_area(ret);
1381                 area->flags |= VM_USERMAP;
1382         }
1383         return ret;
1384 }
1385 EXPORT_SYMBOL(vmalloc_user);
1386
1387 /**
1388  *      vmalloc_node  -  allocate memory on a specific node
1389  *      @size:          allocation size
1390  *      @node:          numa node
1391  *
1392  *      Allocate enough pages to cover @size from the page level
1393  *      allocator and map them into contiguous kernel virtual space.
1394  *
1395  *      For tight control over page level allocator and protection flags
1396  *      use __vmalloc() instead.
1397  */
1398 void *vmalloc_node(unsigned long size, int node)
1399 {
1400         return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL,
1401                                         node, __builtin_return_address(0));
1402 }
1403 EXPORT_SYMBOL(vmalloc_node);
1404
1405 #ifndef PAGE_KERNEL_EXEC
1406 # define PAGE_KERNEL_EXEC PAGE_KERNEL
1407 #endif
1408
1409 /**
1410  *      vmalloc_exec  -  allocate virtually contiguous, executable memory
1411  *      @size:          allocation size
1412  *
1413  *      Kernel-internal function to allocate enough pages to cover @size
1414  *      the page level allocator and map them into contiguous and
1415  *      executable kernel virtual space.
1416  *
1417  *      For tight control over page level allocator and protection flags
1418  *      use __vmalloc() instead.
1419  */
1420
1421 void *vmalloc_exec(unsigned long size)
1422 {
1423         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
1424 }
1425
1426 #if defined(CONFIG_64BIT) && defined(CONFIG_ZONE_DMA32)
1427 #define GFP_VMALLOC32 GFP_DMA32 | GFP_KERNEL
1428 #elif defined(CONFIG_64BIT) && defined(CONFIG_ZONE_DMA)
1429 #define GFP_VMALLOC32 GFP_DMA | GFP_KERNEL
1430 #else
1431 #define GFP_VMALLOC32 GFP_KERNEL
1432 #endif
1433
1434 /**
1435  *      vmalloc_32  -  allocate virtually contiguous memory (32bit addressable)
1436  *      @size:          allocation size
1437  *
1438  *      Allocate enough 32bit PA addressable pages to cover @size from the
1439  *      page level allocator and map them into contiguous kernel virtual space.
1440  */
1441 void *vmalloc_32(unsigned long size)
1442 {
1443         return __vmalloc(size, GFP_VMALLOC32, PAGE_KERNEL);
1444 }
1445 EXPORT_SYMBOL(vmalloc_32);
1446
1447 /**
1448  * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
1449  *      @size:          allocation size
1450  *
1451  * The resulting memory area is 32bit addressable and zeroed so it can be
1452  * mapped to userspace without leaking data.
1453  */
1454 void *vmalloc_32_user(unsigned long size)
1455 {
1456         struct vm_struct *area;
1457         void *ret;
1458
1459         ret = __vmalloc(size, GFP_VMALLOC32 | __GFP_ZERO, PAGE_KERNEL);
1460         if (ret) {
1461                 area = find_vm_area(ret);
1462                 area->flags |= VM_USERMAP;
1463         }
1464         return ret;
1465 }
1466 EXPORT_SYMBOL(vmalloc_32_user);
1467
1468 long vread(char *buf, char *addr, unsigned long count)
1469 {
1470         struct vm_struct *tmp;
1471         char *vaddr, *buf_start = buf;
1472         unsigned long n;
1473
1474         /* Don't allow overflow */
1475         if ((unsigned long) addr + count < count)
1476                 count = -(unsigned long) addr;
1477
1478         read_lock(&vmlist_lock);
1479         for (tmp = vmlist; tmp; tmp = tmp->next) {
1480                 vaddr = (char *) tmp->addr;
1481                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
1482                         continue;
1483                 while (addr < vaddr) {
1484                         if (count == 0)
1485                                 goto finished;
1486                         *buf = '\0';
1487                         buf++;
1488                         addr++;
1489                         count--;
1490                 }
1491                 n = vaddr + tmp->size - PAGE_SIZE - addr;
1492                 do {
1493                         if (count == 0)
1494                                 goto finished;
1495                         *buf = *addr;
1496                         buf++;
1497                         addr++;
1498                         count--;
1499                 } while (--n > 0);
1500         }
1501 finished:
1502         read_unlock(&vmlist_lock);
1503         return buf - buf_start;
1504 }
1505
1506 long vwrite(char *buf, char *addr, unsigned long count)
1507 {
1508         struct vm_struct *tmp;
1509         char *vaddr, *buf_start = buf;
1510         unsigned long n;
1511
1512         /* Don't allow overflow */
1513         if ((unsigned long) addr + count < count)
1514                 count = -(unsigned long) addr;
1515
1516         read_lock(&vmlist_lock);
1517         for (tmp = vmlist; tmp; tmp = tmp->next) {
1518                 vaddr = (char *) tmp->addr;
1519                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
1520                         continue;
1521                 while (addr < vaddr) {
1522                         if (count == 0)
1523                                 goto finished;
1524                         buf++;
1525                         addr++;
1526                         count--;
1527                 }
1528                 n = vaddr + tmp->size - PAGE_SIZE - addr;
1529                 do {
1530                         if (count == 0)
1531                                 goto finished;
1532                         *addr = *buf;
1533                         buf++;
1534                         addr++;
1535                         count--;
1536                 } while (--n > 0);
1537         }
1538 finished:
1539         read_unlock(&vmlist_lock);
1540         return buf - buf_start;
1541 }
1542
1543 /**
1544  *      remap_vmalloc_range  -  map vmalloc pages to userspace
1545  *      @vma:           vma to cover (map full range of vma)
1546  *      @addr:          vmalloc memory
1547  *      @pgoff:         number of pages into addr before first page to map
1548  *
1549  *      Returns:        0 for success, -Exxx on failure
1550  *
1551  *      This function checks that addr is a valid vmalloc'ed area, and
1552  *      that it is big enough to cover the vma. Will return failure if
1553  *      that criteria isn't met.
1554  *
1555  *      Similar to remap_pfn_range() (see mm/memory.c)
1556  */
1557 int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
1558                                                 unsigned long pgoff)
1559 {
1560         struct vm_struct *area;
1561         unsigned long uaddr = vma->vm_start;
1562         unsigned long usize = vma->vm_end - vma->vm_start;
1563
1564         if ((PAGE_SIZE-1) & (unsigned long)addr)
1565                 return -EINVAL;
1566
1567         area = find_vm_area(addr);
1568         if (!area)
1569                 return -EINVAL;
1570
1571         if (!(area->flags & VM_USERMAP))
1572                 return -EINVAL;
1573
1574         if (usize + (pgoff << PAGE_SHIFT) > area->size - PAGE_SIZE)
1575                 return -EINVAL;
1576
1577         addr += pgoff << PAGE_SHIFT;
1578         do {
1579                 struct page *page = vmalloc_to_page(addr);
1580                 int ret;
1581
1582                 ret = vm_insert_page(vma, uaddr, page);
1583                 if (ret)
1584                         return ret;
1585
1586                 uaddr += PAGE_SIZE;
1587                 addr += PAGE_SIZE;
1588                 usize -= PAGE_SIZE;
1589         } while (usize > 0);
1590
1591         /* Prevent "things" like memory migration? VM_flags need a cleanup... */
1592         vma->vm_flags |= VM_RESERVED;
1593
1594         return 0;
1595 }
1596 EXPORT_SYMBOL(remap_vmalloc_range);
1597
1598 /*
1599  * Implement a stub for vmalloc_sync_all() if the architecture chose not to
1600  * have one.
1601  */
1602 void  __attribute__((weak)) vmalloc_sync_all(void)
1603 {
1604 }
1605
1606
1607 static int f(pte_t *pte, pgtable_t table, unsigned long addr, void *data)
1608 {
1609         /* apply_to_page_range() does all the hard work. */
1610         return 0;
1611 }
1612
1613 /**
1614  *      alloc_vm_area - allocate a range of kernel address space
1615  *      @size:          size of the area
1616  *
1617  *      Returns:        NULL on failure, vm_struct on success
1618  *
1619  *      This function reserves a range of kernel address space, and
1620  *      allocates pagetables to map that range.  No actual mappings
1621  *      are created.  If the kernel address space is not shared
1622  *      between processes, it syncs the pagetable across all
1623  *      processes.
1624  */
1625 struct vm_struct *alloc_vm_area(size_t size)
1626 {
1627         struct vm_struct *area;
1628
1629         area = get_vm_area_caller(size, VM_IOREMAP,
1630                                 __builtin_return_address(0));
1631         if (area == NULL)
1632                 return NULL;
1633
1634         /*
1635          * This ensures that page tables are constructed for this region
1636          * of kernel virtual address space and mapped into init_mm.
1637          */
1638         if (apply_to_page_range(&init_mm, (unsigned long)area->addr,
1639                                 area->size, f, NULL)) {
1640                 free_vm_area(area);
1641                 return NULL;
1642         }
1643
1644         /* Make sure the pagetables are constructed in process kernel
1645            mappings */
1646         vmalloc_sync_all();
1647
1648         return area;
1649 }
1650 EXPORT_SYMBOL_GPL(alloc_vm_area);
1651
1652 void free_vm_area(struct vm_struct *area)
1653 {
1654         struct vm_struct *ret;
1655         ret = remove_vm_area(area->addr);
1656         BUG_ON(ret != area);
1657         kfree(area);
1658 }
1659 EXPORT_SYMBOL_GPL(free_vm_area);
1660
1661
1662 #ifdef CONFIG_PROC_FS
1663 static void *s_start(struct seq_file *m, loff_t *pos)
1664 {
1665         loff_t n = *pos;
1666         struct vm_struct *v;
1667
1668         read_lock(&vmlist_lock);
1669         v = vmlist;
1670         while (n > 0 && v) {
1671                 n--;
1672                 v = v->next;
1673         }
1674         if (!n)
1675                 return v;
1676
1677         return NULL;
1678
1679 }
1680
1681 static void *s_next(struct seq_file *m, void *p, loff_t *pos)
1682 {
1683         struct vm_struct *v = p;
1684
1685         ++*pos;
1686         return v->next;
1687 }
1688
1689 static void s_stop(struct seq_file *m, void *p)
1690 {
1691         read_unlock(&vmlist_lock);
1692 }
1693
1694 static void show_numa_info(struct seq_file *m, struct vm_struct *v)
1695 {
1696         if (NUMA_BUILD) {
1697                 unsigned int nr, *counters = m->private;
1698
1699                 if (!counters)
1700                         return;
1701
1702                 memset(counters, 0, nr_node_ids * sizeof(unsigned int));
1703
1704                 for (nr = 0; nr < v->nr_pages; nr++)
1705                         counters[page_to_nid(v->pages[nr])]++;
1706
1707                 for_each_node_state(nr, N_HIGH_MEMORY)
1708                         if (counters[nr])
1709                                 seq_printf(m, " N%u=%u", nr, counters[nr]);
1710         }
1711 }
1712
1713 static int s_show(struct seq_file *m, void *p)
1714 {
1715         struct vm_struct *v = p;
1716
1717         seq_printf(m, "0x%p-0x%p %7ld",
1718                 v->addr, v->addr + v->size, v->size);
1719
1720         if (v->caller) {
1721                 char buff[KSYM_SYMBOL_LEN];
1722
1723                 seq_putc(m, ' ');
1724                 sprint_symbol(buff, (unsigned long)v->caller);
1725                 seq_puts(m, buff);
1726         }
1727
1728         if (v->nr_pages)
1729                 seq_printf(m, " pages=%d", v->nr_pages);
1730
1731         if (v->phys_addr)
1732                 seq_printf(m, " phys=%lx", v->phys_addr);
1733
1734         if (v->flags & VM_IOREMAP)
1735                 seq_printf(m, " ioremap");
1736
1737         if (v->flags & VM_ALLOC)
1738                 seq_printf(m, " vmalloc");
1739
1740         if (v->flags & VM_MAP)
1741                 seq_printf(m, " vmap");
1742
1743         if (v->flags & VM_USERMAP)
1744                 seq_printf(m, " user");
1745
1746         if (v->flags & VM_VPAGES)
1747                 seq_printf(m, " vpages");
1748
1749         show_numa_info(m, v);
1750         seq_putc(m, '\n');
1751         return 0;
1752 }
1753
1754 static const struct seq_operations vmalloc_op = {
1755         .start = s_start,
1756         .next = s_next,
1757         .stop = s_stop,
1758         .show = s_show,
1759 };
1760
1761 static int vmalloc_open(struct inode *inode, struct file *file)
1762 {
1763         unsigned int *ptr = NULL;
1764         int ret;
1765
1766         if (NUMA_BUILD)
1767                 ptr = kmalloc(nr_node_ids * sizeof(unsigned int), GFP_KERNEL);
1768         ret = seq_open(file, &vmalloc_op);
1769         if (!ret) {
1770                 struct seq_file *m = file->private_data;
1771                 m->private = ptr;
1772         } else
1773                 kfree(ptr);
1774         return ret;
1775 }
1776
1777 static const struct file_operations proc_vmalloc_operations = {
1778         .open           = vmalloc_open,
1779         .read           = seq_read,
1780         .llseek         = seq_lseek,
1781         .release        = seq_release_private,
1782 };
1783
1784 static int __init proc_vmalloc_init(void)
1785 {
1786         proc_create("vmallocinfo", S_IRUSR, NULL, &proc_vmalloc_operations);
1787         return 0;
1788 }
1789 module_init(proc_vmalloc_init);
1790 #endif
1791