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} |