2 * Human Monitor Interface commands
4 * Copyright IBM, Corp. 2011
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
12 * Contributions after 2012-01-13 are licensed under the terms of the
13 * GNU GPL, version 2 or (at your option) any later version.
16 #include "qemu/osdep.h"
17 #include "monitor/hmp.h"
20 #include "chardev/char.h"
21 #include "sysemu/block-backend.h"
22 #include "sysemu/runstate.h"
23 #include "qemu/config-file.h"
24 #include "qemu/option.h"
25 #include "qemu/timer.h"
26 #include "qemu/sockets.h"
27 #include "qemu/help_option.h"
28 #include "monitor/monitor-internal.h"
29 #include "qapi/error.h"
30 #include "qapi/clone-visitor.h"
31 #include "qapi/opts-visitor.h"
32 #include "qapi/qapi-builtin-visit.h"
33 #include "qapi/qapi-commands-block.h"
34 #include "qapi/qapi-commands-char.h"
35 #include "qapi/qapi-commands-control.h"
36 #include "qapi/qapi-commands-machine.h"
37 #include "qapi/qapi-commands-migration.h"
38 #include "qapi/qapi-commands-misc.h"
39 #include "qapi/qapi-commands-net.h"
40 #include "qapi/qapi-commands-pci.h"
41 #include "qapi/qapi-commands-rocker.h"
42 #include "qapi/qapi-commands-run-state.h"
43 #include "qapi/qapi-commands-tpm.h"
44 #include "qapi/qapi-commands-ui.h"
45 #include "qapi/qapi-visit-net.h"
46 #include "qapi/qapi-visit-migration.h"
47 #include "qapi/qmp/qdict.h"
48 #include "qapi/qmp/qerror.h"
49 #include "qapi/string-input-visitor.h"
50 #include "qapi/string-output-visitor.h"
51 #include "qom/object_interfaces.h"
52 #include "ui/console.h"
53 #include "qemu/cutils.h"
54 #include "qemu/error-report.h"
55 #include "exec/ramlist.h"
56 #include "hw/intc/intc.h"
57 #include "hw/rdma/rdma.h"
58 #include "migration/snapshot.h"
59 #include "migration/misc.h"
62 #include <spice/enums.h>
65 void hmp_handle_error(Monitor
*mon
, Error
*err
)
68 error_reportf_err(err
, "Error: ");
73 * Produce a strList from a comma separated list.
74 * A NULL or empty input string return NULL.
76 static strList
*strList_from_comma_list(const char *in
)
79 strList
**tail
= &res
;
82 char *comma
= strchr(in
, ',');
86 value
= g_strndup(in
, comma
- in
);
87 in
= comma
+ 1; /* skip the , */
92 QAPI_LIST_APPEND(tail
, value
);
98 void hmp_info_name(Monitor
*mon
, const QDict
*qdict
)
102 info
= qmp_query_name(NULL
);
103 if (info
->has_name
) {
104 monitor_printf(mon
, "%s\n", info
->name
);
106 qapi_free_NameInfo(info
);
109 void hmp_info_version(Monitor
*mon
, const QDict
*qdict
)
113 info
= qmp_query_version(NULL
);
115 monitor_printf(mon
, "%" PRId64
".%" PRId64
".%" PRId64
"%s\n",
116 info
->qemu
->major
, info
->qemu
->minor
, info
->qemu
->micro
,
119 qapi_free_VersionInfo(info
);
122 void hmp_info_kvm(Monitor
*mon
, const QDict
*qdict
)
126 info
= qmp_query_kvm(NULL
);
127 monitor_printf(mon
, "kvm support: ");
129 monitor_printf(mon
, "%s\n", info
->enabled
? "enabled" : "disabled");
131 monitor_printf(mon
, "not compiled\n");
134 qapi_free_KvmInfo(info
);
137 void hmp_info_status(Monitor
*mon
, const QDict
*qdict
)
141 info
= qmp_query_status(NULL
);
143 monitor_printf(mon
, "VM status: %s%s",
144 info
->running
? "running" : "paused",
145 info
->singlestep
? " (single step mode)" : "");
147 if (!info
->running
&& info
->status
!= RUN_STATE_PAUSED
) {
148 monitor_printf(mon
, " (%s)", RunState_str(info
->status
));
151 monitor_printf(mon
, "\n");
153 qapi_free_StatusInfo(info
);
156 void hmp_info_uuid(Monitor
*mon
, const QDict
*qdict
)
160 info
= qmp_query_uuid(NULL
);
161 monitor_printf(mon
, "%s\n", info
->UUID
);
162 qapi_free_UuidInfo(info
);
165 void hmp_info_chardev(Monitor
*mon
, const QDict
*qdict
)
167 ChardevInfoList
*char_info
, *info
;
169 char_info
= qmp_query_chardev(NULL
);
170 for (info
= char_info
; info
; info
= info
->next
) {
171 monitor_printf(mon
, "%s: filename=%s\n", info
->value
->label
,
172 info
->value
->filename
);
175 qapi_free_ChardevInfoList(char_info
);
178 void hmp_info_mice(Monitor
*mon
, const QDict
*qdict
)
180 MouseInfoList
*mice_list
, *mouse
;
182 mice_list
= qmp_query_mice(NULL
);
184 monitor_printf(mon
, "No mouse devices connected\n");
188 for (mouse
= mice_list
; mouse
; mouse
= mouse
->next
) {
189 monitor_printf(mon
, "%c Mouse #%" PRId64
": %s%s\n",
190 mouse
->value
->current
? '*' : ' ',
191 mouse
->value
->index
, mouse
->value
->name
,
192 mouse
->value
->absolute
? " (absolute)" : "");
195 qapi_free_MouseInfoList(mice_list
);
198 static char *SocketAddress_to_str(SocketAddress
*addr
)
200 switch (addr
->type
) {
201 case SOCKET_ADDRESS_TYPE_INET
:
202 return g_strdup_printf("tcp:%s:%s",
205 case SOCKET_ADDRESS_TYPE_UNIX
:
206 return g_strdup_printf("unix:%s",
207 addr
->u
.q_unix
.path
);
208 case SOCKET_ADDRESS_TYPE_FD
:
209 return g_strdup_printf("fd:%s", addr
->u
.fd
.str
);
210 case SOCKET_ADDRESS_TYPE_VSOCK
:
211 return g_strdup_printf("tcp:%s:%s",
215 return g_strdup("unknown address type");
219 void hmp_info_migrate(Monitor
*mon
, const QDict
*qdict
)
223 info
= qmp_query_migrate(NULL
);
225 migration_global_dump(mon
);
228 strList
*reasons
= info
->blocked_reasons
;
229 monitor_printf(mon
, "Outgoing migration blocked:\n");
231 monitor_printf(mon
, " %s\n", reasons
->value
);
232 reasons
= reasons
->next
;
236 if (info
->has_status
) {
237 monitor_printf(mon
, "Migration status: %s",
238 MigrationStatus_str(info
->status
));
239 if (info
->status
== MIGRATION_STATUS_FAILED
&&
240 info
->has_error_desc
) {
241 monitor_printf(mon
, " (%s)\n", info
->error_desc
);
243 monitor_printf(mon
, "\n");
246 monitor_printf(mon
, "total time: %" PRIu64
" ms\n",
248 if (info
->has_expected_downtime
) {
249 monitor_printf(mon
, "expected downtime: %" PRIu64
" ms\n",
250 info
->expected_downtime
);
252 if (info
->has_downtime
) {
253 monitor_printf(mon
, "downtime: %" PRIu64
" ms\n",
256 if (info
->has_setup_time
) {
257 monitor_printf(mon
, "setup: %" PRIu64
" ms\n",
263 monitor_printf(mon
, "transferred ram: %" PRIu64
" kbytes\n",
264 info
->ram
->transferred
>> 10);
265 monitor_printf(mon
, "throughput: %0.2f mbps\n",
267 monitor_printf(mon
, "remaining ram: %" PRIu64
" kbytes\n",
268 info
->ram
->remaining
>> 10);
269 monitor_printf(mon
, "total ram: %" PRIu64
" kbytes\n",
270 info
->ram
->total
>> 10);
271 monitor_printf(mon
, "duplicate: %" PRIu64
" pages\n",
272 info
->ram
->duplicate
);
273 monitor_printf(mon
, "skipped: %" PRIu64
" pages\n",
275 monitor_printf(mon
, "normal: %" PRIu64
" pages\n",
277 monitor_printf(mon
, "normal bytes: %" PRIu64
" kbytes\n",
278 info
->ram
->normal_bytes
>> 10);
279 monitor_printf(mon
, "dirty sync count: %" PRIu64
"\n",
280 info
->ram
->dirty_sync_count
);
281 monitor_printf(mon
, "page size: %" PRIu64
" kbytes\n",
282 info
->ram
->page_size
>> 10);
283 monitor_printf(mon
, "multifd bytes: %" PRIu64
" kbytes\n",
284 info
->ram
->multifd_bytes
>> 10);
285 monitor_printf(mon
, "pages-per-second: %" PRIu64
"\n",
286 info
->ram
->pages_per_second
);
288 if (info
->ram
->dirty_pages_rate
) {
289 monitor_printf(mon
, "dirty pages rate: %" PRIu64
" pages\n",
290 info
->ram
->dirty_pages_rate
);
292 if (info
->ram
->postcopy_requests
) {
293 monitor_printf(mon
, "postcopy request count: %" PRIu64
"\n",
294 info
->ram
->postcopy_requests
);
298 if (info
->has_disk
) {
299 monitor_printf(mon
, "transferred disk: %" PRIu64
" kbytes\n",
300 info
->disk
->transferred
>> 10);
301 monitor_printf(mon
, "remaining disk: %" PRIu64
" kbytes\n",
302 info
->disk
->remaining
>> 10);
303 monitor_printf(mon
, "total disk: %" PRIu64
" kbytes\n",
304 info
->disk
->total
>> 10);
307 if (info
->has_xbzrle_cache
) {
308 monitor_printf(mon
, "cache size: %" PRIu64
" bytes\n",
309 info
->xbzrle_cache
->cache_size
);
310 monitor_printf(mon
, "xbzrle transferred: %" PRIu64
" kbytes\n",
311 info
->xbzrle_cache
->bytes
>> 10);
312 monitor_printf(mon
, "xbzrle pages: %" PRIu64
" pages\n",
313 info
->xbzrle_cache
->pages
);
314 monitor_printf(mon
, "xbzrle cache miss: %" PRIu64
" pages\n",
315 info
->xbzrle_cache
->cache_miss
);
316 monitor_printf(mon
, "xbzrle cache miss rate: %0.2f\n",
317 info
->xbzrle_cache
->cache_miss_rate
);
318 monitor_printf(mon
, "xbzrle encoding rate: %0.2f\n",
319 info
->xbzrle_cache
->encoding_rate
);
320 monitor_printf(mon
, "xbzrle overflow: %" PRIu64
"\n",
321 info
->xbzrle_cache
->overflow
);
324 if (info
->has_compression
) {
325 monitor_printf(mon
, "compression pages: %" PRIu64
" pages\n",
326 info
->compression
->pages
);
327 monitor_printf(mon
, "compression busy: %" PRIu64
"\n",
328 info
->compression
->busy
);
329 monitor_printf(mon
, "compression busy rate: %0.2f\n",
330 info
->compression
->busy_rate
);
331 monitor_printf(mon
, "compressed size: %" PRIu64
" kbytes\n",
332 info
->compression
->compressed_size
>> 10);
333 monitor_printf(mon
, "compression rate: %0.2f\n",
334 info
->compression
->compression_rate
);
337 if (info
->has_cpu_throttle_percentage
) {
338 monitor_printf(mon
, "cpu throttle percentage: %" PRIu64
"\n",
339 info
->cpu_throttle_percentage
);
342 if (info
->has_postcopy_blocktime
) {
343 monitor_printf(mon
, "postcopy blocktime: %u\n",
344 info
->postcopy_blocktime
);
347 if (info
->has_postcopy_vcpu_blocktime
) {
350 v
= string_output_visitor_new(false, &str
);
351 visit_type_uint32List(v
, NULL
, &info
->postcopy_vcpu_blocktime
,
353 visit_complete(v
, &str
);
354 monitor_printf(mon
, "postcopy vcpu blocktime: %s\n", str
);
358 if (info
->has_socket_address
) {
359 SocketAddressList
*addr
;
361 monitor_printf(mon
, "socket address: [\n");
363 for (addr
= info
->socket_address
; addr
; addr
= addr
->next
) {
364 char *s
= SocketAddress_to_str(addr
->value
);
365 monitor_printf(mon
, "\t%s\n", s
);
368 monitor_printf(mon
, "]\n");
371 if (info
->has_vfio
) {
372 monitor_printf(mon
, "vfio device transferred: %" PRIu64
" kbytes\n",
373 info
->vfio
->transferred
>> 10);
376 qapi_free_MigrationInfo(info
);
379 void hmp_info_migrate_capabilities(Monitor
*mon
, const QDict
*qdict
)
381 MigrationCapabilityStatusList
*caps
, *cap
;
383 caps
= qmp_query_migrate_capabilities(NULL
);
386 for (cap
= caps
; cap
; cap
= cap
->next
) {
387 monitor_printf(mon
, "%s: %s\n",
388 MigrationCapability_str(cap
->value
->capability
),
389 cap
->value
->state
? "on" : "off");
393 qapi_free_MigrationCapabilityStatusList(caps
);
396 void hmp_info_migrate_parameters(Monitor
*mon
, const QDict
*qdict
)
398 MigrationParameters
*params
;
400 params
= qmp_query_migrate_parameters(NULL
);
403 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
404 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_INITIAL
),
405 params
->announce_initial
);
406 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
407 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_MAX
),
408 params
->announce_max
);
409 monitor_printf(mon
, "%s: %" PRIu64
"\n",
410 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_ROUNDS
),
411 params
->announce_rounds
);
412 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
413 MigrationParameter_str(MIGRATION_PARAMETER_ANNOUNCE_STEP
),
414 params
->announce_step
);
415 assert(params
->has_compress_level
);
416 monitor_printf(mon
, "%s: %u\n",
417 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_LEVEL
),
418 params
->compress_level
);
419 assert(params
->has_compress_threads
);
420 monitor_printf(mon
, "%s: %u\n",
421 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_THREADS
),
422 params
->compress_threads
);
423 assert(params
->has_compress_wait_thread
);
424 monitor_printf(mon
, "%s: %s\n",
425 MigrationParameter_str(MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD
),
426 params
->compress_wait_thread
? "on" : "off");
427 assert(params
->has_decompress_threads
);
428 monitor_printf(mon
, "%s: %u\n",
429 MigrationParameter_str(MIGRATION_PARAMETER_DECOMPRESS_THREADS
),
430 params
->decompress_threads
);
431 assert(params
->has_throttle_trigger_threshold
);
432 monitor_printf(mon
, "%s: %u\n",
433 MigrationParameter_str(MIGRATION_PARAMETER_THROTTLE_TRIGGER_THRESHOLD
),
434 params
->throttle_trigger_threshold
);
435 assert(params
->has_cpu_throttle_initial
);
436 monitor_printf(mon
, "%s: %u\n",
437 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL
),
438 params
->cpu_throttle_initial
);
439 assert(params
->has_cpu_throttle_increment
);
440 monitor_printf(mon
, "%s: %u\n",
441 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT
),
442 params
->cpu_throttle_increment
);
443 assert(params
->has_cpu_throttle_tailslow
);
444 monitor_printf(mon
, "%s: %s\n",
445 MigrationParameter_str(MIGRATION_PARAMETER_CPU_THROTTLE_TAILSLOW
),
446 params
->cpu_throttle_tailslow
? "on" : "off");
447 assert(params
->has_max_cpu_throttle
);
448 monitor_printf(mon
, "%s: %u\n",
449 MigrationParameter_str(MIGRATION_PARAMETER_MAX_CPU_THROTTLE
),
450 params
->max_cpu_throttle
);
451 assert(params
->has_tls_creds
);
452 monitor_printf(mon
, "%s: '%s'\n",
453 MigrationParameter_str(MIGRATION_PARAMETER_TLS_CREDS
),
455 assert(params
->has_tls_hostname
);
456 monitor_printf(mon
, "%s: '%s'\n",
457 MigrationParameter_str(MIGRATION_PARAMETER_TLS_HOSTNAME
),
458 params
->tls_hostname
);
459 assert(params
->has_max_bandwidth
);
460 monitor_printf(mon
, "%s: %" PRIu64
" bytes/second\n",
461 MigrationParameter_str(MIGRATION_PARAMETER_MAX_BANDWIDTH
),
462 params
->max_bandwidth
);
463 assert(params
->has_downtime_limit
);
464 monitor_printf(mon
, "%s: %" PRIu64
" ms\n",
465 MigrationParameter_str(MIGRATION_PARAMETER_DOWNTIME_LIMIT
),
466 params
->downtime_limit
);
467 assert(params
->has_x_checkpoint_delay
);
468 monitor_printf(mon
, "%s: %u ms\n",
469 MigrationParameter_str(MIGRATION_PARAMETER_X_CHECKPOINT_DELAY
),
470 params
->x_checkpoint_delay
);
471 assert(params
->has_block_incremental
);
472 monitor_printf(mon
, "%s: %s\n",
473 MigrationParameter_str(MIGRATION_PARAMETER_BLOCK_INCREMENTAL
),
474 params
->block_incremental
? "on" : "off");
475 monitor_printf(mon
, "%s: %u\n",
476 MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_CHANNELS
),
477 params
->multifd_channels
);
478 monitor_printf(mon
, "%s: %s\n",
479 MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_COMPRESSION
),
480 MultiFDCompression_str(params
->multifd_compression
));
481 monitor_printf(mon
, "%s: %" PRIu64
" bytes\n",
482 MigrationParameter_str(MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE
),
483 params
->xbzrle_cache_size
);
484 monitor_printf(mon
, "%s: %" PRIu64
"\n",
485 MigrationParameter_str(MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH
),
486 params
->max_postcopy_bandwidth
);
487 monitor_printf(mon
, "%s: '%s'\n",
488 MigrationParameter_str(MIGRATION_PARAMETER_TLS_AUTHZ
),
491 if (params
->has_block_bitmap_mapping
) {
492 const BitmapMigrationNodeAliasList
*bmnal
;
494 monitor_printf(mon
, "%s:\n",
495 MigrationParameter_str(
496 MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING
));
498 for (bmnal
= params
->block_bitmap_mapping
;
502 const BitmapMigrationNodeAlias
*bmna
= bmnal
->value
;
503 const BitmapMigrationBitmapAliasList
*bmbal
;
505 monitor_printf(mon
, " '%s' -> '%s'\n",
506 bmna
->node_name
, bmna
->alias
);
508 for (bmbal
= bmna
->bitmaps
; bmbal
; bmbal
= bmbal
->next
) {
509 const BitmapMigrationBitmapAlias
*bmba
= bmbal
->value
;
511 monitor_printf(mon
, " '%s' -> '%s'\n",
512 bmba
->name
, bmba
->alias
);
518 qapi_free_MigrationParameters(params
);
521 void hmp_info_migrate_cache_size(Monitor
*mon
, const QDict
*qdict
)
523 monitor_printf(mon
, "xbzrel cache size: %" PRId64
" kbytes\n",
524 qmp_query_migrate_cache_size(NULL
) >> 10);
529 /* Helper for hmp_info_vnc_clients, _servers */
530 static void hmp_info_VncBasicInfo(Monitor
*mon
, VncBasicInfo
*info
,
533 monitor_printf(mon
, " %s: %s:%s (%s%s)\n",
537 NetworkAddressFamily_str(info
->family
),
538 info
->websocket
? " (Websocket)" : "");
541 /* Helper displaying and auth and crypt info */
542 static void hmp_info_vnc_authcrypt(Monitor
*mon
, const char *indent
,
544 VncVencryptSubAuth
*vencrypt
)
546 monitor_printf(mon
, "%sAuth: %s (Sub: %s)\n", indent
,
547 VncPrimaryAuth_str(auth
),
548 vencrypt
? VncVencryptSubAuth_str(*vencrypt
) : "none");
551 static void hmp_info_vnc_clients(Monitor
*mon
, VncClientInfoList
*client
)
554 VncClientInfo
*cinfo
= client
->value
;
556 hmp_info_VncBasicInfo(mon
, qapi_VncClientInfo_base(cinfo
), "Client");
557 monitor_printf(mon
, " x509_dname: %s\n",
558 cinfo
->has_x509_dname
?
559 cinfo
->x509_dname
: "none");
560 monitor_printf(mon
, " sasl_username: %s\n",
561 cinfo
->has_sasl_username
?
562 cinfo
->sasl_username
: "none");
564 client
= client
->next
;
568 static void hmp_info_vnc_servers(Monitor
*mon
, VncServerInfo2List
*server
)
571 VncServerInfo2
*sinfo
= server
->value
;
572 hmp_info_VncBasicInfo(mon
, qapi_VncServerInfo2_base(sinfo
), "Server");
573 hmp_info_vnc_authcrypt(mon
, " ", sinfo
->auth
,
574 sinfo
->has_vencrypt
? &sinfo
->vencrypt
: NULL
);
575 server
= server
->next
;
579 void hmp_info_vnc(Monitor
*mon
, const QDict
*qdict
)
581 VncInfo2List
*info2l
, *info2l_head
;
584 info2l
= qmp_query_vnc_servers(&err
);
585 info2l_head
= info2l
;
587 hmp_handle_error(mon
, err
);
591 monitor_printf(mon
, "None\n");
596 VncInfo2
*info
= info2l
->value
;
597 monitor_printf(mon
, "%s:\n", info
->id
);
598 hmp_info_vnc_servers(mon
, info
->server
);
599 hmp_info_vnc_clients(mon
, info
->clients
);
601 /* The server entry displays its auth, we only
602 * need to display in the case of 'reverse' connections
603 * where there's no server.
605 hmp_info_vnc_authcrypt(mon
, " ", info
->auth
,
606 info
->has_vencrypt
? &info
->vencrypt
: NULL
);
608 if (info
->has_display
) {
609 monitor_printf(mon
, " Display: %s\n", info
->display
);
611 info2l
= info2l
->next
;
614 qapi_free_VncInfo2List(info2l_head
);
620 void hmp_info_spice(Monitor
*mon
, const QDict
*qdict
)
622 SpiceChannelList
*chan
;
624 const char *channel_name
;
625 const char * const channel_names
[] = {
626 [SPICE_CHANNEL_MAIN
] = "main",
627 [SPICE_CHANNEL_DISPLAY
] = "display",
628 [SPICE_CHANNEL_INPUTS
] = "inputs",
629 [SPICE_CHANNEL_CURSOR
] = "cursor",
630 [SPICE_CHANNEL_PLAYBACK
] = "playback",
631 [SPICE_CHANNEL_RECORD
] = "record",
632 [SPICE_CHANNEL_TUNNEL
] = "tunnel",
633 [SPICE_CHANNEL_SMARTCARD
] = "smartcard",
634 [SPICE_CHANNEL_USBREDIR
] = "usbredir",
635 [SPICE_CHANNEL_PORT
] = "port",
637 /* minimum spice-protocol is 0.12.3, webdav was added in 0.12.7,
638 * no easy way to #ifdef (SPICE_CHANNEL_* is a enum). Disable
639 * as quick fix for build failures with older versions. */
640 [SPICE_CHANNEL_WEBDAV
] = "webdav",
644 info
= qmp_query_spice(NULL
);
646 if (!info
->enabled
) {
647 monitor_printf(mon
, "Server: disabled\n");
651 monitor_printf(mon
, "Server:\n");
652 if (info
->has_port
) {
653 monitor_printf(mon
, " address: %s:%" PRId64
"\n",
654 info
->host
, info
->port
);
656 if (info
->has_tls_port
) {
657 monitor_printf(mon
, " address: %s:%" PRId64
" [tls]\n",
658 info
->host
, info
->tls_port
);
660 monitor_printf(mon
, " migrated: %s\n",
661 info
->migrated
? "true" : "false");
662 monitor_printf(mon
, " auth: %s\n", info
->auth
);
663 monitor_printf(mon
, " compiled: %s\n", info
->compiled_version
);
664 monitor_printf(mon
, " mouse-mode: %s\n",
665 SpiceQueryMouseMode_str(info
->mouse_mode
));
667 if (!info
->has_channels
|| info
->channels
== NULL
) {
668 monitor_printf(mon
, "Channels: none\n");
670 for (chan
= info
->channels
; chan
; chan
= chan
->next
) {
671 monitor_printf(mon
, "Channel:\n");
672 monitor_printf(mon
, " address: %s:%s%s\n",
673 chan
->value
->host
, chan
->value
->port
,
674 chan
->value
->tls
? " [tls]" : "");
675 monitor_printf(mon
, " session: %" PRId64
"\n",
676 chan
->value
->connection_id
);
677 monitor_printf(mon
, " channel: %" PRId64
":%" PRId64
"\n",
678 chan
->value
->channel_type
, chan
->value
->channel_id
);
680 channel_name
= "unknown";
681 if (chan
->value
->channel_type
> 0 &&
682 chan
->value
->channel_type
< ARRAY_SIZE(channel_names
) &&
683 channel_names
[chan
->value
->channel_type
]) {
684 channel_name
= channel_names
[chan
->value
->channel_type
];
687 monitor_printf(mon
, " channel name: %s\n", channel_name
);
692 qapi_free_SpiceInfo(info
);
696 void hmp_info_balloon(Monitor
*mon
, const QDict
*qdict
)
701 info
= qmp_query_balloon(&err
);
703 hmp_handle_error(mon
, err
);
707 monitor_printf(mon
, "balloon: actual=%" PRId64
"\n", info
->actual
>> 20);
709 qapi_free_BalloonInfo(info
);
712 static void hmp_info_pci_device(Monitor
*mon
, const PciDeviceInfo
*dev
)
714 PciMemoryRegionList
*region
;
716 monitor_printf(mon
, " Bus %2" PRId64
", ", dev
->bus
);
717 monitor_printf(mon
, "device %3" PRId64
", function %" PRId64
":\n",
718 dev
->slot
, dev
->function
);
719 monitor_printf(mon
, " ");
721 if (dev
->class_info
->has_desc
) {
722 monitor_printf(mon
, "%s", dev
->class_info
->desc
);
724 monitor_printf(mon
, "Class %04" PRId64
, dev
->class_info
->q_class
);
727 monitor_printf(mon
, ": PCI device %04" PRIx64
":%04" PRIx64
"\n",
728 dev
->id
->vendor
, dev
->id
->device
);
729 if (dev
->id
->has_subsystem_vendor
&& dev
->id
->has_subsystem
) {
730 monitor_printf(mon
, " PCI subsystem %04" PRIx64
":%04" PRIx64
"\n",
731 dev
->id
->subsystem_vendor
, dev
->id
->subsystem
);
735 monitor_printf(mon
, " IRQ %" PRId64
", pin %c\n",
736 dev
->irq
, (char)('A' + dev
->irq_pin
- 1));
739 if (dev
->has_pci_bridge
) {
740 monitor_printf(mon
, " BUS %" PRId64
".\n",
741 dev
->pci_bridge
->bus
->number
);
742 monitor_printf(mon
, " secondary bus %" PRId64
".\n",
743 dev
->pci_bridge
->bus
->secondary
);
744 monitor_printf(mon
, " subordinate bus %" PRId64
".\n",
745 dev
->pci_bridge
->bus
->subordinate
);
747 monitor_printf(mon
, " IO range [0x%04"PRIx64
", 0x%04"PRIx64
"]\n",
748 dev
->pci_bridge
->bus
->io_range
->base
,
749 dev
->pci_bridge
->bus
->io_range
->limit
);
752 " memory range [0x%08"PRIx64
", 0x%08"PRIx64
"]\n",
753 dev
->pci_bridge
->bus
->memory_range
->base
,
754 dev
->pci_bridge
->bus
->memory_range
->limit
);
756 monitor_printf(mon
, " prefetchable memory range "
757 "[0x%08"PRIx64
", 0x%08"PRIx64
"]\n",
758 dev
->pci_bridge
->bus
->prefetchable_range
->base
,
759 dev
->pci_bridge
->bus
->prefetchable_range
->limit
);
762 for (region
= dev
->regions
; region
; region
= region
->next
) {
765 addr
= region
->value
->address
;
766 size
= region
->value
->size
;
768 monitor_printf(mon
, " BAR%" PRId64
": ", region
->value
->bar
);
770 if (!strcmp(region
->value
->type
, "io")) {
771 monitor_printf(mon
, "I/O at 0x%04" PRIx64
772 " [0x%04" PRIx64
"].\n",
773 addr
, addr
+ size
- 1);
775 monitor_printf(mon
, "%d bit%s memory at 0x%08" PRIx64
776 " [0x%08" PRIx64
"].\n",
777 region
->value
->mem_type_64
? 64 : 32,
778 region
->value
->prefetch
? " prefetchable" : "",
779 addr
, addr
+ size
- 1);
783 monitor_printf(mon
, " id \"%s\"\n", dev
->qdev_id
);
785 if (dev
->has_pci_bridge
) {
786 if (dev
->pci_bridge
->has_devices
) {
787 PciDeviceInfoList
*cdev
;
788 for (cdev
= dev
->pci_bridge
->devices
; cdev
; cdev
= cdev
->next
) {
789 hmp_info_pci_device(mon
, cdev
->value
);
795 static int hmp_info_irq_foreach(Object
*obj
, void *opaque
)
797 InterruptStatsProvider
*intc
;
798 InterruptStatsProviderClass
*k
;
799 Monitor
*mon
= opaque
;
801 if (object_dynamic_cast(obj
, TYPE_INTERRUPT_STATS_PROVIDER
)) {
802 intc
= INTERRUPT_STATS_PROVIDER(obj
);
803 k
= INTERRUPT_STATS_PROVIDER_GET_CLASS(obj
);
804 uint64_t *irq_counts
;
805 unsigned int nb_irqs
, i
;
806 if (k
->get_statistics
&&
807 k
->get_statistics(intc
, &irq_counts
, &nb_irqs
)) {
809 monitor_printf(mon
, "IRQ statistics for %s:\n",
810 object_get_typename(obj
));
811 for (i
= 0; i
< nb_irqs
; i
++) {
812 if (irq_counts
[i
] > 0) {
813 monitor_printf(mon
, "%2d: %" PRId64
"\n", i
,
819 monitor_printf(mon
, "IRQ statistics not available for %s.\n",
820 object_get_typename(obj
));
827 void hmp_info_irq(Monitor
*mon
, const QDict
*qdict
)
829 object_child_foreach_recursive(object_get_root(),
830 hmp_info_irq_foreach
, mon
);
833 static int hmp_info_pic_foreach(Object
*obj
, void *opaque
)
835 InterruptStatsProvider
*intc
;
836 InterruptStatsProviderClass
*k
;
837 Monitor
*mon
= opaque
;
839 if (object_dynamic_cast(obj
, TYPE_INTERRUPT_STATS_PROVIDER
)) {
840 intc
= INTERRUPT_STATS_PROVIDER(obj
);
841 k
= INTERRUPT_STATS_PROVIDER_GET_CLASS(obj
);
843 k
->print_info(intc
, mon
);
845 monitor_printf(mon
, "Interrupt controller information not available for %s.\n",
846 object_get_typename(obj
));
853 void hmp_info_pic(Monitor
*mon
, const QDict
*qdict
)
855 object_child_foreach_recursive(object_get_root(),
856 hmp_info_pic_foreach
, mon
);
859 static int hmp_info_rdma_foreach(Object
*obj
, void *opaque
)
862 RdmaProviderClass
*k
;
863 Monitor
*mon
= opaque
;
865 if (object_dynamic_cast(obj
, INTERFACE_RDMA_PROVIDER
)) {
866 rdma
= RDMA_PROVIDER(obj
);
867 k
= RDMA_PROVIDER_GET_CLASS(obj
);
868 if (k
->print_statistics
) {
869 k
->print_statistics(mon
, rdma
);
871 monitor_printf(mon
, "RDMA statistics not available for %s.\n",
872 object_get_typename(obj
));
879 void hmp_info_rdma(Monitor
*mon
, const QDict
*qdict
)
881 object_child_foreach_recursive(object_get_root(),
882 hmp_info_rdma_foreach
, mon
);
885 void hmp_info_pci(Monitor
*mon
, const QDict
*qdict
)
887 PciInfoList
*info_list
, *info
;
890 info_list
= qmp_query_pci(&err
);
892 monitor_printf(mon
, "PCI devices not supported\n");
897 for (info
= info_list
; info
; info
= info
->next
) {
898 PciDeviceInfoList
*dev
;
900 for (dev
= info
->value
->devices
; dev
; dev
= dev
->next
) {
901 hmp_info_pci_device(mon
, dev
->value
);
905 qapi_free_PciInfoList(info_list
);
908 void hmp_info_tpm(Monitor
*mon
, const QDict
*qdict
)
910 TPMInfoList
*info_list
, *info
;
913 TPMPassthroughOptions
*tpo
;
914 TPMEmulatorOptions
*teo
;
916 info_list
= qmp_query_tpm(&err
);
918 monitor_printf(mon
, "TPM device not supported\n");
924 monitor_printf(mon
, "TPM device:\n");
927 for (info
= info_list
; info
; info
= info
->next
) {
928 TPMInfo
*ti
= info
->value
;
929 monitor_printf(mon
, " tpm%d: model=%s\n",
930 c
, TpmModel_str(ti
->model
));
932 monitor_printf(mon
, " \\ %s: type=%s",
933 ti
->id
, TpmTypeOptionsKind_str(ti
->options
->type
));
935 switch (ti
->options
->type
) {
936 case TPM_TYPE_OPTIONS_KIND_PASSTHROUGH
:
937 tpo
= ti
->options
->u
.passthrough
.data
;
938 monitor_printf(mon
, "%s%s%s%s",
939 tpo
->has_path
? ",path=" : "",
940 tpo
->has_path
? tpo
->path
: "",
941 tpo
->has_cancel_path
? ",cancel-path=" : "",
942 tpo
->has_cancel_path
? tpo
->cancel_path
: "");
944 case TPM_TYPE_OPTIONS_KIND_EMULATOR
:
945 teo
= ti
->options
->u
.emulator
.data
;
946 monitor_printf(mon
, ",chardev=%s", teo
->chardev
);
948 case TPM_TYPE_OPTIONS_KIND__MAX
:
951 monitor_printf(mon
, "\n");
954 qapi_free_TPMInfoList(info_list
);
957 void hmp_quit(Monitor
*mon
, const QDict
*qdict
)
959 monitor_suspend(mon
);
963 void hmp_stop(Monitor
*mon
, const QDict
*qdict
)
968 void hmp_sync_profile(Monitor
*mon
, const QDict
*qdict
)
970 const char *op
= qdict_get_try_str(qdict
, "op");
973 bool on
= qsp_is_enabled();
975 monitor_printf(mon
, "sync-profile is %s\n", on
? "on" : "off");
978 if (!strcmp(op
, "on")) {
980 } else if (!strcmp(op
, "off")) {
982 } else if (!strcmp(op
, "reset")) {
987 error_setg(&err
, QERR_INVALID_PARAMETER
, op
);
988 hmp_handle_error(mon
, err
);
992 void hmp_system_reset(Monitor
*mon
, const QDict
*qdict
)
994 qmp_system_reset(NULL
);
997 void hmp_system_powerdown(Monitor
*mon
, const QDict
*qdict
)
999 qmp_system_powerdown(NULL
);
1002 void hmp_exit_preconfig(Monitor
*mon
, const QDict
*qdict
)
1006 qmp_x_exit_preconfig(&err
);
1007 hmp_handle_error(mon
, err
);
1010 void hmp_cpu(Monitor
*mon
, const QDict
*qdict
)
1014 /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
1015 use it are converted to the QAPI */
1016 cpu_index
= qdict_get_int(qdict
, "index");
1017 if (monitor_set_cpu(mon
, cpu_index
) < 0) {
1018 monitor_printf(mon
, "invalid CPU index\n");
1022 void hmp_memsave(Monitor
*mon
, const QDict
*qdict
)
1024 uint32_t size
= qdict_get_int(qdict
, "size");
1025 const char *filename
= qdict_get_str(qdict
, "filename");
1026 uint64_t addr
= qdict_get_int(qdict
, "val");
1028 int cpu_index
= monitor_get_cpu_index(mon
);
1030 if (cpu_index
< 0) {
1031 monitor_printf(mon
, "No CPU available\n");
1035 qmp_memsave(addr
, size
, filename
, true, cpu_index
, &err
);
1036 hmp_handle_error(mon
, err
);
1039 void hmp_pmemsave(Monitor
*mon
, const QDict
*qdict
)
1041 uint32_t size
= qdict_get_int(qdict
, "size");
1042 const char *filename
= qdict_get_str(qdict
, "filename");
1043 uint64_t addr
= qdict_get_int(qdict
, "val");
1046 qmp_pmemsave(addr
, size
, filename
, &err
);
1047 hmp_handle_error(mon
, err
);
1050 void hmp_ringbuf_write(Monitor
*mon
, const QDict
*qdict
)
1052 const char *chardev
= qdict_get_str(qdict
, "device");
1053 const char *data
= qdict_get_str(qdict
, "data");
1056 qmp_ringbuf_write(chardev
, data
, false, 0, &err
);
1058 hmp_handle_error(mon
, err
);
1061 void hmp_ringbuf_read(Monitor
*mon
, const QDict
*qdict
)
1063 uint32_t size
= qdict_get_int(qdict
, "size");
1064 const char *chardev
= qdict_get_str(qdict
, "device");
1069 data
= qmp_ringbuf_read(chardev
, size
, false, 0, &err
);
1071 hmp_handle_error(mon
, err
);
1075 for (i
= 0; data
[i
]; i
++) {
1076 unsigned char ch
= data
[i
];
1079 monitor_printf(mon
, "\\\\");
1080 } else if ((ch
< 0x20 && ch
!= '\n' && ch
!= '\t') || ch
== 0x7F) {
1081 monitor_printf(mon
, "\\u%04X", ch
);
1083 monitor_printf(mon
, "%c", ch
);
1087 monitor_printf(mon
, "\n");
1091 void hmp_cont(Monitor
*mon
, const QDict
*qdict
)
1096 hmp_handle_error(mon
, err
);
1099 void hmp_system_wakeup(Monitor
*mon
, const QDict
*qdict
)
1103 qmp_system_wakeup(&err
);
1104 hmp_handle_error(mon
, err
);
1107 void hmp_nmi(Monitor
*mon
, const QDict
*qdict
)
1111 qmp_inject_nmi(&err
);
1112 hmp_handle_error(mon
, err
);
1115 void hmp_set_link(Monitor
*mon
, const QDict
*qdict
)
1117 const char *name
= qdict_get_str(qdict
, "name");
1118 bool up
= qdict_get_bool(qdict
, "up");
1121 qmp_set_link(name
, up
, &err
);
1122 hmp_handle_error(mon
, err
);
1125 void hmp_balloon(Monitor
*mon
, const QDict
*qdict
)
1127 int64_t value
= qdict_get_int(qdict
, "value");
1130 qmp_balloon(value
, &err
);
1131 hmp_handle_error(mon
, err
);
1134 void hmp_loadvm(Monitor
*mon
, const QDict
*qdict
)
1136 int saved_vm_running
= runstate_is_running();
1137 const char *name
= qdict_get_str(qdict
, "name");
1140 vm_stop(RUN_STATE_RESTORE_VM
);
1142 if (!load_snapshot(name
, &err
) && saved_vm_running
) {
1145 hmp_handle_error(mon
, err
);
1148 void hmp_savevm(Monitor
*mon
, const QDict
*qdict
)
1152 save_snapshot(qdict_get_try_str(qdict
, "name"), true, &err
);
1153 hmp_handle_error(mon
, err
);
1156 void hmp_delvm(Monitor
*mon
, const QDict
*qdict
)
1159 const char *name
= qdict_get_str(qdict
, "name");
1161 bdrv_all_delete_snapshot(name
, false, NULL
, &err
);
1162 hmp_handle_error(mon
, err
);
1165 void hmp_announce_self(Monitor
*mon
, const QDict
*qdict
)
1167 const char *interfaces_str
= qdict_get_try_str(qdict
, "interfaces");
1168 const char *id
= qdict_get_try_str(qdict
, "id");
1169 AnnounceParameters
*params
= QAPI_CLONE(AnnounceParameters
,
1170 migrate_announce_params());
1172 qapi_free_strList(params
->interfaces
);
1173 params
->interfaces
= strList_from_comma_list(interfaces_str
);
1174 params
->has_interfaces
= params
->interfaces
!= NULL
;
1175 params
->id
= g_strdup(id
);
1176 params
->has_id
= !!params
->id
;
1177 qmp_announce_self(params
, NULL
);
1178 qapi_free_AnnounceParameters(params
);
1181 void hmp_migrate_cancel(Monitor
*mon
, const QDict
*qdict
)
1183 qmp_migrate_cancel(NULL
);
1186 void hmp_migrate_continue(Monitor
*mon
, const QDict
*qdict
)
1189 const char *state
= qdict_get_str(qdict
, "state");
1190 int val
= qapi_enum_parse(&MigrationStatus_lookup
, state
, -1, &err
);
1193 qmp_migrate_continue(val
, &err
);
1196 hmp_handle_error(mon
, err
);
1199 void hmp_migrate_incoming(Monitor
*mon
, const QDict
*qdict
)
1202 const char *uri
= qdict_get_str(qdict
, "uri");
1204 qmp_migrate_incoming(uri
, &err
);
1206 hmp_handle_error(mon
, err
);
1209 void hmp_migrate_recover(Monitor
*mon
, const QDict
*qdict
)
1212 const char *uri
= qdict_get_str(qdict
, "uri");
1214 qmp_migrate_recover(uri
, &err
);
1216 hmp_handle_error(mon
, err
);
1219 void hmp_migrate_pause(Monitor
*mon
, const QDict
*qdict
)
1223 qmp_migrate_pause(&err
);
1225 hmp_handle_error(mon
, err
);
1228 /* Kept for backwards compatibility */
1229 void hmp_migrate_set_downtime(Monitor
*mon
, const QDict
*qdict
)
1233 double value
= qdict_get_double(qdict
, "value");
1234 qmp_migrate_set_downtime(value
, &err
);
1235 hmp_handle_error(mon
, err
);
1238 void hmp_migrate_set_cache_size(Monitor
*mon
, const QDict
*qdict
)
1240 int64_t value
= qdict_get_int(qdict
, "value");
1243 qmp_migrate_set_cache_size(value
, &err
);
1244 hmp_handle_error(mon
, err
);
1247 /* Kept for backwards compatibility */
1248 void hmp_migrate_set_speed(Monitor
*mon
, const QDict
*qdict
)
1252 int64_t value
= qdict_get_int(qdict
, "value");
1253 qmp_migrate_set_speed(value
, &err
);
1254 hmp_handle_error(mon
, err
);
1257 void hmp_migrate_set_capability(Monitor
*mon
, const QDict
*qdict
)
1259 const char *cap
= qdict_get_str(qdict
, "capability");
1260 bool state
= qdict_get_bool(qdict
, "state");
1262 MigrationCapabilityStatusList
*caps
= NULL
;
1263 MigrationCapabilityStatus
*value
;
1266 val
= qapi_enum_parse(&MigrationCapability_lookup
, cap
, -1, &err
);
1271 value
= g_malloc0(sizeof(*value
));
1272 value
->capability
= val
;
1273 value
->state
= state
;
1274 QAPI_LIST_PREPEND(caps
, value
);
1275 qmp_migrate_set_capabilities(caps
, &err
);
1276 qapi_free_MigrationCapabilityStatusList(caps
);
1279 hmp_handle_error(mon
, err
);
1282 void hmp_migrate_set_parameter(Monitor
*mon
, const QDict
*qdict
)
1284 const char *param
= qdict_get_str(qdict
, "parameter");
1285 const char *valuestr
= qdict_get_str(qdict
, "value");
1286 Visitor
*v
= string_input_visitor_new(valuestr
);
1287 MigrateSetParameters
*p
= g_new0(MigrateSetParameters
, 1);
1288 uint64_t valuebw
= 0;
1289 uint64_t cache_size
;
1293 val
= qapi_enum_parse(&MigrationParameter_lookup
, param
, -1, &err
);
1299 case MIGRATION_PARAMETER_COMPRESS_LEVEL
:
1300 p
->has_compress_level
= true;
1301 visit_type_uint8(v
, param
, &p
->compress_level
, &err
);
1303 case MIGRATION_PARAMETER_COMPRESS_THREADS
:
1304 p
->has_compress_threads
= true;
1305 visit_type_uint8(v
, param
, &p
->compress_threads
, &err
);
1307 case MIGRATION_PARAMETER_COMPRESS_WAIT_THREAD
:
1308 p
->has_compress_wait_thread
= true;
1309 visit_type_bool(v
, param
, &p
->compress_wait_thread
, &err
);
1311 case MIGRATION_PARAMETER_DECOMPRESS_THREADS
:
1312 p
->has_decompress_threads
= true;
1313 visit_type_uint8(v
, param
, &p
->decompress_threads
, &err
);
1315 case MIGRATION_PARAMETER_THROTTLE_TRIGGER_THRESHOLD
:
1316 p
->has_throttle_trigger_threshold
= true;
1317 visit_type_uint8(v
, param
, &p
->throttle_trigger_threshold
, &err
);
1319 case MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL
:
1320 p
->has_cpu_throttle_initial
= true;
1321 visit_type_uint8(v
, param
, &p
->cpu_throttle_initial
, &err
);
1323 case MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT
:
1324 p
->has_cpu_throttle_increment
= true;
1325 visit_type_uint8(v
, param
, &p
->cpu_throttle_increment
, &err
);
1327 case MIGRATION_PARAMETER_CPU_THROTTLE_TAILSLOW
:
1328 p
->has_cpu_throttle_tailslow
= true;
1329 visit_type_bool(v
, param
, &p
->cpu_throttle_tailslow
, &err
);
1331 case MIGRATION_PARAMETER_MAX_CPU_THROTTLE
:
1332 p
->has_max_cpu_throttle
= true;
1333 visit_type_uint8(v
, param
, &p
->max_cpu_throttle
, &err
);
1335 case MIGRATION_PARAMETER_TLS_CREDS
:
1336 p
->has_tls_creds
= true;
1337 p
->tls_creds
= g_new0(StrOrNull
, 1);
1338 p
->tls_creds
->type
= QTYPE_QSTRING
;
1339 visit_type_str(v
, param
, &p
->tls_creds
->u
.s
, &err
);
1341 case MIGRATION_PARAMETER_TLS_HOSTNAME
:
1342 p
->has_tls_hostname
= true;
1343 p
->tls_hostname
= g_new0(StrOrNull
, 1);
1344 p
->tls_hostname
->type
= QTYPE_QSTRING
;
1345 visit_type_str(v
, param
, &p
->tls_hostname
->u
.s
, &err
);
1347 case MIGRATION_PARAMETER_TLS_AUTHZ
:
1348 p
->has_tls_authz
= true;
1349 p
->tls_authz
= g_new0(StrOrNull
, 1);
1350 p
->tls_authz
->type
= QTYPE_QSTRING
;
1351 visit_type_str(v
, param
, &p
->tls_authz
->u
.s
, &err
);
1353 case MIGRATION_PARAMETER_MAX_BANDWIDTH
:
1354 p
->has_max_bandwidth
= true;
1356 * Can't use visit_type_size() here, because it
1357 * defaults to Bytes rather than Mebibytes.
1359 ret
= qemu_strtosz_MiB(valuestr
, NULL
, &valuebw
);
1360 if (ret
< 0 || valuebw
> INT64_MAX
1361 || (size_t)valuebw
!= valuebw
) {
1362 error_setg(&err
, "Invalid size %s", valuestr
);
1365 p
->max_bandwidth
= valuebw
;
1367 case MIGRATION_PARAMETER_DOWNTIME_LIMIT
:
1368 p
->has_downtime_limit
= true;
1369 visit_type_size(v
, param
, &p
->downtime_limit
, &err
);
1371 case MIGRATION_PARAMETER_X_CHECKPOINT_DELAY
:
1372 p
->has_x_checkpoint_delay
= true;
1373 visit_type_uint32(v
, param
, &p
->x_checkpoint_delay
, &err
);
1375 case MIGRATION_PARAMETER_BLOCK_INCREMENTAL
:
1376 p
->has_block_incremental
= true;
1377 visit_type_bool(v
, param
, &p
->block_incremental
, &err
);
1379 case MIGRATION_PARAMETER_MULTIFD_CHANNELS
:
1380 p
->has_multifd_channels
= true;
1381 visit_type_uint8(v
, param
, &p
->multifd_channels
, &err
);
1383 case MIGRATION_PARAMETER_MULTIFD_COMPRESSION
:
1384 p
->has_multifd_compression
= true;
1385 visit_type_MultiFDCompression(v
, param
, &p
->multifd_compression
,
1388 case MIGRATION_PARAMETER_MULTIFD_ZLIB_LEVEL
:
1389 p
->has_multifd_zlib_level
= true;
1390 visit_type_uint8(v
, param
, &p
->multifd_zlib_level
, &err
);
1392 case MIGRATION_PARAMETER_MULTIFD_ZSTD_LEVEL
:
1393 p
->has_multifd_zstd_level
= true;
1394 visit_type_uint8(v
, param
, &p
->multifd_zstd_level
, &err
);
1396 case MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE
:
1397 p
->has_xbzrle_cache_size
= true;
1398 if (!visit_type_size(v
, param
, &cache_size
, &err
)) {
1401 if (cache_size
> INT64_MAX
|| (size_t)cache_size
!= cache_size
) {
1402 error_setg(&err
, "Invalid size %s", valuestr
);
1405 p
->xbzrle_cache_size
= cache_size
;
1407 case MIGRATION_PARAMETER_MAX_POSTCOPY_BANDWIDTH
:
1408 p
->has_max_postcopy_bandwidth
= true;
1409 visit_type_size(v
, param
, &p
->max_postcopy_bandwidth
, &err
);
1411 case MIGRATION_PARAMETER_ANNOUNCE_INITIAL
:
1412 p
->has_announce_initial
= true;
1413 visit_type_size(v
, param
, &p
->announce_initial
, &err
);
1415 case MIGRATION_PARAMETER_ANNOUNCE_MAX
:
1416 p
->has_announce_max
= true;
1417 visit_type_size(v
, param
, &p
->announce_max
, &err
);
1419 case MIGRATION_PARAMETER_ANNOUNCE_ROUNDS
:
1420 p
->has_announce_rounds
= true;
1421 visit_type_size(v
, param
, &p
->announce_rounds
, &err
);
1423 case MIGRATION_PARAMETER_ANNOUNCE_STEP
:
1424 p
->has_announce_step
= true;
1425 visit_type_size(v
, param
, &p
->announce_step
, &err
);
1427 case MIGRATION_PARAMETER_BLOCK_BITMAP_MAPPING
:
1428 error_setg(&err
, "The block-bitmap-mapping parameter can only be set "
1439 qmp_migrate_set_parameters(p
, &err
);
1442 qapi_free_MigrateSetParameters(p
);
1444 hmp_handle_error(mon
, err
);
1447 void hmp_client_migrate_info(Monitor
*mon
, const QDict
*qdict
)
1450 const char *protocol
= qdict_get_str(qdict
, "protocol");
1451 const char *hostname
= qdict_get_str(qdict
, "hostname");
1452 bool has_port
= qdict_haskey(qdict
, "port");
1453 int port
= qdict_get_try_int(qdict
, "port", -1);
1454 bool has_tls_port
= qdict_haskey(qdict
, "tls-port");
1455 int tls_port
= qdict_get_try_int(qdict
, "tls-port", -1);
1456 const char *cert_subject
= qdict_get_try_str(qdict
, "cert-subject");
1458 qmp_client_migrate_info(protocol
, hostname
,
1459 has_port
, port
, has_tls_port
, tls_port
,
1460 !!cert_subject
, cert_subject
, &err
);
1461 hmp_handle_error(mon
, err
);
1464 void hmp_migrate_start_postcopy(Monitor
*mon
, const QDict
*qdict
)
1467 qmp_migrate_start_postcopy(&err
);
1468 hmp_handle_error(mon
, err
);
1471 void hmp_x_colo_lost_heartbeat(Monitor
*mon
, const QDict
*qdict
)
1475 qmp_x_colo_lost_heartbeat(&err
);
1476 hmp_handle_error(mon
, err
);
1479 void hmp_set_password(Monitor
*mon
, const QDict
*qdict
)
1481 const char *protocol
= qdict_get_str(qdict
, "protocol");
1482 const char *password
= qdict_get_str(qdict
, "password");
1483 const char *connected
= qdict_get_try_str(qdict
, "connected");
1486 qmp_set_password(protocol
, password
, !!connected
, connected
, &err
);
1487 hmp_handle_error(mon
, err
);
1490 void hmp_expire_password(Monitor
*mon
, const QDict
*qdict
)
1492 const char *protocol
= qdict_get_str(qdict
, "protocol");
1493 const char *whenstr
= qdict_get_str(qdict
, "time");
1496 qmp_expire_password(protocol
, whenstr
, &err
);
1497 hmp_handle_error(mon
, err
);
1502 static void hmp_change_read_arg(void *opaque
, const char *password
,
1503 void *readline_opaque
)
1505 qmp_change_vnc_password(password
, NULL
);
1506 monitor_read_command(opaque
, 1);
1510 void hmp_change(Monitor
*mon
, const QDict
*qdict
)
1512 const char *device
= qdict_get_str(qdict
, "device");
1513 const char *target
= qdict_get_str(qdict
, "target");
1514 const char *arg
= qdict_get_try_str(qdict
, "arg");
1515 const char *read_only
= qdict_get_try_str(qdict
, "read-only-mode");
1516 BlockdevChangeReadOnlyMode read_only_mode
= 0;
1520 if (strcmp(device
, "vnc") == 0) {
1523 "Parameter 'read-only-mode' is invalid for VNC\n");
1526 if (strcmp(target
, "passwd") == 0 ||
1527 strcmp(target
, "password") == 0) {
1529 MonitorHMP
*hmp_mon
= container_of(mon
, MonitorHMP
, common
);
1530 monitor_read_password(hmp_mon
, hmp_change_read_arg
, NULL
);
1533 qmp_change_vnc_password(arg
, &err
);
1536 monitor_printf(mon
, "Expected 'password' after 'vnc'\n");
1543 qapi_enum_parse(&BlockdevChangeReadOnlyMode_lookup
,
1545 BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN
, &err
);
1551 qmp_blockdev_change_medium(true, device
, false, NULL
, target
,
1552 !!arg
, arg
, !!read_only
, read_only_mode
,
1557 hmp_handle_error(mon
, err
);
1560 typedef struct HMPMigrationStatus
{
1563 bool is_block_migration
;
1564 } HMPMigrationStatus
;
1566 static void hmp_migrate_status_cb(void *opaque
)
1568 HMPMigrationStatus
*status
= opaque
;
1569 MigrationInfo
*info
;
1571 info
= qmp_query_migrate(NULL
);
1572 if (!info
->has_status
|| info
->status
== MIGRATION_STATUS_ACTIVE
||
1573 info
->status
== MIGRATION_STATUS_SETUP
) {
1574 if (info
->has_disk
) {
1577 if (info
->disk
->remaining
) {
1578 progress
= info
->disk
->transferred
* 100 / info
->disk
->total
;
1583 monitor_printf(status
->mon
, "Completed %d %%\r", progress
);
1584 monitor_flush(status
->mon
);
1587 timer_mod(status
->timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
) + 1000);
1589 if (status
->is_block_migration
) {
1590 monitor_printf(status
->mon
, "\n");
1592 if (info
->has_error_desc
) {
1593 error_report("%s", info
->error_desc
);
1595 monitor_resume(status
->mon
);
1596 timer_free(status
->timer
);
1600 qapi_free_MigrationInfo(info
);
1603 void hmp_migrate(Monitor
*mon
, const QDict
*qdict
)
1605 bool detach
= qdict_get_try_bool(qdict
, "detach", false);
1606 bool blk
= qdict_get_try_bool(qdict
, "blk", false);
1607 bool inc
= qdict_get_try_bool(qdict
, "inc", false);
1608 bool resume
= qdict_get_try_bool(qdict
, "resume", false);
1609 const char *uri
= qdict_get_str(qdict
, "uri");
1612 qmp_migrate(uri
, !!blk
, blk
, !!inc
, inc
,
1613 false, false, true, resume
, &err
);
1615 hmp_handle_error(mon
, err
);
1620 HMPMigrationStatus
*status
;
1622 if (monitor_suspend(mon
) < 0) {
1623 monitor_printf(mon
, "terminal does not allow synchronous "
1624 "migration, continuing detached\n");
1628 status
= g_malloc0(sizeof(*status
));
1630 status
->is_block_migration
= blk
|| inc
;
1631 status
->timer
= timer_new_ms(QEMU_CLOCK_REALTIME
, hmp_migrate_status_cb
,
1633 timer_mod(status
->timer
, qemu_clock_get_ms(QEMU_CLOCK_REALTIME
));
1637 void hmp_netdev_add(Monitor
*mon
, const QDict
*qdict
)
1641 const char *type
= qdict_get_try_str(qdict
, "type");
1643 if (type
&& is_help_option(type
)) {
1647 opts
= qemu_opts_from_qdict(qemu_find_opts("netdev"), qdict
, &err
);
1652 netdev_add(opts
, &err
);
1654 qemu_opts_del(opts
);
1658 hmp_handle_error(mon
, err
);
1661 void hmp_netdev_del(Monitor
*mon
, const QDict
*qdict
)
1663 const char *id
= qdict_get_str(qdict
, "id");
1666 qmp_netdev_del(id
, &err
);
1667 hmp_handle_error(mon
, err
);
1670 void hmp_object_add(Monitor
*mon
, const QDict
*qdict
)
1676 opts
= qemu_opts_from_qdict(qemu_find_opts("object"), qdict
, &err
);
1681 obj
= user_creatable_add_opts(opts
, &err
);
1682 qemu_opts_del(opts
);
1685 hmp_handle_error(mon
, err
);
1692 void hmp_getfd(Monitor
*mon
, const QDict
*qdict
)
1694 const char *fdname
= qdict_get_str(qdict
, "fdname");
1697 qmp_getfd(fdname
, &err
);
1698 hmp_handle_error(mon
, err
);
1701 void hmp_closefd(Monitor
*mon
, const QDict
*qdict
)
1703 const char *fdname
= qdict_get_str(qdict
, "fdname");
1706 qmp_closefd(fdname
, &err
);
1707 hmp_handle_error(mon
, err
);
1710 void hmp_sendkey(Monitor
*mon
, const QDict
*qdict
)
1712 const char *keys
= qdict_get_str(qdict
, "keys");
1714 KeyValueList
*head
= NULL
, **tail
= &head
;
1715 int has_hold_time
= qdict_haskey(qdict
, "hold-time");
1716 int hold_time
= qdict_get_try_int(qdict
, "hold-time", -1);
1718 const char *separator
;
1722 separator
= qemu_strchrnul(keys
, '-');
1723 keyname_len
= separator
- keys
;
1725 /* Be compatible with old interface, convert user inputted "<" */
1726 if (keys
[0] == '<' && keyname_len
== 1) {
1731 v
= g_malloc0(sizeof(*v
));
1733 if (strstart(keys
, "0x", NULL
)) {
1735 int value
= strtoul(keys
, &endp
, 0);
1736 assert(endp
<= keys
+ keyname_len
);
1737 if (endp
!= keys
+ keyname_len
) {
1740 v
->type
= KEY_VALUE_KIND_NUMBER
;
1741 v
->u
.number
.data
= value
;
1743 int idx
= index_from_key(keys
, keyname_len
);
1744 if (idx
== Q_KEY_CODE__MAX
) {
1747 v
->type
= KEY_VALUE_KIND_QCODE
;
1748 v
->u
.qcode
.data
= idx
;
1750 QAPI_LIST_APPEND(tail
, v
);
1756 keys
= separator
+ 1;
1759 qmp_send_key(head
, has_hold_time
, hold_time
, &err
);
1760 hmp_handle_error(mon
, err
);
1763 qapi_free_KeyValue(v
);
1764 qapi_free_KeyValueList(head
);
1768 monitor_printf(mon
, "invalid parameter: %.*s\n", keyname_len
, keys
);
1773 hmp_screendump(Monitor
*mon
, const QDict
*qdict
)
1775 const char *filename
= qdict_get_str(qdict
, "filename");
1776 const char *id
= qdict_get_try_str(qdict
, "device");
1777 int64_t head
= qdict_get_try_int(qdict
, "head", 0);
1780 qmp_screendump(filename
, id
!= NULL
, id
, id
!= NULL
, head
, &err
);
1781 hmp_handle_error(mon
, err
);
1784 void hmp_chardev_add(Monitor
*mon
, const QDict
*qdict
)
1786 const char *args
= qdict_get_str(qdict
, "args");
1790 opts
= qemu_opts_parse_noisily(qemu_find_opts("chardev"), args
, true);
1792 error_setg(&err
, "Parsing chardev args failed");
1794 qemu_chr_new_from_opts(opts
, NULL
, &err
);
1795 qemu_opts_del(opts
);
1797 hmp_handle_error(mon
, err
);
1800 void hmp_chardev_change(Monitor
*mon
, const QDict
*qdict
)
1802 const char *args
= qdict_get_str(qdict
, "args");
1805 ChardevBackend
*backend
= NULL
;
1806 ChardevReturn
*ret
= NULL
;
1807 QemuOpts
*opts
= qemu_opts_parse_noisily(qemu_find_opts("chardev"), args
,
1810 error_setg(&err
, "Parsing chardev args failed");
1814 id
= qdict_get_str(qdict
, "id");
1815 if (qemu_opts_id(opts
)) {
1816 error_setg(&err
, "Unexpected 'id' parameter");
1820 backend
= qemu_chr_parse_opts(opts
, &err
);
1825 ret
= qmp_chardev_change(id
, backend
, &err
);
1828 qapi_free_ChardevReturn(ret
);
1829 qapi_free_ChardevBackend(backend
);
1830 qemu_opts_del(opts
);
1831 hmp_handle_error(mon
, err
);
1834 void hmp_chardev_remove(Monitor
*mon
, const QDict
*qdict
)
1836 Error
*local_err
= NULL
;
1838 qmp_chardev_remove(qdict_get_str(qdict
, "id"), &local_err
);
1839 hmp_handle_error(mon
, local_err
);
1842 void hmp_chardev_send_break(Monitor
*mon
, const QDict
*qdict
)
1844 Error
*local_err
= NULL
;
1846 qmp_chardev_send_break(qdict_get_str(qdict
, "id"), &local_err
);
1847 hmp_handle_error(mon
, local_err
);
1850 void hmp_object_del(Monitor
*mon
, const QDict
*qdict
)
1852 const char *id
= qdict_get_str(qdict
, "id");
1855 user_creatable_del(id
, &err
);
1856 hmp_handle_error(mon
, err
);
1859 void hmp_info_memory_devices(Monitor
*mon
, const QDict
*qdict
)
1862 MemoryDeviceInfoList
*info_list
= qmp_query_memory_devices(&err
);
1863 MemoryDeviceInfoList
*info
;
1864 VirtioPMEMDeviceInfo
*vpi
;
1865 VirtioMEMDeviceInfo
*vmi
;
1866 MemoryDeviceInfo
*value
;
1867 PCDIMMDeviceInfo
*di
;
1869 for (info
= info_list
; info
; info
= info
->next
) {
1870 value
= info
->value
;
1873 switch (value
->type
) {
1874 case MEMORY_DEVICE_INFO_KIND_DIMM
:
1875 case MEMORY_DEVICE_INFO_KIND_NVDIMM
:
1876 di
= value
->type
== MEMORY_DEVICE_INFO_KIND_DIMM
?
1877 value
->u
.dimm
.data
: value
->u
.nvdimm
.data
;
1878 monitor_printf(mon
, "Memory device [%s]: \"%s\"\n",
1879 MemoryDeviceInfoKind_str(value
->type
),
1880 di
->id
? di
->id
: "");
1881 monitor_printf(mon
, " addr: 0x%" PRIx64
"\n", di
->addr
);
1882 monitor_printf(mon
, " slot: %" PRId64
"\n", di
->slot
);
1883 monitor_printf(mon
, " node: %" PRId64
"\n", di
->node
);
1884 monitor_printf(mon
, " size: %" PRIu64
"\n", di
->size
);
1885 monitor_printf(mon
, " memdev: %s\n", di
->memdev
);
1886 monitor_printf(mon
, " hotplugged: %s\n",
1887 di
->hotplugged
? "true" : "false");
1888 monitor_printf(mon
, " hotpluggable: %s\n",
1889 di
->hotpluggable
? "true" : "false");
1891 case MEMORY_DEVICE_INFO_KIND_VIRTIO_PMEM
:
1892 vpi
= value
->u
.virtio_pmem
.data
;
1893 monitor_printf(mon
, "Memory device [%s]: \"%s\"\n",
1894 MemoryDeviceInfoKind_str(value
->type
),
1895 vpi
->id
? vpi
->id
: "");
1896 monitor_printf(mon
, " memaddr: 0x%" PRIx64
"\n", vpi
->memaddr
);
1897 monitor_printf(mon
, " size: %" PRIu64
"\n", vpi
->size
);
1898 monitor_printf(mon
, " memdev: %s\n", vpi
->memdev
);
1900 case MEMORY_DEVICE_INFO_KIND_VIRTIO_MEM
:
1901 vmi
= value
->u
.virtio_mem
.data
;
1902 monitor_printf(mon
, "Memory device [%s]: \"%s\"\n",
1903 MemoryDeviceInfoKind_str(value
->type
),
1904 vmi
->id
? vmi
->id
: "");
1905 monitor_printf(mon
, " memaddr: 0x%" PRIx64
"\n", vmi
->memaddr
);
1906 monitor_printf(mon
, " node: %" PRId64
"\n", vmi
->node
);
1907 monitor_printf(mon
, " requested-size: %" PRIu64
"\n",
1908 vmi
->requested_size
);
1909 monitor_printf(mon
, " size: %" PRIu64
"\n", vmi
->size
);
1910 monitor_printf(mon
, " max-size: %" PRIu64
"\n", vmi
->max_size
);
1911 monitor_printf(mon
, " block-size: %" PRIu64
"\n",
1913 monitor_printf(mon
, " memdev: %s\n", vmi
->memdev
);
1916 g_assert_not_reached();
1921 qapi_free_MemoryDeviceInfoList(info_list
);
1922 hmp_handle_error(mon
, err
);
1925 void hmp_info_iothreads(Monitor
*mon
, const QDict
*qdict
)
1927 IOThreadInfoList
*info_list
= qmp_query_iothreads(NULL
);
1928 IOThreadInfoList
*info
;
1929 IOThreadInfo
*value
;
1931 for (info
= info_list
; info
; info
= info
->next
) {
1932 value
= info
->value
;
1933 monitor_printf(mon
, "%s:\n", value
->id
);
1934 monitor_printf(mon
, " thread_id=%" PRId64
"\n", value
->thread_id
);
1935 monitor_printf(mon
, " poll-max-ns=%" PRId64
"\n", value
->poll_max_ns
);
1936 monitor_printf(mon
, " poll-grow=%" PRId64
"\n", value
->poll_grow
);
1937 monitor_printf(mon
, " poll-shrink=%" PRId64
"\n", value
->poll_shrink
);
1940 qapi_free_IOThreadInfoList(info_list
);
1943 void hmp_rocker(Monitor
*mon
, const QDict
*qdict
)
1945 const char *name
= qdict_get_str(qdict
, "name");
1946 RockerSwitch
*rocker
;
1949 rocker
= qmp_query_rocker(name
, &err
);
1951 hmp_handle_error(mon
, err
);
1955 monitor_printf(mon
, "name: %s\n", rocker
->name
);
1956 monitor_printf(mon
, "id: 0x%" PRIx64
"\n", rocker
->id
);
1957 monitor_printf(mon
, "ports: %d\n", rocker
->ports
);
1959 qapi_free_RockerSwitch(rocker
);
1962 void hmp_rocker_ports(Monitor
*mon
, const QDict
*qdict
)
1964 RockerPortList
*list
, *port
;
1965 const char *name
= qdict_get_str(qdict
, "name");
1968 list
= qmp_query_rocker_ports(name
, &err
);
1970 hmp_handle_error(mon
, err
);
1974 monitor_printf(mon
, " ena/ speed/ auto\n");
1975 monitor_printf(mon
, " port link duplex neg?\n");
1977 for (port
= list
; port
; port
= port
->next
) {
1978 monitor_printf(mon
, "%10s %-4s %-3s %2s %-3s\n",
1980 port
->value
->enabled
? port
->value
->link_up
?
1981 "up" : "down" : "!ena",
1982 port
->value
->speed
== 10000 ? "10G" : "??",
1983 port
->value
->duplex
? "FD" : "HD",
1984 port
->value
->autoneg
? "Yes" : "No");
1987 qapi_free_RockerPortList(list
);
1990 void hmp_rocker_of_dpa_flows(Monitor
*mon
, const QDict
*qdict
)
1992 RockerOfDpaFlowList
*list
, *info
;
1993 const char *name
= qdict_get_str(qdict
, "name");
1994 uint32_t tbl_id
= qdict_get_try_int(qdict
, "tbl_id", -1);
1997 list
= qmp_query_rocker_of_dpa_flows(name
, tbl_id
!= -1, tbl_id
, &err
);
1999 hmp_handle_error(mon
, err
);
2003 monitor_printf(mon
, "prio tbl hits key(mask) --> actions\n");
2005 for (info
= list
; info
; info
= info
->next
) {
2006 RockerOfDpaFlow
*flow
= info
->value
;
2007 RockerOfDpaFlowKey
*key
= flow
->key
;
2008 RockerOfDpaFlowMask
*mask
= flow
->mask
;
2009 RockerOfDpaFlowAction
*action
= flow
->action
;
2012 monitor_printf(mon
, "%-4d %-3d %-4" PRIu64
,
2013 key
->priority
, key
->tbl_id
, flow
->hits
);
2015 monitor_printf(mon
, "%-4d %-3d ",
2016 key
->priority
, key
->tbl_id
);
2019 if (key
->has_in_pport
) {
2020 monitor_printf(mon
, " pport %d", key
->in_pport
);
2021 if (mask
->has_in_pport
) {
2022 monitor_printf(mon
, "(0x%x)", mask
->in_pport
);
2026 if (key
->has_vlan_id
) {
2027 monitor_printf(mon
, " vlan %d",
2028 key
->vlan_id
& VLAN_VID_MASK
);
2029 if (mask
->has_vlan_id
) {
2030 monitor_printf(mon
, "(0x%x)", mask
->vlan_id
);
2034 if (key
->has_tunnel_id
) {
2035 monitor_printf(mon
, " tunnel %d", key
->tunnel_id
);
2036 if (mask
->has_tunnel_id
) {
2037 monitor_printf(mon
, "(0x%x)", mask
->tunnel_id
);
2041 if (key
->has_eth_type
) {
2042 switch (key
->eth_type
) {
2044 monitor_printf(mon
, " ARP");
2047 monitor_printf(mon
, " IP");
2050 monitor_printf(mon
, " IPv6");
2053 monitor_printf(mon
, " LACP");
2056 monitor_printf(mon
, " LLDP");
2059 monitor_printf(mon
, " eth type 0x%04x", key
->eth_type
);
2064 if (key
->has_eth_src
) {
2065 if ((strcmp(key
->eth_src
, "01:00:00:00:00:00") == 0) &&
2066 (mask
->has_eth_src
) &&
2067 (strcmp(mask
->eth_src
, "01:00:00:00:00:00") == 0)) {
2068 monitor_printf(mon
, " src <any mcast/bcast>");
2069 } else if ((strcmp(key
->eth_src
, "00:00:00:00:00:00") == 0) &&
2070 (mask
->has_eth_src
) &&
2071 (strcmp(mask
->eth_src
, "01:00:00:00:00:00") == 0)) {
2072 monitor_printf(mon
, " src <any ucast>");
2074 monitor_printf(mon
, " src %s", key
->eth_src
);
2075 if (mask
->has_eth_src
) {
2076 monitor_printf(mon
, "(%s)", mask
->eth_src
);
2081 if (key
->has_eth_dst
) {
2082 if ((strcmp(key
->eth_dst
, "01:00:00:00:00:00") == 0) &&
2083 (mask
->has_eth_dst
) &&
2084 (strcmp(mask
->eth_dst
, "01:00:00:00:00:00") == 0)) {
2085 monitor_printf(mon
, " dst <any mcast/bcast>");
2086 } else if ((strcmp(key
->eth_dst
, "00:00:00:00:00:00") == 0) &&
2087 (mask
->has_eth_dst
) &&
2088 (strcmp(mask
->eth_dst
, "01:00:00:00:00:00") == 0)) {
2089 monitor_printf(mon
, " dst <any ucast>");
2091 monitor_printf(mon
, " dst %s", key
->eth_dst
);
2092 if (mask
->has_eth_dst
) {
2093 monitor_printf(mon
, "(%s)", mask
->eth_dst
);
2098 if (key
->has_ip_proto
) {
2099 monitor_printf(mon
, " proto %d", key
->ip_proto
);
2100 if (mask
->has_ip_proto
) {
2101 monitor_printf(mon
, "(0x%x)", mask
->ip_proto
);
2105 if (key
->has_ip_tos
) {
2106 monitor_printf(mon
, " TOS %d", key
->ip_tos
);
2107 if (mask
->has_ip_tos
) {
2108 monitor_printf(mon
, "(0x%x)", mask
->ip_tos
);
2112 if (key
->has_ip_dst
) {
2113 monitor_printf(mon
, " dst %s", key
->ip_dst
);
2116 if (action
->has_goto_tbl
|| action
->has_group_id
||
2117 action
->has_new_vlan_id
) {
2118 monitor_printf(mon
, " -->");
2121 if (action
->has_new_vlan_id
) {
2122 monitor_printf(mon
, " apply new vlan %d",
2123 ntohs(action
->new_vlan_id
));
2126 if (action
->has_group_id
) {
2127 monitor_printf(mon
, " write group 0x%08x", action
->group_id
);
2130 if (action
->has_goto_tbl
) {
2131 monitor_printf(mon
, " goto tbl %d", action
->goto_tbl
);
2134 monitor_printf(mon
, "\n");
2137 qapi_free_RockerOfDpaFlowList(list
);
2140 void hmp_rocker_of_dpa_groups(Monitor
*mon
, const QDict
*qdict
)
2142 RockerOfDpaGroupList
*list
, *g
;
2143 const char *name
= qdict_get_str(qdict
, "name");
2144 uint8_t type
= qdict_get_try_int(qdict
, "type", 9);
2147 list
= qmp_query_rocker_of_dpa_groups(name
, type
!= 9, type
, &err
);
2149 hmp_handle_error(mon
, err
);
2153 monitor_printf(mon
, "id (decode) --> buckets\n");
2155 for (g
= list
; g
; g
= g
->next
) {
2156 RockerOfDpaGroup
*group
= g
->value
;
2159 monitor_printf(mon
, "0x%08x", group
->id
);
2161 monitor_printf(mon
, " (type %s", group
->type
== 0 ? "L2 interface" :
2162 group
->type
== 1 ? "L2 rewrite" :
2163 group
->type
== 2 ? "L3 unicast" :
2164 group
->type
== 3 ? "L2 multicast" :
2165 group
->type
== 4 ? "L2 flood" :
2166 group
->type
== 5 ? "L3 interface" :
2167 group
->type
== 6 ? "L3 multicast" :
2168 group
->type
== 7 ? "L3 ECMP" :
2169 group
->type
== 8 ? "L2 overlay" :
2172 if (group
->has_vlan_id
) {
2173 monitor_printf(mon
, " vlan %d", group
->vlan_id
);
2176 if (group
->has_pport
) {
2177 monitor_printf(mon
, " pport %d", group
->pport
);
2180 if (group
->has_index
) {
2181 monitor_printf(mon
, " index %d", group
->index
);
2184 monitor_printf(mon
, ") -->");
2186 if (group
->has_set_vlan_id
&& group
->set_vlan_id
) {
2188 monitor_printf(mon
, " set vlan %d",
2189 group
->set_vlan_id
& VLAN_VID_MASK
);
2192 if (group
->has_set_eth_src
) {
2195 monitor_printf(mon
, " set");
2197 monitor_printf(mon
, " src %s", group
->set_eth_src
);
2200 if (group
->has_set_eth_dst
) {
2202 monitor_printf(mon
, " set");
2204 monitor_printf(mon
, " dst %s", group
->set_eth_dst
);
2207 if (group
->has_ttl_check
&& group
->ttl_check
) {
2208 monitor_printf(mon
, " check TTL");
2211 if (group
->has_group_id
&& group
->group_id
) {
2212 monitor_printf(mon
, " group id 0x%08x", group
->group_id
);
2215 if (group
->has_pop_vlan
&& group
->pop_vlan
) {
2216 monitor_printf(mon
, " pop vlan");
2219 if (group
->has_out_pport
) {
2220 monitor_printf(mon
, " out pport %d", group
->out_pport
);
2223 if (group
->has_group_ids
) {
2224 struct uint32List
*id
;
2226 monitor_printf(mon
, " groups [");
2227 for (id
= group
->group_ids
; id
; id
= id
->next
) {
2228 monitor_printf(mon
, "0x%08x", id
->value
);
2230 monitor_printf(mon
, ",");
2233 monitor_printf(mon
, "]");
2236 monitor_printf(mon
, "\n");
2239 qapi_free_RockerOfDpaGroupList(list
);
2242 void hmp_info_ramblock(Monitor
*mon
, const QDict
*qdict
)
2244 ram_block_dump(mon
);
2247 void hmp_info_vm_generation_id(Monitor
*mon
, const QDict
*qdict
)
2250 GuidInfo
*info
= qmp_query_vm_generation_id(&err
);
2252 monitor_printf(mon
, "%s\n", info
->guid
);
2254 hmp_handle_error(mon
, err
);
2255 qapi_free_GuidInfo(info
);
2258 void hmp_info_memory_size_summary(Monitor
*mon
, const QDict
*qdict
)
2261 MemoryInfo
*info
= qmp_query_memory_size_summary(&err
);
2263 monitor_printf(mon
, "base memory: %" PRIu64
"\n",
2266 if (info
->has_plugged_memory
) {
2267 monitor_printf(mon
, "plugged memory: %" PRIu64
"\n",
2268 info
->plugged_memory
);
2271 qapi_free_MemoryInfo(info
);
2273 hmp_handle_error(mon
, err
);