LXR linux/include/linux/vmalloc.h

   1/* SPDX-License-Identifier: GPL-2.0 */
   2#ifndef _LINUX_VMALLOC_H
   3#define _LINUX_VMALLOC_H
   4
   5#include <linux/spinlock.h>
   6#include <linux/init.h>
   7#include <linux/list.h>
   8#include <linux/llist.h>
   9#include <asm/page.h>           /* pgprot_t */
  10#include <linux/rbtree.h>
  11#include <linux/overflow.h>
  12
  13struct vm_area_struct;          /* vma defining user mapping in mm_types.h */
  14struct notifier_block;          /* in notifier.h */
  15
  16/* bits in flags of vmalloc's vm_struct below */
  17#define VM_IOREMAP              0x00000001      /* ioremap() and friends */
  18#define VM_ALLOC                0x00000002      /* vmalloc() */
  19#define VM_MAP                  0x00000004      /* vmap()ed pages */
  20#define VM_USERMAP              0x00000008      /* suitable for remap_vmalloc_range */
  21#define VM_UNINITIALIZED        0x00000020      /* vm_struct is not fully initialized */
  22#define VM_NO_GUARD             0x00000040      /* don't add guard page */
  23#define VM_KASAN                0x00000080      /* has allocated kasan shadow memory */
  24/* bits [20..32] reserved for arch specific ioremap internals */
  25
  26/*
  27 * Maximum alignment for ioremap() regions.
  28 * Can be overriden by arch-specific value.
  29 */
  30#ifndef IOREMAP_MAX_ORDER
  31#define IOREMAP_MAX_ORDER       (7 + PAGE_SHIFT)        /* 128 pages */
  32#endif
  33
  34struct vm_struct {
  35        struct vm_struct        *next;
  36        void                    *addr;
  37        unsigned long           size;
  38        unsigned long           flags;
  39        struct page             **pages;
  40        unsigned int            nr_pages;
  41        phys_addr_t             phys_addr;
  42        const void              *caller;
  43};
  44
  45struct vmap_area {
  46        unsigned long va_start;
  47        unsigned long va_end;
  48        unsigned long flags;
  49        struct rb_node rb_node;         /* address sorted rbtree */
  50        struct list_head list;          /* address sorted list */
  51        struct llist_node purge_list;    /* "lazy purge" list */
  52        struct vm_struct *vm;
  53        struct rcu_head rcu_head;
  54};
  55
  56/*
  57 *      Highlevel APIs for driver use
  58 */
  59extern void vm_unmap_ram(const void *mem, unsigned int count);
  60extern void *vm_map_ram(struct page **pages, unsigned int count,
  61                                int node, pgprot_t prot);
  62extern void vm_unmap_aliases(void);
  63
  64#ifdef CONFIG_MMU
  65extern void __init vmalloc_init(void);
  66#else
  67static inline void vmalloc_init(void)
  68{
  69}
  70#endif
  71
  72extern void *vmalloc(unsigned long size);
  73extern void *vzalloc(unsigned long size);
  74extern void *vmalloc_user(unsigned long size);
  75extern void *vmalloc_node(unsigned long size, int node);
  76extern void *vzalloc_node(unsigned long size, int node);
  77extern void *vmalloc_exec(unsigned long size);
  78extern void *vmalloc_32(unsigned long size);
  79extern void *vmalloc_32_user(unsigned long size);
  80extern void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot);
  81extern void *__vmalloc_node_range(unsigned long size, unsigned long align,
  82                        unsigned long start, unsigned long end, gfp_t gfp_mask,
  83                        pgprot_t prot, unsigned long vm_flags, int node,
  84                        const void *caller);
  85#ifndef CONFIG_MMU
  86extern void *__vmalloc_node_flags(unsigned long size, int node, gfp_t flags);
  87static inline void *__vmalloc_node_flags_caller(unsigned long size, int node,
  88                                                gfp_t flags, void *caller)
  89{
  90        return __vmalloc_node_flags(size, node, flags);
  91}
  92#else
  93extern void *__vmalloc_node_flags_caller(unsigned long size,
  94                                         int node, gfp_t flags, void *caller);
  95#endif
  96
  97extern void vfree(const void *addr);
  98extern void vfree_atomic(const void *addr);
  99
 100extern void *vmap(struct page **pages, unsigned int count,
 101                        unsigned long flags, pgprot_t prot);
 102extern void vunmap(const void *addr);
 103
 104extern int remap_vmalloc_range_partial(struct vm_area_struct *vma,
 105                                       unsigned long uaddr, void *kaddr,
 106                                       unsigned long size);
 107
 108extern int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
 109                                                        unsigned long pgoff);
 110void vmalloc_sync_all(void);
 111 
 112/*
 113 *      Lowlevel-APIs (not for driver use!)
 114 */
 115
 116static inline size_t get_vm_area_size(const struct vm_struct *area)
 117{
 118        if (!(area->flags & VM_NO_GUARD))
 119                /* return actual size without guard page */
 120                return area->size - PAGE_SIZE;
 121        else
 122                return area->size;
 123
 124}
 125
 126extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
 127extern struct vm_struct *get_vm_area_caller(unsigned long size,
 128                                        unsigned long flags, const void *caller);
 129extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
 130                                        unsigned long start, unsigned long end);
 131extern struct vm_struct *__get_vm_area_caller(unsigned long size,
 132                                        unsigned long flags,
 133                                        unsigned long start, unsigned long end,
 134                                        const void *caller);
 135extern struct vm_struct *remove_vm_area(const void *addr);
 136extern struct vm_struct *find_vm_area(const void *addr);
 137
 138extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
 139                        struct page **pages);
 140#ifdef CONFIG_MMU
 141extern int map_kernel_range_noflush(unsigned long start, unsigned long size,
 142                                    pgprot_t prot, struct page **pages);
 143extern void unmap_kernel_range_noflush(unsigned long addr, unsigned long size);
 144extern void unmap_kernel_range(unsigned long addr, unsigned long size);
 145#else
 146static inline int
 147map_kernel_range_noflush(unsigned long start, unsigned long size,
 148                        pgprot_t prot, struct page **pages)
 149{
 150        return size >> PAGE_SHIFT;
 151}
 152static inline void
 153unmap_kernel_range_noflush(unsigned long addr, unsigned long size)
 154{
 155}
 156static inline void
 157unmap_kernel_range(unsigned long addr, unsigned long size)
 158{
 159}
 160#endif
 161
 162/* Allocate/destroy a 'vmalloc' VM area. */
 163extern struct vm_struct *alloc_vm_area(size_t size, pte_t **ptes);
 164extern void free_vm_area(struct vm_struct *area);
 165
 166/* for /dev/kmem */
 167extern long vread(char *buf, char *addr, unsigned long count);
 168extern long vwrite(char *buf, char *addr, unsigned long count);
 169
 170/*
 171 *      Internals.  Dont't use..
 172 */
 173extern struct list_head vmap_area_list;
 174extern __init void vm_area_add_early(struct vm_struct *vm);
 175extern __init void vm_area_register_early(struct vm_struct *vm, size_t align);
 176
 177#ifdef CONFIG_SMP
 178# ifdef CONFIG_MMU
 179struct vm_struct **pcpu_get_vm_areas(const unsigned long *offsets,
 180                                     const size_t *sizes, int nr_vms,
 181                                     size_t align);
 182
 183void pcpu_free_vm_areas(struct vm_struct **vms, int nr_vms);
 184# else
 185static inline struct vm_struct **
 186pcpu_get_vm_areas(const unsigned long *offsets,
 187                const size_t *sizes, int nr_vms,
 188                size_t align)
 189{
 190        return NULL;
 191}
 192
 193static inline void
 194pcpu_free_vm_areas(struct vm_struct **vms, int nr_vms)
 195{
 196}
 197# endif
 198#endif
 199
 200#ifdef CONFIG_MMU
 201#define VMALLOC_TOTAL (VMALLOC_END - VMALLOC_START)
 202#else
 203#define VMALLOC_TOTAL 0UL
 204#endif
 205
 206int register_vmap_purge_notifier(struct notifier_block *nb);
 207int unregister_vmap_purge_notifier(struct notifier_block *nb);
 208
 209#endif /* _LINUX_VMALLOC_H */
 210