Chinaunix首页 | 论坛 | 博客

Star-Nightghost4embedded.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

ap0405209

  • 博客访问： 1744880
  • 博文数量： 1493
  • 博客积分： 38
  • 博客等级： 民兵
  • 技术积分： 5834
  • 用 户 组： 普通用户
  • 注册时间： 2009-08-19 17:28
文章分类

全部博文（1493）

文章存档

2016年（11）

2015年（38）

2014年（137）

2013年（253）

2012年（1054）

2011年（1）

我的朋友
最近访客
推荐博文
相关博文
linux内存管理之kmem_cache_init

分类： LINUX

2015-02-12 12:02:25

原文地址：linux内存管理之kmem_cache_init 作者：linuxDOS

   之前多多少少接触过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的值.

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























阅读(748) | 评论(0) | 转发(0) |
0

上一篇：嵌入式Linux 挂载完根文件系统后，自动执行的文件分析

下一篇：Ｃ语言中关于时间的函数

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6