背景
Read the fucking source code!
--By 鲁迅A picture is worth a thousand words.
--By 高尔基
说明:
- Kernel版本:4.14
- ARM64处理器,Contex-A53,双核
- 使用工具:Source Insight 3.5, Visio
1. 介绍
顺着之前的分析,我们来到了bootmem_init()
函数了,本以为一篇文章能搞定,大概扫了一遍代码之后,我默默的把它拆成了两部分。bootmem_init()
函数代码如下:
void __init bootmem_init(void)
{
unsigned long min, max;
min = PFN_UP(memblock_start_of_DRAM());
max = PFN_DOWN(memblock_end_of_DRAM());
early_memtest(min << PAGE_SHIFT, max << PAGE_SHIFT);
max_pfn = max_low_pfn = max;
arm64_numa_init();
/*
* Sparsemem tries to allocate bootmem in memory_present(), so must be
* done after the fixed reservations.
*/
arm64_memory_present();
sparse_init();
zone_sizes_init(min, max);
memblock_dump_all();
}
这一部分,我们将研究一下Sparse Memory Model
。
在讲Linux内存模型之前,需要补充两个知识点:PFN
和NUMA
。
1.1 physical frame number(PFN)
前面我们讲述过了虚拟地址到物理地址的映射过程,而系统中对内存的管理是以页为单位的:page
:线性地址被分成以固定长度为单位的组,称为页,比如典型的4K大小,页内部连续的线性地址被映射到连续的物理地址中;page frame
:内存被分成固定长度的存储区域,称为页框,也叫物理页。每一个页框会包含一个页,页框的长度和一个页的长度是一致的,在内核中使用struct page
来关联物理页。
如下图,PFN从图片中就能看出来了:
至于__page_to_pfn
这个实现取决于具体的物理内存模型,下文将进行介绍。
1.2 NUMA
UMA: Uniform Memory Access
,所有处理器对内存的访问都是一致的:
从上图中可以看出,当处理器和Core变多的时候,内存带宽将成为瓶颈问题。
NUMA: Non Uniform Memory Access
,非一致性内存访问:
从图中可以看出,每个CPU访问local memory,速度更快,延迟更小。当然,整体的内存构成一个内存池,CPU也能访问remote memory,相对来说速度更慢,延迟更大。目前对NUMA
的了解仅限于此,在内核中会遇到相关的代码,大概知道属于什么范畴就可以了。
2. Linux内存模型
Linux提供了三种内存模型(include/asm-generic/memory_model.h
):
一般处理器架构支持一种或者多种内存模型,这个在编译阶段就已经确定,比如目前在ARM64中,使用的Sparse Memory Model
。
-
Flat Memory
物理内存地址连续,这个也是Linux最初使用的内存模型。当内存有空洞的时候也是可以使用这个模型,只是struct page *mem_map
数组的大小跟物理地址正相关,内存有空洞会造成浪费。 -
Discontiguous Memory
物理内存存在空洞,随着Sparse Memory
的提出,这种内存模型也逐渐被弃用了。 -
Sparse Memory
物理内存存在空洞,并且支持内存热插拔,以section
为单位进行管理,这也是下文将分析的。
Linux三种内存模型下,struct page
到物理page frame
的映射方式也不一样,具体可以查看include/asm-generic/memory_model.h
文件中的__pfn_to_page/__page_to_pfn
定义。
关于内存模型,可以参考Memory: the flat, the discontiguous, and the sparse
3. Sparse Memory
本节分析的是ARM64, UMA(linux4.14中不支持ARM NUMA)
下的Sparse Memory
模型。
3.1 mem_section
在Sparse Memory
模型中,section
是管理内存online/offline
的最小内存单元,在ARM64中,section
的大小为1G,而在Linux内核中,通过一个全局的二维数组struct mem_section **mem_section
来维护映射关系。
函数的调用过程如下所示,主要在arm64_memory_present
中来完成初始化及映射关系的建立:
函数调用结束之后的映射关系如下图所示:
已知一个pfn
时,可以通过__pfn_to_section(pfn)
来最终找到对应的struct page
结构。
3.2 sparse_init
看看sparse_init
函数的调用关系图:
在该函数中,首先分配了usermap,这个usermap与内存的回收机制相关,用4bit的bitmap来描述page block(一个pageblock大小通常为2的次幂,比如MAX_ORDER-1)
的迁移类型:
/* Bit indices that affect a whole block of pages */
enum pageblock_bits {
PB_migrate,
PB_migrate_end = PB_migrate + 3 - 1,
/* 3 bits required for migrate types */
PB_migrate_skip,/* If set the block is skipped by compaction */
/*
* Assume the bits will always align on a word. If this assumption
* changes then get/set pageblock needs updating.
*/
NR_PAGEBLOCK_BITS
};
sparse memory
模型会为每一个section都分配一个usermap
,最终的物理页面的压缩,迁移等操作,都跟这些位相关,如下图所示:
sparse_init
函数中,另一部分的作用是遍历所有present section
,然后将其映射到vmemmap区域空间。vmemmap
区域空间,在之前的文章中也提到过。执行完后,整体的效果如下图所示:
关于Sparse Memory Model
就先分析这么多,只有结合使用sparse memory
的具体模块时,理解才会更顺畅。
一不小心就容易扣细节,而一旦陷入细节,内核就容易变成魔鬼,太难了。
背景
Read the fucking source code!
--By 鲁迅A picture is worth a thousand words.
--By 高尔基
说明:
- Kernel版本:4.14
- ARM64处理器,Contex-A53,双核
- 使用工具:Source Insight 3.5, Visio
1. 介绍
在(四)Linux内存模型之Sparse Memory Model中,我们分析了bootmem_init
函数的上半部分,这次让我们来到下半部分吧,下半部分主要是围绕zone_sizes_init
函数展开。
前景回顾:bootmem_init()
函数代码如下:
void __init bootmem_init(void)
{
unsigned long min, max;
min = PFN_UP(memblock_start_of_DRAM());
max = PFN_DOWN(memblock_end_of_DRAM());
early_memtest(min << PAGE_SHIFT, max << PAGE_SHIFT);
max_pfn = max_low_pfn = max;
arm64_numa_init();
/*
* Sparsemem tries to allocate bootmem in memory_present(), so must be
* done after the fixed reservations.
*/
arm64_memory_present();
sparse_init();
zone_sizes_init(min, max);
memblock_dump_all();
}
在Linux中,物理内存地址区域采用zone
来管理。不打算来太多前戏了,先上一张zone_sizes_init
的函数调用图吧:
需要再说明一点是,使用的是ARM64,UMA(只有一个Node)
,此外,流程分析中那些没有打开的宏,相应的函数就不深入分析了。开始探索吧!
2. 数据结构
关键的结构体如上图所示。
在NUMA
架构下,每一个Node
都会对应一个struct pglist_data
,在UMA
架构中只会使用唯一的一个struct pglist_data
结构,比如我们在ARM64 UMA
中使用的全局变量struct pglist_data __refdata contig_page_data
。
struct pglist_data 关键字段
struct zone node_zones[]; //对应的ZONE区域,比如ZONE_DMA,ZONE_NORMAL等
struct zonelist_node_zonelists[];
unsigned long node_start_pfn; //节点的起始内存页面帧号
unsigned long node_present_pages; //总共可用的页面数
unsigned long node_spanned_pages; //总共的页面数,包括有空洞的区域
wait_queue_head_t kswapd_wait; //页面回收进程使用的等待队列
struct task_struct *kswapd; //页面回收进程
struct zone 关键字段
unsigned long watermark[]; //水位值,WMARK_MIN/WMARK_LOV/WMARK_HIGH,页面分配器和kswapd页面回收中会用到
long lowmem_reserved[]; //zone中预留的内存
struct pglist_data *zone_pgdat; //执行所属的pglist_data
struct per_cpu_pageset *pageset; //Per-CPU上的页面,减少自旋锁的争用
unsigned long zone_start_pfn; //ZONE的起始内存页面帧号
unsigned long managed_pages; //被Buddy System管理的页面数量
unsigned long spanned_pages; //ZONE中总共的页面数,包含空洞的区域
unsigned long present_pages; //ZONE里实际管理的页面数量
struct frea_area free_area[]; //管理空闲页面的列表
宏观点的描述:struct pglist_data
描述单个Node的内存(UMA
架构中的所有内存),然后内存又分成不同的zone
区域,zone
描述区域内的不同页面,包括空闲页面,Buddy System
管理的页面等。
3. zone
上个代码吧:
enum zone_type {
#ifdef CONFIG_ZONE_DMA
/*
* ZONE_DMA is used when there are devices that are not able
* to do DMA to all of addressable memory (ZONE_NORMAL). Then we
* carve out the portion of memory that is needed for these devices.
* The range is arch specific.
*
* Some examples
*
* Architecture Limit
* ---------------------------
* parisc, ia64, sparc <4G
* s390 <2G
* arm Various
* alpha Unlimited or 0-16MB.
*
* i386, x86_64 and multiple other arches
* <16M.
*/
ZONE_DMA,
#endif
#ifdef CONFIG_ZONE_DMA32
/*
* x86_64 needs two ZONE_DMAs because it supports devices that are
* only able to do DMA to the lower 16M but also 32 bit devices that
* can only do DMA areas below 4G.
*/
ZONE_DMA32,
#endif
/*
* Normal addressable memory is in ZONE_NORMAL. DMA operations can be
* performed on pages in ZONE_NORMAL if the DMA devices support
* transfers to all addressable memory.
*/
ZONE_NORMAL,
#ifdef CONFIG_HIGHMEM
/*
* A memory area that is only addressable by the kernel through
* mapping portions into its own address space. This is for example
* used by i386 to allow the kernel to address the memory beyond
* 900MB. The kernel will set up special mappings (page
* table entries on i386) for each page that the kernel needs to
* access.
*/
ZONE_HIGHMEM,
#endif
ZONE_MOVABLE,
#ifdef CONFIG_ZONE_DEVICE
ZONE_DEVICE,
#endif
__MAX_NR_ZONES
};
通用内存管理要应对各种不同的架构,X86,ARM,MIPS...,为了减少复杂度,只需要挑自己架构相关的。目前我使用的平台,只配置了ZONE_DMA
和ZONE_NORMAL
。Log输出如下图:
为什么没有ZONE_NORMAL
区域内,跟踪一通代码发现,ZONE_DMA
区域设置的大小是从起始内存开始的4G区域并且不能超过4G边界区域,而我使用的内存为512M,所以都在这个区域内了。
从上述结构体中可以看到,ZONE_DMA
是由宏定义的,ZONE_NORMAL
才是所有架构都有的区域,那么为什么需要一个ZONE_DMA
区域内,来张图:
所以,如果所有设备的寻址范围都是在内存的区域内的话,那么一个ZONE_NORMAL
是够用的。
4. calculate_node_totalpages
这个从名字看就很容易知道是为了统计Node
中的页面数,一张图片解释所有:
- 前边的文章分析过,物理内存由
memblock
维护,整个内存区域,是有可能存在空洞区域,也就是图中的hole
部分; - 针对每个类型的
ZONE
区域,分别会去统计跨越的page frame
,以及可能存在的空洞,并计算实际可用的页面present_pages
; Node
管理各个ZONE
,它的spanned_pages
和present_pages
是统计各个ZONE
相应页面之和。
这个过程计算完,基本就把页框的信息纳入管理了。
5. free_area_init_core
简单来说,free_area_init_core
函数主要完成struct pglist_data
结构中的字段初始化,并初始化它所管理的各个zone
,看一下代码吧:
/*
* Set up the zone data structures:
* - mark all pages reserved
* - mark all memory queues empty
* - clear the memory bitmaps
*
* NOTE: pgdat should get zeroed by caller.
*/
static void __paginginit free_area_init_core(struct pglist_data *pgdat)
{
enum zone_type j;
int nid = pgdat->node_id;
pgdat_resize_init(pgdat);
#ifdef CONFIG_NUMA_BALANCING
spin_lock_init(&pgdat->numabalancing_migrate_lock);
pgdat->numabalancing_migrate_nr_pages = 0;
pgdat->numabalancing_migrate_next_window = jiffies;
#endif
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
spin_lock_init(&pgdat->split_queue_lock);
INIT_LIST_HEAD(&pgdat->split_queue);
pgdat->split_queue_len = 0;
#endif
init_waitqueue_head(&pgdat->kswapd_wait);
init_waitqueue_head(&pgdat->pfmemalloc_wait);
#ifdef CONFIG_COMPACTION
init_waitqueue_head(&pgdat->kcompactd_wait);
#endif
pgdat_page_ext_init(pgdat);
spin_lock_init(&pgdat->lru_lock);
lruvec_init(node_lruvec(pgdat));
pgdat->per_cpu_nodestats = &boot_nodestats;
for (j = 0; j < MAX_NR_ZONES; j++) {
struct zone *zone = pgdat->node_zones + j;
unsigned long size, realsize, freesize, memmap_pages;
unsigned long zone_start_pfn = zone->zone_start_pfn;
size = zone->spanned_pages;
realsize = 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, realsize);
if (!is_highmem_idx(j)) {
if (freesize >= memmap_pages) {
freesize -= memmap_pages;
if (memmap_pages)
printk(KERN_DEBUG
" %s zone: %lu pages used for memmap\n",
zone_names[j], memmap_pages);
} else
pr_warn(" %s zone: %lu pages exceeds freesize %lu\n",
zone_names[j], memmap_pages, freesize);
}
/* Account for reserved pages */
if (j == 0 && freesize > dma_reserve) {
freesize -= dma_reserve;
printk(KERN_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->managed_pages = is_highmem_idx(j) ? realsize : freesize;
#ifdef CONFIG_NUMA
zone->node = nid;
#endif
zone->name = zone_names[j];
zone->zone_pgdat = pgdat;
spin_lock_init(&zone->lock);
zone_seqlock_init(zone);
zone_pcp_init(zone);
if (!size)
continue;
set_pageblock_order();
setup_usemap(pgdat, zone, zone_start_pfn, size);
init_currently_empty_zone(zone, zone_start_pfn, size);
memmap_init(size, nid, j, zone_start_pfn);
}
}
- 初始化
struct pglist_data
内部使用的锁和队列;
遍历各个zone
区域,进行如下初始化:
-
根据
zone
的spanned_pages
和present_pages
,调用calc_memmap_size
计算管理该zone
所需的struct page
结构所占的页面数memmap_pages
; -
zone
中的freesize
表示可用的区域,需要减去memmap_pages
和DMA_RESERVE
的区域,如下图在开发板的Log打印所示:memmap
使用2048
页,DMA
保留0页; -
计算
nr_kernel_pages
和nr_all_pages
的数量,为了说明这两个参数和页面的关系,来一张图(由于我使用的平台只有一个ZONE_DMA
区域,且ARM64
没有ZONE_HIGHMEM
区域,不具备典型性,故以ARM32
为例): -
初始化
zone
使用的各类锁; -
分配和初始化
usemap
,初始化Buddy System
中使用的free_area[]
,lruvec
,pcp
等; -
memmap_init()->memmap_init_zone()
,该函数主要是根据PFN
,通过pfn_to_page
找到对应的struct page
结构,并将该结构进行初始化处理,并设置MIGRATE_MOVABLE
标志,表明可移动;
最后,当我们回顾bootmem_init
函数时,发现它基本上完成了linux物理内存框架的初始化,包括Node
, Zone
, Page Frame
,以及对应的数据结构等。
结合上篇文章(四)Linux内存模型之Sparse Memory Model阅读,效果会更佳噢!
持续中...
在bootmem_init初始化的时候,已经初始化了内存节点的zone成员,该成员是struct zone数组,存放该内存节点的zone信息。在linux的内存管理中,分几个阶段进行抽象,用数据结构来管理。先用结点集合管理内存,然后用zone管理结点,再用页的管理zone。此时使用的数据结构分别为pglist_data、zone、page结构体,本章的主要是来分析内核是如何完成zonelist的初始化。
1. 数据结构
在结点的pglist_data数据结构中有一个node_zone_list[]类型的struct zonelist
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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指针和索引号构成。
struct zoneref {
struct zone *zone; /* Pointer to actual zone */
int zone_idx; /* zone_idx(zoneref->zone) */
};
1
2
3
4
2. zonelist初始化
内核在start_kernel中通过build_all_zonelists完成了内存结点及其管理内存域的初始化工作, 调用如下
void __ref build_all_zonelists(pg_data_t *pgdat, struct zone *zone)
{
set_zonelist_order(); ----------------(1)
if (system_state == SYSTEM_BOOTING) { ----------------(2)
build_all_zonelists_init();
} else {
#ifdef CONFIG_MEMORY_HOTPLUG
if (zone)
setup_zone_pageset(zone);
#endif
/* we have to stop all cpus to guarantee there is no user
of zonelist */
stop_machine(__build_all_zonelists, pgdat, NULL);
/* cpuset refresh routine should be here */
}
vm_total_pages = nr_free_pagecache_pages(); ----------------(3)
/*
* 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)) ----------------(4)
page_group_by_mobility_disabled = 1;
else
page_group_by_mobility_disabled = 0;
----------------(5)
pr_info("Built %i zonelists in %s order, mobility grouping %s. Total pages: %ld\n",
nr_online_nodes,
zonelist_order_name[current_zonelist_order],
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
1.调用set_zonelist_order函数决定zone排列方式;按照相同区域排列,还是以节点为基准排列
2.不同的系统状态调用的函数不同,系统状态为启动阶段时(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;
1
2
3
4
5
6
7
3.调用nr_free_pagecache_pages,从函数名字可以看出,该函数求出可处理的空页数
4.通过nr_free_pagecache_pages求出vm_total_pages和页移动性比较,决定是否激活grouping
5.打印到控制台,打印的信息输出内容为online node、zone列表顺序,是否根据移动性对页面执行集合(grouping)、vm_total_pages、NUMA时输出policy zone
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KWlvYpMv-1592019440924)(D:\学习总结\内存管理单元\image-20200606225539321.png)]
2.1. set_zonelist_order
set_zonelist_order函数决定用节点顺序构建还是用zone顺序构建,其定义如下
static void set_zonelist_order(void)
{
if (user_zonelist_order == ZONELIST_ORDER_DEFAULT)
current_zonelist_order = default_zonelist_order();
else
current_zonelist_order = user_zonelist_order;
}
1
2
3
4
5
6
7
该函数检查user_zonelist_order是否为ZONELIST_ORDER_DEFAULT,user_zonelist_order具有以下3个值之一
#define ZONELIST_ORDER_DEFAULT 0
#define ZONELIST_ORDER_NODE 1
#define ZONELIST_ORDER_ZONE 2
1
2
3
如果是user_zonelist_order,就调用default_zonelist_order,决定将zonelist顺序作为节点顺序还是zone顺序,否则用user_zonelist_order,如果是32位系统,其为ZONELIST_ORDER_ZONE,而如果是64位系统,则为ZONELIST_ORDER_NODE。即为zone优先还是节点优先。
假设节点0的zone类型由ZONE_NORMAL和ZONE_DMA构成,节点1由ZONE_NORMAL构成,可将节点0的zonelist按下面构建
类型A,Node(0)ZONE_NORMAL->Node(0)ZONE_DMA->Node(1)ZONE_NORMAL
类型B,Node(0)ZONE_NORMAL->Node(1)ZONE_NORMAL->Node(0)ZONE_DMA
对于类型A,如果节点0的ZONE_NORMAL中无法分配内存,就从节点0的ZONE_DMA开始分配内存,但由于一般ZONE_DMA区域比较小,就会发生ZONE_DMA的OOM(Out of memory)问题
对于类型B,如果节点的ZONE_NORMAL中无法分配内存,就从节点1的ZONE_NORMAL开始分配。
因此对于类型A为节点优先,类型B为zone顺序优先。
2.2 build_all_zonelists_init
构建备用列表的主要工作是在__build_all_zonelists函数中实现的,其主要是遍历每一个节点,然后调用build_zonelists
static int __build_all_zonelists(void *data)
{
int nid;
int cpu;
pg_data_t *self = data;
#ifdef CONFIG_NUMA
memset(node_load, 0, sizeof(node_load));
#endif
if (self && !node_online(self->node_id)) {
build_zonelists(self);
}
for_each_online_node(nid) {
pg_data_t *pgdat = NODE_DATA(nid);
build_zonelists(pgdat);
}
for_each_possible_cpu(cpu) {
setup_pageset(&per_cpu(boot_pageset, cpu), 0);
#ifdef CONFIG_HAVE_MEMORYLESS_NODES
if (cpu_online(cpu))
set_cpu_numa_mem(cpu, local_memory_node(cpu_to_node(cpu)));
#endif
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
其主要是来分析下build_zonelists的流程
static void build_zonelists(pg_data_t *pgdat)
{
int i, node, load;
nodemask_t used_mask;
int local_node, prev_node;
struct zonelist *zonelist;
unsigned int order = current_zonelist_order;
/* initialize zonelists */
for (i = 0; i < MAX_ZONELISTS; i++) { ------------(1)
zonelist = pgdat->node_zonelists + i;
zonelist->_zonerefs[0].zone = NULL;
zonelist->_zonerefs[0].zone_idx = 0;
}
/* NUMA-aware ordering of nodes */
local_node = pgdat->node_id;
load = nr_online_nodes;
prev_node = local_node;
nodes_clear(used_mask);
memset(node_order, 0, sizeof(node_order));
i = 0;
while ((node = find_next_best_node(local_node, &used_mask)) >= 0) { ------------(2)
/*
* 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] = load;
prev_node = node;
load--;
if (order == ZONELIST_ORDER_NODE) ------------(3)
build_zonelists_in_node_order(pgdat, node);
else
node_order[i++] = node; /* remember order */
}
if (order == ZONELIST_ORDER_ZONE) { ------------(4)
/* calculate node order -- i.e., DMA last! */
build_zonelists_in_zone_order(pgdat, i);
}
build_thisnode_zonelists(pgdat); ------------(5)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
从当前节点的节点描述符pgdat访问struct zonelist结构体类型node_zonelists,并初始化成员变量zone和zone_idx。
调用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列表
static void build_zonelists_in_node_order(pg_data_t *pgdat, int node)
{
int j;
struct zonelist *zonelist;
zonelist = &pgdat->node_zonelists[ZONELIST_FALLBACK];
for (j = 0; zonelist->_zonerefs[j].zone != NULL; j++)
;
j = build_zonelists_node(NODE_DATA(node), zonelist, j);
zonelist->_zonerefs[j].zone = NULL;
zonelist->_zonerefs[j].zone_idx = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
该函数以节点为单位构建备份列表,各节点的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。
static int build_zonelists_node(pg_data_t *pgdat, struct zonelist *zonelist,
int nr_zones)
{
struct zone *zone;
enum zone_type zone_type = MAX_NR_ZONES;
do {
zone_type--; ------------(1)
zone = pgdat->node_zones + zone_type;
if (managed_zone(zone)) { ------------(2)
zoneref_set_zone(zone,
&zonelist->_zonerefs[nr_zones++]);
check_highest_zone(zone_type);
}
} while (zone_type);
return nr_zones;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
将节点的zone注册到备份列表时,zone的类型是按照逆时针注册的。即HIGHMEM->NORMAL->DMA32->DMA的顺序。也就是说HIGHMEM中没有内存,就从NORMAL开始分配;如果NORMAL没有内存,就从DMA开始分配。这样为了减小分配内存时候发生的OOM风险,最大降低对系统的影响
当在相应的zone中有实际的物理内存时就将zone注册到_zonerefs[]数组
2.3 输出备用列表信息
下面分析mminit_verify_zonelist函数
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;
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) {
#ifdef CONFIG_NUMA
pr_cont("%d:%s ", zone->node, zone->name);
#else
pr_cont("0:%s ", zone->name);
#endif /* CONFIG_NUMA */
}
pr_cont("\n");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
该函数,对各个节点进行遍历,对各个节点具有的最大ZONE数,输出zonelist的信息,对各个zonelist输出zone名称。该函数输出系统内所有节点的备份列表信息,只是执行for循环访问节点的备份列表,输出构建备份列表的zone节点号和节点名。
2.4 处理页分配请求节点
cpuset_init_current_mems_allowed函数只调用nodes_setall函数,在当前任务current的mems_allowed位图中,将系统的所有节点设置为1。mems_allowed位图决定处理当前任务中发生的页分配请求的节点。
void __init cpuset_init_current_mems_allowed(void)
{
nodes_setall(current->mems_allowed);
}
1
2
3
4
2.5 求空页数
将gfp_zone(GFP_HIGHUSER_MOVABLE)的结果值作为参数传递,gfp_zone函数对传递来的参数标签值进行检查并返回zone类型,并返回zone类型中的可用页数。
unsigned long nr_free_pagecache_pages(void)
{
return nr_free_zone_pages(gfp_zone(GFP_HIGHUSER_MOVABLE));
}
1
2
3
4
下面来看看nr_free_zone_pages函数
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;
unsigned long high = high_wmark_pages(zone);
if (size > high)
sum += size - high;
}
return sum;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
该函数主要是对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会用到。
该函数主要是用于求出可处理的空页数。
2.6 页移动性
if (vm_total_pages < (pageblock_nr_pages * MIGRATE_TYPES))
page_group_by_mobility_disabled = 1;
else
page_group_by_mobility_disabled = 0;
1
2
3
4
通过前面的函数求出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)
1
2
3
MIGRATE_TYPES表示移动类型的宏,其值为5,其定义为
enum {
MIGRATE_UNMOVABLE, //不可以动
MIGRATE_MOVABLE, //可回收
MIGRATE_RECLAIMABLE, //可移动
MIGRATE_PCPTYPES,
MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
MIGRATE_TYPES
}
1
2
3
4
5
6
7
8
通过以上方式,最终构建了free_list以移动性为基准执行的页集合,其主要有以下好处
防止内存碎片:以顺序为单位对具有相同移动属性的页执行集合,防止内存碎片
分配大内存的方法:将具有相同移动属性的页集合在一处,使其能够在大内存分配中使用,例如
内核内存(kmalloc): UNMOVABLE
磁盘缓存(inode、dentry):RECLAIMABLE
用户内存+页缓存:MOVABLE
3 总结
build_all_zonelists()用来初始化内存分配器使用的存储节点中的管理区链表,是为内存管理算法(伙伴管理算法)做准备工作的,对Linux管理的各内存结构体进行初始化和设置操作,如下图所示