Source of vmalloc.c - linux-imx - PHYTEC BitBucket (Stash)

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
    BUG_ON(addr_to_vb_idx(addr) != addr_to_vb_idx(va_start));
    return (void *)addr;
}
​
/**
 * new_vmap_block - allocates new vmap_block and occupies 2^order pages in this
 *                  block. Of course pages number can't exceed VMAP_BBMAP_BITS
 * @order:    how many 2^order pages should be occupied in newly allocated block
 * @gfp_mask: flags for the page level allocator
 *
 * Returns: virtual address in a newly allocated block or ERR_PTR(-errno)
 * Return: virtual address in a newly allocated block or ERR_PTR(-errno)
 */
static void *new_vmap_block(unsigned int order, gfp_t gfp_mask)
{
    struct vmap_block_queue *vbq;
    struct vmap_block *vb;
    struct vmap_area *va;
    unsigned long vb_idx;
    int node, err;
    void *vaddr;
​
Show more
}
​
/**
 * get_vm_area - reserve a contiguous kernel virtual area
 * @size:    size of the area
 * @flags:   %VM_IOREMAP for I/O mappings or VM_ALLOC
 *
 * Search an area of @size in the kernel virtual mapping area,
 * and reserved it for out purposes.  Returns the area descriptor
 * on success or %NULL on failure.
 *
 * Return: the area descriptor on success or %NULL on failure.
 */
struct vm_struct *get_vm_area(unsigned long size, unsigned long flags)
{
    return __get_vm_area_node(size, 1, flags, VMALLOC_START, VMALLOC_END,
                  NUMA_NO_NODE, GFP_KERNEL,
                  __builtin_return_address(0));
}
​
struct vm_struct *get_vm_area_caller(unsigned long size, unsigned long flags,
                const void *caller)
Show more
                  NUMA_NO_NODE, GFP_KERNEL, caller);
}
​
/**
 * find_vm_area - find a continuous kernel virtual area
 * @addr:     base address
 *
 * Search for the kernel VM area starting at @addr, and return it.
 * It is up to the caller to do all required locking to keep the returned
 * pointer valid.
 *
 * Return: pointer to the found area or %NULL on faulure
 */
struct vm_struct *find_vm_area(const void *addr)
{
    struct vmap_area *va;
​
    va = find_vmap_area((unsigned long)addr);
    if (va && va->flags & VM_VM_AREA)
        return va->vm;
​
    return NULL;
}
​
/**
 * remove_vm_area - find and remove a continuous kernel virtual area
 * @addr:       base address
 *
 * Search for the kernel VM area starting at @addr, and remove it.
 * This function returns the found VM area, but using it is NOT safe
 * on SMP machines, except for its size or flags.
 *
 * Return: pointer to the found area or %NULL on faulure
 */
struct vm_struct *remove_vm_area(const void *addr)
{
    struct vmap_area *va;
​
    might_sleep();
​
    va = find_vmap_area((unsigned long)addr);
    if (va && va->flags & VM_VM_AREA) {
        struct vm_struct *vm = va->vm;
Show more
​
/**
 * vmap - map an array of pages into virtually contiguous space
 * @pages: array of page pointers
 * @count: number of pages to map
 * @flags: vm_area->flags
 * @prot: page protection for the mapping
 *
 * Maps @count pages from @pages into contiguous kernel virtual
 * space.
 *
 * Return: the address of the area or %NULL on failure
 */
void *vmap(struct page **pages, unsigned int count,
       unsigned long flags, pgprot_t prot)
{
    struct vm_struct *area;
    unsigned long size;     /* In bytes */
​
    might_sleep();
​
    if (count > totalram_pages())
Show more
 * @end:          vm area range end
 * @gfp_mask:         flags for the page level allocator
 * @prot:         protection mask for the allocated pages
 * @vm_flags:         additional vm area flags (e.g. %VM_NO_GUARD)
 * @node:         node to use for allocation or NUMA_NO_NODE
 * @caller:       caller's return address
 *
 * Allocate enough pages to cover @size from the page level
 * allocator with @gfp_mask flags.  Map them into contiguous
 * kernel virtual space, using a pagetable protection of @prot.
 *
 * Return: the address of the area or %NULL on failure
 */
void *__vmalloc_node_range(unsigned long size, unsigned long align,
            unsigned long start, unsigned long end, gfp_t gfp_mask,
            pgprot_t prot, unsigned long vm_flags, int node,
            const void *caller)
{
    struct vm_struct *area;
    void *addr;
    unsigned long real_size = size;
​
Show more
 *
 * Allocate enough pages to cover @size from the page level
 * allocator with @gfp_mask flags.  Map them into contiguous
 * kernel virtual space, using a pagetable protection of @prot.
 *
 * Reclaim modifiers in @gfp_mask - __GFP_NORETRY, __GFP_RETRY_MAYFAIL
 * and __GFP_NOFAIL are not supported
 *
 * Any use of gfp flags outside of GFP_KERNEL should be consulted
 * with mm people.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
static void *__vmalloc_node(unsigned long size, unsigned long align,
                gfp_t gfp_mask, pgprot_t prot,
                int node, const void *caller)
{
    return __vmalloc_node_range(size, align, VMALLOC_START, VMALLOC_END,
                gfp_mask, prot, 0, node, caller);
}
​
void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
Show more
​
/**
 * vmalloc - allocate virtually contiguous memory
 * @size:    allocation size
 *
 * Allocate enough pages to cover @size from the page level
 * allocator and map them into contiguous kernel virtual space.
 *
 * For tight control over page level allocator and protection flags
 * use __vmalloc() instead.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vmalloc(unsigned long size)
{
    return __vmalloc_node_flags(size, NUMA_NO_NODE,
                    GFP_KERNEL);
}
EXPORT_SYMBOL(vmalloc);
​
/**
 * vzalloc - allocate virtually contiguous memory with zero fill
 * @size:    allocation size
 *
 * Allocate enough pages to cover @size from the page level
 * allocator and map them into contiguous kernel virtual space.
 * The memory allocated is set to zero.
 *
 * For tight control over page level allocator and protection flags
 * use __vmalloc() instead.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vzalloc(unsigned long size)
{
    return __vmalloc_node_flags(size, NUMA_NO_NODE,
                GFP_KERNEL | __GFP_ZERO);
}
EXPORT_SYMBOL(vzalloc);
​
/**
 * vmalloc_user - allocate zeroed virtually contiguous memory for userspace
 * @size: allocation size
 *
 * The resulting memory area is zeroed so it can be mapped to userspace
 * without leaking data.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vmalloc_user(unsigned long size)
{
    return __vmalloc_node_range(size, SHMLBA,  VMALLOC_START, VMALLOC_END,
                    GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL,
                    VM_USERMAP, NUMA_NO_NODE,
                    __builtin_return_address(0));
}
EXPORT_SYMBOL(vmalloc_user);
​
/**
 * vmalloc_node - allocate memory on a specific node
 * @size:     allocation size
 * @node:     numa node
 *
 * Allocate enough pages to cover @size from the page level
 * allocator and map them into contiguous kernel virtual space.
 *
 * For tight control over page level allocator and protection flags
 * use __vmalloc() instead.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vmalloc_node(unsigned long size, int node)
{
    return __vmalloc_node(size, 1, GFP_KERNEL, PAGE_KERNEL,
                    node, __builtin_return_address(0));
}
EXPORT_SYMBOL(vmalloc_node);
​
/**
 * vzalloc_node - allocate memory on a specific node with zero fill
 * @size:   allocation size
 * @node:   numa node
 *
 * Allocate enough pages to cover @size from the page level
 * allocator and map them into contiguous kernel virtual space.
 * The memory allocated is set to zero.
 *
 * For tight control over page level allocator and protection flags
 * use __vmalloc_node() instead.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vzalloc_node(unsigned long size, int node)
{
    return __vmalloc_node_flags(size, node,
             GFP_KERNEL | __GFP_ZERO);
}
EXPORT_SYMBOL(vzalloc_node);
​
/**
 * vmalloc_exec - allocate virtually contiguous, executable memory
 * @size:     allocation size
 *
 * Kernel-internal function to allocate enough pages to cover @size
 * the page level allocator and map them into contiguous and
 * executable kernel virtual space.
 *
 * For tight control over page level allocator and protection flags
 * use __vmalloc() instead.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vmalloc_exec(unsigned long size)
{
    return __vmalloc_node(size, 1, GFP_KERNEL, PAGE_KERNEL_EXEC,
                  NUMA_NO_NODE, __builtin_return_address(0));
}
​
#if defined(CONFIG_64BIT) && defined(CONFIG_ZONE_DMA32)
#define GFP_VMALLOC32 (GFP_DMA32 | GFP_KERNEL)
#elif defined(CONFIG_64BIT) && defined(CONFIG_ZONE_DMA)
Show more
 */
#define GFP_VMALLOC32 GFP_DMA32 | GFP_KERNEL
#endif
​
/**
 * vmalloc_32 - allocate virtually contiguous memory (32bit addressable)
 * @size:   allocation size
 *
 * Allocate enough 32bit PA addressable pages to cover @size from the
 * page level allocator and map them into contiguous kernel virtual space.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vmalloc_32(unsigned long size)
{
    return __vmalloc_node(size, 1, GFP_VMALLOC32, PAGE_KERNEL,
                  NUMA_NO_NODE, __builtin_return_address(0));
}
EXPORT_SYMBOL(vmalloc_32);
​
/**
 * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
 * @size:        allocation size
 *
 * The resulting memory area is 32bit addressable and zeroed so it can be
 * mapped to userspace without leaking data.
 *
 * Return: pointer to the allocated memory or %NULL on error
 */
void *vmalloc_32_user(unsigned long size)
{
    return __vmalloc_node_range(size, SHMLBA,  VMALLOC_START, VMALLOC_END,
                    GFP_VMALLOC32 | __GFP_ZERO, PAGE_KERNEL,
                    VM_USERMAP, NUMA_NO_NODE,
                    __builtin_return_address(0));
}
EXPORT_SYMBOL(vmalloc_32_user);
​
Show more
    }
    return copied;
}
​
/**
 * vread() - read vmalloc area in a safe way.
 * @buf:     buffer for reading data
 * @addr:    vm address.
 * @count:   number of bytes to be read.
 *
 * Returns # of bytes which addr and buf should be increased.
 * (same number to @count). Returns 0 if [addr...addr+count) doesn't
 * includes any intersect with alive vmalloc area.
 *
 * This function checks that addr is a valid vmalloc'ed area, and
 * copy data from that area to a given buffer. If the given memory range
 * of [addr...addr+count) includes some valid address, data is copied to
 * proper area of @buf. If there are memory holes, they'll be zero-filled.
 * IOREMAP area is treated as memory hole and no copy is done.
 *
 * If [addr...addr+count) doesn't includes any intersects with alive
 * vm_struct area, returns 0. @buf should be kernel's buffer.
 *
 * Note: In usual ops, vread() is never necessary because the caller
 * should know vmalloc() area is valid and can use memcpy().
 * This is for routines which have to access vmalloc area without
 * any informaion, as /dev/kmem.
 *
 * Return: number of bytes for which addr and buf should be increased
 * (same number as @count) or %0 if [addr...addr+count) doesn't
 * include any intersection with valid vmalloc area
 */
long vread(char *buf, char *addr, unsigned long count)
{
    struct vmap_area *va;
    struct vm_struct *vm;
    char *vaddr, *buf_start = buf;
    unsigned long buflen = count;
    unsigned long n;
​
    /* Don't allow overflow */
Show more
​
    return buflen;
}
​
/**
 * vwrite() - write vmalloc area in a safe way.
 * @buf:      buffer for source data
 * @addr:     vm address.
 * @count:    number of bytes to be read.
 *
 * Returns # of bytes which addr and buf should be incresed.
 * (same number to @count).
 * If [addr...addr+count) doesn't includes any intersect with valid
 * vmalloc area, returns 0.
 *
 * This function checks that addr is a valid vmalloc'ed area, and
 * copy data from a buffer to the given addr. If specified range of
 * [addr...addr+count) includes some valid address, data is copied from
 * proper area of @buf. If there are memory holes, no copy to hole.
 * IOREMAP area is treated as memory hole and no copy is done.
 *
 * If [addr...addr+count) doesn't includes any intersects with alive
 * vm_struct area, returns 0. @buf should be kernel's buffer.
 *
 * Note: In usual ops, vwrite() is never necessary because the caller
 * should know vmalloc() area is valid and can use memcpy().
 * This is for routines which have to access vmalloc area without
 * any informaion, as /dev/kmem.
 *
 * Return: number of bytes for which addr and buf should be
 * increased (same number as @count) or %0 if [addr...addr+count)
 * doesn't include any intersection with valid vmalloc area
 */
long vwrite(char *buf, char *addr, unsigned long count)
{
    struct vmap_area *va;
    struct vm_struct *vm;
    char *vaddr;
    unsigned long n, buflen;
    int copied = 0;
​
    /* Don't allow overflow */