struct MemoryRegion {
    ...
    bool ram;   // 是否是ram
    bool terminates;  // 是否是叶子节点
    bool enabled;   // 是否已经通知KVM使用这段内存
    ...
    RAMBlock *ram_block; //指向对应的RAMBlock
    ...
    const MemoryRegionOps *ops;  // 回调函数集合
    void *opaque;
    MemoryRegion *container; //指向父MR，主要用于将mr合并
    Int128 size; // 区域大小
    hwaddr addr; // 在父MR中的偏移量，若父类是`address_spaces_memory`可以理解为GPA
    ...
    MemoryRegion *alias; // 指向实体MR
    hwaddr alias_offset; // 起始地址(GPA)在实体MemoryRegion中的偏移量
    ...
    QTAILQ_HEAD(subregions, MemoryRegion) subregions; //子区域链表头
    QTAILQ_ENTRY(MemoryRegion) subregions_link; //子区域链表结点
    ...
};

struct RAMBlock {
    struct rcu_head rcu;    // 用于保护 Read-Copy-Update
    struct MemoryRegion *mr; // RAMBlock所在的MemoryRegion
    uint8_t *host;         // 对应的HVA
    ram_addr_t offset;     // 在ram_list地址空间中的偏移 (要把前面block的size都加起来)
    ram_addr_t used_length;  // 当前使用的长度
    ram_addr_t max_length;  // 总长度
    ...
    QLIST_ENTRY(RAMBlock) next;    // 指向下一个RAMBlock
    int fd;       // 映射文件的文件描述符
    size_t page_size; // page大小，一般和host保持一致
};

RAMBlock *qemu_ram_alloc_internal(ram_addr_t size, ram_addr_t max_size,
                                  void (*resized)(const char*,
                                                  uint64_t length,
                                                  void *host),
                                  void *host, bool resizeable, bool share,
                                  MemoryRegion *mr, Error **errp)
{
    RAMBlock *new_block;
    Error *local_err = NULL;
    size = HOST_PAGE_ALIGN(size);
    max_size = HOST_PAGE_ALIGN(max_size);
    new_block = g_malloc0(sizeof(*new_block));
    new_block->mr = mr;
    new_block->resized = resized;
    new_block->used_length = size;
    new_block->max_length = max_size;
    assert(max_size >= size);
    new_block->fd = -1;
    new_block->page_size = qemu_real_host_page_size;
    new_block->host = host;                 // 此时host还是空的
    ...
    ram_block_add(new_block, &local_err, share);   // 这里再计算host应该是多少
    ...
    return new_block;
}

new_block->host = phys_mem_alloc(new_block->max_length,
                                 &new_block->mr->align, shared);

struct AddressSpaceDispatch {
    MemoryRegionSection *mru_section;
    /* This is a multi-level map on the physical address space.
     * The bottom level has pointers to MemoryRegionSections.
     */
    PhysPageEntry phys_map;  // 指向一级页表
    PhysPageMap map;
};

typedef struct PhysPageMap {
    struct rcu_head rcu;

    unsigned sections_nb;          // sections动态数组中有效元素个数
    unsigned sections_nb_alloc;    // sections数组的可用长度
    unsigned nodes_nb; 			   // nodes动态数组中有效元素的个数
    unsigned nodes_nb_alloc;       // nodes数组的可用长度
    Node *nodes;        // 指向Node数组，多级页表
    MemoryRegionSection *sections;   // 指向所有MemoryRegionSection，用于寻找GPA
} PhysPageMap;

struct PhysPageEntry {
    /* How many bits skip to next level (in units of L2_SIZE). 0 for a leaf. */
    uint32_t skip : 6;
     /* index into phys_sections (!skip) or phys_map_nodes (skip) */
    uint32_t ptr : 26;
};

FOR_EACH_FLAT_RANGE(fr, view) {
    MemoryRegionSection section = section_from_flat_range(fr, view);

    if (listener->region_add) {
        listener->region_add(listener, &section);
    }
    if (fr->dirty_log_mask && listener->log_start) {
        listener->log_start(listener, &section, 0, fr->dirty_log_mask);
    }
}
if (listener->commit) {
    listener->commit(listener);
}

/*
 * Note that signed integers are needed for negative offsetting in aliases
 * (large MemoryRegion::alias_offset).
 */
struct AddrRange {
    Int128 start; //起始
    Int128 size; //大小
};

/* Range of memory in the global map.  Addresses are absolute. */
struct FlatRange {
    MemoryRegion *mr; //指向所属的MR
    hwaddr offset_in_region; //在MR中的offset
    AddrRange addr; //本FR代表的区间
    uint8_t dirty_log_mask;
    bool romd_mode;
    bool readonly;
};

/* Flattened global view of current active memory hierarchy.  Kept in sorted
 * order.
 */
struct FlatView {
    struct rcu_head rcu;
    unsigned ref; //引用计数，为0就销毁
    FlatRange *ranges; //对应的flatrange数组
    unsigned nr; //flatrange数目
    unsigned nr_allocated;
};

static FlatView *generate_memory_topology(MemoryRegion *mr)
{
    FlatView *view;

    view = g_new(FlatView, 1);
    flatview_init(view);

    if (mr) {
        render_memory_region(view, mr, int128_zero(),
                             addrrange_make(int128_zero(), int128_2_64()), false);
        // 从根级region开始，递归将region映射到线性地址空间中，产生一个个FlatRange，构成 FlatView. addrrange_make创建起始地址为0，结束地址为 2^64 的地址空间，作为 guest 的线性地址空间
    }
    flatview_simplify(view);//将 FlatView 中连续的 FlatRange 进行合并为一个

    view->dispatch = address_space_dispatch_new(view);
    for (i = 0; i < view->nr; i++) {
        MemoryRegionSection mrs =
            section_from_flat_range(&view->ranges[i], view);
        flatview_add_to_dispatch(view, &mrs);
    }

    ...
    return view;
}

render_memory_region(view, mr, int128_zero(),
                     addrrange_make(int128_zero(), int128_2_64()), false);
// 从根级 region 开始，递归将 region 映射到线性地址空间中，产生一个个 FlatRange，构成 FlatView. addrrange_make创建起始地址为 0，结束地址为 2^64 的地址空间，作为 guest 的线性地址空间

/**
 * MemoryRegionSection: describes a fragment of a #MemoryRegion
 *
 * @mr: the region, or %NULL if empty
 * @address_space: the address space the region is mapped in
 * @offset_within_region: the beginning of the section, relative to @mr's start
 * @size: the size of the section; will not exceed @mr's boundaries
 * @offset_within_address_space: the address of the first byte of the section
 *     relative to the region's address space
 * @readonly: writes to this section are ignored
 */
    struct MemoryRegionSection {
    MemoryRegion *mr;                           // 指向所属 MemoryRegion
    AddressSpace *address_space;                // 所属 AddressSpace
    hwaddr offset_within_region;                // Section在MemoryRegion内的偏移
    Int128 size;
    hwaddr offset_within_address_space;         // 在AddressSpace内的偏移量，如果该AddressSpace为系统内存，则为GPA起始地址
    bool readonly;
};