Linux深入理解内存管理18（基于Linux6.6）---bootmem内存分配器介绍
一、概述
Bootmem（Bootstrap Memory）是 Linux 内核在系统启动过程中用来分配内存的一个特殊内存分配器。它的设计目的是在系统启动的早期阶段，内核还没有完全初始化所有的内存管理功能（如页表管理、伙伴系统等）时，能够有效地管理和分配内存。
在 Linux 内核的引导阶段，内存分配的需求与常规内存分配需求有所不同。由于内核还没有完全初始化，通常需要一个简单且快速的内存分配机制，而 Bootmem 就是为此目的而设计的。
1.1、Bootmem 内存分配器的背景
在 Linux 启动过程中，系统需要执行许多初始化任务（例如加载内核、初始化硬件、设置内存映射等），这些任务会消耗大量内存，而此时很多常规的内存管理子系统（如伙伴系统、Slab 分配器等）尚未初始化。因此，Bootmem 作为一种快速且简化的内存管理机制，在这个阶段发挥了重要作用。
启动阶段的内存管理需求：
- 内存分配的需求：在系统启动的初期，内核需要分配内存来加载各种内核模块、设置内核数据结构、初始化硬件设备等。
- 内存管理的限制：此时，内核尚未初始化完整的内存管理子系统（如伙伴系统、Slab 分配器等），因此不能使用复杂的内存分配策略。
- 高效性要求：启动阶段的内存分配要求尽可能高效，以便快速完成系统启动。
1.2、Bootmem 的工作原理
Bootmem 的主要目的是在 Linux 启动时管理物理内存的分配。它的工作流程可以分为几个阶段：
1、内存区域的标记
- 可用内存标记：在启动时，内核会获取系统的物理内存布局，并标记哪些内存区域是可用的。这个过程会使用 e820（在 x86 架构上）或类似机制来扫描系统的物理内存区域并标记内存区域的状态（例如，已使用、可用、保留等）。
2、分配内存
- 简单的内存分配：Bootmem 的内存分配方式比较简单，通常是直接从标记为 "可用" 的内存区域中分配内存，而没有复杂的算法。它通常通过维护一个可用内存区域的链表来进行分配，分配过程尽量避免使用复杂的算法和数据结构，目的是简化处理和提高效率。
3、内存回收
- 内存回收机制：当系统启动完成后，Bootmem 分配器会将已经分配的内存交给后续的内存管理子系统（如伙伴系统或 Slab 分配器）。Bootmem 分配器会释放其管理的内存区域，确保后续的内存管理机制能够接管这些内存资源。
1.3、Bootmem 内存分配器的实现细节
在 Linux 内核中，Bootmem 内存分配器是通过 bootmem 子系统实现的，主要由以下几个核心部分组成：
1、bootmem 数据结构
bootmem_data：这是 Bootmem 内存分配器的核心数据结构。它用于跟踪可用内存区域的信息。- 内存块列表：在
bootmem_data中，通常会维护一个链表或数组来表示可用的内存块。每次分配内存时，Bootmem 会从链表中取出一个块并返回给调用者。
2、bootmem 的分配和释放接口
alloc_bootmem()：这是 Bootmem 内存分配器的主要接口函数，用于从 Bootmem 中分配内存。它会从可用内存区域中选择一个合适的内存块来返回。free_bootmem()：在系统启动完成后，Bootmem 分配的内存通常会被释放，以便交给其他内存管理机制。
3、内存区域管理
- Bootmem 管理内存时，会通过物理地址来跟踪哪些内存区域已被分配，哪些内存区域是空闲的。这些内存区域通常以页为单位进行管理，内存区域的起始地址和大小被记录在
bootmem_data结构中。
4、初始化与交接
- 在系统启动过程中，内核首先使用 Bootmem 来分配内存来初始化硬件和加载内核代码。当内核的页面管理系统（如伙伴系统）初始化完成后，Bootmem 分配的内存将被释放，内存管理交由更加复杂的内存分配器（如 Slab、伙伴系统）接管。
1.4、Bootmem 与其他内存管理器的关系
Bootmem 内存分配器仅在内核启动过程中使用。随着系统的初始化完成，Bootmem 会将分配的内存交给更强大的内存管理器来接管：
- 伙伴系统（Buddy System）：伙伴系统是 Linux 内核中常用的内存分配算法，特别适用于管理大块的内存。系统启动完成后，内存分配的工作会交给伙伴系统，Bootmem 管理的内存将被伙伴系统接管。
- Slab 分配器：Slab 分配器用于高效地分配小块内存（例如内核对象）。在启动后，Bootmem 管理的内存会交给 Slab 分配器，用于内核对象的管理。
二、Bootm初始化
memblock，其作用内核启动初期，常用的内存分配器还未被初始化而不能使用，在此期间memblock是一种用于内存管理区域的方法。然后调用page_init来完成系统分页机制的初始化工作，建立页表，从而内核可以完成虚拟地址到物理地址的映射关系。
arm架构下, 在setup_arch中通过paging_init函数初始化内核分页机制之后, 内核通过bootmem_init()开始完成内存结点和内存区域的初始化工作，其函数定义在arch/arm/mm/init.c中，如下所示。
void __init bootmem_init(void)
{
memblock_allow_resize();---解析1
find_limits(&min_low_pfn, &max_low_pfn, &max_pfn);
early_memtest((phys_addr_t)min_low_pfn << PAGE_SHIFT,
(phys_addr_t)max_low_pfn << PAGE_SHIFT);
/*
* sparse_init() tries to allocate memory from memblock, so must be
* done after the fixed reservations
*/
sparse_init();---解析2
/*
* Now free the memory - free_area_init needs
* the sparse mem_map arrays initialized by sparse_init()
* for memmap_init_zone(), otherwise all PFNs are invalid.
*/
zone_sizes_init(min_low_pfn, max_low_pfn, max_pfn);---解析3
}
- 通过memblock拿到limit，DRAM的起始地址的页面号，分别为min = 0x80000, max_low = 0xa0000，内存的结束地址max_high = 0xa0000，early_memtest做内存的Memtest使用，最终会赋值给min_low_pfn(内存块的起始帧号)，max_low_pfn(normal结束帧号)，max_pfn(内存块的结束帧号)。
- 启动并运行bootmem分配器，对于ARM32位系统，该功能不支持，几乎没有做什么。
- zone_sizes_init()来初始化节点和管理区的一些数据项, 其中关键的是初始化了系统中各个内存域的页帧边界，保存在max_zone_pfn数组，从min_low_pfn到max_low_pfn是ZONE_NORMAL，max_low_pfn到max_pfn是ZONE_HIGHMEM。
三、Zone_sizes_init初始化
arch/arm/mm/init.c
static void __init zone_sizes_init(unsigned long min, unsigned long max_low,
unsigned long max_high)
{
unsigned long max_zone_pfn[MAX_NR_ZONES] = { 0 };
#ifdef CONFIG_ZONE_DMA
max_zone_pfn[ZONE_DMA] = min(arm_dma_pfn_limit, max_low);
#endif
max_zone_pfn[ZONE_NORMAL] = max_low;
#ifdef CONFIG_HIGHMEM
max_zone_pfn[ZONE_HIGHMEM] = max_high;
#endif
free_area_init(max_zone_pfn);
}
统计zone_size[0]和zone_size[ZONE_HIGHMEM]的大小，zone_size[0] = 0x20000，zone_size[ZONE_HIGHMEM] = 0。
mm/page_alloc.c
void __init free_area_init(unsigned long *max_zone_pfn)
{
unsigned long start_pfn, end_pfn;
int i, nid, zone;
bool descending;
/* Record where the zone boundaries are */
memset(arch_zone_lowest_possible_pfn, 0,
sizeof(arch_zone_lowest_possible_pfn));
memset(arch_zone_highest_possible_pfn, 0,
sizeof(arch_zone_highest_possible_pfn));
start_pfn = PHYS_PFN(memblock_start_of_DRAM());
descending = arch_has_descending_max_zone_pfns();
for (i = 0; i < MAX_NR_ZONES; i++) {
if (descending)
zone = MAX_NR_ZONES - i - 1;
else
zone = i;
if (zone == ZONE_MOVABLE)
continue;
end_pfn = max(max_zone_pfn[zone], start_pfn);
arch_zone_lowest_possible_pfn[zone] = start_pfn;
arch_zone_highest_possible_pfn[zone] = end_pfn;
start_pfn = end_pfn;
}
/* Find the PFNs that ZONE_MOVABLE begins at in each node */
memset(zone_movable_pfn, 0, sizeof(zone_movable_pfn));
find_zone_movable_pfns_for_nodes();
/* Print out the zone ranges */
pr_info("Zone ranges:\n");
for (i = 0; i < MAX_NR_ZONES; i++) {
if (i == ZONE_MOVABLE)
continue;
pr_info(" %-8s ", zone_names[i]);
if (arch_zone_lowest_possible_pfn[i] ==
arch_zone_highest_possible_pfn[i])
pr_cont("empty\n");
else
pr_cont("[mem %#018Lx-%#018Lx]\n",
(u64)arch_zone_lowest_possible_pfn[i]
<< PAGE_SHIFT,
((u64)arch_zone_highest_possible_pfn[i]
<< PAGE_SHIFT) - 1);
}
/* Print out the PFNs ZONE_MOVABLE begins at in each node */
pr_info("Movable zone start for each node\n");
for (i = 0; i < MAX_NUMNODES; i++) {
if (zone_movable_pfn[i])
pr_info(" Node %d: %#018Lx\n", i,
(u64)zone_movable_pfn[i] << PAGE_SHIFT);
}
/*
* Print out the early node map, and initialize the
* subsection-map relative to active online memory ranges to
* enable future "sub-section" extensions of the memory map.
*/
pr_info("Early memory node ranges\n");
for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid) {
pr_info(" node %3d: [mem %#018Lx-%#018Lx]\n", nid,
(u64)start_pfn << PAGE_SHIFT,
((u64)end_pfn << PAGE_SHIFT) - 1);
subsection_map_init(start_pfn, end_pfn - start_pfn);
}
/* Initialise every node */
mminit_verify_pageflags_layout();
setup_nr_node_ids();
for_each_node(nid) {
pg_data_t *pgdat;
if (!node_online(nid)) {
pr_info("Initializing node %d as memoryless\n", nid);
/* Allocator not initialized yet */
pgdat = arch_alloc_nodedata(nid);
if (!pgdat) {
pr_err("Cannot allocate %zuB for node %d.\n",
sizeof(*pgdat), nid);
continue;
}
arch_refresh_nodedata(nid, pgdat);
free_area_init_memoryless_node(nid);
/*
* We do not want to confuse userspace by sysfs
* files/directories for node without any memory
* attached to it, so this node is not marked as
* N_MEMORY and not marked online so that no sysfs
* hierarchy will be created via register_one_node for
* it. The pgdat will get fully initialized by
* hotadd_init_pgdat() when memory is hotplugged into
* this node.
*/
continue;
}
pgdat = NODE_DATA(nid);
free_area_init_node(nid);
/* Any memory on that node */
if (pgdat->node_present_pages)
node_set_state(nid, N_MEMORY);
check_for_memory(pgdat, nid);
}
memmap_init();
}
- free_area_init_node用来针对特定的节点进行初始化。
zone_size[]数据用于保持不同ZONE类型具有的页表，zhole_size数组用于保持不同的ZONE类型具有的空洞的页数，如下图所示：
接下来看看free_area_init_node的实现接口。
mm/page_alloc.c
static void __init free_area_init_node(int nid)
{
pg_data_t *pgdat = NODE_DATA(nid);---解析1
unsigned long start_pfn = 0;
unsigned long end_pfn = 0;
/* pg_data_t should be reset to zero when it's allocated */
WARN_ON(pgdat->nr_zones || pgdat->kswapd_highest_zoneidx);
get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
pgdat->node_id = nid;
pgdat->node_start_pfn = start_pfn;
pgdat->per_cpu_nodestats = NULL;
if (start_pfn != end_pfn) {
pr_info("Initmem setup node %d [mem %#018Lx-%#018Lx]\n", nid,
(u64)start_pfn << PAGE_SHIFT,
end_pfn ? ((u64)end_pfn << PAGE_SHIFT) - 1 : 0);
} else {
pr_info("Initmem setup node %d as memoryless\n", nid);
}
calculate_node_totalpages(pgdat, start_pfn, end_pfn);---解析2
alloc_node_mem_map(pgdat);---解析3
pgdat_set_deferred_range(pgdat);---解析4
free_area_init_core(pgdat);---解析5
}
- 在NUMA有多个节点，而每个节点内，访问内存的时间是相同的，不同的节点，访问内存的时间可以不同。而对于UMA，只有一个节点，取得该node的pg_data_t数据结构变量，每个node都有一个pg_data_t变量描述，进行初始化工作。node_id=0，node_start_fn = 0x80000, start_fn = 0x80000
- 对节点长度和节点总可用页面数进行初始化。calculate_node_totalpages函数是通过调用zone_spanned_pages_in_node和zone_absent_pages_in_node函数实现的，主要是为pgdat的成员变量(包括空洞在内的总页数(node_spanned_pages))和除空洞外的页数(node_present_pages)设置值
- alloc_node_mem_map() 初始化节点的局部映射地址，即pg_data_t->node_mem_map。在NUMA中，全局mem_map指向系统第一个节点的地址，系统中每个节点的起始地址，都对应在全局mem_map的某个位置。在UMA中，全局mem_map就是节点的node_mem_map
- 由于CONFIG_DEFERRED_STRUCT_PAGE_INIT未定义，该函数为空
- 调用free_area_init_core()来真正初始化每个struct zone中的成员，填充pgdat的ZONE结构体。
3.1、calculate_node_totalpages
对于该函数主要是用来计算每一个zone的总页数和实际页数（不包含空洞），以及内存节点的总页数和实际页数（不包含空洞），其代码实现如下：
mm/page_alloc.c
static void __init calculate_node_totalpages(struct pglist_data *pgdat,
unsigned long node_start_pfn,
unsigned long node_end_pfn)
{
unsigned long realtotalpages = 0, totalpages = 0;
enum zone_type i;
for (i = 0; i < MAX_NR_ZONES; i++) {
struct zone *zone = pgdat->node_zones + i;
unsigned long zone_start_pfn, zone_end_pfn;
unsigned long spanned, absent;
unsigned long size, real_size;
spanned = zone_spanned_pages_in_node(pgdat->node_id, i,
node_start_pfn,
node_end_pfn,
&zone_start_pfn,
&zone_end_pfn);
absent = zone_absent_pages_in_node(pgdat->node_id, i,
node_start_pfn,
node_end_pfn);
size = spanned;
real_size = size - absent;
if (size)
zone->zone_start_pfn = zone_start_pfn;
else
zone->zone_start_pfn = 0;
zone->spanned_pages = size;
zone->present_pages = real_size;
#if defined(CONFIG_MEMORY_HOTPLUG)
zone->present_early_pages = real_size;
#endif
totalpages += size;
realtotalpages += real_size;
}
pgdat->node_spanned_pages = totalpages;
pgdat->node_present_pages = realtotalpages;
pr_debug("On node %d totalpages: %lu\n", pgdat->node_id, realtotalpages);
}
该函数主要计算各个ZONE区的page数目，对于ZONE区，其主要有以下3个
- ZONE_DMA，该管理区是一些设备无法使用DMA访问所有地址的范围，因此特意划分出来的一块内存，专门用于特殊DMA访问分配使用的区域。比如x86架构此区域为0-16M。本处理器该区域不存在。
- ZONE_NORMAL：直接映射区，含有的页面数为0x20000。
- ZONE_HIGHMEM：高端内存管理区，申请的内存，需要内核进行map后才能访问。
- ZONE_MOVABLE：这个区域是一个特殊的存在，主要是为了支持memory hotplug功能，所以MOVABLE表示可移除，其实它也表示可迁移。
简单来说，可迁移的页面不一定都在ZONE_MOVABLE中，但是ZONE_MOVABLE中的也页面必须都是可迁移的，通过查看/proc/pagetypeinfo来看下实例：
ZONE_MOVABLE这个管理区，主要是和memory hotplug功能有关，为什么要设计内存热插拔功能，主要是为了如下考虑：
- 逻辑内存热插拔，对于虚拟机的支持，对于虚拟机按照需求来分配可用内存。
- 物理内存热插拔，对于NUMA服务器的支持，不需要的内存就设置为offline，以降低功耗。
- 优化内存碎片问题。
3.2、alloc_node_mem_map
在linux内核中，所有的物理内存都用struct page结构来描述，这些对象以数组形式存放，而这个数组的地址就是mem_map。内核以节点node为单位，每个node下的物理内存统一管理，也就是说在表示内存node的描述类型struct pglist_data中，有node_mem_map这个成员，其针对平坦型内存进行描述(CONFIG_FLAT_NODE_MEM_MAP)。如果系统只有一个pglist_data对象，那么此对象下的node_mem_map即为全局对象mem_map。函数alloc_remap()就是针对节点node的node_mem_map处理。
mm/page_alloc.c
#ifdef CONFIG_FLATMEM
static void __init alloc_node_mem_map(struct pglist_data *pgdat)
{
unsigned long __maybe_unused start = 0;
unsigned long __maybe_unused offset = 0;
/* Skip empty nodes */
if (!pgdat->node_spanned_pages)---解析1
return;
start = pgdat->node_start_pfn & ~(MAX_ORDER_NR_PAGES - 1);---解析2
offset = pgdat->node_start_pfn - start;
/* ia64 gets its own node_mem_map, before this, without bootmem */
if (!pgdat->node_mem_map) {
unsigned long size, end;
struct page *map;
/*
* The zone's endpoints aren't required to be MAX_ORDER
* aligned but the node_mem_map endpoints must be in order
* for the buddy allocator to function correctly.
*/
end = pgdat_end_pfn(pgdat);---解析3
end = ALIGN(end, MAX_ORDER_NR_PAGES);
size = (end - start) * sizeof(struct page);---解析4
map = memmap_alloc(size, SMP_CACHE_BYTES, MEMBLOCK_LOW_LIMIT,
pgdat->node_id, false);
if (!map)
panic("Failed to allocate %ld bytes for node %d memory map\n",
size, pgdat->node_id);---解析5
pgdat->node_mem_map = map + offset;
}
pr_debug("%s: node %d, pgdat %08lx, node_mem_map %08lx\n",
__func__, pgdat->node_id, (unsigned long)pgdat,
(unsigned long)pgdat->node_mem_map);
#ifndef CONFIG_NUMA
/*
* With no DISCONTIG, the global mem_map is just set as node 0's
*/
if (pgdat == NODE_DATA(0)) {
mem_map = NODE_DATA(0)->node_mem_map;
if (page_to_pfn(mem_map) != pgdat->node_start_pfn)
mem_map -= offset;
}
#endif
}
#else
static inline void alloc_node_mem_map(struct pglist_data *pgdat) { }
#endif /* CONFIG_FLATMEM */
- pgdat->node_spanned_pages此内存节点内无有效的内存，直接略过
- 起始地址必须对其，这个一般按照MB级别对齐即可，对齐后地址与真正开始地址之间的偏移大小，start = 0x80000，offset = 0
- 获取节点内结束页帧号pfn，然后对齐，end = 0xa0000,
- 计算需要的数组大小，需要注意end-start是页帧个数(0xa0000 - 0x80000 = 0x40000)，每个页需要一个struct page对象，所以，这里是乘关系，这样得到整个node内所有以page为单位描述需要占据的内存
- 如果这里分配失败，则通过memblock管理算法分配内存。
3.3、free_area_init_core
mm/page_alloc.c
{
enum zone_type j;
int nid = pgdat->node_id;
pgdat_init_internals(pgdat);---解析1
pgdat->per_cpu_nodestats = &boot_nodestats;
for (j = 0; j < MAX_NR_ZONES; j++) {---解析2
struct zone *zone = pgdat->node_zones + j;
unsigned long size, freesize, memmap_pages;
size = zone->spanned_pages;
freesize = zone->present_pages;
/*
* Adjust freesize so that it accounts for how much memory
* is used by this zone for memmap. This affects the watermark
* and per-cpu initialisations
*/
memmap_pages = calc_memmap_size(size, freesize);
if (!is_highmem_idx(j)) {
if (freesize >= memmap_pages) {
freesize -= memmap_pages;
if (memmap_pages)
pr_debug(" %s zone: %lu pages used for memmap\n",
zone_names[j], memmap_pages);
} else
pr_warn(" %s zone: %lu memmap pages exceeds freesize %lu\n",
zone_names[j], memmap_pages, freesize);
}
/* Account for reserved pages */
if (j == 0 && freesize > dma_reserve) {
freesize -= dma_reserve;
pr_debug(" %s zone: %lu pages reserved\n", zone_names[0], dma_reserve);
}
if (!is_highmem_idx(j))
nr_kernel_pages += freesize;
/* Charge for highmem memmap if there are enough kernel pages */
else if (nr_kernel_pages > memmap_pages * 2)
nr_kernel_pages -= memmap_pages;
nr_all_pages += freesize;
/*
* Set an approximate value for lowmem here, it will be adjusted
* when the bootmem allocator frees pages into the buddy system.
* And all highmem pages will be managed by the buddy system.
*/
zone_init_internals(zone, j, nid, freesize);---解析3
if (!size)
continue;
set_pageblock_order();
setup_usemap(zone);
init_currently_empty_zone(zone, zone->zone_start_pfn, size);---解析4
}
}
- 主要是初始化struct pglist_data，首先初始化pgdat->node_size_lock自旋锁初始化，初始化pgdat->kswapd_wait等待队列，初始化页换出守护进程创建空闲块的大小。
- 遍历各个zone区域，进行如下初始化：
- 根据spanned_pages和present_pages，调用calc_memmap_size计算管理该zone所需的struct page结构所占的页面数memmap_pages。
- zone中的freesize表示可用的区域，需要减去memmap_pages和dma_reserve的区域，如下开发板的Log打印所示：memmap使用1024页，DMA 保留0页。
- 计算nr_kernel_pages和nr_all_pages的数量。
- 初始化zone的其他变量和各种锁。
- 初始化zone结构体的per_cpu_pageset结构体变量pageset，per_cpu_pageset按CPU进行管理。它不直接返回伙伴系统，为快速分配而按不同CPU持有页。
- 初始化zone结构体的free_area结构体。
四、总结
回顾bootmem_init函数时，发现它基本上完成了linux物理内存框架的初始化，包括Node, Zone, Page Frame，以及对应的数据结构等。
4.1、内存分配流程
-
启动阶段： 内核启动时，
bootmem会根据e820提供的内存映射信息，划分出可用的物理内存区域，并将它们添加到空闲内存块链表中。此时，bootmem分配器还未与其他内存分配器（如伙伴系统、Slab 分配器）交互，它的工作只是为启动阶段提供临时的内存支持。 -
分配内存： 当内核需要分配内存时，
bootmem会从空闲内存块链表中选择一个适合的内存块，并将其分配给请求的模块或功能。每次分配都会更新链表，标记已经分配的内存块，并保证不会分配已使用或不可用的内存。 -
内存释放： 当某个内存区域不再需要时，
bootmem会将其释放回空闲链表中，供后续内存分配使用。这通常发生在内核初始化的某些阶段。 -
内存管理完成： 在内核完成启动过程并初始化了其他内存分配器（如伙伴系统或 Slab 分配器）之后，
bootmem内存分配器的工作逐渐过渡给其他更加高效的内存管理系统。
4.2、内存分配器的接口
bootmem 内存分配器提供了一些接口来进行内存的分配和释放：
bootmem_alloc()：用于从bootmem内存池中分配指定大小的内存块。bootmem_free()：释放先前分配的内存块，将内存块重新加入空闲链表中。bootmem_init()：初始化bootmem内存分配器，准备内存池和管理结构。
4.3、Bootmem 与其他内存管理系统的过渡
-
伙伴系统：在 Linux 启动过程中的某个时刻，
bootmem分配器会将内存管理权交给更为高效的伙伴系统（Buddy System）。伙伴系统具有更高的性能和灵活性，能够处理更复杂的内存分配请求。bootmem的内存块管理方式相对简单，无法高效地应对动态内存需求，因此会在内核完成初始化后被替换。 -
Slab 分配器：
bootmem主要用于物理内存的管理，而 Slab 分配器主要用于内核对象的分配与回收，它提供了更高效的内存管理策略。bootmem只能满足内核初始化阶段的需求，一旦系统准备好，Slab 分配器接管后续的内存管理工作。
扫一扫
9083
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
