linux内核虚拟内存之物理内存

内存访问分为两种体系结构：一致性内存访问（UMA）和非一致性内存访问（NUMA）。NUMA指CPU对不同内存单元的访问时间可能不一样，因而这些物理内存被划分为几个节点，每个节点里的内存访问时间一致，NUMA体系结构主要存在大型机器、alpha等，嵌入式的基本都是UMA。UMA也使用了节点概念，只是永远都只有1个节点。本文讲的是UMA模型的嵌入式平台，linux版本：3.10.y。

每个节点又将物理内存划分为3个管理区，在x86机器上管理区如下：

ZONE_DMA：0~16MB

ZONE_NORMAL：16MB~896MB

ZONE_HIGHMEM：896~末尾（对于64位，则不需要高端内存，虚拟地址足够直接映射）

而在hi3536嵌入式平台上实际的使用时由于系统mem没有超过896M，因此只有一个管理区ZONE_NORMAL（cat /proc/buddyinfo）：

Node 0, zone Normal 70 70 36 22 11 10 2 2 3 2 37

每个管理区管理该内存区域内的所有页面（linux中每个页面的大小为4KB）。

以下linux物理内存组织结构标准的关系图：

在Documentation/arm/memory.txt文件中定义了arm平台的线性地址空间布局情况，其与物理内存关系图：

当用户空间和内核空间比例3:1时，PAGE_OFFSET=0xC0000000。上面橙色虚线地址是一一映射关系，而高于highmem则需要vmalloc申请使用。

PHYS_OFFSET=0x40000000

ZRELADDR == virt_to_phys(PAGE_OFFSET +TEXT_OFFSET) = virt_to_phys (TEXT_ADDR) = 0x40008000

INITRD_PHYS= 0x00800000

PARAMS_PHYS= 0x00000100

high_memory和VMALLOC_START之间保留了8M空间间隙

high_memory=PAGE_OFFSET+ highmem

当系统内存在0~896MB时，highmem=系统内存

当系统内存>896MB时，highmem=896MB，多余的内存需要vmalloc映射访问

VMALLOC_START和VMALLOC_END-1之间用于vmalloc() / ioremap() space映射。

cat /proc/vmallocinfo：

0xfb000000-0xfe190000 51970048iotable_init+0x0/0xb0 phys=10000000 ioremap

映射了CPU寄存器空间

1、节点

每个节点由struct pglist_data定义（include/linux/mmzone.h）：

typedef struct pglist_data {

#define MAX_NR_ZONES 3

struct zonenode_zones[MAX_NR_ZONES]; //分别代表3个管理区

#define MAX_ZONELISTS 1

struct zonelistnode_zonelists[MAX_ZONELISTS]; //按照分配时的管理区顺序排列，如果在ZONE_HIGHMEM中分配失败，就有可能还原成ZONE_NORMAL或ZONE_DMA。

int nr_zones; //表示管理区的数目，值为1、2、3。

struct page *node_mem_map; //指向该节点第一个物理页面

struct bootmem_data*bdata; //指向内存引导程序

unsigned longnode_start_pfn; //该节点的起始页编号

//calculate_node_totalpages中对以下两个值进行计算

unsigned long node_present_pages;/* total number of physical pages */

unsigned longnode_spanned_pages; /* total size of physical pagerange, including holes */

int node_id; //节点号，在嵌入式上一般为0

nodemask_treclaim_nodes; /* Nodes allowed toreclaim from */

wait_queue_head_tkswapd_wait; //交换守护进程kswapd使用的等待队列

wait_queue_head_tpfmemalloc_wait;

struct task_struct*kswapd; //指向交换守护进程描述符

int kswapd_max_order;

enum zone_type classzone_idx; //管理区类型

} pg_data_t;

include/linux/mmzone.h中定义了全局节点：

extern struct pglist_data contig_page_data;

#define NODE_DATA(nid) (&contig_page_data)

mm/bootmem.c进行全局节点定义：

struct pglist_data __refdata contig_page_data = {

.bdata =&bootmem_node_data[0]

};

EXPORT_SYMBOL(contig_page_data);

2、管理区

每个管理区由structzone描述（include/linux/mmzone.h）：

struct zone {

unsigned longwatermark[NR_WMARK]; //该管理区的三个水平线值，min, low, high

unsigned long percpu_drift_mark;

unsigned long lowmem_reserve[MAX_NR_ZONES]; //每个管理区必须保留的页框数

unsigned long dirty_balance_reserve;

struct per_cpu_pageset __percpu*pageset; //CPU的页面缓存

spinlock_t lock; //保护该管理区的自旋锁

int all_unreclaimable; /* All pagespinned */

struct free_area free_area[MAX_ORDER]; //通过伙伴算法管理的空闲页面

ZONE_PADDING(_pad1_)

spinlock_t lru_lock;

struct lruvec lruvec;

unsigned long pages_scanned; //管理区回收页框时使用的计数器，记录上一次回收一同扫描过的页框

unsigned long flags; /* zone flags, see below */

/* Zone statistics */

atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];

unsigned int inactive_ratio;

ZONE_PADDING(_pad2_)

wait_queue_head_t * wait_table; //进程等待的散列表，这些进程正在等待管理区中的某页

unsigned long wait_table_hash_nr_entries; //散列表数组的大小

unsigned long wait_table_bits; //散列表数组的大小对2取log的结果

struct pglist_data *zone_pgdat; //管理区属于的节点

/* zone_start_pfn ==zone_start_paddr >> PAGE_SHIFT */

unsigned long zone_start_pfn; //管理区的起始页号

unsigned long spanned_pages; //管理区的大小包括洞

unsigned long present_pages; //管理区的大小不包括洞

unsigned long managed_pages;

const char *name; //管理区名字，DMA、NORMAL orHIGHMEM

}

当系统中的可用内存很少时，守护程序kswapd被唤醒释放页面。每个管理区通过数组watermark来决定唤醒还是睡眠kswapd守护进程，这个数组通过下面的枚举来分别代表page_min, page_low, page_high，他们的之间的关系图如下图：

enum zone_watermarks {

WMARK_MIN,

WMARK_LOW,

WMARK_HIGH,

NR_WMARK

};

page_low：当空闲页面数达到pages_low时，伙伴算法分配器就会唤醒kswapd释放页面。

page_min：当达到pages_min时，kswap没唤醒则唤醒，同时同步进程释放内存，如果申请内存远远超过实际内存，就会出现out_of_memory。page_min包含里管理区最小保留内存，因此这是GFP_ATOMIC还可以分配出内存。

page_high：当释放页面达到这个值，认为该管理区已经平衡，kswapd开始睡眠。

当多个进程对同一个页面进行IO操作（个人理解觉得更应该是有写操作）时，比如页面换入或换出，为了防止访问数据的不一致性，该页面会被锁住，而其他进程则通过wait_on_page()函数被添加到等待队列中。如果每个页面都有等待队列则系统会花费大量的内存存放，linux则是将等待队列存储在管理区的wait_table散列表中，这样就只有一个等待队列。其简单流程图如下：

当申请分配标志为GFP_ATOMIC时则不会睡眠，因为该标志不能睡眠的内存分配标志，用在中断处理程序、下半部、持有自旋锁以及其他不能睡眠的地方。

3、物理页面

系统中的每个物理页面都由structpage用以记录该页面的状态，结构体包含了很多union，因为现在有slab/slob/slub三种分配器使用其中一种即可，定义如下（include/linux/mm_types.h）：

struct page {

/* First double word block */

unsigned long flags; //存放页的状态

struct address_space*mapping; //如果低位是clear的，则内存映射到文件或设备，它指向文件或设备节点inode的address_space，或者NULL；如果内存映射到匿名则低位被设置，指向匿名对象objects。

/* Second double word*/

struct {

union {

pgoff_tindex; //页面是文件映射的一部分，它就是页面在文件中的偏移；页面是交换高速缓存一部分，它就是在交换地址空间中address_space的偏移量

void*freelist; //指向slub/slob第一个空闲对象

boolpfmemalloc;

};

union {

unsigned counters;

struct {

union {

atomic_t_mapcount;

struct {/* SLUB */

unsigned inuse:16;

unsigned objects:15;

unsigned frozen:1;

};

intunits; /* SLOB */

};

atomic_t _count; //页的引用计数

};

/* Third double word block*/

union {

struct list_headlru; //最近最少使用（LRU）链表的链表首部

struct { /* slub per cpu partial pages */

struct page*next; /* Next partial slab */

short int pages;

short intpobjects;

};

struct list_headlist; //slob列表

struct slab *slab_page;/* slab fields */

};

/* Remainder is not doubleword aligned */

union {

unsigned long private;

struct kmem_cache*slab_cache; /* SL[AU]B: Pointer to slab*/

struct page*first_page; /* Compound tail pages */

};

#if defined(WANT_PAGE_VIRTUAL)

void *virtual; /* Kernel virtual address (NULL if

notkmapped, ie. highmem) */

#endif /* WANT_PAGE_VIRTUAL */

}

Flags的最高ZONES_SHIFT位记录该页面所属的管理区。set_page_zone函数设置页面的管理区。

4、源码解析

linux内核的内存管理分三个阶段。
A. 启动---->bootmem初始化完成为第一阶段。此阶段只能使用memblock_reserve函数分配内存。
B. bootmem初始化完--->buddy完成前。该阶段使用引导内存分配器（boot memoryallocator）分配内存。
C. 全部内存初始化完毕，可以用cache和buddy分配内存。

(1)~(4)点完成第一阶段，该阶段主要在start_kernel—> setup_arch函数实现:

（1）获取总内存

parse_early_param—> early_mem函数根据uboot传递进来的命令行参数mem=size@start计算出起始和内存大小通过arm_add_memory添加到meminfo全局数组里。

这里需要注意parse_early_param之前setup_machine_tags里parse_tags中的parse_tag_mem32也会解析uboot通过tags方法传递进来的系统内存，但是被early_mem覆盖重新计算。

（2）计算高端内存

sanity_check_meminfo（arch/arm/mm/mmu.c）对meminfo里的内存进行判断，是否需要划分为高端内存。

（3）计算保留内存块

保留内存块包括内核（数据段，代码段等）、页目录等占用的内存块。通过arm_memblock_init（arch/arm/mm/init.c）实现：

A．将meminof内存通过memblock_add加到memblock.memory类型内存块里（包含全部物理内存）

B．通过memblock_reserve将保留内存添加到memblock.reserved类型内存块里

memblock_reserve(__pa(_stext), _end -_stext); 内核通过查看System.map可以看到

arm_mm_memblock_reserve(); //页表

最终结果显示如下：

MEMBLOCK configuration:

memory size = 0xfa00000（250M） reservedsize = 0x6ba3cc

memory.cnt = 0x1

memory[0x0] [0x00000040000000-0x0000004f9fffff], 0xfa00000 bytes

reserved.cnt = 0x2

reserved[0x0] [0x00000040004000-0x00000040007fff], 0x4000 bytes //页表

reserved[0x1] [0x000000400081c0-0x000000406be58b], 0x6b63cc bytes //内核

在伙伴算法完成之前，内存的分配通过该方式进行。

（4）paging_init

该函数arch/arm/mm/mmu.c实现，完成页表设置、管理区zone、设置零页等。

*paging_init() sets up the page tables, initialises the zone memory

*maps, and sets up the zero page, bad page and bad page tables.

void __init paging_init(struct machine_desc*mdesc)

{

void *zero_page;

memblock_set_current_limit(arm_lowmem_limit);

build_mem_type_table();//建立各种类型页表的属性（内存MEMORY类型，设备DEVICE，中断向量表是HIGH_VECTORS），根据不同arm体系进行初始化，这是因为地址转换由MMU硬件单元根据页表处理，每个体系的MMU单元有差别（不是很明白）。

/*以下见第二章页表管理*/

prepare_page_table(); //清除在这之前建立的临时页表，以便下面建立正式链表

map_lowmem(); //为低端内存建立一一的映射表（0~ arm_lowmem_limit），存放在swapper_pg_dir位置，用到前面的页表类型：MT_MEMORY

dma_contiguous_remap(); //建立DMA映射表，类型为：MT_MEMORY_DMA_READY

devicemaps_init(mdesc); //完成ffff0000开始的中断向量映射表，完成CPU IO映射表（从0x10000000~0x13190000就是控制器地址空间）、刷新一下TLB

kmap_init(); //申请kmap高端内存永久映射的页表项，虚拟空间为2M（0xbfe00000 - 0xc0000000），如果未定义高端内存（CONFIG_HIGHMEM）什么也不做。

tcm_init(); //do nothing

//关于页表见第二章，此处返回中断向量表0xffff0000在pgd中的偏移量

top_pmd = pmd_off_k(0xffff0000);

/* allocate the zero page. */

zero_page = early_alloc(PAGE_SIZE);

bootmem_init(); //见下一节重点分析

//一种特殊的页，供初始化为0的数据和写时复制使用

empty_zero_page = virt_to_page(zero_page);

__flush_dcache_page(NULL, empty_zero_page);

}

（4-1）bootmem_init

在arch/arm/mm/init.c中定义，完成buddy管理内存需要的工作。

void __init bootmem_init(void)

{

unsigned longmin, max_low, max_high;

max_low = max_high = 0;

find_limits(&min,&max_low, &max_high); //最小物理页号，低端内存最大物理页号，高端内存最大物理页号

/* 申请低端内存所需位图的空间，然后赋值给节点pgdat->bdata（pgdat = NODE_DATA(0);只有一个节点，实际为一个全局变量contig_page_data）并将位图所在内存空间保留（memblock.reserved），bdata->node_bootmem_map指向位图空间（bdata 为struct bootmem_data）；先将memblock.memory内存（所有物理内存）的位图清零—表示未使用，再将memblock.reserved 内存的位图置1—表示使用

node_bootmem_map:cf9f7000，该部分内存空间在建立伙伴系统的时候释放，所以放在内存的末端

arm_bootmem_init(min, max_low);

arm_memory_present(); //do nothing

sparse_init();//do nothing

arm_bootmem_free(min, max_low, max_high); //见下一节介绍

max_low_pfn =max_low - PHYS_PFN_OFFSET; //低端内存的物理页数目

max_pfn = max_high- PHYS_PFN_OFFSET; //高端内存的物理页数目

}

（4-2）arm_bootmem_free

该函数（arch/arm/mm/init.c）先计算zone_size和zhole_size，然后调用free_area_init_node（mm/page_alloc.c），因此这里主要分析free_area_init_node函数：

void __paginginit free_area_init_node(intnid, unsigned long *zones_size,

unsigned long node_start_pfn, unsigned long *zholes_size)

{

pg_data_t *pgdat = NODE_DATA(nid);

pgdat->node_id = nid;

pgdat->node_start_pfn = node_start_pfn;

init_zone_allows_reclaim(nid);

//计算节点的node_spanned_pages和node_present_pages，没有高端内存两者相等

calculate_node_totalpages(pgdat, zones_size, zholes_size);

//申请所有物理页描述结构体（structpage）所需要的内存空间，mem_map= NODE_DATA(0)->node_mem_map指向该空间

alloc_node_mem_map(pgdat); //空间大小：page size:200000//2M

printk("free_area_init_node: node %d, pgdat %08lx, node_mem_map%08lx\n",

nid, (unsigned long)pgdat, (unsigned long)pgdat->node_mem_map);

free_area_init_node:node 0, pgdat c06535c0（内核数据区）, node_mem_map c06bf000（内核bss后面申请的一个内存地址）

free_area_init_core(pgdat, zones_size, zholes_size); //见下节

}

（4-3）free_area_init_core

该函数（mm/page_alloc.c）实现如下：

static void __paginginitfree_area_init_core(struct pglist_data *pgdat,

unsigned long *zones_size, unsigned long *zholes_size)

{

enum zone_type j;

int nid = pgdat->node_id;

unsigned long zone_start_pfn = pgdat->node_start_pfn;

int ret;

//初始化自旋锁和相关等待队列

pgdat_resize_init(pgdat);

init_waitqueue_head(&pgdat->kswapd_wait);

init_waitqueue_head(&pgdat->pfmemalloc_wait);

pgdat_page_cgroup_init(pgdat);

//初始化各个管理区

for (j = 0; j < MAX_NR_ZONES; j++) {

struct zone *zone = pgdat->node_zones + j;

unsigned long size, realsize, freesize, memmap_pages;

/*重新计算管理区的大小（减去struct page所占用的内存空间）*/

size = zone_spanned_pages_in_node(nid, j, zones_size);

realsize = freesize = size - zone_absent_pages_in_node(nid, j,

zholes_size);

memmap_pages = calc_memmap_size(size, realsize);

if (freesize >= memmap_pages) {

freesize -= memmap_pages;

}

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;

zone->spanned_pages = size;

zone->present_pages = realsize;

* 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;

zone->name = zone_names[j];

//初始化其他自旋锁

spin_lock_init(&zone->lock);

spin_lock_init(&zone->lru_lock);

zone_seqlock_init(zone);

//指向节点

zone->zone_pgdat = pgdat;

zone_pcp_init(zone); //初始化CPU页面缓存

lruvec_init(&zone->lruvec); //初始化lru

if (!size)

continue;

set_pageblock_order();

setup_usemap(pgdat, zone, zone_start_pfn, size);

//初始化该管理区的wait_table和free_area(伙伴算法)

ret = init_currently_empty_zone(zone, zone_start_pfn,

size, MEMMAP_EARLY);

BUG_ON(ret);

//初始化该管理区的所有物理页结构体struct page

memmap_init(size, nid, j, zone_start_pfn);

zone_start_pfn += size;

}

（5）setup_per_cpu_areas

在init/main.c的start_kernel调用，在mm/percpu.c中定义，只有在SMP系统下才有用，在UP不做任何处理。

该函数主要是为每个处理器设置per-cpu数据区域，per_cpu数据由各个CPU独立使用，即使不锁访问，十分有效。per-cpu数据按照不同的CPU类型使用，以将性能低下引发的缓存一致性问题减小到最小。

（6）build_all_zonelists

在init/main.c的start_kernel调用，在mm/page_alloc.c中定义。初始化每个节点内的zonelists。

（7）mm_init 设置内存分配器

在init/main.c中定义，主要用于设设置伙伴算法内存分配器。源码如下：

static void __init mm_init(void)

{

* page_cgroup requires contiguous pages,

* bigger than MAX_ORDER unless SPARSEMEM.

page_cgroup_init_flatmem();

mem_init(); //见下面

kmem_cache_init(); //建立kmem_cache和kmem_cache_node两个高速缓存（slab分配器使用）。

percpu_init_late();

pgtable_cache_init(); //do nothing

vmalloc_init(); //vmalloc分配的内存虚拟地址连续，而物理地址无需连续，这里初始vmalloc要用的相关链表等准备工作。

}

void __init mem_init(void)

{

unsigned long reserved_pages, free_pages;

struct memblock_region *reg;

int i;

max_mapnr = pfn_to_page(max_pfn+ PHYS_PFN_OFFSET) - mem_map;

//以下两者都是释放空闲内存到伙伴系统：memblock的空闲内存，后者是bootmem的空闲内存，其实两者有交叠，伙伴系统会尝试与前后连续页框组成更大的页框块。

/* bootmem分配器核心就是node_bootmem_map这个位图，每一位代表这个node的一个页，当需要分配时就会扫描这个位图，然后获取一段物理页框进行分配，一般都会从开始处向后进行分配，并没有什么特殊的算法在其中。而伙伴系统初始化时页会根据这个位图，将位图中空闲的页释放回到伙伴系统中，而已经分配出去的页则不会在初始化阶段释放回伙伴系统，不过有可能会在系统运行过程中释放回伙伴系统中。*/

free_unused_memmap(&meminfo); //根据代码只有一个bank，所以没做啥事情

totalram_pages+= free_all_bootmem();

//释放高端内存到伙伴系统

free_highpages();

reserved_pages = free_pages = 0;

//统计空闲内存和保留内存并打印出来

for_each_bank(i, &meminfo) {

struct membank *bank = &meminfo.bank[i];

unsigned int pfn1, pfn2;

struct page *page, *end;

pfn1 = bank_pfn_start(bank);

pfn2 = bank_pfn_end(bank);

page = pfn_to_page(pfn1);

end = pfn_to_page(pfn2 - 1) + 1;

do {

if (PageReserved(page))

reserved_pages++;

else if (!page_count(page))

free_pages++;

page++;

} while (page < end);

}

（8）伙伴算法建立后物理内存分布

经过上面源码分析后，下图是该阶段物理内存分布情况：

4000：内核全局页表swapper_pg_dir起始地址，共16K

8000~6be58c：内核存放空间（text\data\bss等）

6bf000~6bf000+200000：存放所有页框描述数据结构structpage

f9f7000：存放早期bootmem分配内存使用的位图空间起始地址，建立伙伴算法后会释放掉

916000~fa00000：空闲页表，全部有伙伴系统管理

前面的9304K保留内存永远不释放，也不归伙伴系统管理

内核信息打印如下：

Memory: 250MB = 250MB total

Memory: 246696k/246696k available, 9304k reserved, 0

Virtual kernel memory layout:

vector : 0xffff0000 - 0xffff1000 ( 4kB)

fixmap : 0xfff00000 - 0xfffe0000 ( 896 kB)

vmalloc: 0xd0000000 - 0xff000000 ( 752 MB)

lowmem : 0xc0000000 - 0xcfa00000 ( 250 MB)

pkmap : 0xbfe00000 - 0xc0000000 ( 2MB)

modules: 0xbf000000 - 0xbfe00000 ( 14 MB)

.text: 0xc0008000 - 0xc05e85c8 (6018 kB)

.init: 0xc05e9000 - 0xc0617ec0 ( 188 kB)

.data: 0xc0618000 - 0xc06542c0 ( 241 kB)

.bss: 0xc06542c0 - 0xc06be58c ( 425 kB)