mm: vmalloc: show number of vmalloc pages in /proc/meminfo
[linux-2.6-block.git] / mm / vmalloc.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/mm/vmalloc.c
4  *
5  *  Copyright (C) 1993  Linus Torvalds
6  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
7  *  SMP-safe vmalloc/vfree/ioremap, Tigran Aivazian <tigran@veritas.com>, May 2000
8  *  Major rework to support vmap/vunmap, Christoph Hellwig, SGI, August 2002
9  *  Numa awareness, Christoph Lameter, SGI, June 2005
10  */
11
12 #include <linux/vmalloc.h>
13 #include <linux/mm.h>
14 #include <linux/module.h>
15 #include <linux/highmem.h>
16 #include <linux/sched/signal.h>
17 #include <linux/slab.h>
18 #include <linux/spinlock.h>
19 #include <linux/interrupt.h>
20 #include <linux/proc_fs.h>
21 #include <linux/seq_file.h>
22 #include <linux/set_memory.h>
23 #include <linux/debugobjects.h>
24 #include <linux/kallsyms.h>
25 #include <linux/list.h>
26 #include <linux/notifier.h>
27 #include <linux/rbtree.h>
28 #include <linux/radix-tree.h>
29 #include <linux/rcupdate.h>
30 #include <linux/pfn.h>
31 #include <linux/kmemleak.h>
32 #include <linux/atomic.h>
33 #include <linux/compiler.h>
34 #include <linux/llist.h>
35 #include <linux/bitops.h>
36 #include <linux/rbtree_augmented.h>
37
38 #include <linux/uaccess.h>
39 #include <asm/tlbflush.h>
40 #include <asm/shmparam.h>
41
42 #include "internal.h"
43
44 struct vfree_deferred {
45         struct llist_head list;
46         struct work_struct wq;
47 };
48 static DEFINE_PER_CPU(struct vfree_deferred, vfree_deferred);
49
50 static void __vunmap(const void *, int);
51
52 static void free_work(struct work_struct *w)
53 {
54         struct vfree_deferred *p = container_of(w, struct vfree_deferred, wq);
55         struct llist_node *t, *llnode;
56
57         llist_for_each_safe(llnode, t, llist_del_all(&p->list))
58                 __vunmap((void *)llnode, 1);
59 }
60
61 /*** Page table manipulation functions ***/
62
63 static void vunmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end)
64 {
65         pte_t *pte;
66
67         pte = pte_offset_kernel(pmd, addr);
68         do {
69                 pte_t ptent = ptep_get_and_clear(&init_mm, addr, pte);
70                 WARN_ON(!pte_none(ptent) && !pte_present(ptent));
71         } while (pte++, addr += PAGE_SIZE, addr != end);
72 }
73
74 static void vunmap_pmd_range(pud_t *pud, unsigned long addr, unsigned long end)
75 {
76         pmd_t *pmd;
77         unsigned long next;
78
79         pmd = pmd_offset(pud, addr);
80         do {
81                 next = pmd_addr_end(addr, end);
82                 if (pmd_clear_huge(pmd))
83                         continue;
84                 if (pmd_none_or_clear_bad(pmd))
85                         continue;
86                 vunmap_pte_range(pmd, addr, next);
87         } while (pmd++, addr = next, addr != end);
88 }
89
90 static void vunmap_pud_range(p4d_t *p4d, unsigned long addr, unsigned long end)
91 {
92         pud_t *pud;
93         unsigned long next;
94
95         pud = pud_offset(p4d, addr);
96         do {
97                 next = pud_addr_end(addr, end);
98                 if (pud_clear_huge(pud))
99                         continue;
100                 if (pud_none_or_clear_bad(pud))
101                         continue;
102                 vunmap_pmd_range(pud, addr, next);
103         } while (pud++, addr = next, addr != end);
104 }
105
106 static void vunmap_p4d_range(pgd_t *pgd, unsigned long addr, unsigned long end)
107 {
108         p4d_t *p4d;
109         unsigned long next;
110
111         p4d = p4d_offset(pgd, addr);
112         do {
113                 next = p4d_addr_end(addr, end);
114                 if (p4d_clear_huge(p4d))
115                         continue;
116                 if (p4d_none_or_clear_bad(p4d))
117                         continue;
118                 vunmap_pud_range(p4d, addr, next);
119         } while (p4d++, addr = next, addr != end);
120 }
121
122 static void vunmap_page_range(unsigned long addr, unsigned long end)
123 {
124         pgd_t *pgd;
125         unsigned long next;
126
127         BUG_ON(addr >= end);
128         pgd = pgd_offset_k(addr);
129         do {
130                 next = pgd_addr_end(addr, end);
131                 if (pgd_none_or_clear_bad(pgd))
132                         continue;
133                 vunmap_p4d_range(pgd, addr, next);
134         } while (pgd++, addr = next, addr != end);
135 }
136
137 static int vmap_pte_range(pmd_t *pmd, unsigned long addr,
138                 unsigned long end, pgprot_t prot, struct page **pages, int *nr)
139 {
140         pte_t *pte;
141
142         /*
143          * nr is a running index into the array which helps higher level
144          * callers keep track of where we're up to.
145          */
146
147         pte = pte_alloc_kernel(pmd, addr);
148         if (!pte)
149                 return -ENOMEM;
150         do {
151                 struct page *page = pages[*nr];
152
153                 if (WARN_ON(!pte_none(*pte)))
154                         return -EBUSY;
155                 if (WARN_ON(!page))
156                         return -ENOMEM;
157                 set_pte_at(&init_mm, addr, pte, mk_pte(page, prot));
158                 (*nr)++;
159         } while (pte++, addr += PAGE_SIZE, addr != end);
160         return 0;
161 }
162
163 static int vmap_pmd_range(pud_t *pud, unsigned long addr,
164                 unsigned long end, pgprot_t prot, struct page **pages, int *nr)
165 {
166         pmd_t *pmd;
167         unsigned long next;
168
169         pmd = pmd_alloc(&init_mm, pud, addr);
170         if (!pmd)
171                 return -ENOMEM;
172         do {
173                 next = pmd_addr_end(addr, end);
174                 if (vmap_pte_range(pmd, addr, next, prot, pages, nr))
175                         return -ENOMEM;
176         } while (pmd++, addr = next, addr != end);
177         return 0;
178 }
179
180 static int vmap_pud_range(p4d_t *p4d, unsigned long addr,
181                 unsigned long end, pgprot_t prot, struct page **pages, int *nr)
182 {
183         pud_t *pud;
184         unsigned long next;
185
186         pud = pud_alloc(&init_mm, p4d, addr);
187         if (!pud)
188                 return -ENOMEM;
189         do {
190                 next = pud_addr_end(addr, end);
191                 if (vmap_pmd_range(pud, addr, next, prot, pages, nr))
192                         return -ENOMEM;
193         } while (pud++, addr = next, addr != end);
194         return 0;
195 }
196
197 static int vmap_p4d_range(pgd_t *pgd, unsigned long addr,
198                 unsigned long end, pgprot_t prot, struct page **pages, int *nr)
199 {
200         p4d_t *p4d;
201         unsigned long next;
202
203         p4d = p4d_alloc(&init_mm, pgd, addr);
204         if (!p4d)
205                 return -ENOMEM;
206         do {
207                 next = p4d_addr_end(addr, end);
208                 if (vmap_pud_range(p4d, addr, next, prot, pages, nr))
209                         return -ENOMEM;
210         } while (p4d++, addr = next, addr != end);
211         return 0;
212 }
213
214 /*
215  * Set up page tables in kva (addr, end). The ptes shall have prot "prot", and
216  * will have pfns corresponding to the "pages" array.
217  *
218  * Ie. pte at addr+N*PAGE_SIZE shall point to pfn corresponding to pages[N]
219  */
220 static int vmap_page_range_noflush(unsigned long start, unsigned long end,
221                                    pgprot_t prot, struct page **pages)
222 {
223         pgd_t *pgd;
224         unsigned long next;
225         unsigned long addr = start;
226         int err = 0;
227         int nr = 0;
228
229         BUG_ON(addr >= end);
230         pgd = pgd_offset_k(addr);
231         do {
232                 next = pgd_addr_end(addr, end);
233                 err = vmap_p4d_range(pgd, addr, next, prot, pages, &nr);
234                 if (err)
235                         return err;
236         } while (pgd++, addr = next, addr != end);
237
238         return nr;
239 }
240
241 static int vmap_page_range(unsigned long start, unsigned long end,
242                            pgprot_t prot, struct page **pages)
243 {
244         int ret;
245
246         ret = vmap_page_range_noflush(start, end, prot, pages);
247         flush_cache_vmap(start, end);
248         return ret;
249 }
250
251 int is_vmalloc_or_module_addr(const void *x)
252 {
253         /*
254          * ARM, x86-64 and sparc64 put modules in a special place,
255          * and fall back on vmalloc() if that fails. Others
256          * just put it in the vmalloc space.
257          */
258 #if defined(CONFIG_MODULES) && defined(MODULES_VADDR)
259         unsigned long addr = (unsigned long)x;
260         if (addr >= MODULES_VADDR && addr < MODULES_END)
261                 return 1;
262 #endif
263         return is_vmalloc_addr(x);
264 }
265
266 /*
267  * Walk a vmap address to the struct page it maps.
268  */
269 struct page *vmalloc_to_page(const void *vmalloc_addr)
270 {
271         unsigned long addr = (unsigned long) vmalloc_addr;
272         struct page *page = NULL;
273         pgd_t *pgd = pgd_offset_k(addr);
274         p4d_t *p4d;
275         pud_t *pud;
276         pmd_t *pmd;
277         pte_t *ptep, pte;
278
279         /*
280          * XXX we might need to change this if we add VIRTUAL_BUG_ON for
281          * architectures that do not vmalloc module space
282          */
283         VIRTUAL_BUG_ON(!is_vmalloc_or_module_addr(vmalloc_addr));
284
285         if (pgd_none(*pgd))
286                 return NULL;
287         p4d = p4d_offset(pgd, addr);
288         if (p4d_none(*p4d))
289                 return NULL;
290         pud = pud_offset(p4d, addr);
291
292         /*
293          * Don't dereference bad PUD or PMD (below) entries. This will also
294          * identify huge mappings, which we may encounter on architectures
295          * that define CONFIG_HAVE_ARCH_HUGE_VMAP=y. Such regions will be
296          * identified as vmalloc addresses by is_vmalloc_addr(), but are
297          * not [unambiguously] associated with a struct page, so there is
298          * no correct value to return for them.
299          */
300         WARN_ON_ONCE(pud_bad(*pud));
301         if (pud_none(*pud) || pud_bad(*pud))
302                 return NULL;
303         pmd = pmd_offset(pud, addr);
304         WARN_ON_ONCE(pmd_bad(*pmd));
305         if (pmd_none(*pmd) || pmd_bad(*pmd))
306                 return NULL;
307
308         ptep = pte_offset_map(pmd, addr);
309         pte = *ptep;
310         if (pte_present(pte))
311                 page = pte_page(pte);
312         pte_unmap(ptep);
313         return page;
314 }
315 EXPORT_SYMBOL(vmalloc_to_page);
316
317 /*
318  * Map a vmalloc()-space virtual address to the physical page frame number.
319  */
320 unsigned long vmalloc_to_pfn(const void *vmalloc_addr)
321 {
322         return page_to_pfn(vmalloc_to_page(vmalloc_addr));
323 }
324 EXPORT_SYMBOL(vmalloc_to_pfn);
325
326
327 /*** Global kva allocator ***/
328
329 #define DEBUG_AUGMENT_PROPAGATE_CHECK 0
330 #define DEBUG_AUGMENT_LOWEST_MATCH_CHECK 0
331
332 #define VM_LAZY_FREE    0x02
333 #define VM_VM_AREA      0x04
334
335 static DEFINE_SPINLOCK(vmap_area_lock);
336 /* Export for kexec only */
337 LIST_HEAD(vmap_area_list);
338 static LLIST_HEAD(vmap_purge_list);
339 static struct rb_root vmap_area_root = RB_ROOT;
340 static bool vmap_initialized __read_mostly;
341
342 /*
343  * This kmem_cache is used for vmap_area objects. Instead of
344  * allocating from slab we reuse an object from this cache to
345  * make things faster. Especially in "no edge" splitting of
346  * free block.
347  */
348 static struct kmem_cache *vmap_area_cachep;
349
350 /*
351  * This linked list is used in pair with free_vmap_area_root.
352  * It gives O(1) access to prev/next to perform fast coalescing.
353  */
354 static LIST_HEAD(free_vmap_area_list);
355
356 /*
357  * This augment red-black tree represents the free vmap space.
358  * All vmap_area objects in this tree are sorted by va->va_start
359  * address. It is used for allocation and merging when a vmap
360  * object is released.
361  *
362  * Each vmap_area node contains a maximum available free block
363  * of its sub-tree, right or left. Therefore it is possible to
364  * find a lowest match of free area.
365  */
366 static struct rb_root free_vmap_area_root = RB_ROOT;
367
368 /*
369  * Preload a CPU with one object for "no edge" split case. The
370  * aim is to get rid of allocations from the atomic context, thus
371  * to use more permissive allocation masks.
372  */
373 static DEFINE_PER_CPU(struct vmap_area *, ne_fit_preload_node);
374
375 static __always_inline unsigned long
376 va_size(struct vmap_area *va)
377 {
378         return (va->va_end - va->va_start);
379 }
380
381 static __always_inline unsigned long
382 get_subtree_max_size(struct rb_node *node)
383 {
384         struct vmap_area *va;
385
386         va = rb_entry_safe(node, struct vmap_area, rb_node);
387         return va ? va->subtree_max_size : 0;
388 }
389
390 /*
391  * Gets called when remove the node and rotate.
392  */
393 static __always_inline unsigned long
394 compute_subtree_max_size(struct vmap_area *va)
395 {
396         return max3(va_size(va),
397                 get_subtree_max_size(va->rb_node.rb_left),
398                 get_subtree_max_size(va->rb_node.rb_right));
399 }
400
401 RB_DECLARE_CALLBACKS(static, free_vmap_area_rb_augment_cb,
402         struct vmap_area, rb_node, unsigned long, subtree_max_size,
403         compute_subtree_max_size)
404
405 static void purge_vmap_area_lazy(void);
406 static BLOCKING_NOTIFIER_HEAD(vmap_notify_list);
407 static unsigned long lazy_max_pages(void);
408
409 static atomic_long_t nr_vmalloc_pages;
410
411 unsigned long vmalloc_nr_pages(void)
412 {
413         return atomic_long_read(&nr_vmalloc_pages);
414 }
415
416 static struct vmap_area *__find_vmap_area(unsigned long addr)
417 {
418         struct rb_node *n = vmap_area_root.rb_node;
419
420         while (n) {
421                 struct vmap_area *va;
422
423                 va = rb_entry(n, struct vmap_area, rb_node);
424                 if (addr < va->va_start)
425                         n = n->rb_left;
426                 else if (addr >= va->va_end)
427                         n = n->rb_right;
428                 else
429                         return va;
430         }
431
432         return NULL;
433 }
434
435 /*
436  * This function returns back addresses of parent node
437  * and its left or right link for further processing.
438  */
439 static __always_inline struct rb_node **
440 find_va_links(struct vmap_area *va,
441         struct rb_root *root, struct rb_node *from,
442         struct rb_node **parent)
443 {
444         struct vmap_area *tmp_va;
445         struct rb_node **link;
446
447         if (root) {
448                 link = &root->rb_node;
449                 if (unlikely(!*link)) {
450                         *parent = NULL;
451                         return link;
452                 }
453         } else {
454                 link = &from;
455         }
456
457         /*
458          * Go to the bottom of the tree. When we hit the last point
459          * we end up with parent rb_node and correct direction, i name
460          * it link, where the new va->rb_node will be attached to.
461          */
462         do {
463                 tmp_va = rb_entry(*link, struct vmap_area, rb_node);
464
465                 /*
466                  * During the traversal we also do some sanity check.
467                  * Trigger the BUG() if there are sides(left/right)
468                  * or full overlaps.
469                  */
470                 if (va->va_start < tmp_va->va_end &&
471                                 va->va_end <= tmp_va->va_start)
472                         link = &(*link)->rb_left;
473                 else if (va->va_end > tmp_va->va_start &&
474                                 va->va_start >= tmp_va->va_end)
475                         link = &(*link)->rb_right;
476                 else
477                         BUG();
478         } while (*link);
479
480         *parent = &tmp_va->rb_node;
481         return link;
482 }
483
484 static __always_inline struct list_head *
485 get_va_next_sibling(struct rb_node *parent, struct rb_node **link)
486 {
487         struct list_head *list;
488
489         if (unlikely(!parent))
490                 /*
491                  * The red-black tree where we try to find VA neighbors
492                  * before merging or inserting is empty, i.e. it means
493                  * there is no free vmap space. Normally it does not
494                  * happen but we handle this case anyway.
495                  */
496                 return NULL;
497
498         list = &rb_entry(parent, struct vmap_area, rb_node)->list;
499         return (&parent->rb_right == link ? list->next : list);
500 }
501
502 static __always_inline void
503 link_va(struct vmap_area *va, struct rb_root *root,
504         struct rb_node *parent, struct rb_node **link, struct list_head *head)
505 {
506         /*
507          * VA is still not in the list, but we can
508          * identify its future previous list_head node.
509          */
510         if (likely(parent)) {
511                 head = &rb_entry(parent, struct vmap_area, rb_node)->list;
512                 if (&parent->rb_right != link)
513                         head = head->prev;
514         }
515
516         /* Insert to the rb-tree */
517         rb_link_node(&va->rb_node, parent, link);
518         if (root == &free_vmap_area_root) {
519                 /*
520                  * Some explanation here. Just perform simple insertion
521                  * to the tree. We do not set va->subtree_max_size to
522                  * its current size before calling rb_insert_augmented().
523                  * It is because of we populate the tree from the bottom
524                  * to parent levels when the node _is_ in the tree.
525                  *
526                  * Therefore we set subtree_max_size to zero after insertion,
527                  * to let __augment_tree_propagate_from() puts everything to
528                  * the correct order later on.
529                  */
530                 rb_insert_augmented(&va->rb_node,
531                         root, &free_vmap_area_rb_augment_cb);
532                 va->subtree_max_size = 0;
533         } else {
534                 rb_insert_color(&va->rb_node, root);
535         }
536
537         /* Address-sort this list */
538         list_add(&va->list, head);
539 }
540
541 static __always_inline void
542 unlink_va(struct vmap_area *va, struct rb_root *root)
543 {
544         if (WARN_ON(RB_EMPTY_NODE(&va->rb_node)))
545                 return;
546
547         if (root == &free_vmap_area_root)
548                 rb_erase_augmented(&va->rb_node,
549                         root, &free_vmap_area_rb_augment_cb);
550         else
551                 rb_erase(&va->rb_node, root);
552
553         list_del(&va->list);
554         RB_CLEAR_NODE(&va->rb_node);
555 }
556
557 #if DEBUG_AUGMENT_PROPAGATE_CHECK
558 static void
559 augment_tree_propagate_check(struct rb_node *n)
560 {
561         struct vmap_area *va;
562         struct rb_node *node;
563         unsigned long size;
564         bool found = false;
565
566         if (n == NULL)
567                 return;
568
569         va = rb_entry(n, struct vmap_area, rb_node);
570         size = va->subtree_max_size;
571         node = n;
572
573         while (node) {
574                 va = rb_entry(node, struct vmap_area, rb_node);
575
576                 if (get_subtree_max_size(node->rb_left) == size) {
577                         node = node->rb_left;
578                 } else {
579                         if (va_size(va) == size) {
580                                 found = true;
581                                 break;
582                         }
583
584                         node = node->rb_right;
585                 }
586         }
587
588         if (!found) {
589                 va = rb_entry(n, struct vmap_area, rb_node);
590                 pr_emerg("tree is corrupted: %lu, %lu\n",
591                         va_size(va), va->subtree_max_size);
592         }
593
594         augment_tree_propagate_check(n->rb_left);
595         augment_tree_propagate_check(n->rb_right);
596 }
597 #endif
598
599 /*
600  * This function populates subtree_max_size from bottom to upper
601  * levels starting from VA point. The propagation must be done
602  * when VA size is modified by changing its va_start/va_end. Or
603  * in case of newly inserting of VA to the tree.
604  *
605  * It means that __augment_tree_propagate_from() must be called:
606  * - After VA has been inserted to the tree(free path);
607  * - After VA has been shrunk(allocation path);
608  * - After VA has been increased(merging path).
609  *
610  * Please note that, it does not mean that upper parent nodes
611  * and their subtree_max_size are recalculated all the time up
612  * to the root node.
613  *
614  *       4--8
615  *        /\
616  *       /  \
617  *      /    \
618  *    2--2  8--8
619  *
620  * For example if we modify the node 4, shrinking it to 2, then
621  * no any modification is required. If we shrink the node 2 to 1
622  * its subtree_max_size is updated only, and set to 1. If we shrink
623  * the node 8 to 6, then its subtree_max_size is set to 6 and parent
624  * node becomes 4--6.
625  */
626 static __always_inline void
627 augment_tree_propagate_from(struct vmap_area *va)
628 {
629         struct rb_node *node = &va->rb_node;
630         unsigned long new_va_sub_max_size;
631
632         while (node) {
633                 va = rb_entry(node, struct vmap_area, rb_node);
634                 new_va_sub_max_size = compute_subtree_max_size(va);
635
636                 /*
637                  * If the newly calculated maximum available size of the
638                  * subtree is equal to the current one, then it means that
639                  * the tree is propagated correctly. So we have to stop at
640                  * this point to save cycles.
641                  */
642                 if (va->subtree_max_size == new_va_sub_max_size)
643                         break;
644
645                 va->subtree_max_size = new_va_sub_max_size;
646                 node = rb_parent(&va->rb_node);
647         }
648
649 #if DEBUG_AUGMENT_PROPAGATE_CHECK
650         augment_tree_propagate_check(free_vmap_area_root.rb_node);
651 #endif
652 }
653
654 static void
655 insert_vmap_area(struct vmap_area *va,
656         struct rb_root *root, struct list_head *head)
657 {
658         struct rb_node **link;
659         struct rb_node *parent;
660
661         link = find_va_links(va, root, NULL, &parent);
662         link_va(va, root, parent, link, head);
663 }
664
665 static void
666 insert_vmap_area_augment(struct vmap_area *va,
667         struct rb_node *from, struct rb_root *root,
668         struct list_head *head)
669 {
670         struct rb_node **link;
671         struct rb_node *parent;
672
673         if (from)
674                 link = find_va_links(va, NULL, from, &parent);
675         else
676                 link = find_va_links(va, root, NULL, &parent);
677
678         link_va(va, root, parent, link, head);
679         augment_tree_propagate_from(va);
680 }
681
682 /*
683  * Merge de-allocated chunk of VA memory with previous
684  * and next free blocks. If coalesce is not done a new
685  * free area is inserted. If VA has been merged, it is
686  * freed.
687  */
688 static __always_inline void
689 merge_or_add_vmap_area(struct vmap_area *va,
690         struct rb_root *root, struct list_head *head)
691 {
692         struct vmap_area *sibling;
693         struct list_head *next;
694         struct rb_node **link;
695         struct rb_node *parent;
696         bool merged = false;
697
698         /*
699          * Find a place in the tree where VA potentially will be
700          * inserted, unless it is merged with its sibling/siblings.
701          */
702         link = find_va_links(va, root, NULL, &parent);
703
704         /*
705          * Get next node of VA to check if merging can be done.
706          */
707         next = get_va_next_sibling(parent, link);
708         if (unlikely(next == NULL))
709                 goto insert;
710
711         /*
712          * start            end
713          * |                |
714          * |<------VA------>|<-----Next----->|
715          *                  |                |
716          *                  start            end
717          */
718         if (next != head) {
719                 sibling = list_entry(next, struct vmap_area, list);
720                 if (sibling->va_start == va->va_end) {
721                         sibling->va_start = va->va_start;
722
723                         /* Check and update the tree if needed. */
724                         augment_tree_propagate_from(sibling);
725
726                         /* Free vmap_area object. */
727                         kmem_cache_free(vmap_area_cachep, va);
728
729                         /* Point to the new merged area. */
730                         va = sibling;
731                         merged = true;
732                 }
733         }
734
735         /*
736          * start            end
737          * |                |
738          * |<-----Prev----->|<------VA------>|
739          *                  |                |
740          *                  start            end
741          */
742         if (next->prev != head) {
743                 sibling = list_entry(next->prev, struct vmap_area, list);
744                 if (sibling->va_end == va->va_start) {
745                         sibling->va_end = va->va_end;
746
747                         /* Check and update the tree if needed. */
748                         augment_tree_propagate_from(sibling);
749
750                         if (merged)
751                                 unlink_va(va, root);
752
753                         /* Free vmap_area object. */
754                         kmem_cache_free(vmap_area_cachep, va);
755                         return;
756                 }
757         }
758
759 insert:
760         if (!merged) {
761                 link_va(va, root, parent, link, head);
762                 augment_tree_propagate_from(va);
763         }
764 }
765
766 static __always_inline bool
767 is_within_this_va(struct vmap_area *va, unsigned long size,
768         unsigned long align, unsigned long vstart)
769 {
770         unsigned long nva_start_addr;
771
772         if (va->va_start > vstart)
773                 nva_start_addr = ALIGN(va->va_start, align);
774         else
775                 nva_start_addr = ALIGN(vstart, align);
776
777         /* Can be overflowed due to big size or alignment. */
778         if (nva_start_addr + size < nva_start_addr ||
779                         nva_start_addr < vstart)
780                 return false;
781
782         return (nva_start_addr + size <= va->va_end);
783 }
784
785 /*
786  * Find the first free block(lowest start address) in the tree,
787  * that will accomplish the request corresponding to passing
788  * parameters.
789  */
790 static __always_inline struct vmap_area *
791 find_vmap_lowest_match(unsigned long size,
792         unsigned long align, unsigned long vstart)
793 {
794         struct vmap_area *va;
795         struct rb_node *node;
796         unsigned long length;
797
798         /* Start from the root. */
799         node = free_vmap_area_root.rb_node;
800
801         /* Adjust the search size for alignment overhead. */
802         length = size + align - 1;
803
804         while (node) {
805                 va = rb_entry(node, struct vmap_area, rb_node);
806
807                 if (get_subtree_max_size(node->rb_left) >= length &&
808                                 vstart < va->va_start) {
809                         node = node->rb_left;
810                 } else {
811                         if (is_within_this_va(va, size, align, vstart))
812                                 return va;
813
814                         /*
815                          * Does not make sense to go deeper towards the right
816                          * sub-tree if it does not have a free block that is
817                          * equal or bigger to the requested search length.
818                          */
819                         if (get_subtree_max_size(node->rb_right) >= length) {
820                                 node = node->rb_right;
821                                 continue;
822                         }
823
824                         /*
825                          * OK. We roll back and find the first right sub-tree,
826                          * that will satisfy the search criteria. It can happen
827                          * only once due to "vstart" restriction.
828                          */
829                         while ((node = rb_parent(node))) {
830                                 va = rb_entry(node, struct vmap_area, rb_node);
831                                 if (is_within_this_va(va, size, align, vstart))
832                                         return va;
833
834                                 if (get_subtree_max_size(node->rb_right) >= length &&
835                                                 vstart <= va->va_start) {
836                                         node = node->rb_right;
837                                         break;
838                                 }
839                         }
840                 }
841         }
842
843         return NULL;
844 }
845
846 #if DEBUG_AUGMENT_LOWEST_MATCH_CHECK
847 #include <linux/random.h>
848
849 static struct vmap_area *
850 find_vmap_lowest_linear_match(unsigned long size,
851         unsigned long align, unsigned long vstart)
852 {
853         struct vmap_area *va;
854
855         list_for_each_entry(va, &free_vmap_area_list, list) {
856                 if (!is_within_this_va(va, size, align, vstart))
857                         continue;
858
859                 return va;
860         }
861
862         return NULL;
863 }
864
865 static void
866 find_vmap_lowest_match_check(unsigned long size)
867 {
868         struct vmap_area *va_1, *va_2;
869         unsigned long vstart;
870         unsigned int rnd;
871
872         get_random_bytes(&rnd, sizeof(rnd));
873         vstart = VMALLOC_START + rnd;
874
875         va_1 = find_vmap_lowest_match(size, 1, vstart);
876         va_2 = find_vmap_lowest_linear_match(size, 1, vstart);
877
878         if (va_1 != va_2)
879                 pr_emerg("not lowest: t: 0x%p, l: 0x%p, v: 0x%lx\n",
880                         va_1, va_2, vstart);
881 }
882 #endif
883
884 enum fit_type {
885         NOTHING_FIT = 0,
886         FL_FIT_TYPE = 1,        /* full fit */
887         LE_FIT_TYPE = 2,        /* left edge fit */
888         RE_FIT_TYPE = 3,        /* right edge fit */
889         NE_FIT_TYPE = 4         /* no edge fit */
890 };
891
892 static __always_inline enum fit_type
893 classify_va_fit_type(struct vmap_area *va,
894         unsigned long nva_start_addr, unsigned long size)
895 {
896         enum fit_type type;
897
898         /* Check if it is within VA. */
899         if (nva_start_addr < va->va_start ||
900                         nva_start_addr + size > va->va_end)
901                 return NOTHING_FIT;
902
903         /* Now classify. */
904         if (va->va_start == nva_start_addr) {
905                 if (va->va_end == nva_start_addr + size)
906                         type = FL_FIT_TYPE;
907                 else
908                         type = LE_FIT_TYPE;
909         } else if (va->va_end == nva_start_addr + size) {
910                 type = RE_FIT_TYPE;
911         } else {
912                 type = NE_FIT_TYPE;
913         }
914
915         return type;
916 }
917
918 static __always_inline int
919 adjust_va_to_fit_type(struct vmap_area *va,
920         unsigned long nva_start_addr, unsigned long size,
921         enum fit_type type)
922 {
923         struct vmap_area *lva = NULL;
924
925         if (type == FL_FIT_TYPE) {
926                 /*
927                  * No need to split VA, it fully fits.
928                  *
929                  * |               |
930                  * V      NVA      V
931                  * |---------------|
932                  */
933                 unlink_va(va, &free_vmap_area_root);
934                 kmem_cache_free(vmap_area_cachep, va);
935         } else if (type == LE_FIT_TYPE) {
936                 /*
937                  * Split left edge of fit VA.
938                  *
939                  * |       |
940                  * V  NVA  V   R
941                  * |-------|-------|
942                  */
943                 va->va_start += size;
944         } else if (type == RE_FIT_TYPE) {
945                 /*
946                  * Split right edge of fit VA.
947                  *
948                  *         |       |
949                  *     L   V  NVA  V
950                  * |-------|-------|
951                  */
952                 va->va_end = nva_start_addr;
953         } else if (type == NE_FIT_TYPE) {
954                 /*
955                  * Split no edge of fit VA.
956                  *
957                  *     |       |
958                  *   L V  NVA  V R
959                  * |---|-------|---|
960                  */
961                 lva = __this_cpu_xchg(ne_fit_preload_node, NULL);
962                 if (unlikely(!lva)) {
963                         /*
964                          * For percpu allocator we do not do any pre-allocation
965                          * and leave it as it is. The reason is it most likely
966                          * never ends up with NE_FIT_TYPE splitting. In case of
967                          * percpu allocations offsets and sizes are aligned to
968                          * fixed align request, i.e. RE_FIT_TYPE and FL_FIT_TYPE
969                          * are its main fitting cases.
970                          *
971                          * There are a few exceptions though, as an example it is
972                          * a first allocation (early boot up) when we have "one"
973                          * big free space that has to be split.
974                          */
975                         lva = kmem_cache_alloc(vmap_area_cachep, GFP_NOWAIT);
976                         if (!lva)
977                                 return -1;
978                 }
979
980                 /*
981                  * Build the remainder.
982                  */
983                 lva->va_start = va->va_start;
984                 lva->va_end = nva_start_addr;
985
986                 /*
987                  * Shrink this VA to remaining size.
988                  */
989                 va->va_start = nva_start_addr + size;
990         } else {
991                 return -1;
992         }
993
994         if (type != FL_FIT_TYPE) {
995                 augment_tree_propagate_from(va);
996
997                 if (lva)        /* type == NE_FIT_TYPE */
998                         insert_vmap_area_augment(lva, &va->rb_node,
999                                 &free_vmap_area_root, &free_vmap_area_list);
1000         }
1001
1002         return 0;
1003 }
1004
1005 /*
1006  * Returns a start address of the newly allocated area, if success.
1007  * Otherwise a vend is returned that indicates failure.
1008  */
1009 static __always_inline unsigned long
1010 __alloc_vmap_area(unsigned long size, unsigned long align,
1011         unsigned long vstart, unsigned long vend)
1012 {
1013         unsigned long nva_start_addr;
1014         struct vmap_area *va;
1015         enum fit_type type;
1016         int ret;
1017
1018         va = find_vmap_lowest_match(size, align, vstart);
1019         if (unlikely(!va))
1020                 return vend;
1021
1022         if (va->va_start > vstart)
1023                 nva_start_addr = ALIGN(va->va_start, align);
1024         else
1025                 nva_start_addr = ALIGN(vstart, align);
1026
1027         /* Check the "vend" restriction. */
1028         if (nva_start_addr + size > vend)
1029                 return vend;
1030
1031         /* Classify what we have found. */
1032         type = classify_va_fit_type(va, nva_start_addr, size);
1033         if (WARN_ON_ONCE(type == NOTHING_FIT))
1034                 return vend;
1035
1036         /* Update the free vmap_area. */
1037         ret = adjust_va_to_fit_type(va, nva_start_addr, size, type);
1038         if (ret)
1039                 return vend;
1040
1041 #if DEBUG_AUGMENT_LOWEST_MATCH_CHECK
1042         find_vmap_lowest_match_check(size);
1043 #endif
1044
1045         return nva_start_addr;
1046 }
1047
1048 /*
1049  * Allocate a region of KVA of the specified size and alignment, within the
1050  * vstart and vend.
1051  */
1052 static struct vmap_area *alloc_vmap_area(unsigned long size,
1053                                 unsigned long align,
1054                                 unsigned long vstart, unsigned long vend,
1055                                 int node, gfp_t gfp_mask)
1056 {
1057         struct vmap_area *va, *pva;
1058         unsigned long addr;
1059         int purged = 0;
1060
1061         BUG_ON(!size);
1062         BUG_ON(offset_in_page(size));
1063         BUG_ON(!is_power_of_2(align));
1064
1065         if (unlikely(!vmap_initialized))
1066                 return ERR_PTR(-EBUSY);
1067
1068         might_sleep();
1069
1070         va = kmem_cache_alloc_node(vmap_area_cachep,
1071                         gfp_mask & GFP_RECLAIM_MASK, node);
1072         if (unlikely(!va))
1073                 return ERR_PTR(-ENOMEM);
1074
1075         /*
1076          * Only scan the relevant parts containing pointers to other objects
1077          * to avoid false negatives.
1078          */
1079         kmemleak_scan_area(&va->rb_node, SIZE_MAX, gfp_mask & GFP_RECLAIM_MASK);
1080
1081 retry:
1082         /*
1083          * Preload this CPU with one extra vmap_area object to ensure
1084          * that we have it available when fit type of free area is
1085          * NE_FIT_TYPE.
1086          *
1087          * The preload is done in non-atomic context, thus it allows us
1088          * to use more permissive allocation masks to be more stable under
1089          * low memory condition and high memory pressure.
1090          *
1091          * Even if it fails we do not really care about that. Just proceed
1092          * as it is. "overflow" path will refill the cache we allocate from.
1093          */
1094         preempt_disable();
1095         if (!__this_cpu_read(ne_fit_preload_node)) {
1096                 preempt_enable();
1097                 pva = kmem_cache_alloc_node(vmap_area_cachep, GFP_KERNEL, node);
1098                 preempt_disable();
1099
1100                 if (__this_cpu_cmpxchg(ne_fit_preload_node, NULL, pva)) {
1101                         if (pva)
1102                                 kmem_cache_free(vmap_area_cachep, pva);
1103                 }
1104         }
1105
1106         spin_lock(&vmap_area_lock);
1107         preempt_enable();
1108
1109         /*
1110          * If an allocation fails, the "vend" address is
1111          * returned. Therefore trigger the overflow path.
1112          */
1113         addr = __alloc_vmap_area(size, align, vstart, vend);
1114         if (unlikely(addr == vend))
1115                 goto overflow;
1116
1117         va->va_start = addr;
1118         va->va_end = addr + size;
1119         va->flags = 0;
1120         insert_vmap_area(va, &vmap_area_root, &vmap_area_list);
1121
1122         spin_unlock(&vmap_area_lock);
1123
1124         BUG_ON(!IS_ALIGNED(va->va_start, align));
1125         BUG_ON(va->va_start < vstart);
1126         BUG_ON(va->va_end > vend);
1127
1128         return va;
1129
1130 overflow:
1131         spin_unlock(&vmap_area_lock);
1132         if (!purged) {
1133                 purge_vmap_area_lazy();
1134                 purged = 1;
1135                 goto retry;
1136         }
1137
1138         if (gfpflags_allow_blocking(gfp_mask)) {
1139                 unsigned long freed = 0;
1140                 blocking_notifier_call_chain(&vmap_notify_list, 0, &freed);
1141                 if (freed > 0) {
1142                         purged = 0;
1143                         goto retry;
1144                 }
1145         }
1146
1147         if (!(gfp_mask & __GFP_NOWARN) && printk_ratelimit())
1148                 pr_warn("vmap allocation for size %lu failed: use vmalloc=<size> to increase size\n",
1149                         size);
1150
1151         kmem_cache_free(vmap_area_cachep, va);
1152         return ERR_PTR(-EBUSY);
1153 }
1154
1155 int register_vmap_purge_notifier(struct notifier_block *nb)
1156 {
1157         return blocking_notifier_chain_register(&vmap_notify_list, nb);
1158 }
1159 EXPORT_SYMBOL_GPL(register_vmap_purge_notifier);
1160
1161 int unregister_vmap_purge_notifier(struct notifier_block *nb)
1162 {
1163         return blocking_notifier_chain_unregister(&vmap_notify_list, nb);
1164 }
1165 EXPORT_SYMBOL_GPL(unregister_vmap_purge_notifier);
1166
1167 static void __free_vmap_area(struct vmap_area *va)
1168 {
1169         /*
1170          * Remove from the busy tree/list.
1171          */
1172         unlink_va(va, &vmap_area_root);
1173
1174         /*
1175          * Merge VA with its neighbors, otherwise just add it.
1176          */
1177         merge_or_add_vmap_area(va,
1178                 &free_vmap_area_root, &free_vmap_area_list);
1179 }
1180
1181 /*
1182  * Free a region of KVA allocated by alloc_vmap_area
1183  */
1184 static void free_vmap_area(struct vmap_area *va)
1185 {
1186         spin_lock(&vmap_area_lock);
1187         __free_vmap_area(va);
1188         spin_unlock(&vmap_area_lock);
1189 }
1190
1191 /*
1192  * Clear the pagetable entries of a given vmap_area
1193  */
1194 static void unmap_vmap_area(struct vmap_area *va)
1195 {
1196         vunmap_page_range(va->va_start, va->va_end);
1197 }
1198
1199 /*
1200  * lazy_max_pages is the maximum amount of virtual address space we gather up
1201  * before attempting to purge with a TLB flush.
1202  *
1203  * There is a tradeoff here: a larger number will cover more kernel page tables
1204  * and take slightly longer to purge, but it will linearly reduce the number of
1205  * global TLB flushes that must be performed. It would seem natural to scale
1206  * this number up linearly with the number of CPUs (because vmapping activity
1207  * could also scale linearly with the number of CPUs), however it is likely
1208  * that in practice, workloads might be constrained in other ways that mean
1209  * vmap activity will not scale linearly with CPUs. Also, I want to be
1210  * conservative and not introduce a big latency on huge systems, so go with
1211  * a less aggressive log scale. It will still be an improvement over the old
1212  * code, and it will be simple to change the scale factor if we find that it
1213  * becomes a problem on bigger systems.
1214  */
1215 static unsigned long lazy_max_pages(void)
1216 {
1217         unsigned int log;
1218
1219         log = fls(num_online_cpus());
1220
1221         return log * (32UL * 1024 * 1024 / PAGE_SIZE);
1222 }
1223
1224 static atomic_long_t vmap_lazy_nr = ATOMIC_LONG_INIT(0);
1225
1226 /*
1227  * Serialize vmap purging.  There is no actual criticial section protected
1228  * by this look, but we want to avoid concurrent calls for performance
1229  * reasons and to make the pcpu_get_vm_areas more deterministic.
1230  */
1231 static DEFINE_MUTEX(vmap_purge_lock);
1232
1233 /* for per-CPU blocks */
1234 static void purge_fragmented_blocks_allcpus(void);
1235
1236 /*
1237  * called before a call to iounmap() if the caller wants vm_area_struct's
1238  * immediately freed.
1239  */
1240 void set_iounmap_nonlazy(void)
1241 {
1242         atomic_long_set(&vmap_lazy_nr, lazy_max_pages()+1);
1243 }
1244
1245 /*
1246  * Purges all lazily-freed vmap areas.
1247  */
1248 static bool __purge_vmap_area_lazy(unsigned long start, unsigned long end)
1249 {
1250         unsigned long resched_threshold;
1251         struct llist_node *valist;
1252         struct vmap_area *va;
1253         struct vmap_area *n_va;
1254
1255         lockdep_assert_held(&vmap_purge_lock);
1256
1257         valist = llist_del_all(&vmap_purge_list);
1258         if (unlikely(valist == NULL))
1259                 return false;
1260
1261         /*
1262          * TODO: to calculate a flush range without looping.
1263          * The list can be up to lazy_max_pages() elements.
1264          */
1265         llist_for_each_entry(va, valist, purge_list) {
1266                 if (va->va_start < start)
1267                         start = va->va_start;
1268                 if (va->va_end > end)
1269                         end = va->va_end;
1270         }
1271
1272         flush_tlb_kernel_range(start, end);
1273         resched_threshold = lazy_max_pages() << 1;
1274
1275         spin_lock(&vmap_area_lock);
1276         llist_for_each_entry_safe(va, n_va, valist, purge_list) {
1277                 unsigned long nr = (va->va_end - va->va_start) >> PAGE_SHIFT;
1278
1279                 __free_vmap_area(va);
1280                 atomic_long_sub(nr, &vmap_lazy_nr);
1281
1282                 if (atomic_long_read(&vmap_lazy_nr) < resched_threshold)
1283                         cond_resched_lock(&vmap_area_lock);
1284         }
1285         spin_unlock(&vmap_area_lock);
1286         return true;
1287 }
1288
1289 /*
1290  * Kick off a purge of the outstanding lazy areas. Don't bother if somebody
1291  * is already purging.
1292  */
1293 static void try_purge_vmap_area_lazy(void)
1294 {
1295         if (mutex_trylock(&vmap_purge_lock)) {
1296                 __purge_vmap_area_lazy(ULONG_MAX, 0);
1297                 mutex_unlock(&vmap_purge_lock);
1298         }
1299 }
1300
1301 /*
1302  * Kick off a purge of the outstanding lazy areas.
1303  */
1304 static void purge_vmap_area_lazy(void)
1305 {
1306         mutex_lock(&vmap_purge_lock);
1307         purge_fragmented_blocks_allcpus();
1308         __purge_vmap_area_lazy(ULONG_MAX, 0);
1309         mutex_unlock(&vmap_purge_lock);
1310 }
1311
1312 /*
1313  * Free a vmap area, caller ensuring that the area has been unmapped
1314  * and flush_cache_vunmap had been called for the correct range
1315  * previously.
1316  */
1317 static void free_vmap_area_noflush(struct vmap_area *va)
1318 {
1319         unsigned long nr_lazy;
1320
1321         nr_lazy = atomic_long_add_return((va->va_end - va->va_start) >>
1322                                 PAGE_SHIFT, &vmap_lazy_nr);
1323
1324         /* After this point, we may free va at any time */
1325         llist_add(&va->purge_list, &vmap_purge_list);
1326
1327         if (unlikely(nr_lazy > lazy_max_pages()))
1328                 try_purge_vmap_area_lazy();
1329 }
1330
1331 /*
1332  * Free and unmap a vmap area
1333  */
1334 static void free_unmap_vmap_area(struct vmap_area *va)
1335 {
1336         flush_cache_vunmap(va->va_start, va->va_end);
1337         unmap_vmap_area(va);
1338         if (debug_pagealloc_enabled())
1339                 flush_tlb_kernel_range(va->va_start, va->va_end);
1340
1341         free_vmap_area_noflush(va);
1342 }
1343
1344 static struct vmap_area *find_vmap_area(unsigned long addr)
1345 {
1346         struct vmap_area *va;
1347
1348         spin_lock(&vmap_area_lock);
1349         va = __find_vmap_area(addr);
1350         spin_unlock(&vmap_area_lock);
1351
1352         return va;
1353 }
1354
1355 /*** Per cpu kva allocator ***/
1356
1357 /*
1358  * vmap space is limited especially on 32 bit architectures. Ensure there is
1359  * room for at least 16 percpu vmap blocks per CPU.
1360  */
1361 /*
1362  * If we had a constant VMALLOC_START and VMALLOC_END, we'd like to be able
1363  * to #define VMALLOC_SPACE             (VMALLOC_END-VMALLOC_START). Guess
1364  * instead (we just need a rough idea)
1365  */
1366 #if BITS_PER_LONG == 32
1367 #define VMALLOC_SPACE           (128UL*1024*1024)
1368 #else
1369 #define VMALLOC_SPACE           (128UL*1024*1024*1024)
1370 #endif
1371
1372 #define VMALLOC_PAGES           (VMALLOC_SPACE / PAGE_SIZE)
1373 #define VMAP_MAX_ALLOC          BITS_PER_LONG   /* 256K with 4K pages */
1374 #define VMAP_BBMAP_BITS_MAX     1024    /* 4MB with 4K pages */
1375 #define VMAP_BBMAP_BITS_MIN     (VMAP_MAX_ALLOC*2)
1376 #define VMAP_MIN(x, y)          ((x) < (y) ? (x) : (y)) /* can't use min() */
1377 #define VMAP_MAX(x, y)          ((x) > (y) ? (x) : (y)) /* can't use max() */
1378 #define VMAP_BBMAP_BITS         \
1379                 VMAP_MIN(VMAP_BBMAP_BITS_MAX,   \
1380                 VMAP_MAX(VMAP_BBMAP_BITS_MIN,   \
1381                         VMALLOC_PAGES / roundup_pow_of_two(NR_CPUS) / 16))
1382
1383 #define VMAP_BLOCK_SIZE         (VMAP_BBMAP_BITS * PAGE_SIZE)
1384
1385 struct vmap_block_queue {
1386         spinlock_t lock;
1387         struct list_head free;
1388 };
1389
1390 struct vmap_block {
1391         spinlock_t lock;
1392         struct vmap_area *va;
1393         unsigned long free, dirty;
1394         unsigned long dirty_min, dirty_max; /*< dirty range */
1395         struct list_head free_list;
1396         struct rcu_head rcu_head;
1397         struct list_head purge;
1398 };
1399
1400 /* Queue of free and dirty vmap blocks, for allocation and flushing purposes */
1401 static DEFINE_PER_CPU(struct vmap_block_queue, vmap_block_queue);
1402
1403 /*
1404  * Radix tree of vmap blocks, indexed by address, to quickly find a vmap block
1405  * in the free path. Could get rid of this if we change the API to return a
1406  * "cookie" from alloc, to be passed to free. But no big deal yet.
1407  */
1408 static DEFINE_SPINLOCK(vmap_block_tree_lock);
1409 static RADIX_TREE(vmap_block_tree, GFP_ATOMIC);
1410
1411 /*
1412  * We should probably have a fallback mechanism to allocate virtual memory
1413  * out of partially filled vmap blocks. However vmap block sizing should be
1414  * fairly reasonable according to the vmalloc size, so it shouldn't be a
1415  * big problem.
1416  */
1417
1418 static unsigned long addr_to_vb_idx(unsigned long addr)
1419 {
1420         addr -= VMALLOC_START & ~(VMAP_BLOCK_SIZE-1);
1421         addr /= VMAP_BLOCK_SIZE;
1422         return addr;
1423 }
1424
1425 static void *vmap_block_vaddr(unsigned long va_start, unsigned long pages_off)
1426 {
1427         unsigned long addr;
1428
1429         addr = va_start + (pages_off << PAGE_SHIFT);
1430         BUG_ON(addr_to_vb_idx(addr) != addr_to_vb_idx(va_start));
1431         return (void *)addr;
1432 }
1433
1434 /**
1435  * new_vmap_block - allocates new vmap_block and occupies 2^order pages in this
1436  *                  block. Of course pages number can't exceed VMAP_BBMAP_BITS
1437  * @order:    how many 2^order pages should be occupied in newly allocated block
1438  * @gfp_mask: flags for the page level allocator
1439  *
1440  * Return: virtual address in a newly allocated block or ERR_PTR(-errno)
1441  */
1442 static void *new_vmap_block(unsigned int order, gfp_t gfp_mask)
1443 {
1444         struct vmap_block_queue *vbq;
1445         struct vmap_block *vb;
1446         struct vmap_area *va;
1447         unsigned long vb_idx;
1448         int node, err;
1449         void *vaddr;
1450
1451         node = numa_node_id();
1452
1453         vb = kmalloc_node(sizeof(struct vmap_block),
1454                         gfp_mask & GFP_RECLAIM_MASK, node);
1455         if (unlikely(!vb))
1456                 return ERR_PTR(-ENOMEM);
1457
1458         va = alloc_vmap_area(VMAP_BLOCK_SIZE, VMAP_BLOCK_SIZE,
1459                                         VMALLOC_START, VMALLOC_END,
1460                                         node, gfp_mask);
1461         if (IS_ERR(va)) {
1462                 kfree(vb);
1463                 return ERR_CAST(va);
1464         }
1465
1466         err = radix_tree_preload(gfp_mask);
1467         if (unlikely(err)) {
1468                 kfree(vb);
1469                 free_vmap_area(va);
1470                 return ERR_PTR(err);
1471         }
1472
1473         vaddr = vmap_block_vaddr(va->va_start, 0);
1474         spin_lock_init(&vb->lock);
1475         vb->va = va;
1476         /* At least something should be left free */
1477         BUG_ON(VMAP_BBMAP_BITS <= (1UL << order));
1478         vb->free = VMAP_BBMAP_BITS - (1UL << order);
1479         vb->dirty = 0;
1480         vb->dirty_min = VMAP_BBMAP_BITS;
1481         vb->dirty_max = 0;
1482         INIT_LIST_HEAD(&vb->free_list);
1483
1484         vb_idx = addr_to_vb_idx(va->va_start);
1485         spin_lock(&vmap_block_tree_lock);
1486         err = radix_tree_insert(&vmap_block_tree, vb_idx, vb);
1487         spin_unlock(&vmap_block_tree_lock);
1488         BUG_ON(err);
1489         radix_tree_preload_end();
1490
1491         vbq = &get_cpu_var(vmap_block_queue);
1492         spin_lock(&vbq->lock);
1493         list_add_tail_rcu(&vb->free_list, &vbq->free);
1494         spin_unlock(&vbq->lock);
1495         put_cpu_var(vmap_block_queue);
1496
1497         return vaddr;
1498 }
1499
1500 static void free_vmap_block(struct vmap_block *vb)
1501 {
1502         struct vmap_block *tmp;
1503         unsigned long vb_idx;
1504
1505         vb_idx = addr_to_vb_idx(vb->va->va_start);
1506         spin_lock(&vmap_block_tree_lock);
1507         tmp = radix_tree_delete(&vmap_block_tree, vb_idx);
1508         spin_unlock(&vmap_block_tree_lock);
1509         BUG_ON(tmp != vb);
1510
1511         free_vmap_area_noflush(vb->va);
1512         kfree_rcu(vb, rcu_head);
1513 }
1514
1515 static void purge_fragmented_blocks(int cpu)
1516 {
1517         LIST_HEAD(purge);
1518         struct vmap_block *vb;
1519         struct vmap_block *n_vb;
1520         struct vmap_block_queue *vbq = &per_cpu(vmap_block_queue, cpu);
1521
1522         rcu_read_lock();
1523         list_for_each_entry_rcu(vb, &vbq->free, free_list) {
1524
1525                 if (!(vb->free + vb->dirty == VMAP_BBMAP_BITS && vb->dirty != VMAP_BBMAP_BITS))
1526                         continue;
1527
1528                 spin_lock(&vb->lock);
1529                 if (vb->free + vb->dirty == VMAP_BBMAP_BITS && vb->dirty != VMAP_BBMAP_BITS) {
1530                         vb->free = 0; /* prevent further allocs after releasing lock */
1531                         vb->dirty = VMAP_BBMAP_BITS; /* prevent purging it again */
1532                         vb->dirty_min = 0;
1533                         vb->dirty_max = VMAP_BBMAP_BITS;
1534                         spin_lock(&vbq->lock);
1535                         list_del_rcu(&vb->free_list);
1536                         spin_unlock(&vbq->lock);
1537                         spin_unlock(&vb->lock);
1538                         list_add_tail(&vb->purge, &purge);
1539                 } else
1540                         spin_unlock(&vb->lock);
1541         }
1542         rcu_read_unlock();
1543
1544         list_for_each_entry_safe(vb, n_vb, &purge, purge) {
1545                 list_del(&vb->purge);
1546                 free_vmap_block(vb);
1547         }
1548 }
1549
1550 static void purge_fragmented_blocks_allcpus(void)
1551 {
1552         int cpu;
1553
1554         for_each_possible_cpu(cpu)
1555                 purge_fragmented_blocks(cpu);
1556 }
1557
1558 static void *vb_alloc(unsigned long size, gfp_t gfp_mask)
1559 {
1560         struct vmap_block_queue *vbq;
1561         struct vmap_block *vb;
1562         void *vaddr = NULL;
1563         unsigned int order;
1564
1565         BUG_ON(offset_in_page(size));
1566         BUG_ON(size > PAGE_SIZE*VMAP_MAX_ALLOC);
1567         if (WARN_ON(size == 0)) {
1568                 /*
1569                  * Allocating 0 bytes isn't what caller wants since
1570                  * get_order(0) returns funny result. Just warn and terminate
1571                  * early.
1572                  */
1573                 return NULL;
1574         }
1575         order = get_order(size);
1576
1577         rcu_read_lock();
1578         vbq = &get_cpu_var(vmap_block_queue);
1579         list_for_each_entry_rcu(vb, &vbq->free, free_list) {
1580                 unsigned long pages_off;
1581
1582                 spin_lock(&vb->lock);
1583                 if (vb->free < (1UL << order)) {
1584                         spin_unlock(&vb->lock);
1585                         continue;
1586                 }
1587
1588                 pages_off = VMAP_BBMAP_BITS - vb->free;
1589                 vaddr = vmap_block_vaddr(vb->va->va_start, pages_off);
1590                 vb->free -= 1UL << order;
1591                 if (vb->free == 0) {
1592                         spin_lock(&vbq->lock);
1593                         list_del_rcu(&vb->free_list);
1594                         spin_unlock(&vbq->lock);
1595                 }
1596
1597                 spin_unlock(&vb->lock);
1598                 break;
1599         }
1600
1601         put_cpu_var(vmap_block_queue);
1602         rcu_read_unlock();
1603
1604         /* Allocate new block if nothing was found */
1605         if (!vaddr)
1606                 vaddr = new_vmap_block(order, gfp_mask);
1607
1608         return vaddr;
1609 }
1610
1611 static void vb_free(const void *addr, unsigned long size)
1612 {
1613         unsigned long offset;
1614         unsigned long vb_idx;
1615         unsigned int order;
1616         struct vmap_block *vb;
1617
1618         BUG_ON(offset_in_page(size));
1619         BUG_ON(size > PAGE_SIZE*VMAP_MAX_ALLOC);
1620
1621         flush_cache_vunmap((unsigned long)addr, (unsigned long)addr + size);
1622
1623         order = get_order(size);
1624
1625         offset = (unsigned long)addr & (VMAP_BLOCK_SIZE - 1);
1626         offset >>= PAGE_SHIFT;
1627
1628         vb_idx = addr_to_vb_idx((unsigned long)addr);
1629         rcu_read_lock();
1630         vb = radix_tree_lookup(&vmap_block_tree, vb_idx);
1631         rcu_read_unlock();
1632         BUG_ON(!vb);
1633
1634         vunmap_page_range((unsigned long)addr, (unsigned long)addr + size);
1635
1636         if (debug_pagealloc_enabled())
1637                 flush_tlb_kernel_range((unsigned long)addr,
1638                                         (unsigned long)addr + size);
1639
1640         spin_lock(&vb->lock);
1641
1642         /* Expand dirty range */
1643         vb->dirty_min = min(vb->dirty_min, offset);
1644         vb->dirty_max = max(vb->dirty_max, offset + (1UL << order));
1645
1646         vb->dirty += 1UL << order;
1647         if (vb->dirty == VMAP_BBMAP_BITS) {
1648                 BUG_ON(vb->free);
1649                 spin_unlock(&vb->lock);
1650                 free_vmap_block(vb);
1651         } else
1652                 spin_unlock(&vb->lock);
1653 }
1654
1655 static void _vm_unmap_aliases(unsigned long start, unsigned long end, int flush)
1656 {
1657         int cpu;
1658
1659         if (unlikely(!vmap_initialized))
1660                 return;
1661
1662         might_sleep();
1663
1664         for_each_possible_cpu(cpu) {
1665                 struct vmap_block_queue *vbq = &per_cpu(vmap_block_queue, cpu);
1666                 struct vmap_block *vb;
1667
1668                 rcu_read_lock();
1669                 list_for_each_entry_rcu(vb, &vbq->free, free_list) {
1670                         spin_lock(&vb->lock);
1671                         if (vb->dirty) {
1672                                 unsigned long va_start = vb->va->va_start;
1673                                 unsigned long s, e;
1674
1675                                 s = va_start + (vb->dirty_min << PAGE_SHIFT);
1676                                 e = va_start + (vb->dirty_max << PAGE_SHIFT);
1677
1678                                 start = min(s, start);
1679                                 end   = max(e, end);
1680
1681                                 flush = 1;
1682                         }
1683                         spin_unlock(&vb->lock);
1684                 }
1685                 rcu_read_unlock();
1686         }
1687
1688         mutex_lock(&vmap_purge_lock);
1689         purge_fragmented_blocks_allcpus();
1690         if (!__purge_vmap_area_lazy(start, end) && flush)
1691                 flush_tlb_kernel_range(start, end);
1692         mutex_unlock(&vmap_purge_lock);
1693 }
1694
1695 /**
1696  * vm_unmap_aliases - unmap outstanding lazy aliases in the vmap layer
1697  *
1698  * The vmap/vmalloc layer lazily flushes kernel virtual mappings primarily
1699  * to amortize TLB flushing overheads. What this means is that any page you
1700  * have now, may, in a former life, have been mapped into kernel virtual
1701  * address by the vmap layer and so there might be some CPUs with TLB entries
1702  * still referencing that page (additional to the regular 1:1 kernel mapping).
1703  *
1704  * vm_unmap_aliases flushes all such lazy mappings. After it returns, we can
1705  * be sure that none of the pages we have control over will have any aliases
1706  * from the vmap layer.
1707  */
1708 void vm_unmap_aliases(void)
1709 {
1710         unsigned long start = ULONG_MAX, end = 0;
1711         int flush = 0;
1712
1713         _vm_unmap_aliases(start, end, flush);
1714 }
1715 EXPORT_SYMBOL_GPL(vm_unmap_aliases);
1716
1717 /**
1718  * vm_unmap_ram - unmap linear kernel address space set up by vm_map_ram
1719  * @mem: the pointer returned by vm_map_ram
1720  * @count: the count passed to that vm_map_ram call (cannot unmap partial)
1721  */
1722 void vm_unmap_ram(const void *mem, unsigned int count)
1723 {
1724         unsigned long size = (unsigned long)count << PAGE_SHIFT;
1725         unsigned long addr = (unsigned long)mem;
1726         struct vmap_area *va;
1727
1728         might_sleep();
1729         BUG_ON(!addr);
1730         BUG_ON(addr < VMALLOC_START);
1731         BUG_ON(addr > VMALLOC_END);
1732         BUG_ON(!PAGE_ALIGNED(addr));
1733
1734         if (likely(count <= VMAP_MAX_ALLOC)) {
1735                 debug_check_no_locks_freed(mem, size);
1736                 vb_free(mem, size);
1737                 return;
1738         }
1739
1740         va = find_vmap_area(addr);
1741         BUG_ON(!va);
1742         debug_check_no_locks_freed((void *)va->va_start,
1743                                     (va->va_end - va->va_start));
1744         free_unmap_vmap_area(va);
1745 }
1746 EXPORT_SYMBOL(vm_unmap_ram);
1747
1748 /**
1749  * vm_map_ram - map pages linearly into kernel virtual address (vmalloc space)
1750  * @pages: an array of pointers to the pages to be mapped
1751  * @count: number of pages
1752  * @node: prefer to allocate data structures on this node
1753  * @prot: memory protection to use. PAGE_KERNEL for regular RAM
1754  *
1755  * If you use this function for less than VMAP_MAX_ALLOC pages, it could be
1756  * faster than vmap so it's good.  But if you mix long-life and short-life
1757  * objects with vm_map_ram(), it could consume lots of address space through
1758  * fragmentation (especially on a 32bit machine).  You could see failures in
1759  * the end.  Please use this function for short-lived objects.
1760  *
1761  * Returns: a pointer to the address that has been mapped, or %NULL on failure
1762  */
1763 void *vm_map_ram(struct page **pages, unsigned int count, int node, pgprot_t prot)
1764 {
1765         unsigned long size = (unsigned long)count << PAGE_SHIFT;
1766         unsigned long addr;
1767         void *mem;
1768
1769         if (likely(count <= VMAP_MAX_ALLOC)) {
1770                 mem = vb_alloc(size, GFP_KERNEL);
1771                 if (IS_ERR(mem))
1772                         return NULL;
1773                 addr = (unsigned long)mem;
1774         } else {
1775                 struct vmap_area *va;
1776                 va = alloc_vmap_area(size, PAGE_SIZE,
1777                                 VMALLOC_START, VMALLOC_END, node, GFP_KERNEL);
1778                 if (IS_ERR(va))
1779                         return NULL;
1780
1781                 addr = va->va_start;
1782                 mem = (void *)addr;
1783         }
1784         if (vmap_page_range(addr, addr + size, prot, pages) < 0) {
1785                 vm_unmap_ram(mem, count);
1786                 return NULL;
1787         }
1788         return mem;
1789 }
1790 EXPORT_SYMBOL(vm_map_ram);
1791
1792 static struct vm_struct *vmlist __initdata;
1793
1794 /**
1795  * vm_area_add_early - add vmap area early during boot
1796  * @vm: vm_struct to add
1797  *
1798  * This function is used to add fixed kernel vm area to vmlist before
1799  * vmalloc_init() is called.  @vm->addr, @vm->size, and @vm->flags
1800  * should contain proper values and the other fields should be zero.
1801  *
1802  * DO NOT USE THIS FUNCTION UNLESS YOU KNOW WHAT YOU'RE DOING.
1803  */
1804 void __init vm_area_add_early(struct vm_struct *vm)
1805 {
1806         struct vm_struct *tmp, **p;
1807
1808         BUG_ON(vmap_initialized);
1809         for (p = &vmlist; (tmp = *p) != NULL; p = &tmp->next) {
1810                 if (tmp->addr >= vm->addr) {
1811                         BUG_ON(tmp->addr < vm->addr + vm->size);
1812                         break;
1813                 } else
1814                         BUG_ON(tmp->addr + tmp->size > vm->addr);
1815         }
1816         vm->next = *p;
1817         *p = vm;
1818 }
1819
1820 /**
1821  * vm_area_register_early - register vmap area early during boot
1822  * @vm: vm_struct to register
1823  * @align: requested alignment
1824  *
1825  * This function is used to register kernel vm area before
1826  * vmalloc_init() is called.  @vm->size and @vm->flags should contain
1827  * proper values on entry and other fields should be zero.  On return,
1828  * vm->addr contains the allocated address.
1829  *
1830  * DO NOT USE THIS FUNCTION UNLESS YOU KNOW WHAT YOU'RE DOING.
1831  */
1832 void __init vm_area_register_early(struct vm_struct *vm, size_t align)
1833 {
1834         static size_t vm_init_off __initdata;
1835         unsigned long addr;
1836
1837         addr = ALIGN(VMALLOC_START + vm_init_off, align);
1838         vm_init_off = PFN_ALIGN(addr + vm->size) - VMALLOC_START;
1839
1840         vm->addr = (void *)addr;
1841
1842         vm_area_add_early(vm);
1843 }
1844
1845 static void vmap_init_free_space(void)
1846 {
1847         unsigned long vmap_start = 1;
1848         const unsigned long vmap_end = ULONG_MAX;
1849         struct vmap_area *busy, *free;
1850
1851         /*
1852          *     B     F     B     B     B     F
1853          * -|-----|.....|-----|-----|-----|.....|-
1854          *  |           The KVA space           |
1855          *  |<--------------------------------->|
1856          */
1857         list_for_each_entry(busy, &vmap_area_list, list) {
1858                 if (busy->va_start - vmap_start > 0) {
1859                         free = kmem_cache_zalloc(vmap_area_cachep, GFP_NOWAIT);
1860                         if (!WARN_ON_ONCE(!free)) {
1861                                 free->va_start = vmap_start;
1862                                 free->va_end = busy->va_start;
1863
1864                                 insert_vmap_area_augment(free, NULL,
1865                                         &free_vmap_area_root,
1866                                                 &free_vmap_area_list);
1867                         }
1868                 }
1869
1870                 vmap_start = busy->va_end;
1871         }
1872
1873         if (vmap_end - vmap_start > 0) {
1874                 free = kmem_cache_zalloc(vmap_area_cachep, GFP_NOWAIT);
1875                 if (!WARN_ON_ONCE(!free)) {
1876                         free->va_start = vmap_start;
1877                         free->va_end = vmap_end;
1878
1879                         insert_vmap_area_augment(free, NULL,
1880                                 &free_vmap_area_root,
1881                                         &free_vmap_area_list);
1882                 }
1883         }
1884 }
1885
1886 void __init vmalloc_init(void)
1887 {
1888         struct vmap_area *va;
1889         struct vm_struct *tmp;
1890         int i;
1891
1892         /*
1893          * Create the cache for vmap_area objects.
1894          */
1895         vmap_area_cachep = KMEM_CACHE(vmap_area, SLAB_PANIC);
1896
1897         for_each_possible_cpu(i) {
1898                 struct vmap_block_queue *vbq;
1899                 struct vfree_deferred *p;
1900
1901                 vbq = &per_cpu(vmap_block_queue, i);
1902                 spin_lock_init(&vbq->lock);
1903                 INIT_LIST_HEAD(&vbq->free);
1904                 p = &per_cpu(vfree_deferred, i);
1905                 init_llist_head(&p->list);
1906                 INIT_WORK(&p->wq, free_work);
1907         }
1908
1909         /* Import existing vmlist entries. */
1910         for (tmp = vmlist; tmp; tmp = tmp->next) {
1911                 va = kmem_cache_zalloc(vmap_area_cachep, GFP_NOWAIT);
1912                 if (WARN_ON_ONCE(!va))
1913                         continue;
1914
1915                 va->flags = VM_VM_AREA;
1916                 va->va_start = (unsigned long)tmp->addr;
1917                 va->va_end = va->va_start + tmp->size;
1918                 va->vm = tmp;
1919                 insert_vmap_area(va, &vmap_area_root, &vmap_area_list);
1920         }
1921
1922         /*
1923          * Now we can initialize a free vmap space.
1924          */
1925         vmap_init_free_space();
1926         vmap_initialized = true;
1927 }
1928
1929 /**
1930  * map_kernel_range_noflush - map kernel VM area with the specified pages
1931  * @addr: start of the VM area to map
1932  * @size: size of the VM area to map
1933  * @prot: page protection flags to use
1934  * @pages: pages to map
1935  *
1936  * Map PFN_UP(@size) pages at @addr.  The VM area @addr and @size
1937  * specify should have been allocated using get_vm_area() and its
1938  * friends.
1939  *
1940  * NOTE:
1941  * This function does NOT do any cache flushing.  The caller is
1942  * responsible for calling flush_cache_vmap() on to-be-mapped areas
1943  * before calling this function.
1944  *
1945  * RETURNS:
1946  * The number of pages mapped on success, -errno on failure.
1947  */
1948 int map_kernel_range_noflush(unsigned long addr, unsigned long size,
1949                              pgprot_t prot, struct page **pages)
1950 {
1951         return vmap_page_range_noflush(addr, addr + size, prot, pages);
1952 }
1953
1954 /**
1955  * unmap_kernel_range_noflush - unmap kernel VM area
1956  * @addr: start of the VM area to unmap
1957  * @size: size of the VM area to unmap
1958  *
1959  * Unmap PFN_UP(@size) pages at @addr.  The VM area @addr and @size
1960  * specify should have been allocated using get_vm_area() and its
1961  * friends.
1962  *
1963  * NOTE:
1964  * This function does NOT do any cache flushing.  The caller is
1965  * responsible for calling flush_cache_vunmap() on to-be-mapped areas
1966  * before calling this function and flush_tlb_kernel_range() after.
1967  */
1968 void unmap_kernel_range_noflush(unsigned long addr, unsigned long size)
1969 {
1970         vunmap_page_range(addr, addr + size);
1971 }
1972 EXPORT_SYMBOL_GPL(unmap_kernel_range_noflush);
1973
1974 /**
1975  * unmap_kernel_range - unmap kernel VM area and flush cache and TLB
1976  * @addr: start of the VM area to unmap
1977  * @size: size of the VM area to unmap
1978  *
1979  * Similar to unmap_kernel_range_noflush() but flushes vcache before
1980  * the unmapping and tlb after.
1981  */
1982 void unmap_kernel_range(unsigned long addr, unsigned long size)
1983 {
1984         unsigned long end = addr + size;
1985
1986         flush_cache_vunmap(addr, end);
1987         vunmap_page_range(addr, end);
1988         flush_tlb_kernel_range(addr, end);
1989 }
1990 EXPORT_SYMBOL_GPL(unmap_kernel_range);
1991
1992 int map_vm_area(struct vm_struct *area, pgprot_t prot, struct page **pages)
1993 {
1994         unsigned long addr = (unsigned long)area->addr;
1995         unsigned long end = addr + get_vm_area_size(area);
1996         int err;
1997
1998         err = vmap_page_range(addr, end, prot, pages);
1999
2000         return err > 0 ? 0 : err;
2001 }
2002 EXPORT_SYMBOL_GPL(map_vm_area);
2003
2004 static void setup_vmalloc_vm(struct vm_struct *vm, struct vmap_area *va,
2005                               unsigned long flags, const void *caller)
2006 {
2007         spin_lock(&vmap_area_lock);
2008         vm->flags = flags;
2009         vm->addr = (void *)va->va_start;
2010         vm->size = va->va_end - va->va_start;
2011         vm->caller = caller;
2012         va->vm = vm;
2013         va->flags |= VM_VM_AREA;
2014         spin_unlock(&vmap_area_lock);
2015 }
2016
2017 static void clear_vm_uninitialized_flag(struct vm_struct *vm)
2018 {
2019         /*
2020          * Before removing VM_UNINITIALIZED,
2021          * we should make sure that vm has proper values.
2022          * Pair with smp_rmb() in show_numa_info().
2023          */
2024         smp_wmb();
2025         vm->flags &= ~VM_UNINITIALIZED;
2026 }
2027
2028 static struct vm_struct *__get_vm_area_node(unsigned long size,
2029                 unsigned long align, unsigned long flags, unsigned long start,
2030                 unsigned long end, int node, gfp_t gfp_mask, const void *caller)
2031 {
2032         struct vmap_area *va;
2033         struct vm_struct *area;
2034
2035         BUG_ON(in_interrupt());
2036         size = PAGE_ALIGN(size);
2037         if (unlikely(!size))
2038                 return NULL;
2039
2040         if (flags & VM_IOREMAP)
2041                 align = 1ul << clamp_t(int, get_count_order_long(size),
2042                                        PAGE_SHIFT, IOREMAP_MAX_ORDER);
2043
2044         area = kzalloc_node(sizeof(*area), gfp_mask & GFP_RECLAIM_MASK, node);
2045         if (unlikely(!area))
2046                 return NULL;
2047
2048         if (!(flags & VM_NO_GUARD))
2049                 size += PAGE_SIZE;
2050
2051         va = alloc_vmap_area(size, align, start, end, node, gfp_mask);
2052         if (IS_ERR(va)) {
2053                 kfree(area);
2054                 return NULL;
2055         }
2056
2057         setup_vmalloc_vm(area, va, flags, caller);
2058
2059         return area;
2060 }
2061
2062 struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
2063                                 unsigned long start, unsigned long end)
2064 {
2065         return __get_vm_area_node(size, 1, flags, start, end, NUMA_NO_NODE,
2066                                   GFP_KERNEL, __builtin_return_address(0));
2067 }
2068 EXPORT_SYMBOL_GPL(__get_vm_area);
2069
2070 struct vm_struct *__get_vm_area_caller(unsigned long size, unsigned long flags,
2071                                        unsigned long start, unsigned long end,
2072                                        const void *caller)
2073 {
2074         return __get_vm_area_node(size, 1, flags, start, end, NUMA_NO_NODE,
2075                                   GFP_KERNEL, caller);
2076 }
2077
2078 /**
2079  * get_vm_area - reserve a contiguous kernel virtual area
2080  * @size:        size of the area
2081  * @flags:       %VM_IOREMAP for I/O mappings or VM_ALLOC
2082  *
2083  * Search an area of @size in the kernel virtual mapping area,
2084  * and reserved it for out purposes.  Returns the area descriptor
2085  * on success or %NULL on failure.
2086  *
2087  * Return: the area descriptor on success or %NULL on failure.
2088  */
2089 struct vm_struct *get_vm_area(unsigned long size, unsigned long flags)
2090 {
2091         return __get_vm_area_node(size, 1, flags, VMALLOC_START, VMALLOC_END,
2092                                   NUMA_NO_NODE, GFP_KERNEL,
2093                                   __builtin_return_address(0));
2094 }
2095
2096 struct vm_struct *get_vm_area_caller(unsigned long size, unsigned long flags,
2097                                 const void *caller)
2098 {
2099         return __get_vm_area_node(size, 1, flags, VMALLOC_START, VMALLOC_END,
2100                                   NUMA_NO_NODE, GFP_KERNEL, caller);
2101 }
2102
2103 /**
2104  * find_vm_area - find a continuous kernel virtual area
2105  * @addr:         base address
2106  *
2107  * Search for the kernel VM area starting at @addr, and return it.
2108  * It is up to the caller to do all required locking to keep the returned
2109  * pointer valid.
2110  *
2111  * Return: pointer to the found area or %NULL on faulure
2112  */
2113 struct vm_struct *find_vm_area(const void *addr)
2114 {
2115         struct vmap_area *va;
2116
2117         va = find_vmap_area((unsigned long)addr);
2118         if (va && va->flags & VM_VM_AREA)
2119                 return va->vm;
2120
2121         return NULL;
2122 }
2123
2124 /**
2125  * remove_vm_area - find and remove a continuous kernel virtual area
2126  * @addr:           base address
2127  *
2128  * Search for the kernel VM area starting at @addr, and remove it.
2129  * This function returns the found VM area, but using it is NOT safe
2130  * on SMP machines, except for its size or flags.
2131  *
2132  * Return: pointer to the found area or %NULL on faulure
2133  */
2134 struct vm_struct *remove_vm_area(const void *addr)
2135 {
2136         struct vmap_area *va;
2137
2138         might_sleep();
2139
2140         va = find_vmap_area((unsigned long)addr);
2141         if (va && va->flags & VM_VM_AREA) {
2142                 struct vm_struct *vm = va->vm;
2143
2144                 spin_lock(&vmap_area_lock);
2145                 va->vm = NULL;
2146                 va->flags &= ~VM_VM_AREA;
2147                 va->flags |= VM_LAZY_FREE;
2148                 spin_unlock(&vmap_area_lock);
2149
2150                 kasan_free_shadow(vm);
2151                 free_unmap_vmap_area(va);
2152
2153                 return vm;
2154         }
2155         return NULL;
2156 }
2157
2158 static inline void set_area_direct_map(const struct vm_struct *area,
2159                                        int (*set_direct_map)(struct page *page))
2160 {
2161         int i;
2162
2163         for (i = 0; i < area->nr_pages; i++)
2164                 if (page_address(area->pages[i]))
2165                         set_direct_map(area->pages[i]);
2166 }
2167
2168 /* Handle removing and resetting vm mappings related to the vm_struct. */
2169 static void vm_remove_mappings(struct vm_struct *area, int deallocate_pages)
2170 {
2171         unsigned long start = ULONG_MAX, end = 0;
2172         int flush_reset = area->flags & VM_FLUSH_RESET_PERMS;
2173         int flush_dmap = 0;
2174         int i;
2175
2176         remove_vm_area(area->addr);
2177
2178         /* If this is not VM_FLUSH_RESET_PERMS memory, no need for the below. */
2179         if (!flush_reset)
2180                 return;
2181
2182         /*
2183          * If not deallocating pages, just do the flush of the VM area and
2184          * return.
2185          */
2186         if (!deallocate_pages) {
2187                 vm_unmap_aliases();
2188                 return;
2189         }
2190
2191         /*
2192          * If execution gets here, flush the vm mapping and reset the direct
2193          * map. Find the start and end range of the direct mappings to make sure
2194          * the vm_unmap_aliases() flush includes the direct map.
2195          */
2196         for (i = 0; i < area->nr_pages; i++) {
2197                 unsigned long addr = (unsigned long)page_address(area->pages[i]);
2198                 if (addr) {
2199                         start = min(addr, start);
2200                         end = max(addr + PAGE_SIZE, end);
2201                         flush_dmap = 1;
2202                 }
2203         }
2204
2205         /*
2206          * Set direct map to something invalid so that it won't be cached if
2207          * there are any accesses after the TLB flush, then flush the TLB and
2208          * reset the direct map permissions to the default.
2209          */
2210         set_area_direct_map(area, set_direct_map_invalid_noflush);
2211         _vm_unmap_aliases(start, end, flush_dmap);
2212         set_area_direct_map(area, set_direct_map_default_noflush);
2213 }
2214
2215 static void __vunmap(const void *addr, int deallocate_pages)
2216 {
2217         struct vm_struct *area;
2218
2219         if (!addr)
2220                 return;
2221
2222         if (WARN(!PAGE_ALIGNED(addr), "Trying to vfree() bad address (%p)\n",
2223                         addr))
2224                 return;
2225
2226         area = find_vm_area(addr);
2227         if (unlikely(!area)) {
2228                 WARN(1, KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
2229                                 addr);
2230                 return;
2231         }
2232
2233         debug_check_no_locks_freed(area->addr, get_vm_area_size(area));
2234         debug_check_no_obj_freed(area->addr, get_vm_area_size(area));
2235
2236         vm_remove_mappings(area, deallocate_pages);
2237
2238         if (deallocate_pages) {
2239                 int i;
2240
2241                 for (i = 0; i < area->nr_pages; i++) {
2242                         struct page *page = area->pages[i];
2243
2244                         BUG_ON(!page);
2245                         __free_pages(page, 0);
2246                 }
2247                 atomic_long_sub(area->nr_pages, &nr_vmalloc_pages);
2248
2249                 kvfree(area->pages);
2250         }
2251
2252         kfree(area);
2253         return;
2254 }
2255
2256 static inline void __vfree_deferred(const void *addr)
2257 {
2258         /*
2259          * Use raw_cpu_ptr() because this can be called from preemptible
2260          * context. Preemption is absolutely fine here, because the llist_add()
2261          * implementation is lockless, so it works even if we are adding to
2262          * nother cpu's list.  schedule_work() should be fine with this too.
2263          */
2264         struct vfree_deferred *p = raw_cpu_ptr(&vfree_deferred);
2265
2266         if (llist_add((struct llist_node *)addr, &p->list))
2267                 schedule_work(&p->wq);
2268 }
2269
2270 /**
2271  * vfree_atomic - release memory allocated by vmalloc()
2272  * @addr:         memory base address
2273  *
2274  * This one is just like vfree() but can be called in any atomic context
2275  * except NMIs.
2276  */
2277 void vfree_atomic(const void *addr)
2278 {
2279         BUG_ON(in_nmi());
2280
2281         kmemleak_free(addr);
2282
2283         if (!addr)
2284                 return;
2285         __vfree_deferred(addr);
2286 }
2287
2288 static void __vfree(const void *addr)
2289 {
2290         if (unlikely(in_interrupt()))
2291                 __vfree_deferred(addr);
2292         else
2293                 __vunmap(addr, 1);
2294 }
2295
2296 /**
2297  * vfree - release memory allocated by vmalloc()
2298  * @addr:  memory base address
2299  *
2300  * Free the virtually continuous memory area starting at @addr, as
2301  * obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
2302  * NULL, no operation is performed.
2303  *
2304  * Must not be called in NMI context (strictly speaking, only if we don't
2305  * have CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG, but making the calling
2306  * conventions for vfree() arch-depenedent would be a really bad idea)
2307  *
2308  * May sleep if called *not* from interrupt context.
2309  *
2310  * NOTE: assumes that the object at @addr has a size >= sizeof(llist_node)
2311  */
2312 void vfree(const void *addr)
2313 {
2314         BUG_ON(in_nmi());
2315
2316         kmemleak_free(addr);
2317
2318         might_sleep_if(!in_interrupt());
2319
2320         if (!addr)
2321                 return;
2322
2323         __vfree(addr);
2324 }
2325 EXPORT_SYMBOL(vfree);
2326
2327 /**
2328  * vunmap - release virtual mapping obtained by vmap()
2329  * @addr:   memory base address
2330  *
2331  * Free the virtually contiguous memory area starting at @addr,
2332  * which was created from the page array passed to vmap().
2333  *
2334  * Must not be called in interrupt context.
2335  */
2336 void vunmap(const void *addr)
2337 {
2338         BUG_ON(in_interrupt());
2339         might_sleep();
2340         if (addr)
2341                 __vunmap(addr, 0);
2342 }
2343 EXPORT_SYMBOL(vunmap);
2344
2345 /**
2346  * vmap - map an array of pages into virtually contiguous space
2347  * @pages: array of page pointers
2348  * @count: number of pages to map
2349  * @flags: vm_area->flags
2350  * @prot: page protection for the mapping
2351  *
2352  * Maps @count pages from @pages into contiguous kernel virtual
2353  * space.
2354  *
2355  * Return: the address of the area or %NULL on failure
2356  */
2357 void *vmap(struct page **pages, unsigned int count,
2358            unsigned long flags, pgprot_t prot)
2359 {
2360         struct vm_struct *area;
2361         unsigned long size;             /* In bytes */
2362
2363         might_sleep();
2364
2365         if (count > totalram_pages())
2366                 return NULL;
2367
2368         size = (unsigned long)count << PAGE_SHIFT;
2369         area = get_vm_area_caller(size, flags, __builtin_return_address(0));
2370         if (!area)
2371                 return NULL;
2372
2373         if (map_vm_area(area, prot, pages)) {
2374                 vunmap(area->addr);
2375                 return NULL;
2376         }
2377
2378         return area->addr;
2379 }
2380 EXPORT_SYMBOL(vmap);
2381
2382 static void *__vmalloc_node(unsigned long size, unsigned long align,
2383                             gfp_t gfp_mask, pgprot_t prot,
2384                             int node, const void *caller);
2385 static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
2386                                  pgprot_t prot, int node)
2387 {
2388         struct page **pages;
2389         unsigned int nr_pages, array_size, i;
2390         const gfp_t nested_gfp = (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO;
2391         const gfp_t alloc_mask = gfp_mask | __GFP_NOWARN;
2392         const gfp_t highmem_mask = (gfp_mask & (GFP_DMA | GFP_DMA32)) ?
2393                                         0 :
2394                                         __GFP_HIGHMEM;
2395
2396         nr_pages = get_vm_area_size(area) >> PAGE_SHIFT;
2397         array_size = (nr_pages * sizeof(struct page *));
2398
2399         area->nr_pages = nr_pages;
2400         /* Please note that the recursion is strictly bounded. */
2401         if (array_size > PAGE_SIZE) {
2402                 pages = __vmalloc_node(array_size, 1, nested_gfp|highmem_mask,
2403                                 PAGE_KERNEL, node, area->caller);
2404         } else {
2405                 pages = kmalloc_node(array_size, nested_gfp, node);
2406         }
2407         area->pages = pages;
2408         if (!area->pages) {
2409                 remove_vm_area(area->addr);
2410                 kfree(area);
2411                 return NULL;
2412         }
2413
2414         for (i = 0; i < area->nr_pages; i++) {
2415                 struct page *page;
2416
2417                 if (node == NUMA_NO_NODE)
2418                         page = alloc_page(alloc_mask|highmem_mask);
2419                 else
2420                         page = alloc_pages_node(node, alloc_mask|highmem_mask, 0);
2421
2422                 if (unlikely(!page)) {
2423                         /* Successfully allocated i pages, free them in __vunmap() */
2424                         area->nr_pages = i;
2425                         atomic_long_add(area->nr_pages, &nr_vmalloc_pages);
2426                         goto fail;
2427                 }
2428                 area->pages[i] = page;
2429                 if (gfpflags_allow_blocking(gfp_mask|highmem_mask))
2430                         cond_resched();
2431         }
2432         atomic_long_add(area->nr_pages, &nr_vmalloc_pages);
2433
2434         if (map_vm_area(area, prot, pages))
2435                 goto fail;
2436         return area->addr;
2437
2438 fail:
2439         warn_alloc(gfp_mask, NULL,
2440                           "vmalloc: allocation failure, allocated %ld of %ld bytes",
2441                           (area->nr_pages*PAGE_SIZE), area->size);
2442         __vfree(area->addr);
2443         return NULL;
2444 }
2445
2446 /**
2447  * __vmalloc_node_range - allocate virtually contiguous memory
2448  * @size:                 allocation size
2449  * @align:                desired alignment
2450  * @start:                vm area range start
2451  * @end:                  vm area range end
2452  * @gfp_mask:             flags for the page level allocator
2453  * @prot:                 protection mask for the allocated pages
2454  * @vm_flags:             additional vm area flags (e.g. %VM_NO_GUARD)
2455  * @node:                 node to use for allocation or NUMA_NO_NODE
2456  * @caller:               caller's return address
2457  *
2458  * Allocate enough pages to cover @size from the page level
2459  * allocator with @gfp_mask flags.  Map them into contiguous
2460  * kernel virtual space, using a pagetable protection of @prot.
2461  *
2462  * Return: the address of the area or %NULL on failure
2463  */
2464 void *__vmalloc_node_range(unsigned long size, unsigned long align,
2465                         unsigned long start, unsigned long end, gfp_t gfp_mask,
2466                         pgprot_t prot, unsigned long vm_flags, int node,
2467                         const void *caller)
2468 {
2469         struct vm_struct *area;
2470         void *addr;
2471         unsigned long real_size = size;
2472
2473         size = PAGE_ALIGN(size);
2474         if (!size || (size >> PAGE_SHIFT) > totalram_pages())
2475                 goto fail;
2476
2477         area = __get_vm_area_node(size, align, VM_ALLOC | VM_UNINITIALIZED |
2478                                 vm_flags, start, end, node, gfp_mask, caller);
2479         if (!area)
2480                 goto fail;
2481
2482         addr = __vmalloc_area_node(area, gfp_mask, prot, node);
2483         if (!addr)
2484                 return NULL;
2485
2486         /*
2487          * In this function, newly allocated vm_struct has VM_UNINITIALIZED
2488          * flag. It means that vm_struct is not fully initialized.
2489          * Now, it is fully initialized, so remove this flag here.
2490          */
2491         clear_vm_uninitialized_flag(area);
2492
2493         kmemleak_vmalloc(area, size, gfp_mask);
2494
2495         return addr;
2496
2497 fail:
2498         warn_alloc(gfp_mask, NULL,
2499                           "vmalloc: allocation failure: %lu bytes", real_size);
2500         return NULL;
2501 }
2502
2503 /*
2504  * This is only for performance analysis of vmalloc and stress purpose.
2505  * It is required by vmalloc test module, therefore do not use it other
2506  * than that.
2507  */
2508 #ifdef CONFIG_TEST_VMALLOC_MODULE
2509 EXPORT_SYMBOL_GPL(__vmalloc_node_range);
2510 #endif
2511
2512 /**
2513  * __vmalloc_node - allocate virtually contiguous memory
2514  * @size:           allocation size
2515  * @align:          desired alignment
2516  * @gfp_mask:       flags for the page level allocator
2517  * @prot:           protection mask for the allocated pages
2518  * @node:           node to use for allocation or NUMA_NO_NODE
2519  * @caller:         caller's return address
2520  *
2521  * Allocate enough pages to cover @size from the page level
2522  * allocator with @gfp_mask flags.  Map them into contiguous
2523  * kernel virtual space, using a pagetable protection of @prot.
2524  *
2525  * Reclaim modifiers in @gfp_mask - __GFP_NORETRY, __GFP_RETRY_MAYFAIL
2526  * and __GFP_NOFAIL are not supported
2527  *
2528  * Any use of gfp flags outside of GFP_KERNEL should be consulted
2529  * with mm people.
2530  *
2531  * Return: pointer to the allocated memory or %NULL on error
2532  */
2533 static void *__vmalloc_node(unsigned long size, unsigned long align,
2534                             gfp_t gfp_mask, pgprot_t prot,
2535                             int node, const void *caller)
2536 {
2537         return __vmalloc_node_range(size, align, VMALLOC_START, VMALLOC_END,
2538                                 gfp_mask, prot, 0, node, caller);
2539 }
2540
2541 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
2542 {
2543         return __vmalloc_node(size, 1, gfp_mask, prot, NUMA_NO_NODE,
2544                                 __builtin_return_address(0));
2545 }
2546 EXPORT_SYMBOL(__vmalloc);
2547
2548 static inline void *__vmalloc_node_flags(unsigned long size,
2549                                         int node, gfp_t flags)
2550 {
2551         return __vmalloc_node(size, 1, flags, PAGE_KERNEL,
2552                                         node, __builtin_return_address(0));
2553 }
2554
2555
2556 void *__vmalloc_node_flags_caller(unsigned long size, int node, gfp_t flags,
2557                                   void *caller)
2558 {
2559         return __vmalloc_node(size, 1, flags, PAGE_KERNEL, node, caller);
2560 }
2561
2562 /**
2563  * vmalloc - allocate virtually contiguous memory
2564  * @size:    allocation size
2565  *
2566  * Allocate enough pages to cover @size from the page level
2567  * allocator and map them into contiguous kernel virtual space.
2568  *
2569  * For tight control over page level allocator and protection flags
2570  * use __vmalloc() instead.
2571  *
2572  * Return: pointer to the allocated memory or %NULL on error
2573  */
2574 void *vmalloc(unsigned long size)
2575 {
2576         return __vmalloc_node_flags(size, NUMA_NO_NODE,
2577                                     GFP_KERNEL);
2578 }
2579 EXPORT_SYMBOL(vmalloc);
2580
2581 /**
2582  * vzalloc - allocate virtually contiguous memory with zero fill
2583  * @size:    allocation size
2584  *
2585  * Allocate enough pages to cover @size from the page level
2586  * allocator and map them into contiguous kernel virtual space.
2587  * The memory allocated is set to zero.
2588  *
2589  * For tight control over page level allocator and protection flags
2590  * use __vmalloc() instead.
2591  *
2592  * Return: pointer to the allocated memory or %NULL on error
2593  */
2594 void *vzalloc(unsigned long size)
2595 {
2596         return __vmalloc_node_flags(size, NUMA_NO_NODE,
2597                                 GFP_KERNEL | __GFP_ZERO);
2598 }
2599 EXPORT_SYMBOL(vzalloc);
2600
2601 /**
2602  * vmalloc_user - allocate zeroed virtually contiguous memory for userspace
2603  * @size: allocation size
2604  *
2605  * The resulting memory area is zeroed so it can be mapped to userspace
2606  * without leaking data.
2607  *
2608  * Return: pointer to the allocated memory or %NULL on error
2609  */
2610 void *vmalloc_user(unsigned long size)
2611 {
2612         return __vmalloc_node_range(size, SHMLBA,  VMALLOC_START, VMALLOC_END,
2613                                     GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL,
2614                                     VM_USERMAP, NUMA_NO_NODE,
2615                                     __builtin_return_address(0));
2616 }
2617 EXPORT_SYMBOL(vmalloc_user);
2618
2619 /**
2620  * vmalloc_node - allocate memory on a specific node
2621  * @size:         allocation size
2622  * @node:         numa node
2623  *
2624  * Allocate enough pages to cover @size from the page level
2625  * allocator and map them into contiguous kernel virtual space.
2626  *
2627  * For tight control over page level allocator and protection flags
2628  * use __vmalloc() instead.
2629  *
2630  * Return: pointer to the allocated memory or %NULL on error
2631  */
2632 void *vmalloc_node(unsigned long size, int node)
2633 {
2634         return __vmalloc_node(size, 1, GFP_KERNEL, PAGE_KERNEL,
2635                                         node, __builtin_return_address(0));
2636 }
2637 EXPORT_SYMBOL(vmalloc_node);
2638
2639 /**
2640  * vzalloc_node - allocate memory on a specific node with zero fill
2641  * @size:       allocation size
2642  * @node:       numa node
2643  *
2644  * Allocate enough pages to cover @size from the page level
2645  * allocator and map them into contiguous kernel virtual space.
2646  * The memory allocated is set to zero.
2647  *
2648  * For tight control over page level allocator and protection flags
2649  * use __vmalloc_node() instead.
2650  *
2651  * Return: pointer to the allocated memory or %NULL on error
2652  */
2653 void *vzalloc_node(unsigned long size, int node)
2654 {
2655         return __vmalloc_node_flags(size, node,
2656                          GFP_KERNEL | __GFP_ZERO);
2657 }
2658 EXPORT_SYMBOL(vzalloc_node);
2659
2660 /**
2661  * vmalloc_exec - allocate virtually contiguous, executable memory
2662  * @size:         allocation size
2663  *
2664  * Kernel-internal function to allocate enough pages to cover @size
2665  * the page level allocator and map them into contiguous and
2666  * executable kernel virtual space.
2667  *
2668  * For tight control over page level allocator and protection flags
2669  * use __vmalloc() instead.
2670  *
2671  * Return: pointer to the allocated memory or %NULL on error
2672  */
2673 void *vmalloc_exec(unsigned long size)
2674 {
2675         return __vmalloc_node_range(size, 1, VMALLOC_START, VMALLOC_END,
2676                         GFP_KERNEL, PAGE_KERNEL_EXEC, VM_FLUSH_RESET_PERMS,
2677                         NUMA_NO_NODE, __builtin_return_address(0));
2678 }
2679
2680 #if defined(CONFIG_64BIT) && defined(CONFIG_ZONE_DMA32)
2681 #define GFP_VMALLOC32 (GFP_DMA32 | GFP_KERNEL)
2682 #elif defined(CONFIG_64BIT) && defined(CONFIG_ZONE_DMA)
2683 #define GFP_VMALLOC32 (GFP_DMA | GFP_KERNEL)
2684 #else
2685 /*
2686  * 64b systems should always have either DMA or DMA32 zones. For others
2687  * GFP_DMA32 should do the right thing and use the normal zone.
2688  */
2689 #define GFP_VMALLOC32 GFP_DMA32 | GFP_KERNEL
2690 #endif
2691
2692 /**
2693  * vmalloc_32 - allocate virtually contiguous memory (32bit addressable)
2694  * @size:       allocation size
2695  *
2696  * Allocate enough 32bit PA addressable pages to cover @size from the
2697  * page level allocator and map them into contiguous kernel virtual space.
2698  *
2699  * Return: pointer to the allocated memory or %NULL on error
2700  */
2701 void *vmalloc_32(unsigned long size)
2702 {
2703         return __vmalloc_node(size, 1, GFP_VMALLOC32, PAGE_KERNEL,
2704                               NUMA_NO_NODE, __builtin_return_address(0));
2705 }
2706 EXPORT_SYMBOL(vmalloc_32);
2707
2708 /**
2709  * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
2710  * @size:            allocation size
2711  *
2712  * The resulting memory area is 32bit addressable and zeroed so it can be
2713  * mapped to userspace without leaking data.
2714  *
2715  * Return: pointer to the allocated memory or %NULL on error
2716  */
2717 void *vmalloc_32_user(unsigned long size)
2718 {
2719         return __vmalloc_node_range(size, SHMLBA,  VMALLOC_START, VMALLOC_END,
2720                                     GFP_VMALLOC32 | __GFP_ZERO, PAGE_KERNEL,
2721                                     VM_USERMAP, NUMA_NO_NODE,
2722                                     __builtin_return_address(0));
2723 }
2724 EXPORT_SYMBOL(vmalloc_32_user);
2725
2726 /*
2727  * small helper routine , copy contents to buf from addr.
2728  * If the page is not present, fill zero.
2729  */
2730
2731 static int aligned_vread(char *buf, char *addr, unsigned long count)
2732 {
2733         struct page *p;
2734         int copied = 0;
2735
2736         while (count) {
2737                 unsigned long offset, length;
2738
2739                 offset = offset_in_page(addr);
2740                 length = PAGE_SIZE - offset;
2741                 if (length > count)
2742                         length = count;
2743                 p = vmalloc_to_page(addr);
2744                 /*
2745                  * To do safe access to this _mapped_ area, we need
2746                  * lock. But adding lock here means that we need to add
2747                  * overhead of vmalloc()/vfree() calles for this _debug_
2748                  * interface, rarely used. Instead of that, we'll use
2749                  * kmap() and get small overhead in this access function.
2750                  */
2751                 if (p) {
2752                         /*
2753                          * we can expect USER0 is not used (see vread/vwrite's
2754                          * function description)
2755                          */
2756                         void *map = kmap_atomic(p);
2757                         memcpy(buf, map + offset, length);
2758                         kunmap_atomic(map);
2759                 } else
2760                         memset(buf, 0, length);
2761
2762                 addr += length;
2763                 buf += length;
2764                 copied += length;
2765                 count -= length;
2766         }
2767         return copied;
2768 }
2769
2770 static int aligned_vwrite(char *buf, char *addr, unsigned long count)
2771 {
2772         struct page *p;
2773         int copied = 0;
2774
2775         while (count) {
2776                 unsigned long offset, length;
2777
2778                 offset = offset_in_page(addr);
2779                 length = PAGE_SIZE - offset;
2780                 if (length > count)
2781                         length = count;
2782                 p = vmalloc_to_page(addr);
2783                 /*
2784                  * To do safe access to this _mapped_ area, we need
2785                  * lock. But adding lock here means that we need to add
2786                  * overhead of vmalloc()/vfree() calles for this _debug_
2787                  * interface, rarely used. Instead of that, we'll use
2788                  * kmap() and get small overhead in this access function.
2789                  */
2790                 if (p) {
2791                         /*
2792                          * we can expect USER0 is not used (see vread/vwrite's
2793                          * function description)
2794                          */
2795                         void *map = kmap_atomic(p);
2796                         memcpy(map + offset, buf, length);
2797                         kunmap_atomic(map);
2798                 }
2799                 addr += length;
2800                 buf += length;
2801                 copied += length;
2802                 count -= length;
2803         }
2804         return copied;
2805 }
2806
2807 /**
2808  * vread() - read vmalloc area in a safe way.
2809  * @buf:     buffer for reading data
2810  * @addr:    vm address.
2811  * @count:   number of bytes to be read.
2812  *
2813  * This function checks that addr is a valid vmalloc'ed area, and
2814  * copy data from that area to a given buffer. If the given memory range
2815  * of [addr...addr+count) includes some valid address, data is copied to
2816  * proper area of @buf. If there are memory holes, they'll be zero-filled.
2817  * IOREMAP area is treated as memory hole and no copy is done.
2818  *
2819  * If [addr...addr+count) doesn't includes any intersects with alive
2820  * vm_struct area, returns 0. @buf should be kernel's buffer.
2821  *
2822  * Note: In usual ops, vread() is never necessary because the caller
2823  * should know vmalloc() area is valid and can use memcpy().
2824  * This is for routines which have to access vmalloc area without
2825  * any information, as /dev/kmem.
2826  *
2827  * Return: number of bytes for which addr and buf should be increased
2828  * (same number as @count) or %0 if [addr...addr+count) doesn't
2829  * include any intersection with valid vmalloc area
2830  */
2831 long vread(char *buf, char *addr, unsigned long count)
2832 {
2833         struct vmap_area *va;
2834         struct vm_struct *vm;
2835         char *vaddr, *buf_start = buf;
2836         unsigned long buflen = count;
2837         unsigned long n;
2838
2839         /* Don't allow overflow */
2840         if ((unsigned long) addr + count < count)
2841                 count = -(unsigned long) addr;
2842
2843         spin_lock(&vmap_area_lock);
2844         list_for_each_entry(va, &vmap_area_list, list) {
2845                 if (!count)
2846                         break;
2847
2848                 if (!(va->flags & VM_VM_AREA))
2849                         continue;
2850
2851                 vm = va->vm;
2852                 vaddr = (char *) vm->addr;
2853                 if (addr >= vaddr + get_vm_area_size(vm))
2854                         continue;
2855                 while (addr < vaddr) {
2856                         if (count == 0)
2857                                 goto finished;
2858                         *buf = '\0';
2859                         buf++;
2860                         addr++;
2861                         count--;
2862                 }
2863                 n = vaddr + get_vm_area_size(vm) - addr;
2864                 if (n > count)
2865                         n = count;
2866                 if (!(vm->flags & VM_IOREMAP))
2867                         aligned_vread(buf, addr, n);
2868                 else /* IOREMAP area is treated as memory hole */
2869                         memset(buf, 0, n);
2870                 buf += n;
2871                 addr += n;
2872                 count -= n;
2873         }
2874 finished:
2875         spin_unlock(&vmap_area_lock);
2876
2877         if (buf == buf_start)
2878                 return 0;
2879         /* zero-fill memory holes */
2880         if (buf != buf_start + buflen)
2881                 memset(buf, 0, buflen - (buf - buf_start));
2882
2883         return buflen;
2884 }
2885
2886 /**
2887  * vwrite() - write vmalloc area in a safe way.
2888  * @buf:      buffer for source data
2889  * @addr:     vm address.
2890  * @count:    number of bytes to be read.
2891  *
2892  * This function checks that addr is a valid vmalloc'ed area, and
2893  * copy data from a buffer to the given addr. If specified range of
2894  * [addr...addr+count) includes some valid address, data is copied from
2895  * proper area of @buf. If there are memory holes, no copy to hole.
2896  * IOREMAP area is treated as memory hole and no copy is done.
2897  *
2898  * If [addr...addr+count) doesn't includes any intersects with alive
2899  * vm_struct area, returns 0. @buf should be kernel's buffer.
2900  *
2901  * Note: In usual ops, vwrite() is never necessary because the caller
2902  * should know vmalloc() area is valid and can use memcpy().
2903  * This is for routines which have to access vmalloc area without
2904  * any information, as /dev/kmem.
2905  *
2906  * Return: number of bytes for which addr and buf should be
2907  * increased (same number as @count) or %0 if [addr...addr+count)
2908  * doesn't include any intersection with valid vmalloc area
2909  */
2910 long vwrite(char *buf, char *addr, unsigned long count)
2911 {
2912         struct vmap_area *va;
2913         struct vm_struct *vm;
2914         char *vaddr;
2915         unsigned long n, buflen;
2916         int copied = 0;
2917
2918         /* Don't allow overflow */
2919         if ((unsigned long) addr + count < count)
2920                 count = -(unsigned long) addr;
2921         buflen = count;
2922
2923         spin_lock(&vmap_area_lock);
2924         list_for_each_entry(va, &vmap_area_list, list) {
2925                 if (!count)
2926                         break;
2927
2928                 if (!(va->flags & VM_VM_AREA))
2929                         continue;
2930
2931                 vm = va->vm;
2932                 vaddr = (char *) vm->addr;
2933                 if (addr >= vaddr + get_vm_area_size(vm))
2934                         continue;
2935                 while (addr < vaddr) {
2936                         if (count == 0)
2937                                 goto finished;
2938                         buf++;
2939                         addr++;
2940                         count--;
2941                 }
2942                 n = vaddr + get_vm_area_size(vm) - addr;
2943                 if (n > count)
2944                         n = count;
2945                 if (!(vm->flags & VM_IOREMAP)) {
2946                         aligned_vwrite(buf, addr, n);
2947                         copied++;
2948                 }
2949                 buf += n;
2950                 addr += n;
2951                 count -= n;
2952         }
2953 finished:
2954         spin_unlock(&vmap_area_lock);
2955         if (!copied)
2956                 return 0;
2957         return buflen;
2958 }
2959
2960 /**
2961  * remap_vmalloc_range_partial - map vmalloc pages to userspace
2962  * @vma:                vma to cover
2963  * @uaddr:              target user address to start at
2964  * @kaddr:              virtual address of vmalloc kernel memory
2965  * @size:               size of map area
2966  *
2967  * Returns:     0 for success, -Exxx on failure
2968  *
2969  * This function checks that @kaddr is a valid vmalloc'ed area,
2970  * and that it is big enough to cover the range starting at
2971  * @uaddr in @vma. Will return failure if that criteria isn't
2972  * met.
2973  *
2974  * Similar to remap_pfn_range() (see mm/memory.c)
2975  */
2976 int remap_vmalloc_range_partial(struct vm_area_struct *vma, unsigned long uaddr,
2977                                 void *kaddr, unsigned long size)
2978 {
2979         struct vm_struct *area;
2980
2981         size = PAGE_ALIGN(size);
2982
2983         if (!PAGE_ALIGNED(uaddr) || !PAGE_ALIGNED(kaddr))
2984                 return -EINVAL;
2985
2986         area = find_vm_area(kaddr);
2987         if (!area)
2988                 return -EINVAL;
2989
2990         if (!(area->flags & VM_USERMAP))
2991                 return -EINVAL;
2992
2993         if (kaddr + size > area->addr + get_vm_area_size(area))
2994                 return -EINVAL;
2995
2996         do {
2997                 struct page *page = vmalloc_to_page(kaddr);
2998                 int ret;
2999
3000                 ret = vm_insert_page(vma, uaddr, page);
3001                 if (ret)
3002                         return ret;
3003
3004                 uaddr += PAGE_SIZE;
3005                 kaddr += PAGE_SIZE;
3006                 size -= PAGE_SIZE;
3007         } while (size > 0);
3008
3009         vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
3010
3011         return 0;
3012 }
3013 EXPORT_SYMBOL(remap_vmalloc_range_partial);
3014
3015 /**
3016  * remap_vmalloc_range - map vmalloc pages to userspace
3017  * @vma:                vma to cover (map full range of vma)
3018  * @addr:               vmalloc memory
3019  * @pgoff:              number of pages into addr before first page to map
3020  *
3021  * Returns:     0 for success, -Exxx on failure
3022  *
3023  * This function checks that addr is a valid vmalloc'ed area, and
3024  * that it is big enough to cover the vma. Will return failure if
3025  * that criteria isn't met.
3026  *
3027  * Similar to remap_pfn_range() (see mm/memory.c)
3028  */
3029 int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
3030                                                 unsigned long pgoff)
3031 {
3032         return remap_vmalloc_range_partial(vma, vma->vm_start,
3033                                            addr + (pgoff << PAGE_SHIFT),
3034                                            vma->vm_end - vma->vm_start);
3035 }
3036 EXPORT_SYMBOL(remap_vmalloc_range);
3037
3038 /*
3039  * Implement a stub for vmalloc_sync_all() if the architecture chose not to
3040  * have one.
3041  */
3042 void __weak vmalloc_sync_all(void)
3043 {
3044 }
3045
3046
3047 static int f(pte_t *pte, unsigned long addr, void *data)
3048 {
3049         pte_t ***p = data;
3050
3051         if (p) {
3052                 *(*p) = pte;
3053                 (*p)++;
3054         }
3055         return 0;
3056 }
3057
3058 /**
3059  * alloc_vm_area - allocate a range of kernel address space
3060  * @size:          size of the area
3061  * @ptes:          returns the PTEs for the address space
3062  *
3063  * Returns:     NULL on failure, vm_struct on success
3064  *
3065  * This function reserves a range of kernel address space, and
3066  * allocates pagetables to map that range.  No actual mappings
3067  * are created.
3068  *
3069  * If @ptes is non-NULL, pointers to the PTEs (in init_mm)
3070  * allocated for the VM area are returned.
3071  */
3072 struct vm_struct *alloc_vm_area(size_t size, pte_t **ptes)
3073 {
3074         struct vm_struct *area;
3075
3076         area = get_vm_area_caller(size, VM_IOREMAP,
3077                                 __builtin_return_address(0));
3078         if (area == NULL)
3079                 return NULL;
3080
3081         /*
3082          * This ensures that page tables are constructed for this region
3083          * of kernel virtual address space and mapped into init_mm.
3084          */
3085         if (apply_to_page_range(&init_mm, (unsigned long)area->addr,
3086                                 size, f, ptes ? &ptes : NULL)) {
3087                 free_vm_area(area);
3088                 return NULL;
3089         }
3090
3091         return area;
3092 }
3093 EXPORT_SYMBOL_GPL(alloc_vm_area);
3094
3095 void free_vm_area(struct vm_struct *area)
3096 {
3097         struct vm_struct *ret;
3098         ret = remove_vm_area(area->addr);
3099         BUG_ON(ret != area);
3100         kfree(area);
3101 }
3102 EXPORT_SYMBOL_GPL(free_vm_area);
3103
3104 #ifdef CONFIG_SMP
3105 static struct vmap_area *node_to_va(struct rb_node *n)
3106 {
3107         return rb_entry_safe(n, struct vmap_area, rb_node);
3108 }
3109
3110 /**
3111  * pvm_find_va_enclose_addr - find the vmap_area @addr belongs to
3112  * @addr: target address
3113  *
3114  * Returns: vmap_area if it is found. If there is no such area
3115  *   the first highest(reverse order) vmap_area is returned
3116  *   i.e. va->va_start < addr && va->va_end < addr or NULL
3117  *   if there are no any areas before @addr.
3118  */
3119 static struct vmap_area *
3120 pvm_find_va_enclose_addr(unsigned long addr)
3121 {
3122         struct vmap_area *va, *tmp;
3123         struct rb_node *n;
3124
3125         n = free_vmap_area_root.rb_node;
3126         va = NULL;
3127
3128         while (n) {
3129                 tmp = rb_entry(n, struct vmap_area, rb_node);
3130                 if (tmp->va_start <= addr) {
3131                         va = tmp;
3132                         if (tmp->va_end >= addr)
3133                                 break;
3134
3135                         n = n->rb_right;
3136                 } else {
3137                         n = n->rb_left;
3138                 }
3139         }
3140
3141         return va;
3142 }
3143
3144 /**
3145  * pvm_determine_end_from_reverse - find the highest aligned address
3146  * of free block below VMALLOC_END
3147  * @va:
3148  *   in - the VA we start the search(reverse order);
3149  *   out - the VA with the highest aligned end address.
3150  *
3151  * Returns: determined end address within vmap_area
3152  */
3153 static unsigned long
3154 pvm_determine_end_from_reverse(struct vmap_area **va, unsigned long align)
3155 {
3156         unsigned long vmalloc_end = VMALLOC_END & ~(align - 1);
3157         unsigned long addr;
3158
3159         if (likely(*va)) {
3160                 list_for_each_entry_from_reverse((*va),
3161                                 &free_vmap_area_list, list) {
3162                         addr = min((*va)->va_end & ~(align - 1), vmalloc_end);
3163                         if ((*va)->va_start < addr)
3164                                 return addr;
3165                 }
3166         }
3167
3168         return 0;
3169 }
3170
3171 /**
3172  * pcpu_get_vm_areas - allocate vmalloc areas for percpu allocator
3173  * @offsets: array containing offset of each area
3174  * @sizes: array containing size of each area
3175  * @nr_vms: the number of areas to allocate
3176  * @align: alignment, all entries in @offsets and @sizes must be aligned to this
3177  *
3178  * Returns: kmalloc'd vm_struct pointer array pointing to allocated
3179  *          vm_structs on success, %NULL on failure
3180  *
3181  * Percpu allocator wants to use congruent vm areas so that it can
3182  * maintain the offsets among percpu areas.  This function allocates
3183  * congruent vmalloc areas for it with GFP_KERNEL.  These areas tend to
3184  * be scattered pretty far, distance between two areas easily going up
3185  * to gigabytes.  To avoid interacting with regular vmallocs, these
3186  * areas are allocated from top.
3187  *
3188  * Despite its complicated look, this allocator is rather simple. It
3189  * does everything top-down and scans free blocks from the end looking
3190  * for matching base. While scanning, if any of the areas do not fit the
3191  * base address is pulled down to fit the area. Scanning is repeated till
3192  * all the areas fit and then all necessary data structures are inserted
3193  * and the result is returned.
3194  */
3195 struct vm_struct **pcpu_get_vm_areas(const unsigned long *offsets,
3196                                      const size_t *sizes, int nr_vms,
3197                                      size_t align)
3198 {
3199         const unsigned long vmalloc_start = ALIGN(VMALLOC_START, align);
3200         const unsigned long vmalloc_end = VMALLOC_END & ~(align - 1);
3201         struct vmap_area **vas, *va;
3202         struct vm_struct **vms;
3203         int area, area2, last_area, term_area;
3204         unsigned long base, start, size, end, last_end;
3205         bool purged = false;
3206         enum fit_type type;
3207
3208         /* verify parameters and allocate data structures */
3209         BUG_ON(offset_in_page(align) || !is_power_of_2(align));
3210         for (last_area = 0, area = 0; area < nr_vms; area++) {
3211                 start = offsets[area];
3212                 end = start + sizes[area];
3213
3214                 /* is everything aligned properly? */
3215                 BUG_ON(!IS_ALIGNED(offsets[area], align));
3216                 BUG_ON(!IS_ALIGNED(sizes[area], align));
3217
3218                 /* detect the area with the highest address */
3219                 if (start > offsets[last_area])
3220                         last_area = area;
3221
3222                 for (area2 = area + 1; area2 < nr_vms; area2++) {
3223                         unsigned long start2 = offsets[area2];
3224                         unsigned long end2 = start2 + sizes[area2];
3225
3226                         BUG_ON(start2 < end && start < end2);
3227                 }
3228         }
3229         last_end = offsets[last_area] + sizes[last_area];
3230
3231         if (vmalloc_end - vmalloc_start < last_end) {
3232                 WARN_ON(true);
3233                 return NULL;
3234         }
3235
3236         vms = kcalloc(nr_vms, sizeof(vms[0]), GFP_KERNEL);
3237         vas = kcalloc(nr_vms, sizeof(vas[0]), GFP_KERNEL);
3238         if (!vas || !vms)
3239                 goto err_free2;
3240
3241         for (area = 0; area < nr_vms; area++) {
3242                 vas[area] = kmem_cache_zalloc(vmap_area_cachep, GFP_KERNEL);
3243                 vms[area] = kzalloc(sizeof(struct vm_struct), GFP_KERNEL);
3244                 if (!vas[area] || !vms[area])
3245                         goto err_free;
3246         }
3247 retry:
3248         spin_lock(&vmap_area_lock);
3249
3250         /* start scanning - we scan from the top, begin with the last area */
3251         area = term_area = last_area;
3252         start = offsets[area];
3253         end = start + sizes[area];
3254
3255         va = pvm_find_va_enclose_addr(vmalloc_end);
3256         base = pvm_determine_end_from_reverse(&va, align) - end;
3257
3258         while (true) {
3259                 /*
3260                  * base might have underflowed, add last_end before
3261                  * comparing.
3262                  */
3263                 if (base + last_end < vmalloc_start + last_end)
3264                         goto overflow;
3265
3266                 /*
3267                  * Fitting base has not been found.
3268                  */
3269                 if (va == NULL)
3270                         goto overflow;
3271
3272                 /*
3273                  * If this VA does not fit, move base downwards and recheck.
3274                  */
3275                 if (base + start < va->va_start || base + end > va->va_end) {
3276                         va = node_to_va(rb_prev(&va->rb_node));
3277                         base = pvm_determine_end_from_reverse(&va, align) - end;
3278                         term_area = area;
3279                         continue;
3280                 }
3281
3282                 /*
3283                  * This area fits, move on to the previous one.  If
3284                  * the previous one is the terminal one, we're done.
3285                  */
3286                 area = (area + nr_vms - 1) % nr_vms;
3287                 if (area == term_area)
3288                         break;
3289
3290                 start = offsets[area];
3291                 end = start + sizes[area];
3292                 va = pvm_find_va_enclose_addr(base + end);
3293         }
3294
3295         /* we've found a fitting base, insert all va's */
3296         for (area = 0; area < nr_vms; area++) {
3297                 int ret;
3298
3299                 start = base + offsets[area];
3300                 size = sizes[area];
3301
3302                 va = pvm_find_va_enclose_addr(start);
3303                 if (WARN_ON_ONCE(va == NULL))
3304                         /* It is a BUG(), but trigger recovery instead. */
3305                         goto recovery;
3306
3307                 type = classify_va_fit_type(va, start, size);
3308                 if (WARN_ON_ONCE(type == NOTHING_FIT))
3309                         /* It is a BUG(), but trigger recovery instead. */
3310                         goto recovery;
3311
3312                 ret = adjust_va_to_fit_type(va, start, size, type);
3313                 if (unlikely(ret))
3314                         goto recovery;
3315
3316                 /* Allocated area. */
3317                 va = vas[area];
3318                 va->va_start = start;
3319                 va->va_end = start + size;
3320
3321                 insert_vmap_area(va, &vmap_area_root, &vmap_area_list);
3322         }
3323
3324         spin_unlock(&vmap_area_lock);
3325
3326         /* insert all vm's */
3327         for (area = 0; area < nr_vms; area++)
3328                 setup_vmalloc_vm(vms[area], vas[area], VM_ALLOC,
3329                                  pcpu_get_vm_areas);
3330
3331         kfree(vas);
3332         return vms;
3333
3334 recovery:
3335         /* Remove previously inserted areas. */
3336         while (area--) {
3337                 __free_vmap_area(vas[area]);
3338                 vas[area] = NULL;
3339         }
3340
3341 overflow:
3342         spin_unlock(&vmap_area_lock);
3343         if (!purged) {
3344                 purge_vmap_area_lazy();
3345                 purged = true;
3346
3347                 /* Before "retry", check if we recover. */
3348                 for (area = 0; area < nr_vms; area++) {
3349                         if (vas[area])
3350                                 continue;
3351
3352                         vas[area] = kmem_cache_zalloc(
3353                                 vmap_area_cachep, GFP_KERNEL);
3354                         if (!vas[area])
3355                                 goto err_free;
3356                 }
3357
3358                 goto retry;
3359         }
3360
3361 err_free:
3362         for (area = 0; area < nr_vms; area++) {
3363                 if (vas[area])
3364                         kmem_cache_free(vmap_area_cachep, vas[area]);
3365
3366                 kfree(vms[area]);
3367         }
3368 err_free2:
3369         kfree(vas);
3370         kfree(vms);
3371         return NULL;
3372 }
3373
3374 /**
3375  * pcpu_free_vm_areas - free vmalloc areas for percpu allocator
3376  * @vms: vm_struct pointer array returned by pcpu_get_vm_areas()
3377  * @nr_vms: the number of allocated areas
3378  *
3379  * Free vm_structs and the array allocated by pcpu_get_vm_areas().
3380  */
3381 void pcpu_free_vm_areas(struct vm_struct **vms, int nr_vms)
3382 {
3383         int i;
3384
3385         for (i = 0; i < nr_vms; i++)
3386                 free_vm_area(vms[i]);
3387         kfree(vms);
3388 }
3389 #endif  /* CONFIG_SMP */
3390
3391 #ifdef CONFIG_PROC_FS
3392 static void *s_start(struct seq_file *m, loff_t *pos)
3393         __acquires(&vmap_area_lock)
3394 {
3395         spin_lock(&vmap_area_lock);
3396         return seq_list_start(&vmap_area_list, *pos);
3397 }
3398
3399 static void *s_next(struct seq_file *m, void *p, loff_t *pos)
3400 {
3401         return seq_list_next(p, &vmap_area_list, pos);
3402 }
3403
3404 static void s_stop(struct seq_file *m, void *p)
3405         __releases(&vmap_area_lock)
3406 {
3407         spin_unlock(&vmap_area_lock);
3408 }
3409
3410 static void show_numa_info(struct seq_file *m, struct vm_struct *v)
3411 {
3412         if (IS_ENABLED(CONFIG_NUMA)) {
3413                 unsigned int nr, *counters = m->private;
3414
3415                 if (!counters)
3416                         return;
3417
3418                 if (v->flags & VM_UNINITIALIZED)
3419                         return;
3420                 /* Pair with smp_wmb() in clear_vm_uninitialized_flag() */
3421                 smp_rmb();
3422
3423                 memset(counters, 0, nr_node_ids * sizeof(unsigned int));
3424
3425                 for (nr = 0; nr < v->nr_pages; nr++)
3426                         counters[page_to_nid(v->pages[nr])]++;
3427
3428                 for_each_node_state(nr, N_HIGH_MEMORY)
3429                         if (counters[nr])
3430                                 seq_printf(m, " N%u=%u", nr, counters[nr]);
3431         }
3432 }
3433
3434 static int s_show(struct seq_file *m, void *p)
3435 {
3436         struct vmap_area *va;
3437         struct vm_struct *v;
3438
3439         va = list_entry(p, struct vmap_area, list);
3440
3441         /*
3442          * s_show can encounter race with remove_vm_area, !VM_VM_AREA on
3443          * behalf of vmap area is being tear down or vm_map_ram allocation.
3444          */
3445         if (!(va->flags & VM_VM_AREA)) {
3446                 seq_printf(m, "0x%pK-0x%pK %7ld %s\n",
3447                         (void *)va->va_start, (void *)va->va_end,
3448                         va->va_end - va->va_start,
3449                         va->flags & VM_LAZY_FREE ? "unpurged vm_area" : "vm_map_ram");
3450
3451                 return 0;
3452         }
3453
3454         v = va->vm;
3455
3456         seq_printf(m, "0x%pK-0x%pK %7ld",
3457                 v->addr, v->addr + v->size, v->size);
3458
3459         if (v->caller)
3460                 seq_printf(m, " %pS", v->caller);
3461
3462         if (v->nr_pages)
3463                 seq_printf(m, " pages=%d", v->nr_pages);
3464
3465         if (v->phys_addr)
3466                 seq_printf(m, " phys=%pa", &v->phys_addr);
3467
3468         if (v->flags & VM_IOREMAP)
3469                 seq_puts(m, " ioremap");
3470
3471         if (v->flags & VM_ALLOC)
3472                 seq_puts(m, " vmalloc");
3473
3474         if (v->flags & VM_MAP)
3475                 seq_puts(m, " vmap");
3476
3477         if (v->flags & VM_USERMAP)
3478                 seq_puts(m, " user");
3479
3480         if (is_vmalloc_addr(v->pages))
3481                 seq_puts(m, " vpages");
3482
3483         show_numa_info(m, v);
3484         seq_putc(m, '\n');
3485         return 0;
3486 }
3487
3488 static const struct seq_operations vmalloc_op = {
3489         .start = s_start,
3490         .next = s_next,
3491         .stop = s_stop,
3492         .show = s_show,
3493 };
3494
3495 static int __init proc_vmalloc_init(void)
3496 {
3497         if (IS_ENABLED(CONFIG_NUMA))
3498                 proc_create_seq_private("vmallocinfo", 0400, NULL,
3499                                 &vmalloc_op,
3500                                 nr_node_ids * sizeof(unsigned int), NULL);
3501         else
3502                 proc_create_seq("vmallocinfo", 0400, NULL, &vmalloc_op);
3503         return 0;
3504 }
3505 module_init(proc_vmalloc_init);
3506
3507 #endif