• Linux内存管理:memblock

    思考：

            伙伴系统和struct page数组的内存是从哪里来的，不知道大家有没有考虑过这个问题？

            答案：就是memblock；（本章内容参考4.19内核和x86架构）。

    简介

           内存管理是操作系统内核中最复杂的部分之一， start_kernel函数在内核启动第一个init进程前初始化了所有的内核特性（包括那些依赖于不同架构的特性），你也许还记得引导时创立的临时页表，但复杂的内存管理部分还没有开始，当start_kernel函数被调用时，我们会看到初期内存管理到更复杂的内存管理数据结构和技术的转变，为了更好的理解内核的初始化过程，我们需要对这些技术有更清晰的理解，这个章节我们会着重讨论这个过程，主要针对初期的内存管理memblock的介绍。

            首先我们知道在内核启动后，对于内存，分成好几块：

    • 内存中的某些部分使永久分配给内核的，例如代码段和数据段、ramdisk和dtb占用的空间、临时页表和设备数中的保留区域等，是系统内存的一部分，不能被侵占，也不参与内存的分配，称之为静态内存；
    •  GPU/camera/多核共享的内存都需要预留大量连续内存，这部分内存平时不使用，但是必须为各个应用场景预留，这样的内存称之为预留内存；
    •   内存其余的部分，是需要内核管理的内存，称之为动态内存；

            那么memblock就是将以上内存按功能划分为若干内存区，使用不同的类型存放在memory和reserved的两个集合中，memory即为动态内存，而resvered包括静态内存等。

    1、memblock是什么

    1.1 memblock介绍

            memblock即linux启动后kernel管理内存空间抽象出来的结构，此时buddy系统和slab分配器等并没有初始化，当需要执行一些内存管理、内存分配的任务，此时就是有初期的管理模块memblock机制。在mm_init中会建立内核的内存分配器，停用memblock，释放内存给伙伴系统和slab分配器。memblock是bootmem的升级版本，在config中配置:CONFIG_NO_BOOTMEM=Y。 

    1.2 需要的结构体

            第一个结构体的名字就叫做 memblock。它的定义如下：

    1. struct memblock {
    2.          bool bottom_up;
    3.          phys_addr_t current_limit;
    4.          struct memblock_type memory;   --> array of memblock_region
    5.          struct memblock_type reserved; --> array of memblock_region
    6. #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
    7.          struct memblock_type physmem;
    8. #endif
    9. };

            这个结构体包含五个域。第一个 bottom_up 域置为 true 时允许内存以自底向上模式进行分配。下一个域是 current_limit。 这个域描述了内存块的尺寸限制。接下来的三个域描述了内存块的类型。内存块的类型可以是：被保留、内存和物理内存( CONFIG_HAVE_MEMBLOCK_PHYS_MAP 编译配置选项被开启)。

            接下来我们可以看看下一个数据结构memblock_type,定义如下：

    1. struct memblock_type {
    2. 	unsigned long cnt;
    3. 	unsigned long max;
    4. 	phys_addr_t total_size;
    5. 	struct memblock_region *regions;
    6. };

           这个结构体提供了关于内存类型的信息。它包含了描述当前内存块中内存区域的数量、所有内存区域的大小、内存区域的已分配数组的尺寸和指向 memblock_region 结构体数据的指针的域。

            接下来看对应memblock_region的定义：

    1. struct memblock_region {
    2.         phys_addr_t base;
    3.         phys_addr_t size;
    4.         unsigned long flags;
    5. #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
    6.         int nid;
    7. #endif
    8. };

            memblock_region 提供了内存区域的基址和大小，如果 CONFIG_HAVE_MEMBLOCK_NODE_MAP 编译配置选项被开启， memblock_region 结构体也提供了整数域 - numa 节点选择器。flags 域可以是：

    1. /* Definition of memblock flags. */
    2. enum memblock_flags {
    3. 	MEMBLOCK_NONE		= 0x0,	/* No special request */
    4. 	MEMBLOCK_HOTPLUG	= 0x1,	/* hotpluggable region */
    5. 	MEMBLOCK_MIRROR		= 0x2,	/* mirrored region */
    6. 	MEMBLOCK_NOMAP		= 0x4,	/* don't add to kernel direct mapping */
    7. };

          以上的关系如图所示：  

    在这里插入图片描述

     1.3 初始化静态变量

            在编译时会做好memblock结构体的初始化，代码如下：

    1. static struct memblock_region memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS] __initdata_memblock;
    2. static struct memblock_region memblock_reserved_init_regions[INIT_MEMBLOCK_REGIONS] __initdata_memblock;
    3. #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
    4. static struct memblock_region memblock_physmem_init_regions[INIT_PHYSMEM_REGIONS] __initdata_memblock;
    5. #endif
    6.  
    7. struct memblock memblock __initdata_memblock = {
    8. 	.memory.regions		= memblock_memory_init_regions,
    9. 	.memory.cnt		= 1,	/* empty dummy entry */
    10. 	.memory.max		= INIT_MEMBLOCK_REGIONS,
    11. 	.memory.name		= "memory",
    12.  
    13. 	.reserved.regions	= memblock_reserved_init_regions,
    14. 	.reserved.cnt		= 1,	/* empty dummy entry */
    15. 	.reserved.max		= INIT_MEMBLOCK_REGIONS,
    16. 	.reserved.name		= "reserved",
    17.  
    18. #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
    19. 	.physmem.regions	= memblock_physmem_init_regions,
    20. 	.physmem.cnt		= 1,	/* empty dummy entry */
    21. 	.physmem.max		= INIT_PHYSMEM_REGIONS,
    22. 	.physmem.name		= "physmem",
    23. #endif
    24.  
    25. 	.bottom_up		= false,
    26. 	.current_limit		= MEMBLOCK_ALLOC_ANYWHERE,
    27. };

            可以看到和memblock结构体同名的变量的初始化，首先应该注意__initdata_memblock，这个宏的定义如下：   

    1. #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
    2. #define __init_memblock __meminit
    3. #define __initdata_memblock __meminitdata
    4. #else
    5. #define __init_memblock
    6. #define __initdata_memblock
    7. #endif

            你会发现这个宏依赖于 CONFIG_ARCH_DISCARD_MEMBLOCK 。如果这个编译配置选项开启，内存块的代码会被放置在 .init 段，这样它就会在内核引导完毕后被释放掉。

    2、memblock-API接口

    2.1 各种API

            我们已经结束了memblock结构体初始化讲解，现在我们要看memblock-API和它的实现，所有的memblock-API实现都在mm/block.c，为了理解memblock是怎样实现和工作的，让我们先看看它的用法。内核中很多地方使用到了内存块，举个例子，arch/x86/kernel/e820.c中的e820__memblock_setup函数，这个函数使用了e820提供的内存映射并使用memblock_add和memblock_reserve添加到memblock的region中，接下来我们介绍这几个常用的API。

    1.  
    2. //   基本接口
    3. // 向memory区中添加内存区域.
    4. memblock_add(phys_addr_t base, phys_addr_t size)
    5.  
    6. //  向memory区中删除区域.
    7. memblock_remove(phys_addr_t base, phys_addr_t size)
    8.  
    9. //  申请内存
    10. memblock_alloc(phys_addr_t size, phys_addr_t align)
    11.  
    12.  
    13. // 释放内存
    14. memblock_free(phys_addr_t base, phys_addr_t size)
    15.  
    16.  
    17. //   查找 & 遍历
    18. //  在给定的范围内找到未使用的内存
    19. phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end, phys_addr_t size, phys_addr_t align)
    20.  
    21. //  反复迭代 memblock
    22. for_each_mem_range(i, type_a, type_b, nid, flags, p_start, p_end, p_nid)
    23.  
    24.  
    25. //   获取信息
    26. //  获取内存区域信息
    27. phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr);
    28. //  获取预留内存区域信息
    29. phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
    30.  
    31. //   获取信息
    32. #define memblock_dbg(fmt, ...) \
    33.     if (memblock_debug) printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)

            大致翻看了一下内核代码, 发现很少使用memblock_free(),因为很多地方都是申请了内存做永久使用的. 再者,其实在内核中通过memblock_alloc来分配内存其实比较少,一般都是在调用memblock底层的一些函数来简单粗暴的分配的。

    2.2 memblock_add将内存区域加入到memory中

    2.3 memblock_add函数   

    2.3.1 memblock_add函数  

            memblock_add函数负责向memory区中添加内存区域, 有两个参数：物理基址和内存区域大小，并且把该内存区域添加到memblock。memblock_add函数本身并没有什么, 它只是调用了memblock_add_range函数来完成工作, 定义在mm/memblock.c。

    1. int __init_memblock memblock_add(phys_addr_t base, phys_addr_t size)
    2. {
    3.     memblock_dbg("memblock_add: [%#016llx-%#016llx] flags %#02lx %pF\n",
    4.              (unsigned long long)base,
    5.              (unsigned long long)base + size - 1,
    6.              0UL, (void *)_RET_IP_);
    7.     return memblock_add_range(&memblock.memory, base, size, MAX_NUMNODES, 0);
    8. }

            memblock_add传递的参数依次是 : 内存块类型(memory), 物理基址, 内存区域大小, 最大节点数(1如果CONFIG_NODES_SHIFT没有在配置文件中设置，不然就是1 << CONFIG_NODES_SHIFT）和标志。

    2.3.2 memblock_add_range函数代码

            memblock_add_range函数添加新的内存区域到内存块，主要有以下流程：

    • 首先，该函数检查给定的内存区域大小，如果是0就放回。
    • 在这之后，memblock_add_range用给定的memblock_type检查memblock结构体中是否存在内存区域。
    • 如果没有，我们就用给定的值填充新的memory_region然后返回。
    • 如果memblock_type不为空，我们就把新的内存区域添加到memblock_type类型的memblock中。 
      1. int __init_memblock memblock_add_range(struct memblock_type *type,
      2. 				phys_addr_t base, phys_addr_t size,
      3. 				int nid, enum memblock_flags flags)
      4. {
      5. 	bool insert = false;
      6. 	phys_addr_t obase = base;
      7. 	phys_addr_t end = base + memblock_cap_size(base, &size);
      8. 	int idx, nr_new;
      9. 	struct memblock_region *rgn;
      10.  
      11. 	if (!size)
      12. 		return 0;
      13.  
      14. 	/* special case for empty array */
      15. 	if (type->regions[0].size == 0) {
      16. 		WARN_ON(type->cnt != 1 || type->total_size);
      17. 		type->regions[0].base = base;
      18. 		type->regions[0].size = size;
      19. 		type->regions[0].flags = flags;
      20. 		memblock_set_region_node(&type->regions[0], nid);
      21. 		type->total_size = size;
      22. 		return 0;
      23. 	}
      24. repeat:
      25. 	/*
      26. 	 * The following is executed twice.  Once with %false @insert and
      27. 	 * then with %true.  The first counts the number of regions needed
      28. 	 * to accommodate the new area.  The second actually inserts them.
      29. 	 */
      30. 	base = obase;
      31. 	nr_new = 0;
      32.  
      33. 	for_each_memblock_type(idx, type, rgn) {
      34. 		phys_addr_t rbase = rgn->base;
      35. 		phys_addr_t rend = rbase + rgn->size;
      36.  
      37. 		if (rbase >= end)
      38. 			break;
      39. 		if (rend <= base)
      40. 			continue;
      41. 		/*
      42. 		 * @rgn overlaps.  If it separates the lower part of new
      43. 		 * area, insert that portion.
      44. 		 */
      45. 		if (rbase > base) {
      46. #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
      47. 			WARN_ON(nid != memblock_get_region_node(rgn));
      48. #endif
      49. 			WARN_ON(flags != rgn->flags);
      50. 			nr_new++;
      51. 			if (insert)
      52. 				memblock_insert_region(type, idx++, base,
      53. 						       rbase - base, nid,
      54. 						       flags);
      55. 		}
      56. 		/* area below @rend is dealt with, forget about it */
      57. 		base = min(rend, end);
      58. 	}
      59.  
      60. 	/* insert the remaining portion */
      61. 	if (base < end) {
      62. 		nr_new++;
      63. 		if (insert)
      64. 			memblock_insert_region(type, idx, base, end - base,
      65. 					       nid, flags);
      66. 	}
      67.  
      68. 	if (!nr_new)
      69. 		return 0;
      70.  
      71. 	/*
      72. 	 * If this was the first round, resize array and repeat for actual
      73. 	 * insertions; otherwise, merge and return.
      74. 	 */
      75. 	if (!insert) {
      76. 		while (type->cnt + nr_new > type->max)
      77. 			if (memblock_double_array(type, obase, size) < 0)
      78. 				return -ENOMEM;
      79. 		insert = true;
      80. 		goto repeat;
      81. 	} else {
      82. 		memblock_merge_regions(type);
      83. 		return 0;
      84. 	}
      85. }

    2.3.3 memblock_add_range函数流程解析

            首先，我们用如下代码获得内存区域的结束位置：

    phys_addr_t end = base + memblock_cap_size(base, &size);

             memblock_cap_size函数会设置size大小确保base + size不会溢出，会返回size和ULLONG_MAX - base中的最小值，在那之后我们得到了新的内存区域的结束地址, 然后

    • 查内存区域是否重叠。

    • 将新的添加到memblock, 并且看是否能和已经添加到memblock中的内存区域进行合并。

            首先遍历所有已经存储的内存区域并检查有没有和新的内存区域重叠，如果新内存区域没有和已经存储在memblock的内存区域重叠, 把该新内存区域插入到memblock中. 如果有重叠通通过一个小巧的来完成冲突处理。

    base = min(rend, end);

          重叠检查完毕后, 新的内存区域已经是一块干净的不包含重叠区域的内存, 把新的内存区域插入到memblock中包含两步：

    • 把新的内存区域中非重叠的部分作为独立的区域加入到memblock。

    • 合并所有相邻的内存区域。

            这个过程分为两次循环来完成, 由一个标识变量insert和report代码跳转标签控制。

            第一次循环的时候, 检查新内存区域是否可以放入内存块中并调用memblock_double_array， 而由于insert = false, 则执行!insert条件语句标记的代码块, 并设置insert = true, 然后goto 跳转到report标签继续开始第二次循环。

            第二次循环中, insert = true, 则执行相应的insert == true的代码块, 并且执行memblock_insert_region将新内存区域插入, 最后执行memblock_merge_regions(type)合并内存区域。

    2.4 memblock_remove删除内存区域  

    1. int __init_memblock memblock_remove(phys_addr_t base, phys_addr_t size)
    2. {
    3.     return memblock_remove_range(&memblock.memory, base, size);
    4. }

    2.5 memblock_alloc申请内存

    2.5.1 memblock_alloc函数代码

    1. phys_addr_t __init memblock_alloc(phys_addr_t size, phys_addr_t align)
    2. {
    3. 	return memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE);
    4. }

            memblock_alloc()很粗暴的从能用的内存里分配, 而有些情况下需要从特定的内存范围内分配内存. 解决方法就是通过memblock_alloc_range_nid函数或者实现类似机制的函数。

            memblock_alloc的也是通过memblock_alloc_range_nid函数来完成内存分配的。

    2.5.2 memblock_alloc_range_nid函数

            代码如下：

    1. static phys_addr_t __init memblock_alloc_range_nid(phys_addr_t size,
    2. 					phys_addr_t align, phys_addr_t start,
    3. 					phys_addr_t end, int nid,
    4. 					enum memblock_flags flags)
    5. {
    6. 	phys_addr_t found;
    7.  
    8. 	if (!align)
    9. 		align = SMP_CACHE_BYTES;
    10.  
    11. 	found = memblock_find_in_range_node(size, align, start, end, nid,
    12. 					    flags);
    13. 	if (found && !memblock_reserve(found, size)) {
    14. 		/*
    15. 		 * The min_count is set to 0 so that memblock allocations are
    16. 		 * never reported as leaks.
    17. 		 */
    18. 		kmemleak_alloc_phys(found, size, 0, 0);
    19. 		return found;
    20. 	}
    21. 	return 0;
    22. }

            memblock_alloc_range_nid函数的主要工作如下

    • 首先使用memblock_find_in_range_node指定内存区域和大小查找内存区域。

    • memblock_reserve后将其标为已经分配。

    2.5.3 memblock_find_in_range_node函数

            代码如下：

    1. phys_addr_t __init_memblock memblock_find_in_range_node(phys_addr_t size,
    2. 					phys_addr_t align, phys_addr_t start,
    3. 					phys_addr_t end, int nid,
    4. 					enum memblock_flags flags)
    5. {
    6. 	phys_addr_t kernel_end, ret;
    7.  
    8. 	/* pump up @end */
    9. 	if (end == MEMBLOCK_ALLOC_ACCESSIBLE ||
    10. 	    end == MEMBLOCK_ALLOC_KASAN)
    11. 		end = memblock.current_limit;
    12.  
    13. 	/* avoid allocating the first page */
    14. 	start = max_t(phys_addr_t, start, PAGE_SIZE);
    15. 	end = max(start, end);
    16. 	kernel_end = __pa_symbol(_end);
    17.  
    18. 	/*
    19. 	 * try bottom-up allocation only when bottom-up mode
    20. 	 * is set and @end is above the kernel image.
    21. 	 */
    22. 	if (memblock_bottom_up() && end > kernel_end) {
    23. 		phys_addr_t bottom_up_start;
    24.  
    25. 		/* make sure we will allocate above the kernel */
    26. 		bottom_up_start = max(start, kernel_end);
    27.  
    28. 		/* ok, try bottom-up allocation first */
    29. 		ret = __memblock_find_range_bottom_up(bottom_up_start, end,
    30. 						      size, align, nid, flags);
    31. 		if (ret)
    32. 			return ret;
    33.  
    34. 		/*
    35. 		 * we always limit bottom-up allocation above the kernel,
    36. 		 * but top-down allocation doesn't have the limit, so
    37. 		 * retrying top-down allocation may succeed when bottom-up
    38. 		 * allocation failed.
    39. 		 *
    40. 		 * bottom-up allocation is expected to be fail very rarely,
    41. 		 * so we use WARN_ONCE() here to see the stack trace if
    42. 		 * fail happens.
    43. 		 */
    44. 		WARN_ONCE(IS_ENABLED(CONFIG_MEMORY_HOTREMOVE),
    45. 			  "memblock: bottom-up allocation failed, memory hotremove may be affected\n");
    46. 	}
    47.  
    48. 	return __memblock_find_range_top_down(start, end, size, align, nid,
    49. 					      flags);
    50. }

             如果从memblock_alloc过来, end就是MEMBLOCK_ALLOC_ACCESSIBLE,这个时候会设置为current_limit，如果不通过memblock_alloc分配, 内存范围就是指定的范围. 紧接着对start做调整，为的是避免申请到第一个页面，memblock_bottom_up返回的是memblock.bottom_up，前面初始化的时候也知道这个值是false（在numa初始化时会设置为true），所以初始化前期应该调用的是__memblock_find_range_top_down函数去查找内存。

    2.5.4 __memblock_find_range_top_down查找内存区域        

            函数通过使用for_each_free_mem_range_reverse宏封装调用__next_free_mem_range_rev()函数，此函数逐一将memblock.memory里面的内存块信息提取出来与memblock.reserved的各项信息进行检验，确保返回的this_start和this_end不会是分配过的内存块。

            然后通过clamp取中间值，判断大小是否满足，满足的情况下，将自末端向前（因为这是top-down申请方式）的size大小的空间的起始地址（前提该地址不会超出this_start）返回回去。

    2.5.5 memblock_reserve标记申请的内存

            其实和memblock_add的实现方法一样，但传参数给memblock_add_range不一样，这边使用的是全局变量memblock的reserve区域。

    2.6 memblock_free释放内存区域

            其实和memblock_remove实现方法一样，但传参数给memblock_remove_range不一样，这边使用全局变量memblock的reserved区域。

    3、memblock初始化

    3.1 x86架构下memblock的初始化

            在内核初始化初期,物理内存会通过Int 0x15来被探测和整理, 存放到e820中.而初始化就发生在这个以后，参加arch/x86/kernel/setup.c，只截取了部分。

    1. void __init setup_arch(char **cmdline_p)
    2. {
    3. 	/*
    4. 	 * Need to conclude brk, before e820__memblock_setup()
    5. 	 *  it could use memblock_find_in_range, could overlap with
    6. 	 *  brk area.
    7. 	 */
    8. 	reserve_brk();
    9.  
    10. 	cleanup_highmap();
    11.  
    12. 	memblock_set_current_limit(ISA_END_ADDRESS);
    13. 	e820__memblock_setup();
    14. }

            首先内核建立内核页表需要扩展__brk, 而扩展后的brk就立即被声明为已分配. 这项工作是由reserve_brk通过调用memblock_reserve完成的， 而其实并不是正真通过memblock分配的, 因为此时memblock还没有完成初始化。

           reserve_brk函数定义在arch/x86/kernel/setup.c, 此时memblock还没有初始化, 只能通过memblock_reserve来完成内存的分配。

    1. static void __init reserve_brk(void)
    2. {
    3.     if (_brk_end > _brk_start)
    4.         memblock_reserve(__pa_symbol(_brk_start),
    5.                  _brk_end - _brk_start);
    6.  
    7.     /* Mark brk area as locked down and no longer taking any
    8.        new allocations */
    9.     _brk_start = 0;
    10. }

            设置完__brk后, 可以看到,setup_arch()函数通过e820__memblock_setup,依据e820中的信息来初始化memblock.

    1. void __init e820__memblock_setup(void)
    2. {
    3.     int i;
    4.     u64 end;
    5.  
    6.     /*
    7.      * EFI may have more than 128 entries
    8.      * We are safe to enable resizing, beause memblock_x86_fill()
    9.      * is rather later for x86
    10.      */
    11.     memblock_allow_resize();
    12.  
    13.     for (i = 0; i < e820.nr_map; i++) {
    14.         struct e820entry *ei = &e820.map[i];
    15.  
    16.         end = ei->addr + ei->size;
    17.         if (end != (resource_size_t)end)
    18.             continue;
    19.  
    20.         if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
    21.             continue;
    22.  
    23.         memblock_add(ei->addr, ei->size);
    24.     }
    25.  
    26.     /* throw away partial pages */
    27.     memblock_trim_memory(PAGE_SIZE);
    28.  
    29.     memblock_dump_all();
    30. }

             比较简单,通过e820中的信息memblock_add(),将内存添加到memblock中的memory中,当做可分配内存.后两个函数主要是修剪内存使之对齐和输出信息。至此, 我们的memblock就初始化好了, 简单而且粗暴。

    3.2 arm架构下的memblock的初始化

    1. void __init setup_arch(char **cmdline_p)
    2. {
    3.     arm_memblock_init(mdesc);
    4. }

     arm_memblock_init定义在arch/arm/mm/init.c, 如下所示

    1. void __init arm_memblock_init(const struct machine_desc *mdesc)
    2. {
    3.     /* Register the kernel text, kernel data and initrd with memblock. */
    4. #ifdef CONFIG_XIP_KERNEL
    5.     memblock_reserve(__pa(_sdata), _end - _sdata);
    6. #else
    7.     memblock_reserve(__pa(_stext), _end - _stext);
    8. #endif
    9. #ifdef CONFIG_BLK_DEV_INITRD
    10.     /* FDT scan will populate initrd_start */
    11.     if (initrd_start && !phys_initrd_size) {
    12.         phys_initrd_start = __virt_to_phys(initrd_start);
    13.         phys_initrd_size = initrd_end - initrd_start;
    14.     }
    15.     initrd_start = initrd_end = 0;
    16.     if (phys_initrd_size &&
    17.         !memblock_is_region_memory(phys_initrd_start, phys_initrd_size)) {
    18.         pr_err("INITRD: 0x%08llx+0x%08lx is not a memory region - disabling initrd\n",
    19.                (u64)phys_initrd_start, phys_initrd_size);
    20.         phys_initrd_start = phys_initrd_size = 0;
    21.     }
    22.     if (phys_initrd_size &&
    23.         memblock_is_region_reserved(phys_initrd_start, phys_initrd_size)) {
    24.         pr_err("INITRD: 0x%08llx+0x%08lx overlaps in-use memory region - disabling initrd\n",
    25.                (u64)phys_initrd_start, phys_initrd_size);
    26.         phys_initrd_start = phys_initrd_size = 0;
    27.     }
    28.     if (phys_initrd_size) {
    29.         memblock_reserve(phys_initrd_start, phys_initrd_size);
    30.  
    31.         /* Now convert initrd to virtual addresses */
    32.         initrd_start = __phys_to_virt(phys_initrd_start);
    33.         initrd_end = initrd_start + phys_initrd_size;
    34.     }
    35. #endif
    36.  
    37.     arm_mm_memblock_reserve();
    38.  
    39.     /* reserve any platform specific memblock areas */
    40.     if (mdesc->reserve)
    41.         mdesc->reserve();
    42.  
    43.     early_init_fdt_reserve_self();
    44.     early_init_fdt_scan_reserved_mem();
    45.  
    46.     /* reserve memory for DMA contiguous allocations */
    47.     dma_contiguous_reserve(arm_dma_limit);
    48.  
    49.     arm_memblock_steal_permitted = false;
    50.     memblock_dump_all();
    51. }

    3.3 arm64 架构下memblock的初始化

    1. void __init setup_arch(char **cmdline_p)
    2. {
    3.     /*  初始化memblock  */
    4.     arm64_memblock_init( );
    5.  
    6.     /*  分页机制初始化  */
    7.     paging_init();
    8.  
    9.     bootmem_init();
    10. }

    4、调试

            如果需要了解memblock的详细分配流程，可以通过在bootargs中加入“memblock=debug”。

    在内核启动后，通过/proc/kmsg查看调试信息。

    内存块技术也支持 debugfs 。如果你不是在 X86 架构下运行内核，你可以访问：

    /sys/kernel/debug/memblock/memory

    /sys/kernel/debug/memblock/reserved

    来获取 memblock 内容的核心转储信息。

    5、总结

            memblock内存管理是将所有的物理内存放到memblock.memory中作为可用内存来管理, 分配过的内存只加入到memblock.reserved中, 并不从memory中移出。

            同理释放内存也会加入到memory中. 也就是说, memory在fill过后基本就是不动的了. 申请和分配内存仅仅修改reserved就达到目的. 在初始化阶段没有那么多复杂的内存操作场景, 甚至很多地方都是申请了内存做永久使用的, 所以这样的内存管理方式已经足够凑合着用了, 毕竟内核也不指望用它一辈子. 在系统完成初始化之后所有的工作会移交给强大的buddy系统来进行内存管理。

  • 相关阅读:
    著名音乐app网易云推广运营策划案
    Panoply启动报错A Java Exception has occurred
    新一代信息技术与制造业融合发展背景下网络安全挑战和思考
    中级java面试问题大全及答案大全
    DGIOT基于低代码amis配置联动短信告警
    绿联DX4600 AList部署及挂载阿里云盘
    Rust 二叉树遍历---- DFS 和 BFS
    C++面向对象程序设计（第2版）第二章（类和对象的特性）知识点总结
    大端与小端
    一文梳理NLP主要模型发展脉络
  • 原文地址：https://blog.csdn.net/kwdecsdn/article/details/127667158