内存管理 初始化（五）kmem_cache_init 初始化slab分配器(上)

看了下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;