1 /* 2 * QEMU Management Protocol commands 3 * 4 * Copyright IBM, Corp. 2011 5 * 6 * Authors: 7 * Anthony Liguori <aliguori@us.ibm.com> 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2. See 10 * the COPYING file in the top-level directory. 11 * 12 * Contributions after 2012-01-13 are licensed under the terms of the 13 * GNU GPL, version 2 or (at your option) any later version. 14 */ 15 16 #include "qemu/osdep.h" 17 #include "qemu/sockets.h" 18 #include "monitor-internal.h" 19 #include "monitor/qdev.h" 20 #include "monitor/qmp-helpers.h" 21 #include "system/system.h" 22 #include "system/kvm.h" 23 #include "system/runstate.h" 24 #include "system/runstate-action.h" 25 #include "system/block-backend.h" 26 #include "qapi/error.h" 27 #include "qapi/qapi-init-commands.h" 28 #include "qapi/qapi-commands-control.h" 29 #include "qapi/qapi-commands-misc.h" 30 #include "qapi/qmp/qerror.h" 31 #include "qapi/type-helpers.h" 32 #include "hw/mem/memory-device.h" 33 #include "hw/intc/intc.h" 34 35 NameInfo *qmp_query_name(Error **errp) 36 { 37 NameInfo *info = g_malloc0(sizeof(*info)); 38 39 info->name = g_strdup(qemu_name); 40 return info; 41 } 42 43 void qmp_quit(Error **errp) 44 { 45 shutdown_action = SHUTDOWN_ACTION_POWEROFF; 46 qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_QMP_QUIT); 47 } 48 49 void qmp_stop(Error **errp) 50 { 51 /* if there is a dump in background, we should wait until the dump 52 * finished */ 53 if (qemu_system_dump_in_progress()) { 54 error_setg(errp, "There is a dump in process, please wait."); 55 return; 56 } 57 58 if (runstate_check(RUN_STATE_INMIGRATE)) { 59 autostart = 0; 60 } else { 61 vm_stop(RUN_STATE_PAUSED); 62 } 63 } 64 65 void qmp_cont(Error **errp) 66 { 67 BlockBackend *blk; 68 BlockJob *job; 69 Error *local_err = NULL; 70 71 /* if there is a dump in background, we should wait until the dump 72 * finished */ 73 if (qemu_system_dump_in_progress()) { 74 error_setg(errp, "There is a dump in process, please wait."); 75 return; 76 } 77 78 if (runstate_needs_reset()) { 79 error_setg(errp, "Resetting the Virtual Machine is required"); 80 return; 81 } else if (runstate_check(RUN_STATE_SUSPENDED)) { 82 return; 83 } else if (runstate_check(RUN_STATE_FINISH_MIGRATE)) { 84 error_setg(errp, "Migration is not finalized yet"); 85 return; 86 } 87 88 for (blk = blk_next(NULL); blk; blk = blk_next(blk)) { 89 blk_iostatus_reset(blk); 90 } 91 92 WITH_JOB_LOCK_GUARD() { 93 for (job = block_job_next_locked(NULL); job; 94 job = block_job_next_locked(job)) { 95 block_job_iostatus_reset_locked(job); 96 } 97 } 98 99 if (runstate_check(RUN_STATE_INMIGRATE)) { 100 autostart = 1; 101 } else { 102 /* 103 * Continuing after completed migration. Images have been 104 * inactivated to allow the destination to take control. Need to 105 * get control back now. 106 * 107 * If there are no inactive block nodes (e.g. because the VM was 108 * just paused rather than completing a migration), 109 * bdrv_inactivate_all() simply doesn't do anything. 110 */ 111 bdrv_activate_all(&local_err); 112 if (local_err) { 113 error_propagate(errp, local_err); 114 return; 115 } 116 vm_start(); 117 } 118 } 119 120 void qmp_add_client(const char *protocol, const char *fdname, 121 bool has_skipauth, bool skipauth, bool has_tls, bool tls, 122 Error **errp) 123 { 124 static const struct { 125 const char *name; 126 bool (*add_client)(int fd, bool has_skipauth, bool skipauth, 127 bool has_tls, bool tls, Error **errp); 128 } protocol_table[] = { 129 { "spice", qmp_add_client_spice }, 130 #ifdef CONFIG_VNC 131 { "vnc", qmp_add_client_vnc }, 132 #endif 133 #ifdef CONFIG_DBUS_DISPLAY 134 { "@dbus-display", qmp_add_client_dbus_display }, 135 #endif 136 }; 137 int fd, i; 138 139 fd = monitor_get_fd(monitor_cur(), fdname, errp); 140 if (fd < 0) { 141 return; 142 } 143 144 if (!fd_is_socket(fd)) { 145 error_setg(errp, "parameter @fdname must name a socket"); 146 close(fd); 147 return; 148 } 149 150 for (i = 0; i < ARRAY_SIZE(protocol_table); i++) { 151 if (!strcmp(protocol, protocol_table[i].name)) { 152 if (!protocol_table[i].add_client(fd, has_skipauth, skipauth, 153 has_tls, tls, errp)) { 154 close(fd); 155 } 156 return; 157 } 158 } 159 160 if (!qmp_add_client_char(fd, has_skipauth, skipauth, has_tls, tls, 161 protocol, errp)) { 162 close(fd); 163 } 164 } 165 166 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index, 167 int64_t cpu_index, Error **errp) 168 { 169 char *output = NULL; 170 MonitorHMP hmp = {}; 171 172 monitor_data_init(&hmp.common, false, true, false); 173 174 if (has_cpu_index) { 175 int ret = monitor_set_cpu(&hmp.common, cpu_index); 176 if (ret < 0) { 177 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index", 178 "a CPU number"); 179 goto out; 180 } 181 } 182 183 handle_hmp_command(&hmp, command_line); 184 185 WITH_QEMU_LOCK_GUARD(&hmp.common.mon_lock) { 186 output = g_strdup(hmp.common.outbuf->str); 187 } 188 189 out: 190 monitor_data_destroy(&hmp.common); 191 return output; 192 } 193 194 static void __attribute__((__constructor__)) monitor_init_qmp_commands(void) 195 { 196 /* 197 * Two command lists: 198 * - qmp_commands contains all QMP commands 199 * - qmp_cap_negotiation_commands contains just 200 * "qmp_capabilities", to enforce capability negotiation 201 */ 202 203 qmp_init_marshal(&qmp_commands); 204 205 qmp_register_command(&qmp_commands, "device_add", 206 qmp_device_add, 0, 0); 207 208 QTAILQ_INIT(&qmp_cap_negotiation_commands); 209 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities", 210 qmp_marshal_qmp_capabilities, 211 QCO_ALLOW_PRECONFIG, 0); 212 } 213