Linux深入理解内存管理20（基于Linux6.6）---zonelist初始化
一、概述
在bootmem_init初始化的时候，已经初始化了内存节点的zone成员，该成员是struct zone数组，存放该内存节点的zone信息。在linux的内存管理中，分几个阶段进行抽象，用数据结构来管理。先用结点集合管理内存，然后用zone管理结点，再用页的管理zone。此时使用的数据结构分别为pglist_data、zone、page结构体，以下来分析内核是如何完成zonelist的初始化。
1. zonelist 的定义与作用
zonelist 是一个 zone 数组的链表，它的主要作用是在内存分配时，指导内存分配器遍历多个内存区域（zone），从而选择合适的内存区域来分配内存页。
每个 NUMA 节点可以有一个 zonelist，用于管理该节点上所有内存区域的顺序。zonelist 的顺序通常从 "最合适的" 区域开始，以提高内存分配效率。
2. zonelist 的结构
zonelist 在内核中的数据结构 struct zonelist 是一个 zone 数组，它包含了一个或多个内存区域（zone）。每个 zonelist 结构体在 NUMA 系统中通常是针对每个 NUMA 节点来维护的。
zonelist 结构体定义：
struct zonelist {
struct zone *zones[MAX_NR_ZONES]; // 存储区域的指针
unsigned long _pad; // 补齐
};
zones[]：是一个指向内存区域（zone）的指针数组，通常最多包含MAX_NR_ZONES个zone指针。每个zone代表一个物理内存区域（例如：DMA、Normal、HighMem）。_pad：是为了内存对齐而存在的填充字段。
3. zonelist 的初始化
zonelist 的初始化通常是在 NUMA 节点初始化过程中完成的。每个 NUMA 节点会初始化一个 zonelist，其中包含该节点上所有的内存区域（zone）。初始化的过程中，内存区域（zone）会按照一定的优先级顺序排列，优先考虑节点本地的内存区域。
在多节点系统中，内存分配器会依据 zonelist 来选择最合适的内存区域进行分配，以尽量避免跨节点访问带来的性能损失。
初始化过程概述：
-
每个 NUMA 节点创建一个 zonelist：
zonelist是为每个 NUMA 节点单独创建的，内核会为每个 NUMA 节点分配一个zonelist结构体。 -
根据内存区域（zone）的优先级排序：
zonelist中的内存区域通常按照优先级排序，从节点本地的内存区域（比如节点内的zone）到远程节点的内存区域（比如跨节点访问的zone）。这样可以尽量优先分配本地内存，减少跨节点访问的开销。 -
设置 zonelist 的顺序：在初始化过程中，内核会设置每个
zonelist中的zones[]数组，按照优先级填充每个zone。这些zone按照物理内存的区域分布来排序，通常是本地节点的内存区域排在前面，远程节点的内存区域排在后面。
void build_zonelist(struct zonelist *zonelist, struct pg_data_t *pgdat)
{
struct zone *zone;
unsigned int i;
for (i = 0; i < MAX_NR_ZONES; i++) {
zone = pgdat->node_zones[i];
if (zone)
zonelist->zones[i] = zone;
}
}
上述代码是 zonelist 初始化的一部分，build_zonelist 函数会根据 NUMA 节点上的内存区域（node_zones[]）来构建 zonelist。
4. zonelist 的使用
zonelist 主要用于内存分配过程中，当需要分配内存时，内核会通过 zonelist 来选择最合适的内存区域（zone）。在内存分配过程中，内核会根据 zonelist 中的顺序依次检查各个内存区域，优先分配本地内存。
内存分配示例：
-
分配内存：当内存分配请求发起时，内存分配器（如
kmalloc）会遍历zonelist中的内存区域（zone）进行内存分配。 -
遍历 zonelist：分配器会从
zonelist中的第一个zone开始尝试分配，如果当前zone没有足够的内存，则会继续尝试下一个zone。如果遍历完本地节点的所有区域，才会尝试远程节点的内存区域。 -
分配内存页：一旦找到一个合适的内存区域，内存分配器会尝试从该
zone中分配一个页面。如果成功，则返回已分配的页面地址。
5. zonelist 的优化
为了提高性能，zonelist 的顺序通常会优先选择本地内存区域，以减少跨 NUMA 节点访问时的延迟。此外，Linux 内核还会根据内存区域的可用情况和访问模式进行优化。例如，内存分配器会选择访问频繁的内存区域（例如，本地节点的内存），避免频繁的远程内存访问。
二、数据结构
在结点的pglist_data数据结构中有一个node_zone_list[]类型的struct zonelist。
include/linux/mmzone.h
typedef struct pglist_data {
...
struct zonelist node_zonelists[MAX_ZONELISTS];
...
}pg_data_t;
struct zonelist {
struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
};
enum {
ZONELIST_FALLBACK, /* zonelist with fallback */
#ifdef CONFIG_NUMA
ZONELIST_NOFALLBACK, /* zonelist without fallback (__GFP_THISNODE) */
#endif
MAX_ZONELISTS
}
#define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)
- node_zonelists[]包含了2个zonelist，一个是由本node的zones组成，另一个是由从本node分配不到内存时可选的备用zones组成，相当于是选择了一个退路，所以叫fallback。而对于本开发板，没有定义NUMA，没有备份。
- struct zonelist只有一个_zonerefs[]数组构成，_zonerefs[]数组的大小为MAX_ZONES_PER_ZONELIST，最大的节点数和节点可拥有的ZONE数w为1 *MAX_NR_ZONES
- _zonerefs[]数组的类型struct zoneref定义如下，主要是zone指针和索引号构成。
include/linux/mmzone.h
struct zoneref {
struct zone *zone; /* Pointer to actual zone */
int zone_idx; /* zone_idx(zoneref->zone) */
};
三、zonelist初始化
内核在start_kernel中通过build_all_zonelists完成了内存结点及其管理内存域的初始化工作, 调用如下：
mm/page_alloc.c
void __ref build_all_zonelists(pg_data_t *pgdat)
{
unsigned long vm_total_pages;
if (system_state == SYSTEM_BOOTING) { ---解析1
build_all_zonelists_init();
} else {
__build_all_zonelists(pgdat);
/* cpuset refresh routine should be here */
}
/* Get the number of free pages beyond high watermark in all zones. */
vm_total_pages = nr_free_zone_pages(gfp_zone(GFP_HIGHUSER_MOVABLE));---解析2
/*
* Disable grouping by mobility if the number of pages in the
* system is too low to allow the mechanism to work. It would be
* more accurate, but expensive to check per-zone. This check is
* made on memory-hotadd so a system can start with mobility
* disabled and enable it later
*/
if (vm_total_pages < (pageblock_nr_pages * MIGRATE_TYPES))---解析3
page_group_by_mobility_disabled = 1;
else
page_group_by_mobility_disabled = 0;
---解析4
pr_info("Built %u zonelists, mobility grouping %s. Total pages: %ld\n",
nr_online_nodes,
page_group_by_mobility_disabled ? "off" : "on",
vm_total_pages);
#ifdef CONFIG_NUMA
pr_info("Policy zone: %s\n", zone_names[policy_zone]);
#endif
}
- 不同的系统状态调用的函数不同，系统状态为启动阶段时(SYSTEM_BOOTING)时，就调用build_all_zonelists_init函数，其他状态就调用stop_machine函数。让系统的所有CPU执行停止函数。其系统状态可分为6中，其定义如下：
extern enum system_states { SYSTEM_BOOTING, SYSTEM_RUNNING, SYSTEM_HALT, SYSTEM_POWER_OFF, SYSTEM_RESTART, } system_state; - 调用nr_free_pagecache_pages，从函数名字可以看出，该函数求出可处理的空页数。
- 通过nr_free_pagecache_pages求出vm_total_pages和页移动性比较，决定是否激活grouping。
- 打印到控制台，打印的信息输出内容为online node、zone列表顺序，是否根据移动性对页面执行集合(grouping)、vm_total_pages、NUMA时输出policy zone。
3.1、 build_all_zonelists_init
构建备用列表的主要工作是在__build_all_zonelists函数中实现的，其主要是遍历每一个节点，然后调用build_zonelists。
mm/page_alloc.c
static noinline void __init
build_all_zonelists_init(void)
{
int cpu;
__build_all_zonelists(NULL);
/*
* Initialize the boot_pagesets that are going to be used
* for bootstrapping processors. The real pagesets for
* each zone will be allocated later when the per cpu
* allocator is available.
*
* boot_pagesets are used also for bootstrapping offline
* cpus if the system is already booted because the pagesets
* are needed to initialize allocators on a specific cpu too.
* F.e. the percpu allocator needs the page allocator which
* needs the percpu allocator in order to allocate its pagesets
* (a chicken-egg dilemma).
*/
for_each_possible_cpu(cpu)
per_cpu_pages_init(&per_cpu(boot_pageset, cpu), &per_cpu(boot_zonestats, cpu));
mminit_verify_zonelist();
cpuset_init_current_mems_allowed();
}
static void __build_all_zonelists(void *data)
{
int nid;
int __maybe_unused cpu;
pg_data_t *self = data;
write_seqlock(&zonelist_update_seq);
#ifdef CONFIG_NUMA
memset(node_load, 0, sizeof(node_load));
#endif
/*
* This node is hotadded and no memory is yet present. So just
* building zonelists is fine - no need to touch other nodes.
*/
if (self && !node_online(self->node_id)) {
build_zonelists(self);
} else {
/*
* All possible nodes have pgdat preallocated
* in free_area_init
*/
for_each_node(nid) {
pg_data_t *pgdat = NODE_DATA(nid);
build_zonelists(pgdat);
}
#ifdef CONFIG_HAVE_MEMORYLESS_NODES
/*
* We now know the "local memory node" for each node--
* i.e., the node of the first zone in the generic zonelist.
* Set up numa_mem percpu variable for on-line cpus. During
* boot, only the boot cpu should be on-line; we'll init the
* secondary cpus' numa_mem as they come on-line. During
* node/memory hotplug, we'll fixup all on-line cpus.
*/
for_each_online_cpu(cpu)
set_cpu_numa_mem(cpu, local_memory_node(cpu_to_node(cpu)));
#endif
}
write_sequnlock(&zonelist_update_seq);
}
其主要是来分析下build_zonelists的流程：
mm/page_alloc.c
static void build_zonelists(pg_data_t *pgdat)
{
static int node_order[MAX_NUMNODES];
int node, nr_nodes = 0;
nodemask_t used_mask = NODE_MASK_NONE;
int local_node, prev_node;
/* NUMA-aware ordering of nodes */
local_node = pgdat->node_id;
prev_node = local_node;
memset(node_order, 0, sizeof(node_order));
while ((node = find_next_best_node(local_node, &used_mask)) >= 0) {---解析1
/*
* We don't want to pressure a particular node.
* So adding penalty to the first node in same
* distance group to make it round-robin.
*/
if (node_distance(local_node, node) !=
node_distance(local_node, prev_node))
node_load[node] += 1;
node_order[nr_nodes++] = node;
prev_node = node;
}
build_zonelists_in_node_order(pgdat, node_order, nr_nodes);---解析2
build_thisnode_zonelists(pgdat);---解析3
pr_info("Fallback order for Node %d: ", local_node);
for (node = 0; node < nr_nodes; node++)
pr_cont("%d ", node_order[node]);
pr_cont("\n");
}
- 调用find_nex_best_node，该函数为添加当前节点的备份列表，以当前节点为基准查找最佳节点。
- 由while循环查找当前节点的最佳节点的节点号，因此，如果zone列表顺序为节点顺序，就调用build_zonelists_in_node_order函数，以节点顺序构建备份列表，如果是zone顺序，则调用node_order[]数组保持节点顺序。
- 如果利用node_order[]数组保持的节点顺序就调用build_zonelists_in_zone_order，用zone顺序构建备份列表。
- 调用build_thisnode_zonelists，在node_zonelists[]和_zonerefs[]数组中构建相应节点的zone列表。
mm/page_alloc.c
static void build_zonelists_in_node_order(pg_data_t *pgdat, int *node_order,
unsigned nr_nodes)
{
struct zoneref *zonerefs;
int i;
zonerefs = pgdat->node_zonelists[ZONELIST_FALLBACK]._zonerefs;
for (i = 0; i < nr_nodes; i++) {
int nr_zones;
pg_data_t *node = NODE_DATA(node_order[i]);
nr_zones = build_zonerefs_node(node, zonerefs);
zonerefs += nr_zones;
}
zonerefs->zone = NULL;
zonerefs->zone_idx = 0;
}
该函数以节点为单位构建备份列表，各节点的zone按顺序构建，具有这些zone的列表的数组就是zonelist的_zonerefs成员变量。_
- 首先通过node_zonelists找到对应的zonelist，然后通过for循环线找到_zonerefs的成员中zone为非NULL得索引j后，将相应节点的zone从__zonerefs[j]开始添加到数组即可。
- 然后调用build_zonelists_node将相应的节点的zone添加到_zonerefs[]数组，然后初始化zonelist->_zonerefs[j]的zone和zone_idx，以添加下一个节点zone。这样，就可以为备份列表添加下一个最佳节点的zone。
mm/page_alloc.c
/*
* Builds allocation fallback zone lists.
*
* Add all populated zones of a node to the zonelist.
*/
static int build_zonerefs_node(pg_data_t *pgdat, struct zoneref *zonerefs)
{
struct zone *zone;
enum zone_type zone_type = MAX_NR_ZONES;
int nr_zones = 0;
do {
zone_type--;
zone = pgdat->node_zones + zone_type;
if (populated_zone(zone)) {
zoneref_set_zone(zone, &zonerefs[nr_zones++]);
check_highest_zone(zone_type);
}
} while (zone_type);
return nr_zones;
}
- 将节点的zone注册到备份列表时，zone的类型是按照逆时针注册的。即HIGHMEM->NORMAL->DMA32->DMA的顺序。也就是说HIGHMEM中没有内存，就从NORMAL开始分配；如果NORMAL没有内存，就从DMA开始分配。这样为了减小分配内存时候发生的OOM风险，最大降低对系统的影响。
- 当在相应的zone中有实际的物理内存时就将zone注册到_zonerefs[]数组。
3.2、输出备用列表信息
下面分析mminit_verify_zonelist函数。
mm/mm_init.c
void __init mminit_verify_zonelist(void)
{
int nid;
if (mminit_loglevel < MMINIT_VERIFY)
return;
for_each_online_node(nid) {
pg_data_t *pgdat = NODE_DATA(nid);
struct zone *zone;
struct zoneref *z;
struct zonelist *zonelist;
int i, listid, zoneid;
BUILD_BUG_ON(MAX_ZONELISTS > 2);
for (i = 0; i < MAX_ZONELISTS * MAX_NR_ZONES; i++) {
/* Identify the zone and nodelist */
zoneid = i % MAX_NR_ZONES;
listid = i / MAX_NR_ZONES;
zonelist = &pgdat->node_zonelists[listid];
zone = &pgdat->node_zones[zoneid];
if (!populated_zone(zone))
continue;
/* Print information about the zonelist */
printk(KERN_DEBUG "mminit::zonelist %s %d:%s = ",
listid > 0 ? "thisnode" : "general", nid,
zone->name);
/* Iterate the zonelist */
for_each_zone_zonelist(zone, z, zonelist, zoneid)
pr_cont("%d:%s ", zone_to_nid(zone), zone->name);
pr_cont("\n");
}
}
}
该函数，对各个节点进行遍历，对各个节点具有的最大ZONE数，输出zonelist的信息，对各个zonelist输出zone名称。该函数输出系统内所有节点的备份列表信息，只是执行for循环访问节点的备份列表，输出构建备份列表的zone节点号和节点名。
3.3、处理页分配请求节点
cpuset_init_current_mems_allowed函数只调用nodes_setall函数，在当前任务current的mems_allowed位图中，将系统的所有节点设置为1。mems_allowed位图决定处理当前任务中发生的页分配请求的节点。
kernel/cgroup/cpuset.c
void __init cpuset_init_current_mems_allowed(void)
{
nodes_setall(current->mems_allowed);
}
3.4、求空页数
将gfp_zone(GFP_HIGHUSER_MOVABLE)的结果值作为参数传递，gfp_zone函数对传递来的参数标签值进行检查并返回zone类型，并返回zone类型中的可用页数。
mm/page_alloc.c
/**
* nr_free_buffer_pages - count number of pages beyond high watermark
*
* nr_free_buffer_pages() counts the number of pages which are beyond the high
* watermark within ZONE_DMA and ZONE_NORMAL.
*
* Return: number of pages beyond high watermark within ZONE_DMA and
* ZONE_NORMAL.
*/
unsigned long nr_free_buffer_pages(void)
{
return nr_free_zone_pages(gfp_zone(GFP_USER));
}
EXPORT_SYMBOL_GPL(nr_free_buffer_pages);
下面来看看nr_free_zone_pages函数。
mm/page_alloc.c
static unsigned long nr_free_zone_pages(int offset)
{
struct zoneref *z;
struct zone *zone;
/* Just pick one node, since fallback list is circular */
unsigned long sum = 0;
struct zonelist *zonelist = node_zonelist(numa_node_id(), GFP_KERNEL);
for_each_zone_zonelist(zone, z, zonelist, offset) {
unsigned long size = zone_managed_pages(zone);
unsigned long high = high_wmark_pages(zone);
if (size > high)
sum += size - high;
}
return sum;
}
该函数主要是对zonelist执行循环，访问zonelist的所有zone，在sum中累积从zone->present_pages减掉zone->pages_high的值。zone->present_pages是相应的zone中的物理页数，zone->pages_high变量用于决定相应zone是否为Idle状态。
- 若存在比page_high更多的空页，则当前zone变成idle状态。
- 可用内存不足时，内核将虚拟内存的页面会置换到硬盘，前面提到的struct zone结构体中的min、high、low会用到。
该函数主要是用于求出可处理的空页数。
3.5、页移动性
mm/page_alloc.c
void __ref build_all_zonelists(pg_data_t *pgdat)
{
...
if (vm_total_pages < (pageblock_nr_pages * MIGRATE_TYPES))
page_group_by_mobility_disabled = 1;
else
page_group_by_mobility_disabled = 0;
...
}
通过前面的函数求出vm_total_pages，若比(pageblock_nr_pages * MIGRATE_TYPES)小，就不允许以移动性为基准执行。
pageblock_nr_pages和MIGRATE_TYPES定义如下：
#define MAX_ORDER 11
#define pageblock_order (MAX_ORDER-1)
#define pageblock_nr_pages (1UL << pageblock_order)
MIGRATE_TYPES表示移动类型的宏，其值为5，其定义为：
enum {
MIGRATE_UNMOVABLE, //不可以动
MIGRATE_MOVABLE, //可回收
MIGRATE_RECLAIMABLE, //可移动
MIGRATE_PCPTYPES,
MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
MIGRATE_TYPES
}
通过以上方式，最终构建了free_list以移动性为基准执行的页集合，其主要有以下好处：
- 防止内存碎片：以顺序为单位对具有相同移动属性的页执行集合，防止内存碎片
- 分配大内存的方法：将具有相同移动属性的页集合在一处，使其能够在大内存分配中使用，例如：
- 内核内存(kmalloc): UNMOVABLE
- 磁盘缓存(inode、dentry):RECLAIMABLE
- 用户内存+页缓存：MOVABLE
四、总结
build_all_zonelists()用来初始化内存分配器使用的存储节点中的管理区链表，是为内存管理算法（伙伴管理算法）做准备工作的，对Linux管理的各内存结构体进行初始化和设置操作，如下图所示：
4.1、build_all_zonelists() 的实现和步骤
下面是 build_all_zonelists() 函数的一个简化版本，以及它的主要工作步骤：
void build_all_zonelists(void)
{
struct pglist_data *pgdat;
int nid;
/* 遍历所有 NUMA 节点 */
for (nid = 0; nid < max_num_nodes; nid++) {
pgdat = NODE_DATA(nid); // 获取当前节点的 pglist_data 结构
build_zonelist(pgdat); // 为当前 NUMA 节点初始化 zonelist
}
}
1. 遍历所有 NUMA 节点
Linux 内核支持 NUMA（非一致性内存访问）架构，在这种架构下，系统有多个内存节点，每个节点都有自己的内存区域。max_num_nodes 表示系统中 NUMA 节点的最大数量。build_all_zonelists() 会遍历系统中所有的 NUMA 节点，逐个为每个节点构建并初始化 zonelist。
2. 获取 pglist_data 结构
对于每个 NUMA 节点，通过 NODE_DATA(nid) 获取该节点的 pglist_data 结构。pglist_data 结构体中包含了与该 NUMA 节点相关的所有内存信息，比如内存区域（zone）的管理结构和各类内存操作的函数指针。
3. 调用 build_zonelist()
build_zonelist() 函数负责为每个 NUMA 节点的 zonelist 进行初始化。它将该节点的内存区域按优先级顺序排列，并填充到 zonelist 中。
在内存分配过程中，zonelist 会指导内存分配器选择最适合的内存区域（zone）。这对于优化内存分配效率和提高 NUMA 系统的性能至关重要。
4.2、build_zonelist() 的实现
build_zonelist() 是一个较小的函数，它的作用是为特定的 NUMA 节点初始化 zonelist，将该节点的内存区域按照优先级顺序填充到 zonelist 中。它通常会使用以下步骤：
void build_zonelist(struct pg_data_t *pgdat)
{
struct zonelist *zonelist = pgdat->node_zonelist;
unsigned int i;
/* 遍历所有内存区域，并填充到 zonelist 中 */
for (i = 0; i < MAX_NR_ZONES; i++) {
struct zone *zone = pgdat->node_zones[i];
if (zone) {
/* 填充到 zonelist 的 zones 数组中 */
zonelist->zones[i] = zone;
}
}
}
pgdat->node_zonelist：是当前 NUMA 节点的zonelist结构。pgdat->node_zones[i]：是当前 NUMA 节点上第i个内存区域（zone）。例如，zone[0]可能是DMA区域，zone[1]是Normal区域。zonelist->zones[i]：将每个zone按照优先级顺序填充到zonelist中。
4.3、内存区域（zone）的优先级
在 Linux 中，内存被划分为不同的区域（zone），这些区域在 zonelist 中会按照优先级顺序排列。通常情况下，zonelist 会按照以下顺序排列各个区域：
- DMA 区域：这部分内存区域通常用于低地址的内存，适合进行低延迟的内存分配，通常被用于小设备的内存分配。
- Normal 区域：这是最常见的内存区域，用于分配大多数的内存页。
- HighMem 区域：高内存区域（如果有的话），它通常在
zone中排在最后，适用于较高地址的内存页。
4.4、zonelist 在内存分配中的作用
zonelist 是内存分配器用来选择合适的内存区域的核心数据结构。在内存分配过程中，内核会遍历 zonelist，依次检查每个区域是否满足分配条件，并优先分配本地内存。
- 优先分配本地节点的内存：内存分配器通常会优先选择本地节点的内存区域，减少跨节点内存访问的开销。
- 跨节点内存分配：如果本地节点的内存不够，内存分配器会尝试分配其他节点的内存，从而实现跨节点内存分配。
- 性能优化：通过
zonelist，内核能够根据内存的地域性进行优化，确保内存分配操作尽可能高效。
扫一扫
1093
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
