/*
 * qemu_monitor.h: interaction with QEMU monitor console
 *
 * Copyright (C) 2006-2015 Red Hat, Inc.
 * Copyright (C) 2006 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

#pragma once

#include "internal.h"

#include "domain_conf.h"
#include "virbitmap.h"
#include "virjson.h"
#include "virnetdev.h"
#include "cpu/cpu.h"
#include "util/virgic.h"
#include "virenum.h"

typedef struct _qemuMonitor qemuMonitor;
typedef struct _qemuMonitorMessage qemuMonitorMessage;

typedef enum {
    QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_NONE = 0,
    QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_HYPERV,
    QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_S390,
    QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_TDX,

    QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_LAST
} qemuMonitorEventPanicInfoType;

typedef struct _qemuMonitorEventPanicInfoHyperv qemuMonitorEventPanicInfoHyperv;
struct _qemuMonitorEventPanicInfoHyperv {
    /* Hyper-V specific guest panic information (HV crash MSRs) */
    unsigned long long arg1;
    unsigned long long arg2;
    unsigned long long arg3;
    unsigned long long arg4;
    unsigned long long arg5;
};

typedef struct _qemuMonitorEventPanicInfoS390 qemuMonitorEventPanicInfoS390;
struct _qemuMonitorEventPanicInfoS390 {
    /* S390 specific guest panic information */
    int core;
    unsigned long long psw_mask;
    unsigned long long psw_addr;
    char *reason;
};

typedef struct _qemuMonitorEventPanicInfoTDX qemuMonitorEventPanicInfoTDX;
struct _qemuMonitorEventPanicInfoTDX {
    /* TDX specific guest panic information */
    int error_code;
    char *message;
    bool has_gpa;
    unsigned long long gpa;
};

typedef struct _qemuMonitorEventPanicInfo qemuMonitorEventPanicInfo;
struct _qemuMonitorEventPanicInfo {
    qemuMonitorEventPanicInfoType type;
    union {
        qemuMonitorEventPanicInfoHyperv hyperv;
        qemuMonitorEventPanicInfoS390 s390;
        qemuMonitorEventPanicInfoTDX tdx;
    } data;
};


typedef struct _qemuMonitorRdmaGidStatus qemuMonitorRdmaGidStatus;
struct _qemuMonitorRdmaGidStatus {
    char *netdev;
    bool gid_status;
    unsigned long long subnet_prefix;
    unsigned long long interface_id;
};


typedef struct _qemuMonitorMemoryDeviceSizeChange qemuMonitorMemoryDeviceSizeChange;
typedef qemuMonitorMemoryDeviceSizeChange *qemuMonitorMemoryDeviceSizeChangePtr;
struct _qemuMonitorMemoryDeviceSizeChange {
    char *devAlias;
    unsigned long long size;
};


typedef enum {
    QEMU_MONITOR_ACTION_SHUTDOWN_KEEP, /* do not change the current setting */
    QEMU_MONITOR_ACTION_SHUTDOWN_POWEROFF,
    QEMU_MONITOR_ACTION_SHUTDOWN_PAUSE,

    QEMU_MONITOR_ACTION_SHUTDOWN_LAST
} qemuMonitorActionShutdown;


typedef enum {
    QEMU_MONITOR_ACTION_REBOOT_KEEP, /* do not change the current setting */
    QEMU_MONITOR_ACTION_REBOOT_RESET,
    QEMU_MONITOR_ACTION_REBOOT_SHUTDOWN,

    QEMU_MONITOR_ACTION_REBOOT_LAST
} qemuMonitorActionReboot;


typedef enum {
    QEMU_MONITOR_ACTION_WATCHDOG_KEEP, /* do not change the current setting */
    QEMU_MONITOR_ACTION_WATCHDOG_RESET,
    QEMU_MONITOR_ACTION_WATCHDOG_SHUTDOWN,
    QEMU_MONITOR_ACTION_WATCHDOG_POWEROFF,
    QEMU_MONITOR_ACTION_WATCHDOG_PAUSE,
    QEMU_MONITOR_ACTION_WATCHDOG_DEBUG,
    QEMU_MONITOR_ACTION_WATCHDOG_NONE,
    QEMU_MONITOR_ACTION_WATCHDOG_INJECT_NMI,

    QEMU_MONITOR_ACTION_WATCHDOG_LAST
} qemuMonitorActionWatchdog;


typedef enum {
    QEMU_MONITOR_ACTION_PANIC_KEEP, /* do not change the current setting */
    QEMU_MONITOR_ACTION_PANIC_PAUSE,
    QEMU_MONITOR_ACTION_PANIC_SHUTDOWN,
    QEMU_MONITOR_ACTION_PANIC_NONE,

    QEMU_MONITOR_ACTION_PANIC_LAST
} qemuMonitorActionPanic;


typedef enum {
    QEMU_MONITOR_JOB_TYPE_UNKNOWN, /* internal value, not exposed by qemu */
    QEMU_MONITOR_JOB_TYPE_COMMIT,
    QEMU_MONITOR_JOB_TYPE_STREAM,
    QEMU_MONITOR_JOB_TYPE_MIRROR,
    QEMU_MONITOR_JOB_TYPE_BACKUP,
    QEMU_MONITOR_JOB_TYPE_CREATE,
    QEMU_MONITOR_JOB_TYPE_LAST
} qemuMonitorJobType;

VIR_ENUM_DECL(qemuMonitorJob);

typedef enum {
    QEMU_MONITOR_JOB_STATUS_UNKNOWN, /* internal value, not exposed by qemu */
    QEMU_MONITOR_JOB_STATUS_CREATED,
    QEMU_MONITOR_JOB_STATUS_RUNNING,
    QEMU_MONITOR_JOB_STATUS_PAUSED,
    QEMU_MONITOR_JOB_STATUS_READY,
    QEMU_MONITOR_JOB_STATUS_STANDBY,
    QEMU_MONITOR_JOB_STATUS_WAITING,
    QEMU_MONITOR_JOB_STATUS_PENDING,
    QEMU_MONITOR_JOB_STATUS_ABORTING,
    QEMU_MONITOR_JOB_STATUS_CONCLUDED,
    QEMU_MONITOR_JOB_STATUS_UNDEFINED, /* the job states below should not be visible outside of qemu */
    QEMU_MONITOR_JOB_STATUS_NULL,
    QEMU_MONITOR_JOB_STATUS_LAST
} qemuMonitorJobStatus;

VIR_ENUM_DECL(qemuMonitorJobStatus);

typedef struct _qemuMonitorJobInfo qemuMonitorJobInfo;
struct _qemuMonitorJobInfo {
    char *id;
    qemuMonitorJobType type;
    qemuMonitorJobStatus status;
    char *error;
    unsigned long long progressCurrent;
    unsigned long long progressTotal;
};


char *
qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfo *info);
void
qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfo *info);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorEventPanicInfo, qemuMonitorEventPanicInfoFree);

void
qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatus *info);

void
qemuMonitorMemoryDeviceSizeChangeFree(qemuMonitorMemoryDeviceSizeChange *info);

typedef void (*qemuMonitorDestroyCallback)(qemuMonitor *mon,
                                           virDomainObj *vm);
typedef void (*qemuMonitorEofNotifyCallback)(qemuMonitor *mon,
                                             virDomainObj *vm);
typedef void (*qemuMonitorErrorNotifyCallback)(qemuMonitor *mon,
                                               virDomainObj *vm);
typedef void (*qemuMonitorDomainEventCallback)(qemuMonitor *mon,
                                               virDomainObj *vm,
                                               const char *event,
                                               long long seconds,
                                               unsigned int micros,
                                               const char *details);
typedef void (*qemuMonitorDomainShutdownCallback)(qemuMonitor *mon,
                                                  virDomainObj *vm,
                                                  virTristateBool guest);
typedef void (*qemuMonitorDomainResetCallback)(qemuMonitor *mon,
                                               virDomainObj *vm);
typedef void (*qemuMonitorDomainStopCallback)(qemuMonitor *mon,
                                              virDomainObj *vm);
typedef void (*qemuMonitorDomainResumeCallback)(qemuMonitor *mon,
                                                virDomainObj *vm);
typedef void (*qemuMonitorDomainRTCChangeCallback)(qemuMonitor *mon,
                                                   virDomainObj *vm,
                                                   long long offset);
typedef void (*qemuMonitorDomainWatchdogCallback)(qemuMonitor *mon,
                                                  virDomainObj *vm,
                                                  int action);
typedef void (*qemuMonitorDomainIOErrorCallback)(qemuMonitor *mon,
                                                 virDomainObj *vm,
                                                 const char *device,
                                                 const char *qompath,
                                                 const char *nodename,
                                                 int action,
                                                 bool nospace,
                                                 const char *reason);
typedef void (*qemuMonitorDomainGraphicsCallback)(qemuMonitor *mon,
                                                  virDomainObj *vm,
                                                  int phase,
                                                  int localFamily,
                                                  const char *localNode,
                                                  const char *localService,
                                                  int remoteFamily,
                                                  const char *remoteNode,
                                                  const char *remoteService,
                                                  const char *authScheme,
                                                  const char *x509dname,
                                                  const char *saslUsername);
typedef void (*qemuMonitorDomainJobStatusChangeCallback)(qemuMonitor *mon,
                                                         virDomainObj *vm,
                                                         const char *jobname,
                                                         int status);
typedef void (*qemuMonitorDomainTrayChangeCallback)(qemuMonitor *mon,
                                                    virDomainObj *vm,
                                                    const char *devAlias,
                                                    const char *devid,
                                                    int reason);
typedef void (*qemuMonitorDomainPMWakeupCallback)(qemuMonitor *mon,
                                                  virDomainObj *vm);
typedef void (*qemuMonitorDomainPMSuspendCallback)(qemuMonitor *mon,
                                                   virDomainObj *vm);
typedef void (*qemuMonitorDomainBalloonChangeCallback)(qemuMonitor *mon,
                                                       virDomainObj *vm,
                                                       unsigned long long actual);
typedef void (*qemuMonitorDomainPMSuspendDiskCallback)(qemuMonitor *mon,
                                                       virDomainObj *vm);
typedef void (*qemuMonitorDomainGuestPanicCallback)(qemuMonitor *mon,
                                                    virDomainObj *vm,
                                                    qemuMonitorEventPanicInfo *info);
typedef void (*qemuMonitorDomainDeviceDeletedCallback)(qemuMonitor *mon,
                                                       virDomainObj *vm,
                                                       const char *devAlias);
typedef void (*qemuMonitorDomainDeviceUnplugErrCallback)(qemuMonitor *mon,
                                                         virDomainObj *vm,
                                                         const char *devPath,
                                                         const char *devAlias);
typedef void (*qemuMonitorDomainNetdevStreamDisconnectedCallback)(qemuMonitor *mon,
                                                                  virDomainObj *vm,
                                                                  const char *devAlias);
typedef void (*qemuMonitorDomainNetdevVhostUserDisconnectedCallback)(qemuMonitor *mon,
                                                                     virDomainObj *vm,
                                                                     const char *devAlias);
typedef void (*qemuMonitorDomainNicRxFilterChangedCallback)(qemuMonitor *mon,
                                                            virDomainObj *vm,
                                                            const char *devAlias);

typedef void (*qemuMonitorDomainSerialChangeCallback)(qemuMonitor *mon,
                                                      virDomainObj *vm,
                                                      const char *devAlias,
                                                      bool connected);

typedef void (*qemuMonitorDomainSpiceMigratedCallback)(qemuMonitor *mon,
                                                       virDomainObj *vm);

typedef void (*qemuMonitorDomainMigrationStatusCallback)(qemuMonitor *mon,
                                                         virDomainObj *vm,
                                                         int status);

typedef void (*qemuMonitorDomainMigrationPassCallback)(qemuMonitor *mon,
                                                       virDomainObj *vm,
                                                       int pass);

typedef void (*qemuMonitorDomainAcpiOstInfoCallback)(qemuMonitor *mon,
                                                     virDomainObj *vm,
                                                     const char *alias,
                                                     const char *slotType,
                                                     const char *slot,
                                                     unsigned int source,
                                                     unsigned int status);


typedef void (*qemuMonitorDomainBlockThresholdCallback)(qemuMonitor *mon,
                                                        virDomainObj *vm,
                                                        const char *nodename,
                                                        unsigned long long threshold,
                                                        unsigned long long excess);


typedef enum {
    QEMU_MONITOR_DUMP_STATUS_NONE,
    QEMU_MONITOR_DUMP_STATUS_ACTIVE,
    QEMU_MONITOR_DUMP_STATUS_COMPLETED,
    QEMU_MONITOR_DUMP_STATUS_FAILED,

    QEMU_MONITOR_DUMP_STATUS_LAST,
} qemuMonitorDumpStatus;

VIR_ENUM_DECL(qemuMonitorDumpStatus);

typedef struct _qemuMonitorDumpStats qemuMonitorDumpStats;
struct _qemuMonitorDumpStats {
    int status; /* qemuMonitorDumpStatus */
    unsigned long long completed; /* bytes written */
    unsigned long long total; /* total bytes to be written */
};

typedef void (*qemuMonitorDomainDumpCompletedCallback)(qemuMonitor *mon,
                                                       virDomainObj *vm,
                                                       int status,
                                                       qemuMonitorDumpStats *stats,
                                                       const char *error);

typedef void (*qemuMonitorDomainPRManagerStatusChangedCallback)(qemuMonitor *mon,
                                                                virDomainObj *vm,
                                                                const char *prManager,
                                                                bool connected);

typedef void (*qemuMonitorDomainRdmaGidStatusChangedCallback)(qemuMonitor *mon,
                                                              virDomainObj *vm,
                                                              const char *netdev,
                                                              bool gid_status,
                                                              unsigned long long subnet_prefix,
                                                              unsigned long long interface_id);

typedef void (*qemuMonitorDomainGuestCrashloadedCallback)(qemuMonitor *mon,
                                                          virDomainObj *vm);

typedef enum {
    QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_HYPERVISOR,
    QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_GUEST,

    QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_LAST
} qemuMonitorMemoryFailureRecipient;

VIR_ENUM_DECL(qemuMonitorMemoryFailureRecipient);

typedef enum {
    QEMU_MONITOR_MEMORY_FAILURE_ACTION_IGNORE,
    QEMU_MONITOR_MEMORY_FAILURE_ACTION_INJECT,
    QEMU_MONITOR_MEMORY_FAILURE_ACTION_FATAL,
    QEMU_MONITOR_MEMORY_FAILURE_ACTION_RESET,

    QEMU_MONITOR_MEMORY_FAILURE_ACTION_LAST
} qemuMonitorMemoryFailureAction;

VIR_ENUM_DECL(qemuMonitorMemoryFailureAction);

typedef struct _qemuMonitorEventMemoryFailure qemuMonitorEventMemoryFailure;
struct _qemuMonitorEventMemoryFailure {
    qemuMonitorMemoryFailureRecipient recipient;
    qemuMonitorMemoryFailureAction action;
    bool action_required;
    bool recursive;
};

typedef void (*qemuMonitorDomainMemoryFailureCallback)(qemuMonitor *mon,
                                                       virDomainObj *vm,
                                                       qemuMonitorEventMemoryFailure *mfp);

typedef void (*qemuMonitorDomainMemoryDeviceSizeChange)(qemuMonitor *mon,
                                                        virDomainObj *vm,
                                                        const char *alias,
                                                        unsigned long long size);

typedef struct _qemuMonitorCallbacks qemuMonitorCallbacks;
struct _qemuMonitorCallbacks {
    qemuMonitorEofNotifyCallback eofNotify;
    qemuMonitorErrorNotifyCallback errorNotify;
    qemuMonitorDomainEventCallback domainEvent;
    qemuMonitorDomainShutdownCallback domainShutdown;
    qemuMonitorDomainResetCallback domainReset;
    qemuMonitorDomainStopCallback domainStop;
    qemuMonitorDomainResumeCallback domainResume;
    qemuMonitorDomainRTCChangeCallback domainRTCChange;
    qemuMonitorDomainWatchdogCallback domainWatchdog;
    qemuMonitorDomainIOErrorCallback domainIOError;
    qemuMonitorDomainGraphicsCallback domainGraphics;
    qemuMonitorDomainJobStatusChangeCallback jobStatusChange;
    qemuMonitorDomainTrayChangeCallback domainTrayChange;
    qemuMonitorDomainPMWakeupCallback domainPMWakeup;
    qemuMonitorDomainPMSuspendCallback domainPMSuspend;
    qemuMonitorDomainBalloonChangeCallback domainBalloonChange;
    qemuMonitorDomainPMSuspendDiskCallback domainPMSuspendDisk;
    qemuMonitorDomainGuestPanicCallback domainGuestPanic;
    qemuMonitorDomainDeviceDeletedCallback domainDeviceDeleted;
    qemuMonitorDomainNicRxFilterChangedCallback domainNicRxFilterChanged;
    qemuMonitorDomainSerialChangeCallback domainSerialChange;
    qemuMonitorDomainSpiceMigratedCallback domainSpiceMigrated;
    qemuMonitorDomainMigrationStatusCallback domainMigrationStatus;
    qemuMonitorDomainMigrationPassCallback domainMigrationPass;
    qemuMonitorDomainAcpiOstInfoCallback domainAcpiOstInfo;
    qemuMonitorDomainBlockThresholdCallback domainBlockThreshold;
    qemuMonitorDomainDumpCompletedCallback domainDumpCompleted;
    qemuMonitorDomainPRManagerStatusChangedCallback domainPRManagerStatusChanged;
    qemuMonitorDomainRdmaGidStatusChangedCallback domainRdmaGidStatusChanged;
    qemuMonitorDomainGuestCrashloadedCallback domainGuestCrashloaded;
    qemuMonitorDomainMemoryFailureCallback domainMemoryFailure;
    qemuMonitorDomainMemoryDeviceSizeChange domainMemoryDeviceSizeChange;
    qemuMonitorDomainDeviceUnplugErrCallback domainDeviceUnplugError;
    qemuMonitorDomainNetdevStreamDisconnectedCallback domainNetdevStreamDisconnected;
    qemuMonitorDomainNetdevVhostUserDisconnectedCallback domainNetdevVhostUserDisconnected;
};

qemuMonitor *
qemuMonitorOpen(virDomainObj *vm,
                virDomainChrSourceDef *config,
                GMainContext *context,
                qemuMonitorCallbacks *cb)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(4);

void
qemuMonitorWatchDispose(void);

bool
qemuMonitorWasDisposed(void);

void
qemuMonitorRegister(qemuMonitor *mon)
    ATTRIBUTE_NONNULL(1);

void
qemuMonitorUnregister(qemuMonitor *mon)
    ATTRIBUTE_NONNULL(1);

void
qemuMonitorClose(qemuMonitor *mon);

virErrorPtr
qemuMonitorLastError(qemuMonitor *mon);

int
qemuMonitorSetCapabilities(qemuMonitor *mon);

int
qemuMonitorSetLink(qemuMonitor *mon,
                   const char *name,
                   virDomainNetInterfaceLinkState state)
    ATTRIBUTE_NONNULL(2);

/* These APIs are for use by the internal Text/JSON monitor impl code only */
char *
qemuMonitorNextCommandID(qemuMonitor *mon);

int
qemuMonitorSend(qemuMonitor *mon,
                qemuMonitorMessage *msg) ATTRIBUTE_MOCKABLE;

int
qemuMonitorUpdateVideoMemorySize(qemuMonitor *mon,
                                 virDomainVideoDef *video,
                                 const char *videoName)
    ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);

int
qemuMonitorUpdateVideoVram64Size(qemuMonitor *mon,
                                 virDomainVideoDef *video,
                                 const char *videoName)
    ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);

void
qemuMonitorEmitEvent(qemuMonitor *mon,
                     const char *event,
                     long long seconds,
                     unsigned int micros,
                     const char *details);

void
qemuMonitorEmitShutdown(qemuMonitor *mon,
                        virTristateBool guest,
                        const char *reason);

void
qemuMonitorEmitReset(qemuMonitor *mon);

void
qemuMonitorEmitStop(qemuMonitor *mon);

void
qemuMonitorEmitResume(qemuMonitor *mon);

void
qemuMonitorEmitRTCChange(qemuMonitor *mon,
                         long long offset);

void
qemuMonitorEmitWatchdog(qemuMonitor *mon,
                        int action);

void
qemuMonitorEmitIOError(qemuMonitor *mon,
                       const char *device,
                       const char *qompath,
                       const char *nodename,
                       int action,
                       bool nospace,
                       const char *reason);

void
qemuMonitorEmitGraphics(qemuMonitor *mon,
                        int phase,
                        int localFamily,
                        const char *localNode,
                        const char *localService,
                        int remoteFamily,
                        const char *remoteNode,
                        const char *remoteService,
                        const char *authScheme,
                        const char *x509dname,
                        const char *saslUsername);

void
qemuMonitorEmitTrayChange(qemuMonitor *mon,
                          const char *devAlias,
                          const char *devid,
                          int reason);

void
qemuMonitorEmitPMWakeup(qemuMonitor *mon);

void
qemuMonitorEmitPMSuspend(qemuMonitor *mon);

void
qemuMonitorEmitJobStatusChange(qemuMonitor *mon,
                               const char *jobname,
                               qemuMonitorJobStatus status);

void
qemuMonitorEmitBalloonChange(qemuMonitor *mon,
                             unsigned long long actual);

void
qemuMonitorEmitPMSuspendDisk(qemuMonitor *mon);

void
qemuMonitorEmitGuestPanic(qemuMonitor *mon,
                          qemuMonitorEventPanicInfo *info);

void
qemuMonitorEmitDeviceDeleted(qemuMonitor *mon,
                             const char *devAlias);

void
qemuMonitorEmitDeviceUnplugErr(qemuMonitor *mon,
                               const char *devPath,
                               const char *devAlias);

void
qemuMonitorEmitNetdevStreamDisconnected(qemuMonitor *mon,
                                        const char *devAlias);

void
qemuMonitorEmitNetdevVhostUserDisconnected(qemuMonitor *mon,
                                           const char *devAlias);

void
qemuMonitorEmitNicRxFilterChanged(qemuMonitor *mon,
                                  const char *devAlias);

void
qemuMonitorEmitSerialChange(qemuMonitor *mon,
                            const char *devAlias,
                            bool connected);

void
qemuMonitorEmitSpiceMigrated(qemuMonitor *mon);

void
qemuMonitorEmitMemoryDeviceSizeChange(qemuMonitor *mon,
                                      const char *devAlias,
                                      unsigned long long size);

void
qemuMonitorEmitMemoryFailure(qemuMonitor *mon,
                             qemuMonitorEventMemoryFailure *mfp);

void
qemuMonitorEmitMigrationStatus(qemuMonitor *mon,
                               int status);

void
qemuMonitorEmitMigrationPass(qemuMonitor *mon,
                             int pass);

void
qemuMonitorEmitAcpiOstInfo(qemuMonitor *mon,
                           const char *alias,
                           const char *slotType,
                           const char *slot,
                           unsigned int source,
                           unsigned int status);

void
qemuMonitorEmitBlockThreshold(qemuMonitor *mon,
                              const char *nodename,
                              unsigned long long threshold,
                              unsigned long long excess);

void
qemuMonitorEmitDumpCompleted(qemuMonitor *mon,
                             int status,
                             qemuMonitorDumpStats *stats,
                             const char *error);

void
qemuMonitorEmitPRManagerStatusChanged(qemuMonitor *mon,
                                      const char *prManager,
                                      bool connected);

void
qemuMonitorEmitRdmaGidStatusChanged(qemuMonitor *mon,
                                    const char *netdev,
                                    bool gid_status,
                                    unsigned long long subnet_prefix,
                                    unsigned long long interface_id);

void
qemuMonitorEmitGuestCrashloaded(qemuMonitor *mon);

int
qemuMonitorStartCPUs(qemuMonitor *mon);

int
qemuMonitorStopCPUs(qemuMonitor *mon);

typedef enum {
    QEMU_MONITOR_VM_STATUS_DEBUG,
    QEMU_MONITOR_VM_STATUS_INMIGRATE,
    QEMU_MONITOR_VM_STATUS_INTERNAL_ERROR,
    QEMU_MONITOR_VM_STATUS_IO_ERROR,
    QEMU_MONITOR_VM_STATUS_PAUSED,
    QEMU_MONITOR_VM_STATUS_POSTMIGRATE,
    QEMU_MONITOR_VM_STATUS_PRELAUNCH,
    QEMU_MONITOR_VM_STATUS_FINISH_MIGRATE,
    QEMU_MONITOR_VM_STATUS_RESTORE_VM,
    QEMU_MONITOR_VM_STATUS_RUNNING,
    QEMU_MONITOR_VM_STATUS_SAVE_VM,
    QEMU_MONITOR_VM_STATUS_SHUTDOWN,
    QEMU_MONITOR_VM_STATUS_WATCHDOG,
    QEMU_MONITOR_VM_STATUS_GUEST_PANICKED,

    QEMU_MONITOR_VM_STATUS_LAST
} qemuMonitorVMStatus;
VIR_ENUM_DECL(qemuMonitorVMStatus);

int
qemuMonitorVMStatusToPausedReason(const char *status);

int
qemuMonitorGetStatus(qemuMonitor *mon,
                     bool *running,
                     virDomainPausedReason *reason)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorSystemReset(qemuMonitor *mon);

int
qemuMonitorSystemPowerdown(qemuMonitor *mon);

struct qemuMonitorQueryCpusEntry {
    int qemu_id; /* id of the cpu as reported by qemu */
    pid_t tid;
    char *qom_path;
    bool halted;
};

void
qemuMonitorQueryCpusFree(struct qemuMonitorQueryCpusEntry *entries,
                         size_t nentries);


struct qemuMonitorQueryHotpluggableCpusEntry {
    char *type; /* name of the cpu to use with device_add */
    unsigned int vcpus; /* count of virtual cpus in the guest this entry adds */
    char *qom_path; /* full device qom path only present for online cpus */
    char *alias; /* device alias, may be NULL for non-hotpluggable entities */

    /* verbatim copy of the JSON data representing the CPU which must be used for hotplug */
    virJSONValue *props;

    /* topology information -1 if qemu didn't report given parameter */
    int node_id;
    int socket_id;
    int die_id;
    int cluster_id;
    int core_id;
    int thread_id;

    /* internal data */
    int enable_id;
};

void
qemuMonitorQueryHotpluggableCpusFree(struct qemuMonitorQueryHotpluggableCpusEntry *entries,
                                     size_t nentries);


struct _qemuMonitorCPUInfo {
    pid_t tid;
    int id; /* order of enabling of the given cpu */
    int qemu_id; /* identifier of the cpu as reported by query-cpus */

    /* state data */
    bool online;
    bool hotpluggable;

    /* topology info for hotplug purposes. Hotplug of given vcpu impossible if
     * all entries are -1 */
    int socket_id;
    int die_id;
    int cluster_id;
    int core_id;
    int thread_id;
    int node_id;
    unsigned int vcpus; /* number of vcpus added if given entry is hotplugged */

    /* name of the qemu type to add in case of hotplug */
    char *type;

    /* verbatim copy of the returned data from qemu which should be used when plugging */
    virJSONValue *props;

    /* alias of an hotpluggable entry. Entries with alias can be hot-unplugged */
    char *alias;

    char *qom_path;

    bool halted;
};
typedef struct _qemuMonitorCPUInfo qemuMonitorCPUInfo;

void
qemuMonitorCPUInfoFree(qemuMonitorCPUInfo *cpus,
                       size_t ncpus);

int
qemuMonitorGetCPUInfo(qemuMonitor *mon,
                      qemuMonitorCPUInfo **vcpus,
                      size_t maxvcpus,
                      bool hotplug);

virBitmap *qemuMonitorGetCpuHalted(qemuMonitor *mon,
                                   size_t maxvcpus);

int
qemuMonitorGetBalloonInfo(qemuMonitor *mon,
                          unsigned long long *currmem);

int
qemuMonitorGetMemoryStats(qemuMonitor *mon,
                          virDomainMemballoonDef *balloon,
                          virDomainMemoryStatPtr stats,
                          unsigned int nr_stats);

int
qemuMonitorSetMemoryStatsPeriod(qemuMonitor *mon,
                                virDomainMemballoonDef *balloon,
                                int period);

GHashTable *
qemuMonitorGetBlockInfo(qemuMonitor *mon);


struct qemuBlockStatsLimits {
    unsigned long long request_alignment;
    unsigned long long discard_max;
    unsigned long long discard_alignment;
    unsigned long long write_zeroes_max;
    unsigned long long write_zeroes_alignment;
    unsigned long long transfer_optimal;
    unsigned long long transfer_max;
    unsigned long long transfer_hw_max;
    unsigned long long iov_max;
    unsigned long long iov_hw_max;
    unsigned long long memory_alignment_minimal;
    unsigned long long memory_alignment_optimal;
};


struct qemuBlockStatsLatencyHistogramBin {
    unsigned long long start;
    unsigned long long value;
};


struct qemuBlockStatsLatencyHistogram {
    struct qemuBlockStatsLatencyHistogramBin *bins;
    size_t nbins;
};


struct qemuBlockStatsTimed {
    unsigned long long interval_length;

    /* latencies are in nanoseconds */
    unsigned long long rd_latency_min;
    unsigned long long rd_latency_max;
    unsigned long long rd_latency_avg;

    unsigned long long wr_latency_min;
    unsigned long long wr_latency_max;
    unsigned long long wr_latency_avg;

    unsigned long long zone_append_latency_min;
    unsigned long long zone_append_latency_max;
    unsigned long long zone_append_latency_avg;

    unsigned long long flush_latency_min;
    unsigned long long flush_latency_max;
    unsigned long long flush_latency_avg;

    double rd_queue_depth_avg;
    double wr_queue_depth_avg;
    double zone_append_queue_depth_avg;
};

struct _qemuBlockStats {
    GObject parent;

    unsigned long long rd_req;
    unsigned long long rd_bytes;
    unsigned long long wr_req;
    unsigned long long wr_bytes;
    unsigned long long rd_total_times;
    unsigned long long wr_total_times;
    unsigned long long flush_req;
    unsigned long long flush_total_times;

    unsigned long long capacity;
    unsigned long long physical;

    /* value of wr_highest_offset is valid if it's non 0 or
     * if wr_highest_offset_valid is true */
    unsigned long long wr_highest_offset;
    bool wr_highest_offset_valid;

    /* write_threshold is valid only if it's non-zero, conforming to qemu semantics */
    unsigned long long write_threshold;

    struct qemuBlockStatsLimits *limits;

    /* block accounting/timed stats from qemu - one entry per interval configured */
    size_t n_timed_stats;
    struct qemuBlockStatsTimed *timed_stats;

    /* latency histograms */
    struct qemuBlockStatsLatencyHistogram *histogram_read;
    struct qemuBlockStatsLatencyHistogram *histogram_write;
    struct qemuBlockStatsLatencyHistogram *histogram_zone;
    struct qemuBlockStatsLatencyHistogram *histogram_flush;
};
G_DECLARE_FINAL_TYPE(qemuBlockStats, qemu_block_stats, QEMU, BLOCK_STATS, GObject);

qemuBlockStats *
qemuBlockStatsNew(void);

int
qemuMonitorGetAllBlockStatsInfo(qemuMonitor *mon,
                                GHashTable **ret_stats)
    ATTRIBUTE_NONNULL(2);

typedef struct _qemuBlockNamedNodeDataBitmap qemuBlockNamedNodeDataBitmap;
struct _qemuBlockNamedNodeDataBitmap {
    char *name;
    bool recording;
    bool busy;
    bool persistent;
    bool inconsistent;

    unsigned long long dirtybytes;
    unsigned long long granularity;
};


typedef struct _qemuBlockNamedNodeDataSnapshot qemuBlockNamedNodeDataSnapshot;
struct _qemuBlockNamedNodeDataSnapshot {
    bool vmstate;
};


typedef struct _qemuBlockNamedNodeData qemuBlockNamedNodeData;
struct _qemuBlockNamedNodeData {
    unsigned long long capacity;
    unsigned long long physical;

    /* Information about change block tracking bitmaps which are active and loaded */
    qemuBlockNamedNodeDataBitmap **bitmaps;
    size_t nbitmaps;
    /* With qcow2 we have also a separate list of bitmaps present in the image
     * but not yet activated, which happens when starting qemu during migration */
    char **qcow2bitmaps;

    /* hash table indexed by snapshot name containing data about snapshots
     * (qemuBlockNamedNodeDataSnapshot) */
    GHashTable *snapshots;

    /* the cluster size of the image is valid only when > 0 */
    unsigned long long clusterSize;

    /* image version */
    bool qcow2v2;

    /* qcow2 subcluster allocation -> extended_l2 */
    bool qcow2extendedL2;

    /* qcow2 data file 'raw' feature is enabled */
    bool qcow2dataFileRaw;

    /* node is deactivated in qemu (reported as 'active' but may be missing,
     * thus the flag is asserted only when we know it's inactive) */
    bool inactive;
};

GHashTable *
qemuMonitorBlockGetNamedNodeData(qemuMonitor *mon);

int
qemuMonitorBlockResize(qemuMonitor *mon,
                       const char *device,
                       const char *nodename,
                       unsigned long long size);

int
qemuMonitorSetPassword(qemuMonitor *mon,
                       int type,
                       const char *password,
                       const char *action_if_connected);

int
qemuMonitorExpirePassword(qemuMonitor *mon,
                          int type,
                          const char *expire_time);

int
qemuMonitorSetBalloon(qemuMonitor *mon,
                      unsigned long long newmem);

int
qemuMonitorSaveVirtualMemory(qemuMonitor *mon,
                             unsigned long long offset,
                             unsigned long long length,
                             const char *path);

int
qemuMonitorSavePhysicalMemory(qemuMonitor *mon,
                              unsigned long long offset,
                              unsigned long long length,
                              const char *path);

int
qemuMonitorSetDBusVMStateIdList(qemuMonitor *mon,
                                GSList *list);

int
qemuMonitorSetUSBDiskAttached(qemuMonitor *mon,
                              const char *alias);

int
qemuMonitorGetMigrationParams(qemuMonitor *mon,
                              virJSONValue **params);

int
qemuMonitorSetMigrationParams(qemuMonitor *mon,
                              virJSONValue **params);

typedef enum {
    QEMU_MONITOR_MIGRATION_STATUS_INACTIVE,
    QEMU_MONITOR_MIGRATION_STATUS_SETUP,
    QEMU_MONITOR_MIGRATION_STATUS_ACTIVE,
    QEMU_MONITOR_MIGRATION_STATUS_PRE_SWITCHOVER,
    QEMU_MONITOR_MIGRATION_STATUS_DEVICE,
    QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY,
    QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY_PAUSED,
    QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY_RECOVER,
    QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY_RECOVER_SETUP,
    QEMU_MONITOR_MIGRATION_STATUS_COMPLETED,
    QEMU_MONITOR_MIGRATION_STATUS_ERROR,
    QEMU_MONITOR_MIGRATION_STATUS_CANCELLING,
    QEMU_MONITOR_MIGRATION_STATUS_CANCELLED,
    QEMU_MONITOR_MIGRATION_STATUS_WAIT_UNPLUG,

    QEMU_MONITOR_MIGRATION_STATUS_LAST
} qemuMonitorMigrationStatus;

VIR_ENUM_DECL(qemuMonitorMigrationStatus);

typedef struct _qemuMonitorMigrationStats qemuMonitorMigrationStats;
struct _qemuMonitorMigrationStats {
    int status; /* qemuMonitorMigrationStatus */
    unsigned long long total_time;
    /* total or expected depending on status */
    bool downtime_set;
    unsigned long long downtime;
    /*
     * Duration of the QEMU 'setup' state.
     * for RDMA, this may be on the order of several seconds
     * if pinning support is requested before the migration begins.
     */
    bool setup_time_set;
    unsigned long long setup_time;

    unsigned long long ram_transferred;
    unsigned long long ram_remaining;
    unsigned long long ram_total;
    unsigned long long ram_bps;
    bool ram_duplicate_set;
    unsigned long long ram_duplicate;
    unsigned long long ram_normal;
    unsigned long long ram_normal_bytes;
    unsigned long long ram_dirty_rate;
    unsigned long long ram_page_size;
    unsigned long long ram_iteration;
    unsigned long long ram_postcopy_reqs;

    unsigned long long disk_transferred;
    unsigned long long disk_remaining;
    unsigned long long disk_total;
    unsigned long long disk_bps;

    bool xbzrle_set;
    unsigned long long xbzrle_cache_size;
    unsigned long long xbzrle_bytes;
    unsigned long long xbzrle_pages;
    unsigned long long xbzrle_cache_miss;
    unsigned long long xbzrle_overflow;

    int cpu_throttle_percentage;
    unsigned long long vfio_data_transferred;
};

int
qemuMonitorGetMigrationStats(qemuMonitor *mon,
                             qemuMonitorMigrationStats *stats,
                             char **error);

int
qemuMonitorGetMigrationCapabilities(qemuMonitor *mon,
                                    char ***capabilities);

int
qemuMonitorSetMigrationCapabilities(qemuMonitor *mon,
                                    virJSONValue **caps);

int
qemuMonitorGetGICCapabilities(qemuMonitor *mon,
                              virGICCapability **capabilities);

int
qemuMonitorGetSEVCapabilities(qemuMonitor *mon,
                              virSEVCapability **capabilities);

int
qemuMonitorGetSGXCapabilities(qemuMonitor *mon,
                              virSGXCapability **capabilities);

typedef enum {
  QEMU_MONITOR_MIGRATE_RESUME           = 1 << 0, /* resume failed post-copy migration */
  QEMU_MONITOR_MIGRATION_FLAGS_LAST
} QEMU_MONITOR_MIGRATE;

int
qemuMonitorMigrateToFd(qemuMonitor *mon,
                       unsigned int flags,
                       int fd);

int
qemuMonitorMigrateToFdSet(virDomainObj *vm,
                          int *fd,
                          int *directFd);

int
qemuMonitorMigrateToHost(qemuMonitor *mon,
                         unsigned int flags,
                         const char *protocol,
                         const char *hostname,
                         int port);

int
qemuMonitorMigrateToSocket(qemuMonitor *mon,
                           unsigned int flags,
                           const char *socketPath);

int
qemuMonitorMigrateCancel(qemuMonitor *mon);

int
qemuMonitorMigratePause(qemuMonitor *mon);

int
qemuMonitorGetDumpGuestMemoryCapability(qemuMonitor *mon,
                                        const char *capability);

int
qemuMonitorQueryDump(qemuMonitor *mon,
                     qemuMonitorDumpStats *stats);

int
qemuMonitorDumpToFd(qemuMonitor *mon,
                    int fd,
                    const char *dumpformat);

int
qemuMonitorGraphicsRelocate(qemuMonitor *mon,
                            int type,
                            const char *hostname,
                            int port,
                            int tlsPort,
                            const char *tlsSubject);

int
qemuMonitorAddFileHandleToSet(qemuMonitor *mon,
                              int fd,
                              int fdset,
                              const char *opaque);

int
qemuMonitorRemoveFdset(qemuMonitor *mon,
                       unsigned int fdset);

typedef struct _qemuMonitorFdsetFdInfo qemuMonitorFdsetFdInfo;
struct _qemuMonitorFdsetFdInfo {
    char *opaque;
};
typedef struct _qemuMonitorFdsetInfo qemuMonitorFdsetInfo;
struct _qemuMonitorFdsetInfo {
    unsigned int id;
    qemuMonitorFdsetFdInfo *fds;
    int nfds;
};
typedef struct _qemuMonitorFdsets qemuMonitorFdsets;
struct _qemuMonitorFdsets {
    qemuMonitorFdsetInfo *fdsets;
    int nfdsets;
};

void
qemuMonitorFdsetsFree(qemuMonitorFdsets *fdsets);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorFdsets, qemuMonitorFdsetsFree);

int
qemuMonitorQueryFdsets(qemuMonitor *mon,
                       qemuMonitorFdsets **fdsets);

int
qemuMonitorSendFileHandle(qemuMonitor *mon,
                          const char *fdname,
                          int fd);

/* This function preserves previous error and only set their own
 * error if no error was set before.
 */
int
qemuMonitorCloseFileHandle(qemuMonitor *mon,
                           const char *fdname);

int
qemuMonitorAddNetdev(qemuMonitor *mon,
                     virJSONValue **props);

int
qemuMonitorRemoveNetdev(qemuMonitor *mon,
                        const char *alias);

int
qemuMonitorQueryRxFilter(qemuMonitor *mon,
                         const char *alias,
                         virNetDevRxFilter **filter);

typedef struct _qemuMonitorChardevInfo qemuMonitorChardevInfo;
struct _qemuMonitorChardevInfo {
    char *ptyPath;
    virDomainChrDeviceState state;
};
void
qemuMonitorChardevInfoFree(void *data);

int
qemuMonitorGetChardevInfo(qemuMonitor *mon,
                          GHashTable **retinfo);

int
qemuMonitorAddDeviceProps(qemuMonitor *mon,
                          virJSONValue **props);

int
qemuMonitorDelDevice(qemuMonitor *mon,
                     const char *devalias);

int
qemuMonitorCreateObjectProps(virJSONValue **propsret,
                             const char *type,
                             const char *alias,
                             ...)
    G_GNUC_NULL_TERMINATED;

int
qemuMonitorAddObject(qemuMonitor *mon,
                     virJSONValue **props,
                     char **alias)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorDelObject(qemuMonitor *mon,
                     const char *objalias,
                     bool report_error);

int
qemuMonitorTransaction(qemuMonitor *mon,
                       virJSONValue **actions)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorBlockdevMirror(qemuMonitor *mon,
                          const char *jobname,
                          bool persistjob,
                          const char *device,
                          const char *target,
                          const char *replaces,
                          unsigned long long bandwidth,
                          unsigned int granularity,
                          unsigned long long buf_size,
                          bool shallow,
                          bool syncWrite,
                          bool targetIsZero)
    ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(5);

int
qemuMonitorBlockCommit(qemuMonitor *mon,
                       const char *device,
                       const char *jobname,
                       const char *topNode,
                       const char *baseNode,
                       const char *backingName,
                       unsigned long long bandwidth,
                       virTristateBool autofinalize)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorArbitraryCommand(qemuMonitor *mon,
                            const char *cmd,
                            int fd,
                            char **reply,
                            bool hmp);

int
qemuMonitorInjectNMI(qemuMonitor *mon);

int
qemuMonitorScreendump(qemuMonitor *mon,
                      const char *device,
                      unsigned int head,
                      const char *format,
                      const char *file);

int
qemuMonitorSendKey(qemuMonitor *mon,
                   unsigned int holdtime,
                   unsigned int *keycodes,
                   unsigned int nkeycodes);

int
qemuMonitorBlockStream(qemuMonitor *mon,
                       const char *device,
                       const char *jobname,
                       const char *baseNode,
                       const char *backingName,
                       unsigned long long bandwidth)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorBlockJobCancel(qemuMonitor *mon,
                          const char *jobname,
                          bool force)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorBlockJobSetSpeed(qemuMonitor *mon,
                            const char *jobname,
                            unsigned long long bandwidth);

typedef struct _qemuMonitorBlockJobInfo qemuMonitorBlockJobInfo;
struct _qemuMonitorBlockJobInfo {
    int type; /* virDomainBlockJobType */
    unsigned long long bandwidth; /* in bytes/s */
    virDomainBlockJobCursor cur;
    virDomainBlockJobCursor end;
    bool ready_present;
    bool ready;
};

GHashTable *
qemuMonitorGetAllBlockJobInfo(qemuMonitor *mon,
                              bool rawjobname);

int
qemuMonitorJobDismiss(qemuMonitor *mon,
                      const char *jobname)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorJobFinalize(qemuMonitor *mon,
                       const char *jobname)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorJobComplete(qemuMonitor *mon,
                       const char *jobname)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorOpenGraphics(qemuMonitor *mon,
                        const char *protocol,
                        int fd,
                        const char *fdname,
                        bool skipauth);

int
qemuMonitorSetBlockIoThrottle(qemuMonitor *mon,
                              const char *qomid,
                              virDomainBlockIoTuneInfo *info);

int
qemuMonitorGetBlockIoThrottle(qemuMonitor *mon,
                              const char *qdevid,
                              virDomainBlockIoTuneInfo *reply);

int
qemuMonitorThrottleGroupLimits(virJSONValue *limits,
                               const virDomainThrottleGroupDef *group);

int
qemuMonitorUpdateThrottleGroup(qemuMonitor *mon,
                               const char *qomid,
                               virDomainBlockIoTuneInfo *info);

int
qemuMonitorSystemWakeup(qemuMonitor *mon);

int
qemuMonitorGetVersion(qemuMonitor *mon,
                      int *major,
                      int *minor,
                      int *micro,
                      char **package)
    ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);


typedef struct _qemuMonitorMachineInfo qemuMonitorMachineInfo;
struct _qemuMonitorMachineInfo {
    char *name;
    bool isDefault;
    char *alias;
    unsigned int maxCpus;
    bool hotplugCpus;
    char *defaultCPU;
    bool numaMemSupported;
    char *defaultRAMid;
    bool deprecated;
    virTristateBool acpi;
};

int
qemuMonitorGetMachines(qemuMonitor *mon,
                       qemuMonitorMachineInfo ***machines);

void
qemuMonitorMachineInfoFree(qemuMonitorMachineInfo *machine);

typedef struct _qemuMonitorCPUDefInfo qemuMonitorCPUDefInfo;
struct _qemuMonitorCPUDefInfo {
    virDomainCapsCPUUsable usable;
    char *name;
    char *type;
    char **blockers; /* NULL-terminated string list */
    bool deprecated;
};

typedef struct _qemuMonitorCPUDefs qemuMonitorCPUDefs;
struct _qemuMonitorCPUDefs {
    size_t ncpus;
    qemuMonitorCPUDefInfo *cpus;
};

int
qemuMonitorGetCPUDefinitions(qemuMonitor *mon,
                             qemuMonitorCPUDefs **cpuDefs);

qemuMonitorCPUDefs *
qemuMonitorCPUDefsNew(size_t count);

qemuMonitorCPUDefs *
qemuMonitorCPUDefsCopy(qemuMonitorCPUDefs *src);

void
qemuMonitorCPUDefsFree(qemuMonitorCPUDefs *defs);

G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorCPUDefs, qemuMonitorCPUDefsFree);


typedef enum {
    QEMU_MONITOR_CPU_PROPERTY_BOOLEAN,
    QEMU_MONITOR_CPU_PROPERTY_STRING,
    QEMU_MONITOR_CPU_PROPERTY_NUMBER,

    QEMU_MONITOR_CPU_PROPERTY_LAST
} qemuMonitorCPUPropertyType;

VIR_ENUM_DECL(qemuMonitorCPUProperty);

typedef struct _qemuMonitorCPUProperty qemuMonitorCPUProperty;
struct _qemuMonitorCPUProperty {
    char *name;
    qemuMonitorCPUPropertyType type;
    union {
        bool boolean;
        char *string;
        long long number;
    } value;
    virTristateBool migratable;
};

typedef struct _qemuMonitorCPUModelInfo qemuMonitorCPUModelInfo;
struct _qemuMonitorCPUModelInfo {
    char *name;
    size_t nprops;
    qemuMonitorCPUProperty *props;
    GStrv full_dep_props;   /* deprecated properties resulting from a full model expansion */
    GStrv static_dep_props; /* deprecated properties resulting from a static model expansion */
    bool migratability;
};

typedef enum {
    QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC,
    QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC_FULL,
    QEMU_MONITOR_CPU_MODEL_EXPANSION_FULL,
} qemuMonitorCPUModelExpansionType;

int
qemuMonitorGetCPUModelExpansion(qemuMonitor *mon,
                                qemuMonitorCPUModelExpansionType type,
                                virCPUDef *cpu,
                                bool migratable,
                                bool hv_passthrough,
                                bool fail_no_props,
                                qemuMonitorCPUModelInfo **model_info);

void
qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfo *model_info);

G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorCPUModelInfo, qemuMonitorCPUModelInfoFree);

int
qemuMonitorGetCPUModelBaseline(qemuMonitor *mon,
                               virCPUDef *cpu_a,
                               virCPUDef *cpu_b,
                               qemuMonitorCPUModelInfo **baseline);

int
qemuMonitorGetCPUModelComparison(qemuMonitor *mon,
                                 virCPUDef *cpu_a,
                                 virCPUDef *cpu_b,
                                 char **result);

qemuMonitorCPUModelInfo *
qemuMonitorCPUModelInfoCopy(const qemuMonitorCPUModelInfo *orig);

GHashTable *
qemuMonitorGetCommandLineOptions(qemuMonitor *mon);

int
qemuMonitorGetKVMState(qemuMonitor *mon,
                       bool *enabled,
                       bool *present);

int
qemuMonitorGetAccelerators(qemuMonitor *mon,
                           char **enabled);

int
qemuMonitorGetObjectTypes(qemuMonitor *mon,
                          char ***types);

GHashTable *
qemuMonitorGetDeviceProps(qemuMonitor *mon,
                          const char *device);

int
qemuMonitorGetObjectProps(qemuMonitor *mon,
                          const char *object,
                          char ***props);

char *
qemuMonitorGetTargetArch(qemuMonitor *mon);

int
qemuMonitorNBDServerStart(qemuMonitor *mon,
                          const virStorageNetHostDef *server,
                          const char *tls_alias)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorNBDServerStop(qemuMonitor *mon);

int
qemuMonitorBlockExportAdd(qemuMonitor *mon,
                          virJSONValue **props);

int
qemuMonitorAttachCharDev(qemuMonitor *mon,
                         virJSONValue **props,
                         char **ptypath);

int
qemuMonitorDetachCharDev(qemuMonitor *mon,
                         const char *chrID);

int
qemuMonitorGetDeviceAliases(qemuMonitor *mon,
                            char ***aliases);

typedef void (*qemuMonitorReportDomainLogError)(qemuMonitor *mon,
                                                const char *msg,
                                                void *opaque);
void
qemuMonitorSetDomainLogLocked(qemuMonitor *mon,
                              qemuMonitorReportDomainLogError func,
                              void *opaque,
                              virFreeCallback destroy);

void
qemuMonitorSetDomainLog(qemuMonitor *mon,
                        qemuMonitorReportDomainLogError func,
                        void *opaque,
                        virFreeCallback destroy);

typedef const char *(*qemuMonitorCPUFeatureTranslationCallback)(virArch arch,
                                                                const char *name);

int
qemuMonitorGetGuestCPU(qemuMonitor *mon,
                       virArch arch,
                       bool qomListGet,
                       const char *cpuQOMPath,
                       qemuMonitorCPUFeatureTranslationCallback translate,
                       virCPUDefFeatureFilter filter,
                       virCPUData **enabled,
                       virCPUData **disabled);

int
qemuMonitorRTCResetReinjection(qemuMonitor *mon);

typedef struct _qemuMonitorIOThreadInfo qemuMonitorIOThreadInfo;
struct _qemuMonitorIOThreadInfo {
    unsigned int iothread_id;
    int thread_id;
    bool poll_valid;
    unsigned long long poll_max_ns;
    unsigned long long poll_grow;
    unsigned long long poll_shrink;
    int thread_pool_min;
    int thread_pool_max;
    bool set_poll_max_ns;
    bool set_poll_grow;
    bool set_poll_shrink;
    bool set_thread_pool_min;
    bool set_thread_pool_max;
};

int
qemuMonitorGetIOThreads(qemuMonitor *mon,
                        qemuMonitorIOThreadInfo ***iothreads,
                        int *niothreads);
int
qemuMonitorSetIOThread(qemuMonitor *mon,
                       qemuMonitorIOThreadInfo *iothreadInfo);

typedef struct _qemuMonitorMemoryDeviceInfo qemuMonitorMemoryDeviceInfo;
struct _qemuMonitorMemoryDeviceInfo {
    /* For pc-dimm */
    unsigned long long address;
    unsigned int slot;
    bool hotplugged;
    bool hotpluggable;
    /* For virtio-mem */
    unsigned long long size; /* in bytes */
};

int
qemuMonitorGetMemoryDeviceInfo(qemuMonitor *mon,
                               GHashTable **info)
    ATTRIBUTE_NONNULL(2);

int
qemuMonitorMigrateIncoming(qemuMonitor *mon,
                           const char *uri,
                           virTristateBool exitOnError);

int
qemuMonitorMigrateStartPostCopy(qemuMonitor *mon);

int
qemuMonitorMigrateContinue(qemuMonitor *mon,
                           qemuMonitorMigrationStatus status);

int
qemuMonitorGetRTCTime(qemuMonitor *mon,
                      struct tm *tm);

virJSONValue *
qemuMonitorQueryQMPSchema(qemuMonitor *mon);

int
qemuMonitorSetBlockThreshold(qemuMonitor *mon,
                             const char *nodename,
                             unsigned long long threshold);

int
qemuMonitorSetWatchdogAction(qemuMonitor *mon,
                             const char *action);

int
qemuMonitorBlockdevCreate(qemuMonitor *mon,
                          const char *jobname,
                          virJSONValue **props);

int
qemuMonitorBlockdevAdd(qemuMonitor *mon,
                       virJSONValue **props);

int
qemuMonitorBlockdevReopen(qemuMonitor *mon,
                          virJSONValue **options);

int
qemuMonitorBlockdevDel(qemuMonitor *mon,
                       const char *nodename);

int
qemuMonitorBlockdevTrayOpen(qemuMonitor *mon,
                            const char *id,
                            bool force);

int
qemuMonitorBlockdevTrayClose(qemuMonitor *mon,
                             const char *id);

int
qemuMonitorBlockdevMediumRemove(qemuMonitor *mon,
                                const char *id);

int
qemuMonitorBlockdevMediumInsert(qemuMonitor *mon,
                                const char *id,
                                const char *nodename);

char *
qemuMonitorGetSEVMeasurement(qemuMonitor *mon);

typedef struct _qemuMonitorSEVGuestInfo qemuMonitorSEVGuestInfo;
struct _qemuMonitorSEVGuestInfo {
    unsigned int policy;
    unsigned int handle;
};

typedef struct _qemuMonitorSEVSNPGuestInfo qemuMonitorSEVSNPGuestInfo;
struct _qemuMonitorSEVSNPGuestInfo {
    unsigned long long snp_policy;
};


typedef enum {
    QEMU_MONITOR_SEV_GUEST_TYPE_SEV,
    QEMU_MONITOR_SEV_GUEST_TYPE_SEV_SNP,

    QEMU_MONITOR_SEV_GUEST_TYPE_LAST
} qemuMonitorSEVGuestType;

VIR_ENUM_DECL(qemuMonitorSEVGuest);

typedef struct _qemuMonitorSEVInfo qemuMonitorSEVInfo;
struct _qemuMonitorSEVInfo {
    unsigned int apiMajor;
    unsigned int apiMinor;
    unsigned int buildID;
    qemuMonitorSEVGuestType type;
    union {
        qemuMonitorSEVGuestInfo sev;
        qemuMonitorSEVSNPGuestInfo sev_snp;
    } data;
};

int
qemuMonitorGetSEVInfo(qemuMonitor *mon,
                      qemuMonitorSEVInfo *info)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);

int
qemuMonitorSetLaunchSecurityState(qemuMonitor *mon,
                                  const char *secrethdr,
                                  const char *secret,
                                  unsigned long long setaddr,
                                  bool hasSetaddr);

typedef struct _qemuMonitorPRManagerInfo qemuMonitorPRManagerInfo;
struct _qemuMonitorPRManagerInfo {
    bool connected;
};

int
qemuMonitorGetPRManagerInfo(qemuMonitor *mon,
                            GHashTable **retinfo);

typedef struct  _qemuMonitorCurrentMachineInfo qemuMonitorCurrentMachineInfo;
struct _qemuMonitorCurrentMachineInfo {
    bool wakeupSuspendSupport;
};

int
qemuMonitorGetCurrentMachineInfo(qemuMonitor *mon,
                                 qemuMonitorCurrentMachineInfo *info);

void
qemuMonitorJobInfoFree(qemuMonitorJobInfo *job);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorJobInfo, qemuMonitorJobInfoFree);

int
qemuMonitorGetJobInfo(qemuMonitor *mon,
                      qemuMonitorJobInfo ***jobs,
                      size_t *njobs);

int
qemuMonitorGetCPUMigratable(qemuMonitor *mon,
                            const char *cpuQOMPath,
                            bool *migratable);

int
qemuMonitorTransactionBitmapAdd(virJSONValue *actions,
                                const char *node,
                                const char *name,
                                bool persistent,
                                bool disabled,
                                unsigned long long granularity);
int
qemuMonitorTransactionBitmapRemove(virJSONValue *actions,
                                   const char *node,
                                   const char *name);

int
qemuMonitorBitmapRemove(qemuMonitor *mon,
                        const char *node,
                        const char *name);
int
qemuMonitorTransactionBitmapMerge(virJSONValue *actions,
                                  const char *node,
                                  const char *target,
                                  virJSONValue **sources);
int
qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValue *sources,
                                                 const char *sourcenode,
                                                 const char *sourcebitmap);

int
qemuMonitorTransactionSnapshotBlockdev(virJSONValue *actions,
                                       const char *node,
                                       const char *overlay);

typedef enum {
    QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_NONE = 0,
    QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_INCREMENTAL,
    QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_FULL,
    QEMU_MONITOR_TRANSACTION_BACKUP_SYNC_MODE_LAST,
} qemuMonitorTransactionBackupSyncMode;

int
qemuMonitorTransactionBackup(virJSONValue *actions,
                             const char *device,
                             const char *jobname,
                             const char *target,
                             const char *bitmap,
                             qemuMonitorTransactionBackupSyncMode syncmode);

/**
 * qemuMonitorDirtyRateCalcMode:
 *
 * Dirty page rate calculation mode used during measurement.
 */
typedef enum {
    QEMU_MONITOR_DIRTYRATE_CALC_MODE_PAGE_SAMPLING = 0,
    QEMU_MONITOR_DIRTYRATE_CALC_MODE_DIRTY_BITMAP,
    QEMU_MONITOR_DIRTYRATE_CALC_MODE_DIRTY_RING,
    QEMU_MONITOR_DIRTYRATE_CALC_MODE_LAST,
} qemuMonitorDirtyRateCalcMode;

VIR_ENUM_DECL(qemuMonitorDirtyRateCalcMode);

int
qemuMonitorStartDirtyRateCalc(qemuMonitor *mon,
                              int seconds,
                              qemuMonitorDirtyRateCalcMode mode);

typedef struct _qemuMonitorDirtyRateVcpu qemuMonitorDirtyRateVcpu;
struct _qemuMonitorDirtyRateVcpu {
    int idx;                    /* virtual cpu index */
    unsigned long long value;   /* virtual cpu dirty page rate in MB/s */
};

typedef struct _qemuMonitorDirtyRateInfo qemuMonitorDirtyRateInfo;
struct _qemuMonitorDirtyRateInfo {
    int status;             /* the status of last dirtyrate calculation,
                               one of virDomainDirtyRateStatus */
    int calcTime;           /* the period of dirtyrate calculation */
    long long startTime;    /* the start time of dirtyrate calculation */
    long long dirtyRate;    /* the dirtyrate in MiB/s */
    qemuMonitorDirtyRateCalcMode mode;  /* calculation mode used in
                                           last measurement */
    size_t nvcpus;  /* number of virtual cpu */
    qemuMonitorDirtyRateVcpu *rates; /* array of dirty page rate */
};

int
qemuMonitorQueryDirtyRate(qemuMonitor *mon,
                          qemuMonitorDirtyRateInfo *info);

int
qemuMonitorSetAction(qemuMonitor *mon,
                     qemuMonitorActionShutdown shutdown,
                     qemuMonitorActionReboot reboot,
                     qemuMonitorActionWatchdog watchdog,
                     qemuMonitorActionPanic panic);

int
qemuMonitorChangeMemoryRequestedSize(qemuMonitor *mon,
                                     const char *alias,
                                     unsigned long long requestedsize);

int
qemuMonitorMigrateRecover(qemuMonitor *mon,
                          const char *uri);

int
qemuMonitorGetMigrationBlockers(qemuMonitor *mon,
                                char ***blockers);

typedef enum {
    QEMU_MONITOR_QUERY_STATS_TARGET_VM,
    QEMU_MONITOR_QUERY_STATS_TARGET_VCPU,
    QEMU_MONITOR_QUERY_STATS_TARGET_LAST,
} qemuMonitorQueryStatsTargetType;

VIR_ENUM_DECL(qemuMonitorQueryStatsTarget);

typedef enum {
    QEMU_MONITOR_QUERY_STATS_NAME_HALT_POLL_SUCCESS_NS,
    QEMU_MONITOR_QUERY_STATS_NAME_HALT_POLL_FAIL_NS,
    QEMU_MONITOR_QUERY_STATS_NAME_LAST,
} qemuMonitorQueryStatsNameType;

VIR_ENUM_DECL(qemuMonitorQueryStatsName);

typedef enum {
    QEMU_MONITOR_QUERY_STATS_PROVIDER_KVM,
    QEMU_MONITOR_QUERY_STATS_PROVIDER_LAST,
} qemuMonitorQueryStatsProviderType;

VIR_ENUM_DECL(qemuMonitorQueryStatsProvider);

typedef struct _qemuMonitorQueryStatsProvider qemuMonitorQueryStatsProvider;
struct _qemuMonitorQueryStatsProvider {
    qemuMonitorQueryStatsProviderType type;
    virBitmap *names;
};

void
qemuMonitorQueryStatsProviderFree(qemuMonitorQueryStatsProvider *provider);

qemuMonitorQueryStatsProvider *
qemuMonitorQueryStatsProviderNew(qemuMonitorQueryStatsProviderType provider_type,
                                 ...);

G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMonitorQueryStatsProvider,
                              qemuMonitorQueryStatsProviderFree);

typedef enum {
    QEMU_MONITOR_QUERY_STATS_UNIT_BYTES,
    QEMU_MONITOR_QUERY_STATS_UNIT_SECONDS,
    QEMU_MONITOR_QUERY_STATS_UNIT_CYCLES,
    QEMU_MONITOR_QUERY_STATS_UNIT_BOOLEAN,

    QEMU_MONITOR_QUERY_STATS_UNIT_LAST
} qemuMonitorQueryStatsUnitType;

VIR_ENUM_DECL(qemuMonitorQueryStatsUnit);

typedef enum {
    QEMU_MONITOR_QUERY_STATS_TYPE_CUMULATIVE,
    QEMU_MONITOR_QUERY_STATS_TYPE_INSTANT,
    QEMU_MONITOR_QUERY_STATS_TYPE_PEAK,
    QEMU_MONITOR_QUERY_STATS_TYPE_LINEAR_HISTOGRAM,
    QEMU_MONITOR_QUERY_STATS_TYPE_LOG2_HISTOGRAM,

    QEMU_MONITOR_QUERY_STATS_TYPE_LAST
} qemuMonitorQueryStatsTypeType;

VIR_ENUM_DECL(qemuMonitorQueryStatsType);

typedef struct _qemuMonitorQueryStatsSchemaData qemuMonitorQueryStatsSchemaData;
struct _qemuMonitorQueryStatsSchemaData {
    qemuMonitorQueryStatsTargetType target;
    qemuMonitorQueryStatsUnitType unit;
    qemuMonitorQueryStatsTypeType type;
    unsigned int bucket_size;
    int base;
    int exponent;
};

GHashTable *
qemuMonitorQueryStatsSchema(qemuMonitor *mon,
                            qemuMonitorQueryStatsProviderType provider_type);

virJSONValue *
qemuMonitorQueryStats(qemuMonitor *mon,
                      qemuMonitorQueryStatsTargetType target,
                      char **vcpus,
                      GPtrArray *providers);

GHashTable *
qemuMonitorExtractQueryStats(virJSONValue *info);

virJSONValue *
qemuMonitorGetStatsByQOMPath(virJSONValue *arr,
                             char *qom_path);

int
qemuMonitorDisplayReload(qemuMonitor *mon,
                         const char *type,
                         bool tlsCerts);


int
qemuMonitorSnapshotSave(qemuMonitor *mon,
                        const char *jobname,
                        const char *snapshotname,
                        const char *vmstate_disk,
                        const char **disks);

int
qemuMonitorSnapshotLoad(qemuMonitor *mon,
                        const char *jobname,
                        const char *snapshotname,
                        const char *vmstate_disk,
                        const char **disks);

int
qemuMonitorSnapshotDelete(qemuMonitor *mon,
                          const char *jobname,
                          const char *snapshotname,
                          const char **disks);

int
qemuMonitorBlockdevSetActive(qemuMonitor *mon,
                             const char *nodename,
                             bool active);

int
qemuMonitorBlockLatencyHistogramSet(qemuMonitor *mon,
                                    const char *id,
                                    unsigned int *boundaries,
                                    unsigned int *boundaries_read,
                                    unsigned int *boundaries_write,
                                    unsigned int *boundaries_zone,
                                    unsigned int *boundaries_flush);

int
qemuMonitorAnnounceSelf(qemuMonitor *mon,
                        const char *device,
                        unsigned int initial,
                        unsigned int max,
                        unsigned int rounds,
                        unsigned int step);
