【Linux内存管理】vmalloc不连续内存管理（3）

【file:/mm/vmalloc.c】
/**
 * vfree - release memory allocated by vmalloc()
 * @addr: memory base address
 *
 * Free the virtually continuous memory area starting at @addr, as
 * obtained from vmalloc(), vmalloc_32() or __vmalloc(). If @addr is
 * NULL, no operation is performed.
 *
 * Must not be called in NMI context (strictly speaking, only if we don't
 * have CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG, but making the calling
 * conventions for vfree() arch-depenedent would be a really bad idea)
 *
 * NOTE: assumes that the object at *addr has a size >= sizeof(llist_node)
 */
void vfree(const void *addr)
{
    BUG_ON(in_nmi());
 
    kmemleak_free(addr);
 
    if (!addr)
        return;
    if (unlikely(in_interrupt())) {
        struct vfree_deferred *p = &__get_cpu_var(vfree_deferred);
        if (llist_add((struct llist_node *)addr, &p->list))
            schedule_work(&p->wq);
    } else
        __vunmap(addr, 1);
}

【file:/mm/vmalloc.c】
static void free_work(struct work_struct *w)
{
    struct vfree_deferred *p = container_of(w, struct vfree_deferred, wq);
    struct llist_node *llnode = llist_del_all(&p->list);
    while (llnode) {
        void *p = llnode;
        llnode = llist_next(llnode);
        __vunmap(p, 1);
    }
}

【file:/mm/vmalloc.c】
static void __vunmap(const void *addr, int deallocate_pages)
{
    struct vm_struct *area;
 
    if (!addr)
        return;
 
    if (WARN(!PAGE_ALIGNED(addr), "Trying to vfree() bad address (%p)\n",
            addr))
        return;
 
    area = remove_vm_area(addr);
    if (unlikely(!area)) {
        WARN(1, KERN_ERR "Trying to vfree() nonexistent vm area (%p)\n",
                addr);
        return;
    }
 
    debug_check_no_locks_freed(addr, area->size);
    debug_check_no_obj_freed(addr, area->size);
 
    if (deallocate_pages) {
        int i;
 
        for (i = 0; i < area->nr_pages; i++) {
            struct page *page = area->pages[i];
 
            BUG_ON(!page);
            __free_page(page);
        }
 
        if (area->flags & VM_VPAGES)
            vfree(area->pages);
        else
            kfree(area->pages);
    }
 
    kfree(area);
    return;
}

【file:/mm/vmalloc.c】
/**
 * 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.
 */
struct vm_struct *remove_vm_area(const void *addr)
{
    struct vmap_area *va;
 
    va = find_vmap_area((unsigned long)addr);
    if (va && va->flags & VM_VM_AREA) {
        struct vm_struct *vm = va->vm;
 
        spin_lock(&vmap_area_lock);
        va->vm = NULL;
        va->flags &= ~VM_VM_AREA;
        spin_unlock(&vmap_area_lock);
 
        vmap_debug_free_range(va->va_start, va->va_end);
        free_unmap_vmap_area(va);
        vm->size -= PAGE_SIZE;
 
        return vm;
    }
    return NULL;
}

【file:/mm/vmalloc.c】
static struct vmap_area *find_vmap_area(unsigned long addr)
{
    struct vmap_area *va;
 
    spin_lock(&vmap_area_lock);
    va = __find_vmap_area(addr);
    spin_unlock(&vmap_area_lock);
 
    return va;
}

【file:/mm/vmalloc.c】
static struct vmap_area *__find_vmap_area(unsigned long addr)
{
    struct rb_node *n = vmap_area_root.rb_node;
 
    while (n) {
        struct vmap_area *va;
 
        va = rb_entry(n, struct vmap_area, rb_node);
        if (addr < va->va_start)
            n = n->rb_left;
        else if (addr >= va->va_end)
            n = n->rb_right;
        else
            return va;
    }
 
    return NULL;
}

【file:/mm/vmalloc.c】
/*
 * Free and unmap a vmap area
 */
static void free_unmap_vmap_area(struct vmap_area *va)
{
    flush_cache_vunmap(va->va_start, va->va_end);
    free_unmap_vmap_area_noflush(va);
}

【file:/mm/vmalloc.c】
/*
 * Free and unmap a vmap area, caller ensuring flush_cache_vunmap had been
 * called for the correct range previously.
 */
static void free_unmap_vmap_area_noflush(struct vmap_area *va)
{
    unmap_vmap_area(va);
    free_vmap_area_noflush(va);
}

【file:/mm/vmalloc.c】
/*
 * Clear the pagetable entries of a given vmap_area
 */
static void unmap_vmap_area(struct vmap_area *va)
{
    vunmap_page_range(va->va_start, va->va_end);
}

【file:/mm/vmalloc.c】
static void vunmap_page_range(unsigned long addr, unsigned long end)
{
    pgd_t *pgd;
    unsigned long next;
 
    BUG_ON(addr >= end);
    pgd = pgd_offset_k(addr);
    do {
        next = pgd_addr_end(addr, end);
        if (pgd_none_or_clear_bad(pgd))
            continue;
        vunmap_pud_range(pgd, addr, next);
    } while (pgd++, addr = next, addr != end);
}

【file:/mm/vmalloc.c】
/*
 * Free a vmap area, caller ensuring that the area has been unmapped
 * and flush_cache_vunmap had been called for the correct range
 * previously.
 */
static void free_vmap_area_noflush(struct vmap_area *va)
{
    va->flags |= VM_LAZY_FREE;
    atomic_add((va->va_end - va->va_start) >> PAGE_SHIFT, &vmap_lazy_nr);
    if (unlikely(atomic_read(&vmap_lazy_nr) > lazy_max_pages()))
        try_purge_vmap_area_lazy();
}