开发者社区> sky-heaven> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

linux percpu机制解析【转】

简介: 转自:http://blog.csdn.net/wh8_2011/article/details/53138377 一、概述每cpu变量是最简单也是最重要的同步技术。每cpu变量主要是数据结构数组,系统的每个cpu对应数组的一个元素。
+关注继续查看

转自:http://blog.csdn.net/wh8_2011/article/details/53138377

一、概述

每cpu变量是最简单也是最重要的同步技术。每cpu变量主要是数据结构数组,系统的每个cpu对应数组的一个元素。一个cpu不应该访问与其它cpu对应的数组元素,另外,它可以随意读或修改它自己的元素而不用担心出现竞争条件,因为它是唯一有资格这么做的cpu。这也意味着每cpu变量基本上只能在特殊情况下使用,也就是当它确定在系统的cpu上的数据在逻辑上是独立的时候。

每个处理器访问自己的副本,无需加锁,可以放入自己的cache中,极大地提高了访问与更新效率。常用于计数器。

二、相关结构体:

1.整体的percpu内存管理信息被收集在struct pcpu_alloc_info结构中

struct pcpu_alloc_info {

size_t static_size; //静态定义的percpu变量占用内存区域长度

size_t reserved_size; //预留区域,在percpu内存分配指定为预留区域分配时,将使用该区域

size_t dyn_size; //动态分配的percpu变量占用内存区域长度

//每个cpu的percpu空间所占得内存空间为一个unit, 每个unit的大小记为unit_size

size_t unit_size; //每颗处理器的percpu虚拟内存递进基本单位

size_t atom_size; //PAGE_SIZE

size_t alloc_size; //要分配的percpu内存空间

size_t __ai_size; //整个pcpu_alloc_info结构体的大小

int nr_groups; //该架构下的处理器分组数目

struct pcpu_group_info groups[]; //该架构下的处理器分组信息

};

2.对于处理器的分组信息,内核使用struct pcpu_group_info结构表示

struct pcpu_group_info {

int nr_units;
//该组的处理器数目

//组的percpu内存地址起始地址,即组内处理器数目×处理器percpu虚拟内存递进基本单位

unsigned long base_offset; 

unsigned int 
*cpu_map; //组内cpu对应数组,保存cpu id号

};

3.内核使用pcpu_chunk结构管理percpu内存

struct pcpu_chunk {

//用来把chunk链接起来形成链表。每一个链表又都放到pcpu_slot数组中,根据chunk中空闲空间的大小决定放到数组的哪个元素中。

struct list_head list; 

int free_size;
//chunk中的空闲大小

int contig_hint;
//该chunk中最大的可用空间的map项的size

void *base_addr;
//percpu内存开始基地值

int map_used;
//该chunk中使用了多少个map项

int map_alloc;
//记录map数组的项数,为PERCPU_DYNAMIC_EARLY_SLOTS=128

//若map项>0,表示该map中记录的size是可以用来分配percpu空间的。

//若map项<0,表示该map项中的size已经被分配使用。

int *map;
//map数组,记录该chunk的空间使用情况

void *data;
//chunk data

bool immutable; 
/* no [de]population allowed
*/

unsigned long populated[];
/* populated bitmap
*/

};

三、per-cpu初始化

在系统初始化期间,start_kernel()函数中调用setup_per_cpu_areas()函数,用于为每个cpu的per-cpu变量副本分配空间,注意这时alloc内存分配器还没建立起来,该函数调用alloc_bootmem函数为初始化期间的这些变量副本分配物理空间。

在建立percpu内存管理机制之前要整理出该架构下的处理器信息,包括处理器如何分组、每组对应的处理器位图、静态定义的percpu变量占用内存区域、每颗处理器percpu虚拟内存递进基本单位等信息。

1.setup_per_cpu_areas()函数,用于为每个cpu的per-cpu变量副本分配空间

void __init setup_per_cpu_areas(void)

{

unsigned long delta;

unsigned int cpu;

int rc;



//为percpu建立第一个chunk

rc = pcpu_embed_first_chunk(PERCPU_MODULE_RESERVE,

PERCPU_DYNAMIC_RESERVE, PAGE_SIZE,
NULL,

pcpu_dfl_fc_alloc, pcpu_dfl_fc_free);

if (rc
< 0)

panic("Failed to initialize percpu areas.");



//内核为percpu分配了一大段空间,在整个percpu空间中根据cpu个数将percpu的空间分为不同的unit。

//而pcpu_base_addr表示整个系统中percpu的起始内存地址.

//__per_cpu_start表示静态分配的percpu起始地址。即节区".data..percpu"中起始地址。

//函数首先算出副本空间首地址(pcpu_base_addr)与".data..percpu"section首地址(__per_cpu_start)之间的偏移量delta

delta = (unsigned long)pcpu_base_addr
- (unsigned long)__per_cpu_start;

//遍历系统中的cpu,设置每个cpu的__per_cpu_offset指针

//pcpu_unit_offsets[cpu]保存对应cpu所在副本空间相对于pcpu_base_addr的偏移量

//加上delta,这样就可以得到每个cpu的per-cpu变量副本的偏移量, 放在__per_cpu_offset数组中.

for_each_possible_cpu(cpu)

__per_cpu_offset[cpu]
= delta + pcpu_unit_offsets[cpu];

}

1.1 为percpu建立第一个chunk

int __init pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size,

size_t atom_size,

pcpu_fc_cpu_distance_fn_t cpu_distance_fn,

pcpu_fc_alloc_fn_t alloc_fn,

pcpu_fc_free_fn_t free_fn)

{

void *base 
= (void *)ULONG_MAX;

void **areas
= NULL;

struct pcpu_alloc_info *ai;

size_t size_sum, areas_size, max_distance;

int group, i, rc;



//收集整理该架构下的percpu信息,结果放在struct pcpu_alloc_info结构中

ai = pcpu_build_alloc_info(reserved_size, dyn_size, atom_size,cpu_distance_fn);

if (IS_ERR(ai))

return PTR_ERR(ai);



//计算每个cpu占用的percpu内存空间大小,包括静态定义变量占用空间+reserved空间+动态分配空间

size_sum = ai->static_size
+ ai->reserved_size
+ ai->dyn_size;



//areas用来保存每个group的percpu内存起始地址,为其分配空间,做临时存储使用,用完释放掉

areas_size = PFN_ALIGN(ai->nr_groups
* sizeof(void
*)); 

areas = memblock_virt_alloc_nopanic(areas_size, 0);

if (!areas)
{

rc = -ENOMEM;

goto out_free;

}



//针对该系统下的每个group操作,为每个group分配percpu内存区域,前边只是计算出percpu信息,并没有分配percpu的内存空间。

for (group
= 0; group 
< ai->nr_groups; group++)
{

struct pcpu_group_info *gi 
= &ai->groups[group];//取出该group下的组信息

unsigned int cpu 
= NR_CPUS;

void *ptr;



//检查cpu_map数组

for (i
= 0; i 
< gi->nr_units
&& cpu 
== NR_CPUS; i++)

cpu = gi->cpu_map[i];

BUG_ON(cpu 
== NR_CPUS);



//为该group分配percpu内存区域。长度为该group里的cpu数目X每颗处理器的percpu递进单位。

//函数pcpu_dfl_fc_alloc是从bootmem里取得内存,得到的是物理内存,返回物理地址的内存虚拟地址ptr

ptr = alloc_fn(cpu, gi->nr_units
* ai->unit_size, atom_size);

if (!ptr)
{

rc = 
-ENOMEM;

goto out_free_areas;

}

/* kmemleak tracks the percpu allocations separately
*/

kmemleak_free(ptr);

//将分配到的改组percpu内存虚拟起始地址保存在areas数组中

areas[group]
= ptr;



//比较每个group的percpu内存地址,保存最小的内存地址,即percpu内存的起始地址

//为后边计算group的percpu内存地址的偏移量

base = min(ptr, base);

}



//为每个group中的每个cpu建立其percpu区域

for (group
= 0; group 
< ai->nr_groups; group++)
{

//取出该group下的组信息

struct pcpu_group_info *gi 
= &ai->groups[group];

void *ptr 
= areas[group];//得到该group的percpu内存起始地址



//遍历该组中的cpu,并得到每个cpu对应的percpu内存地址

for (i
= 0; i 
< gi->nr_units; i++, ptr
+= ai->unit_size)
{

if 
(gi->cpu_map[i]
== NR_CPUS)
{

free_fn(ptr, ai->unit_size);//释放掉未使用的unit

continue;

}

//将静态定义的percpu变量拷贝到每个cpu的percpu内存起始地址

memcpy(ptr, __per_cpu_load, ai->static_size);

//为每个cpu释放掉多余的空间,多余的空间是指ai->unit_size减去静态定义变量占用空间+reserved空间+动态分配空间

free_fn(ptr 
+ size_sum, ai->unit_size
- size_sum);

}

}



//计算group的percpu内存地址的偏移量

max_distance = 0;

for (group
= 0; group 
< ai->nr_groups; group++)
{

ai->groups[group].base_offset
= areas[group]
- base;

max_distance = max_t(size_t, max_distance,ai->groups[group].base_offset);

}

//检查最大偏移量是否超过vmalloc空间的75%

max_distance += ai->unit_size; 

if (max_distance
> VMALLOC_TOTAL * 3 / 4)  { pr_warning("PERCPU: max_distance=0x%zx too large for vmalloc " "space 0x%lx\n", max_distance,VMALLOC_TOTAL); } pr_info("PERCPU: Embedded %zu pages/cpu @%p s%zu r%zu d%zu u%zu\n", PFN_DOWN(size_sum), base, ai->static_size, ai->reserved_size, ai->dyn_size, ai->unit_size); //为percpu建立第一个chunk rc = pcpu_setup_first_chunk(ai, base); goto out_free; out_free_areas: for (group = 0; group  < ai->nr_groups; group++) if (areas[group]) free_fn(areas[group],ai->groups[group].nr_units * ai->unit_size); out_free: pcpu_free_alloc_info(ai); if (areas) memblock_free_early(__pa(areas), areas_size); return rc; } 1.1.1 收集整理该架构下的percpu信息 static struct pcpu_alloc_info * __init pcpu_build_alloc_info(size_t reserved_size, size_t dyn_size, size_t atom_size,pcpu_fc_cpu_distance_fn_t cpu_distance_fn) { static int group_map[NR_CPUS] __initdata; static int group_cnt[NR_CPUS] __initdata; const size_t static_size  = __per_cpu_end - __per_cpu_start; int nr_groups  = 1, nr_units  = 0; size_t size_sum, min_unit_size, alloc_size; int upa, max_upa, uninitialized_var(best_upa); /* units_per_alloc */ int last_allocs, group, unit; unsigned int cpu, tcpu; struct pcpu_alloc_info *ai; unsigned int  *cpu_map; /* this function may be called multiple times  */ memset(group_map, 0, sizeof(group_map)); memset(group_cnt, 0, sizeof(group_cnt)); //计算每个cpu所占有的percpu空间大小,包括静态空间+保留空间+动态空间 size_sum = PFN_ALIGN(static_size + reserved_size + max_t(size_t, dyn_size, PERCPU_DYNAMIC_EARLY_SIZE)); //重新计算动态分配的percpu空间大小 dyn_size = size_sum  - static_size - reserved_size; //计算每个unit的大小,即每个group中的每个cpu占用的percpu内存大小为一个unit min_unit_size = max_t(size_t, size_sum, PCPU_MIN_UNIT_SIZE); //atom_size为PAGE_SIZE,即4K.将min_unit_size按4K向上舍入,例如min_unit_size=5k,则alloc_size为两个页面大小即8K,若min_unit_size=9k,则alloc_size为三个页面大小即12K alloc_size = roundup(min_unit_size, atom_size); upa = alloc_size  / min_unit_size; while (alloc_size % upa || ((alloc_size / upa)  & ~PAGE_MASK)) upa--; max_upa = upa; //为cpu分组,将接近的cpu分到一组中,因为没有定义cpu_distance_fn函数体,所以所有的cpu分到一个组中。 //可以得到所有的cpu都是group=0,group_cnt[0]即是该组中的cpu个数 for_each_possible_cpu(cpu) { group = 0; next_group: for_each_possible_cpu(tcpu) { if  (cpu == tcpu) break; //cpu_distance_fn=NULL if  (group_map[tcpu] == group  && cpu_distance_fn  && (cpu_distance_fn(cpu, tcpu) > LOCAL_DISTANCE || cpu_distance_fn(tcpu, cpu) > LOCAL_DISTANCE)) { group++; nr_groups = max(nr_groups, group + 1); goto next_group; } } group_map[cpu] = group; group_cnt[group]++; } /* * Expand unit size  until address space usage goes over 75% * and then as much as possible without using more address * space. */ last_allocs = INT_MAX; for (upa = max_upa; upa; upa--) { int allocs  = 0, wasted  = 0; if (alloc_size % upa || ((alloc_size / upa)  & ~PAGE_MASK)) continue; for (group = 0; group  < nr_groups; group++) { int this_allocs  = DIV_ROUND_UP(group_cnt[group], upa); allocs += this_allocs; wasted += this_allocs * upa - group_cnt[group]; } /* * Don't accept if wastage is over 1/3. The * greater-than comparison ensures upa==1 always * passes the following check. */ if (wasted > num_possible_cpus() / 3) continue; /* and then don't consume more memory */ if (allocs > last_allocs) break; last_allocs = allocs; best_upa = upa; } upa = best_upa; //计算每个group中的cpu个数 for (group = 0; group  < nr_groups; group++) nr_units += roundup(group_cnt[group], upa); //分配pcpu_alloc_info结构空间,并初始化 ai = pcpu_alloc_alloc_info(nr_groups, nr_units); if (!ai) return ERR_PTR(-ENOMEM); //为每个group的cpu_map指针赋值为group[0],group[0]中的cpu_map中的值初始化为NR_CPUS cpu_map = ai->groups[0].cpu_map; for (group = 0; group  < nr_groups; group++) { ai->groups[group].cpu_map = cpu_map; cpu_map += roundup(group_cnt[group], upa); } ai->static_size = static_size; //静态percpu变量空间 ai->reserved_size = reserved_size;//保留percpu变量空间 ai->dyn_size = dyn_size; //动态分配的percpu变量空间 ai->unit_size = alloc_size / upa; //每个cpu占用的percpu变量空间 ai->atom_size = atom_size; //PAGE_SIZE ai->alloc_size = alloc_size; //实际分配的空间 for (group = 0, unit  = 0; group_cnt[group]; group++) { struct pcpu_group_info *gi  = &ai->groups[group]; //设置组内的相对于0地址偏移量,后边会设置真正的对于percpu起始地址的偏移量 gi->base_offset = unit * ai->unit_size; //设置cpu_map数组,数组保存该组中的cpu id号。以及设置组中的cpu个数gi->nr_units //gi->nr_units=0,cpu=0 //gi->nr_units=1,cpu=1 //gi->nr_units=2,cpu=2 //gi->nr_units=3,cpu=3 for_each_possible_cpu(cpu) if  (group_map[cpu] == group) gi->cpu_map[gi->nr_units++] = cpu; gi->nr_units = roundup(gi->nr_units, upa); unit += gi->nr_units; } BUG_ON(unit  != nr_units); return ai; } 1.1.1.1 分配pcpu_alloc_info结构,并初始化 struct pcpu_alloc_info * __init pcpu_alloc_alloc_info(int nr_groups,int nr_units) { struct pcpu_alloc_info *ai; size_t base_size, ai_size; void *ptr; int unit; //根据group数以及,group[0]中cpu个数确定pcpu_alloc_info结构体大小ai_size base_size = ALIGN(sizeof(*ai) + nr_groups * sizeof(ai->groups[0]), __alignof__(ai->groups[0].cpu_map[0])); ai_size = base_size  + nr_units * sizeof(ai->groups[0].cpu_map[0]); //分配空间 ptr = memblock_virt_alloc_nopanic(PFN_ALIGN(ai_size), 0); if (!ptr) return NULL; ai = ptr; ptr += base_size;//指针指向group的cpu_map数组地址处 ai->groups[0].cpu_map = ptr; //初始化group[0]的cpu_map数组值为NR_CPUS for (unit = 0; unit  < nr_units; unit++) ai->groups[0].cpu_map[unit] = NR_CPUS; ai->nr_groups = nr_groups;//group个数 ai->__ai_size = PFN_ALIGN(ai_size);//整个pcpu_alloc_info结构体的大小 return ai; } 1.1.2 为percpu建立第一个chunk int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,void  *base_addr) { static char cpus_buf[4096] __initdata; static int smap[PERCPU_DYNAMIC_EARLY_SLOTS] __initdata; static int dmap[PERCPU_DYNAMIC_EARLY_SLOTS] __initdata; size_t dyn_size = ai->dyn_size; size_t size_sum = ai->static_size + ai->reserved_size + dyn_size; struct pcpu_chunk *schunk, *dchunk =  NULL; unsigned long *group_offsets; size_t *group_sizes; unsigned long *unit_off; unsigned int cpu; int *unit_map; int group, unit, i; cpumask_scnprintf(cpus_buf, sizeof(cpus_buf), cpu_possible_mask); #define PCPU_SETUP_BUG_ON(cond) do {  \ if (unlikely(cond)) { \ pr_emerg("PERCPU: failed to initialize, %s", #cond); \ pr_emerg("PERCPU: cpu_possible_mask=%s\n", cpus_buf); \ pcpu_dump_alloc_info(KERN_EMERG, ai); \ BUG(); \ } \ } while (0) //健康检查 PCPU_SETUP_BUG_ON(ai->nr_groups <= 0); #ifdef CONFIG_SMP PCPU_SETUP_BUG_ON(!ai->static_size); PCPU_SETUP_BUG_ON((unsigned long)__per_cpu_start & ~PAGE_MASK); #endif PCPU_SETUP_BUG_ON(!base_addr); PCPU_SETUP_BUG_ON((unsigned long)base_addr & ~PAGE_MASK); PCPU_SETUP_BUG_ON(ai->unit_size < size_sum); PCPU_SETUP_BUG_ON(ai->unit_size & ~PAGE_MASK); PCPU_SETUP_BUG_ON(ai->unit_size < PCPU_MIN_UNIT_SIZE); PCPU_SETUP_BUG_ON(ai->dyn_size < PERCPU_DYNAMIC_EARLY_SIZE); PCPU_SETUP_BUG_ON(pcpu_verify_alloc_info(ai) < 0); //为group相关percpu信息保存数组分配空间 group_offsets = memblock_virt_alloc(ai->nr_groups *sizeof(group_offsets[0]), 0); group_sizes = memblock_virt_alloc(ai->nr_groups *sizeof(group_sizes[0]), 0); //为每个cpu相关percpu信息保存数组分配空间 unit_map = memblock_virt_alloc(nr_cpu_ids * sizeof(unit_map[0]), 0); unit_off = memblock_virt_alloc(nr_cpu_ids * sizeof(unit_off[0]), 0); //对unit_map、pcpu_low_unit_cpu和pcpu_high_unit_cpu变量初始化 for (cpu = 0; cpu  < nr_cpu_ids; cpu++) unit_map[cpu] = UINT_MAX;  pcpu_low_unit_cpu = NR_CPUS; pcpu_high_unit_cpu = NR_CPUS; //遍历每一group的每一个cpu for (group = 0, unit  = 0; group  < ai->nr_groups; group++, unit += i) { const struct pcpu_group_info  *gi = &ai->groups[group]; //取得该组处理器的percpu内存空间的偏移量 group_offsets[group] = gi->base_offset; //取得该组处理器的percpu内存空间占用的虚拟地址空间大小,即包含改组中每个cpu所占的percpu空间 group_sizes[group] = gi->nr_units * ai->unit_size; //遍历该group中的cpu for (i = 0; i  < gi->nr_units; i++) { cpu = gi->cpu_map[i];//得到该group中的cpu id号 if  (cpu == NR_CPUS) continue; PCPU_SETUP_BUG_ON(cpu  > nr_cpu_ids); PCPU_SETUP_BUG_ON(!cpu_possible(cpu)); PCPU_SETUP_BUG_ON(unit_map[cpu] != UINT_MAX); //计算每个cpu的跨group的编号,保存在unit_map数组中 unit_map[cpu] = unit + i; //计算每个cpu的在整个系统percpu内存空间中的偏移量,保存到数组unit_off中 unit_off[cpu] = gi->base_offset + i * ai->unit_size; /* determine low/high unit_cpu */ if  (pcpu_low_unit_cpu == NR_CPUS || unit_off[cpu] < unit_off[pcpu_low_unit_cpu]) pcpu_low_unit_cpu = cpu; if  (pcpu_high_unit_cpu == NR_CPUS || unit_off[cpu] > unit_off[pcpu_high_unit_cpu]) pcpu_high_unit_cpu = cpu; } } //pcpu_nr_units变量保存系统中有多少个cpu的percpu内存空间 pcpu_nr_units = unit; for_each_possible_cpu(cpu) PCPU_SETUP_BUG_ON(unit_map[cpu] == UINT_MAX); #undef PCPU_SETUP_BUG_ON pcpu_dump_alloc_info(KERN_DEBUG, ai); //记录下全局参数,留在pcpu_alloc时使用 pcpu_nr_groups = ai->nr_groups;//系统中group数量 pcpu_group_offsets = group_offsets;//记录每个group的percpu内存偏移量数组 pcpu_group_sizes = group_sizes;//记录每个group的percpu内存空间大小数组 pcpu_unit_map = unit_map;//整个系统中cpu(跨group)的编号数组 pcpu_unit_offsets = unit_off;//每个cpu的percpu内存空间偏移量 pcpu_unit_pages = ai->unit_size >> PAGE_SHIFT;//每个cpu的percpu内存虚拟空间所占的页面数量 pcpu_unit_size = pcpu_unit_pages  << PAGE_SHIFT;//每个cpu的percpu内存虚拟空间大小 pcpu_atom_size = ai->atom_size;//PAGE_SIZE //计算pcpu_chunk结构的大小,加上populated域的大小 pcpu_chunk_struct_size = sizeof(struct pcpu_chunk) + BITS_TO_LONGS(pcpu_unit_pages) * sizeof(unsigned long); //计算pcpu_nr_slots,即pcpu_slot数组的组项数量 pcpu_nr_slots = __pcpu_size_to_slot(pcpu_unit_size) + 2; //为pcpu_slot数组分配空间,不同size的chunck挂在不同“pcpu_slot”项目中 pcpu_slot = memblock_virt_alloc(pcpu_nr_slots * sizeof(pcpu_slot[0]), 0); for (i = 0; i  < pcpu_nr_slots; i++) INIT_LIST_HEAD(&pcpu_slot[i]); //构建静态chunck,即pcpu_reserved_chunk schunk = memblock_virt_alloc(pcpu_chunk_struct_size, 0); INIT_LIST_HEAD(&schunk->list); schunk->base_addr = base_addr;//整个系统中percpu内存的起始地址 schunk->map = smap;//初始化为一个静态数组 schunk->map_alloc = ARRAY_SIZE(smap);//PERCPU_DYNAMIC_EARLY_SLOTS=128 schunk->immutable = true; //物理内存已经分配这里标志之 //若pcpu_unit_pages=8即每个cpu占用的percpu空间为8页的空间,则populated域被设置为0xff bitmap_fill(schunk->populated, pcpu_unit_pages); if (ai->reserved_size) { //如果存在percpu保留空间,在指定reserved分配时作为空闲空间使用 schunk->free_size = ai->reserved_size;  pcpu_reserved_chunk = schunk; //静态chunk的大小限制包括,定义的静态变量的空间+保留的空间 pcpu_reserved_chunk_limit = ai->static_size + ai->reserved_size; } else { //若不存在保留空间,则将动态分配空间作为空闲空间使用 schunk->free_size = dyn_size; dyn_size = 0;//覆盖掉动态分配空间 } //记录静态chunk中空闲可使用的percpu空间大小 schunk->contig_hint = schunk->free_size; //map数组保存空间的使用情况,负数为已使用的空间,正数表示为以后可以分配的空间 //map_used记录chunk中存在几个map项 schunk->map[schunk->map_used++] = -ai->static_size; if (schunk->free_size) schunk->map[schunk->map_used++] = schunk->free_size; //构建动态chunk分配空间 if (dyn_size) { dchunk = memblock_virt_alloc(pcpu_chunk_struct_size, 0); INIT_LIST_HEAD(&dchunk->list); dchunk->base_addr = base_addr;//整个系统中percpu内存的起始地址 dchunk->map = dmap;//初始化为一个静态数组 dchunk->map_alloc = ARRAY_SIZE(dmap);//PERCPU_DYNAMIC_EARLY_SLOTS=128 dchunk->immutable = true; //记录下来分配的物理页 bitmap_fill(dchunk->populated, pcpu_unit_pages); //设置动态chunk中的空闲可分配空间大小 dchunk->contig_hint = dchunk->free_size = dyn_size; //map数组保存空间的使用情况,负数为已使用的空间(静态变量空间和reserved空间),正数表示为以后可以分配的空间 dchunk->map[dchunk->map_used++] = -pcpu_reserved_chunk_limit; dchunk->map[dchunk->map_used++] = dchunk->free_size; } //把第一个chunk链接进对应的slot链表,reserverd的空间有自己单独的chunk:pcpu_reserved_chunk pcpu_first_chunk = dchunk  ?: schunk; pcpu_chunk_relocate(pcpu_first_chunk, -1); //pcpu_base_addr记录整个系统中percpu内存的起始地址 pcpu_base_addr = base_addr; return 0; } //fls找到size中最高的置1的位,返回该位号 //例:fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32. //若size=32768=0x8000,则fls(32768)=16 //若highbit=0-4,则slot个数均为1 #define PCPU_SLOT_BASE_SHIFT 5 static int __pcpu_size_to_slot(int size) { int highbit  = fls(size); return max(highbit  - PCPU_SLOT_BASE_SHIFT + 2, 1); } static void pcpu_chunk_relocate(struct pcpu_chunk *chunk,  int oslot) { //返回该chunk对应的要挂入的slot数组的下标 int nslot  = pcpu_chunk_slot(chunk); //静态chunk不需挂入pcpu_slot数组中 if (chunk != pcpu_reserved_chunk && oslot  != nslot) { if (oslot < nslot) list_move(&chunk->list, &pcpu_slot[nslot]); else list_move_tail(&chunk->list, &pcpu_slot[nslot]); } } static int pcpu_chunk_slot(const struct pcpu_chunk *chunk) { //该chunk中的空闲空间小于sizeof(int),或者最大的空闲空间块小于sizeof(int),返回0 if (chunk->free_size < sizeof(int) || chunk->contig_hint < sizeof(int)) return 0; return pcpu_size_to_slot(chunk->free_size); } static int pcpu_size_to_slot(int size) { //若size等于每个cpu占用的percpu内存空间大小,返回最后一项pcpu_slot数组下标 if (size == pcpu_unit_size) return pcpu_nr_slots - 1; //否则根据size返回在pcpu_slot数组中的下标 return __pcpu_size_to_slot(size); } 四、每CPU变量提供的函数和宏 1.编译期间分配percpu,即分配静态percpu,函数原型: DEFINE_PER_CPU(type, name) #define DEFINE_PER_CPU(type, name) DEFINE_PER_CPU_SECTION(type, name, "") #define DEFINE_PER_CPU_SECTION(type, name, sec) \ __PCPU_ATTRS(sec) PER_CPU_DEF_ATTRIBUTES \ __typeof__(type) name #define __PCPU_ATTRS(sec) \ __percpu __attribute__((section(PER_CPU_BASE_SECTION sec))) \ PER_CPU_ATTRIBUTES #define PER_CPU_BASE_SECTION ".data..percpu" #define PER_CPU_ATTRIBUTES #define PER_CPU_DEF_ATTRIBUTES 根据以上宏定义展开之,可以得到 __attribute__((section(.data..percpu))) __typeof__(type) name 可见宏“DEFINE_PER_CPU(type, name)”的作用就是将类型为“type”的“name”变量放到“.data..percpu”数据段。 而在/include/asm-generic/vmlinux.lds.h中定义: 链接器会把所有静态定义的per-cpu变量统一放到".data..percpu" section中, 链接器生成__per_cpu_start和__per_cpu_end两个变量来表示该section的起始和结束地址, 为了配合链接器的行为, linux内核源码中针对以上链接脚本声明了外部变量 extern char __per_cpu_load[], __per_cpu_start[], __per_cpu_end[]; #define PERCPU_INPUT(cacheline) \ VMLINUX_SYMBOL(__per_cpu_start) = .; \ *(.data..percpu..first) \ . = ALIGN(PAGE_SIZE); \ *(.data..percpu..page_aligned) \ . = ALIGN(cacheline); \ *(.data..percpu..readmostly) \ . = ALIGN(cacheline); \ *(.data..percpu) \ *(.data..percpu..shared_aligned) \ VMLINUX_SYMBOL(__per_cpu_end) = .; #define PERCPU_VADDR(cacheline, vaddr, phdr) \ VMLINUX_SYMBOL(__per_cpu_load) = .; \ .data..percpu vaddr : AT(VMLINUX_SYMBOL(__per_cpu_load) \ - LOAD_OFFSET) { \ PERCPU_INPUT(cacheline) \ } phdr  \ . = VMLINUX_SYMBOL(__per_cpu_load) + SIZEOF(.data..percpu); 我们知道在系统对percpu初始化的时候,会将静态定义的percpu变量(内核映射".data.percpu"section中的变量数据)拷贝到每个cpu的percpu内存空间中,静态定义的percpu变量的起始地址为__per_cpu_load,即 memcpy(ptr, __per_cpu_load, ai->static_size); 2. 访问percpu变量  (1) per_cpu(var, cpu)获取编号cpu的处理器上面的变量var的副本 (2) get_cpu_var(var)获取本处理器上面的变量var的副本,该函数关闭进程抢占,主要由__get_cpu_var来完成具体的访问 (3) get_cpu_ptr(var) 获取本处理器上面的变量var的副本的指针,该函数关闭进程抢占,主要由__get_cpu_var来完成具体的访问 (4) put_cpu_var(var) & put_cpu_ptr(var)表示每CPU变量的访问结束,恢复进程抢占 (5) __get_cpu_var(var) 获取本处理器上面的变量var的副本,该函数不关闭进程抢占 注意:关闭内核抢占可确保在对per-cpu变量操作的临界区中, 当前进程不会被换出处理器, 在put_cpu_var中恢复内核调度器的可抢占性. //详细代码解析: (1) per_cpu #define per_cpu(var, cpu) (*SHIFT_PERCPU_PTR(&(var), per_cpu_offset(cpu))) #define per_cpu_offset(x) (__per_cpu_offset[x]) #define SHIFT_PERCPU_PTR(__p, __offset) ({  \ __verify_pcpu_ptr((__p)); \ RELOC_HIDE((typeof(*(__p)) __kernel __force *)(__p), (__offset)); \ }) #define RELOC_HIDE(ptr, off) \ ({ unsigned long __ptr; \ __ptr =  (unsigned long)  (ptr); \ (typeof(ptr)) (__ptr +  (off)); }) per_cpu(var, cpu)通过以上的宏展开,就是返回*(__per_cpu_offset[cpu]+&(var))的值。__per_cpu_offset数组记录每个cpu的percpu内存空间距离内核静态percpu内存区起始地址(即".data..percpu"段的起始地址__per_cpu_start)的偏移量,加上var在内核中的内存地址(因为是静态percpu变量,所以地址肯定在".data..percpu"段中),就得到var在该cpu下的percpu内存区的地址,取地址下的值即可得到该var变量的值。 (2) get_cpu_var/__get_cpu_var #define get_cpu_var(var) (*({ \ preempt_disable(); \ //关闭进程抢占 &__get_cpu_var(var); })) #define __get_cpu_var(var) (*this_cpu_ptr(&(var))) #define this_cpu_ptr(ptr) __this_cpu_ptr(ptr) #define __this_cpu_ptr(ptr) SHIFT_PERCPU_PTR(ptr, __my_cpu_offset) #define my_cpu_offset __my_cpu_offset #define __my_cpu_offset per_cpu_offset(raw_smp_processor_id()) #define per_cpu_offset(x) (__per_cpu_offset[x]) 通过一系列宏调用,最终函数还是通过*(__per_cpu_offset[raw_smp_processor_id()]+&(var))来获得本地处理器上的var变量的值。 (3) get_cpu_ptr #define get_cpu_ptr(var) ({  \ preempt_disable(); \ this_cpu_ptr(var); }) 获取本处理器上面的变量var的副本的指针,该函数关闭进程抢占. (4)put_cpu_ptr/put_cpu_var,恢复进程抢占 #define put_cpu_var(var) do {  \ (void)&(var); \ preempt_enable(); \ } while (0) #define put_cpu_ptr(var) do {  \ (void)(var); \ preempt_enable(); \ } while (0) 3.动态分配percpu空间:void  * alloc_percpu(type) #define alloc_percpu(type) \ (typeof(type) __percpu *)__alloc_percpu(sizeof(type), __alignof__(type)) void __percpu *__alloc_percpu(size_t size, size_t align) { return pcpu_alloc(size, align, false); } 3.1 动态分配percpu static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved) { static int warn_limit  = 10; struct pcpu_chunk *chunk; const char  *err; int slot, off, new_alloc; unsigned long flags; void __percpu *ptr; if (unlikely(!size || size  > PCPU_MIN_UNIT_SIZE || align > PAGE_SIZE)) { WARN(true, "illegal size (%zu) or align (%zu) for " "percpu allocation\n", size, align); return NULL; } mutex_lock(&pcpu_alloc_mutex); spin_lock_irqsave(&pcpu_lock, flags); //若指定reserved分配,则从pcpu_reserved_chunk进行 if (reserved && pcpu_reserved_chunk) { chunk = pcpu_reserved_chunk;//找到静态percpu的chunk //检查要分配的空间size是否超出该chunk的所具有的最大的空闲size if (size > chunk->contig_hint) { err  = "alloc from reserved chunk failed"; goto fail_unlock; } //检查是否要扩展chunk的的map数组,map数组默认设置为128项 while  ((new_alloc  = pcpu_need_to_extend(chunk))) { spin_unlock_irqrestore(&pcpu_lock, flags); //对map数组进行扩展 if  (pcpu_extend_area_map(chunk, new_alloc) < 0)  { err  = "failed to extend area map of reserved chunk"; goto fail_unlock_mutex; } spin_lock_irqsave(&pcpu_lock, flags); } //从该chunk分配出size大小的空间,返回该size空间在chunk中的偏移量off //然后重新将该chunk挂到slot数组对应链表中 off = pcpu_alloc_area(chunk, size, align); if (off >= 0) goto area_found; err = "alloc from reserved chunk failed"; goto fail_unlock; } restart: //根据需要分配内存块的大小索引slot数组找到对应链表 for (slot = pcpu_size_to_slot(size); slot < pcpu_nr_slots; slot++) { list_for_each_entry(chunk, &pcpu_slot[slot], list) { if  (size > chunk->contig_hint) //在该链表中进一步寻找符合尺寸要求的chunk continue; //chunck用数组map记录每次分配的内存块,若该数组项数用完(默认为128项), //但是若该chunk仍然还有空闲空间可分配,则需要增长该map数组项数来记录可分配的空间 new_alloc = pcpu_need_to_extend(chunk); if  (new_alloc)  { spin_unlock_irqrestore(&pcpu_lock, flags); //扩展map数组 if  (pcpu_extend_area_map(chunk,new_alloc) < 0)  { err  = "failed to extend area map"; goto fail_unlock_mutex; } spin_lock_irqsave(&pcpu_lock, flags); goto restart; } //从该chunk分配出size大小的空间,返回该size空间在chunk中的偏移量off //然后重新将该chunk挂到slot数组对应链表中 off = pcpu_alloc_area(chunk, size, align); if  (off >= 0) goto area_found; } } //到这里表示没有找到合适的chunk,需要重新创建一个新的chunk spin_unlock_irqrestore(&pcpu_lock, flags); //创建一个新的chunk,这里进行的是虚拟地址空间的分配 chunk = pcpu_create_chunk(); if (!chunk) { err = "failed to allocate new chunk"; goto fail_unlock_mutex; } spin_lock_irqsave(&pcpu_lock, flags); //把一个全新的chunk挂到slot数组对应链表中 pcpu_chunk_relocate(chunk, -1); goto restart; area_found: spin_unlock_irqrestore(&pcpu_lock, flags); //这里要检查该段区域对应物理页是否已经分配 if (pcpu_populate_chunk(chunk, off, size)) { spin_lock_irqsave(&pcpu_lock, flags); pcpu_free_area(chunk, off); err = "failed to populate"; goto fail_unlock; } mutex_unlock(&pcpu_alloc_mutex); /* #define __addr_to_pcpu_ptr(addr) \ (void __percpu  *)((unsigned long)(addr) - \ (unsigned long)pcpu_base_addr + \ (unsigned long)__per_cpu_start) */ //chunk->base_addr + off表示分配该size空间的起始percpu内存地址 //最终返回的地址即__per_cpu_start+off,即得到该动态分配percpu变量在内核镜像中的一个虚拟内存地址。 //实际上该动态分配percpu变量并不在此地址上,只是为了以后通过per_cpu(var, cpu)引用该变量时, //与静态percpu变量一致,因为静态percpu变量在内核镜像中是有分配内存虚拟地址的(在.data..percpu段中)。 //使用per_cpu(var, cpu)时,该动态分配percpu变量的内核镜像中的虚拟地址(假的地址,为了跟静态percpu变量一致),加上本cpu所在percpu空间与.data..percpu段的偏移量, //即得到该动态分配percpu变量在本cpu副本中的内存地址 ptr = __addr_to_pcpu_ptr(chunk->base_addr + off); kmemleak_alloc_percpu(ptr, size); return ptr; fail_unlock: spin_unlock_irqrestore(&pcpu_lock, flags); fail_unlock_mutex: mutex_unlock(&pcpu_alloc_mutex); if (warn_limit) { pr_warning("PERCPU: allocation failed, size=%zu align=%zu, ""%s\n", size, align, err); dump_stack(); if (!--warn_limit) pr_info("PERCPU: limit reached, disable warning\n"); } return NULL; } 3.1.1 检查chunk的map数组是否需要扩展 //#define PCPU_DFL_MAP_ALLOC 16 static int pcpu_need_to_extend(struct pcpu_chunk *chunk) { int new_alloc; //map_alloc默认设置为128,只有map_used记录超过126时才会进行map数组扩展 if (chunk->map_alloc >= chunk->map_used + 2) return 0; new_alloc = PCPU_DFL_MAP_ALLOC;//16 //计算该chunk的map数组新的大小,并返回 while (new_alloc < chunk->map_used + 2) new_alloc *= 2; return new_alloc; } 3.1.2 对map数组的大小进行扩展 static int pcpu_extend_area_map(struct pcpu_chunk *chunk,  int new_alloc) { int *old = NULL, *new =  NULL; size_t old_size = 0, new_size = new_alloc * sizeof(new[0]); unsigned long flags; //为新的map数组大小分配内存空间  new = pcpu_mem_zalloc(new_size); if (!new) return -ENOMEM; /* acquire pcpu_lock and switch to new area map */ spin_lock_irqsave(&pcpu_lock, flags); if (new_alloc <= chunk->map_alloc) goto out_unlock; old_size = chunk->map_alloc * sizeof(chunk->map[0]); old = chunk->map; //复制老的map数组信息到new memcpy(new, old, old_size); //重新设置map数组,完成map数组的扩展 chunk->map_alloc = new_alloc; chunk->map = new; new = NULL; out_unlock: spin_unlock_irqrestore(&pcpu_lock, flags); pcpu_mem_free(old, old_size); pcpu_mem_free(new, new_size); return 0; } 3.1.3 从chunk的map数组中分配size大小空间,返回该size的偏移值 static int pcpu_alloc_area(struct pcpu_chunk *chunk,  int size, int align) { int oslot  = pcpu_chunk_slot(chunk); int max_contig  = 0; int i, off; //遍历该chunk的map中记录的空间,map中负数为已经使用的空间,正数为可以分配使用的空间 for (i = 0, off  = 0; i < chunk->map_used; off += abs(chunk->map[i++])) { //is_last为1表示已经扫描了chunk中所有记录的空间,并且是最后一个map组项 bool is_last = i  + 1 == chunk->map_used; int head, tail; //对map项中记录的percpu空间大小进行对齐,可能会产生的一个偏移量head head = ALIGN(off, align) - off; BUG_ON(i  == 0 && head != 0); //map中记录的负数表示已经使用的percpu空间,继续下一个 if (chunk->map[i] < 0) continue; //若map中的空间大小小于要分配的空间大小,继续下一个 if (chunk->map[i] < head + size) { //更新该chunk中可使用的空间大小 max_contig = max(chunk->map[i], max_contig); continue; } //如果head不为0,并且head很小(小于sizeof(int)),或者前一个map的可用空间大于0(但是chunk->map[i - 1]  < head+size) //如果前一个map项>0,则将head合并到前一个map中 //如果前一个map项<0,则将head合并到前一个map,并且是负数,不可用空间,当前chunk空闲size减去这head大小的空间 if (head &&  (head < sizeof(int) || chunk->map[i - 1]  > 0)) { if  (chunk->map[i - 1]  > 0) chunk->map[i - 1]  += head; else  { chunk->map[i - 1]  -= head; chunk->free_size -= head; } //当前map减去已经与前一个map合并的head大小的空间 chunk->map[i] -= head; off += head;//偏移要加上head head = 0;//合并之后,head清零 } //计算要分配空间的尾部 tail = chunk->map[i] - head - size; if (tail < sizeof(int)) tail = 0; //如果head不为0,或者tail不为0,则要将当前map分割 if (head || tail) { pcpu_split_block(chunk, i, head, tail); //如果head不为0,tail不为0,经过split之后,map[i]记录head,map[i+1]记录要分配的size,map[i+2]记录tail。 if  (head) { i++; //移到记录要分配size空间的map项 off += head;//偏移要加上head,表示从head之后开始 //i-1表示head所在的那个map项,与max_contig比较大小,为下边更新chunk的最大空闲空间 max_contig = max(chunk->map[i - 1], max_contig); } //i+1表示tail所在的那个map项,比较与max_contig的大小,为下边更新chunk的最大空闲空间 if  (tail) max_contig = max(chunk->map[i + 1], max_contig); } //更新chunk的最大空闲空间 if (is_last) chunk->contig_hint = max_contig; /* fully scanned */ else chunk->contig_hint = max(chunk->contig_hint,max_contig); chunk->free_size -= chunk->map[i];//chunk中的空闲空间大小递减 chunk->map[i] = -chunk->map[i];//变成负数表示该map中的size大小已分配 //重新计算chunk在slot中的位置 pcpu_chunk_relocate(chunk, oslot); return off; } chunk->contig_hint = max_contig; /* fully scanned */ pcpu_chunk_relocate(chunk, oslot); /* tell the upper layer that this chunk has no matching area */ return -1; } 3.1.4 将map数组进行分割 static void pcpu_split_block(struct pcpu_chunk *chunk,  int i,int head, int tail) { //若head、tail都不为0,则要添加两个map,有一个不为0则添加一个map int nr_extra  = !!head + !!tail; BUG_ON(chunk->map_alloc < chunk->map_used + nr_extra); //首先将该当前要分割的map后边的数据拷贝 memmove(&chunk->map[i + nr_extra], &chunk->map[i],sizeof(chunk->map[0]) * (chunk->map_used - i)); chunk->map_used += nr_extra;//map数组的使用个数更新 //如果head不为0,则i+1的map项保存chunk->map[i] - head的大小,当前的map保存head的大小 if (head) { chunk->map[i + 1]  = chunk->map[i] - head; chunk->map[i++] = head; } //如果tail不为0,将记录(chunk->map[i] - head)大小的map项减去tail,即得到要分配size空间 //最后一个map保存剩余的tail大小 if (tail) { chunk->map[i++] -= tail;//得到size空间大小的map项 chunk->map[i] = tail; } } 五、结构图 参见附件

【作者】张昺华
【新浪微博】 张昺华--sky
【twitter】 @sky2030_
【facebook】 张昺华 zhangbinghua
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利.

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Linux 的 workqueue 机制浅析
## Intro workqueue 是 Linux 中非常重要的一种异步执行的机制,本文对该机制的各种概念,以及 work 的并行度进行分析,以帮助我们更好地**使用**这一机制;对 workqueue 机制并不陌生的读者也可以直接跳到第四节,即 "Concurrency" 小节,了解 workqueue 机制中 work 的并行度 以 v2.6.36 为界,workqueue 存在两个不
0 0
Linux workqueue工作原理 【转】
转自:http://blog.chinaunix.net/uid-21977330-id-3754719.html 转自:http://bgutech.blog.163.com/blog/static/18261124320116181119889/1. 什么是workqueue       Linux中的Workqueue机制就是为了简化内核线程的创建。
888 0
Linux内核通用队列的使用笔记(读linux内核设计与实现)
Linux内核通用队列实现 Kfifo位置:kernel/kififo.c使用需要包含头文件#include 1、创建队列(动态创建)int kfifo_alloc(struct kififo *fifo , unsigned int size , gfp_t gfp_mask);该函数会创建并初始化一个大小为size的fifo,内核使用gfp_mask标识分配队列。
721 0
linux core文件机制
在程序不寻常退出时,内核会在当前工作目录下生成一个core文件(是一个内存映像,同时加上调试信息)。使用gdb来查看core文件,可以指示出导致程序出错的代码所在文件和行数。 1.core文件的生成开关和大小限制--------------------------------- 1)使用ulimit -c命令可查看core文件的生成开关。
517 0
+关注
sky-heaven
我是一个技术爱好者,喜欢分享交流技术心得
文章
问答
文章排行榜
最热
最新
相关电子书
更多
从 Linux 系统内核层面来解决实际问题的实战经验
立即下载
从Linux系统内核层面来解决实际问题的实战经验
立即下载
Linux系统通过fail2ban对暴力破解进行防护
立即下载