kmem_cache_init初始化slab分配器 - linux内存管理（八）

看了下kmem_cache_init，涉及到不同MIGRATE间的buddy system的迁移，kmem_cache的构建，slab分配器头的构建、buddy system的伙伴拆分。

对于SMP系统，每个kmem_cache还有各个CPU的arraycache_init，这样每个CPU可以从各自的arraycache_init中获取缓存，如果不足，则从slab分配器中获得；当让slab分配器的三条链表也有一定的缓存作用，如果三条链表都已空了，则需要从buddy system中申请页。在申请页的时候，由于每个zone中都有各个CPU的缓存页per_cpu_pages链表，因此在申请页时既可从per_cpu_pages中申请，也可直接从buddy system中申请。当从buddy system中申请时，先从相同的MIGRATE链表的不同order的链表中迁移页，如果相同的MIGRATE链表不满足，则将根据fallbacks数组中指示的各个MIGRATE的后备MIGRATE类型链表来迁移页，由于可能从大的order中迁移出页链表，就需要考虑buddy的拆分……

这个函数跟踪了好几天，上述总结及下面的记录可能有误，望指正。

声明：下面的记录以初始化过程为重点，当内核正常执行时，某些函数内的执行路径可能有一定的偏差.

start_kernel()
    |---->page_address_init()
    | 
    |---->setup_arch(&command_line);
    |
    |---->setup_per_cpu_areas();
    |
    |---->build_all_zonelist()
    |
    |---->page_alloc_init()
    |
    |---->pidhash_init()
    |
    |---->vfs_caches_init_early()
    |
    |---->mm_init()

void mm_init(void)
  |-->mem_init()
  |     业务：bootmem迁移至伙伴系统
  |
  |-->kmem_cache_init()
  |     以slab分配器为参考
  |   (1)构建好了kmem_cache实例cache_cache(静态分配)，且构建好了kmem_cache的slab
  |   分配器,并由initkmem_list3[0]组织, 相应的array为initarray_cache；
  |   (2)构建好了kmem_cache实例（管理arraycache_init），且构建好了
  |   arraycache_init的slab分配器,并由initkmem_list3[1]组织,相应的array为
  |   initarray_generic；
  |   (3)构建好了kmem_cache实例（管理kmem_list3）,此时还未构建好kmem_list3的slab
  |   分配器，但是一旦申请sizeof(kmem_list3)空间，将构建kmem_list3分配器,并由
  |   initkmem_list[2]组织,其array将通过kmalloc进行申请；
  |   (4)为malloc_sizes的相应数组元素构建kmem_cache实例，并分配kmem_list3,用于组织
  |   slab链表，分配arraycache_init用于组织每CPU的同一个kmem_cache下的slab分配;
  |   (5)替换kmem_cache、malloc_sizes[INDEX_AC].cs_cachep下的arraycache_init
  |   实例；
  |   (6)替换kmem_cache、malloc_sizes[INDEX_AC].cs_cachep、
  |   malloc_sizes[INDEX_L3].cs_cachep下的kmem_list3实例;
  |   (7)g_cpucachep_up = EARLY;
  |
  |-->

void kmem_cache_init(void)
  |-->use_alien_caches = 0;
  |   UMA体系
  |
  |-->for(i = 0; i < 3; i++)
  |--{
  |    kmem_list3_init(&initkmem_list3[i]);
  |    初始化initkmem_list3三链.
  |    if (i < 1)  cache_cache.nodelists[i] = NULL;
  |--}
  |
  |-->set_up_list3s(&cache_cache， CACHE_CACHE);
  |   对于UMA：
  |   即,cache_cache.nodelists[0] = &initkmem_list3[0];
  |      cache_cache.nodelists[0]->next_reap = jiffies
  |                  + REAPTIMEOUT_LIST3 
  |                  + ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
  |
  |--内存 > 32M ==> slab_break_gfp_order = BREAK_GFP_ORDER_HI;
  |
  |-->INIT_LIST_HEAD(&cache_chain);
  |
  |-->list_add(&cache_cache.next, &cache_chain);
  |   将cache_cache挂入cache_chain链表
  |
  |-->cache_cache.colour_off = L1_CACHE_BYTES;
  |   关于cache line 和 cache block可能大多数人不会做区分，
  |   可以查阅CSAPP 2ed p_631.
  |   
  |-->cache_cache.array[smp_processor_id()] = &initarray_cache.cache;
  |
  |-->cache_cache.nodelists[0] = &initkmem_list3[0];
  |
  |-->cache_cache.buffer_size = offset(struct kmem_cache, nodelists)
  |                        + nr_node_ids * sizeof(struct kmem_list3 *);
  |   cache_cache.buffer_size存储一个kmem_cache实体需要的空间大小.
  |
  |-->cache_cache.buffer_size = ALIGN(cache_cache.buffer_size,
  |                              cache_line_size());
  |   提高缓存利用率，将buff_size对于到cache_line_size.
  |
  |-->cache_cache.reciprocal_buffer_size = 
  |               reciprocal_value(cache_cache.buffer_size);
  |   获取cache_cache.buffer_size的倒数值，原理：
  |   （ 1/X = （2 **32 / X ） >> 32 ）
  |
  |-->for (order = 0; order < MAX_ORDER; order++)
  |--{
  |      cache_estimate(order, cache_cache.buffer_size,
  |       cache_line_size(); 0, &left_over, &cache_cache.num);
  |
  |      if(cache_cache.num) break;
  |--}
  |   因为cache_cache所占空间在2 ** 0 个页中已可存下，因此，
  |   &cache_cache.num存放在一个页中除去slab结构体可以存放下
  |   占空间（bufer_size + sizeof(kmem_bufctl_t))的实例的数量，
  |   left_over存放在一页中剩余的空间.
  |
  |--cache_cache.gfporder = order;
  |--cache_cache.colour = left_over / cache_cache.colour_off;
  |--cache_cache.slab_size = ALIGN(cache_cache.num 
  |                        * sizeof(kmem_bufctl_t) 
  |                        + sizeof(struct slab), cache_line_size());
  |
  |
  |-->struct cache_sizes *sizes = malloc_sizes; 
  |-->struct cache_names *names = caches_names;
  |   通过kmalloc分配的空间有绝大部分都会通过slab进行分配，因此先构造
  |   kmalloc分配空间的缓存.
  |
  |
  |  INDEX_AC就是与sizeof(struct arraycache_init :28==>0)适配的kmalloc可分配
  |  缓存的索引.
  |  INDEX_L3就是与sizeof(struct kmem_list3 :56==>1)适配的kmalloc可分配缓存的
  |  索引.
  |  为arraycache_init构造kmem_cache实例.
  |-->sizes[INDEX_AC].cs_cachep = 
  |      kmem_cache_create(names[INDEX_AC].name, sizes[INDEX_AC].cs_size,
  |                        ARCH_KMALLOC_MINALIGN,
  |                        ARCH_KMALLOC_FLAGS | SLAB_PANIC,
  |                        NULL);
  |     第一次调用kmem_cache_create，填充了initkmem_list3[0],该类链表上挂载了
  |     kmem_cache类型的slab分配器.
  |     第一次调用setup_cpu_cache，initkmem_list3[1]将被分配给与arraycache_init
  |     匹配的kmem_cache，但是由于arraycache_init的slab分配器还未构建好，因此，
  |     在第一次申请sizeof(arraycache_init)空间时，会把arraycache_init的slab
  |     分配器挂入initkmem_list3[1]类的链表下.
  |
  |-->if(INDEX_AC != INDEX_L3)
  |--{
  |   为kmem_list3构造kmem_cache实例
  |
  |   sizes[INDEX_L3].cs_cachep =
  |      kmem_cache_create(names[INDEX_L3].name, sizes[INDEX_L3].cs_size,
  |                        ARCH_KMALLOC_MINALIGN,
  |                        ARCH_KMALLOC_FLAGS|SLAB_PAINIC,
  |                        NULL);
  |     第二次调用kmem_cache_create，填充了initkmem_list3[1],该类链表上挂载了
  |     arraycache_init类型的slab分配器.
  |
  |     这已是第二次调用kmem_cache_create.
  |     在第二次调用时，arraycache_init的kmem_cache已初始化，但是arraycache_init
  |     的slab分配器还未构建好（相当于都为空）,而setup_cpu_cache中将开始通过
  |     kmalloc申请sizeof(arraycache_init)空间，此时将同于kmem_cache分配器初始化
  |     过程一样，填充arraycache_init分配器.
  |     主要区被在于kmem_cache_create最后调用的 setup_cpu_cache，
  |     setup_cpu_cache中将设置g_cpucache_up，以标志初始化的不同阶段.
  |--}
  |
  |--slab_early_init = 0;
  |   (1)构建好了kmem_cache实例cache_cache，且构建好了kmem_cache的slab分配器,
  |   并由initkmem_list3[0]组织, 相应的array为initarray_cache.
  |   (2)构建好了kmem_cache实例（管理arraycache_init），且构建好了
  |   arraycache_init的slab分配器,并由initkmem_list3[1]组织,相应的array为
  |   initarray_generic.
  |   (3)构建好了kmem_cache实例（管理kmem_list3）,此时还未构建好kmem_list3的slab
  |   分配器，但是一旦申请sizeof(kmem_list3)空间，将构建kmem_list3分配器,并由
  |   initkmem_list[2]组织,其array将通过kmalloc进行申请.
  |
  |
  |  开始为malloc_sizes中的其它空间大小够将kmem_cache实例.如下将是
  |  第[3..00)次调用seup_cpu_cache，因为arraycache_init和kmem_list3
  |  的kmem_cache已构造完成，因此将会通过kmalloc进行申请，而不会再使用静
  |  态的initarray_cache、initarray_generic、initkmem_list3等数据.
  |--while(sizes->cs_size != ULONG_MAX)
  |--{
  |    if(!sizes->cs_cachep)
  |    {
  |       sizes->cs_cachep = kmem_cache_create(names->name,
  |            sizes->cs_size,
  |            ARCH_KMALLOC_MINALIGN,
  |            ARCH_KMALLOC_FLAGS|SLAB_PANIC,
  |            NULL);
  |    }
  |    sizes++;
  |    names++;
  |--}
  |
  |
  |  我们知道initarray_cache和initarray_generic最终都会被释放掉，
  |  而相应于arraycache_init的slab分配器已可分配空间，因此，将拷贝
  |  initarray_cache.cache和initarray_generic.cache.
  |--struct array_cache *ptr;
  |  ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);
  |  memcpy(ptr, cpu_cache_get(&cache_cache),
  |         sizeof(struct arraycache_init));
  |  此处需要留意下，array_cache空间为20,arraycache_init空间为24,
  |  虽然不会造成错误，但是感觉不好.
  |  cache_cache.array[smp_processor_id()] = ptr;
  |
  |  ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);
  |  memcpy(ptr, cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep),
  |         sizeof(struct arraycache_init));
  |  malloc_sizes[INDEX_AC].cs_cachep->array[smp_processor_id()] = ptr;
  |
  |
  |  同initarray_ache和initarray_generic, initkmem_list3[3]最终都会被释放掉，
  |  此时相应于kmem_list3的slab分配器已可分配，因此,将拷贝initkmem_list3[0..2].
  |--init_list(&cache_cache, &initkmem_list3[0], 0);
  |  init_list(malloc_sizes[INDEX_AC].cs_cachep, 
  |            &initkmem_list3[SIZE_AC], 0);
  |  init_list(malloc_sizes[INDEX_L3].cs_cachep,
  |            &initkmem_list3[SIZE_L3], 0);
  |
  |--g_cpucache_up = EARLY.

void kmem_list3_init(struct kmem_list3 *parent)
  |-->INIT_LIST_HEAD(&parent->slabs_full);
  |   INIT_LIST_HEAD(&parent->slabs_partial);
  |   INIT_LIST_HEAD(&parent->slbas_free);
  |
  |-->parent->shared = NULL;
  |-->parent->alien = NULL;
  |-->parent->colour_next = 0;
  |-->spin_lock_init(&parent->list_lock);
  |-->parent->free_objects = 0;
  |-->parent->free_touched = 0;

void setup_list3s(struct kmem_cache *cachep, int index)
  |-->int node;
  |
  |-->for_each_online_node(node)
  |--{
  |     对于UMA，只有一个node；
  |   
  |     cachep->nodelists[node] = &initkmem_list3[index + node];
  |     cachep->nodelists[node]->next_reap = jiffies
  |                 + REAPTIMEOUT_LIST3
  |                 + ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
  |--}
  |  对于如上的for循环，若是NUMA体系，是在干嘛呢？

我们先关注下内核初始化时的情形
struct kmem_cache *kmem_cache_create (const char *name,
    size_t size, size_t align, unsigned long flags, void (*ctor)(void*))
  |-->struct kmem_cache *cachep = NULL;
  |   gfp = GFP_NOWAIT;
  |   cachep = kmem_cache_zalloc(&cache_cache, GFP_NOWAIT);
  |            |-->kmem_cache_alloc(&cache_cache, GFP_NOWAIT 
  |            |                              | __GFP_ZERO)；
  |                |-->void *ret = NULL;
  |                |   ret = __cache_alloc(&cache_cache, GFP_NOWAIT 
  |                |                              | __GFP_ZERO,
  |                |         __builtin_return_address(0));
  |                |   return ret;
  |
  |   业务：从cache_cache中分配出一个kmem_cache实例.
  |        我们需要注意，系统初始化时，cache_cache自身还未分配好
  |        （前边已设置了cache_cache的参数）.初始化的过程很重要.!!!!!!
  |
  |-->size = ALIGN(size, align);
  |
  |-->left_over = calculate_slab_order(cachep, size, align, flags);
  |               构建kmem_cache;
  |
  |-->slab_size = ALIGN(cachep->num * sizeof(kmem_bufctl_t) 
  |                     + sizeof(struct slab), align);
  |
  |-->cachep->colour_off = cache_line_size();
  |   cachep->colour = leftover / cachep->colour_off;
  |   cachep->slab_size = slab_size;
  |   cachep->flags = flags;
  |   cachep->gfpflags = 0;
  |   cachep->buffer_size = size;
  |   cachep->reciprocal_buffer_size = reciprocal_value(size);
  |   cachep->ctor = ctor;
  |   cachep->name = name;
  |
  |-->if(setup_cpu_cache(cachep, gfp))
  |--{ xxxxx }
  |
  |--list_add(&cachep->next, &cache_chain);
  |  将新建的kmem_cache实例挂入cache_chain链表中.
  |--return cachep;

void *__cache_alloc(struct kmem_cache *cachep, gfp_t flags, void *caller)
  |-->flags &= gfp_allowed_mask;
  |   初始化时，gfp_allowed_mask = GFP_BOOT_MASK;
  |
  |-->void *objp = NULL; 
  |   objp = __do_cache_alloc(cachep, flags); 
  |          |--> ____cache_alloc(cachep, flags); 
  |   获取cachep->buffer_size大小空间的起始地址. 
  |
  |-->if((flags & __GFP_ZERO) && objp)
  |      memset(objp, 0, obj_size(cachep));
  |
  |--return objp;

只看初始化
void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
  |-->void *objp = NULL;
  |   struct array_cache *ac = cpu_cache_get(cachep);
  |
  |--if(ac->avail)
  |--{
  |    ac->touched = 1;
  |    objp = ac->entry[--ac->avail];
  |
  |    array_cache->entry存放的是每CPU的某空间大小的缓存.
  |    array_cache->avail指示有多少个缓存实例.
  |    系统初始化，与某kmem_cache相应的array_cache还未建立，
  |    因此将执行else分支.
  |--}
  |--else
  |--{
  |     objp = cache_alloc_refill(cachep, flags);
  |     填充每CPU的array_cache，并获得相应类型的kmem_cache实例空间起始地址.
  |--}
  |
  |--return objp;

关注初始化过程，与书写的程序执行顺序有偏差
void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)
  |
  |   因为系统初始化时，不存在kmem_cache分配器cache_cache，即
  |   kmem_list3实例的三条链表都是空的（不可再分配出空间）,因此 
  |   需要扩展cache_cache.故将先执行标号must_grow处代码.
  |   此时cache_cache的缓存array_cache实例initarray_cache也为空，
  |   所以cache_cache的缓存也需要分配. 
  |   因此先看下列代码：
  |-->struct array_cache *ac = cpu_cache_get(cachep);
  |   if(!ac->avail)
  |      cache_grow(cachep, flags | GFP_THISNODE, node, NULL);
  |   cache_grow将分配新的slab，并加入slabs_free链表.
  |
  |   我们可以看出，kmem_cache的实例有部分缓存在了array_cache中，
  |   entry即为缓存起始地址，avail指示有几个缓存实例. 
  |
  |
  |
  |  分配好kmem_cache的实例cache_cache后，将会跳转到程序入口处的
  |  retry标号开始执行. 
  |-->struct array_cache *ac = cpu_cache_get(cachep);
  |   int batchcount = ac->batchcount;
  |   struct kmem_list3 *l3 = cachep->nodelist3[node];   
  |
  |--while(batchcount > 0)
  |--{
  |    struct list_head *entry; 
  |    entry是slabs_partial（半满），或者是slabs_free.
  |  
  |    struct slab *slabp = list_entry(entry, struct slab, list);
  |
  |    while(slabp->inuse < cachep->num && batchcount--)
  |    {  
  |       ac->entry[ac->avail++] = slab_get_obj(cachep, slabp, node);
  |
  |       array_cache->entry存放的是每CPU的某空间大小的缓存. 
  |    }
  |
  |    list_del(&slabp->list);
  |    if(slabp->free == BUFCTL_END)
  |       list_add(&slapb->list, &l3->slabs_full);
  |    else
  |       list_add(&slapb->list, &l3->slabs_partial);
  |    迁移链表.
  |--}
  |
  |--l3->free_objects -= ac->avail;
  |
  |--ac->touched = 1;
  |
  |--return ac->entry[--ac->avail];

int cache_grow(strut kmem_cache *cachep, gfp_t flags, int nodeid, 
               void *objp)
  |-->struct kmem_list3 *l3 = cachep->nodelists[nodeid];
  |
  |-->offset = l3->colour_next;
  |   l3->colour_next++;
  |   if (l3->colour_next >= cachep->colour)
  |      l3->colour_next = 0;
  |   offset *= cachep->colour_off;
  |   不明白offset调整的原理，为什么可以减少conflict cache呢？？
  |
  |-->gfp_t local_flags = flags & (GFP_CONSTRAINT_MASK 
  |                                | GFP_RECLAIM_MASK);
  |   objp = kmem_getpages(cachep, local_flags, nodeid);
  |   根据flags 和 cachep->gfpflags 申请 2 ** cachep->gfporder个页，
  |   并获得页起始的虚拟地址.
  |
  |-->struct slab *slabp = NULL;
  |   slabp = alloc_slabmgmt(cachep, objp, offset, 
  |                 local_flags & ~GFP_CONSTRAINT_MASK, nodeid);
  |   根据cachep信息和offset构建slab描述符，并获取slab描述符的地址.
  |  （需考虑着色. 但是对于着色的原理、性能提升我并不清楚?????）
  |
  |-->slab_map_pages(cachep, slabp, objp);
  |   复用page->lru上的两个指针，使其分别指向cachep和slap
  |
  |-->cache_init_objs(cachep, slabp);
  |   初始化slab描述符后的kmem_bufctl_t数组.
  |
  |-->list_add_tail(&slabp->list, &(l3->slabs_free));
  |   将新分配的slab加入kmem_list3(initkmem_list3[0])中的slabs_free链表
  |   l3->free_objects += cachep->num;
  |
  |-->return 1;

void *kmem_getpages(struct kmem_cache *cachep, gfp_t flags, int nodeid)
  |-->struct page *page = NULL;
  |   page = alloc_pages_exact_node(nodeid, 
  |          flags | cachep->gfpflags| __GFP_NOTRACK, cachep->gfporder)
  |          |--> __alloc_pages(flags, cachep->gfporder, 
  |          |                  node_zonelist(nodeid, flags));
  |   对于UMA,node_zonelist只有一个contig_page_data.node_zonelists
  |   根据(flags | __GFP_NOTRACK), 从相应类型的MIGRATE链表中获取2**order个页，
  |   可以从per_cpu_pages->lists中获取，也可从伙伴系中获取.
  |
  |   关于__alloc_pages函数，我已不想在跟下去了，分配一个页；
  |   上次和同学讨论下bootmem将页释放给buddy system时都是存放在MIGRATE_MOVABLE链表
  |   下，其它类型的链表都是空.
  |   因为此处是第一次向buddy system提出页申请，因此很有必要看一下如何从其它链表上
  |   分配空间.
  |
  |
  |-->nr_pages = (1 << cachep->gfporder);
  |
  |--if(cachep->flags & SLAB_RECLAIM_ACCOUNT)
  |   add_zone_page_state(page_zone(page), NR_SLAB_RECLAIMABLE,
  |                       nr_pages);
  |--else
  |   add_zone_page_state(page_zone(page), NR_SLAB_UNRECLAIMABLE,
  |                        nr_pages);
  |   在zone->vmstat中统计 可回收/不可回收 的页面数.
  |
  |
  |--for(i = 0; i < nr_pages; i++)
  |     __SetPageSlab(page + i);
  |   设置page->flags： PG_Slab
  |
  |-->return page_address(page);
  |   返回struct page对应的虚拟地址.（低端内存部分存在固定偏移，
  |   高端内存需再做页表映射,在初始化阶段，一定是低端内存)
  |   

struct page *__alloc_pages(gfp_t gfp_mask, unsigned int order,
        struct zonelist *zonelist)
  |-->return
  |   __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
  |   根据gfp_mask从相应类型的MIGRATE链表中获取2**order个页，
  |   可以从per_cpu_pages->lists中获取，也可从伙伴系中获取. 

strut page *__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order)
  |-->enum zone_type high_zoneidx = gfp_zone(gfp_mask);
  |   因为高端内存管理还未初始化，此处只会得到低端内存区标志（不考虑DMA）
  |
  |-->int migratetype = allocflags_to_migratetype(gfp_mask);
  |   获取应从哪个链表获取页分配.
  |   按照以上的执行流程，migratetype为MIGRATE_UNMOVABLE(此时，该链表仍为
  |   空，下面会做链表迁移，可以看下fallbacks数组)
  |
  |-->first_zones_zonelist(zonelist, high_zoneidx, nodemask,
  |                        &preferred_zone);
  |   业务：high_zoneidx基本同于for_each_zone_zonelist中的offset作用，
  |        获取pglist_data.node_zonelist3[0..3]小于等于high_zoneidx
  |        的最大zone_idx所对应的zone,并存于preferred_zone中.
  |
  |-->page = get_page_from_freelist(gfp_mask | __GFP_HARDWALL, nodemask,
  |          order,zonelist, high_zoneidx, ALLOC_WMARK_LOW|ALLOC_CPUSET,
  |          preferred_zone, migratetype);
  |   获取2**order个页     
  |
  |-->return page;

struct page *get_page_from_freelist(gfp_t gfp_mask, nodemaks_t *nodemask,
        unsigned int order, struct zonelist *zonelist, int high_zoneidx,
        int alloc_flags, struct zone *preferred_zone, int migratetype)
  |--对该函数的分析，我们简化下：
  |  1、初始化阶段，高端内存管理区还未初始化
  |  2、watermark还未初始化
  |
  |  因此：
  |-->struct page *page = NULL;
  |   page = buffered_rmqueue(preferred_zone, zone, order, gfp_mask,
  |                           migratetype);
  |   order == 0 ==>从per_cpu_pages->lists数组相应类型的链表中获取1页；
  |   order != 0 ==> 从buddy system中直接获取页.
  |
  |-->return page;

struct buffered_rmqueue(struct zone *preferred_zone, struct zone *zone,
        int order, gfp_t gfp_flags, int migratetype)
  |--struct page *page = NULL;
  |  int cold = !!(gfp_flags & __GFP_COLD);
  |
  |--if(order == 0)
  |--{
  |    struct per_cpu_pages *pcp = NULL;
  |    pcp = &this_cpu_ptr(zone->pageset)->pcp;
  |    struct list_head = NULL;
  |    list_head = &pcp->lists[migratetype];
  |
  |
  |    if(list_empty(list)) //开始时，只有MIGRATE_MOVABLE不为空
  |    { pcp->count += rmqueue_bulk(zone, 0, pcp->batch, list,
  |                                 migratetype, cold);}
  |    即，获取pcp->batch个页，并将页挂入pcp->lists[migratetype]中，
  |    同时修正pcp->count;
  |
  |
  |    if(cold) page = list_entry(list->prev, struct page, lru);
  |    else page = list_entry(list->next, struct page, lru);
  |    关于“冷/热页”的问题，我不太理解！！！！
  |    从per_cpu_pages->lists的相应类型链表上，取出一个页.
  |
  |    list_del(&page->lru);
  |    将获得的页又从per_cpu_pages上取下，从此处我们也可看出，对于单个的页，
  |    将先从per_cpu_pages->lists[MIGRATE_PCPTYPES]上获取，如果对应类型的
  |    pcp链表上没有，则会直接从伙伴系统上区下页链表，并挂入相应类型的
  |    per_cpu_pages->lists链表上.
  |
  |    pcp->count--;
  |--}
  |
  |--else
  |--{
  |   与order = 0的主要区别在于，order = 0可以通过per_cpu_pages进行分配，
  |   而order != 0则没有相应的缓存，只能调用__rmqueue函数进行分配.
  |--}
  |
  |-->if(prep_new_page(page, order, gfp_flags)) goto again;
  |    prep_new_page函数中将对struct page，物理页做适当的修改.
  |
  |-->return page;

int rmqueue_bulk(struct zone *zone, unsigned int order, 
                 unsigned long count, struct list_head *list, 
                 int migratetype, int cold)
  |--int i = 0;
  |
  |--for(i = 0; i < count; ++i)
  |--{
  |    struct page *page = __rmqueue(zone, order, migratetype);
  |
  |    if(cold == 0) list_add(&page->lru, list);
  |    else list_add_tail(&page->lru, list);
  |    将申请到的页放到list链表中.
  |
  |    set_page_private(page, migratetype);
  |    list = &page->lru;
  |--}
  |
  |-->__mod_zone_page_state(zone, NR_FREE_PAGES, -(i << order));
  |   因为从某个链表上的项已经用完，故需从其它链表上迁移处新的项，
  |   完成迁移后，需要跟新zone->vm_state的相关统计量，此处做跟新.
  |
  |-->return i; //返回申请到的页数

/* 1、从不同order上具有相同类型的链表上申请页
 * 2、从其它类型的链表上迁移页到制定的链表上，并申请页
 */
struct page *__rmqueue(struct zone *zone, unsigned int order,
        int migratetype)
  |-->struct page *page = NULL;
  |
  |-->page = __rmqueue_smallest(zone, order, migratetype)
  |   先尝试从其它order上具有相同迁移类型的链表上获取页，但是由于这是初
  |   始化首次调用，因此其它order上的相同迁移类型的链表也为空.
  |
  |   那么此时只能从不同迁移类型的链表上申请页.
  |-->if(unlikely(!page) && migratetype != MIGRATE_RESERVE)
  |--{
  |    page = __rmqueue_fallback(zone, order, migratetype);
  |    if(!page)
  |    { migratetype = MIGRATE_RESERVE; goto retry_rserve;}
  |--}
  |
  |--return page;

从其它类型的链表上迁移页
/*
int fallbacks[MIGRATE_TYPES][MIGRATE_TYPES-1] = {
    [MIGRATE_UNMOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE,   MIGRATE_RESERVE },
    [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE, MIGRATE_MOVABLE,   MIGRATE_RESERVE },
    [MIGRATE_MOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_RESERVE },
    [MIGRATE_RESERVE] = { MIGRATE_RESERVE, MIGRATE_RESERVE,   MIGRATE_RESERVE },
  };
 */
struct page *__rmqueue_fallback(struct zone *zone, int order,
        int start_migratetype)
  |--做了一定的简化，先做下说明：
  |  当从其它链表迁移时，按照order从大到小的顺序选择被迁移的链表;
  |  如果一次性迁移的链表上的页数目太多（不小于一个页块的页数的一半)时，
  |  将会把迁移出的链表放在相应类型的其它order链表上，并且将页块属性修
  |  该成相应的MIGRATE类型;
  |  
  |  而后又将取出的链从相应的MIGRATE类型链表上取下，并按照buddy system要求，
  |  将链表上的页按照order大小依次放到小于所取下order的同类型的链表上.
  |
  |  比如：在系统初始化过程中，所有order的MIGRATE_UNMOVABLE类型链表都为空，
  |       那么将从order = 10的MIGRATE_MOVABLE类型链表上取下一个buddy，
  |       并一次下放到order = [9..0]的MIGARTE_UNMOVABLE类型链表上，
  |       可以看出只下放了1023个页，因为传入的参数order = 0，正好请求1页，
  |       故，多出的1页将不会再在伙伴系统的链表中，而是交由slab来管理.
  |
  |--struct free_area *area = NULL;
  |  struct page *page = NULL;
  |  int current_order = 0;
  |
  |-->for(current_order = MAX_ORDER - 1; 
  |       current_order >= order; 
  |       --current_order)
  |--{
  |     for(i = 0; i < MIGRATE_TYPES - 1; i++)
  |     {
  |       更具fallbacks，从备用链表上选取一个类型的非空链表，
  |       记链表类型为migratetype.
  |      
  |       area = &(zone->free_area[current_order]);
  |       page = list_entry(area->free_list[migratetype].next,
  |                         struct page, lru); 
  |       area->nr_free--; 
  |      
  |       如上文所述，可能需要修改页块的属性，迁移链表到制定的order的类型下：
  |       move_freepages_block(zone, page, start_migratetype);
  |       set_pageblock_migratetype(page, start_migratetype);
  |
  |      list_del(&page->lru);
  |      rmv_page_order(page);
  |
  |      expand(zone, page, order, current_order, area,
  |             start_migratetype);
  |      buddy system中被取下的一个链分别放到order ~ (current_order - 1)的
  |      start_migratetype链表上.
  |
  |      return page;//该页将不会存在于伙伴系统中，开始交由上级（slab)管理.
  |     }
  |--}

int prep_new_page(struct page *page, int order, gfp_t gfp_flags)
  |-->set_page_private(page, 0);
  |   set_page_refcount(page);
  |  
  |-->kernel_map_pages(page, 1 << order, 1);
  |
  |-->if(gfp_flags & __GFP_ZERO)
  |     prep_zero_page(page, order, gfp_flags);
  |   使用临时映射，将物理页清零.
  |
  |-->if(order && (gfp_flags & __GFP_ORDER))
  |     prep_compound_page(page, order);
  |   关于compound_page，不明白什么意思????

/**根据cachep信息和offset获取slab描述符的地址. 
 * 需考虑着色. 但是对于着色的原理、性能提升我并不清楚?????） 
 */
struct slab *alloc_slabmgmt(struct kmem_cache *cachep, void *objp,
        int colour_off, gfp_t local_flags, int nodeid) 
  |-->struct slab *slabp; 
  |--if(OFF_SLAB(cachep))
  |--{ 如果slab描述符在外部，我们此处看看else的情形}
  |
  |--else 
  |--{
  |     slabp = objp + colour_off;
  |     slab结构体偏移页起始空间colour_off大小.
  |     colour_off += cachep->slab->slab_size;
  |     被管理的小内存实体的偏移量偏移页起始空间colour_off
  |--}
  |
  |--slabp->inuse = 0;
  |  slabp->colouroff = colour_off;
  |     被管理的小内存实体的偏移量偏移页起始空间colour_off
  |  slabp->s_mem = objp + colour_off;
  |     被管理的小内存实体的起始地址存于slabp->s_mem中
  |  slabp->nodeid = nodeid; 
  |  slabp->free = 0;
  |
  |--return slabp;     

复用page->lru上的两个指针，使其分别指向cachep和slap
void slab_map_pages(struct kmem_cache *cache, struct slab *slab,
        void *addr)
  |-->int nr_pages = 1;
  |   struct page *page = virt_to_page(addr);
  |
  |--if(!PageCompound(page)) nr_pages <<= cache->gfporder;
  |
  |--do
  |--{
  |     page_set_cache(page, cache);
  |     |-->page->lru.next = (struct list_head *)cache;
  |
  |     page_set_slab(page, slab);
  |     |-->page->lru.prev = (struct list_head *)slab;
  |
  |     page++;
  |--}while(--nr_pages);

void cache_init_objs(struct kmem_cache *cachep, struct slab *slabp)
  |--for(i = 0; i < cachep->num; i++)
  |--{
  |    slab_bufctl(slabp)[i] = i + 1;
  |    紧接着slab描述符的是kmem_bufctl_t 数组
  |--}
  |
  |--slab_bufctl(slabp)[i - 1] = BUFCTL_END;

kmem_bufctl_t *slab_bufctl(struct slab *slabp)
  |--return (kmem_bufctl_t *)(slabp + 1);

void *slab_get_obj(struct kmem_cache *cachep, struct slab *slabp,
        int nodeid)
  |-->void *objp = index_to_obj(cachep, slabp, slapb->free);
  |   根据slabp->free索引号，获得cachep->buffer_size空间大小的起始地址
  |
  |-->slabp->inuse++;
  |
  |-->kmem_bufctl_t next;
  |   next = slabp_bufctl(slabp)[slabp->free];
  |   从此处我们可看出slab描述符后的kmem_bufctl_t数组的作用：
  |   每个数组元数存放的是下一个未被使用的待分配空间的索引.
  |
  |-->slabp->free = next;
  |
  |-->return objp

size_t calculate_slab_order(struct kmem_cache *cachep,
                  size_t size, size_t align, unsigned long flags)
  |-->unsigned long offslab_limit;
  |   size_t left_over = 0;
  |   int gfporder = 0;
  |
  |--for(gfporder = 0; gfporder <= KMALLOC_MAX_ORDER; gfporder++)
  |--{
  |     unsigned int num;
  |     size_t remainder = 0;
  |     cache_estimate(gfporder, size, align, flags, &remainder, &num);
  |     cachep->num = num;
  |     cachep->gfporder = gfporder;
  |     leftover = remainder;
  |--}
  |
  |--return left_over;

int setup_cpu_cache(struct kmem_cache *cachep, gfp_t gfp)
  |--if(g_cpucache_up == FULL)
  |    return enable_cpucache(cachep, gfp);
  |
  |  以下与初始化的不同阶段相关联
  |--if(g_cpucache_up == NONE)
  |--{
  |     g_cpucache_up 值为 NONE，意味着是首次调用kmem_cache_create;
  |     
  |     cachep->array]smp_process_id()] = &initarray_generic.cache;
  |
  |     setup_list3s(cachep, 1)
  |     |-->cachep->nodelists[0] = &initkmem_list3[1];
  |     |   cachep->nodelists[0]->next_reap = jiffies 
  |     |       + REAPTIMEOUT_LIST3
  |     |       + ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
  |
  |     g_cpucache_up = PARTIAL_AC;
  |--}
  |--else
  |--{
  |     第二次调用kmem_cache_create;
  |     第一次调用时只构建了array_cache的kmem_cache实例，但是
  |     并没有分配号array_cache的slab分配器，此处就开始调用kmalloc，
  |     我们跟踪一下，看是如何完成sizeof(arraycache_init)的分配的.
  |     cachep->array[smp_processor_id()] = 
  |          kmalloc(sizeof(struct arraycache_init), gfp);
  |
  |     if(g_cpucache_up == PARTIAL_AC)
  |     {
  |        set_up_list3s(cachep, 2);
  |        |-->cachep->nodelists[0] = &initkmem_list3[2];
  |        |   cachep->nodelists[0]->next_reap = jiffies 
  |        |       + REAPTIMEOUT_LIST3
  |        |       + ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
  |
  |        g_cpucache_up = PARTIAL_L3;
  |     }
  |     else
  |     {
  |        cachep->nodelists[0] = kmalloc_node(sizeof(struct kmem_list3),
  |                                            gfp, 0);
  |        kmem_list3_init(cachep->nodelists[0]);
  |     }
  |--}
  |
  |--cachep->nodelists[0]->next_reap = jiffies
  |      + REAPTIMEOUT_LIST3
  |      + ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
  |
  |--cpu_cache_get(cachep)->avail = 0;
  |  cpu_cache_get(cachep)->limit = 1;
  |  cpu_cache_get(cachep)->batchcount = 1;
  |  cpu_cache_get(cachep)->touched = 0;
  |  cachep->batchcount = 1;
  |  cachep->limit = 1;
  |  return 0;

void *kmalloc(size_t size, gfp_t flags)
  |-->reutrn __kmalloc(size, flags)
      |-->return __do_kmalloc(size, flags, NULL);

void *__do_malloc(size_t size, gfp_t flags, void *caller)
  |-->struct kmem_cache *cachep;
  |   void *ret;
  |
  |-->cachep = __find_general_cachep(size, flags);
  |   在malloc_sizes数组中寻找大于size的最小的kmem_cache缓存实例.
  |
  |-->ret = __cache_alloc(cachep, flags, caller);
  |   同与cache_cache的分配过程:
  |   先尝试从array_cache中分配，其次从slab分配，若没有相应的slab
  |   分配器，则从buddy system中分配页来构建slab份额器，并将slab
  |   分配器挂入kmem_cache实例的kmem_list3实例的某个链表下.
  |
  |--return ret;