machine-qmp-cmds.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409
  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. #include "qemu/osdep.h"
  10. #include "hw/acpi/vmgenid.h"
  11. #include "hw/boards.h"
  12. #include "hw/intc/intc.h"
  13. #include "hw/mem/memory-device.h"
  14. #include "qapi/error.h"
  15. #include "qapi/qapi-builtin-visit.h"
  16. #include "qapi/qapi-commands-machine.h"
  17. #include "qobject/qobject.h"
  18. #include "qapi/qobject-input-visitor.h"
  19. #include "qapi/type-helpers.h"
  20. #include "qemu/uuid.h"
  21. #include "qom/qom-qobject.h"
  22. #include "system/hostmem.h"
  23. #include "system/hw_accel.h"
  24. #include "system/numa.h"
  25. #include "system/runstate.h"
  26. #include "system/system.h"
  27. /*
  28. * fast means: we NEVER interrupt vCPU threads to retrieve
  29. * information from KVM.
  30. */
  31. CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
  32. {
  33. MachineState *ms = MACHINE(qdev_get_machine());
  34. MachineClass *mc = MACHINE_GET_CLASS(ms);
  35. CpuInfoFastList *head = NULL, **tail = &head;
  36. SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, target_name(),
  37. -1, &error_abort);
  38. CPUState *cpu;
  39. CPU_FOREACH(cpu) {
  40. CpuInfoFast *value = g_malloc0(sizeof(*value));
  41. value->cpu_index = cpu->cpu_index;
  42. value->qom_path = object_get_canonical_path(OBJECT(cpu));
  43. value->thread_id = cpu->thread_id;
  44. if (mc->cpu_index_to_instance_props) {
  45. CpuInstanceProperties *props;
  46. props = g_malloc0(sizeof(*props));
  47. *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
  48. value->props = props;
  49. }
  50. value->target = target;
  51. if (cpu->cc->query_cpu_fast) {
  52. cpu->cc->query_cpu_fast(cpu, value);
  53. }
  54. QAPI_LIST_APPEND(tail, value);
  55. }
  56. return head;
  57. }
  58. MachineInfoList *qmp_query_machines(bool has_compat_props, bool compat_props,
  59. Error **errp)
  60. {
  61. GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
  62. MachineInfoList *mach_list = NULL;
  63. for (el = machines; el; el = el->next) {
  64. MachineClass *mc = el->data;
  65. const char *default_cpu_type = machine_class_default_cpu_type(mc);
  66. MachineInfo *info;
  67. info = g_malloc0(sizeof(*info));
  68. if (mc->is_default) {
  69. info->has_is_default = true;
  70. info->is_default = true;
  71. }
  72. if (mc->alias) {
  73. info->alias = g_strdup(mc->alias);
  74. }
  75. info->name = g_strdup(mc->name);
  76. info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
  77. info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
  78. info->numa_mem_supported = mc->numa_mem_supported;
  79. info->deprecated = !!mc->deprecation_reason;
  80. info->acpi = !!object_class_property_find(OBJECT_CLASS(mc), "acpi");
  81. if (default_cpu_type) {
  82. info->default_cpu_type = g_strdup(default_cpu_type);
  83. }
  84. if (mc->default_ram_id) {
  85. info->default_ram_id = g_strdup(mc->default_ram_id);
  86. }
  87. if (compat_props && mc->compat_props) {
  88. int i;
  89. info->compat_props = NULL;
  90. CompatPropertyList **tail = &(info->compat_props);
  91. info->has_compat_props = true;
  92. for (i = 0; i < mc->compat_props->len; i++) {
  93. GlobalProperty *mt_prop = g_ptr_array_index(mc->compat_props,
  94. i);
  95. CompatProperty *prop;
  96. prop = g_malloc0(sizeof(*prop));
  97. prop->qom_type = g_strdup(mt_prop->driver);
  98. prop->property = g_strdup(mt_prop->property);
  99. prop->value = g_strdup(mt_prop->value);
  100. QAPI_LIST_APPEND(tail, prop);
  101. }
  102. }
  103. QAPI_LIST_PREPEND(mach_list, info);
  104. }
  105. g_slist_free(machines);
  106. return mach_list;
  107. }
  108. CurrentMachineParams *qmp_query_current_machine(Error **errp)
  109. {
  110. CurrentMachineParams *params = g_malloc0(sizeof(*params));
  111. params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();
  112. return params;
  113. }
  114. TargetInfo *qmp_query_target(Error **errp)
  115. {
  116. TargetInfo *info = g_malloc0(sizeof(*info));
  117. info->arch = qapi_enum_parse(&SysEmuTarget_lookup, target_name(), -1,
  118. &error_abort);
  119. return info;
  120. }
  121. HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
  122. {
  123. MachineState *ms = MACHINE(qdev_get_machine());
  124. MachineClass *mc = MACHINE_GET_CLASS(ms);
  125. if (!mc->has_hotpluggable_cpus) {
  126. error_setg(errp, "machine does not support hot-plugging CPUs");
  127. return NULL;
  128. }
  129. return machine_query_hotpluggable_cpus(ms);
  130. }
  131. void qmp_set_numa_node(NumaOptions *cmd, Error **errp)
  132. {
  133. if (phase_check(PHASE_MACHINE_INITIALIZED)) {
  134. error_setg(errp, "The command is permitted only before the machine has been created");
  135. return;
  136. }
  137. set_numa_options(MACHINE(qdev_get_machine()), cmd, errp);
  138. }
  139. static int query_memdev(Object *obj, void *opaque)
  140. {
  141. Error *err = NULL;
  142. MemdevList **list = opaque;
  143. Memdev *m;
  144. QObject *host_nodes;
  145. Visitor *v;
  146. if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
  147. m = g_malloc0(sizeof(*m));
  148. m->id = g_strdup(object_get_canonical_path_component(obj));
  149. m->size = object_property_get_uint(obj, "size", &error_abort);
  150. m->merge = object_property_get_bool(obj, "merge", &error_abort);
  151. m->dump = object_property_get_bool(obj, "dump", &error_abort);
  152. m->prealloc = object_property_get_bool(obj, "prealloc", &error_abort);
  153. m->share = object_property_get_bool(obj, "share", &error_abort);
  154. m->reserve = object_property_get_bool(obj, "reserve", &err);
  155. if (err) {
  156. error_free_or_abort(&err);
  157. } else {
  158. m->has_reserve = true;
  159. }
  160. m->policy = object_property_get_enum(obj, "policy", "HostMemPolicy",
  161. &error_abort);
  162. host_nodes = object_property_get_qobject(obj,
  163. "host-nodes",
  164. &error_abort);
  165. v = qobject_input_visitor_new(host_nodes);
  166. visit_type_uint16List(v, NULL, &m->host_nodes, &error_abort);
  167. visit_free(v);
  168. qobject_unref(host_nodes);
  169. QAPI_LIST_PREPEND(*list, m);
  170. }
  171. return 0;
  172. }
  173. MemdevList *qmp_query_memdev(Error **errp)
  174. {
  175. Object *obj = object_get_objects_root();
  176. MemdevList *list = NULL;
  177. object_child_foreach(obj, query_memdev, &list);
  178. return list;
  179. }
  180. HumanReadableText *qmp_x_query_numa(Error **errp)
  181. {
  182. g_autoptr(GString) buf = g_string_new("");
  183. int i, nb_numa_nodes;
  184. NumaNodeMem *node_mem;
  185. CpuInfoFastList *cpu_list, *cpu;
  186. MachineState *ms = MACHINE(qdev_get_machine());
  187. nb_numa_nodes = ms->numa_state ? ms->numa_state->num_nodes : 0;
  188. g_string_append_printf(buf, "%d nodes\n", nb_numa_nodes);
  189. if (!nb_numa_nodes) {
  190. goto done;
  191. }
  192. cpu_list = qmp_query_cpus_fast(&error_abort);
  193. node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
  194. query_numa_node_mem(node_mem, ms);
  195. for (i = 0; i < nb_numa_nodes; i++) {
  196. g_string_append_printf(buf, "node %d cpus:", i);
  197. for (cpu = cpu_list; cpu; cpu = cpu->next) {
  198. if (cpu->value->props && cpu->value->props->has_node_id &&
  199. cpu->value->props->node_id == i) {
  200. g_string_append_printf(buf, " %" PRIi64, cpu->value->cpu_index);
  201. }
  202. }
  203. g_string_append_printf(buf, "\n");
  204. g_string_append_printf(buf, "node %d size: %" PRId64 " MB\n", i,
  205. node_mem[i].node_mem >> 20);
  206. g_string_append_printf(buf, "node %d plugged: %" PRId64 " MB\n", i,
  207. node_mem[i].node_plugged_mem >> 20);
  208. }
  209. qapi_free_CpuInfoFastList(cpu_list);
  210. g_free(node_mem);
  211. done:
  212. return human_readable_text_from_str(buf);
  213. }
  214. KvmInfo *qmp_query_kvm(Error **errp)
  215. {
  216. KvmInfo *info = g_malloc0(sizeof(*info));
  217. info->enabled = kvm_enabled();
  218. info->present = accel_find("kvm");
  219. return info;
  220. }
  221. UuidInfo *qmp_query_uuid(Error **errp)
  222. {
  223. UuidInfo *info = g_malloc0(sizeof(*info));
  224. info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid);
  225. return info;
  226. }
  227. void qmp_system_reset(Error **errp)
  228. {
  229. qemu_system_reset_request(SHUTDOWN_CAUSE_HOST_QMP_SYSTEM_RESET);
  230. }
  231. void qmp_system_powerdown(Error **errp)
  232. {
  233. qemu_system_powerdown_request();
  234. }
  235. void qmp_system_wakeup(Error **errp)
  236. {
  237. if (!qemu_wakeup_suspend_enabled()) {
  238. error_setg(errp,
  239. "wake-up from suspend is not supported by this guest");
  240. return;
  241. }
  242. qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, errp);
  243. }
  244. MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
  245. {
  246. return qmp_memory_device_list();
  247. }
  248. MemoryInfo *qmp_query_memory_size_summary(Error **errp)
  249. {
  250. MemoryInfo *mem_info = g_new0(MemoryInfo, 1);
  251. MachineState *ms = MACHINE(qdev_get_machine());
  252. mem_info->base_memory = ms->ram_size;
  253. mem_info->plugged_memory = get_plugged_memory_size();
  254. mem_info->has_plugged_memory =
  255. mem_info->plugged_memory != (uint64_t)-1;
  256. return mem_info;
  257. }
  258. HumanReadableText *qmp_x_query_ramblock(Error **errp)
  259. {
  260. g_autoptr(GString) buf = ram_block_format();
  261. return human_readable_text_from_str(buf);
  262. }
  263. static int qmp_x_query_irq_foreach(Object *obj, void *opaque)
  264. {
  265. InterruptStatsProvider *intc;
  266. InterruptStatsProviderClass *k;
  267. GString *buf = opaque;
  268. if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
  269. intc = INTERRUPT_STATS_PROVIDER(obj);
  270. k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
  271. uint64_t *irq_counts;
  272. unsigned int nb_irqs, i;
  273. if (k->get_statistics &&
  274. k->get_statistics(intc, &irq_counts, &nb_irqs)) {
  275. if (nb_irqs > 0) {
  276. g_string_append_printf(buf, "IRQ statistics for %s:\n",
  277. object_get_typename(obj));
  278. for (i = 0; i < nb_irqs; i++) {
  279. if (irq_counts[i] > 0) {
  280. g_string_append_printf(buf, "%2d: %" PRId64 "\n", i,
  281. irq_counts[i]);
  282. }
  283. }
  284. }
  285. } else {
  286. g_string_append_printf(buf,
  287. "IRQ statistics not available for %s.\n",
  288. object_get_typename(obj));
  289. }
  290. }
  291. return 0;
  292. }
  293. HumanReadableText *qmp_x_query_irq(Error **errp)
  294. {
  295. g_autoptr(GString) buf = g_string_new("");
  296. object_child_foreach_recursive(object_get_root(),
  297. qmp_x_query_irq_foreach, buf);
  298. return human_readable_text_from_str(buf);
  299. }
  300. static int qmp_x_query_intc_foreach(Object *obj, void *opaque)
  301. {
  302. InterruptStatsProvider *intc;
  303. InterruptStatsProviderClass *k;
  304. GString *buf = opaque;
  305. if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
  306. intc = INTERRUPT_STATS_PROVIDER(obj);
  307. k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
  308. if (k->print_info) {
  309. k->print_info(intc, buf);
  310. } else {
  311. g_string_append_printf(buf,
  312. "Interrupt controller information not available for %s.\n",
  313. object_get_typename(obj));
  314. }
  315. }
  316. return 0;
  317. }
  318. HumanReadableText *qmp_x_query_interrupt_controllers(Error **errp)
  319. {
  320. g_autoptr(GString) buf = g_string_new("");
  321. object_child_foreach_recursive(object_get_root(),
  322. qmp_x_query_intc_foreach, buf);
  323. return human_readable_text_from_str(buf);
  324. }
  325. GuidInfo *qmp_query_vm_generation_id(Error **errp)
  326. {
  327. GuidInfo *info;
  328. VmGenIdState *vms;
  329. Object *obj = find_vmgenid_dev();
  330. if (!obj) {
  331. error_setg(errp, "VM Generation ID device not found");
  332. return NULL;
  333. }
  334. vms = VMGENID(obj);
  335. info = g_malloc0(sizeof(*info));
  336. info->guid = qemu_uuid_unparse_strdup(&vms->guid);
  337. return info;
  338. }