1 /*
2  * qemu_monitor.h: interaction with QEMU monitor console
3  *
4  * Copyright (C) 2006-2015 Red Hat, Inc.
5  * Copyright (C) 2006 Daniel P. Berrange
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library.  If not, see
19  * <http://www.gnu.org/licenses/>.
20  */
21 
22 #pragma once
23 
24 #include "internal.h"
25 
26 #include "domain_conf.h"
27 #include "virbitmap.h"
28 #include "virhash.h"
29 #include "virjson.h"
30 #include "virnetdev.h"
31 #include "device_conf.h"
32 #include "cpu/cpu.h"
33 #include "util/virgic.h"
34 #include "virenum.h"
35 
36 typedef struct _qemuMonitor qemuMonitor;
37 
38 typedef struct _qemuMonitorMessage qemuMonitorMessage;
39 struct _qemuMonitorMessage {
40     int txFD;
41 
42     const char *txBuffer;
43     int txOffset;
44     int txLength;
45 
46     /* Used by the text monitor reply / error */
47     char *rxBuffer;
48     int rxLength;
49     /* Used by the JSON monitor to hold reply / error */
50     void *rxObject;
51 
52     /* True if rxBuffer / rxObject are ready, or a
53      * fatal error occurred on the monitor channel
54      */
55     bool finished;
56 };
57 
58 typedef enum {
59     QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_NONE = 0,
60     QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_HYPERV,
61     QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_S390,
62 
63     QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_LAST
64 } qemuMonitorEventPanicInfoType;
65 
66 typedef struct _qemuMonitorEventPanicInfoHyperv qemuMonitorEventPanicInfoHyperv;
67 struct _qemuMonitorEventPanicInfoHyperv {
68     /* Hyper-V specific guest panic information (HV crash MSRs) */
69     unsigned long long arg1;
70     unsigned long long arg2;
71     unsigned long long arg3;
72     unsigned long long arg4;
73     unsigned long long arg5;
74 };
75 
76 typedef struct _qemuMonitorEventPanicInfoS390 qemuMonitorEventPanicInfoS390;
77 struct _qemuMonitorEventPanicInfoS390 {
78     /* S390 specific guest panic information */
79     int core;
80     unsigned long long psw_mask;
81     unsigned long long psw_addr;
82     char *reason;
83 };
84 
85 typedef struct _qemuMonitorEventPanicInfo qemuMonitorEventPanicInfo;
86 struct _qemuMonitorEventPanicInfo {
87     qemuMonitorEventPanicInfoType type;
88     union {
89         qemuMonitorEventPanicInfoHyperv hyperv;
90         qemuMonitorEventPanicInfoS390 s390;
91     } data;
92 };
93 
94 
95 typedef struct _qemuMonitorRdmaGidStatus qemuMonitorRdmaGidStatus;
96 struct _qemuMonitorRdmaGidStatus {
97     char *netdev;
98     bool gid_status;
99     unsigned long long subnet_prefix;
100     unsigned long long interface_id;
101 };
102 
103 
104 typedef struct _qemuMonitorMemoryDeviceSizeChange qemuMonitorMemoryDeviceSizeChange;
105 typedef qemuMonitorMemoryDeviceSizeChange *qemuMonitorMemoryDeviceSizeChangePtr;
106 struct _qemuMonitorMemoryDeviceSizeChange {
107     char *devAlias;
108     unsigned long long size;
109 };
110 
111 
112 typedef enum {
113     QEMU_MONITOR_ACTION_SHUTDOWN_KEEP, /* do not change the current setting */
114     QEMU_MONITOR_ACTION_SHUTDOWN_POWEROFF,
115     QEMU_MONITOR_ACTION_SHUTDOWN_PAUSE,
116 
117     QEMU_MONITOR_ACTION_SHUTDOWN_LAST
118 } qemuMonitorActionShutdown;
119 
120 
121 typedef enum {
122     QEMU_MONITOR_ACTION_REBOOT_KEEP, /* do not change the current setting */
123     QEMU_MONITOR_ACTION_REBOOT_RESET,
124     QEMU_MONITOR_ACTION_REBOOT_SHUTDOWN,
125 
126     QEMU_MONITOR_ACTION_REBOOT_LAST
127 } qemuMonitorActionReboot;
128 
129 
130 typedef enum {
131     QEMU_MONITOR_ACTION_WATCHDOG_KEEP, /* do not change the current setting */
132     QEMU_MONITOR_ACTION_WATCHDOG_RESET,
133     QEMU_MONITOR_ACTION_WATCHDOG_SHUTDOWN,
134     QEMU_MONITOR_ACTION_WATCHDOG_POWEROFF,
135     QEMU_MONITOR_ACTION_WATCHDOG_PAUSE,
136     QEMU_MONITOR_ACTION_WATCHDOG_DEBUG,
137     QEMU_MONITOR_ACTION_WATCHDOG_NONE,
138     QEMU_MONITOR_ACTION_WATCHDOG_INJECT_NMI,
139 
140     QEMU_MONITOR_ACTION_WATCHDOG_LAST
141 } qemuMonitorActionWatchdog;
142 
143 
144 typedef enum {
145     QEMU_MONITOR_ACTION_PANIC_KEEP, /* do not change the current setting */
146     QEMU_MONITOR_ACTION_PANIC_PAUSE,
147     QEMU_MONITOR_ACTION_PANIC_SHUTDOWN,
148     QEMU_MONITOR_ACTION_PANIC_NONE,
149 
150     QEMU_MONITOR_ACTION_PANIC_LAST
151 } qemuMonitorActionPanic;
152 
153 
154 typedef enum {
155     QEMU_MONITOR_JOB_TYPE_UNKNOWN, /* internal value, not exposed by qemu */
156     QEMU_MONITOR_JOB_TYPE_COMMIT,
157     QEMU_MONITOR_JOB_TYPE_STREAM,
158     QEMU_MONITOR_JOB_TYPE_MIRROR,
159     QEMU_MONITOR_JOB_TYPE_BACKUP,
160     QEMU_MONITOR_JOB_TYPE_CREATE,
161     QEMU_MONITOR_JOB_TYPE_LAST
162 } qemuMonitorJobType;
163 
164 VIR_ENUM_DECL(qemuMonitorJob);
165 
166 typedef enum {
167     QEMU_MONITOR_JOB_STATUS_UNKNOWN, /* internal value, not exposed by qemu */
168     QEMU_MONITOR_JOB_STATUS_CREATED,
169     QEMU_MONITOR_JOB_STATUS_RUNNING,
170     QEMU_MONITOR_JOB_STATUS_PAUSED,
171     QEMU_MONITOR_JOB_STATUS_READY,
172     QEMU_MONITOR_JOB_STATUS_STANDBY,
173     QEMU_MONITOR_JOB_STATUS_WAITING,
174     QEMU_MONITOR_JOB_STATUS_PENDING,
175     QEMU_MONITOR_JOB_STATUS_ABORTING,
176     QEMU_MONITOR_JOB_STATUS_CONCLUDED,
177     QEMU_MONITOR_JOB_STATUS_UNDEFINED, /* the job states below should not be visible outside of qemu */
178     QEMU_MONITOR_JOB_STATUS_NULL,
179     QEMU_MONITOR_JOB_STATUS_LAST
180 } qemuMonitorJobStatus;
181 
182 VIR_ENUM_DECL(qemuMonitorJobStatus);
183 
184 typedef struct _qemuMonitorJobInfo qemuMonitorJobInfo;
185 struct _qemuMonitorJobInfo {
186     char *id;
187     qemuMonitorJobType type;
188     qemuMonitorJobStatus status;
189     char *error;
190     unsigned long long progressCurrent;
191     unsigned long long progressTotal;
192 };
193 
194 
195 char *qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfo *info);
196 void qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfo *info);
197 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorEventPanicInfo, qemuMonitorEventPanicInfoFree);
198 void qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatus *info);
199 void qemuMonitorMemoryDeviceSizeChangeFree(qemuMonitorMemoryDeviceSizeChange *info);
200 
201 typedef void (*qemuMonitorDestroyCallback)(qemuMonitor *mon,
202                                            virDomainObj *vm,
203                                            void *opaque);
204 typedef void (*qemuMonitorEofNotifyCallback)(qemuMonitor *mon,
205                                              virDomainObj *vm,
206                                              void *opaque);
207 typedef void (*qemuMonitorErrorNotifyCallback)(qemuMonitor *mon,
208                                                virDomainObj *vm,
209                                                void *opaque);
210 typedef void (*qemuMonitorDomainEventCallback)(qemuMonitor *mon,
211                                                virDomainObj *vm,
212                                                const char *event,
213                                                long long seconds,
214                                                unsigned int micros,
215                                                const char *details,
216                                                void *opaque);
217 typedef void (*qemuMonitorDomainShutdownCallback)(qemuMonitor *mon,
218                                                   virDomainObj *vm,
219                                                   virTristateBool guest,
220                                                   void *opaque);
221 typedef void (*qemuMonitorDomainResetCallback)(qemuMonitor *mon,
222                                                virDomainObj *vm,
223                                                void *opaque);
224 typedef void (*qemuMonitorDomainStopCallback)(qemuMonitor *mon,
225                                               virDomainObj *vm,
226                                               void *opaque);
227 typedef void (*qemuMonitorDomainResumeCallback)(qemuMonitor *mon,
228                                                 virDomainObj *vm,
229                                                 void *opaque);
230 typedef void (*qemuMonitorDomainRTCChangeCallback)(qemuMonitor *mon,
231                                                    virDomainObj *vm,
232                                                    long long offset,
233                                                    void *opaque);
234 typedef void (*qemuMonitorDomainWatchdogCallback)(qemuMonitor *mon,
235                                                   virDomainObj *vm,
236                                                   int action,
237                                                   void *opaque);
238 typedef void (*qemuMonitorDomainIOErrorCallback)(qemuMonitor *mon,
239                                                  virDomainObj *vm,
240                                                  const char *diskAlias,
241                                                  const char *nodename,
242                                                  int action,
243                                                  const char *reason,
244                                                  void *opaque);
245 typedef void (*qemuMonitorDomainGraphicsCallback)(qemuMonitor *mon,
246                                                   virDomainObj *vm,
247                                                   int phase,
248                                                   int localFamily,
249                                                   const char *localNode,
250                                                   const char *localService,
251                                                   int remoteFamily,
252                                                   const char *remoteNode,
253                                                   const char *remoteService,
254                                                   const char *authScheme,
255                                                   const char *x509dname,
256                                                   const char *saslUsername,
257                                                   void *opaque);
258 typedef void (*qemuMonitorDomainBlockJobCallback)(qemuMonitor *mon,
259                                                   virDomainObj *vm,
260                                                   const char *diskAlias,
261                                                   int type,
262                                                   int status,
263                                                   const char *error,
264                                                   void *opaque);
265 typedef void (*qemuMonitorDomainJobStatusChangeCallback)(qemuMonitor *mon,
266                                                          virDomainObj *vm,
267                                                          const char *jobname,
268                                                          int status,
269                                                          void *opaque);
270 typedef void (*qemuMonitorDomainTrayChangeCallback)(qemuMonitor *mon,
271                                                     virDomainObj *vm,
272                                                     const char *devAlias,
273                                                     const char *devid,
274                                                     int reason,
275                                                     void *opaque);
276 typedef void (*qemuMonitorDomainPMWakeupCallback)(qemuMonitor *mon,
277                                                   virDomainObj *vm,
278                                                   void *opaque);
279 typedef void (*qemuMonitorDomainPMSuspendCallback)(qemuMonitor *mon,
280                                                    virDomainObj *vm,
281                                                    void *opaque);
282 typedef void (*qemuMonitorDomainBalloonChangeCallback)(qemuMonitor *mon,
283                                                        virDomainObj *vm,
284                                                        unsigned long long actual,
285                                                        void *opaque);
286 typedef void (*qemuMonitorDomainPMSuspendDiskCallback)(qemuMonitor *mon,
287                                                        virDomainObj *vm,
288                                                        void *opaque);
289 typedef void (*qemuMonitorDomainGuestPanicCallback)(qemuMonitor *mon,
290                                                     virDomainObj *vm,
291                                                     qemuMonitorEventPanicInfo *info,
292                                                     void *opaque);
293 typedef void (*qemuMonitorDomainDeviceDeletedCallback)(qemuMonitor *mon,
294                                                        virDomainObj *vm,
295                                                        const char *devAlias,
296                                                        void *opaque);
297 typedef void (*qemuMonitorDomainDeviceUnplugErrCallback)(qemuMonitor *mon,
298                                                          virDomainObj *vm,
299                                                          const char *devPath,
300                                                          const char *devAlias,
301                                                          void *opaque);
302 typedef void (*qemuMonitorDomainNicRxFilterChangedCallback)(qemuMonitor *mon,
303                                                             virDomainObj *vm,
304                                                             const char *devAlias,
305                                                             void *opaque);
306 
307 typedef void (*qemuMonitorDomainSerialChangeCallback)(qemuMonitor *mon,
308                                                       virDomainObj *vm,
309                                                       const char *devAlias,
310                                                       bool connected,
311                                                       void *opaque);
312 
313 typedef void (*qemuMonitorDomainSpiceMigratedCallback)(qemuMonitor *mon,
314                                                        virDomainObj *vm,
315                                                        void *opaque);
316 
317 typedef void (*qemuMonitorDomainMigrationStatusCallback)(qemuMonitor *mon,
318                                                          virDomainObj *vm,
319                                                          int status,
320                                                          void *opaque);
321 
322 typedef void (*qemuMonitorDomainMigrationPassCallback)(qemuMonitor *mon,
323                                                        virDomainObj *vm,
324                                                        int pass,
325                                                        void *opaque);
326 
327 typedef void (*qemuMonitorDomainAcpiOstInfoCallback)(qemuMonitor *mon,
328                                                      virDomainObj *vm,
329                                                      const char *alias,
330                                                      const char *slotType,
331                                                      const char *slot,
332                                                      unsigned int source,
333                                                      unsigned int status,
334                                                      void *opaque);
335 
336 
337 typedef void (*qemuMonitorDomainBlockThresholdCallback)(qemuMonitor *mon,
338                                                         virDomainObj *vm,
339                                                         const char *nodename,
340                                                         unsigned long long threshold,
341                                                         unsigned long long excess,
342                                                         void *opaque);
343 
344 
345 typedef enum {
346     QEMU_MONITOR_DUMP_STATUS_NONE,
347     QEMU_MONITOR_DUMP_STATUS_ACTIVE,
348     QEMU_MONITOR_DUMP_STATUS_COMPLETED,
349     QEMU_MONITOR_DUMP_STATUS_FAILED,
350 
351     QEMU_MONITOR_DUMP_STATUS_LAST,
352 } qemuMonitorDumpStatus;
353 
354 VIR_ENUM_DECL(qemuMonitorDumpStatus);
355 
356 typedef struct _qemuMonitorDumpStats qemuMonitorDumpStats;
357 struct _qemuMonitorDumpStats {
358     int status; /* qemuMonitorDumpStatus */
359     unsigned long long completed; /* bytes written */
360     unsigned long long total; /* total bytes to be written */
361 };
362 
363 typedef void (*qemuMonitorDomainDumpCompletedCallback)(qemuMonitor *mon,
364                                                        virDomainObj *vm,
365                                                        int status,
366                                                        qemuMonitorDumpStats *stats,
367                                                        const char *error,
368                                                        void *opaque);
369 
370 typedef void (*qemuMonitorDomainPRManagerStatusChangedCallback)(qemuMonitor *mon,
371                                                                 virDomainObj *vm,
372                                                                 const char *prManager,
373                                                                 bool connected,
374                                                                 void *opaque);
375 
376 typedef void (*qemuMonitorDomainRdmaGidStatusChangedCallback)(qemuMonitor *mon,
377                                                               virDomainObj *vm,
378                                                               const char *netdev,
379                                                               bool gid_status,
380                                                               unsigned long long subnet_prefix,
381                                                               unsigned long long interface_id,
382                                                               void *opaque);
383 
384 typedef void (*qemuMonitorDomainGuestCrashloadedCallback)(qemuMonitor *mon,
385                                                           virDomainObj *vm,
386                                                           void *opaque);
387 
388 typedef enum {
389     QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_HYPERVISOR,
390     QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_GUEST,
391 
392     QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_LAST
393 } qemuMonitorMemoryFailureRecipient;
394 
395 VIR_ENUM_DECL(qemuMonitorMemoryFailureRecipient);
396 
397 typedef enum {
398     QEMU_MONITOR_MEMORY_FAILURE_ACTION_IGNORE,
399     QEMU_MONITOR_MEMORY_FAILURE_ACTION_INJECT,
400     QEMU_MONITOR_MEMORY_FAILURE_ACTION_FATAL,
401     QEMU_MONITOR_MEMORY_FAILURE_ACTION_RESET,
402 
403     QEMU_MONITOR_MEMORY_FAILURE_ACTION_LAST
404 } qemuMonitorMemoryFailureAction;
405 
406 VIR_ENUM_DECL(qemuMonitorMemoryFailureAction);
407 
408 typedef struct _qemuMonitorEventMemoryFailure qemuMonitorEventMemoryFailure;
409 struct _qemuMonitorEventMemoryFailure {
410     qemuMonitorMemoryFailureRecipient recipient;
411     qemuMonitorMemoryFailureAction action;
412     bool action_required;
413     bool recursive;
414 };
415 
416 typedef void (*qemuMonitorDomainMemoryFailureCallback)(qemuMonitor *mon,
417                                                        virDomainObj *vm,
418                                                        qemuMonitorEventMemoryFailure *mfp,
419                                                        void *opaque);
420 
421 typedef void (*qemuMonitorDomainMemoryDeviceSizeChange)(qemuMonitor *mon,
422                                                         virDomainObj *vm,
423                                                         const char *alias,
424                                                         unsigned long long size,
425                                                         void *opaque);
426 
427 typedef struct _qemuMonitorCallbacks qemuMonitorCallbacks;
428 struct _qemuMonitorCallbacks {
429     qemuMonitorEofNotifyCallback eofNotify;
430     qemuMonitorErrorNotifyCallback errorNotify;
431     qemuMonitorDomainEventCallback domainEvent;
432     qemuMonitorDomainShutdownCallback domainShutdown;
433     qemuMonitorDomainResetCallback domainReset;
434     qemuMonitorDomainStopCallback domainStop;
435     qemuMonitorDomainResumeCallback domainResume;
436     qemuMonitorDomainRTCChangeCallback domainRTCChange;
437     qemuMonitorDomainWatchdogCallback domainWatchdog;
438     qemuMonitorDomainIOErrorCallback domainIOError;
439     qemuMonitorDomainGraphicsCallback domainGraphics;
440     qemuMonitorDomainBlockJobCallback domainBlockJob;
441     qemuMonitorDomainJobStatusChangeCallback jobStatusChange;
442     qemuMonitorDomainTrayChangeCallback domainTrayChange;
443     qemuMonitorDomainPMWakeupCallback domainPMWakeup;
444     qemuMonitorDomainPMSuspendCallback domainPMSuspend;
445     qemuMonitorDomainBalloonChangeCallback domainBalloonChange;
446     qemuMonitorDomainPMSuspendDiskCallback domainPMSuspendDisk;
447     qemuMonitorDomainGuestPanicCallback domainGuestPanic;
448     qemuMonitorDomainDeviceDeletedCallback domainDeviceDeleted;
449     qemuMonitorDomainNicRxFilterChangedCallback domainNicRxFilterChanged;
450     qemuMonitorDomainSerialChangeCallback domainSerialChange;
451     qemuMonitorDomainSpiceMigratedCallback domainSpiceMigrated;
452     qemuMonitorDomainMigrationStatusCallback domainMigrationStatus;
453     qemuMonitorDomainMigrationPassCallback domainMigrationPass;
454     qemuMonitorDomainAcpiOstInfoCallback domainAcpiOstInfo;
455     qemuMonitorDomainBlockThresholdCallback domainBlockThreshold;
456     qemuMonitorDomainDumpCompletedCallback domainDumpCompleted;
457     qemuMonitorDomainPRManagerStatusChangedCallback domainPRManagerStatusChanged;
458     qemuMonitorDomainRdmaGidStatusChangedCallback domainRdmaGidStatusChanged;
459     qemuMonitorDomainGuestCrashloadedCallback domainGuestCrashloaded;
460     qemuMonitorDomainMemoryFailureCallback domainMemoryFailure;
461     qemuMonitorDomainMemoryDeviceSizeChange domainMemoryDeviceSizeChange;
462     qemuMonitorDomainDeviceUnplugErrCallback domainDeviceUnplugError;
463 };
464 
465 qemuMonitor *qemuMonitorOpen(virDomainObj *vm,
466                                virDomainChrSourceDef *config,
467                                bool retry,
468                                unsigned long long timeout,
469                                GMainContext *context,
470                                qemuMonitorCallbacks *cb,
471                                void *opaque)
472     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5);
473 
474 void qemuMonitorWatchDispose(void);
475 bool qemuMonitorWasDisposed(void);
476 
477 void qemuMonitorRegister(qemuMonitor *mon)
478     ATTRIBUTE_NONNULL(1);
479 void qemuMonitorUnregister(qemuMonitor *mon)
480     ATTRIBUTE_NONNULL(1);
481 void qemuMonitorClose(qemuMonitor *mon);
482 
483 virErrorPtr qemuMonitorLastError(qemuMonitor *mon);
484 
485 int qemuMonitorSetCapabilities(qemuMonitor *mon);
486 
487 int qemuMonitorSetLink(qemuMonitor *mon,
488                        const char *name,
489                        virDomainNetInterfaceLinkState state)
490     ATTRIBUTE_NONNULL(2);
491 
492 /* These APIs are for use by the internal Text/JSON monitor impl code only */
493 char *qemuMonitorNextCommandID(qemuMonitor *mon);
494 int qemuMonitorSend(qemuMonitor *mon,
495                     qemuMonitorMessage *msg) G_GNUC_NO_INLINE;
496 int qemuMonitorUpdateVideoMemorySize(qemuMonitor *mon,
497                                      virDomainVideoDef *video,
498                                      const char *videoName)
499     ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
500 int qemuMonitorUpdateVideoVram64Size(qemuMonitor *mon,
501                                      virDomainVideoDef *video,
502                                      const char *videoName)
503     ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
504 
505 void qemuMonitorEmitEvent(qemuMonitor *mon, const char *event,
506                           long long seconds, unsigned int micros,
507                           const char *details);
508 void qemuMonitorEmitShutdown(qemuMonitor *mon, virTristateBool guest);
509 void qemuMonitorEmitReset(qemuMonitor *mon);
510 void qemuMonitorEmitStop(qemuMonitor *mon);
511 void qemuMonitorEmitResume(qemuMonitor *mon);
512 void qemuMonitorEmitRTCChange(qemuMonitor *mon, long long offset);
513 void qemuMonitorEmitWatchdog(qemuMonitor *mon, int action);
514 void qemuMonitorEmitIOError(qemuMonitor *mon,
515                             const char *diskAlias,
516                             const char *nodename,
517                             int action,
518                             const char *reason);
519 void qemuMonitorEmitGraphics(qemuMonitor *mon,
520                              int phase,
521                              int localFamily,
522                              const char *localNode,
523                              const char *localService,
524                              int remoteFamily,
525                              const char *remoteNode,
526                              const char *remoteService,
527                              const char *authScheme,
528                              const char *x509dname,
529                              const char *saslUsername);
530 void qemuMonitorEmitTrayChange(qemuMonitor *mon,
531                                const char *devAlias,
532                                const char *devid,
533                                int reason);
534 void qemuMonitorEmitPMWakeup(qemuMonitor *mon);
535 void qemuMonitorEmitPMSuspend(qemuMonitor *mon);
536 void qemuMonitorEmitBlockJob(qemuMonitor *mon,
537                              const char *diskAlias,
538                              int type,
539                              int status,
540                              const char *error);
541 void qemuMonitorEmitJobStatusChange(qemuMonitor *mon,
542                                     const char *jobname,
543                                     qemuMonitorJobStatus status);
544 void qemuMonitorEmitBalloonChange(qemuMonitor *mon,
545                                   unsigned long long actual);
546 void qemuMonitorEmitPMSuspendDisk(qemuMonitor *mon);
547 void qemuMonitorEmitGuestPanic(qemuMonitor *mon,
548                                qemuMonitorEventPanicInfo *info);
549 void qemuMonitorEmitDeviceDeleted(qemuMonitor *mon,
550                                   const char *devAlias);
551 void qemuMonitorEmitDeviceUnplugErr(qemuMonitor *mon,
552                                     const char *devPath,
553                                     const char *devAlias);
554 void qemuMonitorEmitNicRxFilterChanged(qemuMonitor *mon,
555                                        const char *devAlias);
556 void qemuMonitorEmitSerialChange(qemuMonitor *mon,
557                                  const char *devAlias,
558                                  bool connected);
559 void qemuMonitorEmitSpiceMigrated(qemuMonitor *mon);
560 
561 void qemuMonitorEmitMemoryDeviceSizeChange(qemuMonitor *mon,
562                                            const char *devAlias,
563                                            unsigned long long size);
564 
565 void qemuMonitorEmitMemoryFailure(qemuMonitor *mon,
566                                   qemuMonitorEventMemoryFailure *mfp);
567 
568 void qemuMonitorEmitMigrationStatus(qemuMonitor *mon,
569                                     int status);
570 void qemuMonitorEmitMigrationPass(qemuMonitor *mon,
571                                   int pass);
572 
573 void qemuMonitorEmitAcpiOstInfo(qemuMonitor *mon,
574                                 const char *alias,
575                                 const char *slotType,
576                                 const char *slot,
577                                 unsigned int source,
578                                 unsigned int status);
579 
580 void qemuMonitorEmitBlockThreshold(qemuMonitor *mon,
581                                    const char *nodename,
582                                    unsigned long long threshold,
583                                    unsigned long long excess);
584 
585 void qemuMonitorEmitDumpCompleted(qemuMonitor *mon,
586                                   int status,
587                                   qemuMonitorDumpStats *stats,
588                                   const char *error);
589 
590 void qemuMonitorEmitPRManagerStatusChanged(qemuMonitor *mon,
591                                            const char *prManager,
592                                            bool connected);
593 
594 void qemuMonitorEmitRdmaGidStatusChanged(qemuMonitor *mon,
595                                          const char *netdev,
596                                          bool gid_status,
597                                          unsigned long long subnet_prefix,
598                                          unsigned long long interface_id);
599 
600 void qemuMonitorEmitGuestCrashloaded(qemuMonitor *mon);
601 
602 int qemuMonitorStartCPUs(qemuMonitor *mon);
603 int qemuMonitorStopCPUs(qemuMonitor *mon);
604 
605 typedef enum {
606     QEMU_MONITOR_VM_STATUS_DEBUG,
607     QEMU_MONITOR_VM_STATUS_INMIGRATE,
608     QEMU_MONITOR_VM_STATUS_INTERNAL_ERROR,
609     QEMU_MONITOR_VM_STATUS_IO_ERROR,
610     QEMU_MONITOR_VM_STATUS_PAUSED,
611     QEMU_MONITOR_VM_STATUS_POSTMIGRATE,
612     QEMU_MONITOR_VM_STATUS_PRELAUNCH,
613     QEMU_MONITOR_VM_STATUS_FINISH_MIGRATE,
614     QEMU_MONITOR_VM_STATUS_RESTORE_VM,
615     QEMU_MONITOR_VM_STATUS_RUNNING,
616     QEMU_MONITOR_VM_STATUS_SAVE_VM,
617     QEMU_MONITOR_VM_STATUS_SHUTDOWN,
618     QEMU_MONITOR_VM_STATUS_WATCHDOG,
619     QEMU_MONITOR_VM_STATUS_GUEST_PANICKED,
620 
621     QEMU_MONITOR_VM_STATUS_LAST
622 } qemuMonitorVMStatus;
623 VIR_ENUM_DECL(qemuMonitorVMStatus);
624 int qemuMonitorVMStatusToPausedReason(const char *status);
625 
626 int qemuMonitorCheck(qemuMonitor *mon);
627 int qemuMonitorGetStatus(qemuMonitor *mon,
628                          bool *running,
629                          virDomainPausedReason *reason)
630     ATTRIBUTE_NONNULL(2);
631 
632 int qemuMonitorSystemReset(qemuMonitor *mon);
633 int qemuMonitorSystemPowerdown(qemuMonitor *mon);
634 
635 struct qemuMonitorQueryCpusEntry {
636     int qemu_id; /* id of the cpu as reported by qemu */
637     pid_t tid;
638     char *qom_path;
639     bool halted;
640 };
641 void qemuMonitorQueryCpusFree(struct qemuMonitorQueryCpusEntry *entries,
642                               size_t nentries);
643 
644 
645 struct qemuMonitorQueryHotpluggableCpusEntry {
646     char *type; /* name of the cpu to use with device_add */
647     unsigned int vcpus; /* count of virtual cpus in the guest this entry adds */
648     char *qom_path; /* full device qom path only present for online cpus */
649     char *alias; /* device alias, may be NULL for non-hotpluggable entities */
650 
651     /* verbatim copy of the JSON data representing the CPU which must be used for hotplug */
652     virJSONValue *props;
653 
654     /* topology information -1 if qemu didn't report given parameter */
655     int node_id;
656     int socket_id;
657     int die_id;
658     int core_id;
659     int thread_id;
660 
661     /* internal data */
662     int enable_id;
663 };
664 void qemuMonitorQueryHotpluggableCpusFree(struct qemuMonitorQueryHotpluggableCpusEntry *entries,
665                                           size_t nentries);
666 
667 
668 struct _qemuMonitorCPUInfo {
669     pid_t tid;
670     int id; /* order of enabling of the given cpu */
671     int qemu_id; /* identifier of the cpu as reported by query-cpus */
672 
673     /* state data */
674     bool online;
675     bool hotpluggable;
676 
677     /* topology info for hotplug purposes. Hotplug of given vcpu impossible if
678      * all entries are -1 */
679     int socket_id;
680     int die_id;
681     int core_id;
682     int thread_id;
683     int node_id;
684     unsigned int vcpus; /* number of vcpus added if given entry is hotplugged */
685 
686     /* name of the qemu type to add in case of hotplug */
687     char *type;
688 
689     /* verbatim copy of the returned data from qemu which should be used when plugging */
690     virJSONValue *props;
691 
692     /* alias of an hotpluggable entry. Entries with alias can be hot-unplugged */
693     char *alias;
694 
695     /* internal for use in the matching code */
696     char *qom_path;
697 
698     bool halted;
699 };
700 typedef struct _qemuMonitorCPUInfo qemuMonitorCPUInfo;
701 
702 void qemuMonitorCPUInfoFree(qemuMonitorCPUInfo *list,
703                             size_t nitems);
704 int qemuMonitorGetCPUInfo(qemuMonitor *mon,
705                           qemuMonitorCPUInfo **vcpus,
706                           size_t maxvcpus,
707                           bool hotplug,
708                           bool fast);
709 virBitmap *qemuMonitorGetCpuHalted(qemuMonitor *mon,
710                                      size_t maxvcpus,
711                                      bool fast);
712 
713 int qemuMonitorGetBalloonInfo(qemuMonitor *mon,
714                               unsigned long long *currmem);
715 int qemuMonitorGetMemoryStats(qemuMonitor *mon,
716                               virDomainMemballoonDef *balloon,
717                               virDomainMemoryStatPtr stats,
718                               unsigned int nr_stats);
719 int qemuMonitorSetMemoryStatsPeriod(qemuMonitor *mon,
720                                     virDomainMemballoonDef *balloon,
721                                     int period);
722 
723 int qemuMonitorBlockIOStatusToError(const char *status);
724 GHashTable *qemuMonitorGetBlockInfo(qemuMonitor *mon);
725 
726 virJSONValue *qemuMonitorQueryBlockstats(qemuMonitor *mon);
727 
728 typedef struct _qemuBlockStats qemuBlockStats;
729 struct _qemuBlockStats {
730     unsigned long long rd_req;
731     unsigned long long rd_bytes;
732     unsigned long long wr_req;
733     unsigned long long wr_bytes;
734     unsigned long long rd_total_times;
735     unsigned long long wr_total_times;
736     unsigned long long flush_req;
737     unsigned long long flush_total_times;
738     unsigned long long capacity;
739     unsigned long long physical;
740 
741     /* value of wr_highest_offset is valid if it's non 0 or
742      * if wr_highest_offset_valid is true */
743     unsigned long long wr_highest_offset;
744     bool wr_highest_offset_valid;
745 
746     /* write_threshold is valid only if it's non-zero, conforming to qemu semantics */
747     unsigned long long write_threshold;
748 };
749 
750 int qemuMonitorGetAllBlockStatsInfo(qemuMonitor *mon,
751                                     GHashTable **ret_stats)
752     ATTRIBUTE_NONNULL(2);
753 
754 int qemuMonitorBlockStatsUpdateCapacity(qemuMonitor *mon,
755                                         GHashTable *stats)
756     ATTRIBUTE_NONNULL(2);
757 
758 int qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitor *mon,
759                                                 GHashTable *stats)
760     ATTRIBUTE_NONNULL(2);
761 
762 typedef struct _qemuBlockNamedNodeDataBitmap qemuBlockNamedNodeDataBitmap;
763 struct _qemuBlockNamedNodeDataBitmap {
764     char *name;
765     bool recording;
766     bool busy;
767     bool persistent;
768     bool inconsistent;
769 
770     unsigned long long dirtybytes;
771     unsigned long long granularity;
772 };
773 
774 typedef struct _qemuBlockNamedNodeData qemuBlockNamedNodeData;
775 struct _qemuBlockNamedNodeData {
776     unsigned long long capacity;
777     unsigned long long physical;
778 
779     qemuBlockNamedNodeDataBitmap **bitmaps;
780     size_t nbitmaps;
781 
782     /* the cluster size of the image is valid only when > 0 */
783     unsigned long long clusterSize;
784 
785     /* image version */
786     bool qcow2v2;
787 };
788 
789 GHashTable *
790 qemuMonitorBlockGetNamedNodeData(qemuMonitor *mon,
791                                  bool supports_flat);
792 
793 int qemuMonitorBlockResize(qemuMonitor *mon,
794                            const char *device,
795                            const char *nodename,
796                            unsigned long long size);
797 int qemuMonitorSetPassword(qemuMonitor *mon,
798                            int type,
799                            const char *password,
800                            const char *action_if_connected);
801 int qemuMonitorExpirePassword(qemuMonitor *mon,
802                               int type,
803                               const char *expire_time);
804 int qemuMonitorSetBalloon(qemuMonitor *mon,
805                           unsigned long long newmem);
806 
807 int qemuMonitorEjectMedia(qemuMonitor *mon,
808                           const char *dev_name,
809                           bool force);
810 int qemuMonitorChangeMedia(qemuMonitor *mon,
811                            const char *dev_name,
812                            const char *newmedia,
813                            const char *format);
814 
815 
816 int qemuMonitorSaveVirtualMemory(qemuMonitor *mon,
817                                  unsigned long long offset,
818                                  unsigned long long length,
819                                  const char *path);
820 int qemuMonitorSavePhysicalMemory(qemuMonitor *mon,
821                                   unsigned long long offset,
822                                   unsigned long long length,
823                                   const char *path);
824 
825 int qemuMonitorSetDBusVMStateIdList(qemuMonitor *mon,
826                                     GSList *list);
827 
828 int qemuMonitorSetMigrationSpeed(qemuMonitor *mon,
829                                  unsigned long bandwidth);
830 
831 int qemuMonitorSetMigrationDowntime(qemuMonitor *mon,
832                                     unsigned long long downtime);
833 
834 int qemuMonitorGetMigrationCacheSize(qemuMonitor *mon,
835                                      unsigned long long *cacheSize);
836 int qemuMonitorSetMigrationCacheSize(qemuMonitor *mon,
837                                      unsigned long long cacheSize);
838 
839 int qemuMonitorGetMigrationParams(qemuMonitor *mon,
840                                   virJSONValue **params);
841 int qemuMonitorSetMigrationParams(qemuMonitor *mon,
842                                   virJSONValue **params);
843 
844 typedef enum {
845     QEMU_MONITOR_MIGRATION_STATUS_INACTIVE,
846     QEMU_MONITOR_MIGRATION_STATUS_SETUP,
847     QEMU_MONITOR_MIGRATION_STATUS_ACTIVE,
848     QEMU_MONITOR_MIGRATION_STATUS_PRE_SWITCHOVER,
849     QEMU_MONITOR_MIGRATION_STATUS_DEVICE,
850     QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY,
851     QEMU_MONITOR_MIGRATION_STATUS_COMPLETED,
852     QEMU_MONITOR_MIGRATION_STATUS_ERROR,
853     QEMU_MONITOR_MIGRATION_STATUS_CANCELLING,
854     QEMU_MONITOR_MIGRATION_STATUS_CANCELLED,
855     QEMU_MONITOR_MIGRATION_STATUS_WAIT_UNPLUG,
856 
857     QEMU_MONITOR_MIGRATION_STATUS_LAST
858 } qemuMonitorMigrationStatus;
859 
860 VIR_ENUM_DECL(qemuMonitorMigrationStatus);
861 
862 typedef struct _qemuMonitorMigrationStats qemuMonitorMigrationStats;
863 struct _qemuMonitorMigrationStats {
864     int status; /* qemuMonitorMigrationStatus */
865     unsigned long long total_time;
866     /* total or expected depending on status */
867     bool downtime_set;
868     unsigned long long downtime;
869     /*
870      * Duration of the QEMU 'setup' state.
871      * for RDMA, this may be on the order of several seconds
872      * if pinning support is requested before the migration begins.
873      */
874     bool setup_time_set;
875     unsigned long long setup_time;
876 
877     unsigned long long ram_transferred;
878     unsigned long long ram_remaining;
879     unsigned long long ram_total;
880     unsigned long long ram_bps;
881     bool ram_duplicate_set;
882     unsigned long long ram_duplicate;
883     unsigned long long ram_normal;
884     unsigned long long ram_normal_bytes;
885     unsigned long long ram_dirty_rate;
886     unsigned long long ram_page_size;
887     unsigned long long ram_iteration;
888     unsigned long long ram_postcopy_reqs;
889 
890     unsigned long long disk_transferred;
891     unsigned long long disk_remaining;
892     unsigned long long disk_total;
893     unsigned long long disk_bps;
894 
895     bool xbzrle_set;
896     unsigned long long xbzrle_cache_size;
897     unsigned long long xbzrle_bytes;
898     unsigned long long xbzrle_pages;
899     unsigned long long xbzrle_cache_miss;
900     unsigned long long xbzrle_overflow;
901 
902     int cpu_throttle_percentage;
903 };
904 
905 int qemuMonitorGetMigrationStats(qemuMonitor *mon,
906                                  qemuMonitorMigrationStats *stats,
907                                  char **error);
908 
909 int qemuMonitorGetMigrationCapabilities(qemuMonitor *mon,
910                                         char ***capabilities);
911 int qemuMonitorSetMigrationCapabilities(qemuMonitor *mon,
912                                         virJSONValue **caps);
913 
914 int qemuMonitorGetGICCapabilities(qemuMonitor *mon,
915                                   virGICCapability **capabilities);
916 
917 int qemuMonitorGetSEVCapabilities(qemuMonitor *mon,
918                                   virSEVCapability **capabilities);
919 
920 typedef enum {
921   QEMU_MONITOR_MIGRATE_BACKGROUND       = 1 << 0,
922   QEMU_MONITOR_MIGRATE_NON_SHARED_DISK  = 1 << 1, /* migration with non-shared storage with full disk copy */
923   QEMU_MONITOR_MIGRATE_NON_SHARED_INC   = 1 << 2, /* migration with non-shared storage with incremental copy */
924   QEMU_MONITOR_MIGRATION_FLAGS_LAST
925 } QEMU_MONITOR_MIGRATE;
926 
927 int qemuMonitorMigrateToFd(qemuMonitor *mon,
928                            unsigned int flags,
929                            int fd);
930 
931 int qemuMonitorMigrateToHost(qemuMonitor *mon,
932                              unsigned int flags,
933                              const char *protocol,
934                              const char *hostname,
935                              int port);
936 
937 int qemuMonitorMigrateToSocket(qemuMonitor *mon,
938                                unsigned int flags,
939                                const char *socketPath);
940 
941 int qemuMonitorMigrateCancel(qemuMonitor *mon);
942 
943 int qemuMonitorGetDumpGuestMemoryCapability(qemuMonitor *mon,
944                                             const char *capability);
945 
946 int qemuMonitorQueryDump(qemuMonitor *mon,
947                          qemuMonitorDumpStats *stats);
948 
949 int qemuMonitorDumpToFd(qemuMonitor *mon,
950                         int fd,
951                         const char *dumpformat,
952                         bool detach);
953 
954 int qemuMonitorGraphicsRelocate(qemuMonitor *mon,
955                                 int type,
956                                 const char *hostname,
957                                 int port,
958                                 int tlsPort,
959                                 const char *tlsSubject);
960 
961 typedef struct _qemuMonitorAddFdInfo qemuMonitorAddFdInfo;
962 struct _qemuMonitorAddFdInfo {
963     int fd;
964     int fdset;
965 };
966 int
967 qemuMonitorAddFileHandleToSet(qemuMonitor *mon,
968                               int fd,
969                               int fdset,
970                               const char *opaque,
971                               qemuMonitorAddFdInfo *info);
972 
973 int
974 qemuMonitorRemoveFdset(qemuMonitor *mon,
975                        int fdset);
976 
977 typedef struct _qemuMonitorFdsetFdInfo qemuMonitorFdsetFdInfo;
978 struct _qemuMonitorFdsetFdInfo {
979     int fd;
980     char *opaque;
981 };
982 typedef struct _qemuMonitorFdsetInfo qemuMonitorFdsetInfo;
983 struct _qemuMonitorFdsetInfo {
984     int id;
985     qemuMonitorFdsetFdInfo *fds;
986     int nfds;
987 };
988 typedef struct _qemuMonitorFdsets qemuMonitorFdsets;
989 struct _qemuMonitorFdsets {
990     qemuMonitorFdsetInfo *fdsets;
991     int nfdsets;
992 };
993 void qemuMonitorFdsetsFree(qemuMonitorFdsets *fdsets);
994 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorFdsets, qemuMonitorFdsetsFree);
995 int qemuMonitorQueryFdsets(qemuMonitor *mon,
996                            qemuMonitorFdsets **fdsets);
997 
998 int qemuMonitorSendFileHandle(qemuMonitor *mon,
999                               const char *fdname,
1000                               int fd);
1001 
1002 /* This function preserves previous error and only set their own
1003  * error if no error was set before.
1004  */
1005 int qemuMonitorCloseFileHandle(qemuMonitor *mon,
1006                                const char *fdname);
1007 
1008 int qemuMonitorAddNetdev(qemuMonitor *mon,
1009                          virJSONValue **props,
1010                          int *tapfd, char **tapfdName, int tapfdSize,
1011                          int *vhostfd, char **vhostfdName, int vhostfdSize,
1012                          int slirpfd, char *slirpfdName);
1013 
1014 int qemuMonitorRemoveNetdev(qemuMonitor *mon,
1015                             const char *alias);
1016 
1017 int qemuMonitorQueryRxFilter(qemuMonitor *mon, const char *alias,
1018                              virNetDevRxFilter **filter);
1019 
1020 typedef struct _qemuMonitorChardevInfo qemuMonitorChardevInfo;
1021 struct _qemuMonitorChardevInfo {
1022     char *ptyPath;
1023     virDomainChrDeviceState state;
1024 };
1025 void qemuMonitorChardevInfoFree(void *data);
1026 int qemuMonitorGetChardevInfo(qemuMonitor *mon,
1027                               GHashTable **retinfo);
1028 
1029 int qemuMonitorAttachPCIDiskController(qemuMonitor *mon,
1030                                        const char *bus,
1031                                        virPCIDeviceAddress *guestAddr);
1032 
1033 int qemuMonitorAddDeviceProps(qemuMonitor *mon,
1034                               virJSONValue **props);
1035 
1036 int qemuMonitorDelDevice(qemuMonitor *mon,
1037                          const char *devalias);
1038 
1039 int qemuMonitorCreateObjectProps(virJSONValue **propsret,
1040                                  const char *type,
1041                                  const char *alias,
1042                                  ...);
1043 
1044 int qemuMonitorAddObject(qemuMonitor *mon,
1045                          virJSONValue **props,
1046                          char **alias)
1047     ATTRIBUTE_NONNULL(2);
1048 
1049 int qemuMonitorDelObject(qemuMonitor *mon,
1050                          const char *objalias,
1051                          bool report_error);
1052 
1053 int qemuMonitorAddDrive(qemuMonitor *mon,
1054                         const char *drivestr);
1055 
1056 int qemuMonitorDriveDel(qemuMonitor *mon,
1057                         const char *drivestr);
1058 
1059 int qemuMonitorCreateSnapshot(qemuMonitor *mon, const char *name);
1060 int qemuMonitorDeleteSnapshot(qemuMonitor *mon, const char *name);
1061 
1062 int qemuMonitorTransaction(qemuMonitor *mon, virJSONValue **actions)
1063     ATTRIBUTE_NONNULL(2);
1064 int qemuMonitorDriveMirror(qemuMonitor *mon,
1065                            const char *device,
1066                            const char *file,
1067                            const char *format,
1068                            unsigned long long bandwidth,
1069                            unsigned int granularity,
1070                            unsigned long long buf_size,
1071                            bool shallow,
1072                            bool reuse)
1073     ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
1074 int qemuMonitorBlockdevMirror(qemuMonitor *mon,
1075                               const char *jobname,
1076                               bool persistjob,
1077                               const char *device,
1078                               const char *target,
1079                               unsigned long long bandwidth,
1080                               unsigned int granularity,
1081                               unsigned long long buf_size,
1082                               bool shallow)
1083     ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);
1084 int qemuMonitorDrivePivot(qemuMonitor *mon,
1085                           const char *jobname)
1086     ATTRIBUTE_NONNULL(2);
1087 
1088 int qemuMonitorBlockCommit(qemuMonitor *mon,
1089                            const char *device,
1090                            const char *jobname,
1091                            bool persistjob,
1092                            const char *top,
1093                            const char *topNode,
1094                            const char *base,
1095                            const char *baseNode,
1096                            const char *backingName,
1097                            unsigned long long bandwidth)
1098     ATTRIBUTE_NONNULL(2);
1099 char *qemuMonitorDiskNameLookup(qemuMonitor *mon,
1100                                 const char *device,
1101                                 virStorageSource *top,
1102                                 virStorageSource *target)
1103     ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
1104 
1105 int qemuMonitorArbitraryCommand(qemuMonitor *mon,
1106                                 const char *cmd,
1107                                 char **reply,
1108                                 bool hmp);
1109 
1110 int qemuMonitorInjectNMI(qemuMonitor *mon);
1111 
1112 int qemuMonitorScreendump(qemuMonitor *mon,
1113                           const char *device,
1114                           unsigned int head,
1115                           const char *file);
1116 
1117 int qemuMonitorSendKey(qemuMonitor *mon,
1118                        unsigned int holdtime,
1119                        unsigned int *keycodes,
1120                        unsigned int nkeycodes);
1121 
1122 int qemuMonitorBlockStream(qemuMonitor *mon,
1123                            const char *device,
1124                            const char *jobname,
1125                            bool persistjob,
1126                            const char *base,
1127                            const char *baseNode,
1128                            const char *backingName,
1129                            unsigned long long bandwidth)
1130     ATTRIBUTE_NONNULL(2);
1131 
1132 int qemuMonitorBlockJobCancel(qemuMonitor *mon,
1133                               const char *jobname,
1134                               bool force)
1135     ATTRIBUTE_NONNULL(2);
1136 
1137 int qemuMonitorBlockJobSetSpeed(qemuMonitor *mon,
1138                                 const char *jobname,
1139                                 unsigned long long bandwidth);
1140 
1141 typedef struct _qemuMonitorBlockJobInfo qemuMonitorBlockJobInfo;
1142 struct _qemuMonitorBlockJobInfo {
1143     int type; /* virDomainBlockJobType */
1144     unsigned long long bandwidth; /* in bytes/s */
1145     virDomainBlockJobCursor cur;
1146     virDomainBlockJobCursor end;
1147     bool ready_present;
1148     bool ready;
1149 };
1150 
1151 GHashTable *qemuMonitorGetAllBlockJobInfo(qemuMonitor *mon,
1152                                               bool rawjobname);
1153 
1154 int qemuMonitorJobDismiss(qemuMonitor *mon,
1155                           const char *jobname)
1156     ATTRIBUTE_NONNULL(2);
1157 
1158 int qemuMonitorJobComplete(qemuMonitor *mon,
1159                            const char *jobname)
1160     ATTRIBUTE_NONNULL(2);
1161 
1162 int qemuMonitorOpenGraphics(qemuMonitor *mon,
1163                             const char *protocol,
1164                             int fd,
1165                             const char *fdname,
1166                             bool skipauth);
1167 
1168 int qemuMonitorSetBlockIoThrottle(qemuMonitor *mon,
1169                                   const char *drivealias,
1170                                   const char *qomid,
1171                                   virDomainBlockIoTuneInfo *info);
1172 
1173 int qemuMonitorGetBlockIoThrottle(qemuMonitor *mon,
1174                                   const char *drivealias,
1175                                   const char *qdevid,
1176                                   virDomainBlockIoTuneInfo *reply);
1177 
1178 int qemuMonitorSystemWakeup(qemuMonitor *mon);
1179 
1180 int qemuMonitorGetVersion(qemuMonitor *mon,
1181                           int *major,
1182                           int *minor,
1183                           int *micro,
1184                           char **package)
1185     ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
1186 
1187 
1188 typedef struct _qemuMonitorMachineInfo qemuMonitorMachineInfo;
1189 struct _qemuMonitorMachineInfo {
1190     char *name;
1191     bool isDefault;
1192     char *alias;
1193     unsigned int maxCpus;
1194     bool hotplugCpus;
1195     char *defaultCPU;
1196     bool numaMemSupported;
1197     char *defaultRAMid;
1198     bool deprecated;
1199 };
1200 
1201 int qemuMonitorGetMachines(qemuMonitor *mon,
1202                            qemuMonitorMachineInfo ***machines);
1203 
1204 void qemuMonitorMachineInfoFree(qemuMonitorMachineInfo *machine);
1205 
1206 typedef struct _qemuMonitorCPUDefInfo qemuMonitorCPUDefInfo;
1207 struct _qemuMonitorCPUDefInfo {
1208     virDomainCapsCPUUsable usable;
1209     char *name;
1210     char *type;
1211     char **blockers; /* NULL-terminated string list */
1212     bool deprecated;
1213 };
1214 
1215 typedef struct _qemuMonitorCPUDefs qemuMonitorCPUDefs;
1216 struct _qemuMonitorCPUDefs {
1217     size_t ncpus;
1218     qemuMonitorCPUDefInfo *cpus;
1219 };
1220 
1221 int qemuMonitorGetCPUDefinitions(qemuMonitor *mon,
1222                                  qemuMonitorCPUDefs **cpuDefs);
1223 qemuMonitorCPUDefs *qemuMonitorCPUDefsNew(size_t count);
1224 qemuMonitorCPUDefs *qemuMonitorCPUDefsCopy(qemuMonitorCPUDefs *src);
1225 void qemuMonitorCPUDefsFree(qemuMonitorCPUDefs *defs);
1226 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorCPUDefs, qemuMonitorCPUDefsFree);
1227 
1228 
1229 typedef enum {
1230     QEMU_MONITOR_CPU_PROPERTY_BOOLEAN,
1231     QEMU_MONITOR_CPU_PROPERTY_STRING,
1232     QEMU_MONITOR_CPU_PROPERTY_NUMBER,
1233 
1234     QEMU_MONITOR_CPU_PROPERTY_LAST
1235 } qemuMonitorCPUPropertyType;
1236 
1237 VIR_ENUM_DECL(qemuMonitorCPUProperty);
1238 
1239 typedef struct _qemuMonitorCPUProperty qemuMonitorCPUProperty;
1240 struct _qemuMonitorCPUProperty {
1241     char *name;
1242     qemuMonitorCPUPropertyType type;
1243     union {
1244         bool boolean;
1245         char *string;
1246         long long number;
1247     } value;
1248     virTristateBool migratable;
1249 };
1250 
1251 typedef struct _qemuMonitorCPUModelInfo qemuMonitorCPUModelInfo;
1252 struct _qemuMonitorCPUModelInfo {
1253     char *name;
1254     size_t nprops;
1255     qemuMonitorCPUProperty *props;
1256     bool migratability;
1257 };
1258 
1259 typedef enum {
1260     QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC,
1261     QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC_FULL,
1262     QEMU_MONITOR_CPU_MODEL_EXPANSION_FULL,
1263 } qemuMonitorCPUModelExpansionType;
1264 
1265 int qemuMonitorGetCPUModelExpansion(qemuMonitor *mon,
1266                                     qemuMonitorCPUModelExpansionType type,
1267                                     virCPUDef *cpu,
1268                                     bool migratable,
1269                                     bool fail_no_props,
1270                                     qemuMonitorCPUModelInfo **model_info);
1271 
1272 void qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfo *model_info);
1273 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorCPUModelInfo, qemuMonitorCPUModelInfoFree);
1274 
1275 int qemuMonitorGetCPUModelBaseline(qemuMonitor *mon,
1276                                    virCPUDef *cpu_a,
1277                                    virCPUDef *cpu_b,
1278                                    qemuMonitorCPUModelInfo **baseline);
1279 
1280 int qemuMonitorGetCPUModelComparison(qemuMonitor *mon,
1281                                      virCPUDef *cpu_a,
1282                                      virCPUDef *cpu_b,
1283                                      char **result);
1284 
1285 qemuMonitorCPUModelInfo *
1286 qemuMonitorCPUModelInfoCopy(const qemuMonitorCPUModelInfo *orig);
1287 
1288 int qemuMonitorGetCommands(qemuMonitor *mon,
1289                            char ***commands);
1290 GHashTable *qemuMonitorGetCommandLineOptions(qemuMonitor *mon);
1291 
1292 int qemuMonitorGetKVMState(qemuMonitor *mon,
1293                            bool *enabled,
1294                            bool *present);
1295 int qemuMonitorGetNVMMState(qemuMonitor *mon,
1296                            bool *enabled,
1297                            bool *present);
1298 
1299 int qemuMonitorGetObjectTypes(qemuMonitor *mon,
1300                               char ***types);
1301 GHashTable *qemuMonitorGetDeviceProps(qemuMonitor *mon,
1302                                           const char *device);
1303 int qemuMonitorGetObjectProps(qemuMonitor *mon,
1304                               const char *object,
1305                               char ***props);
1306 char *qemuMonitorGetTargetArch(qemuMonitor *mon);
1307 
1308 int qemuMonitorNBDServerStart(qemuMonitor *mon,
1309                               const virStorageNetHostDef *server,
1310                               const char *tls_alias)
1311     ATTRIBUTE_NONNULL(2);
1312 int qemuMonitorNBDServerAdd(qemuMonitor *mon,
1313                             const char *deviceID,
1314                             const char *export,
1315                             bool writable,
1316                             const char *bitmap);
1317 int qemuMonitorNBDServerStop(qemuMonitor *);
1318 
1319 int qemuMonitorBlockExportAdd(qemuMonitor *mon,
1320                               virJSONValue **props);
1321 
1322 int qemuMonitorGetTPMModels(qemuMonitor *mon,
1323                             char ***tpmmodels);
1324 
1325 int qemuMonitorGetTPMTypes(qemuMonitor *mon,
1326                            char ***tpmtypes);
1327 
1328 int qemuMonitorAttachCharDev(qemuMonitor *mon,
1329                              const char *chrID,
1330                              virDomainChrSourceDef *chr);
1331 int qemuMonitorDetachCharDev(qemuMonitor *mon,
1332                              const char *chrID);
1333 
1334 int qemuMonitorGetDeviceAliases(qemuMonitor *mon,
1335                                 char ***aliases);
1336 
1337 typedef void (*qemuMonitorReportDomainLogError)(qemuMonitor *mon,
1338                                                 const char *msg,
1339                                                 void *opaque);
1340 void qemuMonitorSetDomainLogLocked(qemuMonitor *mon,
1341                                    qemuMonitorReportDomainLogError func,
1342                                    void *opaque,
1343                                    virFreeCallback destroy);
1344 void qemuMonitorSetDomainLog(qemuMonitor *mon,
1345                              qemuMonitorReportDomainLogError func,
1346                              void *opaque,
1347                              virFreeCallback destroy);
1348 
1349 int qemuMonitorGetGuestCPUx86(qemuMonitor *mon,
1350                               virCPUData **data,
1351                               virCPUData **disabled);
1352 
1353 typedef const char *(*qemuMonitorCPUFeatureTranslationCallback)(const char *name,
1354                                                                 void *opaque);
1355 
1356 int qemuMonitorGetGuestCPU(qemuMonitor *mon,
1357                            virArch arch,
1358                            qemuMonitorCPUFeatureTranslationCallback translate,
1359                            void *opaque,
1360                            virCPUData **enabled,
1361                            virCPUData **disabled);
1362 
1363 int qemuMonitorRTCResetReinjection(qemuMonitor *mon);
1364 
1365 typedef struct _qemuMonitorIOThreadInfo qemuMonitorIOThreadInfo;
1366 struct _qemuMonitorIOThreadInfo {
1367     unsigned int iothread_id;
1368     int thread_id;
1369     bool poll_valid;
1370     unsigned long long poll_max_ns;
1371     unsigned int poll_grow;
1372     unsigned int poll_shrink;
1373     bool set_poll_max_ns;
1374     bool set_poll_grow;
1375     bool set_poll_shrink;
1376 };
1377 int qemuMonitorGetIOThreads(qemuMonitor *mon,
1378                             qemuMonitorIOThreadInfo ***iothreads,
1379                             int *niothreads);
1380 int qemuMonitorSetIOThread(qemuMonitor *mon,
1381                            qemuMonitorIOThreadInfo *iothreadInfo);
1382 
1383 typedef struct _qemuMonitorMemoryDeviceInfo qemuMonitorMemoryDeviceInfo;
1384 struct _qemuMonitorMemoryDeviceInfo {
1385     /* For pc-dimm */
1386     unsigned long long address;
1387     unsigned int slot;
1388     bool hotplugged;
1389     bool hotpluggable;
1390     /* For virtio-mem */
1391     unsigned long long size; /* in bytes */
1392 };
1393 
1394 int qemuMonitorGetMemoryDeviceInfo(qemuMonitor *mon,
1395                                    GHashTable **info)
1396     ATTRIBUTE_NONNULL(2);
1397 
1398 int qemuMonitorMigrateIncoming(qemuMonitor *mon,
1399                                const char *uri);
1400 
1401 int qemuMonitorMigrateStartPostCopy(qemuMonitor *mon);
1402 
1403 int qemuMonitorMigrateContinue(qemuMonitor *mon,
1404                                qemuMonitorMigrationStatus status);
1405 
1406 int qemuMonitorGetRTCTime(qemuMonitor *mon,
1407                           struct tm *tm);
1408 
1409 virJSONValue *qemuMonitorQueryQMPSchema(qemuMonitor *mon);
1410 
1411 int qemuMonitorSetBlockThreshold(qemuMonitor *mon,
1412                                  const char *nodename,
1413                                  unsigned long long threshold);
1414 
1415 virJSONValue *qemuMonitorQueryNamedBlockNodes(qemuMonitor *mon);
1416 
1417 int qemuMonitorSetWatchdogAction(qemuMonitor *mon,
1418                                  const char *action);
1419 
1420 int qemuMonitorBlockdevCreate(qemuMonitor *mon,
1421                               const char *jobname,
1422                               virJSONValue *props);
1423 
1424 int qemuMonitorBlockdevAdd(qemuMonitor *mon,
1425                            virJSONValue **props);
1426 
1427 int qemuMonitorBlockdevReopen(qemuMonitor *mon,
1428                               virJSONValue **props);
1429 
1430 int qemuMonitorBlockdevDel(qemuMonitor *mon,
1431                            const char *nodename);
1432 
1433 int qemuMonitorBlockdevTrayOpen(qemuMonitor *mon,
1434                                 const char *id,
1435                                 bool force);
1436 
1437 int qemuMonitorBlockdevTrayClose(qemuMonitor *mon,
1438                                  const char *id);
1439 
1440 int qemuMonitorBlockdevMediumRemove(qemuMonitor *mon,
1441                                     const char *id);
1442 
1443 int qemuMonitorBlockdevMediumInsert(qemuMonitor *mon,
1444                                     const char *id,
1445                                     const char *nodename);
1446 
1447 char *
1448 qemuMonitorGetSEVMeasurement(qemuMonitor *mon);
1449 
1450 typedef struct _qemuMonitorPRManagerInfo qemuMonitorPRManagerInfo;
1451 struct _qemuMonitorPRManagerInfo {
1452     bool connected;
1453 };
1454 
1455 int qemuMonitorGetPRManagerInfo(qemuMonitor *mon,
1456                                 GHashTable **retinfo);
1457 
1458 typedef struct  _qemuMonitorCurrentMachineInfo qemuMonitorCurrentMachineInfo;
1459 struct _qemuMonitorCurrentMachineInfo {
1460     bool wakeupSuspendSupport;
1461 };
1462 
1463 int qemuMonitorGetCurrentMachineInfo(qemuMonitor *mon,
1464                                      qemuMonitorCurrentMachineInfo *info);
1465 void qemuMonitorJobInfoFree(qemuMonitorJobInfo *job);
1466 
1467 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorJobInfo, qemuMonitorJobInfoFree);
1468 
1469 int qemuMonitorGetJobInfo(qemuMonitor *mon,
1470                           qemuMonitorJobInfo ***jobs,
1471                           size_t *njobs);
1472 
1473 int
1474 qemuMonitorGetCPUMigratable(qemuMonitor *mon,
1475                             bool *migratable);
1476 
1477 int
1478 qemuMonitorTransactionBitmapAdd(virJSONValue *actions,
1479                                 const char *node,
1480                                 const char *name,
1481                                 bool persistent,
1482                                 bool disabled,
1483                                 unsigned long long granularity);
1484 int
1485 qemuMonitorTransactionBitmapRemove(virJSONValue *actions,
1486                                    const char *node,
1487                                    const char *name);
1488 
1489 int
1490 qemuMonitorBitmapRemove(qemuMonitor *mon,
1491                         const char *node,
1492                         const char *name);
1493 int
1494 qemuMonitorTransactionBitmapEnable(virJSONValue *actions,
1495                                    const char *node,
1496                                    const char *name);
1497 int
1498 qemuMonitorTransactionBitmapDisable(virJSONValue *actions,
1499                                     const char *node,
1500                                     const char *name);
1501 int
1502 qemuMonitorTransactionBitmapMerge(virJSONValue *actions,
1503                                   const char *node,
1504                                   const char *target,
1505                                   virJSONValue **sources);
1506 int
1507 qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValue *sources,
1508                                                  const char *sourcenode,
1509                                                  const char *sourcebitmap);
1510 
1511 int
1512 qemuMonitorTransactionSnapshotLegacy(virJSONValue *actions,
1513                                      const char *device,
1514                                      const char *path,
1515                                      const char *format,
1516                                      bool existing);
1517 int
1518 qemuMonitorTransactionSnapshotBlockdev(virJSONValue *actions,
1519                                        const char *node,
1520                                        const char *overlay);
1521 
1522 typedef enum {
1523     QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_NONE = 0,
1524     QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_INCREMENTAL,
1525     QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_FULL,
1526     QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_LAST,
1527 } qemuMonitorTransactionBackupSyncMode;
1528 
1529 int
1530 qemuMonitorTransactionBackup(virJSONValue *actions,
1531                              const char *device,
1532                              const char *jobname,
1533                              const char *target,
1534                              const char *bitmap,
1535                              qemuMonitorTransactionBackupSyncMode syncmode);
1536 
1537 int
1538 qemuMonitorStartDirtyRateCalc(qemuMonitor *mon,
1539                               int seconds);
1540 
1541 typedef struct _qemuMonitorDirtyRateInfo qemuMonitorDirtyRateInfo;
1542 struct _qemuMonitorDirtyRateInfo {
1543     int status;             /* the status of last dirtyrate calculation,
1544                                one of virDomainDirtyRateStatus */
1545     int calcTime;           /* the period of dirtyrate calculation */
1546     long long startTime;    /* the start time of dirtyrate calculation */
1547     long long dirtyRate;    /* the dirtyrate in MiB/s */
1548 };
1549 
1550 int
1551 qemuMonitorQueryDirtyRate(qemuMonitor *mon,
1552                           qemuMonitorDirtyRateInfo *info);
1553 
1554 int
1555 qemuMonitorSetAction(qemuMonitor *mon,
1556                      qemuMonitorActionShutdown shutdown,
1557                      qemuMonitorActionReboot reboot,
1558                      qemuMonitorActionWatchdog watchdog,
1559                      qemuMonitorActionPanic panic);
1560 
1561 int
1562 qemuMonitorChangeMemoryRequestedSize(qemuMonitor *mon,
1563                                      const char *alias,
1564                                      unsigned long long requestedsize);
1565