memblock：struct memblock

HZero.chen

已于 2022-03-29 15:26:59 修改

阅读量334

点赞数

分类专栏：内核源码分析文章标签： memblock

于 2022-02-19 18:05:43 首次发布

本文链接：https://blog.csdn.net/jasonactions/article/details/123019539

版权

内核源码分析专栏收录该内容

13 篇文章 7 订阅

订阅专栏

kernel: 5.10
arch: arm64

在这里插入图片描述
memblock 结构体定义如下，它主要用于描述整个memblock分配器

/**                                                                                                                                                             
 * struct memblock - memblock allocator metadata                                                                                                                
 * @bottom_up: is bottom up direction?                                                                                                                          
 * @current_limit: physical address of the current allocation limit                                                                                             
 * @memory: usable memory regions                                                                                                                               
 * @reserved: reserved memory regions                                                                                                                           
 */                                                                                                                                                             
struct memblock {                                                                                                                                               
        bool bottom_up;  /* is bottom up direction? */                                                                                                          
        phys_addr_t current_limit;                                                                                                                              
        struct memblock_type memory;                                                                                                                            
        struct memblock_type reserved;                                                                                                                          
};

memblock_type代表一种类型的memory block区域，可以包含多个区域，其中一个memblock_region用于描述其中的一个区域，因此此处定义了一个数组来表示多个区域

/**                                                                                                                                                             
 * struct memblock_type - collection of memory regions of certain type                                                                                          
 * @cnt: number of regions                                                                                                                                      
 * @max: size of the allocated array                                                                                                                            
 * @total_size: size of all regions                                                                                                                             
 * @regions: array of regions                                                                                                                                   
 * @name: the memory type symbolic name                                                                                                                         
 */                                                                                                                                                             
struct memblock_type {                                                                                                                                          
        unsigned long cnt;                                                                                                                                      
        unsigned long max;                                                                                                                                      
        phys_addr_t total_size;                                                                                                                                 
        struct memblock_region *regions;                                                                                                                        
        char *name;                                                                                                                                             
};

/**
 * struct memblock_region - represents a memory region
 * @base: base address of the region
 * @size: size of the region
 * @flags: memory region attributes
 * @nid: NUMA node id
 */
struct memblock_region {
        phys_addr_t base;
        phys_addr_t size;
        enum memblock_flags flags;
#ifdef CONFIG_NEED_MULTIPLE_NODES
        int nid;
#endif
};

定义了一个全局struct memblock 结构体 memblock

# mm/memblock.c
struct memblock memblock __initdata_memblock = {                                                                                                                
        .memory.regions         = memblock_memory_init_regions,                                                                                                 
        .memory.cnt             = 1,    /* empty dummy entry */                                                                                                 
        .memory.max             = INIT_MEMBLOCK_REGIONS,                                                                                                        
        .memory.name            = "memory",                                                                                                                     
                                                                                                                                                                
        .reserved.regions       = memblock_reserved_init_regions,                                                                                               
        .reserved.cnt           = 1,    /* empty dummy entry */                                                                                                 
        .reserved.max           = INIT_MEMBLOCK_RESERVED_REGIONS,                                                                                               
        .reserved.name          = "reserved",                                                                                                                   
                                                                                                                                                                
        .bottom_up              = false,                                                                                                                        
        .current_limit          = MEMBLOCK_ALLOC_ANYWHERE,                                                                                                      
};