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