Linux内核高-低端内存设置代码盯梢（ARM构架）

首要定位设置内核虚拟地址开始方位（也便是内核逻辑地址结尾+1的地址）的文件：init.c (arch\arm\mm)，在这个文件中的void __init bootmem_init(void)函数如下

这个high_memory=__va(((phys_addr_t)max_low<<PAGE_SHIFT)–1)+1;句子便是要害。从这儿能够知道max_low便是高端内存的开始地址（物理地址）。那么这个max_low是怎么得到的？其实看上面的代码能够推测出，他其实是在find_limits(&min,&max_low,&max_high);中（在同一个文件中）被设置的：

这个函数的意思很明显：经过扫描struct meminfo*mi=&meminfo;（结构体meminfo的数组）中的一切信息，设置三个指针所指的变量：

1. min :内存物理地址开始
2. max_low :低端内存区物理地址结尾
3. max_high :高端内存区物理地址结尾

从上面能够看出，max_low和max_high所保存的地址不同便是因为bank->highmem形成的，它是内存bank被设为高端内存的根据：

1. “假如这个内存bank是高端内存（bank->highmem ！= 0），越过max_low = end;句子，max_low和max_high将不同（成果实际上是max_high >max_low）；
2. 不然假定没有一个内存bank是高端内存（一切bank->highmem == 0）max_low和max_high必定共同（高端内存巨细为0）”

当然要完结这个函数的功用，有必要确保meminfo所指数组中的一切bank是依照地址数据从小到大排序好的哦～～。可是这个咱们不必忧虑，后边会看到的：）

经过上面的盯梢，焦点会集到了全局变量（同一个文件中）：

1. struct meminfo meminfo;

这个结构体的界说（setup.h (arch\arm\include\asm)）：

1. /*
2. * Memory map description
3. */
4. #define NR_BANKS 8
6. struct membank {
7. phys_addr_t start;
8. unsigned long size;
9. unsigned int highmem;
10. };
12. struct meminfo {
13. int nr_banks;
14. struct membank bank[NR_BANKS];
15. };
17. extern struct meminfo meminfo;
19. #define for_each_bank(iter,mi)\
20. for (iter = 0; iter < (mi)->nr_banks; iter++)

只需找到初始化这个全局变量并完结排序的当地，就能够知道高端内存是怎么装备的了！！OK，明晰方针，go on～～～

经过查找代码，咱们能够在setup.c (arch\arm\kernel)这个文件中找到相关的代码。在体系发动早期会运转的函数（详细的次序你能够自行剖析下ARM内核的发动流程，今后我也会写下）中有这样一个函数：

1. void __init setup_arch(char **cmdline_p)
2. {
3. struct machine_desc *mdesc;
5. unwind_init();
7. setup_processor();
8. mdesc = setup_machine_fdt(__atags_pointer);
9. if (!mdesc)
10. mdesc = setup_machine_tags(machine_arch_type);
11. machine_desc = mdesc;
12. machine_name = mdesc->name;
14. if (mdesc->soft_reboot)
15. reboot_setup(“s”);
17. init_mm.start_code = (unsigned long) _text;
18. init_mm.end_code = (unsigned long) _etext;
19. init_mm.end_data = (unsigned long) _edata;
20. init_mm.brk = (unsigned long) _end;
23. strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
24. *cmdline_p = cmd_line;
26. parse_early_param();
28. sanity_check_meminfo();
29. arm_memblock_init(&meminfo, mdesc);
31. paging_init(mdesc);
32. request_standard_resources(mdesc);
34. unflatten_device_tree();
36. #ifdef CONFIG_SMP
37. if (is_smp())
38. smp_init_cpus();
39. #endif
40. reserve_crashkernel();
42. cpu_init();
43. tcm_init();
45. #ifdef CONFIG_MULTI_IRQ_HANDLER
46. handle_arch_irq = mdesc->handle_irq;
47. #endif
49. #ifdef CONFIG_VT
50. #if defined(CONFIG_VGA_CONSOLE)
51. conswitchp = &vga_con;
52. #elif defined(CONFIG_DUMMY_CONSOLE)
53. conswitchp = &dummy_con;
54. #endif
55. #endif
56. early_trap_init();
58. if (mdesc->init_early)
59. mdesc->init_early();
60. }

在上面的注释中，我现已表明晰要点和解析，下面我细化下：

（1）获取参数部分

经过parse_early_param();函数能够解析内核发动参数中的许多字符串，可是关于咱们这次剖析内存的话主要是剖析以下两个参数：

mem=size@start参数，她为初始化struct meminfo meminfo;（咱们一向重视的内存信息哦～）供给信息。详细的获取信息的函数（相同坐落setup.c (arch\arm\kernel)）：

1. int __init arm_add_memory(phys_addr_t start, unsigned long size)
2. {
3. struct membank *bank = &meminfo.bank[meminfo.nr_banks];
5. if (meminfo.nr_banks >= NR_BANKS) {
6. printk(KERN_CRIT “NR_BANKS too low, “
7. “ignoring memory at 0xllx\n”, (long long)start);
8. return -EINVAL;
9. }
11. /*
12. * Ensure that start/size are aligned to a page boundary.
13. * Size is appropriately rounded down, start is rounded up.
14. */
15. size -= start & ~PAGE_MASK;
16. bank->start = PAGE_ALIGN(start);
17. bank->size = size & PAGE_MASK;
19. /*
20. * Check whether this memory region has non-zero size or
21. * invalid node number.
22. */
23. if (bank->size == 0)
24. return -EINVAL;
26. meminfo.nr_banks++;
27. return 0;
28. }
30. /*
31. * Pick out the memory size. We look for mem=size@start,
32. * where start and size are “size[KkMm]”
33. */
34. static int __init early_mem(char *p)
35. {
36. static int usermem __initdata = 0;
37. unsigned long size;
38. phys_addr_t start;
39. char *endp;
41. /*
42. * If the user specifies memory size, we
43. * blow away any automatically generated
44. * size.
45. */
46. if (usermem == 0) {
47. usermem = 1;
48. meminfo.nr_banks = 0;
49. }
51. start = PHYS_OFFSET;
52. size = memparse(p, &endp);
53. if (*endp == @)
54. start = memparse(endp + 1, NULL);
56. arm_add_memory(start, size);
58. return 0;
59. }
60. early_param(“mem”, early_mem);

vmalloc=size参数，她为初始化vmalloc_min（需求保存的内核虚拟地址空间巨细，也便是这个内核虚拟地址空间中除掉逻辑地址空间和必要的避免越界的维护空泛后最少要预留的地址空间）供给信息。详细的完结函数（坐落mmu.c (arch\arm\mm)）：

1. static void * __initdata vmalloc_min = (void *)(VMALLOC_END – SZ_128M);

2. /*
3. * vmalloc=size forces the vmalloc area to be exactly size
4. * bytes. This can be used to increase (or decrease) the vmalloc
5. * area – the default is 128m.
6. */
7. static int __init early_vmalloc(char *arg)
8. {
9. unsigned long vmalloc_reserve = memparse(arg, NULL);
11. if (vmalloc_reserve < SZ_16M) {
12. vmalloc_reserve = SZ_16M;
13. printk(KERN_WARNING
14. “vmalloc area too small, limiting to %luMB\n”,
15. vmalloc_reserve >> 20);
16. }
18. if (vmalloc_reserve > VMALLOC_END – (PAGE_OFFSET + SZ_32M)) {
19. vmalloc_reserve = VMALLOC_END – (PAGE_OFFSET + SZ_32M);
20. printk(KERN_WARNING
21. “vmalloc area is too big, limiting to %luMB\n”,
22. vmalloc_reserve >> 20);
23. }
25. vmalloc_min = (void *)(VMALLOC_END – vmalloc_reserve);
27. return 0;
28. }
29. early_param(“vmalloc”, early_vmalloc);

（2）在获得了必要的信息（初始化好struct meminfo meminfo和vmalloc_min）后，内核经过sanity_check_meminfo函数主动去经过vmalloc_min信息来初始化每个meminfo.bank[？]中的highmem成员。此过程中假如有必要，将或许会改动meminfo中的bank数组。处理函数坐落mmu.c (arch\arm\mm)：

1. static phys_addr_t lowmem_limit __initdata = 0;
3. void __init sanity_check_meminfo(void)
4. {
5. int i, j, highmem = 0;
7. for (i = 0, j = 0; i < meminfo.nr_banks; i++) {
8. struct membank *bank = &meminfo.bank[j];
9. *bank = meminfo.bank[i];
11. #ifdef CONFIG_HIGHMEM
12. if (__va(bank->start) >= vmalloc_min ||
13. __va(bank->start) < (void *)PAGE_OFFSET)
14. highmem = 1;
16. bank->highmem = highmem;
18. /*
19. * Split those memory banks which are partially overlapping
20. * the vmalloc area greatly simplifying things later.
21. */
22. if (__va(bank->start) < vmalloc_min &&
23. bank->size > vmalloc_min – __va(bank->start)) {
24. if (meminfo.nr_banks >= NR_BANKS) {
25. printk(KERN_CRIT “NR_BANKS too low, “
26. “ignoring high memory\n”);
27. } else {
28. memmove(bank + 1, bank,
29. (meminfo.nr_banks – i) * sizeof(*bank));
30. meminfo.nr_banks++;
31. i++;
32. bank[1].size -= vmalloc_min – __va(bank->start);
33. bank[1].start = __pa(vmalloc_min – 1) + 1;
34. bank[1].highmem = highmem = 1;
35. j++;
36. }
37. bank->size = vmalloc_min – __va(bank->start);
38. }
39. #else
40. bank->highmem = highmem;
42. /*
43. * Check whether this memory bank would entirely overlap
44. * the vmalloc area.
45. */
46. if (__va(bank->start) >= vmalloc_min ||
47. __va(bank->start) < (void *)PAGE_OFFSET) {
48. printk(KERN_NOTICE “Ignoring RAM at %.8llx-%.8llx “
49. “(vmalloc region overlap).\n”,
50. (unsigned long long)bank->start,
51. (unsigned long long)bank->start + bank->size – 1);
52. continue;
53. }
55. /*
56. * Check whether this memory bank would partially overlap
57. * the vmalloc area.
58. */
59. if (__va(bank->start + bank->size) > vmalloc_min ||
60. __va(bank->start + bank->size) < __va(bank->start)) {
61. unsigned long newsize = vmalloc_min – __va(bank->start);
62. printk(KERN_NOTICE “Truncating RAM at %.8llx-%.8llx “
63. “to -%.8llx (vmalloc region overlap).\n”,
64. (unsigned long long)bank->start,
65. (unsigned long long)bank->start + bank->size – 1,
66. (unsigned long long)bank->start + newsize – 1);
67. bank->size = newsize;
68. }
69. #endif
70. if (!bank->highmem && bank->start + bank->size > lowmem_limit)
71. lowmem_limit = bank->start + bank->size;
73. j++;
74. }
75. #ifdef CONFIG_HIGHMEM
76. if (highmem) {
77. const char *reason = NULL;
79. if (cache_is_vipt_aliasing()) {
80. /*
81. * Interactions between kmap and other mappings
82. * make highmem support with aliasing VIPT caches
83. * rather difficult.
84. */
85. reason = “with VIPT aliasing cache”;
86. }
87. if (reason) {
88. printk(KERN_CRIT “HIGHMEM is not supported %s, ignoring high memory\n”,
89. reason);
90. while (j > 0 && meminfo.bank[j – 1].highmem)
91. j–;
92. }
93. }
94. #endif
95. meminfo.nr_banks = j;
96. memblock_set_current_limit(lowmem_limit);
97. }

（3）最终有必要做的便是排序了，完结了这个作业就能够彻底被咱们上面说到的find_limits函数运用了，而这个作业就放在了接下来的arm_memblock_init(&meminfo, mdesc);中的一最初：

1. static int __init meminfo_cmp(const void *_a, const void *_b)
2. {
3. const struct membank *a = _a, *b = _b;
4. long cmp = bank_pfn_start(a) – bank_pfn_start(b);
5. return cmp < 0 ? -1 : cmp > 0 ? 1 : 0;
6. }
8. void __init arm_memblock_init(struct meminfo *mi, struct machine_desc *mdesc)
9. {
10. int i;
12. sort(&meminfo.bank, meminfo.nr_banks, sizeof(meminfo.bank[0]), meminfo_cmp, NULL);
14. memblock_init();
15. for (i = 0; i < mi->nr_banks; i++)
16. memblock_add(mi->bank[i].start, mi->bank[i].size);
18. /* Register the kernel text, kernel data and initrd with memblock. */
19. #ifdef CONFIG_XIP_KERNEL
20. memblock_reserve(__pa(_sdata), _end – _sdata);
21. #else
22. memblock_reserve(__pa(_stext), _end – _stext);
23. #endif
24. #ifdef CONFIG_BLK_DEV_INITRD
25. if (phys_initrd_size &&
26. !memblock_is_region_memory(phys_initrd_start, phys_initrd_size)) {
27. pr_err(“INITRD: 0xlx+0xlx is not a memory region – disabling initrd\n”,
28. phys_initrd_start, phys_initrd_size);
29. phys_initrd_start = phys_initrd_size = 0;
30. }
31. if (phys_initrd_size &&
32. memblock_is_region_reserved(phys_initrd_start, phys_initrd_size)) {
33. pr_err(“INITRD: 0xlx+0xlx overlaps in-use memory region – disabling initrd\n”,
34. phys_initrd_start, phys_initrd_size);
35. phys_initrd_start = phys_initrd_size = 0;
36. }
37. if (phys_initrd_size) {
38. memblock_reserve(phys_initrd_start, phys_initrd_size);
40. /* Now convert initrd to virtual addresses */
41. initrd_start = __phys_to_virt(phys_initrd_start);
42. initrd_end = initrd_start + phys_initrd_size;
43. }
44. #endif
46. arm_mm_memblock_reserve();
47. arm_dt_memblock_reserve();
49. /* reserve any platform specific memblock areas */
50. if (mdesc->reserve)
51. mdesc->reserve();
53. memblock_analyze();
54. memblock_dump_all();
55. }

经过上面的剖析，整个高低端内存是怎么确认的基本就明晰了，这儿总结一下：

ARM构架中，高-低段内存是内核经过内核发动参数（mem=size@start和vmalloc=size）来主动装备的，假如没有特别去装备他，那么在一般的ARM体系中是不会有高端内存存在的。除非你体系的RAM很大或vmalloc装备得很大，就很或许呈现高端内存。