AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

linux内存管理之kmem_cache_init

2015-02-10 1478
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：    之前多多少少接触过cache之类的东西，总觉的很神秘，当然cache就是为了读写内存更高效。比如查看meminfo或者slabinfo的时候，你是否真的对内存机制理解的很清晰？  参考内核linux 3.
   之前多多少少接触过cache之类的东西，总觉的很神秘，当然cache就是为了读写内存更高效。比如查看meminfo或者slabinfo的时候，你是否真的对内存机制理解的很清晰？
 参考内核linux 3.8.13
 我们看看调用它的函数接口：

点击(此处)折叠或打开

  1. /*
  2.  * Set up kernel memory allocators
  3.  */
  4. static void __init mm_init(void)
  5. {
  6.     /*
  7.      * page_cgroup requires contiguous pages,
  8.      * bigger than MAX_ORDER unless SPARSEMEM.
  9.      */
  10.     page_cgroup_init_flatmem();
  11.     mem_init();
  12.     kmem_cache_init();
  13.     percpu_init_late();
  14.     pgtable_cache_init();
  15.     vmalloc_init();
  16. }
这个函数在start_kernel里调用. 下面我们就看看  kmem_cache_init ( ) ;  //默认slab分配器

点击(此处)折叠或打开

  1. /*
  2.  * Initialisation. Called after the page allocator have been initialised and
  3.  * before smp_init().
  4.  */
  5. void __init kmem_cache_init(void)
  6. {
  7.     struct cache_sizes *sizes;
  8.     struct cache_names *names;
  9.     int i;

  11.     kmem_cache = &kmem_cache_boot;
  12.     setup_nodelists_pointer(kmem_cache);    // 关于为什么要设置这个玩意，我找到一个patch说明

  13. 点击(此处)折叠或打开

    1. From 3c58346525d82625e68e24f071804c2dc057b6f4 Mon Sep 17 00:00:00 2001
    2. From: Christoph Lameter cl@linux.com>
    3. Date: Wed, 28 Nov 2012 16:23:01 +0000
    4. Subject: [PATCH] slab: Simplify bootstrap

    6. The nodelists field in kmem_cache is pointing to the first unused
    7. object in the array field when bootstrap is complete.

    9. A problem with the current approach is that the statically sized
    10. kmem_cache structure use on boot can only contain NR_CPUS entries.
    11. If the number of nodes plus the number of cpus is greater then we
    12. would overwrite memory following the kmem_cache_boot definition.

    14. Increase the size of the array field to ensure that also the node
    15. pointers fit into the array field.

    17. Once we do that we no longer need the kmem_cache_nodelists
    18. array and we can then also use that structure elsewhere.

    20. Acked-by: Glauber Costa glommer@parallels.com>
    21. Signed-off-by: Christoph Lameter cl@linux.com>
    22. Signed-off-by: Pekka Enberg penberg@kernel.org>



  15.     if (num_possible_nodes() == 1)
  16.         use_alien_caches = 0;

  18.     for (i = 0; i NUM_INIT_LISTS; i++)
  19.         kmem_list3_init(&initkmem_list3[i]);

  21.     set_up_list3s(kmem_cache, CACHE_CACHE);

  23.     /*
  24.      * Fragmentation resistance on low memory - only use bigger
  25.      * page orders on machines with more than 32MB of memory if
  26.      * not overridden on the command line.
  27.      */
  28.     if (!slab_max_order_set && totalram_pages > (32 20) >> PAGE_SHIFT)
  29.         slab_max_order = SLAB_MAX_ORDER_HI;

  31.     /* Bootstrap is tricky, because several objects are allocated
  32.      * from caches that do not exist yet:
  33.      * 1) initialize the kmem_cache cache: it contains the struct
  34.      * kmem_cache structures of all caches, except kmem_cache itself:
  35.      * kmem_cache is statically allocated.
  36.      * Initially an __init data area is used for the head array and the
  37.      * kmem_list3 structures, it's replaced with a kmalloc allocated
  38.      * array at the end of the bootstrap.
  39.      * 2) Create the first kmalloc cache.
  40.      * The struct kmem_cache for the new cache is allocated normally.
  41.      * An __init data area is used for the head array.
  42.      * 3) Create the remaining kmalloc caches, with minimally sized
  43.      * head arrays.
  44.      * 4) Replace the __init data head arrays for kmem_cache and the first
  45.      * kmalloc cache with kmalloc allocated arrays.
  46.      * 5) Replace the __init data for kmem_list3 for kmem_cache and
  47.      * the other cache's with kmalloc allocated memory.
  48.      * 6) Resize the head arrays of the kmalloc caches to their final sizes.
  49.      */

  51.     /* 1) create the kmem_cache */

  53.     /*
  54.      * struct kmem_cache size depends on nr_node_ids & nr_cpu_ids
  55.      */
  56.     create_boot_cache(kmem_cache, "kmem_cache",
  57.         offsetof(struct kmem_cache, array[nr_cpu_ids]) +
  58.                  nr_node_ids * sizeof(struct kmem_list3 *),
  59.                  SLAB_HWCACHE_ALIGN);
  60.     list_add(&kmem_cache->list, &slab_caches);   // create kmem_cache后把它添加到slab_caches全局链表.

  62.     /* 2+3) create the kmalloc caches */
  63.     sizes = malloc_sizes;
  64.     names = cache_names;

  66.     /*
  67.      * Initialize the caches that provide memory for the array cache and the
  68.      * kmem_list3 structures first. Without this, further allocations will
  69.      * bug.
  70.      */

  72.     sizes[INDEX_AC].cs_cachep = create_kmalloc_cache(names[INDEX_AC].name,
  73.                     sizes[INDEX_AC].cs_size, ARCH_KMALLOC_FLAGS);

  75.     if (INDEX_AC != INDEX_L3)
  76.         sizes[INDEX_L3].cs_cachep =
  77.             create_kmalloc_cache(names[INDEX_L3].name,
  78.                 sizes[INDEX_L3].cs_size, ARCH_KMALLOC_FLAGS);

  80.     slab_early_init = 0;

  82.     while (sizes->cs_size != ULONG_MAX) {
  83.         /*
  84.          * For performance, all the general caches are L1 aligned.
  85.          * This should be particularly beneficial on SMP boxes, as it
  86.          * eliminates "false sharing".
  87.          * Note for systems short on memory removing the alignment will
  88.          * allow tighter packing of the smaller caches.
  89.          */
  90.         if (!sizes->cs_cachep)
  91.             sizes->cs_cachep = create_kmalloc_cache(names->name,
  92.                     sizes->cs_size, ARCH_KMALLOC_FLAGS);

  94. #ifdef CONFIG_ZONE_DMA
  95.         sizes->cs_dmacachep = create_kmalloc_cache(
  96.             names->name_dma, sizes->cs_size,
  97.             SLAB_CACHE_DMA|ARCH_KMALLOC_FLAGS);
  98. #endif
  99.         sizes++;
  100.         names++;
  101.     }
  102.     /* 4) Replace the bootstrap head arrays */
  103.     {
  104.         struct array_cache *ptr;

  106.         ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);

  108.         memcpy(ptr, cpu_cache_get(kmem_cache),
  109.          sizeof(struct arraycache_init));
  110.         /*
  111.          * Do not assume that spinlocks can be initialized via memcpy:
  112.          */
  113.         spin_lock_init(&ptr->lock);

  115.         kmem_cache->array[smp_processor_id()] = ptr;

  117.         ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);

  119.         BUG_ON(cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep)
  120.          != &initarray_generic.cache);
  121.         memcpy(ptr, cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep),
  122.          sizeof(struct arraycache_init));
  123.         /*
  124.          * Do not assume that spinlocks can be initialized via memcpy:
  125.          */
  126.         spin_lock_init(&ptr->lock);

  128.         malloc_sizes[INDEX_AC].cs_cachep->array[smp_processor_id()] =
  129.          ptr;
  130.     }
  131.     /* 5) Replace the bootstrap kmem_list3's */
  132.     {
  133.         int nid;

  135.         for_each_online_node(nid) {
  136.             init_list(kmem_cache, &initkmem_list3[CACHE_CACHE + nid], nid);

  138.             init_list(malloc_sizes[INDEX_AC].cs_cachep,
  139.                  &initkmem_list3[SIZE_AC + nid], nid);

  141.             if (INDEX_AC != INDEX_L3) {
  142.                 init_list(malloc_sizes[INDEX_L3].cs_cachep,
  143.                      &initkmem_list3[SIZE_L3 + nid], nid);
  144.             }
  145.         }
  146.     }

  148.     slab_state = UP;
  149. }
第一行来自一个全局的指针变量，即为创建第一个cache（ kmem_cache）
在mm/slab_common.c中
struct kmem_cache *kmem_cache;
创建的所有cache都会挂在LIST_HEAD(slab_caches); 这个全局链表上.在cat /proc/slabinfo可以查看》
这里可以看看 struct kmem_cache：在slab_def.h中

点击(此处)折叠或打开

  1. struct kmem_cache {
  2. /* 1) Cache tunables. Protected by cache_chain_mutex */
  3.     unsigned int batchcount;
  4.     unsigned int limit;
  5.     unsigned int shared;

  7.     unsigned int size;
  8.     u32 reciprocal_buffer_size;  
  9. /* 2) touched by every alloc & free from the backend */

  11.     unsigned int flags;        /* constant flags */
  12.     unsigned int num;        /* # of objs per slab */

  14. /* 3) cache_grow/shrink */
  15.     /* order of pgs per slab (2^n) */
  16.     unsigned int gfporder;

  18.     /* force GFP flags, e.g. GFP_DMA */
  19.     gfp_t allocflags;

  21.     size_t colour;            /* cache colouring range */
  22.     unsigned int colour_off;    /* colour offset */
  23.     struct kmem_cache *slabp_cache;
  24.     unsigned int slab_size;

  26.     /* constructor func */
  27.     void (*ctor)(void *obj);

  29. /* 4) cache creation/removal */
  30.     const char *name;
  31.     struct list_head list;
  32.     int refcount;
  33.     int object_size;
  34.     int align;

  36. /* 5) 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;

  53.     /*
  54.      * If debugging is enabled, then the allocator can add additional
  55.      * fields and/or padding to every object. 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. #endif /* CONFIG_DEBUG_SLAB */
  61. #ifdef CONFIG_MEMCG_KMEM
  62.     struct memcg_cache_params *memcg_params;
  63. #endif

  65. /* 6) per-cpu/per-node data, touched during every alloc/free */
  66.     /*
  67.      * We put array[] at the end of kmem_cache, because we want to size
  68.      * this array to nr_cpu_ids slots instead of NR_CPUS
  69.      * (see kmem_cache_init())
  70.      * We still use [NR_CPUS] and not [1] or [0] because cache_cache
  71.      * is statically defined, so we reserve the max number of cpus.
  72.      *
  73.      * We also need to guarantee that the list is able to accomodate a
  74.      * pointer for each node since "nodelists" uses the remainder of
  75.      * available pointers.
  76.      */
  77.     struct kmem_list3 **nodelists;
  78.     struct array_cache *array[NR_CPUS + MAX_NUMNODES];
  79.     /*
  80.      * Do not add fields after array[]
  81.      */
  82. }
这个结构体里面几个关键的元素之前在kmalloc里已经说到了。
而 kmem_cache_boot则是：

点击(此处)折叠或打开

  1. /* internal cache of cache description objs */
  2. static struct kmem_cache kmem_cache_boot = {
  3.     .batchcount = 1,
  4.     .limit = BOOT_CPUCACHE_ENTRIES,   // 默认为 1
  5.     .shared = 1,
  6.     .size = sizeof(struct kmem_cache),
  7.     .name = "kmem_cache",
  8. };
注释解释的已经很清晰了.
而setup_nodelists_pointer的作用就是把struct kmem_cache里array指针地址存放在nodelists.目的是为了便于操作指针.
对于一致性内存访问，inode只有一个. 

点击(此处)折叠或打开

  1. static struct kmem_list3 __initdata initkmem_list3[NUM_INIT_LISTS];
它是slab.c中静态全局变量

点击(此处)折叠或打开

  1. /*
  2.  * Need this for bootstrapping a per node allocator.
  3.  */
kmem_list3_init初始化slab的三个链表slabs_full、slabs_partial、slabs_free.为什么初始化这个和cache组成结构有关系，可以看个图：

这里CACHE_CACHE在文件的开头部分被定义为0.

点击(此处)折叠或打开

  1. /*
  2.  * For setting up all the kmem_list3s for cache whose buffer_size is same as
  3.  * size of kmem_list3.
  4.  */
  5. static void __init set_up_list3s(struct kmem_cache *cachep, int index)
  6. {
  7.     int node;

  9.     for_each_online_node(node) {
  10.         cachep->nodelists[node] = &initkmem_list3[index + node];
  11.         cachep->nodelists[node]->next_reap = jiffies +
  12.          REAPTIMEOUT_LIST3 +
  13.          ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
  14.     }
  15. }
接着就要开始了真正的创建cache的工作，并且给出了初始化步骤和说明：

点击(此处)折叠或打开

  1. /* Bootstrap is tricky, because several objects are allocated
  2.      * from caches that do not exist yet:
  3.      * 1) initialize the kmem_cache cache: it contains the struct
  4.      * kmem_cache structures of all caches, except kmem_cache itself:
  5.      * kmem_cache is statically allocated.
  6.      * Initially an __init data area is used for the head array and the
  7.      * kmem_list3 structures, it's replaced with a kmalloc allocated
  8.      * array at the end of the bootstrap.
  9.      * 2) Create the first kmalloc cache.
  10.      * The struct kmem_cache for the new cache is allocated normally.
  11.      * An __init data area is used for the head array.
  12.      * 3) Create the remaining kmalloc caches, with minimally sized
  13.      * head arrays.
  14.      * 4) Replace the __init data head arrays for kmem_cache and the first
  15.      * kmalloc cache with kmalloc allocated arrays.
  16.      * 5) Replace the __init data for kmem_list3 for kmem_cache and
  17.      * the other cache's with kmalloc allocated memory.
  18.      * 6) Resize the head arrays of the kmalloc caches to their final sizes.
  19.      */

  21.     /* 1) create the kmem_cache */

  23.     /*
  24.      * struct kmem_cache size depends on nr_node_ids & nr_cpu_ids
  25.      */
  26.     create_boot_cache(kmem_cache, "kmem_cache",
  27.         offsetof(struct kmem_cache, array[nr_cpu_ids]) +
  28.                  nr_node_ids * sizeof(struct kmem_list3 *),
  29.                  SLAB_HWCACHE_ALIGN);
  30.     list_add(&kmem_cache->list, &slab_caches);
首先创建第一个cache它名为kmem_cache，并且kmem_cache指针变量指向了kmem_cache_boot.
下面我们看看 create_boot_cache函数

点击(此处)折叠或打开

  1. #ifndef CONFIG_SLOB
  2. /* Create a cache during boot when no slab services are available yet */
  3. void __init create_boot_cache(struct kmem_cache *s, const char *name, size_t size,
  4.         unsigned long flags)
  5. {
  6.     int err;

  8.     s->name = name;
  9.     s->size = s->object_size = size;
  10.     s->align = calculate_alignment(flags, ARCH_KMALLOC_MINALIGN, size);
  11.     err = __kmem_cache_create(s, flags);

  13.     if (err)
  14.         panic("Creation of kmalloc slab %s size=%zd failed. Reason %d\n",
  15.                     name, size, err);

  17.     s->refcount = -1;    /* Exempt from merging for now */
  18. }

  20. struct kmem_cache *__init create_kmalloc_cache(const char *name, size_t size,
  21.                 unsigned long flags)
  22. {
  23.     struct kmem_cache *s = kmem_cache_zalloc(kmem_cache, GFP_NOWAIT);

  25.     if (!s)
  26.         panic("Out of memory when creating slab %s\n", name);

  28.     create_boot_cache(s, name, size, flags);
  29.     list_add(&s->list, &slab_caches);
  30.     s->refcount = 1;
  31.     return s;
  32. }

  34. #endif /* !CONFIG_SLOB */
而它接着调用了__kmem_cache_create：这是最关键的函数

点击(此处)折叠或打开

  1. /**
  2.  * __kmem_cache_create - Create a cache.
  3.  * @cachep: cache management descriptor
  4.  * @flags: SLAB flags
  5.  *
  6.  * Returns a ptr to the cache on success, NULL on failure.
  7.  * Cannot be called within a int, but can be interrupted.
  8.  * The @ctor is run when new pages are allocated by the cache.
  9.  *
  10.  * The flags are
  11.  *
  12.  * %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
  13.  * to catch references to uninitialised memory.
  14.  *
  15.  * %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check
  16.  * for buffer overruns.
  17.  *
  18.  * %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
  19.  * cacheline. This can be beneficial if you're counting cycles as closely
  20.  * as davem.
  21.  */
  22. int
  23. __kmem_cache_create (struct kmem_cache *cachep, unsigned long flags)
  24. {
  25.     size_t left_over, slab_size, ralign;
  26.     gfp_t gfp;
  27.     int err;
  28.     size_t size = cachep->size;

  30. #if DEBUG
  31. #if FORCED_DEBUG
  32.     /*
  33.      * Enable redzoning and last user accounting, except for caches with
  34.      * large objects, if the increased size would increase the object size
  35.      * above the next power of two: caches with object sizes just above a
  36.      * power of two have a significant amount of internal fragmentation.
  37.      */
  38.     if (size 4096 || fls(size - 1) == fls(size-1 + REDZONE_ALIGN +
  39.                         2 * sizeof(unsigned long long)))
  40.         flags |= SLAB_RED_ZONE | SLAB_STORE_USER;
  41.     if (!(flags & SLAB_DESTROY_BY_RCU))
  42.         flags |= SLAB_POISON;
  43. #endif
  44.     if (flags & SLAB_DESTROY_BY_RCU)
  45.         BUG_ON(flags & SLAB_POISON);
  46. #endif

  48.     /*
  49.      * Check that size is in terms of words. This is needed to avoid
  50.      * unaligned accesses for some archs when redzoning is used, and makes
  51.      * sure any on-slab bufctl's are also correctly aligned.
  52.      */
  53.     if (size & (BYTES_PER_WORD - 1)) {
  54.         size += (BYTES_PER_WORD - 1);
  55.         size &= ~(BYTES_PER_WORD - 1);
  56.     } //4//四字节对齐

  58.     /*
  59.      * Redzoning and user store require word alignment or possibly larger.
  60.      * Note this will be overridden by architecture or caller mandated
  61.      * alignment if either is greater than BYTES_PER_WORD.
  62.      */
  63.     if (flags & SLAB_STORE_USER)
  64.         ralign = BYTES_PER_WORD;

  66.     if (flags & SLAB_RED_ZONE) {
  67.         ralign = REDZONE_ALIGN;
  68.         /* If redzoning, ensure that the second redzone is suitably
  69.          * aligned, by adjusting the object size accordingly. */
  70.         size += REDZONE_ALIGN - 1;
  71.         size &= ~(REDZONE_ALIGN - 1);
  72.     }

  74.     /* 3) caller mandated alignment */
  75.     if (ralign cachep->align) {
  76.         ralign = cachep->align;
  77.     }
  78.     /* disable debug if necessary */
  79.     if (ralign > __alignof__(unsigned long long))
  80.         flags &= ~(SLAB_RED_ZONE | SLAB_STORE_USER);
  81.     /*
  82.      * 4) Store it.
  83.      */
  84.     cachep->align = ralign;

  86.     if (slab_is_available())     //  为什么要插入这一段注释，因为它就是判断slab_state的值，默认它的值没人初始化即为DOWN.

    点击(此处)折叠或打开

    1. /*
    2.  * State of the slab allocator.
    3.  *
    4.  * This is used to describe the states of the allocator during bootup.
    5.  * Allocators use this to gradually bootstrap themselves. Most allocators
    6.  * have the problem that the structures used for managing slab caches are
    7.  * allocated from slab caches themselves.
    8.  */
    9. enum slab_state {
    10.     DOWN,            /* No slab functionality yet */
    11.     PARTIAL,        /* SLUB: kmem_cache_node available */
    12.     PARTIAL_ARRAYCACHE,    /* SLAB: kmalloc size for arraycache available */
    13.     PARTIAL_L3,        /* SLAB: kmalloc size for l3 struct available */
    14.     UP,            /* Slab caches usable but not all extras yet */
    15.     FULL            /* Everything is working */
    16. };

  87.         gfp = GFP_KERNEL;
  88.     else
  89.         gfp = GFP_NOWAIT;
  90. //点击(此处)折叠或打开
    1. #define GFP_NOWAIT    (GFP_ATOMIC & ~__GFP_HIGH)


  92.     setup_nodelists_pointer(cachep);
  93. #if DEBUG

  95.     /*
  96.      * Both debugging options require word-alignment which is calculated
  97.      * into align above.
  98.      */
  99.     if (flags & SLAB_RED_ZONE) {
  100.         /* add space for red zone words */
  101.         cachep->obj_offset += sizeof(unsigned long long);
  102.         size += 2 * sizeof(unsigned long long);
  103.     }
  104.     if (flags & SLAB_STORE_USER) {
  105.         /* user store requires one word storage behind the end of
  106.          * the real object. But if the second red zone needs to be
  107.          * aligned to 64 bits, we must allow that much space.
  108.          */
  109.         if (flags & SLAB_RED_ZONE)
  110.             size += REDZONE_ALIGN;
  111.         else
  112.             size += BYTES_PER_WORD;
  113.     }
  114. #if FORCED_DEBUG && defined(CONFIG_DEBUG_PAGEALLOC)
  115.     if (size >= malloc_sizes[INDEX_L3 + 1].cs_size
  116.      && cachep->object_size > cache_line_size()
  117.      && ALIGN(size, cachep->align) PAGE_SIZE) {
  118.         cachep->obj_offset += PAGE_SIZE - ALIGN(size, cachep->align);
  119.         size = PAGE_SIZE;
  120.     }
  121. #endif
  122. #endif

  124.     /*
  125.      * Determine if the slab management is 'on' or 'off' slab.
  126.      * (bootstrapping cannot cope with offslab caches so don't do    //  判断slab管理信息是否在slab分配的内存页上，判断条件见下面：
  127.      * it too early on. Always use on-slab management when            //  size  >=  (默认page =4k/8k) 512/1024  ; slab_early_init在创建kmem_cache的时候为1；当创建通用cache
  128.      * SLAB_NOLEAKTRACE to avoid recursive calls into kmemleak)       //的时才会把它初始化为0 . 而第一传递的flags为 SLAB_HWCACHE_ALIGN
  129.      */
  130.     if ((size >= (PAGE_SIZE >> 3)) && !slab_early_init &&
  131.      !(flags & SLAB_NOLEAKTRACE))
  132.         /*
  133.          * Size is large, assume best to place the slab management obj
  134.          * off-slab (should allow better packing of objs).
  135.          */
  136.         flags |= CFLGS_OFF_SLAB;

  138.     size = ALIGN(size, cachep->align);

  140.     left_over = calculate_slab_order(cachep, size, cachep->align, flags); //  根据obj size 计算申请page的个数即一个slab包含多少个pages，
  141.     if (!cachep->num)                                                      //  也包含了多少个obj，除去管理信息等 剩余的空间。很简单易懂.
  142.         return -E2BIG;

  144.     slab_size = ALIGN(cachep->num * sizeof(kmem_bufctl_t)
  145.              + sizeof(struct slab), cachep->align);

  147.     /*
  148.      * If the slab has been placed off-slab, and we have enough space then
  149.      * move it on-slab. This is at the expense of any extra colouring.
  150.      */
  151.     if (flags & CFLGS_OFF_SLAB && left_over >= slab_size) {
  152.         flags &= ~CFLGS_OFF_SLAB;
  153.         left_over -= slab_size;
  154.     }

  156.     if (flags & CFLGS_OFF_SLAB) {
  157.         /* really off slab. No need for manual alignment */
  158.         slab_size =
  159.          cachep->num * sizeof(kmem_bufctl_t) + sizeof(struct slab);

  161. #ifdef CONFIG_PAGE_POISONING
  162.         /* If we're going to use the generic kernel_map_pages()
  163.          * poisoning, then it's going to smash the contents of
  164.          * the redzone and userword anyhow, so switch them off.
  165.          */
  166.         if (size % PAGE_SIZE == 0 && flags & SLAB_POISON)
  167.             flags &= ~(SLAB_RED_ZONE | SLAB_STORE_USER);
  168. #endif
  169.     }

  171.     cachep->colour_off = cache_line_size(); //32B
  172.     /* Offset must be a multiple of the alignment. */
  173.     if (cachep->colour_off cachep->align)
  174.         cachep->colour_off = cachep->align;
  175.     cachep->colour = left_over / cachep->colour_off;      // slab 着色的初始化工作.
  176.     cachep->slab_size = slab_size;
  177.     cachep->flags = flags;
  178.     cachep->allocflags = 0;
  179.     if (CONFIG_ZONE_DMA_FLAG && (flags & SLAB_CACHE_DMA))
  180.         cachep->allocflags |= GFP_DMA;
  181.     cachep->size = size;
  182.     cachep->reciprocal_buffer_size = reciprocal_value(size);

  184.     if (flags & CFLGS_OFF_SLAB) {
  185.         cachep->slabp_cache = kmem_find_general_cachep(slab_size, 0u);
  186.         /*
  187.          * This is a possibility for one of the malloc_sizes caches.
  188.          * But since we go off slab only for object size greater than
  189.          * PAGE_SIZE/8, and malloc_sizes gets created in ascending order,
  190.          * this should not happen at all.
  191.          * But leave a BUG_ON for some lucky dude.
  192.          */
  193.         BUG_ON(ZERO_OR_NULL_PTR(cachep->slabp_cache));
  194.     }

  196.     err = setup_cpu_cache(cachep, gfp);
  197.     if (err) {
  198.         __kmem_cache_shutdown(cachep);
  199.         return err;
  200.     }

  202.     if (flags & SLAB_DEBUG_OBJECTS) {
  203.         /*
  204.          * Would deadlock through slab_destroy()->call_rcu()->
  205.          * debug_object_activate()->kmem_cache_alloc().
  206.          */
  207.         WARN_ON_ONCE(flags & SLAB_DESTROY_BY_RCU);

  209.         slab_set_debugobj_lock_classes(cachep);
  210.     } else if (!OFF_SLAB(cachep) && !(flags & SLAB_DESTROY_BY_RCU))
  211.         on_slab_lock_classes(cachep);

  213.     return 0;
  214. }
它里面有个很有趣的函数很关键的一个函数：它泄露了slab具体管理obj的布局和方法.

点击(此处)折叠或打开

  1. /**
  2.  * calculate_slab_order - calculate size (page order) of slabs
  3.  * @cachep: pointer to the cache that is being created
  4.  * @size: size of objects to be created in this cache.
  5.  * @align: required alignment for the objects.
  6.  * @flags: slab allocation flags
  7.  *
  8.  * Also calculates the number of objects per slab.
  9.  *
  10.  * This could be made much more intelligent. For now, try to avoid using
  11.  * high order pages for slabs. When the gfp() functions are more friendly
  12.  * towards high-order requests, this should be changed.
  13.  */
  14. static size_t calculate_slab_order(struct kmem_cache *cachep,
  15.             size_t size, size_t align, unsigned long flags)
  16. {
  17.     unsigned long offslab_limit;
  18.     size_t left_over = 0;
  19.     int gfporder;

  21.     for (gfporder = 0; gfporder = KMALLOC_MAX_ORDER; gfporder++) {
  22.         unsigned int num;
  23.         size_t remainder;

  25.         cache_estimate(gfporder, size, align, flags, &remainder, &num); //  根据是off-slab 还是on-slab除去管理信息后多少个页面才能存下一个obj.以及其他信息，值得仔细看看.
  26.         if (!num)   // 必须保证slab至少能装下一个obj 
  27.             continue;

  29.         if (flags & CFLGS_OFF_SLAB) {
  30.             /*
  31.              * Max number of objs-per-slab for caches which
  32.              * use off-slab slabs. Needed to avoid a possible
  33.              * looping condition in cache_grow().
  34.              */
  35.             offslab_limit = size - sizeof(struct slab);
  36.             offslab_limit /= sizeof(kmem_bufctl_t);

  38.              if (num > offslab_limit)
  39.                 break;
  40.         }

  42.         /* Found something acceptable - save it away */
  43.         cachep->num = num;
  44.         cachep->gfporder = gfporder;
  45.         left_over = remainder;

  47.         /*
  48.          * A VFS-reclaimable slab tends to have most allocations
  49.          * as GFP_NOFS and we really don't want to have to be allocating
  50.          * higher-order pages when we are unable to shrink dcache.
  51.          */
  52.         if (flags & SLAB_RECLAIM_ACCOUNT)
  53.             break;

  55.         /*
  56.          * Large number of objects is good, but very large slabs are
  57.          * currently bad for the gfp()s.
  58.          */
  59.         if (gfporder >= slab_max_order)
  60.             break;

  62.         /*
  63.          * Acceptable internal fragmentation?
  64.          */
  65.         if (left_over * 8 = (PAGE_SIZE gfporder))
  66.             break;
  67.     }
  68.     return left_over;
  69. }
经过上面的初始化和设置，最后调用setup_cpu_cache就完成了一个创建cache的工作.接着进行第2、3步的工作：

点击(此处)折叠或打开

  1. /* 2+3) create the kmalloc caches */
  2.     sizes = malloc_sizes;
  3.     names = cache_names;

  5.     /*
  6.      * Initialize the caches that provide memory for the array cache and the
  7.      * kmem_list3 structures first. Without this, further allocations will
  8.      * bug.
  9.      */

  11.     sizes[INDEX_AC].cs_cachep = create_kmalloc_cache(names[INDEX_AC].name,   //  create obj size  为sizeof(struct arraycache_init) 的cache
  12.                     sizes[INDEX_AC].cs_size, ARCH_KMALLOC_FLAGS);

  14.     if (INDEX_AC != INDEX_L3)
  15.         sizes[INDEX_L3].cs_cachep =
  16.             create_kmalloc_cache(names[INDEX_L3].name,                         ////  create obj size  为sizeof(struct kmem_list3) 的cache
  17.                 sizes[INDEX_L3].cs_size, ARCH_KMALLOC_FLAGS);

  19.     slab_early_init = 0;

  21.     while (sizes->cs_size != ULONG_MAX) {         //创建通用cache 根据 malloc_sizes ，cache_names
  22.         /*
  23.          * For performance, all the general caches are L1 aligned.
  24.          * This should be particularly beneficial on SMP boxes, as it
  25.          * eliminates "false sharing".
  26.          * Note for systems short on memory removing the alignment will
  27.          * allow tighter packing of the smaller caches.
  28.          */
  29.         if (!sizes->cs_cachep)
  30.             sizes->cs_cachep = create_kmalloc_cache(names->name,
  31.                     sizes->cs_size, ARCH_KMALLOC_FLAGS);

  33. #ifdef CONFIG_ZONE_DMA
  34.         sizes->cs_dmacachep = create_kmalloc_cache(
  35.             names->name_dma, sizes->cs_size,
  36.             SLAB_CACHE_DMA|ARCH_KMALLOC_FLAGS);
  37. #endif
  38.         sizes++;
  39.         names++;
  40.     }
这里在说一下 cache_names和 malloc_sizes：

点击(此处)折叠或打开

  1. /*
  2.  * These are the default caches for kmalloc. Custom caches can have other sizes.
  3.  */
  4. struct cache_sizes malloc_sizes[] = {
  5. #define CACHE(x) { .cs_size = (x) },
  6. #include linux/kmalloc_sizes.h>
  7.     CACHE(ULONG_MAX)
  8. #undef CACHE
  9. };
这里就不扩展开了.

点击(此处)折叠或打开

  1. /* Must match cache_sizes above. Out of line to keep cache footprint low. */
  2. struct cache_names {
  3.     char *name;
  4.     char *name_dma;
  5. };

  7. static struct cache_names __initdata cache_names[] = {
  8. #define CACHE(x) { .name = "size-" #x, .name_dma = "size-" #x "(DMA)" },
  9. #include linux/kmalloc_sizes.h>
  10.     {NULL,}
  11. #undef CACHE
  12. };
create_kmalloc_cache实际上是调用create_boot_cache. 把kernel预定义的通用cache创建一遍.之后我们进入第四步、第5步：

点击(此处)折叠或打开

  1. /* 4) Replace the bootstrap head arrays */
  2.     {
  3.         struct array_cache *ptr;

  5.         ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);

  7.         memcpy(ptr, cpu_cache_get(kmem_cache),
  8.          sizeof(struct arraycache_init));
  9.         /*
  10.          * Do not assume that spinlocks can be initialized via memcpy:
  11.          */
  12.         spin_lock_init(&ptr->lock);

  14.         kmem_cache->array[smp_processor_id()] = ptr;

  16.         ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);

  18.         BUG_ON(cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep)
  19.          != &initarray_generic.cache);
  20.         memcpy(ptr, cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep),
  21.          sizeof(struct arraycache_init));
  22.         /*
  23.          * Do not assume that spinlocks can be initialized via memcpy:
  24.          */
  25.         spin_lock_init(&ptr->lock);

  27.         malloc_sizes[INDEX_AC].cs_cachep->array[smp_processor_id()] =
  28.          ptr;
  29.     }

点击(此处)折叠或打开

  1. /* 5) Replace the bootstrap kmem_list3's */
  2.     {
  3.         int nid;

  5.         for_each_online_node(nid) {
  6.             init_list(kmem_cache, &initkmem_list3[CACHE_CACHE + nid], nid);

  8.             init_list(malloc_sizes[INDEX_AC].cs_cachep,
  9.                  &initkmem_list3[SIZE_AC + nid], nid);

  11.             if (INDEX_AC != INDEX_L3) {
  12.                 init_list(malloc_sizes[INDEX_L3].cs_cachep,
  13.                      &initkmem_list3[SIZE_L3 + nid], nid);
  14.             }
  15.         }
  16.     }

  18.     slab_state = UP;
最后把slab_state状态设置为up 即已经可以正常使用了。虽然上面大部分是代码，具体申请内存的流程前面kmalloc已经讲过了。仅仅是为了弄明白cache到底是个什么玩意，以及如何初始化的。
在kmem_cache_init后，还有一个kmem_cache_init_late函数.
它主要是调用了enable_cpucache和注册一个cpu通知连

点击(此处)折叠或打开

  1. /*
  2.      * Register a cpu startup notifier callback that initializes
  3.      * cpu_cache_get for all new cpus
  4.      */
  5.     register_cpu_notifier(&cpucache_notifier);
还记不记得之前我们分析batchcount的时候的矛盾点？ 

点击(此处)折叠或打开

  1. /* Called with slab_mutex held always */
  2. static int enable_cpucache(struct kmem_cache *cachep, gfp_t gfp)
  3. {
  4.     int err;
  5.     int limit = 0;
  6.     int shared = 0;
  7.     int batchcount = 0;

  9.     if (!is_root_cache(cachep)) {
  10.         struct kmem_cache *root = memcg_root_cache(cachep);
  11.         limit = root->limit;
  12.         shared = root->shared;
  13.         batchcount = root->batchcount;
  14.     }

  16.     if (limit && shared && batchcount)
  17.         goto skip_setup;
  18.     /*
  19.      * The head array serves three purposes:
  20.      * - create a LIFO ordering, i.e. return objects that are cache-warm
  21.      * - reduce the number of spinlock operations.
  22.      * - reduce the number of linked list operations on the slab and
  23.      * bufctl chains: array operations are cheaper.
  24.      * The numbers are guessed, we should auto-tune as described by
  25.      * Bonwick.
  26.      */
  27.     if (cachep->size > 131072)
  28.         limit = 1;
  29.     else if (cachep->size > PAGE_SIZE)
  30.         limit = 8;
  31.     else if (cachep->size > 1024)
  32.         limit = 24;
  33.     else if (cachep->size > 256)
  34.         limit = 54;
  35.     else
  36.         limit = 120;

  38.     /*
  39.      * CPU bound tasks (e.g. network routing) can exhibit cpu bound
  40.      * allocation behaviour: Most allocs on one cpu, most free operations
  41.      * on another cpu. For these cases, an efficient object passing between
  42.      * cpus is necessary. This is provided by a shared array. The array
  43.      * replaces Bonwick's magazine layer.
  44.      * On uniprocessor, it's functionally equivalent (but less efficient)
  45.      * to a larger limit. Thus disabled by default.
  46.      */
  47.     shared = 0;
  48.     if (cachep->size = PAGE_SIZE && num_possible_cpus() > 1)
  49.         shared = 8;

  51. #if DEBUG
  52.     /*
  53.      * With debugging enabled, large batchcount lead to excessively long
  54.      * periods with disabled local interrupts. Limit the batchcount
  55.      */
  56.     if (limit > 32)
  57.         limit = 32;
  58. #endif
  59.     batchcount = (limit + 1) / 2;
  60. skip_setup:
  61.     err = do_tune_cpucache(cachep, limit, batchcount, shared, gfp);
  62.     if (err)
  63.         printk(KERN_ERR "enable_cpucache failed for %s, error %d.\n",
  64.          cachep->name, -err);
  65.     return err;
  66. }
它会根据obj size 计算limit值 ，再去计算batchcount的值.

这个只是一个小小的开始吧，内存管理本来就博大精深，只有遇到具体问题具体分析，来加深理解了.























文章标签：
Linux
前端开发
关键词：
Linux内存
Linux内存管理
云之大者
目录
相关文章
小王老师呀
|
2月前
|
安全 Linux Shell
Linux上执行内存中的脚本和程序
【9月更文挑战第3天】在 Linux 系统中，可以通过多种方式执行内存中的脚本和程序：一是使用 `eval` 命令直接执行内存中的脚本内容；二是利用管道将脚本内容传递给 `bash` 解释器执行；三是将编译好的程序复制到 `/dev/shm` 并执行。这些方法虽便捷，但也需谨慎操作以避免安全风险。
小王老师呀
179 6
叫个什么名字
|
12天前
|
算法 Linux 开发者
深入探究Linux内核中的内存管理机制
本文旨在对Linux操作系统的内存管理机制进行深入分析，探讨其如何通过高效的内存分配和回收策略来优化系统性能。文章将详细介绍Linux内核中内存管理的关键技术点，包括物理内存与虚拟内存的映射、页面置换算法、以及内存碎片的处理方法等。通过对这些技术点的解析，本文旨在为读者提供一个清晰的Linux内存管理框架，帮助理解其在现代计算环境中的重要性和应用。
叫个什么名字
42 6
最好zzz
|
18天前
|
存储 缓存 监控
揭秘Linux内存缓存：性能优化的核心要素
【10月更文挑战第26天】
最好zzz
29 1
听风de歌
|
1月前
|
存储 缓存 监控
Linux中内存和性能问题
【10月更文挑战第5天】
听风de歌
38 4
听风de歌
|
1月前
|
算法 Linux
Linux中内存问题
【10月更文挑战第6天】
听风de歌
41 2
丰宝宝
|
15天前
|
缓存 算法 Linux
Linux内核中的内存管理机制深度剖析####
【10月更文挑战第28天】 本文深入探讨了Linux操作系统的心脏——内核，聚焦其内存管理机制的奥秘。不同于传统摘要的概述方式，本文将以一次虚拟的内存分配请求为引子，逐步揭开Linux如何高效、安全地管理着从微小嵌入式设备到庞大数据中心数以千计程序的内存需求。通过这段旅程，读者将直观感受到Linux内存管理的精妙设计与强大能力，以及它是如何在复杂多变的环境中保持系统稳定与性能优化的。 ####
丰宝宝
24 0
wljslmz
|
1月前
|
存储 缓存 固态存储
如何在 Linux 中清除缓冲区和缓存内存？
【10月更文挑战第7天】
wljslmz
67 0
如何在 Linux 中清除缓冲区和缓存内存？
石小浪♪
|
1月前
|
Linux C++
Linux c/c++文件虚拟内存映射
这篇文章介绍了在Linux环境下，如何使用虚拟内存映射技术来提高文件读写的速度，并通过C/C++代码示例展示了文件映射的整个流程。
石小浪♪
46 0
Liuqz2009
|
3月前
|
Linux 调度
深入理解Linux虚拟内存管理（七）（下）
深入理解Linux虚拟内存管理（七）
Liuqz2009
70 4
Liuqz2009
|
3月前
|
存储 Linux 索引
深入理解Linux虚拟内存管理（九）（中）
深入理解Linux虚拟内存管理（九）
Liuqz2009
38 2

热门文章

最新文章

  • 1
    Linux 内存管理新特性：Memory folios 解读
  • 2
    Linux下启动Nginx时报错：nginx: [emerg] bind() to 0.0.0.0:80 failed (98: Address already in use)
  • 3
    linux下面禁止别人PING
  • 4
    linux命令之tcpdump
  • 5
    Linux操作系统上的mysql安装
  • 6
    Linux多线程5-5_线程与fork
  • 7
    Linux使用Aria2命令下载BT种子/磁力/直链文件
  • 8
    linux命令之userdel
  • 9
    微软Win 10年度升级将加入Linux命令行
  • 10
    Linux (x86) Exploit 开发系列教程之十一 Off-By-One 漏洞（基于堆）
  • 1
    LINUX——动/静态库
    43
  • 2
    LINUX--基础IOLINUX--基础IO
    37
  • 3
    YUM管理器的命令列表-Linux
    45
  • 4
    Linux系统之部署Homepage个人导航页
    233
  • 5
    FreeLearning Kali Linux 译文集翻译完成
    50
  • 6
    linux/服务器使用scp将一个服务器文件转移到另一个服务器上
    1541
  • 7
    linux ls -la文件信息含义
    53
  • 8
    Linux（阿里云）安装Hadoop(详细教程+避坑)
    1489
  • 9
    Linux系统之安装uptime-kuma服务器监控面板
    237
  • 10
    Linux｜如何允许 awk 使用 Shell 变量
    85

    • 相关课程

    更多
  • Linux高级网络应用 - 网络管理与配置实战
  • Linux MySQL服务器搭建与应用
  • Linux基本命令
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序
  • 手动部署MySQL数据库（Alibaba Cloud Linux 2）
  • 部署并使用Docker（Alibaba Cloud Linux 3）
  • 部署Linux主机管理系统WDCP

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    阿里云OSS设置跨域访问