qemu vcpu的创建过程

发布于：2025-07-11 ⋅ 阅读:(20) ⋅ 点赞:(0)

在 QEMU 中，vCPU 线程的启动流程涉及多个阶段，包括初始化、线程创建和执行逻辑。以下是基于搜索结果的详细分析：

QEMU vCPU 线程的启动流程

1. 初始化阶段

  • 设备实例化：QEMU 使用 QOM（QEMU Object Model）系统进行设备的实例化。CPU 设备也需要通过 type_init() 方法注册到 QOM 系统中，这样可以通过 object_new() 创建 CPU 实例。
  • CPU 模型初始化：在 QEMU 启动时，会根据用户指定的 CPU 模型类型（通过命令行参数指定）初始化 vCPU 的特性。例如，对于 x86 架构，QEMU 会加载对应的 CPU 模型定义，并设置支持的特性。

2. 线程创建

  • vCPU 线程创建：在 qemu_init_vcpu() 函数中，QEMU 会为每个 vCPU 创建一个线程。这个线程的主体逻辑是在一个大循环中反复执行取指令、翻译和执行的操作。
  • 线程函数：对于 RISC-V 架构，vCPU 线程的主体函数是 mttcg_cpu_thread_fn，它负责模拟 vCPU 的执行。

3. CPU 状态配置

  • CPU 复位：在 qemu_init_vcpu() 中，vCPU 的初始状态被设置为停止状态（stopped）。在后续的 cpu_reset() 函数中，会调用 riscv_cpu_reset() 来配置 CPU 的初始状态。
  • 启动 vCPU：在 CPU 实例化完成后，通过调用 cpu_resume() 将 vCPU 设置为可以运行的状态。

4. 执行阶段

  • 指令执行循环：vCPU 线程进入一个主循环，不断从虚拟机的内存中取指令、翻译并执行。如果 CPU 处于停止状态，线程会等待直到被唤醒。
  • KVM 支持：在使用 KVM 时，QEMU 会通过 KVM 的 ioctl 接口与内核进行交互，以加速 vCPU 的执行。

5. 多核启动逻辑

  • 主从核协调：在多核虚拟机中，QEMU 会启动多个 vCPU 线程。主核（通常为第一个 vCPU）会初始化公共资源，而从核（其他 vCPU）可能会通过 WFI（Wait for Interrupt）指令挂起，直到主核通过 IPI（Inter-Processor Interrupt）唤醒它们。
  • 固件与内核启动：QEMU 在启动时会加载固件（如 OpenSBI），并通过固件引导内核启动。内核会通过 SBI 接口下发启动命令给从核，从而完成多核启动。

6.小结

QEMU vCPU 线程的启动流程包括初始化设备、创建线程、配置 CPU 状态、进入指令执行循环以及多核协调等阶段。具体实现涉及多个函数和模块，如 qemu_init_vcpu()、cpu_reset() 和 cpu_resume()。对于 RISC-V 架构，QEMU 使用 mttcg_cpu_thread_fn 作为 vCPU 线程的主体函数。

如果您需要进一步深入研究，可以参考 QEMU 的源码，特别是 qemu_init_vcpu() 和 cpu_reset() 等函数的实现。

7.tcg解释器创建过程：

static void tcg_accel_ops_init(AccelOpsClass *ops)
{
    if (qemu_tcg_mttcg_enabled()) {
        ops->create_vcpu_thread = mttcg_start_vcpu_thread;
        ops->kick_vcpu_thread = mttcg_kick_vcpu_thread;
        ops->handle_interrupt = tcg_handle_interrupt;
    } else {
        ops->create_vcpu_thread = rr_start_vcpu_thread;
        ops->kick_vcpu_thread = rr_kick_vcpu_thread;

        if (icount_enabled()) {
            ops->handle_interrupt = icount_handle_interrupt;
            ops->get_virtual_clock = icount_get;
            ops->get_elapsed_ticks = icount_get;
        } else {
            ops->handle_interrupt = tcg_handle_interrupt;
        }
    }

    ops->cpu_reset_hold = tcg_cpu_reset_hold;
    ops->supports_guest_debug = tcg_supports_guest_debug;
    ops->insert_breakpoint = tcg_insert_breakpoint;
    ops->remove_breakpoint = tcg_remove_breakpoint;
    ops->remove_all_breakpoints = tcg_remove_all_breakpoints;
}

这段代码是 QEMU 中与 TCG（Tiny Code Generator）加速器相关的初始化逻辑，用于设置不同加速模式下的虚拟 CPU（vCPU）线程操作函数。以下是对这段代码的详细解析和解释：

7.1. 函数定义
static void tcg_accel_ops_init(AccelOpsClass *ops)
  • tcg_accel_ops_init：这是一个静态函数，用于初始化 TCG 加速器的操作函数。
  • AccelOpsClass *ops：这是一个指向 AccelOpsClass 结构的指针，该结构定义了加速器的操作接口。
7.2. 多线程 TCG（MTTCG）模式
if (qemu_tcg_mttcg_enabled()) {
    ops->create_vcpu_thread = mttcg_start_vcpu_thread;
    ops->kick_vcpu_thread = mttcg_kick_vcpu_thread;
    ops->handle_interrupt = tcg_handle_interrupt;
}
  • qemu_tcg_mttcg_enabled()：检查是否启用了多线程 TCG（MTTCG）模式。
    • 如果启用，ops 的相关操作函数会被设置为 MTTCG 版本。
  • mttcg_start_vcpu_thread：用于启动 vCPU 线程的函数。
  • mttcg_kick_vcpu_thread：用于唤醒 vCPU 线程的函数。
  • tcg_handle_interrupt：处理中断的通用函数。
7.3. 单线程 TCG（RR）模式
else {
    ops->create_vcpu_thread = rr_start_vcpu_thread;
    ops->kick_vcpu_thread = rr_kick_vcpu_thread;

    if (icount_enabled()) {
        ops->handle_interrupt = icount_handle_interrupt;
        ops->get_virtual_clock = icount_get;
        ops->get_elapsed_ticks = icount_get;
    } else {
        ops->handle_interrupt = tcg_handle_interrupt;
    }
}
  • rr_start_vcpu_thread：用于启动 vCPU 线程的函数（单线程模式）。
  • rr_kick_vcpu_thread：用于唤醒 vCPU 线程的函数（单线程模式）。
  • icount_enabled()：检查是否启用了指令计数模式（Instruction Counting Mode）。
    • 如果启用，中断处理和时钟获取函数会被设置为指令计数版本。
    • icount_handle_interrupt：处理中断的指令计数版本。
    • icount_get：获取虚拟时钟和已过时钟的指令计数版本。
    • 如果未启用指令计数模式，则使用通用的 tcg_handle_interrupt 函数。
7.4. 通用操作
ops->cpu_reset_hold = tcg_cpu_reset_hold;
ops->supports_guest_debug = tcg_supports_guest_debug;
ops->insert_breakpoint = tcg_insert_breakpoint;
ops->remove_breakpoint = tcg_remove_breakpoint;
ops->remove_all_breakpoints = tcg_remove_all_breakpoints;
  • tcg_cpu_reset_hold：用于在 CPU 重置时保持状态的函数。
  • tcg_supports_guest_debug：检查是否支持客户机调试的函数。
  • tcg_insert_breakpoint：插入断点的函数。
  • tcg_remove_breakpoint：移除断点的函数。
  • tcg_remove_all_breakpoints：移除所有断点的函数。
7.5 功能总结

这段代码的主要功能是根据 QEMU 的配置（MTTCG 或 RR 模式，以及是否启用指令计数）初始化 TCG 加速器的操作函数。这些操作函数定义了 vCPU 线程的启动、唤醒、中断处理以及调试支持等行为。

7.6 关键点

  1. MTTCG 模式：

    • 启用多线程 TCG 时，使用 mttcg_start_vcpu_thread 和 mttcg_kick_vcpu_thread。
    • 这种模式适合多核系统，可以提高性能。

  2. RR 模式：

    • 单线程 TCG 模式，使用 rr_start_vcpu_thread 和 rr_kick_vcpu_thread。
    • 适合单核系统或调试场景。

  3. 指令计数模式：

    • 如果启用指令计数，中断处理和时钟获取函数会被设置为指令计数版本。
    • 这种模式用于精确模拟指令执行时间。

  4. 调试支持：

    • 提供了断点插入和移除的功能，支持客户机调试。

通过这段代码，QEMU 能够灵活地根据配置选择合适的加速模式和操作函数，从而优化虚拟机的性能和调试能力。

8. vcpu 线程建立细节

void mttcg_start_vcpu_thread(CPUState *cpu)
{
    char thread_name[VCPU_THREAD_NAME_SIZE];

    g_assert(tcg_enabled());
    tcg_cpu_init_cflags(cpu, current_machine->smp.max_cpus > 1);

    /* create a thread per vCPU with TCG (MTTCG) */
    snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
             cpu->cpu_index);

    qemu_thread_create(cpu->thread, thread_name, mttcg_cpu_thread_fn,
                       cpu, QEMU_THREAD_JOINABLE);
}

qemu_thread_create
	qemu_thread_start

thread_context_class_init
	thread_context_set_cpu_affinity
		qemu_thread_set_affinity
		
static void thread_context_class_init(ObjectClass *oc, void *data)
{
    UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);

    ucc->complete = thread_context_instance_complete;
    object_class_property_add(oc, "thread-id", "int",
                              thread_context_get_thread_id, NULL, NULL,
                              NULL);
    object_class_property_add(oc, "cpu-affinity", "int",
                              thread_context_get_cpu_affinity,
                              thread_context_set_cpu_affinity, NULL, NULL);
    object_class_property_add(oc, "node-affinity", "int", NULL,
                              thread_context_set_node_affinity, NULL, NULL);
}

9. cpu属性更改 object_class_property_add

在 QEMU 中，object_class_property_add 函数用于为一个对象类添加一个属性。这个属性可以被用户通过 QEMU 的命令行工具（如 qemu-monitor）或 API 访问和修改。以下是如何使用 object_class_property_add 添加 cpu-affinity 属性的详细说明，以及如何通过 QEMU 的机制访问和修改这个属性。

9.1. object_class_property_add 函数的参数
object_class_property_add(ObjectClass *oc, const char *name, const char *type,
                          ObjectPropertyAccessor *get,
                          ObjectPropertyAccessor *set,
                          ObjectPropertyRelease *release,
                          void *opaque);
  • oc：指向 ObjectClass 的指针，表示当前正在初始化的类。
  • name：属性的名称（例如 "cpu-affinity"）。
  • type：属性的类型（例如 "int" 表示整数）。
  • get：获取属性值的回调函数。
  • set：设置属性值的回调函数。
  • release：释放属性值的回调函数（可选）。
  • opaque：用户数据，传递给回调函数（可选）。
9.2. 回调函数

在您的代码中，cpu-affinity 属性的 get 和 set 回调函数分别是 thread_context_get_cpu_affinity 和 thread_context_set_cpu_affinity。

获取属性值的回调函数
static int thread_context_get_cpu_affinity(Object *obj, Error **errp)
{
    ThreadContext *tc = THREAD_CONTEXT(obj);
    return tc->cpu_affinity;
}
  • obj：指向对象的指针。
  • errp：用于返回错误信息的指针。
  • 返回值：当前的 CPU 亲和性值。
设置属性值的回调函数
static void thread_context_set_cpu_affinity(Object *obj, int value, Error **errp)
{
    ThreadContext *tc = THREAD_CONTEXT(obj);
    tc->cpu_affinity = value;
}
  • obj：指向对象的指针。
  • value：要设置的属性值。
  • errp：用于返回错误信息的指针。
9.3. 如何使用 cpu-affinity 属性
通过 QEMU 命令行工具

假设您已经创建了一个 ThreadContext 对象，并且它被添加到了 QEMU 的对象模型中，您可以通过 QEMU 的命令行工具（如 qemu-monitor）访问和修改 cpu-affinity 属性。

  1. 查询当前的 CPU 亲和性

    (qemu) info object <object-name>

    这将显示对象的所有属性，包括 cpu-affinity。

  2. 设置 CPU 亲和性

    (qemu) object_property_set <object-name> cpu-affinity=2

    这将设置 cpu-affinity 属性为 2。

通过 QEMU API

您也可以通过 QEMU 的 C API 访问和修改属性。

  1. 查询当前的 CPU 亲和性

    int cpu_affinity = object_property_get_int(OBJECT(tc), "cpu-affinity", &error_abort);
printf("Current CPU affinity: %d\n", cpu_affinity);

  2. 设置 CPU 亲和性

    object_property_set_int(OBJECT(tc), "cpu-affinity", 2, &error_abort);
9.4. 完整示例

以下是一个完整的示例，展示如何定义和使用 cpu-affinity 属性。

定义 ThreadContext 类
typedef struct ThreadContext {
    Object parent_obj;
    int cpu_affinity;
} ThreadContext;

static void thread_context_class_init(ObjectClass *oc, void *data)
{
    UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);

    ucc->complete = thread_context_instance_complete;
    object_class_property_add(oc, "cpu-affinity", "int",
                              thread_context_get_cpu_affinity,
                              thread_context_set_cpu_affinity, NULL, NULL);
}

static void thread_context_instance_init(Object *obj)
{
    ThreadContext *tc = THREAD_CONTEXT(obj);
    tc->cpu_affinity = 0; // 默认值
}

static int thread_context_get_cpu_affinity(Object *obj, Error **errp)
{
    ThreadContext *tc = THREAD_CONTEXT(obj);
    return tc->cpu_affinity;
}

static void thread_context_set_cpu_affinity(Object *obj, int value, Error **errp)
{
    ThreadContext *tc = THREAD_CONTEXT(obj);
    tc->cpu_affinity = value;
}

static void thread_context_register_types(void)
{
    static const TypeInfo thread_context_info = {
        .name = TYPE_THREAD_CONTEXT,
        .parent = TYPE_OBJECT,
        .instance_size = sizeof(ThreadContext),
        .instance_init = thread_context_instance_init,
        .class_init = thread_context_class_init,
    };

    type_register_static(&thread_context_info);
}

type_init(thread_context_register_types)
使用 ThreadContext 类
int main(int argc, char *argv[])
{
    ThreadContext *tc = THREAD_CONTEXT(object_new(TYPE_THREAD_CONTEXT));

    // 设置 CPU 亲和性
    object_property_set_int(OBJECT(tc), "cpu-affinity", 2, &error_abort);

    // 查询 CPU 亲和性
    int cpu_affinity = object_property_get_int(OBJECT(tc), "cpu-affinity", &error_abort);
    printf("Current CPU affinity: %d\n", cpu_affinity);

    object_unref(OBJECT(tc));
    return 0;
}
9.5小结

通过 object_class_property_add，您可以为 QEMU 的对象类添加属性，并通过回调函数实现对属性的访问和修改。在您的代码中，cpu-affinity 属性允许用户通过 QEMU 的命令行工具或 API 查询和设置线程的 CPU 亲和性。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布