现在的位置: 首页 > 综合 > 正文

linux percpu机制解析

2018年04月01日 ⁄ 综合 ⁄ 共 31988字 ⁄ 字号 小 中 大 ⁄ 评论关闭
  1. //based
    on Linux V3.14 source code
  2. 一、概述
  3. 每cpu变量是最简单也是最重要的同步技术。每cpu变量主要是数据结构数组，系统的每个cpu对应数组的一个元素。一个cpu不应该访问与其它cpu对应的数组元素，另外，它可以随意读或修改它自己的元素而不用担心出现竞争条件，因为它是唯一有资格这么做的cpu。这也意味着每cpu变量基本上只能在特殊情况下使用，也就是当它确定在系统的cpu上的数据在逻辑上是独立的时候。
  5. 每个处理器访问自己的副本，无需加锁，可以放入自己的cache中，极大地提高了访问与更新效率。常用于计数器。
  7. 二、相关结构体：
  8. 1.整体的percpu内存管理信息被收集在struct pcpu_alloc_info结构中
  9. struct pcpu_alloc_info {
  10.     size_t static_size;    //静态定义的percpu变量占用内存区域长度
  11.     size_t reserved_size;    //预留区域，在percpu内存分配指定为预留区域分配时，将使用该区域
  12.     size_t dyn_size;        //动态分配的percpu变量占用内存区域长度
  13.     //每个cpu的percpu空间所占得内存空间为一个unit, 每个unit的大小记为unit_size
  14.     size_t unit_size;        //每颗处理器的percpu虚拟内存递进基本单位
  15.     size_t atom_size;        //PAGE_SIZE
  16.     size_t alloc_size;        //要分配的percpu内存空间
  17.     size_t __ai_size;        //整个pcpu_alloc_info结构体的大小
  18.     int nr_groups;        //该架构下的处理器分组数目
  19.     struct pcpu_group_info groups[];        //该架构下的处理器分组信息
  20. };
  22. 2.对于处理器的分组信息，内核使用struct pcpu_group_info结构表示
  23. struct pcpu_group_info {
  24.     int nr_units;
    //该组的处理器数目
  25.     //组的percpu内存地址起始地址，即组内处理器数目×处理器percpu虚拟内存递进基本单位
  26.     unsigned long base_offset;
  27.     unsigned int
    *    cpu_map; //组内cpu对应数组，保存cpu id号
  28. };
  30. 3.内核使用pcpu_chunk结构管理percpu内存
  31. struct pcpu_chunk {
  32.     //用来把chunk链接起来形成链表。每一个链表又都放到pcpu_slot数组中，根据chunk中空闲空间的大小决定放到数组的哪个元素中。
  33.     struct list_head list;
  34.     int free_size;
    //chunk中的空闲大小
  35.     int contig_hint;
    //该chunk中最大的可用空间的map项的size
  36.     void *base_addr;
    //percpu内存开始基地值
  37.     int map_used;
    //该chunk中使用了多少个map项
  38.     int map_alloc;
    //记录map数组的项数，为PERCPU_DYNAMIC_EARLY_SLOTS=128
  39.     //若map项>0,表示该map中记录的size是可以用来分配percpu空间的。
  40.     //若map项<0,表示该map项中的size已经被分配使用。
  41.     int *map;
    //map数组，记录该chunk的空间使用情况
  42.     void *data;
    //chunk data
  43.     bool immutable;
    /    * no [de]population allowed
    */
  44.     unsigned long populated[];
    /* populated bitmap
    */
  45. };
  47. 三、per-cpu初始化
  48. 在系统初始化期间，start_kernel()函数中调用setup_per_cpu_areas()函数，用于为每个cpu的per-cpu变量副本分配空间，注意这时alloc内存分配器还没建立起来，该函数调用alloc_bootmem函数为初始化期间的这些变量副本分配物理空间。
  50. 在建立percpu内存管理机制之前要整理出该架构下的处理器信息，包括处理器如何分组、每组对应的处理器位图、静态定义的percpu变量占用内存区域、每颗处理器percpu虚拟内存递进基本单位等信息。
  52. 1.setup_per_cpu_areas()函数，用于为每个cpu的per-cpu变量副本分配空间
  53. void __init setup_per_cpu_areas(void)
  54. {
  55.     unsigned long delta;
  56.     unsigned int cpu;
  57.     int rc;
  58.     
  59.     //为percpu建立第一个chunk
  60.     rc = pcpu_embed_first_chunk(PERCPU_MODULE_RESERVE,
  61.                                 PERCPU_DYNAMIC_RESERVE, PAGE_SIZE,
    NULL,
  62.                                 pcpu_dfl_fc_alloc, pcpu_dfl_fc_free);
  63.     if (rc
    < 0)
  64.         panic("Failed to initialize percpu areas.");
  65.     
  66.     //内核为percpu分配了一大段空间，在整个percpu空间中根据cpu个数将percpu的空间分为不同的unit。
  67.     //而pcpu_base_addr表示整个系统中percpu的起始内存地址.
  68.     //__per_cpu_start表示静态分配的percpu起始地址。即节区".data..percpu"中起始地址。
  69.     //函数首先算出副本空间首地址(pcpu_base_addr)与".data..percpu"section首地址(__per_cpu_start)之间的偏移量delta
  70.     delta = (unsigned long)pcpu_base_addr
    - (unsigned long)__per_cpu_start;
  72.     //遍历系统中的cpu，设置每个cpu的__per_cpu_offset指针
  73.     //pcpu_unit_offsets[cpu]保存对应cpu所在副本空间相对于pcpu_base_addr的偏移量
  74.     //加上delta，这样就可以得到每个cpu的per-cpu变量副本的偏移量, 放在__per_cpu_offset数组中.
  75.     for_each_possible_cpu(cpu)
  76.         __per_cpu_offset[cpu]
    = delta + pcpu_unit_offsets[cpu];
  77. }
  79. 1.1 为percpu建立第一个chunk
  80. int __init pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size,
  81.                                     size_t atom_size,
  82.                                     pcpu_fc_cpu_distance_fn_t cpu_distance_fn,
  83.                                     pcpu_fc_alloc_fn_t alloc_fn,
  84.                                     pcpu_fc_free_fn_t free_fn)
  85. {
  86.     void *base
    =     (void *)ULONG_MAX;
  87.     void **areas
    = NULL;
  88.     struct pcpu_alloc_info *ai;
  89.     size_t size_sum, areas_size, max_distance;
  90.     int group, i, rc;
  91.     
  92.     //收集整理该架构下的percpu信息，结果放在struct pcpu_alloc_info结构中
  93.     ai = pcpu_build_alloc_info(reserved_size, dyn_size, atom_size,cpu_distance_fn);
  94.     if (IS_ERR(ai))
  95.         return PTR_ERR(ai);
  96.     
  97.     //计算每个cpu占用的percpu内存空间大小，包括静态定义变量占用空间+reserved空间+动态分配空间
  98.     size_sum = ai->static_size
    + ai->reserved_size
    + ai->dyn_size;
  99.     
  100.     //areas用来保存每个group的percpu内存起始地址，为其分配空间，做临时存储使用，用完释放掉
  101.     areas_size = PFN_ALIGN(ai->nr_groups
    * sizeof(void
    *));    
  102.     areas = memblock_virt_alloc_nopanic(areas_size, 0);
  103.     if (!areas)
    {
  104.         rc = -ENOMEM;
  105.         goto out_free;
  106.     }
  107.     
  108.     //针对该系统下的每个group操作，为每个group分配percpu内存区域，前边只是计算出percpu信息，并没有分配percpu的内存空间。
  109.     for (group
    = 0; group
    <     ai->nr_groups; group++)
    {
  110.         struct pcpu_group_info *gi
    =     &ai->groups[group];//取出该group下的组信息
  111.         unsigned int cpu
    =     NR_CPUS;
  112.         void *ptr;
  113.     
  114.         //检查cpu_map数组
  115.         for (i
    = 0; i
    <     gi->nr_units
    && cpu
    =    = NR_CPUS; i++)
  116.             cpu = gi->cpu_map[i];
  117.         BUG_ON(cpu
    =    = NR_CPUS);
  118.  
  119.         //为该group分配percpu内存区域。长度为该group里的cpu数目X每颗处理器的percpu递进单位。
  120.         //函数pcpu_dfl_fc_alloc是从bootmem里取得内存，得到的是物理内存，返回物理地址的内存虚拟地址ptr
  121.         ptr = alloc_fn(cpu, gi->nr_units
    * ai->unit_size, atom_size);
  122.         if (!ptr)
    {
  123.             rc =
    -    ENOMEM;
  124.             goto out_free_areas;
  125.         }
  126.         /* kmemleak tracks the percpu allocations separately
    */
  127.         kmemleak_free(ptr);
  128.         //将分配到的改组percpu内存虚拟起始地址保存在areas数组中
  129.         areas[group]
    = ptr;
  130.          
  131.         //比较每个group的percpu内存地址，保存最小的内存地址，即percpu内存的起始地址
  132.         //为后边计算group的percpu内存地址的偏移量
  133.         base = min(ptr, base);
  134.     }
  135.     
  136.     //为每个group中的每个cpu建立其percpu区域
  137.     for (group
    = 0; group
    <     ai->nr_groups; group++)
    {
  138.         //取出该group下的组信息
  139.         struct pcpu_group_info *gi
    =     &ai->groups[group];
  140.         void *ptr
    =     areas[group];//得到该group的percpu内存起始地址
  141.          
  142.         //遍历该组中的cpu，并得到每个cpu对应的percpu内存地址
  143.         for (i
    = 0; i
    <     gi->nr_units; i++, ptr
    += ai->unit_size)
    {
  144.             if
    (    gi->cpu_map[i]
    == NR_CPUS)
    {
  145.                 free_fn(ptr, ai->unit_size);//释放掉未使用的unit
  146.                 continue;
  147.             }
  149.             //将静态定义的percpu变量拷贝到每个cpu的percpu内存起始地址
  150.             memcpy(ptr, __per_cpu_load, ai->static_size);
  151.             //为每个cpu释放掉多余的空间，多余的空间是指ai->unit_size减去静态定义变量占用空间+reserved空间+动态分配空间
  152.             free_fn(ptr
    +     size_sum, ai->unit_size
    - size_sum);
  153.         }
  154.     }
  155.  
  156.     //计算group的percpu内存地址的偏移量
  157.     max_distance = 0;
  158.     for (group
    = 0; group
    <     ai->nr_groups; group++)
    {
  159.         ai->groups[group].base_offset
    = areas[group]
    - base;
  160.         max_distance = max_t(size_t, max_distance,ai->groups[group].base_offset);
  161.     }
  163.     //检查最大偏移量是否超过vmalloc空间的75%
  164.     max_distance += ai->unit_size;    
  165.     if (max_distance
    > VMALLOC_TOTAL * 3
    / 4)
    {
  166.         pr_warning("PERCPU: max_distance=0x%zx too large for vmalloc "
  167.                     "space 0x%lx\n", max_distance,VMALLOC_TOTAL);
  168.     }
  169.     
  170.     pr_info("PERCPU: Embedded %zu pages/cpu @%p s%zu r%zu d%zu u%zu\n",
  171.             PFN_DOWN(size_sum), base, ai->static_size,
    ai->reserved_size,
  172.             ai->dyn_size, ai->unit_size);
  174.     //为percpu建立第一个chunk
  175.     rc = pcpu_setup_first_chunk(ai, base);
  176.     goto out_free;
  177.     
  178. out_free_areas:
  179.     for (group
    = 0; group
    <     ai->nr_groups; group++)
  180.         if (areas[group])
  181.             free_fn(areas[group],ai->groups[group].nr_units
    * ai->unit_size);
  182. out_free:
  183.     pcpu_free_alloc_info(ai);
  184.     if (areas)
  185.         memblock_free_early(__pa(areas), areas_size);
  186.     return rc;
  187. }
  189. 1.1.1 收集整理该架构下的percpu信息
  190. static struct pcpu_alloc_info * __init pcpu_build_alloc_info(size_t reserved_size, size_t dyn_size,
  191.                                     size_t atom_size,pcpu_fc_cpu_distance_fn_t cpu_distance_fn)
  192. {
  193.     static int group_map[NR_CPUS] __initdata;
  194.     static int group_cnt[NR_CPUS] __initdata;
  195.     const size_t static_size
    =     __per_cpu_end - __per_cpu_start;
  196.     int nr_groups
    =     1, nr_units
    =     0;
  197.     size_t size_sum, min_unit_size, alloc_size;
  198.     int upa, max_upa, uninitialized_var(best_upa);
    /* units_per_alloc
    */
  199.     int last_allocs, group, unit;
  200.     unsigned int cpu, tcpu;
  201.     struct pcpu_alloc_info *ai;
  202.     unsigned int
    *    cpu_map;
  203.     
  204.     /* this
    function may be called multiple times
    *    /
  205.     memset(group_map, 0, sizeof(group_map));
  206.     memset(group_cnt, 0, sizeof(group_cnt));
  207.     
  208.     //计算每个cpu所占有的percpu空间大小，包括静态空间+保留空间+动态空间
  209.     size_sum = PFN_ALIGN(static_size
    + reserved_size +
  210.                         max_t(size_t, dyn_size, PERCPU_DYNAMIC_EARLY_SIZE));
  211.     //重新计算动态分配的percpu空间大小
  212.     dyn_size = size_sum
    -     static_size - reserved_size;
  213.  
  214.     //计算每个unit的大小，即每个group中的每个cpu占用的percpu内存大小为一个unit
  215.     min_unit_size = max_t(size_t, size_sum, PCPU_MIN_UNIT_SIZE);
  216.     //atom_size为PAGE_SIZE，即4K.将min_unit_size按4K向上舍入，例如min_unit_size=5k，则alloc_size为两个页面大小即8K，若min_unit_size=9k，则alloc_size为三个页面大小即12K
  217.     alloc_size = roundup(min_unit_size, atom_size);
  218.     upa = alloc_size
    /     min_unit_size;
  219.     while (alloc_size
    % upa ||
    ((alloc_size
    / upa)
    &     ~PAGE_MASK))
  220.         upa--;
  221.     max_upa = upa;
  222.     
  223.     //为cpu分组，将接近的cpu分到一组中，因为没有定义cpu_distance_fn函数体，所以所有的cpu分到一个组中。
  224.     //可以得到所有的cpu都是group=0，group_cnt[0]即是该组中的cpu个数
  225.     for_each_possible_cpu(cpu)
    {
  226.         group = 0;
  227. next_group:
  228.         for_each_possible_cpu(tcpu)
    {
  229.             if
    (    cpu == tcpu)
  230.                 break;
  231.             //cpu_distance_fn=NULL
  232.             if
    (    group_map[tcpu]
    == group
    &    & cpu_distance_fn
    &    &
  233.                 (cpu_distance_fn(cpu, tcpu)
    > LOCAL_DISTANCE ||
  234.                 cpu_distance_fn(tcpu, cpu)
    > LOCAL_DISTANCE))
    {
  235.                     group++;
  236.                     nr_groups = max(nr_groups, group
    + 1);
  237.                     goto next_group;
  238.                 }
  239.         }
  240.         group_map[cpu]
    = group;
  241.         group_cnt[group]++;
  242.     }
  243.      
  244.     /*
  245.     * Expand unit size
    until     address space usage goes over 75%
  246.     * and
    then as much as possible without using more address
  247.     * space.
  248.     */
  249.     last_allocs = INT_MAX;
  250.     for (upa
    = max_upa; upa; upa--)
    {
  251.         int allocs
    =     0, wasted
    =     0;
  252.     
  253.         if (alloc_size
    % upa ||
    ((alloc_size
    / upa)
    &     ~PAGE_MASK))
  254.             continue;
  255.     
  256.         for (group
    = 0; group
    <     nr_groups; group++)
    {
  257.             int this_allocs
    =     DIV_ROUND_UP(group_cnt[group], upa);
  258.             allocs += this_allocs;
  259.             wasted += this_allocs
    * upa - group_cnt[group];
  260.         }
  261.     
  262.         /*
  263.             * Don't accept
    if wastage is over 1/3. The
  264.             * greater-than comparison ensures upa==1 always
  265.             * passes the following check.
  266.         */
  267.         if (wasted
    > num_possible_cpus()
    / 3)
  268.             continue;
  269.     
  270.         /*
    and then don't consume more memory
    */
  271.         if (allocs
    > last_allocs)
  272.             break;
  273.         last_allocs = allocs;
  274.         best_upa = upa;
  275.     }
  276.     upa = best_upa;
  277.     
  278.     //计算每个group中的cpu个数
  279.     for (group
    = 0; group
    <     nr_groups; group++)
  280.         nr_units += roundup(group_cnt[group],
    upa);
  281.     
  282.     //分配pcpu_alloc_info结构空间，并初始化
  283.     ai = pcpu_alloc_alloc_info(nr_groups, nr_units);
  284.     if (!ai)
  285.         return ERR_PTR(-ENOMEM);
  286.     
  287.     //为每个group的cpu_map指针赋值为group[0]，group[0]中的cpu_map中的值初始化为NR_CPUS
  288.     cpu_map = ai->groups[0].cpu_map;
  289.     for (group
    = 0; group
    <     nr_groups; group++)
    {
  290.         ai->groups[group].cpu_map
    = cpu_map;
  291.         cpu_map += roundup(group_cnt[group],
    upa);
  292.     }
  293.     
  294.     ai->static_size
    = static_size;
    //静态percpu变量空间
  295.     ai->reserved_size
    = reserved_size;//保留percpu变量空间
  296.     ai->dyn_size
    = dyn_size;
    //动态分配的percpu变量空间
  297.     ai->unit_size
    = alloc_size / upa;
    //每个cpu占用的percpu变量空间
  298.     ai->atom_size
    = atom_size;
    //PAGE_SIZE
  299.     ai->alloc_size
    = alloc_size;
    //实际分配的空间
  300.     
  301.     for (group
    = 0, unit
    =     0; group_cnt[group]; group++)
    {
  302.         struct pcpu_group_info *gi
    =     &ai->groups[group];
  303.         //设置组内的相对于0地址偏移量，后边会设置真正的对于percpu起始地址的偏移量
  304.         gi->base_offset
    = unit * ai->unit_size;
  305.          //设置cpu_map数组，数组保存该组中的cpu id号。以及设置组中的cpu个数gi->nr_units
  306.         //gi->nr_units=0,cpu=0
  307.         //gi->nr_units=1,cpu=1
  308.         //gi->nr_units=2,cpu=2
  309.         //gi->nr_units=3,cpu=3
  310.         for_each_possible_cpu(cpu)
  311.             if
    (    group_map[cpu]
    == group)
  312.                 gi->cpu_map[gi->nr_units++]
    = cpu;
  313.         gi->nr_units
    = roundup(gi->nr_units, upa);
  314.         unit += gi->nr_units;
  315.     }
  316.     BUG_ON(unit
    !    = nr_units);
  317.         
  318.     return ai;
  319. }
  321. 1.1.1.1 分配pcpu_alloc_info结构，并初始化
  322. struct pcpu_alloc_info * __init pcpu_alloc_alloc_info(int nr_groups,int nr_units)
  323. {
  324.     struct pcpu_alloc_info *ai;
  325.     size_t base_size, ai_size;
  326.     void *ptr;
  327.     int unit;
  328.     
  329.     //根据group数以及，group[0]中cpu个数确定pcpu_alloc_info结构体大小ai_size
  330.     base_size = ALIGN(sizeof(*ai)
    + nr_groups * sizeof(ai->groups[0]),
  331.                 __alignof__(ai->groups[0].cpu_map[0]));
  333.     ai_size = base_size
    +     nr_units * sizeof(ai->groups[0].cpu_map[0]);
  334.     
  335.     //分配空间
  336.     ptr = memblock_virt_alloc_nopanic(PFN_ALIGN(ai_size), 0);
  337.     if (!ptr)
  338.         return NULL;
  339.     ai = ptr;
  340.     ptr += base_size;//指针指向group的cpu_map数组地址处
  341.     
  342.     ai->groups[0].cpu_map
    = ptr;
  343.     
  344.     //初始化group[0]的cpu_map数组值为NR_CPUS
  345.     for (unit
    = 0; unit
    <     nr_units; unit++)
  346.         ai->groups[0].cpu_map[unit]
    = NR_CPUS;
  347.     
  348.     ai->nr_groups
    = nr_groups;//group个数
  349.     ai->__ai_size
    = PFN_ALIGN(ai_size);//整个pcpu_alloc_info结构体的大小
  350.     
  351.     return ai;
  352. }
  354. 1.1.2 为percpu建立第一个chunk
  355. int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info
    *ai,void
    *    base_addr)
  356. {
  357.     static char cpus_buf[4096] __initdata;
  358.     static int smap[PERCPU_DYNAMIC_EARLY_SLOTS] __initdata;
  359.     static int dmap[PERCPU_DYNAMIC_EARLY_SLOTS] __initdata;
  360.     size_t dyn_size = ai->dyn_size;
  361.     size_t size_sum = ai->static_size
    + ai->reserved_size
    + dyn_size;
  362.     struct pcpu_chunk *schunk,
    *dchunk =
    NULL    ;
  363.     unsigned long *group_offsets;
  364.     size_t *group_sizes;
  365.     unsigned long *unit_off;
  366.     unsigned int cpu;
  367.     int *unit_map;
  368.     int group, unit, i;
  369.     
  370.     cpumask_scnprintf(cpus_buf, sizeof(cpus_buf), cpu_possible_mask);
  371.     
  372. #define PCPU_SETUP_BUG_ON(cond)
    do {
    \
  373.         if (unlikely(cond))
    { \
  374.             pr_emerg("PERCPU: failed to initialize, %s", #cond);
    \
  375.             pr_emerg("PERCPU: cpu_possible_mask=%s\n", cpus_buf);
    \
  376.             pcpu_dump_alloc_info(KERN_EMERG, ai);
    \
  377.             BUG();
    \
  378.         } \
  379.     } while
    (0)
  380.     
  381.     //健康检查
  382.     PCPU_SETUP_BUG_ON(ai->nr_groups
    <= 0);
  383. #ifdef CONFIG_SMP
  384.     PCPU_SETUP_BUG_ON(!ai->static_size);
  385.     PCPU_SETUP_BUG_ON((unsigned long)__per_cpu_start
    & ~PAGE_MASK);
  386. #endif
  387.     PCPU_SETUP_BUG_ON(!base_addr);
  388.     PCPU_SETUP_BUG_ON((unsigned long)base_addr
    & ~PAGE_MASK);
  389.     PCPU_SETUP_BUG_ON(ai->unit_size
    < size_sum);
  390.     PCPU_SETUP_BUG_ON(ai->unit_size
    & ~PAGE_MASK);
  391.     PCPU_SETUP_BUG_ON(ai->unit_size
    < PCPU_MIN_UNIT_SIZE);
  392.     PCPU_SETUP_BUG_ON(ai->dyn_size
    < PERCPU_DYNAMIC_EARLY_SIZE);
  393.     PCPU_SETUP_BUG_ON(pcpu_verify_alloc_info(ai)
    < 0);
  394.     
  395.     //为group相关percpu信息保存数组分配空间
  396.     group_offsets = memblock_virt_alloc(ai->nr_groups
    *sizeof(group_offsets[0]), 0);
  397.     group_sizes = memblock_virt_alloc(ai->nr_groups
    *sizeof(group_sizes[0]), 0);
  398.     //为每个cpu相关percpu信息保存数组分配空间
  399.     unit_map = memblock_virt_alloc(nr_cpu_ids
    * sizeof(unit_map[0]), 0);
  400.     unit_off = memblock_virt_alloc(nr_cpu_ids
    * sizeof(unit_off[0]), 0);
  401.     
  402.     //对unit_map、pcpu_low_unit_cpu和pcpu_high_unit_cpu变量初始化
  403.     for (cpu
    = 0; cpu
    <     nr_cpu_ids; cpu++)
  404.         unit_map[cpu]
    = UINT_MAX;    
  405.     pcpu_low_unit_cpu = NR_CPUS;
  406.     pcpu_high_unit_cpu = NR_CPUS;
  407.     
  408.     //遍历每一group的每一个cpu
  409.     for (group
    = 0, unit
    =     0; group
    <     ai->nr_groups; group++, unit
    += i)
    {
  410.         const struct pcpu_group_info
    *    gi = &ai->groups[group];
  411.         //取得该组处理器的percpu内存空间的偏移量
  412.         group_offsets[group]
    = gi->base_offset;
  413.         //取得该组处理器的percpu内存空间占用的虚拟地址空间大小，即包含改组中每个cpu所占的percpu空间
  414.         group_sizes[group]
    = gi->nr_units
    * ai->unit_size;
  415.         //遍历该group中的cpu
  416.         for (i
    = 0; i
    <     gi->nr_units; i++)
    {
  417.             cpu = gi->cpu_map[i];//得到该group中的cpu
    id号
  418.             if
    (    cpu == NR_CPUS)
  419.                 continue;
  420.     
  421.             PCPU_SETUP_BUG_ON(cpu
    >     nr_cpu_ids);
  422.             PCPU_SETUP_BUG_ON(!cpu_possible(cpu));
  423.             PCPU_SETUP_BUG_ON(unit_map[cpu]
    != UINT_MAX);
  424.              
  425.             //计算每个cpu的跨group的编号，保存在unit_map数组中
  426.             unit_map[cpu]
    = unit + i;
  427.             //计算每个cpu的在整个系统percpu内存空间中的偏移量，保存到数组unit_off中
  428.             unit_off[cpu]
    = gi->base_offset
    + i * ai->unit_size;
  429.     
  430.             /* determine low/high unit_cpu
    */
  431.             if
    (    pcpu_low_unit_cpu == NR_CPUS
    || unit_off[cpu]
    < unit_off[pcpu_low_unit_cpu])
  432.                 pcpu_low_unit_cpu = cpu;
  433.             if
    (    pcpu_high_unit_cpu == NR_CPUS
    || unit_off[cpu]
    > unit_off[pcpu_high_unit_cpu])
  434.                 pcpu_high_unit_cpu = cpu;
  435.         }
  436.     }
  437.     //pcpu_nr_units变量保存系统中有多少个cpu的percpu内存空间
  438.     pcpu_nr_units = unit;
  439.     
  440.     for_each_possible_cpu(cpu)
  441.         PCPU_SETUP_BUG_ON(unit_map[cpu]
    == UINT_MAX);
  442.     
  443. #undef PCPU_SETUP_BUG_ON
  444.     pcpu_dump_alloc_info(KERN_DEBUG, ai);
  446.     //记录下全局参数，留在pcpu_alloc时使用
  447.     pcpu_nr_groups = ai->nr_groups;//系统中group数量
  448.     pcpu_group_offsets = group_offsets;//记录每个group的percpu内存偏移量数组
  449.     pcpu_group_sizes = group_sizes;//记录每个group的percpu内存空间大小数组
  450.     pcpu_unit_map = unit_map;//整个系统中cpu(跨group)的编号数组
  451.     pcpu_unit_offsets = unit_off;//每个cpu的percpu内存空间偏移量
  452.     pcpu_unit_pages = ai->unit_size
    >> PAGE_SHIFT;//每个cpu的percpu内存虚拟空间所占的页面数量
  453.     pcpu_unit_size = pcpu_unit_pages
    <    < PAGE_SHIFT;//每个cpu的percpu内存虚拟空间大小
  454.     pcpu_atom_size = ai->atom_size;//PAGE_SIZE
  456.     //计算pcpu_chunk结构的大小，加上populated域的大小
  457.     pcpu_chunk_struct_size = sizeof(struct pcpu_chunk)
    +
  458.                             BITS_TO_LONGS(pcpu_unit_pages)
    * sizeof(unsigned long);
  459.     
  460.     //计算pcpu_nr_slots，即pcpu_slot数组的组项数量
  461.     pcpu_nr_slots = __pcpu_size_to_slot(pcpu_unit_size)
    + 2;
  462.     //为pcpu_slot数组分配空间，不同size的chunck挂在不同“pcpu_slot”项目中
  463.     pcpu_slot = memblock_virt_alloc(pcpu_nr_slots
    * sizeof(pcpu_slot[0]), 0);
  464.     for (i
    = 0; i
    <     pcpu_nr_slots; i++)
  465.         INIT_LIST_HEAD(&pcpu_slot[i]);
  466.     
  467.     //构建静态chunck,即pcpu_reserved_chunk
  468.     schunk = memblock_virt_alloc(pcpu_chunk_struct_size, 0);
  469.     INIT_LIST_HEAD(&schunk->list);
  470.     schunk->base_addr
    = base_addr;//整个系统中percpu内存的起始地址
  471.     schunk->map
    = smap;//初始化为一个静态数组
  472.     schunk->map_alloc
    = ARRAY_SIZE(smap);//PERCPU_DYNAMIC_EARLY_SLOTS=128
  473.     schunk->immutable
    = true;
  474.     //物理内存已经分配这里标志之
  475.     //若pcpu_unit_pages=8即每个cpu占用的percpu空间为8页的空间，则populated域被设置为0xff
  476.     bitmap_fill(schunk->populated, pcpu_unit_pages);
  477.     
  478.     if (ai->reserved_size)
    {
  479.         //如果存在percpu保留空间，在指定reserved分配时作为空闲空间使用
  480.         schunk->free_size
    = ai->reserved_size;            
  481.         pcpu_reserved_chunk = schunk;
  482.         //静态chunk的大小限制包括，定义的静态变量的空间+保留的空间
  483.         pcpu_reserved_chunk_limit = ai->static_size
    + ai->reserved_size;
  484.     } else
    {
  485.         //若不存在保留空间，则将动态分配空间作为空闲空间使用
  486.         schunk->free_size
    = dyn_size;
  487.         dyn_size = 0;//覆盖掉动态分配空间
  488.     }
  490.     //记录静态chunk中空闲可使用的percpu空间大小
  491.     schunk->contig_hint
    = schunk->free_size;
  492.     //map数组保存空间的使用情况，负数为已使用的空间，正数表示为以后可以分配的空间
  493.     //map_used记录chunk中存在几个map项
  494.     schunk->map[schunk->map_used++]
    = -ai->static_size;
  495.     if (schunk->free_size)
  496.         schunk->map[schunk->map_used++]
    = schunk->free_size;
  497.     
  498.     //构建动态chunk分配空间
  499.     if (dyn_size)
    {
  500.         dchunk = memblock_virt_alloc(pcpu_chunk_struct_size, 0);
  501.         INIT_LIST_HEAD(&dchunk->list);
  502.         dchunk->base_addr
    = base_addr;//整个系统中percpu内存的起始地址
  503.         dchunk->map
    = dmap;//初始化为一个静态数组
  504.         dchunk->map_alloc
    = ARRAY_SIZE(dmap);//PERCPU_DYNAMIC_EARLY_SLOTS=128
  505.         dchunk->immutable
    = true;
  506.         //记录下来分配的物理页
  507.         bitmap_fill(dchunk->populated, pcpu_unit_pages);
  508.          //设置动态chunk中的空闲可分配空间大小
  509.         dchunk->contig_hint
    = dchunk->free_size
    = dyn_size;
  510.         //map数组保存空间的使用情况，负数为已使用的空间（静态变量空间和reserved空间），正数表示为以后可以分配的空间
  511.         dchunk->map[dchunk->map_used++]
    = -pcpu_reserved_chunk_limit;
  512.         dchunk->map[dchunk->map_used++]
    = dchunk->free_size;
  513.     }
  514.     
  515.     //把第一个chunk链接进对应的slot链表，reserverd的空间有自己单独的chunk：pcpu_reserved_chunk
  516.     pcpu_first_chunk = dchunk
    ?    : schunk;
  517.     pcpu_chunk_relocate(pcpu_first_chunk,
    -1);
  518.  
  519.     //pcpu_base_addr记录整个系统中percpu内存的起始地址
  520.     pcpu_base_addr = base_addr;
  521.     return 0;
  522. }
  524. //fls找到size中最高的置1的位，返回该位号
  525. //例：fls(0)
    = 0, fls(1)
    = 1, fls(0x80000000)
    = 32.
  526. //若size=32768=0x8000，则fls(32768)=16
  527. //若highbit=0-4，则slot个数均为1
  528. #define PCPU_SLOT_BASE_SHIFT    5
  529. static int __pcpu_size_to_slot(int size)
  530. {
  531.     int highbit
    =     fls(size);
  532.     return max(highbit
    -     PCPU_SLOT_BASE_SHIFT + 2, 1);
  533. }
  535. static void pcpu_chunk_relocate(struct pcpu_chunk
    *chunk,
    int     oslot)
  536. {
  537.     //返回该chunk对应的要挂入的slot数组的下标
  538.     int nslot
    =     pcpu_chunk_slot(chunk);
  539.         
  540.     //静态chunk不需挂入pcpu_slot数组中
  541.     if (chunk
    != pcpu_reserved_chunk
    && oslot
    !    = nslot)
    {
  542.         if (oslot
    < nslot)
  543.             list_move(&chunk->list,
    &pcpu_slot[nslot]);
  544.         else
  545.             list_move_tail(&chunk->list,
    &pcpu_slot[nslot]);
  546.     }
  547. }
  549. static int pcpu_chunk_slot(const struct pcpu_chunk
    *chunk)
  550. {
  551.     //该chunk中的空闲空间小于sizeof(int)，或者最大的空闲空间块小于sizeof(int)，返回0
  552.     if (chunk->free_size
    < sizeof(int)
    || chunk->contig_hint
    < sizeof(int))
  553.         return 0;
  554.  
  555.     return pcpu_size_to_slot(chunk->free_size);
  556. }
  558. static int pcpu_size_to_slot(int size)
  559. {
  560.     //若size等于每个cpu占用的percpu内存空间大小，返回最后一项pcpu_slot数组下标
  561.     if (size
    == pcpu_unit_size)
  562.         return pcpu_nr_slots - 1;
  563.     
  564.     //否则根据size返回在pcpu_slot数组中的下标
  565.     return __pcpu_size_to_slot(size);
  566. }
  569. 四、每CPU变量提供的函数和宏
  570. 1.编译期间分配percpu，即分配静态percpu，函数原型:
  571. DEFINE_PER_CPU(type, name)
  573. #define DEFINE_PER_CPU(type, name) DEFINE_PER_CPU_SECTION(type, name,
    "")
  575. #define DEFINE_PER_CPU_SECTION(type, name, sec)
    \
  576.         __PCPU_ATTRS(sec) PER_CPU_DEF_ATTRIBUTES
    \
  577.         __typeof__(type) name
  579. #define __PCPU_ATTRS(sec)
    \
  580.         __percpu __attribute__((section(PER_CPU_BASE_SECTION sec)))
    \
  581.         PER_CPU_ATTRIBUTES
  583. #define PER_CPU_BASE_SECTION ".data..percpu"
  584. #define PER_CPU_ATTRIBUTES
  585. #define PER_CPU_DEF_ATTRIBUTES
  587. 根据以上宏定义展开之，可以得到
  588. __attribute__((section(.data..percpu)))
    __typeof__(type) name
  589. 可见宏“DEFINE_PER_CPU(type, name)”的作用就是将类型为“type”的“name”变量放到“.data..percpu”数据段。
  590. 而在/include/asm-generic/vmlinux.lds.h中定义：
  591. 链接器会把所有静态定义的per-cpu变量统一放到".data..percpu" section中, 链接器生成__per_cpu_start和__per_cpu_end两个变量来表示该section的起始和结束地址, 为了配合链接器的行为,
    linux内核源码中针对以上链接脚本声明了外部变量 extern char __per_cpu_load[], __per_cpu_start[],
    __per_cpu_end[];
  592. #define PERCPU_INPUT(cacheline)                                        \
  593.     VMLINUX_SYMBOL(__per_cpu_start)
    = .;
    \
  594.     *(.data..percpu..first)
    \
  595.     . = ALIGN(PAGE_SIZE);
    \
  596.     *(.data..percpu..page_aligned)
    \
  597.     . = ALIGN(cacheline);
    \
  598.     *(.data..percpu..readmostly)
    \
  599.     . = ALIGN(cacheline);
    \
  600.     *(.data..percpu)
    \
  601.     *(.data..percpu..shared_aligned)
    \
  602.     VMLINUX_SYMBOL(__per_cpu_end)
    = .;
  604. #define PERCPU_VADDR(cacheline, vaddr, phdr)
    \
  605.         VMLINUX_SYMBOL(__per_cpu_load)
    = .;
    \
  606.         .data..percpu vaddr
    : AT(VMLINUX_SYMBOL(__per_cpu_load)
    \
  607.                                 - LOAD_OFFSET)
    { \
  608.                 PERCPU_INPUT(cacheline)
    \
  609.         } phdr
    \
  610.         . = VMLINUX_SYMBOL(__per_cpu_load)
    + SIZEOF(.data..percpu);
  612. 我们知道在系统对percpu初始化的时候，会将静态定义的percpu变量(内核映射".data.percpu"section中的变量数据)拷贝到每个cpu的percpu内存空间中，静态定义的percpu变量的起始地址为__per_cpu_load，即
  613. memcpy(ptr, __per_cpu_load, ai->static_size);
  615. 2. 访问percpu变量
  616. (1) per_cpu(var, cpu)获取编号cpu的处理器上面的变量var的副本
  617. (2) get_cpu_var(var)获取本处理器上面的变量var的副本，该函数关闭进程抢占，主要由__get_cpu_var来完成具体的访问
  618. (3) get_cpu_ptr(var) 获取本处理器上面的变量var的副本的指针，该函数关闭进程抢占，主要由__get_cpu_var来完成具体的访问
  619. (4) put_cpu_var(var)
    & put_cpu_ptr(var)表示每CPU变量的访问结束，恢复进程抢占
  620. (5) __get_cpu_var(var) 获取本处理器上面的变量var的副本，该函数不关闭进程抢占
  622. 注意：关闭内核抢占可确保在对per-cpu变量操作的临界区中, 当前进程不会被换出处理器, 在put_cpu_var中恢复内核调度器的可抢占性.
  624. //详细代码解析：
  625. (1) per_cpu
  626. #define per_cpu(var, cpu)
    (*SHIFT_PERCPU_PTR(&(var),
    per_cpu_offset(cpu)))
  628. #define per_cpu_offset(x)
    (__per_cpu_offset[x])
  630. #define SHIFT_PERCPU_PTR(__p, __offset)
    ({
    \
  631.         __verify_pcpu_ptr((__p));
    \
  632.         RELOC_HIDE((typeof(*(__p))
    __kernel __force *)(__p),
    (__offset));
    \
  633.         })
  635. #define RELOC_HIDE(ptr, off)             \
  636.         ({ unsigned long __ptr;                                            \
  637.         __ptr =
    (    unsigned long)
    (    ptr);                                    \
  638.         (typeof(ptr))
    (__ptr +
    (    off));
    })
  640. 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变量的值。
  642. (2) get_cpu_var/__get_cpu_var
  643. #define get_cpu_var(var)
    (*({
    \
  644.         preempt_disable();
    \ //关闭进程抢占
  645.         &__get_cpu_var(var);
    }))
  647. #define __get_cpu_var(var)
    (*this_cpu_ptr(&(var)))
  648. #define this_cpu_ptr(ptr) __this_cpu_ptr(ptr)
  649. #define __this_cpu_ptr(ptr) SHIFT_PERCPU_PTR(ptr, __my_cpu_offset)
  650. #define my_cpu_offset __my_cpu_offset
  651. #define __my_cpu_offset per_cpu_offset(raw_smp_processor_id())
  652. #define per_cpu_offset(x)
    (__per_cpu_offset[x])
  653. 通过一系列宏调用，最终函数还是通过*(__per_cpu_offset[raw_smp_processor_id()]+&(var))来获得本地处理器上的var变量的值。
  655. (3) get_cpu_ptr
  656. #define get_cpu_ptr(var)
    ({
    \
  657.         preempt_disable();
    \
  658.         this_cpu_ptr(var);
    })
  659. 获取本处理器上面的变量var的副本的指针，该函数关闭进程抢占.
  661. (4)put_cpu_ptr/put_cpu_var,恢复进程抢占
  662. #define put_cpu_var(var)
    do {
    \
  663.         (void)&(var);
    \
  664.         preempt_enable();
    \
  665.         } while
    (0)
  666.          
  667. #define put_cpu_ptr(var)
    do {
    \
  668.         (void)(var);
    \
  669.         preempt_enable();
    \
  670.         } while
    (0)
  672. 3.动态分配percpu空间：void
    *     alloc_percpu(type)
  673. #define alloc_percpu(type)
    \
  674.         (typeof(type) __percpu
    *)__alloc_percpu(sizeof(type), __alignof__(type))
  676. void __percpu *__alloc_percpu(size_t size, size_t align)
  677. {
  678.     return pcpu_alloc(size, align,
    false);
  679. }
  681. 3.1 动态分配percpu
  682. static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved)
  683. {
  684.     static int warn_limit
    =     10;
  685.     struct pcpu_chunk *chunk;
  686.     const char
    *    err;
  687.     int slot, off, new_alloc;
  688.     unsigned long flags;
  689.     void __percpu *ptr;
  690.         
  691.     if (unlikely(!size
    || size
    >     PCPU_MIN_UNIT_SIZE || align
    > PAGE_SIZE))
    {
  692.         WARN(true,
    "illegal size (%zu) or align (%zu) for "
  693.             "percpu allocation\n", size, align);
  694.         return NULL;
  695.     }
  696.     
  697.     mutex_lock(&pcpu_alloc_mutex);
  698.     spin_lock_irqsave(&pcpu_lock, flags);
  699.         
  700.     //若指定reserved分配，则从pcpu_reserved_chunk进行
  701.     if (reserved
    && pcpu_reserved_chunk)
    {
  702.         chunk = pcpu_reserved_chunk;//找到静态percpu的chunk
  703.         
  704.         //检查要分配的空间size是否超出该chunk的所具有的最大的空闲size
  705.         if (size
    > chunk->contig_hint)
    {
  706.             err
    =     "alloc from reserved chunk failed";
  707.             goto fail_unlock;
  708.         }
  709.     
  710.         //检查是否要扩展chunk的的map数组，map数组默认设置为128项
  711.         while
    (    (new_alloc
    =     pcpu_need_to_extend(chunk)))
    {
  712.             spin_unlock_irqrestore(&pcpu_lock, flags);
  713.             //对map数组进行扩展
  714.             if
    (    pcpu_extend_area_map(chunk, new_alloc)
    < 0)
    {
  715.                 err
    =     "failed to extend area map of reserved chunk";
  716.                 goto fail_unlock_mutex;
  717.             }
  718.             spin_lock_irqsave(&pcpu_lock, flags);
  719.         }
  720.     
  721.         //从该chunk分配出size大小的空间，返回该size空间在chunk中的偏移量off
  722.         //然后重新将该chunk挂到slot数组对应链表中
  723.         off = pcpu_alloc_area(chunk, size, align);
  724.         if (off
    >= 0)
  725.             goto area_found;
  726.     
  727.         err =
    "alloc from reserved chunk failed";
  728.         goto fail_unlock;
  729.     }
  730.         
  731. restart:
  732.     //根据需要分配内存块的大小索引slot数组找到对应链表
  733.     for (slot
    = pcpu_size_to_slot(size); slot
    < pcpu_nr_slots; slot++)
    {
  734.         list_for_each_entry(chunk,
    &pcpu_slot[slot], list)
    {
  735.             if
    (    size > chunk->contig_hint)
    //在该链表中进一步寻找符合尺寸要求的chunk
  736.                 continue;
  737.              //chunck用数组map记录每次分配的内存块，若该数组项数用完(默认为128项)，
  738.             //但是若该chunk仍然还有空闲空间可分配，则需要增长该map数组项数来记录可分配的空间
  739.             new_alloc = pcpu_need_to_extend(chunk);
  740.             if
    (    new_alloc)
    {
  741.                 spin_unlock_irqrestore(&pcpu_lock, flags);
  742.                 //扩展map数组
  743.                 if
    (    pcpu_extend_area_map(chunk,new_alloc)
    < 0)
    {
  744.                     err
    =     "failed to extend area map";
  745.                     goto fail_unlock_mutex;
  746.                 }
  747.                 spin_lock_irqsave(&pcpu_lock, flags);
  749.                 goto restart;
  750.             }
  751.              //从该chunk分配出size大小的空间，返回该size空间在chunk中的偏移量off
  752.             //然后重新将该chunk挂到slot数组对应链表中
  753.             off = pcpu_alloc_area(chunk, size, align);
  754.             if
    (    off >= 0)
  755.                 goto area_found;
  756.         }
  757.     }
  758.     
  759.     //到这里表示没有找到合适的chunk，需要重新创建一个新的chunk
  760.     spin_unlock_irqrestore(&pcpu_lock, flags);
  761.     //创建一个新的chunk，这里进行的是虚拟地址空间的分配
  762.     chunk = pcpu_create_chunk();
  763.     if (!chunk)
    {
  764.         err =
    "failed to allocate new chunk";
  765.         goto fail_unlock_mutex;
  766.     }
  767.     
  768.     spin_lock_irqsave(&pcpu_lock, flags);
  769.     //把一个全新的chunk挂到slot数组对应链表中
  770.     pcpu_chunk_relocate(chunk,
    -1);
  771.     goto restart;
  772.     
  773. area_found:
  774.     spin_unlock_irqrestore(&pcpu_lock, flags);
  775.     
  776.     //这里要检查该段区域对应物理页是否已经分配
  777.     if (pcpu_populate_chunk(chunk, off, size))
    {
  778.         spin_lock_irqsave(&pcpu_lock, flags);
  779.         pcpu_free_area(chunk, off);
  780.         err =
    "failed to populate";
  781.         goto fail_unlock;
  782.     }
  783.     
  784.     mutex_unlock(&pcpu_alloc_mutex);
  785.     
  786.     /*
  787.     #define __addr_to_pcpu_ptr(addr)     \
  788.         (void __percpu
    *    )((unsigned long)(addr)
    - \
  789.         (unsigned long)pcpu_base_addr
    +                     \
  790.         (unsigned long)__per_cpu_start)
  791.     */
  792.     //chunk->base_addr
    + off表示分配该size空间的起始percpu内存地址
  793.     //最终返回的地址即__per_cpu_start+off，即得到该动态分配percpu变量在内核镜像中的一个虚拟内存地址。
  794.     //实际上该动态分配percpu变量并不在此地址上，只是为了以后通过per_cpu(var, cpu)引用该变量时，
  795.     //与静态percpu变量一致，因为静态percpu变量在内核镜像中是有分配内存虚拟地址的(在.data..percpu段中)。
  796.     //使用per_cpu(var, cpu)时，该动态分配percpu变量的内核镜像中的虚拟地址(假的地址，为了跟静态percpu变量一致)，加上本cpu所在percpu空间与.data..percpu段的偏移量，
  797.     //即得到该动态分配percpu变量在本cpu副本中的内存地址
  798.     ptr = __addr_to_pcpu_ptr(chunk->base_addr
    + off);
  799.     kmemleak_alloc_percpu(ptr, size);
  800.     return ptr;
  801.     
  802. fail_unlock:
  803.     spin_unlock_irqrestore(&pcpu_lock, flags);
  804. fail_unlock_mutex:
  805.     mutex_unlock(&pcpu_alloc_mutex);
  806.     if (warn_limit)
    {
  807.         pr_warning("PERCPU: allocation failed, size=%zu align=%zu, ""%s\n", size,
    align, err);
  808.         dump_stack();
  809.         if (!--warn_limit)
  810.             pr_info("PERCPU: limit reached, disable warning\n");
  811.     }
  812.     return NULL;
  813. }
  815. 3.1.1 检查chunk的map数组是否需要扩展
  816. //#define PCPU_DFL_MAP_ALLOC    16
  817. static int pcpu_need_to_extend(struct pcpu_chunk
    *chunk)
  818. {
  819.     int new_alloc;
  820.     
  821.     //map_alloc默认设置为128，只有map_used记录超过126时才会进行map数组扩展
  822.     if (chunk->map_alloc
    >= chunk->map_used
    + 2)
  823.         return 0;
  824.         
  825.     new_alloc = PCPU_DFL_MAP_ALLOC;//16
  827.     //计算该chunk的map数组新的大小，并返回
  828.     while (new_alloc
    < chunk->map_used
    + 2)
  829.         new_alloc *= 2;
  830.         
  831.     return new_alloc;
  832. }
  834. 3.1.2 对map数组的大小进行扩展
  835. static int pcpu_extend_area_map(struct pcpu_chunk
    *chunk,
    int     new_alloc)
  836. {
  837.     int *old
    = NULL,
    *new =
    NULL    ;
  838.     size_t old_size = 0, new_size
    = new_alloc * sizeof(new[0]);
  839.     unsigned long flags;
  840.     
  841.     //为新的map数组大小分配内存空间    
  842.     new = pcpu_mem_zalloc(new_size);
  843.     if (!new)
  844.         return -ENOMEM;
  845.         
  846.     /* acquire pcpu_lock
    and switch to new area map
    */
  847.     spin_lock_irqsave(&pcpu_lock, flags);
  848.         
  849.     if (new_alloc
    <= chunk->map_alloc)
  850.         goto out_unlock;
  851.         
  852.     old_size = chunk->map_alloc
    * sizeof(chunk->map[0]);
  853.     old = chunk->map;
  854.     
  855.     //复制老的map数组信息到new
  856.     memcpy(new, old, old_size);
  857.     
  858.     //重新设置map数组，完成map数组的扩展
  859.     chunk->map_alloc
    = new_alloc;
  860.     chunk->map
    = new;
  861.     new = NULL;
  862.     
  863. out_unlock:
  864.     spin_unlock_irqrestore(&pcpu_lock, flags);
  865.     
  866.     pcpu_mem_free(old, old_size);
  867.     pcpu_mem_free(new, new_size);
  868.         
  869.     return 0;
  870. }
  872. 3.1.3 从chunk的map数组中分配size大小空间，返回该size的偏移值
  873. static int pcpu_alloc_area(struct pcpu_chunk
    *chunk,
    int     size, int align)
  874. {
  875.     int oslot
    =     pcpu_chunk_slot(chunk);
  876.     int max_contig
    =     0;
  877.     int i, off;
  878.     
  879.     //遍历该chunk的map中记录的空间，map中负数为已经使用的空间，正数为可以分配使用的空间
  880.     for (i
    = 0, off
    =     0; i < chunk->map_used; off
    += abs(chunk->map[i++]))
    {
  881.         //is_last为1表示已经扫描了chunk中所有记录的空间，并且是最后一个map组项
  882.         bool is_last = i
    +     1 == chunk->map_used;
  883.         int head, tail;
  884.         
  885.         //对map项中记录的percpu空间大小进行对齐，可能会产生的一个偏移量head
  886.         head = ALIGN(off, align)
    - off;
  887.         BUG_ON(i
    =    = 0 && head
    != 0);
  888.          
  889.          //map中记录的负数表示已经使用的percpu空间，继续下一个
  890.         if (chunk->map[i]
    < 0)
  891.             continue;
  892.             
  893.         //若map中的空间大小小于要分配的空间大小，继续下一个
  894.         if (chunk->map[i]
    < head + size)
    {
  895.             //更新该chunk中可使用的空间大小
  896.             max_contig = max(chunk->map[i],
    max_contig);
  897.             continue;
  898.         }
  899.     
  900.         //如果head不为0，并且head很小(小于sizeof(int))，或者前一个map的可用空间大于0(但是chunk->map[i
    - 1]
    <     head+size)
  901.         //如果前一个map项>0，则将head合并到前一个map中
  902.         //如果前一个map项<0,则将head合并到前一个map，并且是负数，不可用空间，当前chunk空闲size减去这head大小的空间
  903.         if (head
    &&
    (    head < sizeof(int)
    || chunk->map[i
    - 1]
    >     0))
    {
  904.             if
    (    chunk->map[i
    - 1]
    >     0)
  905.                 chunk->map[i
    - 1]
    +    = head;
  906.             else
    {
  907.                 chunk->map[i
    - 1]
    -    = head;
  908.                 chunk->free_size
    -= head;
  909.             }
  910.             //当前map减去已经与前一个map合并的head大小的空间
  911.             chunk->map[i]
    -= head;
  912.             off += head;//偏移要加上head
  913.             head = 0;//合并之后，head清零
  914.         }
  915.     
  916.         //计算要分配空间的尾部
  917.         tail = chunk->map[i]
    - head - size;
  918.         if (tail
    < sizeof(int))
  919.             tail = 0;
  920.     
  921.         //如果head不为0，或者tail不为0，则要将当前map分割
  922.         if (head
    || tail)
    {
  923.             pcpu_split_block(chunk, i, head, tail);
  924.             //如果head不为0，tail不为0，经过split之后，map[i]记录head，map[i+1]记录要分配的size，map[i+2]记录tail。
  925.             if
    (    head) {
  926.                 i++;
    //移到记录要分配size空间的map项
  927.                 off += head;//偏移要加上head，表示从head之后开始
  928.                 //i-1表示head所在的那个map项，与max_contig比较大小，为下边更新chunk的最大空闲空间
  929.                 max_contig = max(chunk->map[i
    - 1], max_contig);
  930.             }
  931.             //i+1表示tail所在的那个map项，比较与max_contig的大小，为下边更新chunk的最大空闲空间
  932.             if
    (    tail)
  933.                 max_contig = max(chunk->map[i
    + 1], max_contig);
  934.         }
  935.     
  936.         //更新chunk的最大空闲空间
  937.         if (is_last)
  938.             chunk->contig_hint
    = max_contig;
    /* fully scanned
    */
  939.         else
  940.             chunk->contig_hint
    = max(chunk->contig_hint,max_contig);
  941.     
  942.         chunk->free_size
    -= chunk->map[i];//chunk中的空闲空间大小递减
  943.         chunk->map[i]
    = -chunk->map[i];//变成负数表示该map中的size大小已分配
  944.         
  945.         //重新计算chunk在slot中的位置
  946.         pcpu_chunk_relocate(chunk, oslot);
  947.         return off;
  948.     }
  949.     
  950.     chunk->contig_hint
    = max_contig;
    /* fully scanned
    */
  951.     pcpu_chunk_relocate(chunk, oslot);
  952.     
  953.     /* tell the upper layer that this chunk has no matching area
    */
  954.     return -1;
  955. }
  957. 3.1.4 将map数组进行分割
  958. static void pcpu_split_block(struct pcpu_chunk
    *chunk,
    int     i,int head,
    int tail)
  959. {
  960.     //若head、tail都不为0，则要添加两个map，有一个不为0则添加一个map
  961.     int nr_extra
    =     !!head
    + !!tail;
  962.     
  963.     BUG_ON(chunk->map_alloc
    < chunk->map_used
    + nr_extra);
  964.     
  965.     //首先将该当前要分割的map后边的数据拷贝
  966.     memmove(&chunk->map[i
    + nr_extra],
    &chunk->map[i],sizeof(chunk->map[0])
    * (chunk->map_used
    - i));
  967.     chunk->map_used
    += nr_extra;//map数组的使用个数更新
  968.     
  969.     //如果head不为0，则i+1的map项保存chunk->map[i]
    - head的大小，当前的map保存head的大小
  970.     if (head)
    {
  971.         chunk->map[i
    + 1]
    =     chunk->map[i]
    - head;
  972.         chunk->map[i++]
    = head;
  973.     }
  975.     //如果tail不为0，将记录(chunk->map[i]
    - head)大小的map项减去tail，即得到要分配size空间
  976.     //最后一个map保存剩余的tail大小
  977.     if (tail)
    {
  978.         chunk->map[i++]
    -= tail;//得到size空间大小的map项
  979.         chunk->map[i]
    = tail;
  980.     }
  981. }
  983. 五、结构图
  984. 参见附件

linux percpu机制解析

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞