hw/core/machine-qmp-cmds.c - qemu - Git at Google

 /*
  * QMP commands related to machines and CPUs
  *
  * Copyright (C) 2014 Red Hat Inc
  *
  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  * See the COPYING file in the top-level directory.
  */

 #include "qemu/osdep.h"
 #include "cpu.h"
 #include "hw/boards.h"
 #include "qapi/error.h"
 #include "qapi/qapi-builtin-visit.h"
 #include "qapi/qapi-commands-machine.h"
 #include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qobject.h"
 #include "qapi/qobject-input-visitor.h"
 #include "qemu/main-loop.h"
 #include "qom/qom-qobject.h"
 #include "sysemu/hostmem.h"
 #include "sysemu/hw_accel.h"
 #include "sysemu/numa.h"
 #include "sysemu/runstate.h"
 #include "sysemu/sysemu.h"

 CpuInfoList *qmp_query_cpus(Error **errp)
 {
     MachineState *ms = MACHINE(qdev_get_machine());
     MachineClass *mc = MACHINE_GET_CLASS(ms);
     CpuInfoList *head = NULL, **tail = &head;
     CPUState *cpu;

     CPU_FOREACH(cpu) {
         CpuInfo *value;
 #if defined(TARGET_I386)
         X86CPU *x86_cpu = X86_CPU(cpu);
         CPUX86State *env = &x86_cpu->env;
 #elif defined(TARGET_PPC)
         PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
         CPUPPCState *env = &ppc_cpu->env;
 #elif defined(TARGET_SPARC)
         SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
         CPUSPARCState *env = &sparc_cpu->env;
 #elif defined(TARGET_RISCV)
         RISCVCPU *riscv_cpu = RISCV_CPU(cpu);
         CPURISCVState *env = &riscv_cpu->env;
 #elif defined(TARGET_MIPS)
         MIPSCPU *mips_cpu = MIPS_CPU(cpu);
         CPUMIPSState *env = &mips_cpu->env;
 #elif defined(TARGET_TRICORE)
         TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
         CPUTriCoreState *env = &tricore_cpu->env;
 #elif defined(TARGET_S390X)
         S390CPU *s390_cpu = S390_CPU(cpu);
         CPUS390XState *env = &s390_cpu->env;
 #endif

         cpu_synchronize_state(cpu);

         value = g_malloc0(sizeof(*value));
         value->CPU = cpu->cpu_index;
         value->current = (cpu == first_cpu);
         value->halted = cpu->halted;
         value->qom_path = object_get_canonical_path(OBJECT(cpu));
         value->thread_id = cpu->thread_id;
 #if defined(TARGET_I386)
         value->arch = CPU_INFO_ARCH_X86;
         value->u.x86.pc = env->eip + env->segs[R_CS].base;
 #elif defined(TARGET_PPC)
         value->arch = CPU_INFO_ARCH_PPC;
         value->u.ppc.nip = env->nip;
 #elif defined(TARGET_SPARC)
         value->arch = CPU_INFO_ARCH_SPARC;
         value->u.q_sparc.pc = env->pc;
         value->u.q_sparc.npc = env->npc;
 #elif defined(TARGET_MIPS)
         value->arch = CPU_INFO_ARCH_MIPS;
         value->u.q_mips.PC = env->active_tc.PC;
 #elif defined(TARGET_TRICORE)
         value->arch = CPU_INFO_ARCH_TRICORE;
         value->u.tricore.PC = env->PC;
 #elif defined(TARGET_S390X)
         value->arch = CPU_INFO_ARCH_S390;
         value->u.s390.cpu_state = env->cpu_state;
 #elif defined(TARGET_RISCV)
         value->arch = CPU_INFO_ARCH_RISCV;
         value->u.riscv.pc = env->pc;
 #else
         value->arch = CPU_INFO_ARCH_OTHER;
 #endif
         value->has_props = !!mc->cpu_index_to_instance_props;
         if (value->has_props) {
             CpuInstanceProperties *props;
             props = g_malloc0(sizeof(*props));
             *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
             value->props = props;
         }

         QAPI_LIST_APPEND(tail, value);
     }

     return head;
 }

 static CpuInfoArch sysemu_target_to_cpuinfo_arch(SysEmuTarget target)
 {
     /*
      * The @SysEmuTarget -> @CpuInfoArch mapping below is based on the
      * TARGET_ARCH -> TARGET_BASE_ARCH mapping in the "configure" script.
      */
     switch (target) {
     case SYS_EMU_TARGET_I386:
     case SYS_EMU_TARGET_X86_64:
         return CPU_INFO_ARCH_X86;

     case SYS_EMU_TARGET_PPC:
     case SYS_EMU_TARGET_PPC64:
         return CPU_INFO_ARCH_PPC;

     case SYS_EMU_TARGET_SPARC:
     case SYS_EMU_TARGET_SPARC64:
         return CPU_INFO_ARCH_SPARC;

     case SYS_EMU_TARGET_MIPS:
     case SYS_EMU_TARGET_MIPSEL:
     case SYS_EMU_TARGET_MIPS64:
     case SYS_EMU_TARGET_MIPS64EL:
         return CPU_INFO_ARCH_MIPS;

     case SYS_EMU_TARGET_TRICORE:
         return CPU_INFO_ARCH_TRICORE;

     case SYS_EMU_TARGET_S390X:
         return CPU_INFO_ARCH_S390;

     case SYS_EMU_TARGET_RISCV32:
     case SYS_EMU_TARGET_RISCV64:
         return CPU_INFO_ARCH_RISCV;

     default:
         return CPU_INFO_ARCH_OTHER;
     }
 }

 static void cpustate_to_cpuinfo_s390(CpuInfoS390 *info, const CPUState *cpu)
 {
 #ifdef TARGET_S390X
     S390CPU *s390_cpu = S390_CPU(cpu);
     CPUS390XState *env = &s390_cpu->env;

     info->cpu_state = env->cpu_state;
 #else
     abort();
 #endif
 }

 /*
  * fast means: we NEVER interrupt vCPU threads to retrieve
  * information from KVM.
  */
 CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
 {
     MachineState *ms = MACHINE(qdev_get_machine());
     MachineClass *mc = MACHINE_GET_CLASS(ms);
     CpuInfoFastList *head = NULL, **tail = &head;
     SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME,
                                           -1, &error_abort);
     CPUState *cpu;

     CPU_FOREACH(cpu) {
         CpuInfoFast *value = g_malloc0(sizeof(*value));

         value->cpu_index = cpu->cpu_index;
         value->qom_path = object_get_canonical_path(OBJECT(cpu));
         value->thread_id = cpu->thread_id;

         value->has_props = !!mc->cpu_index_to_instance_props;
         if (value->has_props) {
             CpuInstanceProperties *props;
             props = g_malloc0(sizeof(*props));
             *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
             value->props = props;
         }

         value->arch = sysemu_target_to_cpuinfo_arch(target);
         value->target = target;
         if (target == SYS_EMU_TARGET_S390X) {
             cpustate_to_cpuinfo_s390(&value->u.s390x, cpu);
         }

         QAPI_LIST_APPEND(tail, value);
     }

     return head;
 }

 MachineInfoList *qmp_query_machines(Error **errp)
 {
     GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
     MachineInfoList *mach_list = NULL;

     for (el = machines; el; el = el->next) {
         MachineClass *mc = el->data;
         MachineInfo *info;

         info = g_malloc0(sizeof(*info));
         if (mc->is_default) {
             info->has_is_default = true;
             info->is_default = true;
         }

         if (mc->alias) {
             info->has_alias = true;
             info->alias = g_strdup(mc->alias);
         }

         info->name = g_strdup(mc->name);
         info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
         info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
         info->numa_mem_supported = mc->numa_mem_supported;
         info->deprecated = !!mc->deprecation_reason;
         if (mc->default_cpu_type) {
             info->default_cpu_type = g_strdup(mc->default_cpu_type);
             info->has_default_cpu_type = true;
         }
         if (mc->default_ram_id) {
             info->default_ram_id = g_strdup(mc->default_ram_id);
             info->has_default_ram_id = true;
         }

         QAPI_LIST_PREPEND(mach_list, info);
     }

     g_slist_free(machines);
     return mach_list;
 }

 CurrentMachineParams *qmp_query_current_machine(Error **errp)
 {
     CurrentMachineParams *params = g_malloc0(sizeof(*params));
     params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();

     return params;
 }

 TargetInfo *qmp_query_target(Error **errp)
 {
     TargetInfo *info = g_malloc0(sizeof(*info));

     info->arch = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME, -1,
                                  &error_abort);

     return info;
 }

 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
 {
     MachineState *ms = MACHINE(qdev_get_machine());
     MachineClass *mc = MACHINE_GET_CLASS(ms);

     if (!mc->has_hotpluggable_cpus) {
         error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
         return NULL;
     }

     return machine_query_hotpluggable_cpus(ms);
 }

 void qmp_set_numa_node(NumaOptions *cmd, Error **errp)
 {
     if (phase_check(PHASE_MACHINE_INITIALIZED)) {
         error_setg(errp, "The command is permitted only before the machine has been created");
         return;
     }

     set_numa_options(MACHINE(qdev_get_machine()), cmd, errp);
 }

 static int query_memdev(Object *obj, void *opaque)
 {
     MemdevList **list = opaque;
     Memdev *m;
     QObject *host_nodes;
     Visitor *v;

     if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
         m = g_malloc0(sizeof(*m));

         m->id = g_strdup(object_get_canonical_path_component(obj));
         m->has_id = !!m->id;

         m->size = object_property_get_uint(obj, "size", &error_abort);
         m->merge = object_property_get_bool(obj, "merge", &error_abort);
         m->dump = object_property_get_bool(obj, "dump", &error_abort);
         m->prealloc = object_property_get_bool(obj, "prealloc", &error_abort);
         m->policy = object_property_get_enum(obj, "policy", "HostMemPolicy",
                                              &error_abort);
         host_nodes = object_property_get_qobject(obj,
                                                  "host-nodes",
                                                  &error_abort);
         v = qobject_input_visitor_new(host_nodes);
         visit_type_uint16List(v, NULL, &m->host_nodes, &error_abort);
         visit_free(v);
         qobject_unref(host_nodes);

         QAPI_LIST_PREPEND(*list, m);
     }

     return 0;
 }

 MemdevList *qmp_query_memdev(Error **errp)
 {
     Object *obj = object_get_objects_root();
     MemdevList *list = NULL;

     object_child_foreach(obj, query_memdev, &list);
     return list;
 }
	/*
	* QMP commands related to machines and CPUs
	*
	* Copyright (C) 2014 Red Hat Inc
	*
	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	* See the COPYING file in the top-level directory.
	*/

	#include "qemu/osdep.h"
	#include "cpu.h"
	#include "hw/boards.h"
	#include "qapi/error.h"
	#include "qapi/qapi-builtin-visit.h"
	#include "qapi/qapi-commands-machine.h"
	#include "qapi/qmp/qerror.h"
	#include "qapi/qmp/qobject.h"
	#include "qapi/qobject-input-visitor.h"
	#include "qemu/main-loop.h"
	#include "qom/qom-qobject.h"
	#include "sysemu/hostmem.h"
	#include "sysemu/hw_accel.h"
	#include "sysemu/numa.h"
	#include "sysemu/runstate.h"
	#include "sysemu/sysemu.h"

	CpuInfoList qmp_query_cpus(Error *errp)
	{
	MachineState *ms = MACHINE(qdev_get_machine());
	MachineClass *mc = MACHINE_GET_CLASS(ms);
	CpuInfoList head = NULL, *tail = &head;
	CPUState *cpu;

	CPU_FOREACH(cpu) {
	CpuInfo *value;
	#if defined(TARGET_I386)
	X86CPU *x86_cpu = X86_CPU(cpu);
	CPUX86State *env = &x86_cpu->env;
	#elif defined(TARGET_PPC)
	PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
	CPUPPCState *env = &ppc_cpu->env;
	#elif defined(TARGET_SPARC)
	SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
	CPUSPARCState *env = &sparc_cpu->env;
	#elif defined(TARGET_RISCV)
	RISCVCPU *riscv_cpu = RISCV_CPU(cpu);
	CPURISCVState *env = &riscv_cpu->env;
	#elif defined(TARGET_MIPS)
	MIPSCPU *mips_cpu = MIPS_CPU(cpu);
	CPUMIPSState *env = &mips_cpu->env;
	#elif defined(TARGET_TRICORE)
	TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
	CPUTriCoreState *env = &tricore_cpu->env;
	#elif defined(TARGET_S390X)
	S390CPU *s390_cpu = S390_CPU(cpu);
	CPUS390XState *env = &s390_cpu->env;
	#endif

	cpu_synchronize_state(cpu);

	value = g_malloc0(sizeof(*value));
	value->CPU = cpu->cpu_index;
	value->current = (cpu == first_cpu);
	value->halted = cpu->halted;
	value->qom_path = object_get_canonical_path(OBJECT(cpu));
	value->thread_id = cpu->thread_id;
	#if defined(TARGET_I386)
	value->arch = CPU_INFO_ARCH_X86;
	value->u.x86.pc = env->eip + env->segs[R_CS].base;
	#elif defined(TARGET_PPC)
	value->arch = CPU_INFO_ARCH_PPC;
	value->u.ppc.nip = env->nip;
	#elif defined(TARGET_SPARC)
	value->arch = CPU_INFO_ARCH_SPARC;
	value->u.q_sparc.pc = env->pc;
	value->u.q_sparc.npc = env->npc;
	#elif defined(TARGET_MIPS)
	value->arch = CPU_INFO_ARCH_MIPS;
	value->u.q_mips.PC = env->active_tc.PC;
	#elif defined(TARGET_TRICORE)
	value->arch = CPU_INFO_ARCH_TRICORE;
	value->u.tricore.PC = env->PC;
	#elif defined(TARGET_S390X)
	value->arch = CPU_INFO_ARCH_S390;
	value->u.s390.cpu_state = env->cpu_state;
	#elif defined(TARGET_RISCV)
	value->arch = CPU_INFO_ARCH_RISCV;
	value->u.riscv.pc = env->pc;
	#else
	value->arch = CPU_INFO_ARCH_OTHER;
	#endif
	value->has_props = !!mc->cpu_index_to_instance_props;
	if (value->has_props) {
	CpuInstanceProperties *props;
	props = g_malloc0(sizeof(*props));
	*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
	value->props = props;
	}

	QAPI_LIST_APPEND(tail, value);
	}

	return head;
	}

	static CpuInfoArch sysemu_target_to_cpuinfo_arch(SysEmuTarget target)
	{
	/*
	* The @SysEmuTarget -> @CpuInfoArch mapping below is based on the
	* TARGET_ARCH -> TARGET_BASE_ARCH mapping in the "configure" script.
	*/
	switch (target) {
	case SYS_EMU_TARGET_I386:
	case SYS_EMU_TARGET_X86_64:
	return CPU_INFO_ARCH_X86;

	case SYS_EMU_TARGET_PPC:
	case SYS_EMU_TARGET_PPC64:
	return CPU_INFO_ARCH_PPC;

	case SYS_EMU_TARGET_SPARC:
	case SYS_EMU_TARGET_SPARC64:
	return CPU_INFO_ARCH_SPARC;

	case SYS_EMU_TARGET_MIPS:
	case SYS_EMU_TARGET_MIPSEL:
	case SYS_EMU_TARGET_MIPS64:
	case SYS_EMU_TARGET_MIPS64EL:
	return CPU_INFO_ARCH_MIPS;

	case SYS_EMU_TARGET_TRICORE:
	return CPU_INFO_ARCH_TRICORE;

	case SYS_EMU_TARGET_S390X:
	return CPU_INFO_ARCH_S390;

	case SYS_EMU_TARGET_RISCV32:
	case SYS_EMU_TARGET_RISCV64:
	return CPU_INFO_ARCH_RISCV;

	default:
	return CPU_INFO_ARCH_OTHER;
	}
	}

	static void cpustate_to_cpuinfo_s390(CpuInfoS390 info, const CPUState cpu)
	{
	#ifdef TARGET_S390X
	S390CPU *s390_cpu = S390_CPU(cpu);
	CPUS390XState *env = &s390_cpu->env;

	info->cpu_state = env->cpu_state;
	#else
	abort();
	#endif
	}

	/*
	* fast means: we NEVER interrupt vCPU threads to retrieve
	* information from KVM.
	*/
	CpuInfoFastList qmp_query_cpus_fast(Error *errp)
	{
	MachineState *ms = MACHINE(qdev_get_machine());
	MachineClass *mc = MACHINE_GET_CLASS(ms);
	CpuInfoFastList head = NULL, *tail = &head;
	SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME,
	-1, &error_abort);
	CPUState *cpu;

	CPU_FOREACH(cpu) {
	CpuInfoFast value = g_malloc0(sizeof(value));

	value->cpu_index = cpu->cpu_index;
	value->qom_path = object_get_canonical_path(OBJECT(cpu));
	value->thread_id = cpu->thread_id;

	value->has_props = !!mc->cpu_index_to_instance_props;
	if (value->has_props) {
	CpuInstanceProperties *props;
	props = g_malloc0(sizeof(*props));
	*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
	value->props = props;
	}

	value->arch = sysemu_target_to_cpuinfo_arch(target);
	value->target = target;
	if (target == SYS_EMU_TARGET_S390X) {
	cpustate_to_cpuinfo_s390(&value->u.s390x, cpu);
	}

	QAPI_LIST_APPEND(tail, value);
	}

	return head;
	}

	MachineInfoList qmp_query_machines(Error *errp)
	{
	GSList el, machines = object_class_get_list(TYPE_MACHINE, false);
	MachineInfoList *mach_list = NULL;

	for (el = machines; el; el = el->next) {
	MachineClass *mc = el->data;
	MachineInfo *info;

	info = g_malloc0(sizeof(*info));
	if (mc->is_default) {
	info->has_is_default = true;
	info->is_default = true;
	}

	if (mc->alias) {
	info->has_alias = true;
	info->alias = g_strdup(mc->alias);
	}

	info->name = g_strdup(mc->name);
	info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
	info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
	info->numa_mem_supported = mc->numa_mem_supported;
	info->deprecated = !!mc->deprecation_reason;
	if (mc->default_cpu_type) {
	info->default_cpu_type = g_strdup(mc->default_cpu_type);
	info->has_default_cpu_type = true;
	}
	if (mc->default_ram_id) {
	info->default_ram_id = g_strdup(mc->default_ram_id);
	info->has_default_ram_id = true;
	}

	QAPI_LIST_PREPEND(mach_list, info);
	}

	g_slist_free(machines);
	return mach_list;
	}

	CurrentMachineParams qmp_query_current_machine(Error *errp)
	{
	CurrentMachineParams params = g_malloc0(sizeof(params));
	params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();

	return params;
	}

	TargetInfo qmp_query_target(Error *errp)
	{
	TargetInfo info = g_malloc0(sizeof(info));

	info->arch = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME, -1,
	&error_abort);

	return info;
	}

	HotpluggableCPUList qmp_query_hotpluggable_cpus(Error *errp)
	{
	MachineState *ms = MACHINE(qdev_get_machine());
	MachineClass *mc = MACHINE_GET_CLASS(ms);

	if (!mc->has_hotpluggable_cpus) {
	error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
	return NULL;
	}

	return machine_query_hotpluggable_cpus(ms);
	}

	void qmp_set_numa_node(NumaOptions cmd, Error *errp)
	{
	if (phase_check(PHASE_MACHINE_INITIALIZED)) {
	error_setg(errp, "The command is permitted only before the machine has been created");
	return;
	}

	set_numa_options(MACHINE(qdev_get_machine()), cmd, errp);
	}

	static int query_memdev(Object obj, void opaque)
	{
	MemdevList **list = opaque;
	Memdev *m;
	QObject *host_nodes;
	Visitor *v;

	if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
	m = g_malloc0(sizeof(*m));

	m->id = g_strdup(object_get_canonical_path_component(obj));
	m->has_id = !!m->id;

	m->size = object_property_get_uint(obj, "size", &error_abort);
	m->merge = object_property_get_bool(obj, "merge", &error_abort);
	m->dump = object_property_get_bool(obj, "dump", &error_abort);
	m->prealloc = object_property_get_bool(obj, "prealloc", &error_abort);
	m->policy = object_property_get_enum(obj, "policy", "HostMemPolicy",
	&error_abort);
	host_nodes = object_property_get_qobject(obj,
	"host-nodes",
	&error_abort);
	v = qobject_input_visitor_new(host_nodes);
	visit_type_uint16List(v, NULL, &m->host_nodes, &error_abort);
	visit_free(v);
	qobject_unref(host_nodes);

	QAPI_LIST_PREPEND(*list, m);
	}

	return 0;
	}

	MemdevList qmp_query_memdev(Error *errp)
	{
	Object *obj = object_get_objects_root();
	MemdevList *list = NULL;

	object_child_foreach(obj, query_memdev, &list);
	return list;
	}