hmp-cmds.c (f3b8f18ebf344ab359e8f79f6ed777e740dae77c) hmp-cmds.c (187c614767cdb3407bc67acf77b9b1a0d985a39d)
1/*
2 * Human Monitor Interface commands
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *

--- 46 unchanged lines hidden (view full) ---

55#include "hw/rdma/rdma.h"
56#include "migration/snapshot.h"
57#include "migration/misc.h"
58
59#ifdef CONFIG_SPICE
60#include <spice/enums.h>
61#endif
62
1/*
2 * Human Monitor Interface commands
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *

--- 46 unchanged lines hidden (view full) ---

55#include "hw/rdma/rdma.h"
56#include "migration/snapshot.h"
57#include "migration/misc.h"
58
59#ifdef CONFIG_SPICE
60#include <spice/enums.h>
61#endif
62
63void hmp_handle_error(Monitor *mon, Error **errp)
63void hmp_handle_error(Monitor *mon, Error *err)
64{
64{
65 assert(errp);
66 if (*errp) {
67 error_reportf_err(*errp, "Error: ");
65 if (err) {
66 error_reportf_err(err, "Error: ");
68 }
69}
70
71/*
72 * Produce a strList from a comma separated list.
73 * A NULL or empty input string return NULL.
74 */
75static strList *strList_from_comma_list(const char *in)

--- 653 unchanged lines hidden (view full) ---

729
730void hmp_info_vnc(Monitor *mon, const QDict *qdict)
731{
732 VncInfo2List *info2l;
733 Error *err = NULL;
734
735 info2l = qmp_query_vnc_servers(&err);
736 if (err) {
67 }
68}
69
70/*
71 * Produce a strList from a comma separated list.
72 * A NULL or empty input string return NULL.
73 */
74static strList *strList_from_comma_list(const char *in)

--- 653 unchanged lines hidden (view full) ---

728
729void hmp_info_vnc(Monitor *mon, const QDict *qdict)
730{
731 VncInfo2List *info2l;
732 Error *err = NULL;
733
734 info2l = qmp_query_vnc_servers(&err);
735 if (err) {
737 hmp_handle_error(mon, &err);
736 hmp_handle_error(mon, err);
738 return;
739 }
740 if (!info2l) {
741 monitor_printf(mon, "None\n");
742 return;
743 }
744
745 while (info2l) {

--- 99 unchanged lines hidden (view full) ---

845
846void hmp_info_balloon(Monitor *mon, const QDict *qdict)
847{
848 BalloonInfo *info;
849 Error *err = NULL;
850
851 info = qmp_query_balloon(&err);
852 if (err) {
737 return;
738 }
739 if (!info2l) {
740 monitor_printf(mon, "None\n");
741 return;
742 }
743
744 while (info2l) {

--- 99 unchanged lines hidden (view full) ---

844
845void hmp_info_balloon(Monitor *mon, const QDict *qdict)
846{
847 BalloonInfo *info;
848 Error *err = NULL;
849
850 info = qmp_query_balloon(&err);
851 if (err) {
853 hmp_handle_error(mon, &err);
852 hmp_handle_error(mon, err);
854 return;
855 }
856
857 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
858
859 qapi_free_BalloonInfo(info);
860}
861

--- 305 unchanged lines hidden (view full) ---

1167 } else if (!strcmp(op, "off")) {
1168 qsp_disable();
1169 } else if (!strcmp(op, "reset")) {
1170 qsp_reset();
1171 } else {
1172 Error *err = NULL;
1173
1174 error_setg(&err, QERR_INVALID_PARAMETER, op);
853 return;
854 }
855
856 monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);
857
858 qapi_free_BalloonInfo(info);
859}
860

--- 305 unchanged lines hidden (view full) ---

1166 } else if (!strcmp(op, "off")) {
1167 qsp_disable();
1168 } else if (!strcmp(op, "reset")) {
1169 qsp_reset();
1170 } else {
1171 Error *err = NULL;
1172
1173 error_setg(&err, QERR_INVALID_PARAMETER, op);
1175 hmp_handle_error(mon, &err);
1174 hmp_handle_error(mon, err);
1176 }
1177}
1178
1179void hmp_system_reset(Monitor *mon, const QDict *qdict)
1180{
1181 qmp_system_reset(NULL);
1182}
1183
1184void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
1185{
1186 qmp_system_powerdown(NULL);
1187}
1188
1189void hmp_exit_preconfig(Monitor *mon, const QDict *qdict)
1190{
1191 Error *err = NULL;
1192
1193 qmp_x_exit_preconfig(&err);
1175 }
1176}
1177
1178void hmp_system_reset(Monitor *mon, const QDict *qdict)
1179{
1180 qmp_system_reset(NULL);
1181}
1182
1183void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
1184{
1185 qmp_system_powerdown(NULL);
1186}
1187
1188void hmp_exit_preconfig(Monitor *mon, const QDict *qdict)
1189{
1190 Error *err = NULL;
1191
1192 qmp_x_exit_preconfig(&err);
1194 hmp_handle_error(mon, &err);
1193 hmp_handle_error(mon, err);
1195}
1196
1197void hmp_cpu(Monitor *mon, const QDict *qdict)
1198{
1199 int64_t cpu_index;
1200
1201 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
1202 use it are converted to the QAPI */

--- 12 unchanged lines hidden (view full) ---

1215 int cpu_index = monitor_get_cpu_index();
1216
1217 if (cpu_index < 0) {
1218 monitor_printf(mon, "No CPU available\n");
1219 return;
1220 }
1221
1222 qmp_memsave(addr, size, filename, true, cpu_index, &err);
1194}
1195
1196void hmp_cpu(Monitor *mon, const QDict *qdict)
1197{
1198 int64_t cpu_index;
1199
1200 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
1201 use it are converted to the QAPI */

--- 12 unchanged lines hidden (view full) ---

1214 int cpu_index = monitor_get_cpu_index();
1215
1216 if (cpu_index < 0) {
1217 monitor_printf(mon, "No CPU available\n");
1218 return;
1219 }
1220
1221 qmp_memsave(addr, size, filename, true, cpu_index, &err);
1223 hmp_handle_error(mon, &err);
1222 hmp_handle_error(mon, err);
1224}
1225
1226void hmp_pmemsave(Monitor *mon, const QDict *qdict)
1227{
1228 uint32_t size = qdict_get_int(qdict, "size");
1229 const char *filename = qdict_get_str(qdict, "filename");
1230 uint64_t addr = qdict_get_int(qdict, "val");
1231 Error *err = NULL;
1232
1233 qmp_pmemsave(addr, size, filename, &err);
1223}
1224
1225void hmp_pmemsave(Monitor *mon, const QDict *qdict)
1226{
1227 uint32_t size = qdict_get_int(qdict, "size");
1228 const char *filename = qdict_get_str(qdict, "filename");
1229 uint64_t addr = qdict_get_int(qdict, "val");
1230 Error *err = NULL;
1231
1232 qmp_pmemsave(addr, size, filename, &err);
1234 hmp_handle_error(mon, &err);
1233 hmp_handle_error(mon, err);
1235}
1236
1237void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
1238{
1239 const char *chardev = qdict_get_str(qdict, "device");
1240 const char *data = qdict_get_str(qdict, "data");
1241 Error *err = NULL;
1242
1243 qmp_ringbuf_write(chardev, data, false, 0, &err);
1244
1234}
1235
1236void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
1237{
1238 const char *chardev = qdict_get_str(qdict, "device");
1239 const char *data = qdict_get_str(qdict, "data");
1240 Error *err = NULL;
1241
1242 qmp_ringbuf_write(chardev, data, false, 0, &err);
1243
1245 hmp_handle_error(mon, &err);
1244 hmp_handle_error(mon, err);
1246}
1247
1248void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
1249{
1250 uint32_t size = qdict_get_int(qdict, "size");
1251 const char *chardev = qdict_get_str(qdict, "device");
1252 char *data;
1253 Error *err = NULL;
1254 int i;
1255
1256 data = qmp_ringbuf_read(chardev, size, false, 0, &err);
1257 if (err) {
1245}
1246
1247void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
1248{
1249 uint32_t size = qdict_get_int(qdict, "size");
1250 const char *chardev = qdict_get_str(qdict, "device");
1251 char *data;
1252 Error *err = NULL;
1253 int i;
1254
1255 data = qmp_ringbuf_read(chardev, size, false, 0, &err);
1256 if (err) {
1258 hmp_handle_error(mon, &err);
1257 hmp_handle_error(mon, err);
1259 return;
1260 }
1261
1262 for (i = 0; data[i]; i++) {
1263 unsigned char ch = data[i];
1264
1265 if (ch == '\\') {
1266 monitor_printf(mon, "\\\\");

--- 8 unchanged lines hidden (view full) ---

1275 g_free(data);
1276}
1277
1278void hmp_cont(Monitor *mon, const QDict *qdict)
1279{
1280 Error *err = NULL;
1281
1282 qmp_cont(&err);
1258 return;
1259 }
1260
1261 for (i = 0; data[i]; i++) {
1262 unsigned char ch = data[i];
1263
1264 if (ch == '\\') {
1265 monitor_printf(mon, "\\\\");

--- 8 unchanged lines hidden (view full) ---

1274 g_free(data);
1275}
1276
1277void hmp_cont(Monitor *mon, const QDict *qdict)
1278{
1279 Error *err = NULL;
1280
1281 qmp_cont(&err);
1283 hmp_handle_error(mon, &err);
1282 hmp_handle_error(mon, err);
1284}
1285
1286void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
1287{
1288 Error *err = NULL;
1289
1290 qmp_system_wakeup(&err);
1283}
1284
1285void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
1286{
1287 Error *err = NULL;
1288
1289 qmp_system_wakeup(&err);
1291 hmp_handle_error(mon, &err);
1290 hmp_handle_error(mon, err);
1292}
1293
1294void hmp_nmi(Monitor *mon, const QDict *qdict)
1295{
1296 Error *err = NULL;
1297
1298 qmp_inject_nmi(&err);
1291}
1292
1293void hmp_nmi(Monitor *mon, const QDict *qdict)
1294{
1295 Error *err = NULL;
1296
1297 qmp_inject_nmi(&err);
1299 hmp_handle_error(mon, &err);
1298 hmp_handle_error(mon, err);
1300}
1301
1302void hmp_set_link(Monitor *mon, const QDict *qdict)
1303{
1304 const char *name = qdict_get_str(qdict, "name");
1305 bool up = qdict_get_bool(qdict, "up");
1306 Error *err = NULL;
1307
1308 qmp_set_link(name, up, &err);
1299}
1300
1301void hmp_set_link(Monitor *mon, const QDict *qdict)
1302{
1303 const char *name = qdict_get_str(qdict, "name");
1304 bool up = qdict_get_bool(qdict, "up");
1305 Error *err = NULL;
1306
1307 qmp_set_link(name, up, &err);
1309 hmp_handle_error(mon, &err);
1308 hmp_handle_error(mon, err);
1310}
1311
1312void hmp_block_passwd(Monitor *mon, const QDict *qdict)
1313{
1314 const char *device = qdict_get_str(qdict, "device");
1315 const char *password = qdict_get_str(qdict, "password");
1316 Error *err = NULL;
1317
1318 qmp_block_passwd(true, device, false, NULL, password, &err);
1309}
1310
1311void hmp_block_passwd(Monitor *mon, const QDict *qdict)
1312{
1313 const char *device = qdict_get_str(qdict, "device");
1314 const char *password = qdict_get_str(qdict, "password");
1315 Error *err = NULL;
1316
1317 qmp_block_passwd(true, device, false, NULL, password, &err);
1319 hmp_handle_error(mon, &err);
1318 hmp_handle_error(mon, err);
1320}
1321
1322void hmp_balloon(Monitor *mon, const QDict *qdict)
1323{
1324 int64_t value = qdict_get_int(qdict, "value");
1325 Error *err = NULL;
1326
1327 qmp_balloon(value, &err);
1319}
1320
1321void hmp_balloon(Monitor *mon, const QDict *qdict)
1322{
1323 int64_t value = qdict_get_int(qdict, "value");
1324 Error *err = NULL;
1325
1326 qmp_balloon(value, &err);
1328 hmp_handle_error(mon, &err);
1327 hmp_handle_error(mon, err);
1329}
1330
1331void hmp_block_resize(Monitor *mon, const QDict *qdict)
1332{
1333 const char *device = qdict_get_str(qdict, "device");
1334 int64_t size = qdict_get_int(qdict, "size");
1335 Error *err = NULL;
1336
1337 qmp_block_resize(true, device, false, NULL, size, &err);
1328}
1329
1330void hmp_block_resize(Monitor *mon, const QDict *qdict)
1331{
1332 const char *device = qdict_get_str(qdict, "device");
1333 int64_t size = qdict_get_int(qdict, "size");
1334 Error *err = NULL;
1335
1336 qmp_block_resize(true, device, false, NULL, size, &err);
1338 hmp_handle_error(mon, &err);
1337 hmp_handle_error(mon, err);
1339}
1340
1341void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
1342{
1343 const char *filename = qdict_get_str(qdict, "target");
1344 const char *format = qdict_get_try_str(qdict, "format");
1345 bool reuse = qdict_get_try_bool(qdict, "reuse", false);
1346 bool full = qdict_get_try_bool(qdict, "full", false);

--- 6 unchanged lines hidden (view full) ---

1353 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
1354 .has_mode = true,
1355 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
1356 .unmap = true,
1357 };
1358
1359 if (!filename) {
1360 error_setg(&err, QERR_MISSING_PARAMETER, "target");
1338}
1339
1340void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
1341{
1342 const char *filename = qdict_get_str(qdict, "target");
1343 const char *format = qdict_get_try_str(qdict, "format");
1344 bool reuse = qdict_get_try_bool(qdict, "reuse", false);
1345 bool full = qdict_get_try_bool(qdict, "full", false);

--- 6 unchanged lines hidden (view full) ---

1352 .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
1353 .has_mode = true,
1354 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
1355 .unmap = true,
1356 };
1357
1358 if (!filename) {
1359 error_setg(&err, QERR_MISSING_PARAMETER, "target");
1361 hmp_handle_error(mon, &err);
1360 hmp_handle_error(mon, err);
1362 return;
1363 }
1364 qmp_drive_mirror(&mirror, &err);
1361 return;
1362 }
1363 qmp_drive_mirror(&mirror, &err);
1365 hmp_handle_error(mon, &err);
1364 hmp_handle_error(mon, err);
1366}
1367
1368void hmp_drive_backup(Monitor *mon, const QDict *qdict)
1369{
1370 const char *device = qdict_get_str(qdict, "device");
1371 const char *filename = qdict_get_str(qdict, "target");
1372 const char *format = qdict_get_try_str(qdict, "format");
1373 bool reuse = qdict_get_try_bool(qdict, "reuse", false);

--- 9 unchanged lines hidden (view full) ---

1383 .has_mode = true,
1384 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
1385 .has_compress = !!compress,
1386 .compress = compress,
1387 };
1388
1389 if (!filename) {
1390 error_setg(&err, QERR_MISSING_PARAMETER, "target");
1365}
1366
1367void hmp_drive_backup(Monitor *mon, const QDict *qdict)
1368{
1369 const char *device = qdict_get_str(qdict, "device");
1370 const char *filename = qdict_get_str(qdict, "target");
1371 const char *format = qdict_get_try_str(qdict, "format");
1372 bool reuse = qdict_get_try_bool(qdict, "reuse", false);

--- 9 unchanged lines hidden (view full) ---

1382 .has_mode = true,
1383 .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
1384 .has_compress = !!compress,
1385 .compress = compress,
1386 };
1387
1388 if (!filename) {
1389 error_setg(&err, QERR_MISSING_PARAMETER, "target");
1391 hmp_handle_error(mon, &err);
1390 hmp_handle_error(mon, err);
1392 return;
1393 }
1394
1395 qmp_drive_backup(&backup, &err);
1391 return;
1392 }
1393
1394 qmp_drive_backup(&backup, &err);
1396 hmp_handle_error(mon, &err);
1395 hmp_handle_error(mon, err);
1397}
1398
1399void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
1400{
1401 const char *device = qdict_get_str(qdict, "device");
1402 const char *filename = qdict_get_try_str(qdict, "snapshot-file");
1403 const char *format = qdict_get_try_str(qdict, "format");
1404 bool reuse = qdict_get_try_bool(qdict, "reuse", false);
1405 enum NewImageMode mode;
1406 Error *err = NULL;
1407
1408 if (!filename) {
1409 /* In the future, if 'snapshot-file' is not specified, the snapshot
1410 will be taken internally. Today it's actually required. */
1411 error_setg(&err, QERR_MISSING_PARAMETER, "snapshot-file");
1396}
1397
1398void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
1399{
1400 const char *device = qdict_get_str(qdict, "device");
1401 const char *filename = qdict_get_try_str(qdict, "snapshot-file");
1402 const char *format = qdict_get_try_str(qdict, "format");
1403 bool reuse = qdict_get_try_bool(qdict, "reuse", false);
1404 enum NewImageMode mode;
1405 Error *err = NULL;
1406
1407 if (!filename) {
1408 /* In the future, if 'snapshot-file' is not specified, the snapshot
1409 will be taken internally. Today it's actually required. */
1410 error_setg(&err, QERR_MISSING_PARAMETER, "snapshot-file");
1412 hmp_handle_error(mon, &err);
1411 hmp_handle_error(mon, err);
1413 return;
1414 }
1415
1416 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1417 qmp_blockdev_snapshot_sync(true, device, false, NULL,
1418 filename, false, NULL,
1419 !!format, format,
1420 true, mode, &err);
1412 return;
1413 }
1414
1415 mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
1416 qmp_blockdev_snapshot_sync(true, device, false, NULL,
1417 filename, false, NULL,
1418 !!format, format,
1419 true, mode, &err);
1421 hmp_handle_error(mon, &err);
1420 hmp_handle_error(mon, err);
1422}
1423
1424void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
1425{
1426 const char *device = qdict_get_str(qdict, "device");
1427 const char *name = qdict_get_str(qdict, "name");
1428 Error *err = NULL;
1429
1430 qmp_blockdev_snapshot_internal_sync(device, name, &err);
1421}
1422
1423void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
1424{
1425 const char *device = qdict_get_str(qdict, "device");
1426 const char *name = qdict_get_str(qdict, "name");
1427 Error *err = NULL;
1428
1429 qmp_blockdev_snapshot_internal_sync(device, name, &err);
1431 hmp_handle_error(mon, &err);
1430 hmp_handle_error(mon, err);
1432}
1433
1434void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1435{
1436 const char *device = qdict_get_str(qdict, "device");
1437 const char *name = qdict_get_str(qdict, "name");
1438 const char *id = qdict_get_try_str(qdict, "id");
1439 Error *err = NULL;
1440
1441 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
1442 true, name, &err);
1431}
1432
1433void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
1434{
1435 const char *device = qdict_get_str(qdict, "device");
1436 const char *name = qdict_get_str(qdict, "name");
1437 const char *id = qdict_get_try_str(qdict, "id");
1438 Error *err = NULL;
1439
1440 qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
1441 true, name, &err);
1443 hmp_handle_error(mon, &err);
1442 hmp_handle_error(mon, err);
1444}
1445
1446void hmp_loadvm(Monitor *mon, const QDict *qdict)
1447{
1448 int saved_vm_running = runstate_is_running();
1449 const char *name = qdict_get_str(qdict, "name");
1450 Error *err = NULL;
1451
1452 vm_stop(RUN_STATE_RESTORE_VM);
1453
1454 if (load_snapshot(name, &err) == 0 && saved_vm_running) {
1455 vm_start();
1456 }
1443}
1444
1445void hmp_loadvm(Monitor *mon, const QDict *qdict)
1446{
1447 int saved_vm_running = runstate_is_running();
1448 const char *name = qdict_get_str(qdict, "name");
1449 Error *err = NULL;
1450
1451 vm_stop(RUN_STATE_RESTORE_VM);
1452
1453 if (load_snapshot(name, &err) == 0 && saved_vm_running) {
1454 vm_start();
1455 }
1457 hmp_handle_error(mon, &err);
1456 hmp_handle_error(mon, err);
1458}
1459
1460void hmp_savevm(Monitor *mon, const QDict *qdict)
1461{
1462 Error *err = NULL;
1463
1464 save_snapshot(qdict_get_try_str(qdict, "name"), &err);
1457}
1458
1459void hmp_savevm(Monitor *mon, const QDict *qdict)
1460{
1461 Error *err = NULL;
1462
1463 save_snapshot(qdict_get_try_str(qdict, "name"), &err);
1465 hmp_handle_error(mon, &err);
1464 hmp_handle_error(mon, err);
1466}
1467
1468void hmp_delvm(Monitor *mon, const QDict *qdict)
1469{
1470 BlockDriverState *bs;
1471 Error *err = NULL;
1472 const char *name = qdict_get_str(qdict, "name");
1473
1474 if (bdrv_all_delete_snapshot(name, &bs, &err) < 0) {
1475 error_prepend(&err,
1476 "deleting snapshot on device '%s': ",
1477 bdrv_get_device_name(bs));
1478 }
1465}
1466
1467void hmp_delvm(Monitor *mon, const QDict *qdict)
1468{
1469 BlockDriverState *bs;
1470 Error *err = NULL;
1471 const char *name = qdict_get_str(qdict, "name");
1472
1473 if (bdrv_all_delete_snapshot(name, &bs, &err) < 0) {
1474 error_prepend(&err,
1475 "deleting snapshot on device '%s': ",
1476 bdrv_get_device_name(bs));
1477 }
1479 hmp_handle_error(mon, &err);
1478 hmp_handle_error(mon, err);
1480}
1481
1482void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
1483{
1484 BlockDriverState *bs, *bs1;
1485 BdrvNextIterator it1;
1486 QEMUSnapshotInfo *sn_tab, *sn;
1487 bool no_snapshot = true;

--- 159 unchanged lines hidden (view full) ---

1647 Error *err = NULL;
1648 const char *state = qdict_get_str(qdict, "state");
1649 int val = qapi_enum_parse(&MigrationStatus_lookup, state, -1, &err);
1650
1651 if (val >= 0) {
1652 qmp_migrate_continue(val, &err);
1653 }
1654
1479}
1480
1481void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
1482{
1483 BlockDriverState *bs, *bs1;
1484 BdrvNextIterator it1;
1485 QEMUSnapshotInfo *sn_tab, *sn;
1486 bool no_snapshot = true;

--- 159 unchanged lines hidden (view full) ---

1646 Error *err = NULL;
1647 const char *state = qdict_get_str(qdict, "state");
1648 int val = qapi_enum_parse(&MigrationStatus_lookup, state, -1, &err);
1649
1650 if (val >= 0) {
1651 qmp_migrate_continue(val, &err);
1652 }
1653
1655 hmp_handle_error(mon, &err);
1654 hmp_handle_error(mon, err);
1656}
1657
1658void hmp_migrate_incoming(Monitor *mon, const QDict *qdict)
1659{
1660 Error *err = NULL;
1661 const char *uri = qdict_get_str(qdict, "uri");
1662
1663 qmp_migrate_incoming(uri, &err);
1664
1655}
1656
1657void hmp_migrate_incoming(Monitor *mon, const QDict *qdict)
1658{
1659 Error *err = NULL;
1660 const char *uri = qdict_get_str(qdict, "uri");
1661
1662 qmp_migrate_incoming(uri, &err);
1663
1665 hmp_handle_error(mon, &err);
1664 hmp_handle_error(mon, err);
1666}
1667
1668void hmp_migrate_recover(Monitor *mon, const QDict *qdict)
1669{
1670 Error *err = NULL;
1671 const char *uri = qdict_get_str(qdict, "uri");
1672
1673 qmp_migrate_recover(uri, &err);
1674
1665}
1666
1667void hmp_migrate_recover(Monitor *mon, const QDict *qdict)
1668{
1669 Error *err = NULL;
1670 const char *uri = qdict_get_str(qdict, "uri");
1671
1672 qmp_migrate_recover(uri, &err);
1673
1675 hmp_handle_error(mon, &err);
1674 hmp_handle_error(mon, err);
1676}
1677
1678void hmp_migrate_pause(Monitor *mon, const QDict *qdict)
1679{
1680 Error *err = NULL;
1681
1682 qmp_migrate_pause(&err);
1683
1675}
1676
1677void hmp_migrate_pause(Monitor *mon, const QDict *qdict)
1678{
1679 Error *err = NULL;
1680
1681 qmp_migrate_pause(&err);
1682
1684 hmp_handle_error(mon, &err);
1683 hmp_handle_error(mon, err);
1685}
1686
1687/* Kept for backwards compatibility */
1688void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1689{
1690 double value = qdict_get_double(qdict, "value");
1691 qmp_migrate_set_downtime(value, NULL);
1692}
1693
1694void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1695{
1696 int64_t value = qdict_get_int(qdict, "value");
1697 Error *err = NULL;
1698
1699 qmp_migrate_set_cache_size(value, &err);
1684}
1685
1686/* Kept for backwards compatibility */
1687void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
1688{
1689 double value = qdict_get_double(qdict, "value");
1690 qmp_migrate_set_downtime(value, NULL);
1691}
1692
1693void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
1694{
1695 int64_t value = qdict_get_int(qdict, "value");
1696 Error *err = NULL;
1697
1698 qmp_migrate_set_cache_size(value, &err);
1700 hmp_handle_error(mon, &err);
1699 hmp_handle_error(mon, err);
1701}
1702
1703/* Kept for backwards compatibility */
1704void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1705{
1706 int64_t value = qdict_get_int(qdict, "value");
1707 qmp_migrate_set_speed(value, NULL);
1708}

--- 14 unchanged lines hidden (view full) ---

1723 caps->value = g_malloc0(sizeof(*caps->value));
1724 caps->value->capability = val;
1725 caps->value->state = state;
1726 caps->next = NULL;
1727 qmp_migrate_set_capabilities(caps, &err);
1728
1729end:
1730 qapi_free_MigrationCapabilityStatusList(caps);
1700}
1701
1702/* Kept for backwards compatibility */
1703void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
1704{
1705 int64_t value = qdict_get_int(qdict, "value");
1706 qmp_migrate_set_speed(value, NULL);
1707}

--- 14 unchanged lines hidden (view full) ---

1722 caps->value = g_malloc0(sizeof(*caps->value));
1723 caps->value->capability = val;
1724 caps->value->state = state;
1725 caps->next = NULL;
1726 qmp_migrate_set_capabilities(caps, &err);
1727
1728end:
1729 qapi_free_MigrationCapabilityStatusList(caps);
1731 hmp_handle_error(mon, &err);
1730 hmp_handle_error(mon, err);
1732}
1733
1734void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
1735{
1736 const char *param = qdict_get_str(qdict, "parameter");
1737 const char *valuestr = qdict_get_str(qdict, "value");
1738 Visitor *v = string_input_visitor_new(valuestr);
1739 MigrateSetParameters *p = g_new0(MigrateSetParameters, 1);

--- 124 unchanged lines hidden (view full) ---

1864 goto cleanup;
1865 }
1866
1867 qmp_migrate_set_parameters(p, &err);
1868
1869 cleanup:
1870 qapi_free_MigrateSetParameters(p);
1871 visit_free(v);
1731}
1732
1733void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
1734{
1735 const char *param = qdict_get_str(qdict, "parameter");
1736 const char *valuestr = qdict_get_str(qdict, "value");
1737 Visitor *v = string_input_visitor_new(valuestr);
1738 MigrateSetParameters *p = g_new0(MigrateSetParameters, 1);

--- 124 unchanged lines hidden (view full) ---

1863 goto cleanup;
1864 }
1865
1866 qmp_migrate_set_parameters(p, &err);
1867
1868 cleanup:
1869 qapi_free_MigrateSetParameters(p);
1870 visit_free(v);
1872 hmp_handle_error(mon, &err);
1871 hmp_handle_error(mon, err);
1873}
1874
1875void hmp_client_migrate_info(Monitor *mon, const QDict *qdict)
1876{
1877 Error *err = NULL;
1878 const char *protocol = qdict_get_str(qdict, "protocol");
1879 const char *hostname = qdict_get_str(qdict, "hostname");
1880 bool has_port = qdict_haskey(qdict, "port");
1881 int port = qdict_get_try_int(qdict, "port", -1);
1882 bool has_tls_port = qdict_haskey(qdict, "tls-port");
1883 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1884 const char *cert_subject = qdict_get_try_str(qdict, "cert-subject");
1885
1886 qmp_client_migrate_info(protocol, hostname,
1887 has_port, port, has_tls_port, tls_port,
1888 !!cert_subject, cert_subject, &err);
1872}
1873
1874void hmp_client_migrate_info(Monitor *mon, const QDict *qdict)
1875{
1876 Error *err = NULL;
1877 const char *protocol = qdict_get_str(qdict, "protocol");
1878 const char *hostname = qdict_get_str(qdict, "hostname");
1879 bool has_port = qdict_haskey(qdict, "port");
1880 int port = qdict_get_try_int(qdict, "port", -1);
1881 bool has_tls_port = qdict_haskey(qdict, "tls-port");
1882 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1883 const char *cert_subject = qdict_get_try_str(qdict, "cert-subject");
1884
1885 qmp_client_migrate_info(protocol, hostname,
1886 has_port, port, has_tls_port, tls_port,
1887 !!cert_subject, cert_subject, &err);
1889 hmp_handle_error(mon, &err);
1888 hmp_handle_error(mon, err);
1890}
1891
1892void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict)
1893{
1894 Error *err = NULL;
1895 qmp_migrate_start_postcopy(&err);
1889}
1890
1891void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict)
1892{
1893 Error *err = NULL;
1894 qmp_migrate_start_postcopy(&err);
1896 hmp_handle_error(mon, &err);
1895 hmp_handle_error(mon, err);
1897}
1898
1899void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict)
1900{
1901 Error *err = NULL;
1902
1903 qmp_x_colo_lost_heartbeat(&err);
1896}
1897
1898void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict)
1899{
1900 Error *err = NULL;
1901
1902 qmp_x_colo_lost_heartbeat(&err);
1904 hmp_handle_error(mon, &err);
1903 hmp_handle_error(mon, err);
1905}
1906
1907void hmp_set_password(Monitor *mon, const QDict *qdict)
1908{
1909 const char *protocol = qdict_get_str(qdict, "protocol");
1910 const char *password = qdict_get_str(qdict, "password");
1911 const char *connected = qdict_get_try_str(qdict, "connected");
1912 Error *err = NULL;
1913
1914 qmp_set_password(protocol, password, !!connected, connected, &err);
1904}
1905
1906void hmp_set_password(Monitor *mon, const QDict *qdict)
1907{
1908 const char *protocol = qdict_get_str(qdict, "protocol");
1909 const char *password = qdict_get_str(qdict, "password");
1910 const char *connected = qdict_get_try_str(qdict, "connected");
1911 Error *err = NULL;
1912
1913 qmp_set_password(protocol, password, !!connected, connected, &err);
1915 hmp_handle_error(mon, &err);
1914 hmp_handle_error(mon, err);
1916}
1917
1918void hmp_expire_password(Monitor *mon, const QDict *qdict)
1919{
1920 const char *protocol = qdict_get_str(qdict, "protocol");
1921 const char *whenstr = qdict_get_str(qdict, "time");
1922 Error *err = NULL;
1923
1924 qmp_expire_password(protocol, whenstr, &err);
1915}
1916
1917void hmp_expire_password(Monitor *mon, const QDict *qdict)
1918{
1919 const char *protocol = qdict_get_str(qdict, "protocol");
1920 const char *whenstr = qdict_get_str(qdict, "time");
1921 Error *err = NULL;
1922
1923 qmp_expire_password(protocol, whenstr, &err);
1925 hmp_handle_error(mon, &err);
1924 hmp_handle_error(mon, err);
1926}
1927
1928void hmp_eject(Monitor *mon, const QDict *qdict)
1929{
1930 bool force = qdict_get_try_bool(qdict, "force", false);
1931 const char *device = qdict_get_str(qdict, "device");
1932 Error *err = NULL;
1933
1934 qmp_eject(true, device, false, NULL, true, force, &err);
1925}
1926
1927void hmp_eject(Monitor *mon, const QDict *qdict)
1928{
1929 bool force = qdict_get_try_bool(qdict, "force", false);
1930 const char *device = qdict_get_str(qdict, "device");
1931 Error *err = NULL;
1932
1933 qmp_eject(true, device, false, NULL, true, force, &err);
1935 hmp_handle_error(mon, &err);
1934 hmp_handle_error(mon, err);
1936}
1937
1938#ifdef CONFIG_VNC
1939static void hmp_change_read_arg(void *opaque, const char *password,
1940 void *readline_opaque)
1941{
1942 qmp_change_vnc_password(password, NULL);
1943 monitor_read_command(opaque, 1);

--- 29 unchanged lines hidden (view full) ---

1973#endif
1974 {
1975 if (read_only) {
1976 read_only_mode =
1977 qapi_enum_parse(&BlockdevChangeReadOnlyMode_lookup,
1978 read_only,
1979 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, &err);
1980 if (err) {
1935}
1936
1937#ifdef CONFIG_VNC
1938static void hmp_change_read_arg(void *opaque, const char *password,
1939 void *readline_opaque)
1940{
1941 qmp_change_vnc_password(password, NULL);
1942 monitor_read_command(opaque, 1);

--- 29 unchanged lines hidden (view full) ---

1972#endif
1973 {
1974 if (read_only) {
1975 read_only_mode =
1976 qapi_enum_parse(&BlockdevChangeReadOnlyMode_lookup,
1977 read_only,
1978 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, &err);
1979 if (err) {
1981 hmp_handle_error(mon, &err);
1980 hmp_handle_error(mon, err);
1982 return;
1983 }
1984 }
1985
1986 qmp_blockdev_change_medium(true, device, false, NULL, target,
1987 !!arg, arg, !!read_only, read_only_mode,
1988 &err);
1989 }
1990
1981 return;
1982 }
1983 }
1984
1985 qmp_blockdev_change_medium(true, device, false, NULL, target,
1986 !!arg, arg, !!read_only, read_only_mode,
1987 &err);
1988 }
1989
1991 hmp_handle_error(mon, &err);
1990 hmp_handle_error(mon, err);
1992}
1993
1994void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1995{
1996 Error *err = NULL;
1997 char *device = (char *) qdict_get_str(qdict, "device");
1998 BlockIOThrottle throttle = {
1999 .bps = qdict_get_int(qdict, "bps"),

--- 11 unchanged lines hidden (view full) ---

2011 throttle.has_device = true;
2012 throttle.device = device;
2013 } else {
2014 throttle.has_id = true;
2015 throttle.id = device;
2016 }
2017
2018 qmp_block_set_io_throttle(&throttle, &err);
1991}
1992
1993void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
1994{
1995 Error *err = NULL;
1996 char *device = (char *) qdict_get_str(qdict, "device");
1997 BlockIOThrottle throttle = {
1998 .bps = qdict_get_int(qdict, "bps"),

--- 11 unchanged lines hidden (view full) ---

2010 throttle.has_device = true;
2011 throttle.device = device;
2012 } else {
2013 throttle.has_id = true;
2014 throttle.id = device;
2015 }
2016
2017 qmp_block_set_io_throttle(&throttle, &err);
2019 hmp_handle_error(mon, &err);
2018 hmp_handle_error(mon, err);
2020}
2021
2022void hmp_block_stream(Monitor *mon, const QDict *qdict)
2023{
2024 Error *error = NULL;
2025 const char *device = qdict_get_str(qdict, "device");
2026 const char *base = qdict_get_try_str(qdict, "base");
2027 int64_t speed = qdict_get_try_int(qdict, "speed", 0);
2028
2029 qmp_block_stream(true, device, device, base != NULL, base, false, NULL,
2030 false, NULL, qdict_haskey(qdict, "speed"), speed, true,
2031 BLOCKDEV_ON_ERROR_REPORT, false, false, false, false,
2032 &error);
2033
2019}
2020
2021void hmp_block_stream(Monitor *mon, const QDict *qdict)
2022{
2023 Error *error = NULL;
2024 const char *device = qdict_get_str(qdict, "device");
2025 const char *base = qdict_get_try_str(qdict, "base");
2026 int64_t speed = qdict_get_try_int(qdict, "speed", 0);
2027
2028 qmp_block_stream(true, device, device, base != NULL, base, false, NULL,
2029 false, NULL, qdict_haskey(qdict, "speed"), speed, true,
2030 BLOCKDEV_ON_ERROR_REPORT, false, false, false, false,
2031 &error);
2032
2034 hmp_handle_error(mon, &error);
2033 hmp_handle_error(mon, error);
2035}
2036
2037void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
2038{
2039 Error *error = NULL;
2040 const char *device = qdict_get_str(qdict, "device");
2041 int64_t value = qdict_get_int(qdict, "speed");
2042
2043 qmp_block_job_set_speed(device, value, &error);
2044
2034}
2035
2036void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
2037{
2038 Error *error = NULL;
2039 const char *device = qdict_get_str(qdict, "device");
2040 int64_t value = qdict_get_int(qdict, "speed");
2041
2042 qmp_block_job_set_speed(device, value, &error);
2043
2045 hmp_handle_error(mon, &error);
2044 hmp_handle_error(mon, error);
2046}
2047
2048void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
2049{
2050 Error *error = NULL;
2051 const char *device = qdict_get_str(qdict, "device");
2052 bool force = qdict_get_try_bool(qdict, "force", false);
2053
2054 qmp_block_job_cancel(device, true, force, &error);
2055
2045}
2046
2047void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
2048{
2049 Error *error = NULL;
2050 const char *device = qdict_get_str(qdict, "device");
2051 bool force = qdict_get_try_bool(qdict, "force", false);
2052
2053 qmp_block_job_cancel(device, true, force, &error);
2054
2056 hmp_handle_error(mon, &error);
2055 hmp_handle_error(mon, error);
2057}
2058
2059void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
2060{
2061 Error *error = NULL;
2062 const char *device = qdict_get_str(qdict, "device");
2063
2064 qmp_block_job_pause(device, &error);
2065
2056}
2057
2058void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
2059{
2060 Error *error = NULL;
2061 const char *device = qdict_get_str(qdict, "device");
2062
2063 qmp_block_job_pause(device, &error);
2064
2066 hmp_handle_error(mon, &error);
2065 hmp_handle_error(mon, error);
2067}
2068
2069void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
2070{
2071 Error *error = NULL;
2072 const char *device = qdict_get_str(qdict, "device");
2073
2074 qmp_block_job_resume(device, &error);
2075
2066}
2067
2068void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
2069{
2070 Error *error = NULL;
2071 const char *device = qdict_get_str(qdict, "device");
2072
2073 qmp_block_job_resume(device, &error);
2074
2076 hmp_handle_error(mon, &error);
2075 hmp_handle_error(mon, error);
2077}
2078
2079void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
2080{
2081 Error *error = NULL;
2082 const char *device = qdict_get_str(qdict, "device");
2083
2084 qmp_block_job_complete(device, &error);
2085
2076}
2077
2078void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
2079{
2080 Error *error = NULL;
2081 const char *device = qdict_get_str(qdict, "device");
2082
2083 qmp_block_job_complete(device, &error);
2084
2086 hmp_handle_error(mon, &error);
2085 hmp_handle_error(mon, error);
2087}
2088
2089typedef struct HMPMigrationStatus
2090{
2091 QEMUTimer *timer;
2092 Monitor *mon;
2093 bool is_block_migration;
2094} HMPMigrationStatus;

--- 43 unchanged lines hidden (view full) ---

2138 bool inc = qdict_get_try_bool(qdict, "inc", false);
2139 bool resume = qdict_get_try_bool(qdict, "resume", false);
2140 const char *uri = qdict_get_str(qdict, "uri");
2141 Error *err = NULL;
2142
2143 qmp_migrate(uri, !!blk, blk, !!inc, inc,
2144 false, false, true, resume, &err);
2145 if (err) {
2086}
2087
2088typedef struct HMPMigrationStatus
2089{
2090 QEMUTimer *timer;
2091 Monitor *mon;
2092 bool is_block_migration;
2093} HMPMigrationStatus;

--- 43 unchanged lines hidden (view full) ---

2137 bool inc = qdict_get_try_bool(qdict, "inc", false);
2138 bool resume = qdict_get_try_bool(qdict, "resume", false);
2139 const char *uri = qdict_get_str(qdict, "uri");
2140 Error *err = NULL;
2141
2142 qmp_migrate(uri, !!blk, blk, !!inc, inc,
2143 false, false, true, resume, &err);
2144 if (err) {
2146 hmp_handle_error(mon, &err);
2145 hmp_handle_error(mon, err);
2147 return;
2148 }
2149
2150 if (!detach) {
2151 HMPMigrationStatus *status;
2152
2153 if (monitor_suspend(mon) < 0) {
2154 monitor_printf(mon, "terminal does not allow synchronous "

--- 21 unchanged lines hidden (view full) ---

2176 }
2177
2178 netdev_add(opts, &err);
2179 if (err) {
2180 qemu_opts_del(opts);
2181 }
2182
2183out:
2146 return;
2147 }
2148
2149 if (!detach) {
2150 HMPMigrationStatus *status;
2151
2152 if (monitor_suspend(mon) < 0) {
2153 monitor_printf(mon, "terminal does not allow synchronous "

--- 21 unchanged lines hidden (view full) ---

2175 }
2176
2177 netdev_add(opts, &err);
2178 if (err) {
2179 qemu_opts_del(opts);
2180 }
2181
2182out:
2184 hmp_handle_error(mon, &err);
2183 hmp_handle_error(mon, err);
2185}
2186
2187void hmp_netdev_del(Monitor *mon, const QDict *qdict)
2188{
2189 const char *id = qdict_get_str(qdict, "id");
2190 Error *err = NULL;
2191
2192 qmp_netdev_del(id, &err);
2184}
2185
2186void hmp_netdev_del(Monitor *mon, const QDict *qdict)
2187{
2188 const char *id = qdict_get_str(qdict, "id");
2189 Error *err = NULL;
2190
2191 qmp_netdev_del(id, &err);
2193 hmp_handle_error(mon, &err);
2192 hmp_handle_error(mon, err);
2194}
2195
2196void hmp_object_add(Monitor *mon, const QDict *qdict)
2197{
2198 Error *err = NULL;
2199 QemuOpts *opts;
2200 Object *obj = NULL;
2201
2202 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
2203 if (err) {
2193}
2194
2195void hmp_object_add(Monitor *mon, const QDict *qdict)
2196{
2197 Error *err = NULL;
2198 QemuOpts *opts;
2199 Object *obj = NULL;
2200
2201 opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
2202 if (err) {
2204 hmp_handle_error(mon, &err);
2203 hmp_handle_error(mon, err);
2205 return;
2206 }
2207
2208 obj = user_creatable_add_opts(opts, &err);
2209 qemu_opts_del(opts);
2210
2211 if (err) {
2204 return;
2205 }
2206
2207 obj = user_creatable_add_opts(opts, &err);
2208 qemu_opts_del(opts);
2209
2210 if (err) {
2212 hmp_handle_error(mon, &err);
2211 hmp_handle_error(mon, err);
2213 }
2214 if (obj) {
2215 object_unref(obj);
2216 }
2217}
2218
2219void hmp_getfd(Monitor *mon, const QDict *qdict)
2220{
2221 const char *fdname = qdict_get_str(qdict, "fdname");
2222 Error *err = NULL;
2223
2224 qmp_getfd(fdname, &err);
2212 }
2213 if (obj) {
2214 object_unref(obj);
2215 }
2216}
2217
2218void hmp_getfd(Monitor *mon, const QDict *qdict)
2219{
2220 const char *fdname = qdict_get_str(qdict, "fdname");
2221 Error *err = NULL;
2222
2223 qmp_getfd(fdname, &err);
2225 hmp_handle_error(mon, &err);
2224 hmp_handle_error(mon, err);
2226}
2227
2228void hmp_closefd(Monitor *mon, const QDict *qdict)
2229{
2230 const char *fdname = qdict_get_str(qdict, "fdname");
2231 Error *err = NULL;
2232
2233 qmp_closefd(fdname, &err);
2225}
2226
2227void hmp_closefd(Monitor *mon, const QDict *qdict)
2228{
2229 const char *fdname = qdict_get_str(qdict, "fdname");
2230 Error *err = NULL;
2231
2232 qmp_closefd(fdname, &err);
2234 hmp_handle_error(mon, &err);
2233 hmp_handle_error(mon, err);
2235}
2236
2237void hmp_sendkey(Monitor *mon, const QDict *qdict)
2238{
2239 const char *keys = qdict_get_str(qdict, "keys");
2240 KeyValueList *keylist, *head = NULL, *tmp = NULL;
2241 int has_hold_time = qdict_haskey(qdict, "hold-time");
2242 int hold_time = qdict_get_try_int(qdict, "hold-time", -1);

--- 42 unchanged lines hidden (view full) ---

2285
2286 if (!*separator) {
2287 break;
2288 }
2289 keys = separator + 1;
2290 }
2291
2292 qmp_send_key(head, has_hold_time, hold_time, &err);
2234}
2235
2236void hmp_sendkey(Monitor *mon, const QDict *qdict)
2237{
2238 const char *keys = qdict_get_str(qdict, "keys");
2239 KeyValueList *keylist, *head = NULL, *tmp = NULL;
2240 int has_hold_time = qdict_haskey(qdict, "hold-time");
2241 int hold_time = qdict_get_try_int(qdict, "hold-time", -1);

--- 42 unchanged lines hidden (view full) ---

2284
2285 if (!*separator) {
2286 break;
2287 }
2288 keys = separator + 1;
2289 }
2290
2291 qmp_send_key(head, has_hold_time, hold_time, &err);
2293 hmp_handle_error(mon, &err);
2292 hmp_handle_error(mon, err);
2294
2295out:
2296 qapi_free_KeyValueList(head);
2297 return;
2298
2299err_out:
2300 monitor_printf(mon, "invalid parameter: %.*s\n", keyname_len, keys);
2301 goto out;
2302}
2303
2304void hmp_screendump(Monitor *mon, const QDict *qdict)
2305{
2306 const char *filename = qdict_get_str(qdict, "filename");
2307 const char *id = qdict_get_try_str(qdict, "device");
2308 int64_t head = qdict_get_try_int(qdict, "head", 0);
2309 Error *err = NULL;
2310
2311 qmp_screendump(filename, id != NULL, id, id != NULL, head, &err);
2293
2294out:
2295 qapi_free_KeyValueList(head);
2296 return;
2297
2298err_out:
2299 monitor_printf(mon, "invalid parameter: %.*s\n", keyname_len, keys);
2300 goto out;
2301}
2302
2303void hmp_screendump(Monitor *mon, const QDict *qdict)
2304{
2305 const char *filename = qdict_get_str(qdict, "filename");
2306 const char *id = qdict_get_try_str(qdict, "device");
2307 int64_t head = qdict_get_try_int(qdict, "head", 0);
2308 Error *err = NULL;
2309
2310 qmp_screendump(filename, id != NULL, id, id != NULL, head, &err);
2312 hmp_handle_error(mon, &err);
2311 hmp_handle_error(mon, err);
2313}
2314
2315void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
2316{
2317 const char *uri = qdict_get_str(qdict, "uri");
2318 bool writable = qdict_get_try_bool(qdict, "writable", false);
2319 bool all = qdict_get_try_bool(qdict, "all", false);
2320 Error *local_err = NULL;

--- 38 unchanged lines hidden (view full) ---

2359 qmp_nbd_server_stop(NULL);
2360 break;
2361 }
2362 }
2363
2364 qapi_free_BlockInfoList(block_list);
2365
2366exit:
2312}
2313
2314void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
2315{
2316 const char *uri = qdict_get_str(qdict, "uri");
2317 bool writable = qdict_get_try_bool(qdict, "writable", false);
2318 bool all = qdict_get_try_bool(qdict, "all", false);
2319 Error *local_err = NULL;

--- 38 unchanged lines hidden (view full) ---

2358 qmp_nbd_server_stop(NULL);
2359 break;
2360 }
2361 }
2362
2363 qapi_free_BlockInfoList(block_list);
2364
2365exit:
2367 hmp_handle_error(mon, &local_err);
2366 hmp_handle_error(mon, local_err);
2368}
2369
2370void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
2371{
2372 const char *device = qdict_get_str(qdict, "device");
2373 const char *name = qdict_get_try_str(qdict, "name");
2374 bool writable = qdict_get_try_bool(qdict, "writable", false);
2375 Error *local_err = NULL;
2376
2377 qmp_nbd_server_add(device, !!name, name, true, writable,
2378 false, NULL, &local_err);
2367}
2368
2369void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
2370{
2371 const char *device = qdict_get_str(qdict, "device");
2372 const char *name = qdict_get_try_str(qdict, "name");
2373 bool writable = qdict_get_try_bool(qdict, "writable", false);
2374 Error *local_err = NULL;
2375
2376 qmp_nbd_server_add(device, !!name, name, true, writable,
2377 false, NULL, &local_err);
2379 hmp_handle_error(mon, &local_err);
2378 hmp_handle_error(mon, local_err);
2380}
2381
2382void hmp_nbd_server_remove(Monitor *mon, const QDict *qdict)
2383{
2384 const char *name = qdict_get_str(qdict, "name");
2385 bool force = qdict_get_try_bool(qdict, "force", false);
2386 Error *err = NULL;
2387
2388 /* Rely on NBD_SERVER_REMOVE_MODE_SAFE being the default */
2389 qmp_nbd_server_remove(name, force, NBD_SERVER_REMOVE_MODE_HARD, &err);
2379}
2380
2381void hmp_nbd_server_remove(Monitor *mon, const QDict *qdict)
2382{
2383 const char *name = qdict_get_str(qdict, "name");
2384 bool force = qdict_get_try_bool(qdict, "force", false);
2385 Error *err = NULL;
2386
2387 /* Rely on NBD_SERVER_REMOVE_MODE_SAFE being the default */
2388 qmp_nbd_server_remove(name, force, NBD_SERVER_REMOVE_MODE_HARD, &err);
2390 hmp_handle_error(mon, &err);
2389 hmp_handle_error(mon, err);
2391}
2392
2393void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
2394{
2395 Error *err = NULL;
2396
2397 qmp_nbd_server_stop(&err);
2390}
2391
2392void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
2393{
2394 Error *err = NULL;
2395
2396 qmp_nbd_server_stop(&err);
2398 hmp_handle_error(mon, &err);
2397 hmp_handle_error(mon, err);
2399}
2400
2401void hmp_chardev_add(Monitor *mon, const QDict *qdict)
2402{
2403 const char *args = qdict_get_str(qdict, "args");
2404 Error *err = NULL;
2405 QemuOpts *opts;
2406
2407 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, true);
2408 if (opts == NULL) {
2409 error_setg(&err, "Parsing chardev args failed");
2410 } else {
2411 qemu_chr_new_from_opts(opts, NULL, &err);
2412 qemu_opts_del(opts);
2413 }
2398}
2399
2400void hmp_chardev_add(Monitor *mon, const QDict *qdict)
2401{
2402 const char *args = qdict_get_str(qdict, "args");
2403 Error *err = NULL;
2404 QemuOpts *opts;
2405
2406 opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, true);
2407 if (opts == NULL) {
2408 error_setg(&err, "Parsing chardev args failed");
2409 } else {
2410 qemu_chr_new_from_opts(opts, NULL, &err);
2411 qemu_opts_del(opts);
2412 }
2414 hmp_handle_error(mon, &err);
2413 hmp_handle_error(mon, err);
2415}
2416
2417void hmp_chardev_change(Monitor *mon, const QDict *qdict)
2418{
2419 const char *args = qdict_get_str(qdict, "args");
2420 const char *id;
2421 Error *err = NULL;
2422 ChardevBackend *backend = NULL;

--- 17 unchanged lines hidden (view full) ---

2440 }
2441
2442 ret = qmp_chardev_change(id, backend, &err);
2443
2444end:
2445 qapi_free_ChardevReturn(ret);
2446 qapi_free_ChardevBackend(backend);
2447 qemu_opts_del(opts);
2414}
2415
2416void hmp_chardev_change(Monitor *mon, const QDict *qdict)
2417{
2418 const char *args = qdict_get_str(qdict, "args");
2419 const char *id;
2420 Error *err = NULL;
2421 ChardevBackend *backend = NULL;

--- 17 unchanged lines hidden (view full) ---

2439 }
2440
2441 ret = qmp_chardev_change(id, backend, &err);
2442
2443end:
2444 qapi_free_ChardevReturn(ret);
2445 qapi_free_ChardevBackend(backend);
2446 qemu_opts_del(opts);
2448 hmp_handle_error(mon, &err);
2447 hmp_handle_error(mon, err);
2449}
2450
2451void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
2452{
2453 Error *local_err = NULL;
2454
2455 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
2448}
2449
2450void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
2451{
2452 Error *local_err = NULL;
2453
2454 qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
2456 hmp_handle_error(mon, &local_err);
2455 hmp_handle_error(mon, local_err);
2457}
2458
2459void hmp_chardev_send_break(Monitor *mon, const QDict *qdict)
2460{
2461 Error *local_err = NULL;
2462
2463 qmp_chardev_send_break(qdict_get_str(qdict, "id"), &local_err);
2456}
2457
2458void hmp_chardev_send_break(Monitor *mon, const QDict *qdict)
2459{
2460 Error *local_err = NULL;
2461
2462 qmp_chardev_send_break(qdict_get_str(qdict, "id"), &local_err);
2464 hmp_handle_error(mon, &local_err);
2463 hmp_handle_error(mon, local_err);
2465}
2466
2467void hmp_qemu_io(Monitor *mon, const QDict *qdict)
2468{
2469 BlockBackend *blk;
2470 BlockBackend *local_blk = NULL;
2471 const char* device = qdict_get_str(qdict, "device");
2472 const char* command = qdict_get_str(qdict, "command");

--- 39 unchanged lines hidden (view full) ---

2512 * permissions if necessary for the qemu-io command. And they simply stay
2513 * extended, possibly resulting in a read-only guest device keeping write
2514 * permissions. Ugly, but it appears to be the lesser evil.
2515 */
2516 qemuio_command(blk, command);
2517
2518fail:
2519 blk_unref(local_blk);
2464}
2465
2466void hmp_qemu_io(Monitor *mon, const QDict *qdict)
2467{
2468 BlockBackend *blk;
2469 BlockBackend *local_blk = NULL;
2470 const char* device = qdict_get_str(qdict, "device");
2471 const char* command = qdict_get_str(qdict, "command");

--- 39 unchanged lines hidden (view full) ---

2511 * permissions if necessary for the qemu-io command. And they simply stay
2512 * extended, possibly resulting in a read-only guest device keeping write
2513 * permissions. Ugly, but it appears to be the lesser evil.
2514 */
2515 qemuio_command(blk, command);
2516
2517fail:
2518 blk_unref(local_blk);
2520 hmp_handle_error(mon, &err);
2519 hmp_handle_error(mon, err);
2521}
2522
2523void hmp_object_del(Monitor *mon, const QDict *qdict)
2524{
2525 const char *id = qdict_get_str(qdict, "id");
2526 Error *err = NULL;
2527
2528 user_creatable_del(id, &err);
2520}
2521
2522void hmp_object_del(Monitor *mon, const QDict *qdict)
2523{
2524 const char *id = qdict_get_str(qdict, "id");
2525 Error *err = NULL;
2526
2527 user_creatable_del(id, &err);
2529 hmp_handle_error(mon, &err);
2528 hmp_handle_error(mon, err);
2530}
2531
2532void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
2533{
2534 Error *err = NULL;
2535 MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
2536 MemoryDeviceInfoList *info;
2537 VirtioPMEMDeviceInfo *vpi;

--- 33 unchanged lines hidden (view full) ---

2571 break;
2572 default:
2573 g_assert_not_reached();
2574 }
2575 }
2576 }
2577
2578 qapi_free_MemoryDeviceInfoList(info_list);
2529}
2530
2531void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
2532{
2533 Error *err = NULL;
2534 MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
2535 MemoryDeviceInfoList *info;
2536 VirtioPMEMDeviceInfo *vpi;

--- 33 unchanged lines hidden (view full) ---

2570 break;
2571 default:
2572 g_assert_not_reached();
2573 }
2574 }
2575 }
2576
2577 qapi_free_MemoryDeviceInfoList(info_list);
2579 hmp_handle_error(mon, &err);
2578 hmp_handle_error(mon, err);
2580}
2581
2582void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
2583{
2584 IOThreadInfoList *info_list = qmp_query_iothreads(NULL);
2585 IOThreadInfoList *info;
2586 IOThreadInfo *value;
2587

--- 12 unchanged lines hidden (view full) ---

2600void hmp_rocker(Monitor *mon, const QDict *qdict)
2601{
2602 const char *name = qdict_get_str(qdict, "name");
2603 RockerSwitch *rocker;
2604 Error *err = NULL;
2605
2606 rocker = qmp_query_rocker(name, &err);
2607 if (err != NULL) {
2579}
2580
2581void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
2582{
2583 IOThreadInfoList *info_list = qmp_query_iothreads(NULL);
2584 IOThreadInfoList *info;
2585 IOThreadInfo *value;
2586

--- 12 unchanged lines hidden (view full) ---

2599void hmp_rocker(Monitor *mon, const QDict *qdict)
2600{
2601 const char *name = qdict_get_str(qdict, "name");
2602 RockerSwitch *rocker;
2603 Error *err = NULL;
2604
2605 rocker = qmp_query_rocker(name, &err);
2606 if (err != NULL) {
2608 hmp_handle_error(mon, &err);
2607 hmp_handle_error(mon, err);
2609 return;
2610 }
2611
2612 monitor_printf(mon, "name: %s\n", rocker->name);
2613 monitor_printf(mon, "id: 0x%" PRIx64 "\n", rocker->id);
2614 monitor_printf(mon, "ports: %d\n", rocker->ports);
2615
2616 qapi_free_RockerSwitch(rocker);
2617}
2618
2619void hmp_rocker_ports(Monitor *mon, const QDict *qdict)
2620{
2621 RockerPortList *list, *port;
2622 const char *name = qdict_get_str(qdict, "name");
2623 Error *err = NULL;
2624
2625 list = qmp_query_rocker_ports(name, &err);
2626 if (err != NULL) {
2608 return;
2609 }
2610
2611 monitor_printf(mon, "name: %s\n", rocker->name);
2612 monitor_printf(mon, "id: 0x%" PRIx64 "\n", rocker->id);
2613 monitor_printf(mon, "ports: %d\n", rocker->ports);
2614
2615 qapi_free_RockerSwitch(rocker);
2616}
2617
2618void hmp_rocker_ports(Monitor *mon, const QDict *qdict)
2619{
2620 RockerPortList *list, *port;
2621 const char *name = qdict_get_str(qdict, "name");
2622 Error *err = NULL;
2623
2624 list = qmp_query_rocker_ports(name, &err);
2625 if (err != NULL) {
2627 hmp_handle_error(mon, &err);
2626 hmp_handle_error(mon, err);
2628 return;
2629 }
2630
2631 monitor_printf(mon, " ena/ speed/ auto\n");
2632 monitor_printf(mon, " port link duplex neg?\n");
2633
2634 for (port = list; port; port = port->next) {
2635 monitor_printf(mon, "%10s %-4s %-3s %2s %-3s\n",

--- 12 unchanged lines hidden (view full) ---

2648{
2649 RockerOfDpaFlowList *list, *info;
2650 const char *name = qdict_get_str(qdict, "name");
2651 uint32_t tbl_id = qdict_get_try_int(qdict, "tbl_id", -1);
2652 Error *err = NULL;
2653
2654 list = qmp_query_rocker_of_dpa_flows(name, tbl_id != -1, tbl_id, &err);
2655 if (err != NULL) {
2627 return;
2628 }
2629
2630 monitor_printf(mon, " ena/ speed/ auto\n");
2631 monitor_printf(mon, " port link duplex neg?\n");
2632
2633 for (port = list; port; port = port->next) {
2634 monitor_printf(mon, "%10s %-4s %-3s %2s %-3s\n",

--- 12 unchanged lines hidden (view full) ---

2647{
2648 RockerOfDpaFlowList *list, *info;
2649 const char *name = qdict_get_str(qdict, "name");
2650 uint32_t tbl_id = qdict_get_try_int(qdict, "tbl_id", -1);
2651 Error *err = NULL;
2652
2653 list = qmp_query_rocker_of_dpa_flows(name, tbl_id != -1, tbl_id, &err);
2654 if (err != NULL) {
2656 hmp_handle_error(mon, &err);
2655 hmp_handle_error(mon, err);
2657 return;
2658 }
2659
2660 monitor_printf(mon, "prio tbl hits key(mask) --> actions\n");
2661
2662 for (info = list; info; info = info->next) {
2663 RockerOfDpaFlow *flow = info->value;
2664 RockerOfDpaFlowKey *key = flow->key;

--- 134 unchanged lines hidden (view full) ---

2799 RockerOfDpaGroupList *list, *g;
2800 const char *name = qdict_get_str(qdict, "name");
2801 uint8_t type = qdict_get_try_int(qdict, "type", 9);
2802 Error *err = NULL;
2803 bool set = false;
2804
2805 list = qmp_query_rocker_of_dpa_groups(name, type != 9, type, &err);
2806 if (err != NULL) {
2656 return;
2657 }
2658
2659 monitor_printf(mon, "prio tbl hits key(mask) --> actions\n");
2660
2661 for (info = list; info; info = info->next) {
2662 RockerOfDpaFlow *flow = info->value;
2663 RockerOfDpaFlowKey *key = flow->key;

--- 134 unchanged lines hidden (view full) ---

2798 RockerOfDpaGroupList *list, *g;
2799 const char *name = qdict_get_str(qdict, "name");
2800 uint8_t type = qdict_get_try_int(qdict, "type", 9);
2801 Error *err = NULL;
2802 bool set = false;
2803
2804 list = qmp_query_rocker_of_dpa_groups(name, type != 9, type, &err);
2805 if (err != NULL) {
2807 hmp_handle_error(mon, &err);
2806 hmp_handle_error(mon, err);
2808 return;
2809 }
2810
2811 monitor_printf(mon, "id (decode) --> buckets\n");
2812
2813 for (g = list; g; g = g->next) {
2814 RockerOfDpaGroup *group = g->value;
2815

--- 90 unchanged lines hidden (view full) ---

2906
2907void hmp_info_vm_generation_id(Monitor *mon, const QDict *qdict)
2908{
2909 Error *err = NULL;
2910 GuidInfo *info = qmp_query_vm_generation_id(&err);
2911 if (info) {
2912 monitor_printf(mon, "%s\n", info->guid);
2913 }
2807 return;
2808 }
2809
2810 monitor_printf(mon, "id (decode) --> buckets\n");
2811
2812 for (g = list; g; g = g->next) {
2813 RockerOfDpaGroup *group = g->value;
2814

--- 90 unchanged lines hidden (view full) ---

2905
2906void hmp_info_vm_generation_id(Monitor *mon, const QDict *qdict)
2907{
2908 Error *err = NULL;
2909 GuidInfo *info = qmp_query_vm_generation_id(&err);
2910 if (info) {
2911 monitor_printf(mon, "%s\n", info->guid);
2912 }
2914 hmp_handle_error(mon, &err);
2913 hmp_handle_error(mon, err);
2915 qapi_free_GuidInfo(info);
2916}
2917
2918void hmp_info_memory_size_summary(Monitor *mon, const QDict *qdict)
2919{
2920 Error *err = NULL;
2921 MemoryInfo *info = qmp_query_memory_size_summary(&err);
2922 if (info) {
2923 monitor_printf(mon, "base memory: %" PRIu64 "\n",
2924 info->base_memory);
2925
2926 if (info->has_plugged_memory) {
2927 monitor_printf(mon, "plugged memory: %" PRIu64 "\n",
2928 info->plugged_memory);
2929 }
2930
2931 qapi_free_MemoryInfo(info);
2932 }
2914 qapi_free_GuidInfo(info);
2915}
2916
2917void hmp_info_memory_size_summary(Monitor *mon, const QDict *qdict)
2918{
2919 Error *err = NULL;
2920 MemoryInfo *info = qmp_query_memory_size_summary(&err);
2921 if (info) {
2922 monitor_printf(mon, "base memory: %" PRIu64 "\n",
2923 info->base_memory);
2924
2925 if (info->has_plugged_memory) {
2926 monitor_printf(mon, "plugged memory: %" PRIu64 "\n",
2927 info->plugged_memory);
2928 }
2929
2930 qapi_free_MemoryInfo(info);
2931 }
2933 hmp_handle_error(mon, &err);
2932 hmp_handle_error(mon, err);
2934}
2933}