📋 函数调用链#

vmstate_save(f, se, ms->vmdesc)
    ↓
vmstate_save_state_with_err(f, se->vmsd, se->opaque, vmdesc, &local_err)
    ↓ 
vmstate_save_state_v(f, vmsd, opaque, vmdesc, version_id, errp)
    ↓
[实际的字段序列化处理]

🔍 详细工作流程#

static int vmstate_save(QEMUFile *f, SaveStateEntry *se, JSONWriter *vmdesc)
{
    // 检查是否需要保存这个状态
    if (!se->vmsd || !vmstate_section_needed(se->vmsd, se->opaque)) {
        trace_savevm_section_skip(se->idstr, se->section_id);
        return 0;  // 跳过不需要的状态
    }
    
    // 开始保存过程
    trace_vmstate_save(se->idstr, se->vmsd ? se->vmsd->name : "(old)");
    ret = vmstate_save_state_with_err(f, se->vmsd, se->opaque, vmdesc, &local_err);
}

int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
                         void *opaque, JSONWriter *vmdesc, int version_id, Error errp)
{
    const VMStateField *field = vmsd->fields;
    
    // 🔧 调用保存前处理函数
    if (vmsd->pre_save) {
        ret = vmsd->pre_save(opaque);  // 架构特定的预处理
        if (ret) return ret;
    }
    
    // 🔄 遍历所有字段并保存
    while (field->name) {
        if (vmstate_field_exists(vmsd, field, opaque, version_id)) {
            void *first_elem = opaque + field->offset;  // 计算字段地址
            
            // 根据字段类型选择保存方式
            if (field->flags & VMS_STRUCT) {
                // 递归保存子结构
                ret = vmstate_save_state(f, field->vmsd, curr_elem, vmdesc_loop);
            } else {
                // 保存基础数据类型
                ret = field->info->put(f, curr_elem, size, field, vmdesc_loop);
            }
        }
        field++;
    }
}

🎯 实际架构状态保存示例#

当保存RISC-V CPU状态时：

// 1. 迁移框架调用
vmstate_save(f, riscv_cpu_se, vmdesc);

// 2. 传入vmstate_riscv_cpu描述符
vmstate_save_state_with_err(f, &vmstate_riscv_cpu, cpu_object, vmdesc, &err);

// 3. 实际字段保存
vmstate_save_state_v(f, vmsd, cpu, vmdesc, 10, errp) {
    // 保存32个通用寄存器
    for (i = 0; i < 32; i++) {
        qemu_put_be64(f, cpu->env.gpr[i]);  // 保存 x0-x31 寄存器
    }
    
    // 保存32个浮点寄存器  
    for (i = 0; i < 32; i++) {
        qemu_put_be64(f, cpu->env.fpr[i]);  // 保存 f0-f31 寄存器
    }
    
    // 保存程序计数器
    qemu_put_be64(f, cpu->env.pc);
    
    // 保存控制状态寄存器
    qemu_put_be64(f, cpu->env.mstatus);  // 机器状态寄存器
    qemu_put_be64(f, cpu->env.mip);      // 中断挂起寄存器
    qemu_put_be64(f, cpu->env.mie);      // 中断使能寄存器
    
    // 条件保存子状态
    if (pmp_needed(cpu)) {
        // 保存PMP状态
        vmstate_save_subsection(f, &vmstate_pmp, cpu, vmdesc);
    }
    
    if (vector_needed(cpu)) {
        // 保存向量扩展状态
        vmstate_save_subsection(f, &vmstate_vector, cpu, vmdesc);
    }
}

🔗 在迁移中的调用路径#

migration_thread()
    ↓
qemu_savevm_state_setup(s->to_dst_file)
    ↓
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
    ↓
    vmstate_save(f, se, ms->vmdesc)  // ← 为每个注册的状态条目调用
        ↓
        if (se->idstr == "cpu") {
            // 这里就是保存架构特定CPU状态的地方！
            vmstate_save_state_with_err(f, &vmstate_riscv_cpu, cpu_obj, ...);
        }
        if (se->idstr == "some_device") {
            // 保存设备状态
            vmstate_save_state_with_err(f, &vmstate_device, dev_obj, ...);
        }
}

🎭 支持的不同架构状态#

每次调用vmstate_save()时，根据SaveStateEntry的不同，会保存不同架构的状态：

⚡ 关键机制#

// SaveStateEntry包含架构信息
se->vmsd = &vmstate_riscv_cpu;  // RISC-V架构
se->opaque = riscv_cpu_object;  // RISC-V CPU实例

// 只保存启用的功能
if (vmstate_section_needed(se->vmsd, se->opaque)) {
    // 例如：只有启用Vector扩展时才保存Vector状态
    vmstate_save(...);
}

// 每个字段都有特定的序列化方法
VMSTATE_UINTTL(env.pc, RISCVCPU) 
    ↓ 转换为
field->info->put(f, &cpu->env.pc, sizeof(target_ulong), field, vmdesc);