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(&init_mm, 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         spin_lock(&init_mm.page_table_lock);
 151         do {
 152                 next = pgd_addr_end(addr, end);
 153                 err = vmap_pud_range(pgd, addr, next, prot, pages);
 154                 if (err)
 155                         break;
 156         } while (pgd++, addr = next, addr != end);
 157         spin_unlock(&init_mm.page_table_lock);
 158         flush_cache_vmap((unsigned long) area->addr, end);
 159         return err;
 160 }
 161
 162 struct vm_struct *__get_vm_area_node(unsigned long size, unsigned long flags,
 163                                 unsigned long start, unsigned long end, int node)
 164 {
 165         struct vm_struct **p, *tmp, *area;
 166         unsigned long align = 1;
 167         unsigned long addr;
 168
 169         if (flags & VM_IOREMAP) {
 170                 int bit = fls(size);
 171
 172                 if (bit > IOREMAP_MAX_ORDER)
 173                         bit = IOREMAP_MAX_ORDER;
 174                 else if (bit < PAGE_SHIFT)
 175                         bit = PAGE_SHIFT;
 176
 177                 align = 1ul << bit;
 178         }
 179         addr = ALIGN(start, align);
 180         size = PAGE_ALIGN(size);
 181
 182         area = kmalloc_node(sizeof(*area), GFP_KERNEL, node);
 183         if (unlikely(!area))
 184                 return NULL;
 185
 186         if (unlikely(!size)) {
 187                 kfree (area);
 188                 return NULL;
 189         }
 190
 191         /*
 192          * We always allocate a guard page.
 193          */
 194         size += PAGE_SIZE;
 195
 196         write_lock(&vmlist_lock);
 197         for (p = &vmlist; (tmp = *p) != NULL ;p = &tmp->next) {
 198                 if ((unsigned long)tmp->addr < addr) {
 199                         if((unsigned long)tmp->addr + tmp->size >= addr)
 200                                 addr = ALIGN(tmp->size +
 201                                              (unsigned long)tmp->addr, align);
 202                         continue;
 203                 }
 204                 if ((size + addr) < addr)
 205                         goto out;
 206                 if (size + addr <= (unsigned long)tmp->addr)
 207                         goto found;
 208                 addr = ALIGN(tmp->size + (unsigned long)tmp->addr, align);
 209                 if (addr > end - size)
 210                         goto out;
 211         }
 212
 213 found:
 214         area->next = *p;
 215         *p = area;
 216
 217         area->flags = flags;
 218         area->addr = (void *)addr;
 219         area->size = size;
 220         area->pages = NULL;
 221         area->nr_pages = 0;
 222         area->phys_addr = 0;
 223         write_unlock(&vmlist_lock);
 224
 225         return area;
 226
 227 out:
 228         write_unlock(&vmlist_lock);
 229         kfree(area);
 230         if (printk_ratelimit())
 231                 printk(KERN_WARNING "allocation failed: out of vmalloc space - use vmalloc=<size> to increase size.\n");
 232         return NULL;
 233 }
 234
 235 struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
 236                                 unsigned long start, unsigned long end)
 237 {
 238         return __get_vm_area_node(size, flags, start, end, -1);
 239 }
 240
 241 /**
 242  *      get_vm_area  -  reserve a contingous kernel virtual area
 243  *
 244  *      @size:          size of the area
 245  *      @flags:         %VM_IOREMAP for I/O mappings or VM_ALLOC
 246  *
 247  *      Search an area of @size in the kernel virtual mapping area,
 248  *      and reserved it for out purposes.  Returns the area descriptor
 249  *      on success or %NULL on failure.
 250  */
 251 struct vm_struct *get_vm_area(unsigned long size, unsigned long flags)
 252 {
 253         return __get_vm_area(size, flags, VMALLOC_START, VMALLOC_END);
 254 }
 255
 256 struct vm_struct *get_vm_area_node(unsigned long size, unsigned long flags, int node)
 257 {
 258         return __get_vm_area_node(size, flags, VMALLOC_START, VMALLOC_END, node);
 259 }
 260
 261 /* Caller must hold vmlist_lock */
 262 struct vm_struct *__remove_vm_area(void *addr)
 263 {
 264         struct vm_struct **p, *tmp;
 265
 266         for (p = &vmlist ; (tmp = *p) != NULL ;p = &tmp->next) {
 267                  if (tmp->addr == addr)
 268                          goto found;
 269         }
 270         return NULL;
 271
 272 found:
 273         unmap_vm_area(tmp);
 274         *p = tmp->next;
 275
 276         /*
 277          * Remove the guard page.
 278          */
 279         tmp->size -= PAGE_SIZE;
 280         return tmp;
 281 }
 282
 283 /**
 284  *      remove_vm_area  -  find and remove a contingous kernel virtual area
 285  *
 286  *      @addr:          base address
 287  *
 288  *      Search for the kernel VM area starting at @addr, and remove it.
 289  *      This function returns the found VM area, but using it is NOT safe
 290  *      on SMP machines, except for its size or flags.
 291  */
 292 struct vm_struct *remove_vm_area(void *addr)
 293 {
 294         struct vm_struct *v;
 295         write_lock(&vmlist_lock);
 296         v = __remove_vm_area(addr);
 297         write_unlock(&vmlist_lock);
 298         return v;
 299 }
 300
 301 void __vunmap(void *addr, int deallocate_pages)
 302 {
 303         struct vm_struct *area;
 304
 305         if (!addr)
 306                 return;
 307
 308         if ((PAGE_SIZE-1) & (unsigned long)addr) {
 309                 printk(KERN_ERR "Trying to vfree() bad address (%p)\n", addr);
 310                 WARN_ON(1);
 311                 return;
 312         }
 313
 314         area = remove_vm_area(addr);
 315         if (unlikely(!area)) {
 316                 printk(KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
 317                                 addr);
 318                 WARN_ON(1);
 319                 return;
 320         }
 321
 322         if (deallocate_pages) {
 323                 int i;
 324
 325                 for (i = 0; i < area->nr_pages; i++) {
 326                         if (unlikely(!area->pages[i]))
 327                                 BUG();
 328                         __free_page(area->pages[i]);
 329                 }
 330
 331                 if (area->nr_pages > PAGE_SIZE/sizeof(struct page *))
 332                         vfree(area->pages);
 333                 else
 334                         kfree(area->pages);
 335         }
 336
 337         kfree(area);
 338         return;
 339 }
 340
 341 /**
 342  *      vfree  -  release memory allocated by vmalloc()
 343  *
 344  *      @addr:          memory base address
 345  *
 346  *      Free the virtually contiguous memory area starting at @addr, as
 347  *      obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
 348  *      NULL, no operation is performed.
 349  *
 350  *      Must not be called in interrupt context.
 351  */
 352 void vfree(void *addr)
 353 {
 354         BUG_ON(in_interrupt());
 355         __vunmap(addr, 1);
 356 }
 357 EXPORT_SYMBOL(vfree);
 358
 359 /**
 360  *      vunmap  -  release virtual mapping obtained by vmap()
 361  *
 362  *      @addr:          memory base address
 363  *
 364  *      Free the virtually contiguous memory area starting at @addr,
 365  *      which was created from the page array passed to vmap().
 366  *
 367  *      Must not be called in interrupt context.
 368  */
 369 void vunmap(void *addr)
 370 {
 371         BUG_ON(in_interrupt());
 372         __vunmap(addr, 0);
 373 }
 374 EXPORT_SYMBOL(vunmap);
 375
 376 /**
 377  *      vmap  -  map an array of pages into virtually contiguous space
 378  *
 379  *      @pages:         array of page pointers
 380  *      @count:         number of pages to map
 381  *      @flags:         vm_area->flags
 382  *      @prot:          page protection for the mapping
 383  *
 384  *      Maps @count pages from @pages into contiguous kernel virtual
 385  *      space.
 386  */
 387 void *vmap(struct page **pages, unsigned int count,
 388                 unsigned long flags, pgprot_t prot)
 389 {
 390         struct vm_struct *area;
 391
 392         if (count > num_physpages)
 393                 return NULL;
 394
 395         area = get_vm_area((count << PAGE_SHIFT), flags);
 396         if (!area)
 397                 return NULL;
 398         if (map_vm_area(area, prot, &pages)) {
 399                 vunmap(area->addr);
 400                 return NULL;
 401         }
 402
 403         return area->addr;
 404 }
 405 EXPORT_SYMBOL(vmap);
 406
 407 void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
 408                                 pgprot_t prot, int node)
 409 {
 410         struct page **pages;
 411         unsigned int nr_pages, array_size, i;
 412
 413         nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
 414         array_size = (nr_pages * sizeof(struct page *));
 415
 416         area->nr_pages = nr_pages;
 417         /* Please note that the recursion is strictly bounded. */
 418         if (array_size > PAGE_SIZE)
 419                 pages = __vmalloc_node(array_size, gfp_mask, PAGE_KERNEL, node);
 420         else
 421                 pages = kmalloc_node(array_size, (gfp_mask & ~__GFP_HIGHMEM), node);
 422         area->pages = pages;
 423         if (!area->pages) {
 424                 remove_vm_area(area->addr);
 425                 kfree(area);
 426                 return NULL;
 427         }
 428         memset(area->pages, 0, array_size);
 429
 430         for (i = 0; i < area->nr_pages; i++) {
 431                 if (node < 0)
 432                         area->pages[i] = alloc_page(gfp_mask);
 433                 else
 434                         area->pages[i] = alloc_pages_node(node, gfp_mask, 0);
 435                 if (unlikely(!area->pages[i])) {
 436                         /* Successfully allocated i pages, free them in __vunmap() */
 437                         area->nr_pages = i;
 438                         goto fail;
 439                 }
 440         }
 441
 442         if (map_vm_area(area, prot, &pages))
 443                 goto fail;
 444         return area->addr;
 445
 446 fail:
 447         vfree(area->addr);
 448         return NULL;
 449 }
 450
 451 void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask, pgprot_t prot)
 452 {
 453         return __vmalloc_area_node(area, gfp_mask, prot, -1);
 454 }
 455
 456 /**
 457  *      __vmalloc_node  -  allocate virtually contiguous memory
 458  *
 459  *      @size:          allocation size
 460  *      @gfp_mask:      flags for the page level allocator
 461  *      @prot:          protection mask for the allocated pages
 462  *      @node           node to use for allocation or -1
 463  *
 464  *      Allocate enough pages to cover @size from the page level
 465  *      allocator with @gfp_mask flags.  Map them into contiguous
 466  *      kernel virtual space, using a pagetable protection of @prot.
 467  */
 468 void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
 469                         int node)
 470 {
 471         struct vm_struct *area;
 472
 473         size = PAGE_ALIGN(size);
 474         if (!size || (size >> PAGE_SHIFT) > num_physpages)
 475                 return NULL;
 476
 477         area = get_vm_area_node(size, VM_ALLOC, node);
 478         if (!area)
 479                 return NULL;
 480
 481         return __vmalloc_area_node(area, gfp_mask, prot, node);
 482 }
 483 EXPORT_SYMBOL(__vmalloc_node);
 484
 485 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
 486 {
 487         return __vmalloc_node(size, gfp_mask, prot, -1);
 488 }
 489 EXPORT_SYMBOL(__vmalloc);
 490
 491 /**
 492  *      vmalloc  -  allocate virtually contiguous memory
 493  *
 494  *      @size:          allocation size
 495  *
 496  *      Allocate enough pages to cover @size from the page level
 497  *      allocator and map them into contiguous kernel virtual space.
 498  *
 499  *      For tight cotrol over page level allocator and protection flags
 500  *      use __vmalloc() instead.
 501  */
 502 void *vmalloc(unsigned long size)
 503 {
 504        return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
 505 }
 506 EXPORT_SYMBOL(vmalloc);
 507
 508 /**
 509  *      vmalloc_node  -  allocate memory on a specific node
 510  *
 511  *      @size:          allocation size
 512  *      @node;          numa node
 513  *
 514  *      Allocate enough pages to cover @size from the page level
 515  *      allocator and map them into contiguous kernel virtual space.
 516  *
 517  *      For tight cotrol over page level allocator and protection flags
 518  *      use __vmalloc() instead.
 519  */
 520 void *vmalloc_node(unsigned long size, int node)
 521 {
 522        return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL, node);
 523 }
 524 EXPORT_SYMBOL(vmalloc_node);
 525
 526 #ifndef PAGE_KERNEL_EXEC
 527 # define PAGE_KERNEL_EXEC PAGE_KERNEL
 528 #endif
 529
 530 /**
 531  *      vmalloc_exec  -  allocate virtually contiguous, executable memory
 532  *
 533  *      @size:          allocation size
 534  *
 535  *      Kernel-internal function to allocate enough pages to cover @size
 536  *      the page level allocator and map them into contiguous and
 537  *      executable kernel virtual space.
 538  *
 539  *      For tight cotrol over page level allocator and protection flags
 540  *      use __vmalloc() instead.
 541  */
 542
 543 void *vmalloc_exec(unsigned long size)
 544 {
 545         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
 546 }
 547
 548 /**
 549  *      vmalloc_32  -  allocate virtually contiguous memory (32bit addressable)
 550  *
 551  *      @size:          allocation size
 552  *
 553  *      Allocate enough 32bit PA addressable pages to cover @size from the
 554  *      page level allocator and map them into contiguous kernel virtual space.
 555  */
 556 void *vmalloc_32(unsigned long size)
 557 {
 558         return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
 559 }
 560 EXPORT_SYMBOL(vmalloc_32);
 561
 562 long vread(char *buf, char *addr, unsigned long count)
 563 {
 564         struct vm_struct *tmp;
 565         char *vaddr, *buf_start = buf;
 566         unsigned long n;
 567
 568         /* Don't allow overflow */
 569         if ((unsigned long) addr + count < count)
 570                 count = -(unsigned long) addr;
 571
 572         read_lock(&vmlist_lock);
 573         for (tmp = vmlist; tmp; tmp = tmp->next) {
 574                 vaddr = (char *) tmp->addr;
 575                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
 576                         continue;
 577                 while (addr < vaddr) {
 578                         if (count == 0)
 579                                 goto finished;
 580                         *buf = '\0';
 581                         buf++;
 582                         addr++;
 583                         count--;
 584                 }
 585                 n = vaddr + tmp->size - PAGE_SIZE - addr;
 586                 do {
 587                         if (count == 0)
 588                                 goto finished;
 589                         *buf = *addr;
 590                         buf++;
 591                         addr++;
 592                         count--;
 593                 } while (--n > 0);
 594         }
 595 finished:
 596         read_unlock(&vmlist_lock);
 597         return buf - buf_start;
 598 }
 599
 600 long vwrite(char *buf, char *addr, unsigned long count)
 601 {
 602         struct vm_struct *tmp;
 603         char *vaddr, *buf_start = buf;
 604         unsigned long n;
 605
 606         /* Don't allow overflow */
 607         if ((unsigned long) addr + count < count)
 608                 count = -(unsigned long) addr;
 609
 610         read_lock(&vmlist_lock);
 611         for (tmp = vmlist; tmp; tmp = tmp->next) {
 612                 vaddr = (char *) tmp->addr;
 613                 if (addr >= vaddr + tmp->size - PAGE_SIZE)
 614                         continue;
 615                 while (addr < vaddr) {
 616                         if (count == 0)
 617                                 goto finished;
 618                         buf++;
 619                         addr++;
 620                         count--;
 621                 }
 622                 n = vaddr + tmp->size - PAGE_SIZE - addr;
 623                 do {
 624                         if (count == 0)
 625                                 goto finished;
 626                         *addr = *buf;
 627                         buf++;
 628                         addr++;
 629                         count--;
 630                 } while (--n > 0);
 631         }
 632 finished:
 633         read_unlock(&vmlist_lock);
 634         return buf - buf_start;
 635 }