内核内存分配

 1 struct kmem_cache {
 2 /* 1) per-cpu data, touched during every alloc/free 每次alloc都会被创建*/
 3     struct array_cache *array[NR_CPUS];
 4 /* 2) Cache tunables. Protected by cache_chain_mutex cache微调器 被cache_chain_mutex cache保护*/
 5     unsigned int batchcount;
 6     unsigned int limit;
 7     unsigned int shared;
 8 
 9     unsigned int buffer_size;
10     u32 reciprocal_buffer_size;
11 /* 3) touched by every alloc & free from the backend */
12 
13     unsigned int flags;        /* constant flags */
14     unsigned int num;        /* # of objs per slab */
15 
16 /* 4) cache_grow/shrink */
17     /* order of pgs per slab (2^n) */
18     unsigned int gfporder;
19 
20     /* force GFP flags, e.g. GFP_DMA */
21     gfp_t gfpflags;
22 
23     size_t colour;            /* cache colouring range */
24     unsigned int colour_off;    /* colour offset */
25     struct kmem_cache *slabp_cache;
26     unsigned int slab_size;
27     unsigned int dflags;        /* dynamic flags */
28 
29     /* constructor func */
30     void (*ctor)(void *obj);
31 
32 /* 5) cache creation/removal */
33     const char *name;
34     struct list_head next;
35 
36 /* 6) statistics */
37 #ifdef CONFIG_DEBUG_SLAB
38     unsigned long num_active;
39     unsigned long num_allocations;
40     unsigned long high_mark;
41     unsigned long grown;
42     unsigned long reaped;
43     unsigned long errors;
44     unsigned long max_freeable;
45     unsigned long node_allocs;
46     unsigned long node_frees;
47     unsigned long node_overflow;
48     atomic_t allochit;
49     atomic_t allocmiss;
50     atomic_t freehit;
51     atomic_t freemiss;
52 
53     /*
54      * If debugging is enabled, then the allocator can add additional
55      * fields and/or padding to every object. buffer_size contains the total
56      * object size including these internal fields, the following two
57      * variables contain the offset to the user object and its size.
58      */
59     int obj_offset;
60     int obj_size;
61 #endif /* CONFIG_DEBUG_SLAB */
62 
63     /*
64      * We put nodelists[] at the end of kmem_cache, because we want to size
65      * this array to nr_node_ids slots instead of MAX_NUMNODES
66      * (see kmem_cache_init())
67      * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache
68      * is statically defined, so we reserve the max number of nodes.
69      */
70     struct kmem_list3 *nodelists[MAX_NUMNODES];
71     /*
72      * Do not add fields after nodelists[]
73      */
74 };

struct kmem_cache *kmem_cache_create(const char *name, size_t size,
    size_t align, unsigned long flags, void (*ctor)(void *))
{
    struct kmem_cache *c;

    c = slob_alloc(sizeof(struct kmem_cache),
        GFP_KERNEL, ARCH_KMALLOC_MINALIGN, -1);

    if (c) {
        c->name = name;
        c->size = size;
        if (flags & SLAB_DESTROY_BY_RCU) {
            /* leave room for rcu footer at the end of object */
            c->size += sizeof(struct slob_rcu);
        }
        c->flags = flags;
        c->ctor = ctor;
        /* ignore alignment unless it‘s forced */
        c->align = (flags & SLAB_HWCACHE_ALIGN) ? SLOB_ALIGN : 0;
        if (c->align < ARCH_SLAB_MINALIGN)
            c->align = ARCH_SLAB_MINALIGN;
        if (c->align < align)
            c->align = align;
    } else if (flags & SLAB_PANIC)
        panic("Cannot create slab cache %s\n", name);

    kmemleak_alloc(c, sizeof(struct kmem_cache), 1, GFP_KERNEL);
    return c;
}

 1 typedef struct mempool_s {
 2     spinlock_t lock;
 3     int min_nr;        /* nr of elements at *elements 内存池应该始终保持的已分配对象的最小数目*/
 4     int curr_nr;        /* Current nr of elements at *elements */
 5     void **elements;
 6 
 7     void *pool_data;
 8     mempool_alloc_t *alloc;/*对象的实际分配和释放有这俩个函数指针来处理 */
 9     mempool_free_t *free;
10     wait_queue_head_t wait;
11 } mempool_t;

 1 /**
 2  * mempool_create - create a memory pool
 3  * @min_nr:    the minimum number of elements guaranteed to be
 4  *             allocated for this pool.
 5  * @alloc_fn:  user-defined element-allocation function.
 6  * @free_fn:   user-defined element-freeing function.
 7  * @pool_data: optional private data available to the user-defined functions.
 8  *
 9  * this function creates and allocates a guaranteed size, preallocated
10  * memory pool. The pool can be used from the mempool_alloc() and mempool_free()
11  * functions. This function might sleep. Both the alloc_fn() and the free_fn()
12  * functions might sleep - as long as the mempool_alloc() function is not called
13  * from IRQ contexts.
14  */
15 mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
16                 mempool_free_t *free_fn, void *pool_data)
17 {
18     return  mempool_create_node(min_nr,alloc_fn,free_fn, pool_data,-1);
19 }
20 EXPORT_SYMBOL(mempool_create);
21 
22 mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
23             mempool_free_t *free_fn, void *pool_data, int node_id)
24 {
25     mempool_t *pool;
26     pool = kmalloc_node(sizeof(*pool), GFP_KERNEL | __GFP_ZERO, node_id);
27     if (!pool)
28         return NULL;
29     pool->elements = kmalloc_node(min_nr * sizeof(void *),
30                     GFP_KERNEL, node_id);
31     if (!pool->elements) {
32         kfree(pool);
33         return NULL;
34     }
35     spin_lock_init(&pool->lock);
36     pool->min_nr = min_nr;
37     pool->pool_data = pool_data;
38     init_waitqueue_head(&pool->wait);
39     pool->alloc = alloc_fn;
40     pool->free = free_fn;
41 
42     /*
43      * First pre-allocate the guaranteed number of buffers.
44      */
45     while (pool->curr_nr < pool->min_nr) {
46         void *element;
47 
48         element = pool->alloc(GFP_KERNEL, pool->pool_data);
49         if (unlikely(!element)) {
50             free_pool(pool);
51             return NULL;
52         }
53         add_element(pool, element);
54     }
55     return pool;
56 }

 1 /**
 2  * mempool_resize - resize an existing memory pool
 3  * @pool:       pointer to the memory pool which was allocated via
 4  *              mempool_create().
 5  * @new_min_nr: the new minimum number of elements guaranteed to be
 6  *              allocated for this pool.
 7  * @gfp_mask:   the usual allocation bitmask.
 8  *
 9  * This function shrinks/grows the pool. In the case of growing,
10  * it cannot be guaranteed that the pool will be grown to the new
11  * size immediately, but new mempool_free() calls will refill it.
12  *
13  * Note, the caller must guarantee that no mempool_destroy is called
14  * while this function is running. mempool_alloc() & mempool_free()
15  * might be called (eg. from IRQ contexts) while this function executes.
16  */
17 int mempool_resize(mempool_t *pool, int new_min_nr, gfp_t gfp_mask)
18 {
19     void *element;
20     void **new_elements;
21     unsigned long flags;
22 
23     BUG_ON(new_min_nr <= 0);
24 
25     spin_lock_irqsave(&pool->lock, flags);
26     if (new_min_nr <= pool->min_nr) {
27         while (new_min_nr < pool->curr_nr) {
28             element = remove_element(pool);
29             spin_unlock_irqrestore(&pool->lock, flags);
30             pool->free(element, pool->pool_data);
31             spin_lock_irqsave(&pool->lock, flags);
32         }
33         pool->min_nr = new_min_nr;
34         goto out_unlock;
35     }
36     spin_unlock_irqrestore(&pool->lock, flags);
37 
38     /* Grow the pool */
39     new_elements = kmalloc(new_min_nr * sizeof(*new_elements), gfp_mask);
40     if (!new_elements)
41         return -ENOMEM;
42 
43     spin_lock_irqsave(&pool->lock, flags);
44     if (unlikely(new_min_nr <= pool->min_nr)) {
45         /* Raced, other resize will do our work */
46         spin_unlock_irqrestore(&pool->lock, flags);
47         kfree(new_elements);
48         goto out;
49     }
50     memcpy(new_elements, pool->elements,
51             pool->curr_nr * sizeof(*new_elements));
52     kfree(pool->elements);
53     pool->elements = new_elements;
54     pool->min_nr = new_min_nr;
55 
56     while (pool->curr_nr < pool->min_nr) {
57         spin_unlock_irqrestore(&pool->lock, flags);
58         element = pool->alloc(gfp_mask, pool->pool_data);
59         if (!element)
60             goto out;
61         spin_lock_irqsave(&pool->lock, flags);
62         if (pool->curr_nr < pool->min_nr) {
63             add_element(pool, element);
64         } else {
65             spin_unlock_irqrestore(&pool->lock, flags);
66             pool->free(element, pool->pool_data);    /* Raced */
67             goto out;
68         }
69     }
70 out_unlock:
71     spin_unlock_irqrestore(&pool->lock, flags);
72 out:
73     return 0;
74 }

 1 /**
 2  * mempool_destroy - deallocate a memory pool
 3  * @pool:      pointer to the memory pool which was allocated via
 4  *             mempool_create().
 5  *
 6  * this function only sleeps if the free_fn() function sleeps. The caller
 7  * has to guarantee that all elements have been returned to the pool (ie:
 8  * freed) prior to calling mempool_destroy().
 9  */
10 void mempool_destroy(mempool_t *pool)
11 {
12     /* Check for outstanding elements */
13     BUG_ON(pool->curr_nr != pool->min_nr);
14     free_pool(pool);
15 }

1 unsigned long get_zeroed_page(gfp_t gfp_mask)
2 {
3     return __get_free_pages(gfp_mask | __GFP_ZERO, 0);
4 }

 1 /*
 2  * Common helper functions.
 3  */
 4 unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
 5 {
 6     struct page *page;
 7 
 8     /*
 9      * __get_free_pages() returns a 32-bit address, which cannot represent
10      * a highmem page
11      */
12     VM_BUG_ON((gfp_mask & __GFP_HIGHMEM) != 0);
13 
14     page = alloc_pages(gfp_mask, order);
15     if (!page)
16         return 0;
17     return (unsigned long) page_address(page);
18 }

1 #define __get_free_page(gfp_mask) 2         __get_free_pages((gfp_mask), 0)

/*
 * Common helper functions.
 */
unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
{
    struct page *page;

    /*
     * __get_free_pages() returns a 32-bit address, which cannot represent
     * a highmem page
     */
    VM_BUG_ON((gfp_mask & __GFP_HIGHMEM) != 0);

    page = alloc_pages(gfp_mask, order);
    if (!page)
        return 0;
    return (unsigned long) page_address(page);
}

1 void __free_pages(struct page *page, unsigned int order)
2 {
3     if (put_page_testzero(page)) {
4         if (order == 0)
5             free_hot_cold_page(page, 0);
6         else
7             __free_pages_ok(page, order);
8     }
9 }

1 #define alloc_pages(gfp_mask, order) 2         alloc_pages_node(numa_node_id(), gfp_mask, order)

 1   #ifdef CONFIG_NUMA
 2 extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order);
 3   
 4   static inline struct page *
 5   alloc_pages(gfp_t gfp_mask, unsigned int order)
 6   {
 7       return alloc_pages_current(gfp_mask, order);
 8   }
 9   extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
10              struct vm_area_struct *vma, unsigned long addr,
11              int node);
12  #else
13  #define alloc_pages(gfp_mask, order) 14          alloc_pages_node(numa_node_id(), gfp_mask, order)
15  #define alloc_pages_vma(gfp_mask, order, vma, addr, node)    16      alloc_pages(gfp_mask, order)
17 #endif