hw/core/machine-qmp-cmds.c

   1 /*
   2  * QMP commands related to machines and CPUs
   3  *
   4  * Copyright (C) 2014 Red Hat Inc
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "cpu.h"
  12 #include "hw/boards.h"
  13 #include "qapi/error.h"
  14 #include "qapi/qapi-builtin-visit.h"
  15 #include "qapi/qapi-commands-machine.h"
  16 #include "qapi/qmp/qerror.h"
  17 #include "qapi/qmp/qobject.h"
  18 #include "qapi/qobject-input-visitor.h"
  19 #include "qemu/main-loop.h"
  20 #include "qom/qom-qobject.h"
  21 #include "sysemu/hostmem.h"
  22 #include "sysemu/hw_accel.h"
  23 #include "sysemu/numa.h"
  24 #include "sysemu/runstate.h"
  25 #include "sysemu/sysemu.h"
  26
  27 CpuInfoList *qmp_query_cpus(Error **errp)
  28 {
  29     MachineState *ms = MACHINE(qdev_get_machine());
  30     MachineClass *mc = MACHINE_GET_CLASS(ms);
  31     CpuInfoList *head = NULL, **tail = &head;
  32     CPUState *cpu;
  33
  34     CPU_FOREACH(cpu) {
  35         CpuInfo *value;
  36 #if defined(TARGET_I386)
  37         X86CPU *x86_cpu = X86_CPU(cpu);
  38         CPUX86State *env = &x86_cpu->env;
  39 #elif defined(TARGET_PPC)
  40         PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
  41         CPUPPCState *env = &ppc_cpu->env;
  42 #elif defined(TARGET_SPARC)
  43         SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
  44         CPUSPARCState *env = &sparc_cpu->env;
  45 #elif defined(TARGET_RISCV)
  46         RISCVCPU *riscv_cpu = RISCV_CPU(cpu);
  47         CPURISCVState *env = &riscv_cpu->env;
  48 #elif defined(TARGET_MIPS)
  49         MIPSCPU *mips_cpu = MIPS_CPU(cpu);
  50         CPUMIPSState *env = &mips_cpu->env;
  51 #elif defined(TARGET_TRICORE)
  52         TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
  53         CPUTriCoreState *env = &tricore_cpu->env;
  54 #elif defined(TARGET_S390X)
  55         S390CPU *s390_cpu = S390_CPU(cpu);
  56         CPUS390XState *env = &s390_cpu->env;
  57 #endif
  58
  59         cpu_synchronize_state(cpu);
  60
  61         value = g_malloc0(sizeof(*value));
  62         value->CPU = cpu->cpu_index;
  63         value->current = (cpu == first_cpu);
  64         value->halted = cpu->halted;
  65         value->qom_path = object_get_canonical_path(OBJECT(cpu));
  66         value->thread_id = cpu->thread_id;
  67 #if defined(TARGET_I386)
  68         value->arch = CPU_INFO_ARCH_X86;
  69         value->u.x86.pc = env->eip + env->segs[R_CS].base;
  70 #elif defined(TARGET_PPC)
  71         value->arch = CPU_INFO_ARCH_PPC;
  72         value->u.ppc.nip = env->nip;
  73 #elif defined(TARGET_SPARC)
  74         value->arch = CPU_INFO_ARCH_SPARC;
  75         value->u.q_sparc.pc = env->pc;
  76         value->u.q_sparc.npc = env->npc;
  77 #elif defined(TARGET_MIPS)
  78         value->arch = CPU_INFO_ARCH_MIPS;
  79         value->u.q_mips.PC = env->active_tc.PC;
  80 #elif defined(TARGET_TRICORE)
  81         value->arch = CPU_INFO_ARCH_TRICORE;
  82         value->u.tricore.PC = env->PC;
  83 #elif defined(TARGET_S390X)
  84         value->arch = CPU_INFO_ARCH_S390;
  85         value->u.s390.cpu_state = env->cpu_state;
  86 #elif defined(TARGET_RISCV)
  87         value->arch = CPU_INFO_ARCH_RISCV;
  88         value->u.riscv.pc = env->pc;
  89 #else
  90         value->arch = CPU_INFO_ARCH_OTHER;
  91 #endif
  92         value->has_props = !!mc->cpu_index_to_instance_props;
  93         if (value->has_props) {
  94             CpuInstanceProperties *props;
  95             props = g_malloc0(sizeof(*props));
  96             *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
  97             value->props = props;
  98         }
  99
 100         QAPI_LIST_APPEND(tail, value);
 101     }
 102
 103     return head;
 104 }
 105
 106 static CpuInfoArch sysemu_target_to_cpuinfo_arch(SysEmuTarget target)
 107 {
 108     /*
 109      * The @SysEmuTarget -> @CpuInfoArch mapping below is based on the
 110      * TARGET_ARCH -> TARGET_BASE_ARCH mapping in the "configure" script.
 111      */
 112     switch (target) {
 113     case SYS_EMU_TARGET_I386:
 114     case SYS_EMU_TARGET_X86_64:
 115         return CPU_INFO_ARCH_X86;
 116
 117     case SYS_EMU_TARGET_PPC:
 118     case SYS_EMU_TARGET_PPC64:
 119         return CPU_INFO_ARCH_PPC;
 120
 121     case SYS_EMU_TARGET_SPARC:
 122     case SYS_EMU_TARGET_SPARC64:
 123         return CPU_INFO_ARCH_SPARC;
 124
 125     case SYS_EMU_TARGET_MIPS:
 126     case SYS_EMU_TARGET_MIPSEL:
 127     case SYS_EMU_TARGET_MIPS64:
 128     case SYS_EMU_TARGET_MIPS64EL:
 129         return CPU_INFO_ARCH_MIPS;
 130
 131     case SYS_EMU_TARGET_TRICORE:
 132         return CPU_INFO_ARCH_TRICORE;
 133
 134     case SYS_EMU_TARGET_S390X:
 135         return CPU_INFO_ARCH_S390;
 136
 137     case SYS_EMU_TARGET_RISCV32:
 138     case SYS_EMU_TARGET_RISCV64:
 139         return CPU_INFO_ARCH_RISCV;
 140
 141     default:
 142         return CPU_INFO_ARCH_OTHER;
 143     }
 144 }
 145
 146 static void cpustate_to_cpuinfo_s390(CpuInfoS390 *info, const CPUState *cpu)
 147 {
 148 #ifdef TARGET_S390X
 149     S390CPU *s390_cpu = S390_CPU(cpu);
 150     CPUS390XState *env = &s390_cpu->env;
 151
 152     info->cpu_state = env->cpu_state;
 153 #else
 154     abort();
 155 #endif
 156 }
 157
 158 /*
 159  * fast means: we NEVER interrupt vCPU threads to retrieve
 160  * information from KVM.
 161  */
 162 CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
 163 {
 164     MachineState *ms = MACHINE(qdev_get_machine());
 165     MachineClass *mc = MACHINE_GET_CLASS(ms);
 166     CpuInfoFastList *head = NULL, **tail = &head;
 167     SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME,
 168                                           -1, &error_abort);
 169     CPUState *cpu;
 170
 171     CPU_FOREACH(cpu) {
 172         CpuInfoFast *value = g_malloc0(sizeof(*value));
 173
 174         value->cpu_index = cpu->cpu_index;
 175         value->qom_path = object_get_canonical_path(OBJECT(cpu));
 176         value->thread_id = cpu->thread_id;
 177
 178         value->has_props = !!mc->cpu_index_to_instance_props;
 179         if (value->has_props) {
 180             CpuInstanceProperties *props;
 181             props = g_malloc0(sizeof(*props));
 182             *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
 183             value->props = props;
 184         }
 185
 186         value->arch = sysemu_target_to_cpuinfo_arch(target);
 187         value->target = target;
 188         if (target == SYS_EMU_TARGET_S390X) {
 189             cpustate_to_cpuinfo_s390(&value->u.s390x, cpu);
 190         }
 191
 192         QAPI_LIST_APPEND(tail, value);
 193     }
 194
 195     return head;
 196 }
 197
 198 MachineInfoList *qmp_query_machines(Error **errp)
 199 {
 200     GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
 201     MachineInfoList *mach_list = NULL;
 202
 203     for (el = machines; el; el = el->next) {
 204         MachineClass *mc = el->data;
 205         MachineInfo *info;
 206
 207         info = g_malloc0(sizeof(*info));
 208         if (mc->is_default) {
 209             info->has_is_default = true;
 210             info->is_default = true;
 211         }
 212
 213         if (mc->alias) {
 214             info->has_alias = true;
 215             info->alias = g_strdup(mc->alias);
 216         }
 217
 218         info->name = g_strdup(mc->name);
 219         info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
 220         info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
 221         info->numa_mem_supported = mc->numa_mem_supported;
 222         info->deprecated = !!mc->deprecation_reason;
 223         if (mc->default_cpu_type) {
 224             info->default_cpu_type = g_strdup(mc->default_cpu_type);
 225             info->has_default_cpu_type = true;
 226         }
 227         if (mc->default_ram_id) {
 228             info->default_ram_id = g_strdup(mc->default_ram_id);
 229             info->has_default_ram_id = true;
 230         }
 231
 232         QAPI_LIST_PREPEND(mach_list, info);
 233     }
 234
 235     g_slist_free(machines);
 236     return mach_list;
 237 }
 238
 239 CurrentMachineParams *qmp_query_current_machine(Error **errp)
 240 {
 241     CurrentMachineParams *params = g_malloc0(sizeof(*params));
 242     params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();
 243
 244     return params;
 245 }
 246
 247 TargetInfo *qmp_query_target(Error **errp)
 248 {
 249     TargetInfo *info = g_malloc0(sizeof(*info));
 250
 251     info->arch = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME, -1,
 252                                  &error_abort);
 253
 254     return info;
 255 }
 256
 257 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
 258 {
 259     MachineState *ms = MACHINE(qdev_get_machine());
 260     MachineClass *mc = MACHINE_GET_CLASS(ms);
 261
 262     if (!mc->has_hotpluggable_cpus) {
 263         error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
 264         return NULL;
 265     }
 266
 267     return machine_query_hotpluggable_cpus(ms);
 268 }
 269
 270 void qmp_set_numa_node(NumaOptions *cmd, Error **errp)
 271 {
 272     if (phase_check(PHASE_MACHINE_INITIALIZED)) {
 273         error_setg(errp, "The command is permitted only before the machine has been created");
 274         return;
 275     }
 276
 277     set_numa_options(MACHINE(qdev_get_machine()), cmd, errp);
 278 }
 279
 280 static int query_memdev(Object *obj, void *opaque)
 281 {
 282     MemdevList **list = opaque;
 283     Memdev *m;
 284     QObject *host_nodes;
 285     Visitor *v;
 286
 287     if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
 288         m = g_malloc0(sizeof(*m));
 289
 290         m->id = g_strdup(object_get_canonical_path_component(obj));
 291         m->has_id = !!m->id;
 292
 293         m->size = object_property_get_uint(obj, "size", &error_abort);
 294         m->merge = object_property_get_bool(obj, "merge", &error_abort);
 295         m->dump = object_property_get_bool(obj, "dump", &error_abort);
 296         m->prealloc = object_property_get_bool(obj, "prealloc", &error_abort);
 297         m->policy = object_property_get_enum(obj, "policy", "HostMemPolicy",
 298                                              &error_abort);
 299         host_nodes = object_property_get_qobject(obj,
 300                                                  "host-nodes",
 301                                                  &error_abort);
 302         v = qobject_input_visitor_new(host_nodes);
 303         visit_type_uint16List(v, NULL, &m->host_nodes, &error_abort);
 304         visit_free(v);
 305         qobject_unref(host_nodes);
 306
 307         QAPI_LIST_PREPEND(*list, m);
 308     }
 309
 310     return 0;
 311 }
 312
 313 MemdevList *qmp_query_memdev(Error **errp)
 314 {
 315     Object *obj = object_get_objects_root();
 316     MemdevList *list = NULL;
 317
 318     object_child_foreach(obj, query_memdev, &list);
 319     return list;
 320 }