vcpu的初始化函数注册
在accel/kvm/kvm_all中的最后一行
type_init(kvm_type_init)
kvm_type_init
type_register_static(&kvm_accel_type)
kvm_accel_type.class_init=kvm_accel_class_init
kvm_accel_class_init中设置ac->init_machine=kvm_init
在kvm_init中执行初始化。
其中，type_init(kvm_type_init)只是把kvm_type_init插入给了init_type_list[MODULE_INIT_QOM]链表中，并把type_register_static(&kvm_accel)作为该成员的e->init而已。
而这个初始化函数，则是在module_call_init(MODULE_INIT_QOM)中调用，此时会把这个type_info，即kvm_accel_type得相关信息，生成一个TypeImpl得类型，插入到全局类型哈希表type_table中。
kvm_init初始化函数的执行
而我们注册的ac->init_machine何时被调用呢？
他就是在vl.c的main函数中，在configure_accelerator()函数中被调用，首先，在寻找加速器accel的过程中，会根据传入的参数，调用accel_find()函数，在全局的type_table中找到相应的KVM类，然后把它转换成AccelClass返回到configure_accelerator函数中，紧接着调用accel_init_machine函数，在这个函数中，则会调用acc->init_machine(ms)函数，由于之前注册了ac->init_machine=kvm_init，所以此时实际调用的就是kvm_init函数，从而完成KVM的初始化。
vpu的初始化以及每个vcpu主线程的执行流程
在target/i386/cpu.c中设置了x86_cpu_type_info.class_init=x86_cpu_common_class_init，并调用x86_cpu_register_types将其在初始化时注册进MODULE_INIT_QOM类型中
x86_cpu_common_class_init中调用device_class_set_parent_realize(dc, x86_cpu_realizefn, &xcc->parent_realize)
x86_cpu_realizefn()调用
qemu_init_vpcu（在cpus.c中）调用
qemu_kvm_start_vcpu，在这里面，调用了qemu_thread_create(cpu->thread, thread_name, qemu_kvm_cpu_thread_fn, cpu, QEMU_THREAD_JOINABLE)增加了qemu_kvm_cpu_thread_fn作为线程工作函数：
static void *qemu_kvm_cpu_thread_fn(void *arg)
{
CPUState *cpu = arg;
int r;
rcu_register_thread();
qemu_mutex_lock_iothread();
qemu_thread_get_self(cpu->thread);
cpu->thread_id = qemu_get_thread_id();
cpu->can_do_io = 1;
current_cpu = cpu;
r = kvm_init_vcpu(cpu);
if (r < 0) {
error_report("kvm_init_vcpu failed: %s", strerror(-r));
exit(1);
}
kvm_init_cpu_signals(cpu);
/* signal CPU creation */
cpu->created = true;
qemu_cond_signal(&qemu_cpu_cond);
do {
if (cpu_can_run(cpu)) {
r = kvm_cpu_exec(cpu);
if (r == EXCP_DEBUG) {
cpu_handle_guest_debug(cpu);
}
}
qemu_wait_io_event(cpu);
} while (!cpu->unplug || cpu_can_run(cpu));
qemu_kvm_destroy_vcpu(cpu);
cpu->created = false;
qemu_cond_signal(&qemu_cpu_cond);
qemu_mutex_unlock_iothread();
rcu_unregister_thread();
return NULL;
}
在这里，调用了kvm_init_vcpu(cpu)进行初始化，其实主要也就是用ioctl创建vpu，并给vcpu进行一些属性的初始化。
内存初始化的执行
在hw/i386/pc_piix.c中的pc_init1函数中，会首先初始化ram_size
首先对max_ram_below_4g这个元素进行了初始化，默认初始化成了0xe0000000，即3.5G的默认值，并且是初始化了above_4g_mem_size。
在pc_memory_init中，则是调用了memory_region_allocate_system_memory(位于numa.c:510)，此处则是调用了allocate_system_memory_nonnuma, 在这其中则调用了memory_region_init_ram_from_file函数，该函数的实现如下图所示：
void memory_region_init_ram_from_file(MemoryRegion *mr,
struct Object *owner,
const char *name,
uint64_t size,
uint64_t align,
uint32_t ram_flags,
const char *path,
Error **errp)
{
Error *err = NULL;
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->terminates = true;
mr->destructor = memory_region_destructor_ram;
mr->align = align;
mr->ram_block = qemu_ram_alloc_from_file(size, mr, ram_flags, path, &err);
mr->dirty_log_mask = tcg_enabled() ? (1 << DIRTY_MEMORY_CODE) : 0;
if (err) {
mr->size = int128_zero();
object_unparent(OBJECT(mr));
error_propagate(errp, err);
}
}
显然，初始化后，使用了qemu_ram_alloc_from_file函数分配了ram_block，那么再往深处走一下，其实这个函数就是比较简单的调用了qemu_ram_alloc_from_fd，而该函数的实现则：
RAMBlock *qemu_ram_alloc_from_fd(ram_addr_t size, MemoryRegion *mr,
uint32_t ram_flags, int fd,
Error **errp)
{
RAMBlock *new_block;
Error *local_err = NULL;
int64_t file_size;
/* Just support these ram flags by now. */
assert((ram_flags & ~(RAM_SHARED | RAM_PMEM)) == 0);
if (xen_enabled()) {
error_setg(errp, "-mem-path not supported with Xen");
return NULL;
}
if (kvm_enabled() && !kvm_has_sync_mmu()) {
error_setg(errp,
"host lacks kvm mmu notifiers, -mem-path unsupported");
return NULL;
}
if (phys_mem_alloc != qemu_anon_ram_alloc) {
/*
* file_ram_alloc() needs to allocate just like
* phys_mem_alloc, but we haven't bothered to provide
* a hook there.
*/
error_setg(errp,
"-mem-path not supported with this accelerator");
return NULL;
}
size = HOST_PAGE_ALIGN(size);
file_size = get_file_size(fd);
if (file_size > 0 && file_size < size) {
error_setg(errp, "backing store %s size 0x%" PRIx64
" does not match 'size' option 0x" RAM_ADDR_FMT,
mem_path, file_size, size);
return NULL;
}
new_block = g_malloc0(sizeof(*new_block));
new_block->mr = mr;
new_block->used_length = size;
new_block->max_length = size;
new_block->flags = ram_flags;
new_block->host = file_ram_alloc(new_block, size, fd, !file_size, errp);
if (!new_block->host) {
g_free(new_block);
return NULL;
}
ram_block_add(new_block, &local_err, ram_flags & RAM_SHARED);
if (local_err) {
g_free(new_block);
error_propagate(errp, local_err);
return NULL;
}
return new_block;
}
尽管该函数的实现颇长，但我们需要关系的大概也就两句话：file_ram_alloc和ram_block_add，前一句是实打实地用qemu_ram_mmap影射了一段内存并返回，而后一句则是把这段内存使用RAMBlock的形式保存，并插入全局的ram_list.blocks中。
这样系统的RAMBlock就初始化完毕了，那么如何把分配出来的内存分配给KVM呢？这里就主要是memory_region_add_subregion做的事情了。
memory_region_add_subregion首先讲传入的subregion的container成员设为mr,然后就调用memory_region_update_container_subregions函数。
memory_region_update_container_subregions则把subregion插入到其container，也就是爸爸的subregions_link链表中去，紧接着就调用memory_region_transaction_commit函数，对所有address_spaces_link调用address_space_set_flatview，寻找挂载在AddressSpace上的所有listener，执行address_space_update_topology_pass，两个FlatView逐条的FlatRange进行对比，以后一个FlatView为准，如果前面FlatView的FlatRange和后面的不一样，则对前面的FlatView的这条FlatRange进行处理。
具体逻辑如下：
static void address_space_update_topology_pass(AddressSpace *as,
const FlatView *old_view,
const FlatView *new_view,
bool adding)
{
unsigned iold, inew;
FlatRange *frold, *frnew;
/* Generate a symmetric difference of the old and new memory maps.
* Kill ranges in the old map, and instantiate ranges in the new map.
*/
iold = inew = 0;
while (iold < old_view->nr || inew < new_view->nr) {
if (iold < old_view->nr) {
frold = &old_view->ranges[iold];
} else {
frold = NULL;
}
if (inew < new_view->nr) {
frnew = &new_view->ranges[inew];
} else {
frnew = NULL;
}
if (frold
&& (!frnew
|| int128_lt(frold->addr.start, frnew->addr.start)
|| (int128_eq(frold->addr.start, frnew->addr.start)
&& !flatrange_equal(frold, frnew)))) {
/* In old but not in new, or in both but attributes changed. */
if (!adding) {
flat_range_coalesced_io_del(frold, as);
MEMORY_LISTENER_UPDATE_REGION(frold, as, Reverse, region_del);
}
++iold;
} else if (frold && frnew && flatrange_equal(frold, frnew)) {
/* In both and unchanged (except logging may have changed) */
if (adding) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, region_nop);
if (frnew->dirty_log_mask & ~frold->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, log_start,
frold->dirty_log_mask,
frnew->dirty_log_mask);
}
if (frold->dirty_log_mask & ~frnew->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Reverse, log_stop,
frold->dirty_log_mask,
frnew->dirty_log_mask);
}
}
++iold;
++inew;
} else {
/* In new */
if (adding) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, region_add);
flat_range_coalesced_io_add(frnew, as);
}
++inew;
}
}
}
可以看出，经过一系列判断之后，调用了MEMORY_LISTENER_UPDATE_REGION宏，该宏则根据第四个参数索引应该执行的回调方法，这里如果传入的是region_add，则调用AddressSpace::region_add方法，对于kvm而言，则是调用了kvm_region_add方法。
而该回调则是在初始化时调用kvm_init时，在初始化结束之后调用了kvm_memory_listener_register将kvm的一系列函数注册到address_space_memory中的。
话说回来，kvm_region_add又做了什么呢？最核心的其实就是用kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem)将这段内存扔给KVM啦。
