Linux内存管理(3)：内存探测与初始化

    1、内存探测
    linux在被bootloader加载到内存后， cpu最初执行的内核代码是arch/x86/boot/header.S汇编文件中的_start例程，设置好头部header，其中包括大量的bootloader参数。接着是其中的start_of_setup例程，这个例程在做了一些准备工作后会通过call main跳转到arch/x86/boot/main.c:main()函数处执行，这就是众所周知的x86下的main函数，它们都工作在实模式下。在这个main函数中我们可以第一次看到与内存管理相关的代码，这段代码调用detect_memory()函数检测系统物理内存。如下：

void main(void)
{
/* First, copy the boot header into the "zeropage" */
copy_boot_params(); /* 把头部各参数复制到boot_params变量中 */

/* End of heap check */
init_heap();

/* Make sure we have all the proper CPU support */
if (validate_cpu()) {
puts("Unable to boot - please use a kernel appropriate "
"for your CPU.\n");
die();
}

/* Tell the BIOS what CPU mode we intend to run in. */
set_bios_mode();

/* Detect memory layout */
detect_memory(); /* 内存探测函数 */

/* Set keyboard repeat rate (why?) */
keyboard_set_repeat();

/* Query MCA information */
query_mca();

/* Query Intel SpeedStep (IST) information */
query_ist();

/* Query APM information */
#if defined(CONFIG_APM) || defined(CONFIG_APM_MODULE)
query_apm_bios();
#endif

/* Query EDD information */
#if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
query_edd();
#endif

/* Set the video mode */
set_video();

/* Parse command line for 'quiet' and pass it to decompressor. */
if (cmdline_find_option_bool("quiet"))
boot_params.hdr.loadflags |= QUIET_FLAG;

/* Do the last things and invoke protected mode */
go_to_protected_mode();
}    内存探测的实现在arch/x86/boot/memory.c中，如下：
int detect_memory(void)
{
int err = -1;

if (detect_memory_e820() > 0)
err = 0;

if (!detect_memory_e801())
err = 0;

if (!detect_memory_88())
err = 0;

return err;
}    由上面的代码可知，linux内核会分别尝试调用detect_memory_e820()、detcct_memory_e801()、detect_memory_88()获得系统物理内存布局，这3个函数都在memory.c中实现，它们内部其实都会以内联汇编的形式调用bios中断以取得内存信息，该中断调用形式为int 0x15，同时调用前分别把AX寄存器设置为0xe820h、0xe801h、0x88h，关于0x15号中断有兴趣的可以去查询相关手册。下面分析detect_memory_e820()的代码，其它代码基本一样。
#define SMAP 0x534d4150 /* ASCII "SMAP" */

static int detect_memory_e820(void)
{
int count = 0; /* 用于记录已检测到的物理内存数目 */
struct biosregs ireg, oreg;
struct e820entry *desc = boot_params.e820_map;
static struct e820entry buf; /* static so it is zeroed */

initregs(&ireg); /* 初始化ireg中的相关寄存器 */
ireg.ax = 0xe820;
ireg.cx = sizeof buf; /* e820entry数据结构大小 */
ireg.edx = SMAP; /* 标识 */
ireg.di = (size_t)&buf; /* int15返回值的存放处 */

/*
* Note: at least one BIOS is known which assumes that the
* buffer pointed to by one e820 call is the same one as
* the previous call, and only changes modified fields. Therefore,
* we use a temporary buffer and copy the results entry by entry.
*
* This routine deliberately does not try to account for
* ACPI 3+ extended attributes. This is because there are
* BIOSes in the field which report zero for the valid bit for
* all ranges, and we don't currently make any use of the
* other attribute bits. Revisit this if we see the extended
* attribute bits deployed in a meaningful way in the future.
*/

do {
/* 在执行这条内联汇编语句时输入的参数有：
eax寄存器=0xe820
dx寄存器=’SMAP’
edi寄存器=desc
ebx寄存器=next
ecx寄存器=size

返回给c语言代码的参数有：
id=eax寄存器
rr=edx寄存器
ext=ebx寄存器
size=ecx寄存器
desc指向的内存地址在执行0x15中断调用时被设置
*/
intcall(0x15, &ireg, &oreg);
ireg.ebx = oreg.ebx; /* 选择下一个 */

/* BIOSes which terminate the chain with CF = 1 as opposed
to %ebx = 0 don't always report the SMAP signature on
the final, failing, probe. */
if (oreg.eflags & X86_EFLAGS_CF)
break;

/* Some BIOSes stop returning SMAP in the middle of
the search loop. We don't know exactly how the BIOS
screwed up the map at that point, we might have a
partial map, the full map, or complete garbage, so
just return failure. */
if (oreg.eax != SMAP) {
count = 0;
break;
}

*desc++ = buf; /* 将buf赋值给desc */
count++; /* 探测数加一 */
} while (ireg.ebx && count < ARRAY_SIZE(boot_params.e820_map));
/* 将内存块数保持到变量中 */
return boot_params.e820_entries = count;
}    由于历史原因，一些I/O设备也会占据一部分内存物理地址空间，因此系统可以使用的物理内存空间是不连续的，系统内存被分成了很多段，每个段的属性也是不一样的。int 0x15查询物理内存时每次返回一个内存段的信息，因此要想返回系统中所有的物理内存，我们必须以迭代的方式去查询。detect_memory_e820()函数把int 0x15放到一个do-while循环里，每次得到的一个内存段放到struct e820entry里，而struct e820entry的结构正是e820返回结果的结构。像其它启动时获得的结果一样，最终都会被放到boot_params里，探测到的各个内存段情况被放到了boot_params.e820_map。

    这里存放中断返回值的e820entry结构，以及表示内存图的e820map结构均位于arch/x86/include/asm/e820.h中，如下：

struct e820entry {
__u64 addr;	/* 内存段的开始 */
__u64 size;	/* 内存段的大小 */
__u32 type;	/* 内存段的类型 */
} __attribute__((packed));

struct e820map {
__u32 nr_map;
struct e820entry map[E820_X_MAX];
};

    内存探测用于检测出系统有多少个通常不连续的内存区块。之后要建立一个描述这些内存块的内存图数据结构，这就是上面的e820map结构，其中nr_map为检测到的系统中内存区块数，不能超过E820_X_MAX（定义为128），map数组描述各个内存块的情况，包括其开始地址、内存块大小、类型。
     对于32位的系统，通过调用链arch/x86/boot/main.c:main()--->arch/x86/boot/pm.c:go_to_protected_mode()--->arch/x86/boot/pmjump.S:protected_mode_jump()--->arch/i386/boot/compressed/head_32.S:startup_32()--->arch/x86/kernel/head_32.S:startup_32()--->arch/x86/kernel/head32.c:i386_start_kernel()--->init/main.c:start_kernel()，到达众所周知的Linux内核启动函数start_kernel()，这里会调用setup_arch()完成与体系结构相关的一系列初始化工作，其中就包括各种内存的初始化工作，如内存图的建立、管理区的初始化等等。对x86体系结构，setup_arch()函数在arch/x86/kernel/setup.c中，如下：

void __init setup_arch(char **cmdline_p)
{
/* ...... */

x86_init.oem.arch_setup();

setup_memory_map(); /* 建立内存图 */
parse_setup_data();
/* update the e820_saved too */
e820_reserve_setup_data();

/* ...... */

/*
* partially used pages are not usable - thus
* we are rounding upwards:
*/
max_pfn = e820_end_of_ram_pfn(); /* 找出最大可用内存页面帧号 */

/* preallocate 4k for mptable mpc */
early_reserve_e820_mpc_new();
/* update e820 for memory not covered by WB MTRRs */
mtrr_bp_init();
if (mtrr_trim_uncached_memory(max_pfn))
max_pfn = e820_end_of_ram_pfn();

#ifdef CONFIG_X86_32
/* max_low_pfn在这里更新 */
find_low_pfn_range(); /* 找出低端内存的最大页帧号 */
#else
num_physpages = max_pfn;

/* ...... */

/* max_pfn_mapped在这更新 */
/* 初始化内存映射机制 */
max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
max_pfn_mapped = max_low_pfn_mapped;

#ifdef CONFIG_X86_64
if (max_pfn > max_low_pfn) {
max_pfn_mapped = init_memory_mapping(1UL<<32,
max_pfn<<PAGE_SHIFT);
/* can we preseve max_low_pfn ?*/
max_low_pfn = max_pfn;
}
#endif

/* ...... */

initmem_init(0, max_pfn); /* 启动内存分配器 */

/* ...... */

x86_init.paging.pagetable_setup_start(swapper_pg_dir);
paging_init(); /* 建立完整的页表 */
x86_init.paging.pagetable_setup_done(swapper_pg_dir);

/* ...... */
}    几乎所有的内存初始化工作都是在setup_arch()中完成的，主要的工作包括：

    （1）建立内存图：setup_memory_map()；

    （2）调用e820_end_of_ram_pfn()找出最大可用页帧号max_pfn，调用find_low_pfn_range()找出低端内存区的最大可用页帧号max_low_pfn。

    （2）初始化内存映射机制：init_memory_mapping()；

    （3）初始化内存分配器：initmem_init()；

    （4）建立完整的页表：paging_init()。

    2、建立内存图

    内存探测完之后，就要建立描述各内存块情况的全局内存图结构了。函数为setup_arch()--->arch/x86/kernel/e820.c:setup_memory_map()，如下：
void __init setup_memory_map(void)
{
char *who;
/* 调用x86体系下的memory_setup函数 */
who = x86_init.resources.memory_setup();
/* 保存到e820_saved中 */
memcpy(&e820_saved, &e820, sizeof(struct e820map));
printk(KERN_INFO "BIOS-provided physical RAM map:\n");
/* 打印输出 */
e820_print_map(who);
}    该函数调用x86_init.resources.memory_setup()实现对BIOS e820内存图的设置和优化，然后将全局e820中的值保存在e820_saved中，并打印内存图。Linux的内存图保存在一个全局的e820变量中，还有其备份e820_saved，这两个全局的e820map结构变量均定义在arch/x86/kernel/e820.c中。memory_setup()函数是建立e820内存图的核心函数，从arch/x86/kernel/x86_init.c中可知，x86_init.resources.memory_setup()就是e820.c中的default_machine_specific_memory_setup()函数，如下：
char *__init default_machine_specific_memory_setup(void)
{
char *who = "BIOS-e820";
u32 new_nr;
/*
* 复制BIOS提供的e820内存图，否则伪造一个内存图：一块为0-640k，接着的
* 下一块为1mb到appropriate_mem_k的大小
*/
new_nr = boot_params.e820_entries;
/* 将重叠的去除 */
sanitize_e820_map(boot_params.e820_map,
ARRAY_SIZE(boot_params.e820_map),
&new_nr);
/* 去掉重叠的部分后得到的内存块个数 */
boot_params.e820_entries = new_nr;
/* 将其复制到全局变量e820中,小于0时，为出错处理 */
if (append_e820_map(boot_params.e820_map, boot_params.e820_entries)
< 0) {
u64 mem_size;

/* compare results from other methods and take the greater */
if (boot_params.alt_mem_k
< boot_params.screen_info.ext_mem_k) {
mem_size = boot_params.screen_info.ext_mem_k;
who = "BIOS-88";
} else {
mem_size = boot_params.alt_mem_k;
who = "BIOS-e801";
}

e820.nr_map = 0;
e820_add_region(0, LOWMEMSIZE(), E820_RAM);
e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
}

/* In case someone cares... */
return who;
}

/*
* 复制BIOS e820内存图到一个安全的地方。如果我们在里面，则要进行重叠检查
* 如果我们用的是现代系统，则设置代码将给我们提供一个可以使用的内存图，以便
* 用它来建立内存。如果不是现代系统，则将伪造一个内存图
*/
static int __init append_e820_map(struct e820entry *biosmap, int nr_map)
{
/* Only one memory region (or negative)? Ignore it */
if (nr_map < 2)
return -1;

return __append_e820_map(biosmap, nr_map);
}

static int __init __append_e820_map(struct e820entry *biosmap, int nr_map)
{
while (nr_map) { /* 循环nr_map次调用，添加内存块到e820 */
u64 start = biosmap->addr;
u64 size = biosmap->size;
u64 end = start + size;
u32 type = biosmap->type;

/* Overflow in 64 bits? Ignore the memory map. */
if (start > end)
return -1;
/* 添加函数 */
e820_add_region(start, size, type);

biosmap++;
nr_map--;
}
return 0;
}

void __init e820_add_region(u64 start, u64 size, int type)
{
__e820_add_region(&e820, start, size, type);
}

/*
* 添加一个内存块到内存e820内存图中
*/
static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size,
int type)
{
int x = e820x->nr_map;

if (x >= ARRAY_SIZE(e820x->map)) {
printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
return;
}

e820x->map[x].addr = start;
e820x->map[x].size = size;
e820x->map[x].type = type;
e820x->nr_map++;
}    从以上代码可知，内存图设置函数memory_setup()    把从BIOS中探测到的内存块情况（保存在boot_params.e820_map中）做重叠检测，把重叠的内存块去除，然后调用append_e820_map()将它们添加到全局的e920变量中，具体完成添加工作的函数是__e820_add_region()。到这里，物理内存就已经从BIOS中读出来存放到全局变量e820中，e820是linux内核中用于建立内存管理框架的基础。例如建立初始化页表映射、管理区等都会用到它。