在分析了KVM中对虚拟机各级地址（gva->gpa->hva->hpa）的转换之后，想要知道qemu中又是如何完成各级地址转换的，因此对qemu中对虚拟机内存管理的相关数据结构与源码进行了分析。qemu中对于虚拟机内存管理涉及的数据结构较多，仅gpa->hpa的转换过程涉及的数据结构就有：MemoryRegion, AddressSpace, MemoryRegionSection, Flatview, FlatRange, RAMBlock, RAMList等。
这几个数据结构的关系刚接触时有些混乱，以下试图从gpa到hva的转换来整理这几个数据结构之间的关系。
qemu源码版本为qemu-2.8.0
一、MemoryRegion
QEMU通过MemoryRegion来管理虚拟机内存，通过内存属性，GUEST物理地址等特点对内存分类，就形成了多个MemoryRegion，这些MemoryRegion 通过树状组织起来，挂接到根MemoryRegion下。每个MemoryRegion树代表了一类作用的内存，如系统内存空间(system_memory)或IO内存空间(system_io),这两个是qemu中的两个全局MemoryRegion。
struct MemoryRegion {
Object parent_obj;
/* All fields are private - violators will be prosecuted */
/* The following fields should fit in a cache line */
bool romd_mode;
bool ram;
bool subpage;
bool readonly; /* For RAM regions */
bool rom_device;
bool flush_coalesced_mmio;
bool global_locking;
uint8_t dirty_log_mask;
RAMBlock *ram_block; //指向对应的RAMBlock
Object *owner;
const MemoryRegionIOMMUOps *iommu_ops;
const MemoryRegionOps *ops;
void *opaque;
MemoryRegion *container; //指向父MR
Int128 size; //区域大小
hwaddr addr; //在父MR中的偏移量
void (*destructor)(MemoryRegion *mr);
uint64_t align;
bool terminates;
bool ram_device;
bool enabled;
bool warning_printed; /* For reservations */
uint8_t vga_logging_count;
MemoryRegion *alias; //指向实体MR
hwaddr alias_offset;// 起始地址 (GPA) 在实体 MemoryRegion 中的偏移量
int32_t priority;
QTAILQ_HEAD(subregions, MemoryRegion) subregions; //子区域链表头
QTAILQ_ENTRY(MemoryRegion) subregions_link; //子区域链表结点
QTAILQ_HEAD(coalesced_ranges, CoalescedMemoryRange) coalesced;
const char *name;
unsigned ioeventfd_nb;
MemoryRegionIoeventfd *ioeventfds;
QLIST_HEAD(, IOMMUNotifier) iommu_notify;
IOMMUNotifierFlag iommu_notify_flags;
};
MemoryRegion 表示在 Guest memory layout 中的一段内存，可将 MemoryRegion 划分为以下三种类型：
- 根级 MemoryRegion: 直接通过 memory_region_init 初始化，没有自己的内存，用于管理 subregion。如 system_memory
- 实体 MemoryRegion: 通过 memory_region_init_ram 初始化，有自己的内存 (从 QEMU 进程地址空间中分配)，大小为 size 。如 ram_memory(pc.ram) 、 pci_memory(pci) 等。 这种MemoryRegion中真正的分配物理内存，最主要的就是pc.ram和pci。分配的物理内存的作用分别是内存、PCI地址空间以及fireware空间。QEMU是用户空间代码，分配的物理内存返回的是hva，hva保存至RAMBlock的host域。通过实体MemoryRegion对应的RAMBlock可以管理HVA。
- 别名 MemoryRegion: 通过 memory_region_init_alias 初始化，没有自己的内存，表示实体 MemoryRegion(如 pc.ram) 的一部分，通过 alias 成员指向实体 MemoryRegion，alias_offset 代表了该别名MemoryRegion所代表内存起始GPA相对于实体 MemoryRegion 所代表内存起始GPA的偏移量。如 ram_below_4g 、ram_above_4g 等。
代码中常见的 MemoryRegion 关系为：
alias
ram_memory (pc.ram) - ram_below_4g(ram-below-4g)
- ram_above_4g(ram-above-4g) sub
system_memory(system) - ram_below_4g(ram-below-4g)
- ram_above_4g(ram-above-4g)
- pcms->hotplug_memory.mr 热插拔内存
实际上虚拟机的ram申请时是一次性申请的一个完成的ram，记录在一个MR中，之后又对此ram按照size进行了划分，形成subregion,而subregion 的alias便指向原始的MR，而alias_offset 便是在原始ram中的偏移。对于系统地址空间的ram，会把刚才得到的subregion注册到系统中，父MR是刚才提到的全局MR system_memory,subregions_link是链表节点。addr是子MR相对于父MR的偏移，在函数pc_memory_init()函数中有对实体MemoryRegion和别名MemoryRegion的初始化：
void pc_memory_init(PCMachineState *pcms,
MemoryRegion *system_memory,
MemoryRegion *rom_memory,
MemoryRegion **ram_memory)
{
int linux_boot, i;
MemoryRegion *ram, *option_rom_mr;
MemoryRegion *ram_below_4g, *ram_above_4g;
FWCfgState *fw_cfg;
MachineState *machine = MACHINE(pcms);
PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms); assert(machine->ram_size == pcms->below_4g_mem_size +
pcms->above_4g_mem_size); linux_boot = (machine->kernel_filename != NULL); /* Allocate RAM. We allocate it as a single memory region and use
* aliases to address portions of it, mostly for backwards compatibility
* with older qemus that used qemu_ram_alloc().
*/
ram = g_malloc(sizeof(*ram));
memory_region_allocate_system_memory(ram, NULL, "pc.ram",
machine->ram_size); //初始化实体MR pc.ram
*ram_memory = ram;
ram_below_4g = g_malloc(sizeof(*ram_below_4g));
memory_region_init_alias(ram_below_4g, NULL, "ram-below-4g", ram,
, pcms->below_4g_mem_size); //初始化别名MR ram_below_4g，将其alias指向ram，alias_offset为0
memory_region_add_subregion(system_memory, , ram_below_4g); //将别名MRram_below_4g添加为system_memory的subregion,设置偏移addr为0
e820_add_entry(, pcms->below_4g_mem_size, E820_RAM);
if (pcms->above_4g_mem_size > ) {
ram_above_4g = g_malloc(sizeof(*ram_above_4g));
memory_region_init_alias(ram_above_4g, NULL, "ram-above-4g", ram,
pcms->below_4g_mem_size,
pcms->above_4g_mem_size); //初始化别名MR ram_above_4g，将其alias指向ram，alias_offset为below_4g_mem_size
memory_region_add_subregion(system_memory, 0x100000000ULL,
ram_above_4g);//同上述ram_below_4g，初始化并添加ram_above_4g，设置偏移addr为0x100000000ull,即4g
e820_add_entry(0x100000000ULL, pcms->above_4g_mem_size, E820_RAM);
}
void memory_region_init_alias(MemoryRegion *mr,
Object *owner,
const char *name,
MemoryRegion *orig,
hwaddr offset,
uint64_t size)
{
memory_region_init(mr, owner, name, size);
mr->alias = orig; //别名MR的alias指向原实体MR
mr->alias_offset = offset; //alias_offset表示偏移
}
static void memory_region_add_subregion_common(MemoryRegion *mr,
hwaddr offset,
MemoryRegion *subregion)
{
assert(!subregion->container);
subregion->container = mr;
subregion->addr = offset; //将addr设置为offset
memory_region_update_container_subregions(subregion);
} void memory_region_add_subregion(MemoryRegion *mr,
hwaddr offset,
MemoryRegion *subregion)
{
subregion->priority = ;
memory_region_add_subregion_common(mr, offset, subregion);
}
可见subregion的addr即为相对于父MR的偏移，对于ram_below_4g，addr为0，对于ram_above_4g,偏移则为4g,而alias_offset为相对于实体MR的偏移量，对于ram_below_4g，alias_offset为0，对于ram_above_4g，alias_offset为ram_below_4g_size，即为4g。
二、RAMBlock
上面提到了qemu为虚拟机分配的内存的hva保存在RAMblock的host域，RAMBlock的定义如下：
struct RAMBlock {
struct rcu_head rcu; // 用于保护 Read-Copy-Update
struct MemoryRegion *mr; // 对应的 MemoryRegion
uint8_t *host; // 对应的 HVA
ram_addr_t offset; // 在 ram_list 地址空间中的偏移 (要把前面 block 的 size 都加起来)
ram_addr_t used_length; // 当前使用的长度
ram_addr_t max_length; // 总长度
void (*resized)(const char*, uint64_t length, void *host); // resize 函数
uint32_t flags;
/* Protected by iothread lock. */
char idstr[]; // id
/* RCU-enabled, writes protected by the ramlist lock */
QLIST_ENTRY(RAMBlock) next; // 指向在 ram_list.blocks 中的下一个 block
int fd; // 映射文件的文件描述符
size_t page_size; // page 大小，一般和 host 保持一致
};
一个RAMBlock表示一段虚拟内存，host域指向申请的ram的虚拟地址，即hva。所有的RAMBlock通过next字段连接起来，表头保存在全局RAMList中，offset表示当前RAMBlock在RAMList中的偏移。每个RAMBlock都有一个唯一的MemoryRegion对应，但需要注意的是不是每个MemoryRegion都有RAMBlock对应。
在函数pc_memory_init()中为实体memoryregion分配内存时，调用了函数memory_region_allocate_system_memory()，非numa架构下调用函数allocate_system_memory_nonnuma(),继而调用memory_region_init_ram_from_file():
#ifdef __linux__
void memory_region_init_ram_from_file(MemoryRegion *mr,
struct Object *owner,
const char *name,
uint64_t size,
bool share,
const char *path,
Error **errp)
{
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->terminates = true;
mr->destructor = memory_region_destructor_ram;
mr->ram_block = qemu_ram_alloc_from_file(size, mr, share, path, errp); //实体MR指向的RAM_BLOCK为qemu_ram_alloc_from_file函数返回的RAMBlock
mr->dirty_log_mask = tcg_enabled() ? ( << DIRTY_MEMORY_CODE) : ;
}
#endif
函数 qemu_ram_alloc_from_file()中申请并设置RAMBlock，RAMBlock->host 为函数file_ram_alloc()函数的返回值，该函数使用对应路径的（设备）文件来分配内存，调用qemu_ram_mmap()通过mmap方式进行内存分配，可见RAMBlock->host 则为分配的内存的hva的起始地址。
static void *file_ram_alloc(RAMBlock *block,
ram_addr_t memory,
const char *path,
Error **errp)
{
......
area = qemu_ram_mmap(fd, memory, block->mr->align,
block->flags & RAM_SHARED);//通过mmap在qemu的进程地址空间中进行地址分配
if (area == MAP_FAILED) {
error_setg_errno(errp, errno,
"unable to map backing store for guest RAM");
goto error;
}
上述为对实体MemoryRegion “pc.ram” 内存的分配，在为别名MemoryRegion“ram-below-4g”和“ram-above-4g”初始化时调用的是函数memory_region_init_alias(), 该函数调用memory_region_init()
void memory_region_init(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size)
{
object_initialize(mr, sizeof(*mr), TYPE_MEMORY_REGION);
mr->size = int128_make64(size);
if (size == UINT64_MAX) {
mr->size = int128_2_64();
}
mr->name = g_strdup(name);
mr->owner = owner;
mr->ram_block = NULL; //别名MR的ram_block设置为null
.......
}
在该函数中将别名MR的ram_block设置为NULL，而“pc.ram”指向的ram_block是有内容的，可见不是所有的MemoryRegion都有对应的RAMBlock，对于分配的RAMBlock，最后会将其插入到全局链表RAMList中。
上述对结构体MemoryRegion和RAMblock的分析可知，对于系统内存而言（不考虑io）实体MemoryRegion是有具体内存的，而别名MemoryRegion是对实体MR不同分段的一个指向，其alias指向实体MR。别名MR都是根级MR system_memory的subregion，通过RAMBlock，可以知道一个MemoryRegion对应内存的hva，其关系大致如下：
三、AddressSpace
从GPA与hva的角度来看，如果以结构体MemoryRegion为核心的话，RAMBlock可以看成是对该片内存区域hva的关联，而AddressSpace在我看来可以看做是对该片内存区域GPA的一个关联，从其注释AddressSpace: describes a mapping of addresses to #MemoryRegion objects也可看出。
这里我有一个疑问：在qemu-2.3.0版本的源码中，结构体MemoryRegion中有一个变量ram_addr表示该片内存区域的GPA的起始地址，而在qemu-2.8.0中，结构体MemoryRegion中没有了这个变量。猜想对于实体MR而言，其addr变量是否就表示为该片内存区域GPA的起始地址，如果是的话，那么对于subregion而言，其alias_offset加上实体addr即可表示该片MemoryRegion的GPA起始地址，加上实体MR对应的RAMBlock，应该就可以实现GPA到HVA的映射了，那么AddressSpace的作用又是什么，其意义何在？先提出这个疑问，看看后续能否得到解答。
/**
* AddressSpace: describes a mapping of addresses to #MemoryRegion objects
*/
struct AddressSpace {
/* All fields are private. */
struct rcu_head rcu;
char *name;
MemoryRegion *root; //指向根MR
int ref_count;
bool malloced; /* Accessed via RCU. */
struct FlatView *current_map; // 指向当前维护的 FlatView，在 address_space_update_topology 时作为 old 比较 int ioeventfd_nb;
struct MemoryRegionIoeventfd *ioeventfds;
struct AddressSpaceDispatch *dispatch; // 负责根据 GPA 找到 HVA
struct AddressSpaceDispatch *next_dispatch;
MemoryListener dispatch_listener;
QTAILQ_HEAD(memory_listeners_as, MemoryListener) listeners;
QTAILQ_ENTRY(AddressSpace) address_spaces_link;
};
结构体AddressSpace用来表示虚拟机的一片地址空间，不同的设备使用的地址空间不同，但qemu x86中只有两种， address_space_memory和address_space_io,这也是两个全局的address_space变量，所有设备的地址空间都被映射到了这两个上面。其root指向根MemoryRegion, 对于全局变量address_space_memory而言，其root指向系统全局的system_memory，address_space_io的root则指向system_io.由于根MR可能有自己的若干个subregion，因此每个AddressSpace一般包含一系列MemoryRegion，形成树状结构。
AddressSpace中的current_map指向当前维护的FlatView:
/*
* 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;
};
FlatView管理MR展开后得到的所有FlatRange，ranges是一个数组，记录FlatView下所有的FlatRange，每个FlatRange对应一段虚拟机物理地址区间，各个FlatRange不会重叠，按照地址的顺序保存在数组中。具体的范围由一个AddrRange结构描述，其描述了地址和大小。当memory region发生变化的时候，执行memory_region_transaction_commit，address_space_update_topology，address_space_update_topology_pass最终完成更新FlatView的目标。
FlatView结构如下，图源见水印：
由图片可知每个FlatRange的中的AddrRange的start为该段内存区间GPA的首地址，size则描述了该段区间的大小。那么结构体FlatRange中的offset_in_region是什么，是该flatrange相对于所属MR的offset？
与flatrange对应的是MemoryRegionSection：
/**
* 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; // 起始地址 (HVA) 在 MemoryRegion 内的偏移量
Int128 size;
hwaddr offset_within_address_space; // 在 AddressSpace 内的偏移量，如果该 AddressSpace 为系统内存，则为 GPA 起始地址
bool readonly;
};
MemoryRegionSection 指向 MemoryRegion 的一部分 ([offset_within_region, offset_within_region + size])，是注册到 KVM 的基本单位。
将 AddressSpace 中的 MemoryRegion 映射到线性地址空间后，由于重叠的关系，原本完整的 region 可能会被切分成片段，于是产生了 MemoryRegionSection。
其中偏移offset_within_region描述的是该section在其所属的MR中的偏移，一个address_space可能有多个MR构成，因此该offset是局部的。而offset_within_address_space是在整个地址空间中的偏移，是全局的offset，如果AddressSpace为系统内存，则该偏移则为GPA的起始地址。
到这里，借助函数kvm_set_phys_mem()中组装kvmslot，并通过kvm_userspace_memory_region将qemu的内存分布信息传递给kvm的部分过程整理一下上述数据结构中GPA到HVA的对应关系：
static void kvm_set_phys_mem(KVMMemoryListener *kml,
MemoryRegionSection *section, bool add)
{
KVMState *s = kvm_state;
KVMSlot *mem, old;
int err;
MemoryRegion *mr = section->mr;
bool writeable = !mr->readonly && !mr->rom_device;
hwaddr start_addr = section->offset_within_address_space; //获取GPA
ram_addr_t size = int128_get64(section->size);
void *ram = NULL;
unsigned delta; /* kvm works in page size chunks, but the function may be called
with sub-page size and unaligned start address. Pad the start
address to next and truncate size to previous page boundary. */
delta = qemu_real_host_page_size - (start_addr & ~qemu_real_host_page_mask);
delta &= ~qemu_real_host_page_mask;
if (delta > size) {
return;
}
start_addr += delta; //页对齐修正
size -= delta;
size &= qemu_real_host_page_mask;
if (!size || (start_addr & ~qemu_real_host_page_mask)) {
return;
} if (!memory_region_is_ram(mr)) {
if (writeable || !kvm_readonly_mem_allowed) {
return;
} else if (!mr->romd_mode) {
/* If the memory device is not in romd_mode, then we actually want
* to remove the kvm memory slot so all accesses will trap. */
add = false;
}
} ram = memory_region_get_ram_ptr(mr) + section->offset_within_region + delta; //获取hva
.......
}
GPA：在该函数中传入的参数为MemoryRegionSection，根据region section在AddressSpace中的偏移，即offset_within_address_space，加上页对齐修正（delta）得到该section的GPA，填入start_addr。
HVA: hva是通过该section所属的MR的起始HVA + 该region section在所属MR中的偏移量（offset_within_region）+页对齐修正（delta）得到。
该region section所属MR的起始HVA通过函数memory_region_get_ram_ptr()得到，该函数内容如下：
void *memory_region_get_ram_ptr(MemoryRegion *mr)
{
void *ptr;
uint64_t offset = ; rcu_read_lock();
while (mr->alias) { //追溯到实体MR为止
offset += mr->alias_offset;
mr = mr->alias;
}
assert(mr->ram_block);
ptr = qemu_map_ram_ptr(mr->ram_block, offset); //实体MR有对应的RAMBlock
rcu_read_unlock(); return ptr;
} void *qemu_map_ram_ptr(RAMBlock *ram_block, ram_addr_t addr)
{
RAMBlock *block = ram_block; if (block == NULL) {
block = qemu_get_ram_block(addr);
addr -= block->offset;
} if (xen_enabled() && block->host == NULL) {
/* We need to check if the requested address is in the RAM
* because we don't want to map the entire memory in QEMU.
* In that case just map until the end of the page.
*/
if (block->offset == ) {
return xen_map_cache(addr, , );
} block->host = xen_map_cache(block->offset, block->max_length, );
}
return ramblock_ptr(block, addr);
} static inline void *ramblock_ptr(RAMBlock *block, ram_addr_t offset)
{
assert(offset_in_ramblock(block, offset));
return (char *)block->host + offset; //hva的起始地址加上所有偏移得到最终hva
}
在 memory_region_get_ram_ptr 中，如果当前MR是另一个MR的 alias，则会向上追溯，一直追溯到非 alias region(实体 region) 为止。将追溯过程中的 alias_offset 加起来，可以得到当前 region 在实体 region 中的偏移量。由于实体 region 具有对应的 RAMBlock，所以调用函数 qemu_map_ram_ptr ，将实体 region 对应的 RAMBlock 的 host 和总 offset 加起来，得到当前 region 的起始 HVA。
在函数qemu_map_ram_ptr()中，如果传入的ram_block为空，还可以根据当前region在实体region中的偏移量找到对应的ramblock，其调用qemu_get_ram_block（）
static RAMBlock *qemu_get_ram_block(ram_addr_t addr)
{
RAMBlock *block; block = atomic_rcu_read(&ram_list.mru_block);//首先看是不是处于最近使用的block中
if (block && addr - block->offset < block->max_length) { //addr即为当前region相对于实体region的offset，若offset-当前block.offset小于该block的大小，说明该region对应的内存处于该block中
return block;
}
QLIST_FOREACH_RCU(block, &ram_list.blocks, next) { //不在最近使用的block中，则遍历RAMList的所有block
if (addr - block->offset < block->max_length) {
goto found;
}
} fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
abort();
.......
}
由于每一段内存都对应一个RAMblock，通过当前region相对于实体region的offset可以知道这段内存的大小，如果该段大小减去某个RAMBlock的offset小于该block的size，说明该段内存对应的hva在这段block中，否则则查找下一个。比如第一个block的offset为0，如果addr小于该block的大小，那么该block就是这段内存区域对应的block。
一些猜想及疑问：
1、虚拟机的GPA是从0开始的，由系统内存的初始化过程可以看出（不考虑io），初始时分配了一整片内存“pc.ram”及对应的RAMBlock，因此猜想MemoryRegion “pc.ram”的addr为起始GPA，即为0，其他region到该实体region的各级alias_offset之和应该就是该region的起始GPA。又MemoryRegionSection中的offset_within_address_space表示在所属AddressSpace中的偏移量，若该AS为系统内存，则为GPA的起始地址。那么各级subregion的alias_offset相加，再加上实体MR的addr是否就等于MemoryRegionSection中的offset_within_address_space。个人感觉应该是，但不确定，可通过实验进行相关验证。
2、若上述猜想是对的，那么由MemoryRegion及RAMBlock即可得到GPA到HVA的对应关系，那么之前提出的疑问：AddressSpace的意义何在？分析qemu的源码可知AddressSpace绑定了相关listener，当发生变化时会触发相关的listener，不能单从GPA到HVA的映射来考虑AddressSpace的意义。两个全局的AddressSpace（address_space_io，address_space_memory）串起了属于系统内存和io内存的所有memoryRegion，当内存发生变化时，会触发相关listener。所以个人认为AddressSpace可以更好地对不同级别的MemoryRegion进行管理，而不需要为各个MemoryRegion注册绑定listener。且由源码可以看出，MemoryRegion的偏移更偏向于应用得到该region对应于起始hva的偏移，从而计算该region的起始hva，而AddressSpace更偏向于应用于得到起始GPA。（若实体MR的addr为起始GPA，那么该MR到实体MR的偏移之和也可以用于得到该region的起始GPA，但源码中并没有应用此种方式，因为AddressSpace中的相关变量已经可以表示起始GPA了）
3、结构体FlatRange.addr.start就可以表示该段FlatRange的起始GPA,那么该结构体中的offset_in_region是什么，是其相对于所属的MR的offset，其意义又是什么？该问题从函数listener_add_address_space()中可以得到一些解答：
static void listener_add_address_space(MemoryListener *listener,
AddressSpace *as)
{
FlatView *view;
FlatRange *fr;
....... view = address_space_get_flatview(as);//获取as中的flatview
FOR_EACH_FLAT_RANGE(fr, view) { //遍历flatview中的每个flatrange
MemoryRegionSection section = { //新建一个memoryregionsection 并进行赋值
.mr = fr->mr,
.address_space = as,
.offset_within_region = fr->offset_in_region,
.size = fr->addr.size,
.offset_within_address_space = int128_get64(fr->addr.start),
.readonly = fr->readonly,
};
......
}
由上述代码也可以看出FlatRange和MemoryRegionSection的对应关系，MemoryRegionSection中的offset_within_region即为FlatRange的offset_in_region，因此均表示为在所属MR中的偏移，若所属MR为全局MR，则表示为在全局MR中的偏移。同样的，MemoryRegionSection中的offset_within_address_space即为FlatRange.addr.start，表示GPA的起始地址。
补充一个在虚拟机退出时如何根据GPA找到HVA：https://www.anquanke.com/post/id/86412 链接中的第四小节对此进行了分析，主要原理是由AddressSpaceDispatch中的6级页表PhysPageMap实现，该页表的最后一级指向MemoryRegionSection，由MemoryRegionSection可以得到GPA对应的MR，由此得到HVA。
后续会分析结构体AddressSpace注册的listerner的一些操作，以及qemu如何把内存管理的信息传至KVM中，以及如何进行视图的更新。
以上仅是对qemu中管理虚拟机内存的一些数据结构的整理，由于个人理解及分析不够，存在着一些疑问及猜想，难免有不对的地方，欢迎大家提出疑问，指正错误。
参考：https://www.cnblogs.com/ck1020/p/6729224.html
https://www.binss.me/blog/qemu-note-of-memory/