Linux深入理解内存管理20

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 来选择最合适的内存区域进行分配，以尽量避免跨节点访问带来的性能损失。

初始化过程概述：

1. 每个 NUMA 节点创建一个 zonelist：zonelist 是为每个 NUMA 节点单独创建的，内核会为每个 NUMA 节点分配一个 zonelist 结构体。

2. 根据内存区域（zone）的优先级排序：zonelist 中的内存区域通常按照优先级排序，从节点本地的内存区域（比如节点内的 zone）到远程节点的内存区域（比如跨节点访问的 zone）。这样可以尽量优先分配本地内存，减少跨节点访问的开销。

3. 设置 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 中的顺序依次检查各个内存区域，优先分配本地内存。

内存分配示例：

1. 分配内存：当内存分配请求发起时，内存分配器（如 kmalloc）会遍历 zonelist 中的内存区域（zone）进行内存分配。

2. 遍历 zonelist：分配器会从 zonelist 中的第一个 zone 开始尝试分配，如果当前 zone 没有足够的内存，则会继续尝试下一个 zone。如果遍历完本地节点的所有区域，才会尝试远程节点的内存区域。

3. 分配内存页：一旦找到一个合适的内存区域，内存分配器会尝试从该 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
}

1. 不同的系统状态调用的函数不同，系统状态为启动阶段时(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;

2. 调用nr_free_pagecache_pages，从函数名字可以看出，该函数求出可处理的空页数。
3. 通过nr_free_pagecache_pages求出vm_total_pages和页移动性比较，决定是否激活grouping。
4. 打印到控制台，打印的信息输出内容为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");
}

1. 调用find_nex_best_node，该函数为添加当前节点的备份列表，以当前节点为基准查找最佳节点。
2. 由while循环查找当前节点的最佳节点的节点号，因此，如果zone列表顺序为节点顺序，就调用build_zonelists_in_node_order函数，以节点顺序构建备份列表，如果是zone顺序，则调用node_order[]数组保持节点顺序。
3. 如果利用node_order[]数组保持的节点顺序就调用build_zonelists_in_zone_order，用zone顺序构建备份列表。
4. 调用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以移动性为基准执行的页集合，其主要有以下好处：

1. 防止内存碎片：以顺序为单位对具有相同移动属性的页执行集合，防止内存碎片
2. 分配大内存的方法：将具有相同移动属性的页集合在一处，使其能够在大内存分配中使用，例如：

• 内核内存(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 会按照以下顺序排列各个区域：

1. DMA 区域：这部分内存区域通常用于低地址的内存，适合进行低延迟的内存分配，通常被用于小设备的内存分配。
2. Normal 区域：这是最常见的内存区域，用于分配大多数的内存页。
3. HighMem 区域：高内存区域（如果有的话），它通常在 zone 中排在最后，适用于较高地址的内存页。

4.4、zonelist 在内存分配中的作用

zonelist 是内存分配器用来选择合适的内存区域的核心数据结构。在内存分配过程中，内核会遍历 zonelist，依次检查每个区域是否满足分配条件，并优先分配本地内存。

1. 优先分配本地节点的内存：内存分配器通常会优先选择本地节点的内存区域，减少跨节点内存访问的开销。
2. 跨节点内存分配：如果本地节点的内存不够，内存分配器会尝试分配其他节点的内存，从而实现跨节点内存分配。
3. 性能优化：通过 zonelist，内核能够根据内存的地域性进行优化，确保内存分配操作尽可能高效。