#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QapiErrorClass {
#[serde(rename = "GenericError")] GenericError,
#[serde(rename = "CommandNotFound")] CommandNotFound,
#[serde(rename = "DeviceNotActive")] DeviceNotActive,
#[serde(rename = "DeviceNotFound")] DeviceNotFound,
#[serde(rename = "KVMMissingCap")] KVMMissingCap,
}
impl ::core::str::FromStr for QapiErrorClass {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QapiErrorClass {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
QapiErrorClass::GenericError,
QapiErrorClass::CommandNotFound,
QapiErrorClass::DeviceNotActive,
QapiErrorClass::DeviceNotFound,
QapiErrorClass::KVMMissingCap,
];
const NAMES: &'static [&'static str] = &[
"GenericError",
"CommandNotFound",
"DeviceNotActive",
"DeviceNotFound",
"KVMMissingCap",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum IoOperationType {
#[serde(rename = "read")] read,
#[serde(rename = "write")] write,
}
impl ::core::str::FromStr for IoOperationType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for IoOperationType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
IoOperationType::read,
IoOperationType::write,
];
const NAMES: &'static [&'static str] = &[
"read",
"write",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum OnOffAuto {
#[serde(rename = "auto")] auto,
#[serde(rename = "on")] on,
#[serde(rename = "off")] off,
}
impl ::core::str::FromStr for OnOffAuto {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for OnOffAuto {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
OnOffAuto::auto,
OnOffAuto::on,
OnOffAuto::off,
];
const NAMES: &'static [&'static str] = &[
"auto",
"on",
"off",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum OnOffSplit {
#[serde(rename = "on")] on,
#[serde(rename = "off")] off,
#[serde(rename = "split")] split,
}
impl ::core::str::FromStr for OnOffSplit {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for OnOffSplit {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
OnOffSplit::on,
OnOffSplit::off,
OnOffSplit::split,
];
const NAMES: &'static [&'static str] = &[
"on",
"off",
"split",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum StrOrNull {
#[serde(rename = "s")] s(::std::string::String),
#[serde(rename = "n")] n(()),
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum OffAutoPCIBAR {
#[serde(rename = "off")] off,
#[serde(rename = "auto")] auto,
#[serde(rename = "bar0")] bar0,
#[serde(rename = "bar1")] bar1,
#[serde(rename = "bar2")] bar2,
#[serde(rename = "bar3")] bar3,
#[serde(rename = "bar4")] bar4,
#[serde(rename = "bar5")] bar5,
}
impl ::core::str::FromStr for OffAutoPCIBAR {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for OffAutoPCIBAR {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 8;
const VARIANTS: &'static [Self] = &[
OffAutoPCIBAR::off,
OffAutoPCIBAR::auto,
OffAutoPCIBAR::bar0,
OffAutoPCIBAR::bar1,
OffAutoPCIBAR::bar2,
OffAutoPCIBAR::bar3,
OffAutoPCIBAR::bar4,
OffAutoPCIBAR::bar5,
];
const NAMES: &'static [&'static str] = &[
"off",
"auto",
"bar0",
"bar1",
"bar2",
"bar3",
"bar4",
"bar5",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum PCIELinkSpeed {
#[serde(rename = "2_5")] _2_5,
#[serde(rename = "5")] _5,
#[serde(rename = "8")] _8,
#[serde(rename = "16")] _16,
}
impl ::core::str::FromStr for PCIELinkSpeed {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for PCIELinkSpeed {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
PCIELinkSpeed::_2_5,
PCIELinkSpeed::_5,
PCIELinkSpeed::_8,
PCIELinkSpeed::_16,
];
const NAMES: &'static [&'static str] = &[
"2_5",
"5",
"8",
"16",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum PCIELinkWidth {
#[serde(rename = "1")] _1,
#[serde(rename = "2")] _2,
#[serde(rename = "4")] _4,
#[serde(rename = "8")] _8,
#[serde(rename = "12")] _12,
#[serde(rename = "16")] _16,
#[serde(rename = "32")] _32,
}
impl ::core::str::FromStr for PCIELinkWidth {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for PCIELinkWidth {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
PCIELinkWidth::_1,
PCIELinkWidth::_2,
PCIELinkWidth::_4,
PCIELinkWidth::_8,
PCIELinkWidth::_12,
PCIELinkWidth::_16,
PCIELinkWidth::_32,
];
const NAMES: &'static [&'static str] = &[
"1",
"2",
"4",
"8",
"12",
"16",
"32",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum NetworkAddressFamily {
#[serde(rename = "ipv4")] ipv4,
#[serde(rename = "ipv6")] ipv6,
#[serde(rename = "unix")] unix,
#[serde(rename = "vsock")] vsock,
#[serde(rename = "unknown")] unknown,
}
impl ::core::str::FromStr for NetworkAddressFamily {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for NetworkAddressFamily {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
NetworkAddressFamily::ipv4,
NetworkAddressFamily::ipv6,
NetworkAddressFamily::unix,
NetworkAddressFamily::vsock,
NetworkAddressFamily::unknown,
];
const NAMES: &'static [&'static str] = &[
"ipv4",
"ipv6",
"unix",
"vsock",
"unknown",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SocketAddressLegacy {
#[serde(rename = "fd")]
fd { data: String },
#[serde(rename = "inet")]
inet { data: InetSocketAddress },
#[serde(rename = "unix")]
unix { data: UnixSocketAddress },
#[serde(rename = "vsock")]
vsock { data: VsockSocketAddress },
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SocketAddressType {
#[serde(rename = "inet")] inet,
#[serde(rename = "unix")] unix,
#[serde(rename = "vsock")] vsock,
#[serde(rename = "fd")] fd,
}
impl ::core::str::FromStr for SocketAddressType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SocketAddressType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
SocketAddressType::inet,
SocketAddressType::unix,
SocketAddressType::vsock,
SocketAddressType::fd,
];
const NAMES: &'static [&'static str] = &[
"inet",
"unix",
"vsock",
"fd",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RunState {
#[serde(rename = "debug")] debug,
#[serde(rename = "inmigrate")] inmigrate,
#[serde(rename = "internal-error")] internal_error,
#[serde(rename = "io-error")] io_error,
#[serde(rename = "paused")] paused,
#[serde(rename = "postmigrate")] postmigrate,
#[serde(rename = "prelaunch")] prelaunch,
#[serde(rename = "finish-migrate")] finish_migrate,
#[serde(rename = "restore-vm")] restore_vm,
#[serde(rename = "running")] running,
#[serde(rename = "save-vm")] save_vm,
#[serde(rename = "shutdown")] shutdown,
#[serde(rename = "suspended")] suspended,
#[serde(rename = "watchdog")] watchdog,
#[serde(rename = "guest-panicked")] guest_panicked,
#[serde(rename = "colo")] colo,
#[serde(rename = "preconfig")] preconfig,
}
impl ::core::str::FromStr for RunState {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for RunState {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 17;
const VARIANTS: &'static [Self] = &[
RunState::debug,
RunState::inmigrate,
RunState::internal_error,
RunState::io_error,
RunState::paused,
RunState::postmigrate,
RunState::prelaunch,
RunState::finish_migrate,
RunState::restore_vm,
RunState::running,
RunState::save_vm,
RunState::shutdown,
RunState::suspended,
RunState::watchdog,
RunState::guest_panicked,
RunState::colo,
RunState::preconfig,
];
const NAMES: &'static [&'static str] = &[
"debug",
"inmigrate",
"internal-error",
"io-error",
"paused",
"postmigrate",
"prelaunch",
"finish-migrate",
"restore-vm",
"running",
"save-vm",
"shutdown",
"suspended",
"watchdog",
"guest-panicked",
"colo",
"preconfig",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ShutdownCause {
#[serde(rename = "none")] none,
#[serde(rename = "host-error")] host_error,
#[serde(rename = "host-qmp-quit")] host_qmp_quit,
#[serde(rename = "host-qmp-system-reset")] host_qmp_system_reset,
#[serde(rename = "host-signal")] host_signal,
#[serde(rename = "host-ui")] host_ui,
#[serde(rename = "guest-shutdown")] guest_shutdown,
#[serde(rename = "guest-reset")] guest_reset,
#[serde(rename = "guest-panic")] guest_panic,
#[serde(rename = "subsystem-reset")] subsystem_reset,
}
impl ::core::str::FromStr for ShutdownCause {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for ShutdownCause {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 10;
const VARIANTS: &'static [Self] = &[
ShutdownCause::none,
ShutdownCause::host_error,
ShutdownCause::host_qmp_quit,
ShutdownCause::host_qmp_system_reset,
ShutdownCause::host_signal,
ShutdownCause::host_ui,
ShutdownCause::guest_shutdown,
ShutdownCause::guest_reset,
ShutdownCause::guest_panic,
ShutdownCause::subsystem_reset,
];
const NAMES: &'static [&'static str] = &[
"none",
"host-error",
"host-qmp-quit",
"host-qmp-system-reset",
"host-signal",
"host-ui",
"guest-shutdown",
"guest-reset",
"guest-panic",
"subsystem-reset",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_status {
}
impl crate::QmpCommand for query_status { }
impl ::qapi_spec::Command for query_status {
const NAME: &'static str = "query-status";
const ALLOW_OOB: bool = false;
type Ok = StatusInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SHUTDOWN {
#[serde(rename = "guest")]
pub guest: bool,
#[serde(rename = "reason")]
pub reason: ShutdownCause,
}
impl ::qapi_spec::Event for SHUTDOWN {
const NAME: &'static str = "SHUTDOWN";
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct POWERDOWN {
}
impl ::qapi_spec::Event for POWERDOWN {
const NAME: &'static str = "POWERDOWN";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RESET {
#[serde(rename = "guest")]
pub guest: bool,
#[serde(rename = "reason")]
pub reason: ShutdownCause,
}
impl ::qapi_spec::Event for RESET {
const NAME: &'static str = "RESET";
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct STOP {
}
impl ::qapi_spec::Event for STOP {
const NAME: &'static str = "STOP";
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct RESUME {
}
impl ::qapi_spec::Event for RESUME {
const NAME: &'static str = "RESUME";
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SUSPEND {
}
impl ::qapi_spec::Event for SUSPEND {
const NAME: &'static str = "SUSPEND";
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SUSPEND_DISK {
}
impl ::qapi_spec::Event for SUSPEND_DISK {
const NAME: &'static str = "SUSPEND_DISK";
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct WAKEUP {
}
impl ::qapi_spec::Event for WAKEUP {
const NAME: &'static str = "WAKEUP";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WATCHDOG {
#[serde(rename = "action")]
pub action: WatchdogAction,
}
impl ::qapi_spec::Event for WATCHDOG {
const NAME: &'static str = "WATCHDOG";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum WatchdogAction {
#[serde(rename = "reset")] reset,
#[serde(rename = "shutdown")] shutdown,
#[serde(rename = "poweroff")] poweroff,
#[serde(rename = "pause")] pause,
#[serde(rename = "debug")] debug,
#[serde(rename = "none")] none,
#[serde(rename = "inject-nmi")] inject_nmi,
}
impl ::core::str::FromStr for WatchdogAction {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for WatchdogAction {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
WatchdogAction::reset,
WatchdogAction::shutdown,
WatchdogAction::poweroff,
WatchdogAction::pause,
WatchdogAction::debug,
WatchdogAction::none,
WatchdogAction::inject_nmi,
];
const NAMES: &'static [&'static str] = &[
"reset",
"shutdown",
"poweroff",
"pause",
"debug",
"none",
"inject-nmi",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct watchdog_set_action {
#[serde(rename = "action")]
pub action: WatchdogAction,
}
impl crate::QmpCommand for watchdog_set_action { }
impl ::qapi_spec::Command for watchdog_set_action {
const NAME: &'static str = "watchdog-set-action";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GUEST_PANICKED {
#[serde(rename = "info", default, skip_serializing_if = "Option::is_none")]
pub info: Option<GuestPanicInformation>,
#[serde(rename = "action")]
pub action: GuestPanicAction,
}
impl ::qapi_spec::Event for GUEST_PANICKED {
const NAME: &'static str = "GUEST_PANICKED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GUEST_CRASHLOADED {
#[serde(rename = "action")]
pub action: GuestPanicAction,
#[serde(rename = "info", default, skip_serializing_if = "Option::is_none")]
pub info: Option<GuestPanicInformation>,
}
impl ::qapi_spec::Event for GUEST_CRASHLOADED {
const NAME: &'static str = "GUEST_CRASHLOADED";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestPanicAction {
#[serde(rename = "pause")] pause,
#[serde(rename = "poweroff")] poweroff,
#[serde(rename = "run")] run,
}
impl ::core::str::FromStr for GuestPanicAction {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestPanicAction {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
GuestPanicAction::pause,
GuestPanicAction::poweroff,
GuestPanicAction::run,
];
const NAMES: &'static [&'static str] = &[
"pause",
"poweroff",
"run",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GuestPanicInformationType {
#[serde(rename = "hyper-v")] hyper_v,
#[serde(rename = "s390")] s390,
}
impl ::core::str::FromStr for GuestPanicInformationType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GuestPanicInformationType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
GuestPanicInformationType::hyper_v,
GuestPanicInformationType::s390,
];
const NAMES: &'static [&'static str] = &[
"hyper-v",
"s390",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum S390CrashReason {
#[serde(rename = "unknown")] unknown,
#[serde(rename = "disabled-wait")] disabled_wait,
#[serde(rename = "extint-loop")] extint_loop,
#[serde(rename = "pgmint-loop")] pgmint_loop,
#[serde(rename = "opint-loop")] opint_loop,
}
impl ::core::str::FromStr for S390CrashReason {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for S390CrashReason {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
S390CrashReason::unknown,
S390CrashReason::disabled_wait,
S390CrashReason::extint_loop,
S390CrashReason::pgmint_loop,
S390CrashReason::opint_loop,
];
const NAMES: &'static [&'static str] = &[
"unknown",
"disabled-wait",
"extint-loop",
"pgmint-loop",
"opint-loop",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MEMORY_FAILURE {
#[serde(rename = "action")]
pub action: MemoryFailureAction,
#[serde(rename = "flags")]
pub flags: MemoryFailureFlags,
#[serde(rename = "recipient")]
pub recipient: MemoryFailureRecipient,
}
impl ::qapi_spec::Event for MEMORY_FAILURE {
const NAME: &'static str = "MEMORY_FAILURE";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MemoryFailureRecipient {
#[serde(rename = "hypervisor")] hypervisor,
#[serde(rename = "guest")] guest,
}
impl ::core::str::FromStr for MemoryFailureRecipient {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MemoryFailureRecipient {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
MemoryFailureRecipient::hypervisor,
MemoryFailureRecipient::guest,
];
const NAMES: &'static [&'static str] = &[
"hypervisor",
"guest",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MemoryFailureAction {
#[serde(rename = "ignore")] ignore,
#[serde(rename = "inject")] inject,
#[serde(rename = "fatal")] fatal,
#[serde(rename = "reset")] reset,
}
impl ::core::str::FromStr for MemoryFailureAction {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MemoryFailureAction {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
MemoryFailureAction::ignore,
MemoryFailureAction::inject,
MemoryFailureAction::fatal,
MemoryFailureAction::reset,
];
const NAMES: &'static [&'static str] = &[
"ignore",
"inject",
"fatal",
"reset",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoTLSCredsEndpoint {
#[serde(rename = "client")] client,
#[serde(rename = "server")] server,
}
impl ::core::str::FromStr for QCryptoTLSCredsEndpoint {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoTLSCredsEndpoint {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
QCryptoTLSCredsEndpoint::client,
QCryptoTLSCredsEndpoint::server,
];
const NAMES: &'static [&'static str] = &[
"client",
"server",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoSecretFormat {
#[serde(rename = "raw")] raw,
#[serde(rename = "base64")] base64,
}
impl ::core::str::FromStr for QCryptoSecretFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoSecretFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
QCryptoSecretFormat::raw,
QCryptoSecretFormat::base64,
];
const NAMES: &'static [&'static str] = &[
"raw",
"base64",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoHashAlgorithm {
#[serde(rename = "md5")] md5,
#[serde(rename = "sha1")] sha1,
#[serde(rename = "sha224")] sha224,
#[serde(rename = "sha256")] sha256,
#[serde(rename = "sha384")] sha384,
#[serde(rename = "sha512")] sha512,
#[serde(rename = "ripemd160")] ripemd160,
}
impl ::core::str::FromStr for QCryptoHashAlgorithm {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoHashAlgorithm {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
QCryptoHashAlgorithm::md5,
QCryptoHashAlgorithm::sha1,
QCryptoHashAlgorithm::sha224,
QCryptoHashAlgorithm::sha256,
QCryptoHashAlgorithm::sha384,
QCryptoHashAlgorithm::sha512,
QCryptoHashAlgorithm::ripemd160,
];
const NAMES: &'static [&'static str] = &[
"md5",
"sha1",
"sha224",
"sha256",
"sha384",
"sha512",
"ripemd160",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoCipherAlgorithm {
#[serde(rename = "aes-128")] aes_128,
#[serde(rename = "aes-192")] aes_192,
#[serde(rename = "aes-256")] aes_256,
#[serde(rename = "des-rfb")] des_rfb,
#[serde(rename = "3des")] _3des,
#[serde(rename = "cast5-128")] cast5_128,
#[serde(rename = "serpent-128")] serpent_128,
#[serde(rename = "serpent-192")] serpent_192,
#[serde(rename = "serpent-256")] serpent_256,
#[serde(rename = "twofish-128")] twofish_128,
#[serde(rename = "twofish-192")] twofish_192,
#[serde(rename = "twofish-256")] twofish_256,
}
impl ::core::str::FromStr for QCryptoCipherAlgorithm {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoCipherAlgorithm {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 12;
const VARIANTS: &'static [Self] = &[
QCryptoCipherAlgorithm::aes_128,
QCryptoCipherAlgorithm::aes_192,
QCryptoCipherAlgorithm::aes_256,
QCryptoCipherAlgorithm::des_rfb,
QCryptoCipherAlgorithm::_3des,
QCryptoCipherAlgorithm::cast5_128,
QCryptoCipherAlgorithm::serpent_128,
QCryptoCipherAlgorithm::serpent_192,
QCryptoCipherAlgorithm::serpent_256,
QCryptoCipherAlgorithm::twofish_128,
QCryptoCipherAlgorithm::twofish_192,
QCryptoCipherAlgorithm::twofish_256,
];
const NAMES: &'static [&'static str] = &[
"aes-128",
"aes-192",
"aes-256",
"des-rfb",
"3des",
"cast5-128",
"serpent-128",
"serpent-192",
"serpent-256",
"twofish-128",
"twofish-192",
"twofish-256",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoCipherMode {
#[serde(rename = "ecb")] ecb,
#[serde(rename = "cbc")] cbc,
#[serde(rename = "xts")] xts,
#[serde(rename = "ctr")] ctr,
}
impl ::core::str::FromStr for QCryptoCipherMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoCipherMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
QCryptoCipherMode::ecb,
QCryptoCipherMode::cbc,
QCryptoCipherMode::xts,
QCryptoCipherMode::ctr,
];
const NAMES: &'static [&'static str] = &[
"ecb",
"cbc",
"xts",
"ctr",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoIVGenAlgorithm {
#[serde(rename = "plain")] plain,
#[serde(rename = "plain64")] plain64,
#[serde(rename = "essiv")] essiv,
}
impl ::core::str::FromStr for QCryptoIVGenAlgorithm {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoIVGenAlgorithm {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
QCryptoIVGenAlgorithm::plain,
QCryptoIVGenAlgorithm::plain64,
QCryptoIVGenAlgorithm::essiv,
];
const NAMES: &'static [&'static str] = &[
"plain",
"plain64",
"essiv",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoBlockFormat {
#[serde(rename = "qcow")] qcow,
#[serde(rename = "luks")] luks,
}
impl ::core::str::FromStr for QCryptoBlockFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoBlockFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
QCryptoBlockFormat::qcow,
QCryptoBlockFormat::luks,
];
const NAMES: &'static [&'static str] = &[
"qcow",
"luks",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QCryptoBlockLUKSKeyslotState {
#[serde(rename = "active")] active,
#[serde(rename = "inactive")] inactive,
}
impl ::core::str::FromStr for QCryptoBlockLUKSKeyslotState {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QCryptoBlockLUKSKeyslotState {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
QCryptoBlockLUKSKeyslotState::active,
QCryptoBlockLUKSKeyslotState::inactive,
];
const NAMES: &'static [&'static str] = &[
"active",
"inactive",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BiosAtaTranslation {
#[serde(rename = "auto")] auto,
#[serde(rename = "none")] none,
#[serde(rename = "lba")] lba,
#[serde(rename = "large")] large,
#[serde(rename = "rechs")] rechs,
}
impl ::core::str::FromStr for BiosAtaTranslation {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BiosAtaTranslation {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
BiosAtaTranslation::auto,
BiosAtaTranslation::none,
BiosAtaTranslation::lba,
BiosAtaTranslation::large,
BiosAtaTranslation::rechs,
];
const NAMES: &'static [&'static str] = &[
"auto",
"none",
"lba",
"large",
"rechs",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum FloppyDriveType {
#[serde(rename = "144")] _144,
#[serde(rename = "288")] _288,
#[serde(rename = "120")] _120,
#[serde(rename = "none")] none,
#[serde(rename = "auto")] auto,
}
impl ::core::str::FromStr for FloppyDriveType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for FloppyDriveType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
FloppyDriveType::_144,
FloppyDriveType::_288,
FloppyDriveType::_120,
FloppyDriveType::none,
FloppyDriveType::auto,
];
const NAMES: &'static [&'static str] = &[
"144",
"288",
"120",
"none",
"auto",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_pr_managers {
}
impl crate::QmpCommand for query_pr_managers { }
impl ::qapi_spec::Command for query_pr_managers {
const NAME: &'static str = "query-pr-managers";
const ALLOW_OOB: bool = false;
type Ok = Vec<PRManagerInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct eject {
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub device: Option<::std::string::String>,
#[serde(rename = "force", default, skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
}
impl crate::QmpCommand for eject { }
impl ::qapi_spec::Command for eject {
const NAME: &'static str = "eject";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_open_tray {
#[serde(rename = "force", default, skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub device: Option<::std::string::String>,
}
impl crate::QmpCommand for blockdev_open_tray { }
impl ::qapi_spec::Command for blockdev_open_tray {
const NAME: &'static str = "blockdev-open-tray";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_close_tray {
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub device: Option<::std::string::String>,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
}
impl crate::QmpCommand for blockdev_close_tray { }
impl ::qapi_spec::Command for blockdev_close_tray {
const NAME: &'static str = "blockdev-close-tray";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_remove_medium {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for blockdev_remove_medium { }
impl ::qapi_spec::Command for blockdev_remove_medium {
const NAME: &'static str = "blockdev-remove-medium";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_insert_medium {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
}
impl crate::QmpCommand for blockdev_insert_medium { }
impl ::qapi_spec::Command for blockdev_insert_medium {
const NAME: &'static str = "blockdev-insert-medium";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevChangeReadOnlyMode {
#[serde(rename = "retain")] retain,
#[serde(rename = "read-only")] read_only,
#[serde(rename = "read-write")] read_write,
}
impl ::core::str::FromStr for BlockdevChangeReadOnlyMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevChangeReadOnlyMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
BlockdevChangeReadOnlyMode::retain,
BlockdevChangeReadOnlyMode::read_only,
BlockdevChangeReadOnlyMode::read_write,
];
const NAMES: &'static [&'static str] = &[
"retain",
"read-only",
"read-write",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_change_medium {
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub device: Option<::std::string::String>,
#[serde(rename = "read-only-mode", default, skip_serializing_if = "Option::is_none")]
pub read_only_mode: Option<BlockdevChangeReadOnlyMode>,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<::std::string::String>,
}
impl crate::QmpCommand for blockdev_change_medium { }
impl ::qapi_spec::Command for blockdev_change_medium {
const NAME: &'static str = "blockdev-change-medium";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DEVICE_TRAY_MOVED {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "tray-open")]
pub tray_open: bool,
#[serde(rename = "device")]
pub device: ::std::string::String,
}
impl ::qapi_spec::Event for DEVICE_TRAY_MOVED {
const NAME: &'static str = "DEVICE_TRAY_MOVED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PR_MANAGER_STATUS_CHANGED {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "connected")]
pub connected: bool,
}
impl ::qapi_spec::Event for PR_MANAGER_STATUS_CHANGED {
const NAME: &'static str = "PR_MANAGER_STATUS_CHANGED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_set_io_throttle(pub BlockIOThrottle);
impl crate::QmpCommand for block_set_io_throttle { }
impl ::qapi_spec::Command for block_set_io_throttle {
const NAME: &'static str = "block_set_io_throttle";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_latency_histogram_set {
#[serde(rename = "boundaries", default, skip_serializing_if = "Option::is_none")]
pub boundaries: Option<Vec<u64>>,
#[serde(rename = "boundaries-read", default, skip_serializing_if = "Option::is_none")]
pub boundaries_read: Option<Vec<u64>>,
#[serde(rename = "boundaries-write", default, skip_serializing_if = "Option::is_none")]
pub boundaries_write: Option<Vec<u64>>,
#[serde(rename = "boundaries-flush", default, skip_serializing_if = "Option::is_none")]
pub boundaries_flush: Option<Vec<u64>>,
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for block_latency_histogram_set { }
impl ::qapi_spec::Command for block_latency_histogram_set {
const NAME: &'static str = "block-latency-histogram-set";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ImageInfoSpecific {
#[serde(rename = "qcow2")]
qcow2 { data: ImageInfoSpecificQCow2 },
#[serde(rename = "luks")]
luks { data: QCryptoBlockInfoLUKS },
#[serde(rename = "vmdk")]
vmdk { data: ImageInfoSpecificVmdk },
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockDeviceIoStatus {
#[serde(rename = "ok")] ok,
#[serde(rename = "failed")] failed,
#[serde(rename = "nospace")] nospace,
}
impl ::core::str::FromStr for BlockDeviceIoStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockDeviceIoStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
BlockDeviceIoStatus::ok,
BlockDeviceIoStatus::failed,
BlockDeviceIoStatus::nospace,
];
const NAMES: &'static [&'static str] = &[
"ok",
"failed",
"nospace",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DirtyBitmapStatus {
#[serde(rename = "active")] active,
#[serde(rename = "disabled")] disabled,
#[serde(rename = "frozen")] frozen,
#[serde(rename = "locked")] locked,
#[serde(rename = "inconsistent")] inconsistent,
}
impl ::core::str::FromStr for DirtyBitmapStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for DirtyBitmapStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
DirtyBitmapStatus::active,
DirtyBitmapStatus::disabled,
DirtyBitmapStatus::frozen,
DirtyBitmapStatus::locked,
DirtyBitmapStatus::inconsistent,
];
const NAMES: &'static [&'static str] = &[
"active",
"disabled",
"frozen",
"locked",
"inconsistent",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Qcow2BitmapInfoFlags {
#[serde(rename = "in-use")] in_use,
#[serde(rename = "auto")] auto,
}
impl ::core::str::FromStr for Qcow2BitmapInfoFlags {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for Qcow2BitmapInfoFlags {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
Qcow2BitmapInfoFlags::in_use,
Qcow2BitmapInfoFlags::auto,
];
const NAMES: &'static [&'static str] = &[
"in-use",
"auto",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_block {
}
impl crate::QmpCommand for query_block { }
impl ::qapi_spec::Command for query_block {
const NAME: &'static str = "query-block";
const ALLOW_OOB: bool = false;
type Ok = Vec<BlockInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_blockstats {
#[serde(rename = "query-nodes", default, skip_serializing_if = "Option::is_none")]
pub query_nodes: Option<bool>,
}
impl crate::QmpCommand for query_blockstats { }
impl ::qapi_spec::Command for query_blockstats {
const NAME: &'static str = "query-blockstats";
const ALLOW_OOB: bool = false;
type Ok = Vec<BlockStats>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevOnError {
#[serde(rename = "report")] report,
#[serde(rename = "ignore")] ignore,
#[serde(rename = "enospc")] enospc,
#[serde(rename = "stop")] stop,
#[serde(rename = "auto")] auto,
}
impl ::core::str::FromStr for BlockdevOnError {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevOnError {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
BlockdevOnError::report,
BlockdevOnError::ignore,
BlockdevOnError::enospc,
BlockdevOnError::stop,
BlockdevOnError::auto,
];
const NAMES: &'static [&'static str] = &[
"report",
"ignore",
"enospc",
"stop",
"auto",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MirrorSyncMode {
#[serde(rename = "top")] top,
#[serde(rename = "full")] full,
#[serde(rename = "none")] none,
#[serde(rename = "incremental")] incremental,
#[serde(rename = "bitmap")] bitmap,
}
impl ::core::str::FromStr for MirrorSyncMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MirrorSyncMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
MirrorSyncMode::top,
MirrorSyncMode::full,
MirrorSyncMode::none,
MirrorSyncMode::incremental,
MirrorSyncMode::bitmap,
];
const NAMES: &'static [&'static str] = &[
"top",
"full",
"none",
"incremental",
"bitmap",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BitmapSyncMode {
#[serde(rename = "on-success")] on_success,
#[serde(rename = "never")] never,
#[serde(rename = "always")] always,
}
impl ::core::str::FromStr for BitmapSyncMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BitmapSyncMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
BitmapSyncMode::on_success,
BitmapSyncMode::never,
BitmapSyncMode::always,
];
const NAMES: &'static [&'static str] = &[
"on-success",
"never",
"always",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MirrorCopyMode {
#[serde(rename = "background")] background,
#[serde(rename = "write-blocking")] write_blocking,
}
impl ::core::str::FromStr for MirrorCopyMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MirrorCopyMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
MirrorCopyMode::background,
MirrorCopyMode::write_blocking,
];
const NAMES: &'static [&'static str] = &[
"background",
"write-blocking",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_block_jobs {
}
impl crate::QmpCommand for query_block_jobs { }
impl ::qapi_spec::Command for query_block_jobs {
const NAME: &'static str = "query-block-jobs";
const ALLOW_OOB: bool = false;
type Ok = Vec<BlockJobInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_passwd {
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
#[serde(rename = "password")]
pub password: ::std::string::String,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
}
impl crate::QmpCommand for block_passwd { }
impl ::qapi_spec::Command for block_passwd {
const NAME: &'static str = "block_passwd";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_resize {
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
#[serde(rename = "size")]
pub size: isize,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
}
impl crate::QmpCommand for block_resize { }
impl ::qapi_spec::Command for block_resize {
const NAME: &'static str = "block_resize";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum NewImageMode {
#[serde(rename = "existing")] existing,
#[serde(rename = "absolute-paths")] absolute_paths,
}
impl ::core::str::FromStr for NewImageMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for NewImageMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
NewImageMode::existing,
NewImageMode::absolute_paths,
];
const NAMES: &'static [&'static str] = &[
"existing",
"absolute-paths",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_snapshot_sync(pub BlockdevSnapshotSync);
impl crate::QmpCommand for blockdev_snapshot_sync { }
impl ::qapi_spec::Command for blockdev_snapshot_sync {
const NAME: &'static str = "blockdev-snapshot-sync";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_snapshot(pub BlockdevSnapshot);
impl crate::QmpCommand for blockdev_snapshot { }
impl ::qapi_spec::Command for blockdev_snapshot {
const NAME: &'static str = "blockdev-snapshot";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct change_backing_file {
#[serde(rename = "backing-file")]
pub backing_file: ::std::string::String,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "image-node-name")]
pub image_node_name: ::std::string::String,
}
impl crate::QmpCommand for change_backing_file { }
impl ::qapi_spec::Command for change_backing_file {
const NAME: &'static str = "change-backing-file";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_commit {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "job-id", default, skip_serializing_if = "Option::is_none")]
pub job_id: Option<::std::string::String>,
#[serde(rename = "auto-dismiss", default, skip_serializing_if = "Option::is_none")]
pub auto_dismiss: Option<bool>,
#[serde(rename = "top-node", default, skip_serializing_if = "Option::is_none")]
pub top_node: Option<::std::string::String>,
#[serde(rename = "top", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub top: Option<::std::string::String>,
#[serde(rename = "filter-node-name", default, skip_serializing_if = "Option::is_none")]
pub filter_node_name: Option<::std::string::String>,
#[serde(rename = "base", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub base: Option<::std::string::String>,
#[serde(rename = "auto-finalize", default, skip_serializing_if = "Option::is_none")]
pub auto_finalize: Option<bool>,
#[serde(rename = "on-error", default, skip_serializing_if = "Option::is_none")]
pub on_error: Option<BlockdevOnError>,
#[serde(rename = "base-node", default, skip_serializing_if = "Option::is_none")]
pub base_node: Option<::std::string::String>,
#[serde(rename = "backing-file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
pub speed: Option<isize>,
}
impl crate::QmpCommand for block_commit { }
impl ::qapi_spec::Command for block_commit {
const NAME: &'static str = "block-commit";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct drive_backup(pub DriveBackup);
impl crate::QmpCommand for drive_backup { }
impl ::qapi_spec::Command for drive_backup {
const NAME: &'static str = "drive-backup";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_backup(pub BlockdevBackup);
impl crate::QmpCommand for blockdev_backup { }
impl ::qapi_spec::Command for blockdev_backup {
const NAME: &'static str = "blockdev-backup";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_named_block_nodes {
#[serde(rename = "flat", default, skip_serializing_if = "Option::is_none")]
pub flat: Option<bool>,
}
impl crate::QmpCommand for query_named_block_nodes { }
impl ::qapi_spec::Command for query_named_block_nodes {
const NAME: &'static str = "query-named-block-nodes";
const ALLOW_OOB: bool = false;
type Ok = Vec<BlockDeviceInfo>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum XDbgBlockGraphNodeType {
#[serde(rename = "block-backend")] block_backend,
#[serde(rename = "block-job")] block_job,
#[serde(rename = "block-driver")] block_driver,
}
impl ::core::str::FromStr for XDbgBlockGraphNodeType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for XDbgBlockGraphNodeType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
XDbgBlockGraphNodeType::block_backend,
XDbgBlockGraphNodeType::block_job,
XDbgBlockGraphNodeType::block_driver,
];
const NAMES: &'static [&'static str] = &[
"block-backend",
"block-job",
"block-driver",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockPermission {
#[serde(rename = "consistent-read")] consistent_read,
#[serde(rename = "write")] write,
#[serde(rename = "write-unchanged")] write_unchanged,
#[serde(rename = "resize")] resize,
#[serde(rename = "graph-mod")] graph_mod,
}
impl ::core::str::FromStr for BlockPermission {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockPermission {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
BlockPermission::consistent_read,
BlockPermission::write,
BlockPermission::write_unchanged,
BlockPermission::resize,
BlockPermission::graph_mod,
];
const NAMES: &'static [&'static str] = &[
"consistent-read",
"write",
"write-unchanged",
"resize",
"graph-mod",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_debug_query_block_graph {
}
impl crate::QmpCommand for x_debug_query_block_graph { }
impl ::qapi_spec::Command for x_debug_query_block_graph {
const NAME: &'static str = "x-debug-query-block-graph";
const ALLOW_OOB: bool = false;
type Ok = XDbgBlockGraph;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct drive_mirror(pub DriveMirror);
impl crate::QmpCommand for drive_mirror { }
impl ::qapi_spec::Command for drive_mirror {
const NAME: &'static str = "drive-mirror";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BlockDirtyBitmapMergeSource {
#[serde(rename = "local")] local(::std::string::String),
#[serde(rename = "external")] external(BlockDirtyBitmap),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_dirty_bitmap_add(pub BlockDirtyBitmapAdd);
impl crate::QmpCommand for block_dirty_bitmap_add { }
impl ::qapi_spec::Command for block_dirty_bitmap_add {
const NAME: &'static str = "block-dirty-bitmap-add";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_dirty_bitmap_remove(pub BlockDirtyBitmap);
impl crate::QmpCommand for block_dirty_bitmap_remove { }
impl ::qapi_spec::Command for block_dirty_bitmap_remove {
const NAME: &'static str = "block-dirty-bitmap-remove";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_dirty_bitmap_clear(pub BlockDirtyBitmap);
impl crate::QmpCommand for block_dirty_bitmap_clear { }
impl ::qapi_spec::Command for block_dirty_bitmap_clear {
const NAME: &'static str = "block-dirty-bitmap-clear";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_dirty_bitmap_enable(pub BlockDirtyBitmap);
impl crate::QmpCommand for block_dirty_bitmap_enable { }
impl ::qapi_spec::Command for block_dirty_bitmap_enable {
const NAME: &'static str = "block-dirty-bitmap-enable";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_dirty_bitmap_disable(pub BlockDirtyBitmap);
impl crate::QmpCommand for block_dirty_bitmap_disable { }
impl ::qapi_spec::Command for block_dirty_bitmap_disable {
const NAME: &'static str = "block-dirty-bitmap-disable";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_dirty_bitmap_merge(pub BlockDirtyBitmapMerge);
impl crate::QmpCommand for block_dirty_bitmap_merge { }
impl ::qapi_spec::Command for block_dirty_bitmap_merge {
const NAME: &'static str = "block-dirty-bitmap-merge";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_debug_block_dirty_bitmap_sha256(pub BlockDirtyBitmap);
impl crate::QmpCommand for x_debug_block_dirty_bitmap_sha256 { }
impl ::qapi_spec::Command for x_debug_block_dirty_bitmap_sha256 {
const NAME: &'static str = "x-debug-block-dirty-bitmap-sha256";
const ALLOW_OOB: bool = false;
type Ok = BlockDirtyBitmapSha256;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_mirror {
#[serde(rename = "granularity", default, skip_serializing_if = "Option::is_none")]
pub granularity: Option<u32>,
#[serde(rename = "target")]
pub target: ::std::string::String,
#[serde(rename = "sync")]
pub sync: MirrorSyncMode,
#[serde(rename = "buf-size", default, skip_serializing_if = "Option::is_none")]
pub buf_size: Option<isize>,
#[serde(rename = "copy-mode", default, skip_serializing_if = "Option::is_none")]
pub copy_mode: Option<MirrorCopyMode>,
#[serde(rename = "on-target-error", default, skip_serializing_if = "Option::is_none")]
pub on_target_error: Option<BlockdevOnError>,
#[serde(rename = "job-id", default, skip_serializing_if = "Option::is_none")]
pub job_id: Option<::std::string::String>,
#[serde(rename = "auto-finalize", default, skip_serializing_if = "Option::is_none")]
pub auto_finalize: Option<bool>,
#[serde(rename = "on-source-error", default, skip_serializing_if = "Option::is_none")]
pub on_source_error: Option<BlockdevOnError>,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "replaces", default, skip_serializing_if = "Option::is_none")]
pub replaces: Option<::std::string::String>,
#[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
pub speed: Option<isize>,
#[serde(rename = "filter-node-name", default, skip_serializing_if = "Option::is_none")]
pub filter_node_name: Option<::std::string::String>,
#[serde(rename = "auto-dismiss", default, skip_serializing_if = "Option::is_none")]
pub auto_dismiss: Option<bool>,
}
impl crate::QmpCommand for blockdev_mirror { }
impl ::qapi_spec::Command for blockdev_mirror {
const NAME: &'static str = "blockdev-mirror";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_stream {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "base-node", default, skip_serializing_if = "Option::is_none")]
pub base_node: Option<::std::string::String>,
#[serde(rename = "auto-dismiss", default, skip_serializing_if = "Option::is_none")]
pub auto_dismiss: Option<bool>,
#[serde(rename = "backing-file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "job-id", default, skip_serializing_if = "Option::is_none")]
pub job_id: Option<::std::string::String>,
#[serde(rename = "on-error", default, skip_serializing_if = "Option::is_none")]
pub on_error: Option<BlockdevOnError>,
#[serde(rename = "auto-finalize", default, skip_serializing_if = "Option::is_none")]
pub auto_finalize: Option<bool>,
#[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
pub speed: Option<isize>,
#[serde(rename = "base", default, skip_serializing_if = "Option::is_none")]
pub base: Option<::std::string::String>,
}
impl crate::QmpCommand for block_stream { }
impl ::qapi_spec::Command for block_stream {
const NAME: &'static str = "block-stream";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_job_set_speed {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "speed")]
pub speed: isize,
}
impl crate::QmpCommand for block_job_set_speed { }
impl ::qapi_spec::Command for block_job_set_speed {
const NAME: &'static str = "block-job-set-speed";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_job_cancel {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "force", default, skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
}
impl crate::QmpCommand for block_job_cancel { }
impl ::qapi_spec::Command for block_job_cancel {
const NAME: &'static str = "block-job-cancel";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_job_pause {
#[serde(rename = "device")]
pub device: ::std::string::String,
}
impl crate::QmpCommand for block_job_pause { }
impl ::qapi_spec::Command for block_job_pause {
const NAME: &'static str = "block-job-pause";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_job_resume {
#[serde(rename = "device")]
pub device: ::std::string::String,
}
impl crate::QmpCommand for block_job_resume { }
impl ::qapi_spec::Command for block_job_resume {
const NAME: &'static str = "block-job-resume";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_job_complete {
#[serde(rename = "device")]
pub device: ::std::string::String,
}
impl crate::QmpCommand for block_job_complete { }
impl ::qapi_spec::Command for block_job_complete {
const NAME: &'static str = "block-job-complete";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_job_dismiss {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for block_job_dismiss { }
impl ::qapi_spec::Command for block_job_dismiss {
const NAME: &'static str = "block-job-dismiss";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_job_finalize {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for block_job_finalize { }
impl ::qapi_spec::Command for block_job_finalize {
const NAME: &'static str = "block-job-finalize";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevDiscardOptions {
#[serde(rename = "ignore")] ignore,
#[serde(rename = "unmap")] unmap,
}
impl ::core::str::FromStr for BlockdevDiscardOptions {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevDiscardOptions {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
BlockdevDiscardOptions::ignore,
BlockdevDiscardOptions::unmap,
];
const NAMES: &'static [&'static str] = &[
"ignore",
"unmap",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevDetectZeroesOptions {
#[serde(rename = "off")] off,
#[serde(rename = "on")] on,
#[serde(rename = "unmap")] unmap,
}
impl ::core::str::FromStr for BlockdevDetectZeroesOptions {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevDetectZeroesOptions {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
BlockdevDetectZeroesOptions::off,
BlockdevDetectZeroesOptions::on,
BlockdevDetectZeroesOptions::unmap,
];
const NAMES: &'static [&'static str] = &[
"off",
"on",
"unmap",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevAioOptions {
#[serde(rename = "threads")] threads,
#[serde(rename = "native")] native,
#[serde(rename = "io_uring")] io_uring,
}
impl ::core::str::FromStr for BlockdevAioOptions {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevAioOptions {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
BlockdevAioOptions::threads,
BlockdevAioOptions::native,
BlockdevAioOptions::io_uring,
];
const NAMES: &'static [&'static str] = &[
"threads",
"native",
"io_uring",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevDriver {
#[serde(rename = "blkdebug")] blkdebug,
#[serde(rename = "blklogwrites")] blklogwrites,
#[serde(rename = "blkreplay")] blkreplay,
#[serde(rename = "blkverify")] blkverify,
#[serde(rename = "bochs")] bochs,
#[serde(rename = "cloop")] cloop,
#[serde(rename = "compress")] compress,
#[serde(rename = "copy-on-read")] copy_on_read,
#[serde(rename = "dmg")] dmg,
#[serde(rename = "file")] file,
#[serde(rename = "ftp")] ftp,
#[serde(rename = "ftps")] ftps,
#[serde(rename = "gluster")] gluster,
#[serde(rename = "host_cdrom")] host_cdrom,
#[serde(rename = "host_device")] host_device,
#[serde(rename = "http")] http,
#[serde(rename = "https")] https,
#[serde(rename = "iscsi")] iscsi,
#[serde(rename = "luks")] luks,
#[serde(rename = "nbd")] nbd,
#[serde(rename = "nfs")] nfs,
#[serde(rename = "null-aio")] null_aio,
#[serde(rename = "null-co")] null_co,
#[serde(rename = "nvme")] nvme,
#[serde(rename = "parallels")] parallels,
#[serde(rename = "qcow")] qcow,
#[serde(rename = "qcow2")] qcow2,
#[serde(rename = "qed")] qed,
#[serde(rename = "quorum")] quorum,
#[serde(rename = "raw")] raw,
#[serde(rename = "rbd")] rbd,
#[serde(rename = "replication")] replication,
#[serde(rename = "sheepdog")] sheepdog,
#[serde(rename = "ssh")] ssh,
#[serde(rename = "throttle")] throttle,
#[serde(rename = "vdi")] vdi,
#[serde(rename = "vhdx")] vhdx,
#[serde(rename = "vmdk")] vmdk,
#[serde(rename = "vpc")] vpc,
#[serde(rename = "vvfat")] vvfat,
}
impl ::core::str::FromStr for BlockdevDriver {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevDriver {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 40;
const VARIANTS: &'static [Self] = &[
BlockdevDriver::blkdebug,
BlockdevDriver::blklogwrites,
BlockdevDriver::blkreplay,
BlockdevDriver::blkverify,
BlockdevDriver::bochs,
BlockdevDriver::cloop,
BlockdevDriver::compress,
BlockdevDriver::copy_on_read,
BlockdevDriver::dmg,
BlockdevDriver::file,
BlockdevDriver::ftp,
BlockdevDriver::ftps,
BlockdevDriver::gluster,
BlockdevDriver::host_cdrom,
BlockdevDriver::host_device,
BlockdevDriver::http,
BlockdevDriver::https,
BlockdevDriver::iscsi,
BlockdevDriver::luks,
BlockdevDriver::nbd,
BlockdevDriver::nfs,
BlockdevDriver::null_aio,
BlockdevDriver::null_co,
BlockdevDriver::nvme,
BlockdevDriver::parallels,
BlockdevDriver::qcow,
BlockdevDriver::qcow2,
BlockdevDriver::qed,
BlockdevDriver::quorum,
BlockdevDriver::raw,
BlockdevDriver::rbd,
BlockdevDriver::replication,
BlockdevDriver::sheepdog,
BlockdevDriver::ssh,
BlockdevDriver::throttle,
BlockdevDriver::vdi,
BlockdevDriver::vhdx,
BlockdevDriver::vmdk,
BlockdevDriver::vpc,
BlockdevDriver::vvfat,
];
const NAMES: &'static [&'static str] = &[
"blkdebug",
"blklogwrites",
"blkreplay",
"blkverify",
"bochs",
"cloop",
"compress",
"copy-on-read",
"dmg",
"file",
"ftp",
"ftps",
"gluster",
"host_cdrom",
"host_device",
"http",
"https",
"iscsi",
"luks",
"nbd",
"nfs",
"null-aio",
"null-co",
"nvme",
"parallels",
"qcow",
"qcow2",
"qed",
"quorum",
"raw",
"rbd",
"replication",
"sheepdog",
"ssh",
"throttle",
"vdi",
"vhdx",
"vmdk",
"vpc",
"vvfat",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Qcow2OverlapCheckMode {
#[serde(rename = "none")] none,
#[serde(rename = "constant")] constant,
#[serde(rename = "cached")] cached,
#[serde(rename = "all")] all,
}
impl ::core::str::FromStr for Qcow2OverlapCheckMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for Qcow2OverlapCheckMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
Qcow2OverlapCheckMode::none,
Qcow2OverlapCheckMode::constant,
Qcow2OverlapCheckMode::cached,
Qcow2OverlapCheckMode::all,
];
const NAMES: &'static [&'static str] = &[
"none",
"constant",
"cached",
"all",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Qcow2OverlapChecks {
#[serde(rename = "mode")] mode(Qcow2OverlapCheckMode),
#[serde(rename = "flags")] flags(Qcow2OverlapCheckFlags),
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevQcowEncryptionFormat {
#[serde(rename = "aes")] aes,
}
impl ::core::str::FromStr for BlockdevQcowEncryptionFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevQcowEncryptionFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 1;
const VARIANTS: &'static [Self] = &[
BlockdevQcowEncryptionFormat::aes,
];
const NAMES: &'static [&'static str] = &[
"aes",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevQcow2EncryptionFormat {
#[serde(rename = "aes")] aes,
#[serde(rename = "luks")] luks,
}
impl ::core::str::FromStr for BlockdevQcow2EncryptionFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevQcow2EncryptionFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
BlockdevQcow2EncryptionFormat::aes,
BlockdevQcow2EncryptionFormat::luks,
];
const NAMES: &'static [&'static str] = &[
"aes",
"luks",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SshHostKeyCheckMode {
#[serde(rename = "none")] none,
#[serde(rename = "hash")] hash,
#[serde(rename = "known_hosts")] known_hosts,
}
impl ::core::str::FromStr for SshHostKeyCheckMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SshHostKeyCheckMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
SshHostKeyCheckMode::none,
SshHostKeyCheckMode::hash,
SshHostKeyCheckMode::known_hosts,
];
const NAMES: &'static [&'static str] = &[
"none",
"hash",
"known_hosts",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SshHostKeyCheckHashType {
#[serde(rename = "md5")] md5,
#[serde(rename = "sha1")] sha1,
}
impl ::core::str::FromStr for SshHostKeyCheckHashType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SshHostKeyCheckHashType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
SshHostKeyCheckHashType::md5,
SshHostKeyCheckHashType::sha1,
];
const NAMES: &'static [&'static str] = &[
"md5",
"sha1",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlkdebugEvent {
#[serde(rename = "l1_update")] l1_update,
#[serde(rename = "l1_grow_alloc_table")] l1_grow_alloc_table,
#[serde(rename = "l1_grow_write_table")] l1_grow_write_table,
#[serde(rename = "l1_grow_activate_table")] l1_grow_activate_table,
#[serde(rename = "l2_load")] l2_load,
#[serde(rename = "l2_update")] l2_update,
#[serde(rename = "l2_update_compressed")] l2_update_compressed,
#[serde(rename = "l2_alloc_cow_read")] l2_alloc_cow_read,
#[serde(rename = "l2_alloc_write")] l2_alloc_write,
#[serde(rename = "read_aio")] read_aio,
#[serde(rename = "read_backing_aio")] read_backing_aio,
#[serde(rename = "read_compressed")] read_compressed,
#[serde(rename = "write_aio")] write_aio,
#[serde(rename = "write_compressed")] write_compressed,
#[serde(rename = "vmstate_load")] vmstate_load,
#[serde(rename = "vmstate_save")] vmstate_save,
#[serde(rename = "cow_read")] cow_read,
#[serde(rename = "cow_write")] cow_write,
#[serde(rename = "reftable_load")] reftable_load,
#[serde(rename = "reftable_grow")] reftable_grow,
#[serde(rename = "reftable_update")] reftable_update,
#[serde(rename = "refblock_load")] refblock_load,
#[serde(rename = "refblock_update")] refblock_update,
#[serde(rename = "refblock_update_part")] refblock_update_part,
#[serde(rename = "refblock_alloc")] refblock_alloc,
#[serde(rename = "refblock_alloc_hookup")] refblock_alloc_hookup,
#[serde(rename = "refblock_alloc_write")] refblock_alloc_write,
#[serde(rename = "refblock_alloc_write_blocks")] refblock_alloc_write_blocks,
#[serde(rename = "refblock_alloc_write_table")] refblock_alloc_write_table,
#[serde(rename = "refblock_alloc_switch_table")] refblock_alloc_switch_table,
#[serde(rename = "cluster_alloc")] cluster_alloc,
#[serde(rename = "cluster_alloc_bytes")] cluster_alloc_bytes,
#[serde(rename = "cluster_free")] cluster_free,
#[serde(rename = "flush_to_os")] flush_to_os,
#[serde(rename = "flush_to_disk")] flush_to_disk,
#[serde(rename = "pwritev_rmw_head")] pwritev_rmw_head,
#[serde(rename = "pwritev_rmw_after_head")] pwritev_rmw_after_head,
#[serde(rename = "pwritev_rmw_tail")] pwritev_rmw_tail,
#[serde(rename = "pwritev_rmw_after_tail")] pwritev_rmw_after_tail,
#[serde(rename = "pwritev")] pwritev,
#[serde(rename = "pwritev_zero")] pwritev_zero,
#[serde(rename = "pwritev_done")] pwritev_done,
#[serde(rename = "empty_image_prepare")] empty_image_prepare,
#[serde(rename = "l1_shrink_write_table")] l1_shrink_write_table,
#[serde(rename = "l1_shrink_free_l2_clusters")] l1_shrink_free_l2_clusters,
#[serde(rename = "cor_write")] cor_write,
#[serde(rename = "cluster_alloc_space")] cluster_alloc_space,
#[serde(rename = "none")] none,
}
impl ::core::str::FromStr for BlkdebugEvent {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlkdebugEvent {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 48;
const VARIANTS: &'static [Self] = &[
BlkdebugEvent::l1_update,
BlkdebugEvent::l1_grow_alloc_table,
BlkdebugEvent::l1_grow_write_table,
BlkdebugEvent::l1_grow_activate_table,
BlkdebugEvent::l2_load,
BlkdebugEvent::l2_update,
BlkdebugEvent::l2_update_compressed,
BlkdebugEvent::l2_alloc_cow_read,
BlkdebugEvent::l2_alloc_write,
BlkdebugEvent::read_aio,
BlkdebugEvent::read_backing_aio,
BlkdebugEvent::read_compressed,
BlkdebugEvent::write_aio,
BlkdebugEvent::write_compressed,
BlkdebugEvent::vmstate_load,
BlkdebugEvent::vmstate_save,
BlkdebugEvent::cow_read,
BlkdebugEvent::cow_write,
BlkdebugEvent::reftable_load,
BlkdebugEvent::reftable_grow,
BlkdebugEvent::reftable_update,
BlkdebugEvent::refblock_load,
BlkdebugEvent::refblock_update,
BlkdebugEvent::refblock_update_part,
BlkdebugEvent::refblock_alloc,
BlkdebugEvent::refblock_alloc_hookup,
BlkdebugEvent::refblock_alloc_write,
BlkdebugEvent::refblock_alloc_write_blocks,
BlkdebugEvent::refblock_alloc_write_table,
BlkdebugEvent::refblock_alloc_switch_table,
BlkdebugEvent::cluster_alloc,
BlkdebugEvent::cluster_alloc_bytes,
BlkdebugEvent::cluster_free,
BlkdebugEvent::flush_to_os,
BlkdebugEvent::flush_to_disk,
BlkdebugEvent::pwritev_rmw_head,
BlkdebugEvent::pwritev_rmw_after_head,
BlkdebugEvent::pwritev_rmw_tail,
BlkdebugEvent::pwritev_rmw_after_tail,
BlkdebugEvent::pwritev,
BlkdebugEvent::pwritev_zero,
BlkdebugEvent::pwritev_done,
BlkdebugEvent::empty_image_prepare,
BlkdebugEvent::l1_shrink_write_table,
BlkdebugEvent::l1_shrink_free_l2_clusters,
BlkdebugEvent::cor_write,
BlkdebugEvent::cluster_alloc_space,
BlkdebugEvent::none,
];
const NAMES: &'static [&'static str] = &[
"l1_update",
"l1_grow_alloc_table",
"l1_grow_write_table",
"l1_grow_activate_table",
"l2_load",
"l2_update",
"l2_update_compressed",
"l2_alloc_cow_read",
"l2_alloc_write",
"read_aio",
"read_backing_aio",
"read_compressed",
"write_aio",
"write_compressed",
"vmstate_load",
"vmstate_save",
"cow_read",
"cow_write",
"reftable_load",
"reftable_grow",
"reftable_update",
"refblock_load",
"refblock_update",
"refblock_update_part",
"refblock_alloc",
"refblock_alloc_hookup",
"refblock_alloc_write",
"refblock_alloc_write_blocks",
"refblock_alloc_write_table",
"refblock_alloc_switch_table",
"cluster_alloc",
"cluster_alloc_bytes",
"cluster_free",
"flush_to_os",
"flush_to_disk",
"pwritev_rmw_head",
"pwritev_rmw_after_head",
"pwritev_rmw_tail",
"pwritev_rmw_after_tail",
"pwritev",
"pwritev_zero",
"pwritev_done",
"empty_image_prepare",
"l1_shrink_write_table",
"l1_shrink_free_l2_clusters",
"cor_write",
"cluster_alloc_space",
"none",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlkdebugIOType {
#[serde(rename = "read")] read,
#[serde(rename = "write")] write,
#[serde(rename = "write-zeroes")] write_zeroes,
#[serde(rename = "discard")] discard,
#[serde(rename = "flush")] flush,
#[serde(rename = "block-status")] block_status,
}
impl ::core::str::FromStr for BlkdebugIOType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlkdebugIOType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 6;
const VARIANTS: &'static [Self] = &[
BlkdebugIOType::read,
BlkdebugIOType::write,
BlkdebugIOType::write_zeroes,
BlkdebugIOType::discard,
BlkdebugIOType::flush,
BlkdebugIOType::block_status,
];
const NAMES: &'static [&'static str] = &[
"read",
"write",
"write-zeroes",
"discard",
"flush",
"block-status",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QuorumReadPattern {
#[serde(rename = "quorum")] quorum,
#[serde(rename = "fifo")] fifo,
}
impl ::core::str::FromStr for QuorumReadPattern {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QuorumReadPattern {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
QuorumReadPattern::quorum,
QuorumReadPattern::fifo,
];
const NAMES: &'static [&'static str] = &[
"quorum",
"fifo",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum IscsiTransport {
#[serde(rename = "tcp")] tcp,
#[serde(rename = "iser")] iser,
}
impl ::core::str::FromStr for IscsiTransport {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for IscsiTransport {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
IscsiTransport::tcp,
IscsiTransport::iser,
];
const NAMES: &'static [&'static str] = &[
"tcp",
"iser",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum IscsiHeaderDigest {
#[serde(rename = "crc32c")] crc32c,
#[serde(rename = "none")] none,
#[serde(rename = "crc32c-none")] crc32c_none,
#[serde(rename = "none-crc32c")] none_crc32c,
}
impl ::core::str::FromStr for IscsiHeaderDigest {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for IscsiHeaderDigest {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
IscsiHeaderDigest::crc32c,
IscsiHeaderDigest::none,
IscsiHeaderDigest::crc32c_none,
IscsiHeaderDigest::none_crc32c,
];
const NAMES: &'static [&'static str] = &[
"crc32c",
"none",
"crc32c-none",
"none-crc32c",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RbdAuthMode {
#[serde(rename = "cephx")] cephx,
#[serde(rename = "none")] none,
}
impl ::core::str::FromStr for RbdAuthMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for RbdAuthMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
RbdAuthMode::cephx,
RbdAuthMode::none,
];
const NAMES: &'static [&'static str] = &[
"cephx",
"none",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ReplicationMode {
#[serde(rename = "primary")] primary,
#[serde(rename = "secondary")] secondary,
}
impl ::core::str::FromStr for ReplicationMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for ReplicationMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
ReplicationMode::primary,
ReplicationMode::secondary,
];
const NAMES: &'static [&'static str] = &[
"primary",
"secondary",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum NFSTransport {
#[serde(rename = "inet")] inet,
}
impl ::core::str::FromStr for NFSTransport {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for NFSTransport {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 1;
const VARIANTS: &'static [Self] = &[
NFSTransport::inet,
];
const NAMES: &'static [&'static str] = &[
"inet",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BlockdevRef {
#[serde(rename = "definition")] definition(Box<BlockdevOptions>),
#[serde(rename = "reference")] reference(::std::string::String),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BlockdevRefOrNull {
#[serde(rename = "null")] null(()),
#[serde(rename = "reference")] reference(::std::string::String),
#[serde(rename = "definition")] definition(Box<BlockdevOptions>),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_add(pub BlockdevOptions);
impl crate::QmpCommand for blockdev_add { }
impl ::qapi_spec::Command for blockdev_add {
const NAME: &'static str = "blockdev-add";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_blockdev_reopen(pub BlockdevOptions);
impl crate::QmpCommand for x_blockdev_reopen { }
impl ::qapi_spec::Command for x_blockdev_reopen {
const NAME: &'static str = "x-blockdev-reopen";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_del {
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
}
impl crate::QmpCommand for blockdev_del { }
impl ::qapi_spec::Command for blockdev_del {
const NAME: &'static str = "blockdev-del";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevQcow2Version {
#[serde(rename = "v2")] v2,
#[serde(rename = "v3")] v3,
}
impl ::core::str::FromStr for BlockdevQcow2Version {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevQcow2Version {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
BlockdevQcow2Version::v2,
BlockdevQcow2Version::v3,
];
const NAMES: &'static [&'static str] = &[
"v2",
"v3",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Qcow2CompressionType {
#[serde(rename = "zlib")] zlib,
#[serde(rename = "zstd")] zstd,
}
impl ::core::str::FromStr for Qcow2CompressionType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for Qcow2CompressionType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
Qcow2CompressionType::zlib,
Qcow2CompressionType::zstd,
];
const NAMES: &'static [&'static str] = &[
"zlib",
"zstd",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevVmdkSubformat {
#[serde(rename = "monolithicSparse")] monolithicSparse,
#[serde(rename = "monolithicFlat")] monolithicFlat,
#[serde(rename = "twoGbMaxExtentSparse")] twoGbMaxExtentSparse,
#[serde(rename = "twoGbMaxExtentFlat")] twoGbMaxExtentFlat,
#[serde(rename = "streamOptimized")] streamOptimized,
}
impl ::core::str::FromStr for BlockdevVmdkSubformat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevVmdkSubformat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
BlockdevVmdkSubformat::monolithicSparse,
BlockdevVmdkSubformat::monolithicFlat,
BlockdevVmdkSubformat::twoGbMaxExtentSparse,
BlockdevVmdkSubformat::twoGbMaxExtentFlat,
BlockdevVmdkSubformat::streamOptimized,
];
const NAMES: &'static [&'static str] = &[
"monolithicSparse",
"monolithicFlat",
"twoGbMaxExtentSparse",
"twoGbMaxExtentFlat",
"streamOptimized",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevVmdkAdapterType {
#[serde(rename = "ide")] ide,
#[serde(rename = "buslogic")] buslogic,
#[serde(rename = "lsilogic")] lsilogic,
#[serde(rename = "legacyESX")] legacyESX,
}
impl ::core::str::FromStr for BlockdevVmdkAdapterType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevVmdkAdapterType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
BlockdevVmdkAdapterType::ide,
BlockdevVmdkAdapterType::buslogic,
BlockdevVmdkAdapterType::lsilogic,
BlockdevVmdkAdapterType::legacyESX,
];
const NAMES: &'static [&'static str] = &[
"ide",
"buslogic",
"lsilogic",
"legacyESX",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SheepdogRedundancyType {
#[serde(rename = "full")] full,
#[serde(rename = "erasure-coded")] erasure_coded,
}
impl ::core::str::FromStr for SheepdogRedundancyType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SheepdogRedundancyType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
SheepdogRedundancyType::full,
SheepdogRedundancyType::erasure_coded,
];
const NAMES: &'static [&'static str] = &[
"full",
"erasure-coded",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevVhdxSubformat {
#[serde(rename = "dynamic")] dynamic,
#[serde(rename = "fixed")] fixed,
}
impl ::core::str::FromStr for BlockdevVhdxSubformat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevVhdxSubformat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
BlockdevVhdxSubformat::dynamic,
BlockdevVhdxSubformat::fixed,
];
const NAMES: &'static [&'static str] = &[
"dynamic",
"fixed",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockdevVpcSubformat {
#[serde(rename = "dynamic")] dynamic,
#[serde(rename = "fixed")] fixed,
}
impl ::core::str::FromStr for BlockdevVpcSubformat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockdevVpcSubformat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
BlockdevVpcSubformat::dynamic,
BlockdevVpcSubformat::fixed,
];
const NAMES: &'static [&'static str] = &[
"dynamic",
"fixed",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_create {
#[serde(rename = "options")]
pub options: BlockdevCreateOptions,
#[serde(rename = "job-id")]
pub job_id: ::std::string::String,
}
impl crate::QmpCommand for blockdev_create { }
impl ::qapi_spec::Command for blockdev_create {
const NAME: &'static str = "blockdev-create";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_blockdev_amend {
#[serde(rename = "force", default, skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "options")]
pub options: BlockdevAmendOptions,
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
#[serde(rename = "job-id")]
pub job_id: ::std::string::String,
}
impl crate::QmpCommand for x_blockdev_amend { }
impl ::qapi_spec::Command for x_blockdev_amend {
const NAME: &'static str = "x-blockdev-amend";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockErrorAction {
#[serde(rename = "ignore")] ignore,
#[serde(rename = "report")] report,
#[serde(rename = "stop")] stop,
}
impl ::core::str::FromStr for BlockErrorAction {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockErrorAction {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
BlockErrorAction::ignore,
BlockErrorAction::report,
BlockErrorAction::stop,
];
const NAMES: &'static [&'static str] = &[
"ignore",
"report",
"stop",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_IMAGE_CORRUPTED {
#[serde(rename = "msg")]
pub msg: ::std::string::String,
#[serde(rename = "size", default, skip_serializing_if = "Option::is_none")]
pub size: Option<isize>,
#[serde(rename = "fatal")]
pub fatal: bool,
#[serde(rename = "offset", default, skip_serializing_if = "Option::is_none")]
pub offset: Option<isize>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
#[serde(rename = "device")]
pub device: ::std::string::String,
}
impl ::qapi_spec::Event for BLOCK_IMAGE_CORRUPTED {
const NAME: &'static str = "BLOCK_IMAGE_CORRUPTED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_IO_ERROR {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "reason")]
pub reason: ::std::string::String,
#[serde(rename = "action")]
pub action: BlockErrorAction,
#[serde(rename = "operation")]
pub operation: IoOperationType,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
#[serde(rename = "nospace", default, skip_serializing_if = "Option::is_none")]
pub nospace: Option<bool>,
}
impl ::qapi_spec::Event for BLOCK_IO_ERROR {
const NAME: &'static str = "BLOCK_IO_ERROR";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_JOB_COMPLETED {
#[serde(rename = "offset")]
pub offset: isize,
#[serde(rename = "type")]
pub type_: JobType,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "speed")]
pub speed: isize,
#[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
pub error: Option<::std::string::String>,
#[serde(rename = "len")]
pub len: isize,
}
impl ::qapi_spec::Event for BLOCK_JOB_COMPLETED {
const NAME: &'static str = "BLOCK_JOB_COMPLETED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_JOB_CANCELLED {
#[serde(rename = "offset")]
pub offset: isize,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "type")]
pub type_: JobType,
#[serde(rename = "speed")]
pub speed: isize,
#[serde(rename = "len")]
pub len: isize,
}
impl ::qapi_spec::Event for BLOCK_JOB_CANCELLED {
const NAME: &'static str = "BLOCK_JOB_CANCELLED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_JOB_ERROR {
#[serde(rename = "action")]
pub action: BlockErrorAction,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "operation")]
pub operation: IoOperationType,
}
impl ::qapi_spec::Event for BLOCK_JOB_ERROR {
const NAME: &'static str = "BLOCK_JOB_ERROR";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_JOB_READY {
#[serde(rename = "offset")]
pub offset: isize,
#[serde(rename = "speed")]
pub speed: isize,
#[serde(rename = "type")]
pub type_: JobType,
#[serde(rename = "len")]
pub len: isize,
#[serde(rename = "device")]
pub device: ::std::string::String,
}
impl ::qapi_spec::Event for BLOCK_JOB_READY {
const NAME: &'static str = "BLOCK_JOB_READY";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_JOB_PENDING {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "type")]
pub type_: JobType,
}
impl ::qapi_spec::Event for BLOCK_JOB_PENDING {
const NAME: &'static str = "BLOCK_JOB_PENDING";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum PreallocMode {
#[serde(rename = "off")] off,
#[serde(rename = "metadata")] metadata,
#[serde(rename = "falloc")] falloc,
#[serde(rename = "full")] full,
}
impl ::core::str::FromStr for PreallocMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for PreallocMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
PreallocMode::off,
PreallocMode::metadata,
PreallocMode::falloc,
PreallocMode::full,
];
const NAMES: &'static [&'static str] = &[
"off",
"metadata",
"falloc",
"full",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_WRITE_THRESHOLD {
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
#[serde(rename = "amount-exceeded")]
pub amount_exceeded: u64,
#[serde(rename = "write-threshold")]
pub write_threshold: u64,
}
impl ::qapi_spec::Event for BLOCK_WRITE_THRESHOLD {
const NAME: &'static str = "BLOCK_WRITE_THRESHOLD";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_set_write_threshold {
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
#[serde(rename = "write-threshold")]
pub write_threshold: u64,
}
impl crate::QmpCommand for block_set_write_threshold { }
impl ::qapi_spec::Command for block_set_write_threshold {
const NAME: &'static str = "block-set-write-threshold";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_blockdev_change {
#[serde(rename = "node", default, skip_serializing_if = "Option::is_none")]
pub node: Option<::std::string::String>,
#[serde(rename = "parent")]
pub parent: ::std::string::String,
#[serde(rename = "child", default, skip_serializing_if = "Option::is_none")]
pub child: Option<::std::string::String>,
}
impl crate::QmpCommand for x_blockdev_change { }
impl ::qapi_spec::Command for x_blockdev_change {
const NAME: &'static str = "x-blockdev-change";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_blockdev_set_iothread {
#[serde(rename = "iothread")]
pub iothread: StrOrNull,
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
#[serde(rename = "force", default, skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
}
impl crate::QmpCommand for x_blockdev_set_iothread { }
impl ::qapi_spec::Command for x_blockdev_set_iothread {
const NAME: &'static str = "x-blockdev-set-iothread";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QuorumOpType {
#[serde(rename = "read")] read,
#[serde(rename = "write")] write,
#[serde(rename = "flush")] flush,
}
impl ::core::str::FromStr for QuorumOpType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QuorumOpType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
QuorumOpType::read,
QuorumOpType::write,
QuorumOpType::flush,
];
const NAMES: &'static [&'static str] = &[
"read",
"write",
"flush",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QUORUM_FAILURE {
#[serde(rename = "sector-num")]
pub sector_num: isize,
#[serde(rename = "sectors-count")]
pub sectors_count: isize,
#[serde(rename = "reference")]
pub reference: ::std::string::String,
}
impl ::qapi_spec::Event for QUORUM_FAILURE {
const NAME: &'static str = "QUORUM_FAILURE";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QUORUM_REPORT_BAD {
#[serde(rename = "sector-num")]
pub sector_num: isize,
#[serde(rename = "sectors-count")]
pub sectors_count: isize,
#[serde(rename = "type")]
pub type_: QuorumOpType,
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
#[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
pub error: Option<::std::string::String>,
}
impl ::qapi_spec::Event for QUORUM_REPORT_BAD {
const NAME: &'static str = "QUORUM_REPORT_BAD";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_snapshot_internal_sync(pub BlockdevSnapshotInternal);
impl crate::QmpCommand for blockdev_snapshot_internal_sync { }
impl ::qapi_spec::Command for blockdev_snapshot_internal_sync {
const NAME: &'static str = "blockdev-snapshot-internal-sync";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct blockdev_snapshot_delete_internal_sync {
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
}
impl crate::QmpCommand for blockdev_snapshot_delete_internal_sync { }
impl ::qapi_spec::Command for blockdev_snapshot_delete_internal_sync {
const NAME: &'static str = "blockdev-snapshot-delete-internal-sync";
const ALLOW_OOB: bool = false;
type Ok = SnapshotInfo;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum JobType {
#[serde(rename = "commit")] commit,
#[serde(rename = "stream")] stream,
#[serde(rename = "mirror")] mirror,
#[serde(rename = "backup")] backup,
#[serde(rename = "create")] create,
#[serde(rename = "amend")] amend,
}
impl ::core::str::FromStr for JobType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for JobType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 6;
const VARIANTS: &'static [Self] = &[
JobType::commit,
JobType::stream,
JobType::mirror,
JobType::backup,
JobType::create,
JobType::amend,
];
const NAMES: &'static [&'static str] = &[
"commit",
"stream",
"mirror",
"backup",
"create",
"amend",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum JobStatus {
#[serde(rename = "undefined")] undefined,
#[serde(rename = "created")] created,
#[serde(rename = "running")] running,
#[serde(rename = "paused")] paused,
#[serde(rename = "ready")] ready,
#[serde(rename = "standby")] standby,
#[serde(rename = "waiting")] waiting,
#[serde(rename = "pending")] pending,
#[serde(rename = "aborting")] aborting,
#[serde(rename = "concluded")] concluded,
#[serde(rename = "null")] null,
}
impl ::core::str::FromStr for JobStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for JobStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 11;
const VARIANTS: &'static [Self] = &[
JobStatus::undefined,
JobStatus::created,
JobStatus::running,
JobStatus::paused,
JobStatus::ready,
JobStatus::standby,
JobStatus::waiting,
JobStatus::pending,
JobStatus::aborting,
JobStatus::concluded,
JobStatus::null,
];
const NAMES: &'static [&'static str] = &[
"undefined",
"created",
"running",
"paused",
"ready",
"standby",
"waiting",
"pending",
"aborting",
"concluded",
"null",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum JobVerb {
#[serde(rename = "cancel")] cancel,
#[serde(rename = "pause")] pause,
#[serde(rename = "resume")] resume,
#[serde(rename = "set-speed")] set_speed,
#[serde(rename = "complete")] complete,
#[serde(rename = "dismiss")] dismiss,
#[serde(rename = "finalize")] finalize,
}
impl ::core::str::FromStr for JobVerb {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for JobVerb {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
JobVerb::cancel,
JobVerb::pause,
JobVerb::resume,
JobVerb::set_speed,
JobVerb::complete,
JobVerb::dismiss,
JobVerb::finalize,
];
const NAMES: &'static [&'static str] = &[
"cancel",
"pause",
"resume",
"set-speed",
"complete",
"dismiss",
"finalize",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JOB_STATUS_CHANGE {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "status")]
pub status: JobStatus,
}
impl ::qapi_spec::Event for JOB_STATUS_CHANGE {
const NAME: &'static str = "JOB_STATUS_CHANGE";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct job_pause {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for job_pause { }
impl ::qapi_spec::Command for job_pause {
const NAME: &'static str = "job-pause";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct job_resume {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for job_resume { }
impl ::qapi_spec::Command for job_resume {
const NAME: &'static str = "job-resume";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct job_cancel {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for job_cancel { }
impl ::qapi_spec::Command for job_cancel {
const NAME: &'static str = "job-cancel";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct job_complete {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for job_complete { }
impl ::qapi_spec::Command for job_complete {
const NAME: &'static str = "job-complete";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct job_dismiss {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for job_dismiss { }
impl ::qapi_spec::Command for job_dismiss {
const NAME: &'static str = "job-dismiss";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct job_finalize {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for job_finalize { }
impl ::qapi_spec::Command for job_finalize {
const NAME: &'static str = "job-finalize";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_jobs {
}
impl crate::QmpCommand for query_jobs { }
impl ::qapi_spec::Command for query_jobs {
const NAME: &'static str = "query-jobs";
const ALLOW_OOB: bool = false;
type Ok = Vec<JobInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct nbd_server_start {
#[serde(rename = "max-connections", default, skip_serializing_if = "Option::is_none")]
pub max_connections: Option<u32>,
#[serde(rename = "addr")]
pub addr: SocketAddressLegacy,
#[serde(rename = "tls-creds", default, skip_serializing_if = "Option::is_none")]
pub tls_creds: Option<::std::string::String>,
#[serde(rename = "tls-authz", default, skip_serializing_if = "Option::is_none")]
pub tls_authz: Option<::std::string::String>,
}
impl crate::QmpCommand for nbd_server_start { }
impl ::qapi_spec::Command for nbd_server_start {
const NAME: &'static str = "nbd-server-start";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct nbd_server_add(pub NbdServerAddOptions);
impl crate::QmpCommand for nbd_server_add { }
impl ::qapi_spec::Command for nbd_server_add {
const NAME: &'static str = "nbd-server-add";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockExportRemoveMode {
#[serde(rename = "safe")] safe,
#[serde(rename = "hard")] hard,
}
impl ::core::str::FromStr for BlockExportRemoveMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockExportRemoveMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
BlockExportRemoveMode::safe,
BlockExportRemoveMode::hard,
];
const NAMES: &'static [&'static str] = &[
"safe",
"hard",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct nbd_server_remove {
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<BlockExportRemoveMode>,
}
impl crate::QmpCommand for nbd_server_remove { }
impl ::qapi_spec::Command for nbd_server_remove {
const NAME: &'static str = "nbd-server-remove";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct nbd_server_stop {
}
impl crate::QmpCommand for nbd_server_stop { }
impl ::qapi_spec::Command for nbd_server_stop {
const NAME: &'static str = "nbd-server-stop";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BlockExportType {
#[serde(rename = "nbd")] nbd,
#[serde(rename = "vhost-user-blk")] vhost_user_blk,
}
impl ::core::str::FromStr for BlockExportType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for BlockExportType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
BlockExportType::nbd,
BlockExportType::vhost_user_blk,
];
const NAMES: &'static [&'static str] = &[
"nbd",
"vhost-user-blk",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_export_add(pub BlockExportOptions);
impl crate::QmpCommand for block_export_add { }
impl ::qapi_spec::Command for block_export_add {
const NAME: &'static str = "block-export-add";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct block_export_del {
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<BlockExportRemoveMode>,
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for block_export_del { }
impl ::qapi_spec::Command for block_export_del {
const NAME: &'static str = "block-export-del";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BLOCK_EXPORT_DELETED {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl ::qapi_spec::Event for BLOCK_EXPORT_DELETED {
const NAME: &'static str = "BLOCK_EXPORT_DELETED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_block_exports {
}
impl crate::QmpCommand for query_block_exports { }
impl ::qapi_spec::Command for query_block_exports {
const NAME: &'static str = "query-block-exports";
const ALLOW_OOB: bool = false;
type Ok = Vec<BlockExportInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_chardev {
}
impl crate::QmpCommand for query_chardev { }
impl ::qapi_spec::Command for query_chardev {
const NAME: &'static str = "query-chardev";
const ALLOW_OOB: bool = false;
type Ok = Vec<ChardevInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_chardev_backends {
}
impl crate::QmpCommand for query_chardev_backends { }
impl ::qapi_spec::Command for query_chardev_backends {
const NAME: &'static str = "query-chardev-backends";
const ALLOW_OOB: bool = false;
type Ok = Vec<ChardevBackendInfo>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DataFormat {
#[serde(rename = "utf8")] utf8,
#[serde(rename = "base64")] base64,
}
impl ::core::str::FromStr for DataFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for DataFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
DataFormat::utf8,
DataFormat::base64,
];
const NAMES: &'static [&'static str] = &[
"utf8",
"base64",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ringbuf_write {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "data")]
pub data: ::std::string::String,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<DataFormat>,
}
impl crate::QmpCommand for ringbuf_write { }
impl ::qapi_spec::Command for ringbuf_write {
const NAME: &'static str = "ringbuf-write";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ringbuf_read {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<DataFormat>,
#[serde(rename = "size")]
pub size: isize,
}
impl crate::QmpCommand for ringbuf_read { }
impl ::qapi_spec::Command for ringbuf_read {
const NAME: &'static str = "ringbuf-read";
const ALLOW_OOB: bool = false;
type Ok = ::std::string::String;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ChardevBackend {
#[serde(rename = "wctablet")]
wctablet { data: ChardevCommon },
#[serde(rename = "parallel")]
parallel { data: ChardevHostdev },
#[serde(rename = "socket")]
socket { data: ChardevSocket },
#[serde(rename = "stdio")]
stdio { data: ChardevStdio },
#[serde(rename = "console")]
console { data: ChardevCommon },
#[serde(rename = "serial")]
serial { data: ChardevHostdev },
#[serde(rename = "braille")]
braille { data: ChardevCommon },
#[serde(rename = "spiceport")]
spiceport { data: ChardevSpicePort },
#[serde(rename = "msmouse")]
msmouse { data: ChardevCommon },
#[serde(rename = "file")]
file { data: ChardevFile },
#[serde(rename = "mux")]
mux { data: ChardevMux },
#[serde(rename = "testdev")]
testdev { data: ChardevCommon },
#[serde(rename = "null")]
null { data: ChardevCommon },
#[serde(rename = "pipe")]
pipe { data: ChardevHostdev },
#[serde(rename = "pty")]
pty { data: ChardevCommon },
#[serde(rename = "ringbuf")]
ringbuf { data: ChardevRingbuf },
#[serde(rename = "udp")]
udp { data: ChardevUdp },
#[serde(rename = "vc")]
vc { data: ChardevVC },
#[serde(rename = "memory")]
memory { data: ChardevRingbuf },
#[serde(rename = "spicevmc")]
spicevmc { data: ChardevSpiceChannel },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct chardev_add {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "backend")]
pub backend: ChardevBackend,
}
impl crate::QmpCommand for chardev_add { }
impl ::qapi_spec::Command for chardev_add {
const NAME: &'static str = "chardev-add";
const ALLOW_OOB: bool = false;
type Ok = ChardevReturn;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct chardev_change {
#[serde(rename = "backend")]
pub backend: ChardevBackend,
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for chardev_change { }
impl ::qapi_spec::Command for chardev_change {
const NAME: &'static str = "chardev-change";
const ALLOW_OOB: bool = false;
type Ok = ChardevReturn;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct chardev_remove {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for chardev_remove { }
impl ::qapi_spec::Command for chardev_remove {
const NAME: &'static str = "chardev-remove";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct chardev_send_break {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for chardev_send_break { }
impl ::qapi_spec::Command for chardev_send_break {
const NAME: &'static str = "chardev-send-break";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VSERPORT_CHANGE {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "open")]
pub open: bool,
}
impl ::qapi_spec::Event for VSERPORT_CHANGE {
const NAME: &'static str = "VSERPORT_CHANGE";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DumpGuestMemoryFormat {
#[serde(rename = "elf")] elf,
#[serde(rename = "kdump-zlib")] kdump_zlib,
#[serde(rename = "kdump-lzo")] kdump_lzo,
#[serde(rename = "kdump-snappy")] kdump_snappy,
#[serde(rename = "win-dmp")] win_dmp,
}
impl ::core::str::FromStr for DumpGuestMemoryFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for DumpGuestMemoryFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
DumpGuestMemoryFormat::elf,
DumpGuestMemoryFormat::kdump_zlib,
DumpGuestMemoryFormat::kdump_lzo,
DumpGuestMemoryFormat::kdump_snappy,
DumpGuestMemoryFormat::win_dmp,
];
const NAMES: &'static [&'static str] = &[
"elf",
"kdump-zlib",
"kdump-lzo",
"kdump-snappy",
"win-dmp",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct dump_guest_memory {
#[serde(rename = "detach", default, skip_serializing_if = "Option::is_none")]
pub detach: Option<bool>,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<DumpGuestMemoryFormat>,
#[serde(rename = "begin", default, skip_serializing_if = "Option::is_none")]
pub begin: Option<isize>,
#[serde(rename = "length", default, skip_serializing_if = "Option::is_none")]
pub length: Option<isize>,
#[serde(rename = "protocol")]
pub protocol: ::std::string::String,
#[serde(rename = "paging")]
pub paging: bool,
}
impl crate::QmpCommand for dump_guest_memory { }
impl ::qapi_spec::Command for dump_guest_memory {
const NAME: &'static str = "dump-guest-memory";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DumpStatus {
#[serde(rename = "none")] none,
#[serde(rename = "active")] active,
#[serde(rename = "completed")] completed,
#[serde(rename = "failed")] failed,
}
impl ::core::str::FromStr for DumpStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for DumpStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
DumpStatus::none,
DumpStatus::active,
DumpStatus::completed,
DumpStatus::failed,
];
const NAMES: &'static [&'static str] = &[
"none",
"active",
"completed",
"failed",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_dump {
}
impl crate::QmpCommand for query_dump { }
impl ::qapi_spec::Command for query_dump {
const NAME: &'static str = "query-dump";
const ALLOW_OOB: bool = false;
type Ok = DumpQueryResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DUMP_COMPLETED {
#[serde(rename = "result")]
pub result: DumpQueryResult,
#[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
pub error: Option<::std::string::String>,
}
impl ::qapi_spec::Event for DUMP_COMPLETED {
const NAME: &'static str = "DUMP_COMPLETED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_dump_guest_memory_capability {
}
impl crate::QmpCommand for query_dump_guest_memory_capability { }
impl ::qapi_spec::Command for query_dump_guest_memory_capability {
const NAME: &'static str = "query-dump-guest-memory-capability";
const ALLOW_OOB: bool = false;
type Ok = DumpGuestMemoryCapability;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct set_link {
#[serde(rename = "up")]
pub up: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
impl crate::QmpCommand for set_link { }
impl ::qapi_spec::Command for set_link {
const NAME: &'static str = "set_link";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct netdev_add(pub Netdev);
impl crate::QmpCommand for netdev_add { }
impl ::qapi_spec::Command for netdev_add {
const NAME: &'static str = "netdev_add";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct netdev_del {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for netdev_del { }
impl ::qapi_spec::Command for netdev_del {
const NAME: &'static str = "netdev_del";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum NetClientDriver {
#[serde(rename = "none")] none,
#[serde(rename = "nic")] nic,
#[serde(rename = "user")] user,
#[serde(rename = "tap")] tap,
#[serde(rename = "l2tpv3")] l2tpv3,
#[serde(rename = "socket")] socket,
#[serde(rename = "vde")] vde,
#[serde(rename = "bridge")] bridge,
#[serde(rename = "hubport")] hubport,
#[serde(rename = "netmap")] netmap,
#[serde(rename = "vhost-user")] vhost_user,
#[serde(rename = "vhost-vdpa")] vhost_vdpa,
}
impl ::core::str::FromStr for NetClientDriver {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for NetClientDriver {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 12;
const VARIANTS: &'static [Self] = &[
NetClientDriver::none,
NetClientDriver::nic,
NetClientDriver::user,
NetClientDriver::tap,
NetClientDriver::l2tpv3,
NetClientDriver::socket,
NetClientDriver::vde,
NetClientDriver::bridge,
NetClientDriver::hubport,
NetClientDriver::netmap,
NetClientDriver::vhost_user,
NetClientDriver::vhost_vdpa,
];
const NAMES: &'static [&'static str] = &[
"none",
"nic",
"user",
"tap",
"l2tpv3",
"socket",
"vde",
"bridge",
"hubport",
"netmap",
"vhost-user",
"vhost-vdpa",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum NetFilterDirection {
#[serde(rename = "all")] all,
#[serde(rename = "rx")] rx,
#[serde(rename = "tx")] tx,
}
impl ::core::str::FromStr for NetFilterDirection {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for NetFilterDirection {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
NetFilterDirection::all,
NetFilterDirection::rx,
NetFilterDirection::tx,
];
const NAMES: &'static [&'static str] = &[
"all",
"rx",
"tx",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RxState {
#[serde(rename = "normal")] normal,
#[serde(rename = "none")] none,
#[serde(rename = "all")] all,
}
impl ::core::str::FromStr for RxState {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for RxState {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
RxState::normal,
RxState::none,
RxState::all,
];
const NAMES: &'static [&'static str] = &[
"normal",
"none",
"all",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_rx_filter {
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
}
impl crate::QmpCommand for query_rx_filter { }
impl ::qapi_spec::Command for query_rx_filter {
const NAME: &'static str = "query-rx-filter";
const ALLOW_OOB: bool = false;
type Ok = Vec<RxFilterInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NIC_RX_FILTER_CHANGED {
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
#[serde(rename = "path")]
pub path: ::std::string::String,
}
impl ::qapi_spec::Event for NIC_RX_FILTER_CHANGED {
const NAME: &'static str = "NIC_RX_FILTER_CHANGED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct announce_self(pub AnnounceParameters);
impl crate::QmpCommand for announce_self { }
impl ::qapi_spec::Command for announce_self {
const NAME: &'static str = "announce-self";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FAILOVER_NEGOTIATED {
#[serde(rename = "device-id")]
pub device_id: ::std::string::String,
}
impl ::qapi_spec::Event for FAILOVER_NEGOTIATED {
const NAME: &'static str = "FAILOVER_NEGOTIATED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RDMA_GID_STATUS_CHANGED {
#[serde(rename = "subnet-prefix")]
pub subnet_prefix: u64,
#[serde(rename = "gid-status")]
pub gid_status: bool,
#[serde(rename = "netdev")]
pub netdev: ::std::string::String,
#[serde(rename = "interface-id")]
pub interface_id: u64,
}
impl ::qapi_spec::Event for RDMA_GID_STATUS_CHANGED {
const NAME: &'static str = "RDMA_GID_STATUS_CHANGED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_rocker {
#[serde(rename = "name")]
pub name: ::std::string::String,
}
impl crate::QmpCommand for query_rocker { }
impl ::qapi_spec::Command for query_rocker {
const NAME: &'static str = "query-rocker";
const ALLOW_OOB: bool = false;
type Ok = RockerSwitch;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RockerPortDuplex {
#[serde(rename = "half")] half,
#[serde(rename = "full")] full,
}
impl ::core::str::FromStr for RockerPortDuplex {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for RockerPortDuplex {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
RockerPortDuplex::half,
RockerPortDuplex::full,
];
const NAMES: &'static [&'static str] = &[
"half",
"full",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RockerPortAutoneg {
#[serde(rename = "off")] off,
#[serde(rename = "on")] on,
}
impl ::core::str::FromStr for RockerPortAutoneg {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for RockerPortAutoneg {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
RockerPortAutoneg::off,
RockerPortAutoneg::on,
];
const NAMES: &'static [&'static str] = &[
"off",
"on",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_rocker_ports {
#[serde(rename = "name")]
pub name: ::std::string::String,
}
impl crate::QmpCommand for query_rocker_ports { }
impl ::qapi_spec::Command for query_rocker_ports {
const NAME: &'static str = "query-rocker-ports";
const ALLOW_OOB: bool = false;
type Ok = Vec<RockerPort>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_rocker_of_dpa_flows {
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "tbl-id", default, skip_serializing_if = "Option::is_none")]
pub tbl_id: Option<u32>,
}
impl crate::QmpCommand for query_rocker_of_dpa_flows { }
impl ::qapi_spec::Command for query_rocker_of_dpa_flows {
const NAME: &'static str = "query-rocker-of-dpa-flows";
const ALLOW_OOB: bool = false;
type Ok = Vec<RockerOfDpaFlow>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_rocker_of_dpa_groups {
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<u8>,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
impl crate::QmpCommand for query_rocker_of_dpa_groups { }
impl ::qapi_spec::Command for query_rocker_of_dpa_groups {
const NAME: &'static str = "query-rocker-of-dpa-groups";
const ALLOW_OOB: bool = false;
type Ok = Vec<RockerOfDpaGroup>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum TpmModel {
#[serde(rename = "tpm-tis")] tpm_tis,
#[serde(rename = "tpm-crb")] tpm_crb,
#[serde(rename = "tpm-spapr")] tpm_spapr,
}
impl ::core::str::FromStr for TpmModel {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for TpmModel {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
TpmModel::tpm_tis,
TpmModel::tpm_crb,
TpmModel::tpm_spapr,
];
const NAMES: &'static [&'static str] = &[
"tpm-tis",
"tpm-crb",
"tpm-spapr",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_tpm_models {
}
impl crate::QmpCommand for query_tpm_models { }
impl ::qapi_spec::Command for query_tpm_models {
const NAME: &'static str = "query-tpm-models";
const ALLOW_OOB: bool = false;
type Ok = Vec<TpmModel>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum TpmType {
#[serde(rename = "passthrough")] passthrough,
#[serde(rename = "emulator")] emulator,
}
impl ::core::str::FromStr for TpmType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for TpmType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
TpmType::passthrough,
TpmType::emulator,
];
const NAMES: &'static [&'static str] = &[
"passthrough",
"emulator",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_tpm_types {
}
impl crate::QmpCommand for query_tpm_types { }
impl ::qapi_spec::Command for query_tpm_types {
const NAME: &'static str = "query-tpm-types";
const ALLOW_OOB: bool = false;
type Ok = Vec<TpmType>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum TpmTypeOptions {
#[serde(rename = "passthrough")]
passthrough { data: TPMPassthroughOptions },
#[serde(rename = "emulator")]
emulator { data: TPMEmulatorOptions },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_tpm {
}
impl crate::QmpCommand for query_tpm { }
impl ::qapi_spec::Command for query_tpm {
const NAME: &'static str = "query-tpm";
const ALLOW_OOB: bool = false;
type Ok = Vec<TPMInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct set_password {
#[serde(rename = "connected", default, skip_serializing_if = "Option::is_none")]
pub connected: Option<::std::string::String>,
#[serde(rename = "protocol")]
pub protocol: ::std::string::String,
#[serde(rename = "password")]
pub password: ::std::string::String,
}
impl crate::QmpCommand for set_password { }
impl ::qapi_spec::Command for set_password {
const NAME: &'static str = "set_password";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct expire_password {
#[serde(rename = "time")]
pub time: ::std::string::String,
#[serde(rename = "protocol")]
pub protocol: ::std::string::String,
}
impl crate::QmpCommand for expire_password { }
impl ::qapi_spec::Command for expire_password {
const NAME: &'static str = "expire_password";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct screendump {
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "head", default, skip_serializing_if = "Option::is_none")]
pub head: Option<isize>,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
}
impl crate::QmpCommand for screendump { }
impl ::qapi_spec::Command for screendump {
const NAME: &'static str = "screendump";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SpiceQueryMouseMode {
#[serde(rename = "client")] client,
#[serde(rename = "server")] server,
#[serde(rename = "unknown")] unknown,
}
impl ::core::str::FromStr for SpiceQueryMouseMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SpiceQueryMouseMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
SpiceQueryMouseMode::client,
SpiceQueryMouseMode::server,
SpiceQueryMouseMode::unknown,
];
const NAMES: &'static [&'static str] = &[
"client",
"server",
"unknown",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_spice {
}
impl crate::QmpCommand for query_spice { }
impl ::qapi_spec::Command for query_spice {
const NAME: &'static str = "query-spice";
const ALLOW_OOB: bool = false;
type Ok = SpiceInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SPICE_CONNECTED {
#[serde(rename = "server")]
pub server: SpiceBasicInfo,
#[serde(rename = "client")]
pub client: SpiceBasicInfo,
}
impl ::qapi_spec::Event for SPICE_CONNECTED {
const NAME: &'static str = "SPICE_CONNECTED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SPICE_INITIALIZED {
#[serde(rename = "server")]
pub server: SpiceServerInfo,
#[serde(rename = "client")]
pub client: SpiceChannel,
}
impl ::qapi_spec::Event for SPICE_INITIALIZED {
const NAME: &'static str = "SPICE_INITIALIZED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SPICE_DISCONNECTED {
#[serde(rename = "server")]
pub server: SpiceBasicInfo,
#[serde(rename = "client")]
pub client: SpiceBasicInfo,
}
impl ::qapi_spec::Event for SPICE_DISCONNECTED {
const NAME: &'static str = "SPICE_DISCONNECTED";
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct SPICE_MIGRATE_COMPLETED {
}
impl ::qapi_spec::Event for SPICE_MIGRATE_COMPLETED {
const NAME: &'static str = "SPICE_MIGRATE_COMPLETED";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum VncPrimaryAuth {
#[serde(rename = "none")] none,
#[serde(rename = "vnc")] vnc,
#[serde(rename = "ra2")] ra2,
#[serde(rename = "ra2ne")] ra2ne,
#[serde(rename = "tight")] tight,
#[serde(rename = "ultra")] ultra,
#[serde(rename = "tls")] tls,
#[serde(rename = "vencrypt")] vencrypt,
#[serde(rename = "sasl")] sasl,
}
impl ::core::str::FromStr for VncPrimaryAuth {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for VncPrimaryAuth {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 9;
const VARIANTS: &'static [Self] = &[
VncPrimaryAuth::none,
VncPrimaryAuth::vnc,
VncPrimaryAuth::ra2,
VncPrimaryAuth::ra2ne,
VncPrimaryAuth::tight,
VncPrimaryAuth::ultra,
VncPrimaryAuth::tls,
VncPrimaryAuth::vencrypt,
VncPrimaryAuth::sasl,
];
const NAMES: &'static [&'static str] = &[
"none",
"vnc",
"ra2",
"ra2ne",
"tight",
"ultra",
"tls",
"vencrypt",
"sasl",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum VncVencryptSubAuth {
#[serde(rename = "plain")] plain,
#[serde(rename = "tls-none")] tls_none,
#[serde(rename = "x509-none")] x509_none,
#[serde(rename = "tls-vnc")] tls_vnc,
#[serde(rename = "x509-vnc")] x509_vnc,
#[serde(rename = "tls-plain")] tls_plain,
#[serde(rename = "x509-plain")] x509_plain,
#[serde(rename = "tls-sasl")] tls_sasl,
#[serde(rename = "x509-sasl")] x509_sasl,
}
impl ::core::str::FromStr for VncVencryptSubAuth {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for VncVencryptSubAuth {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 9;
const VARIANTS: &'static [Self] = &[
VncVencryptSubAuth::plain,
VncVencryptSubAuth::tls_none,
VncVencryptSubAuth::x509_none,
VncVencryptSubAuth::tls_vnc,
VncVencryptSubAuth::x509_vnc,
VncVencryptSubAuth::tls_plain,
VncVencryptSubAuth::x509_plain,
VncVencryptSubAuth::tls_sasl,
VncVencryptSubAuth::x509_sasl,
];
const NAMES: &'static [&'static str] = &[
"plain",
"tls-none",
"x509-none",
"tls-vnc",
"x509-vnc",
"tls-plain",
"x509-plain",
"tls-sasl",
"x509-sasl",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_vnc {
}
impl crate::QmpCommand for query_vnc { }
impl ::qapi_spec::Command for query_vnc {
const NAME: &'static str = "query-vnc";
const ALLOW_OOB: bool = false;
type Ok = VncInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_vnc_servers {
}
impl crate::QmpCommand for query_vnc_servers { }
impl ::qapi_spec::Command for query_vnc_servers {
const NAME: &'static str = "query-vnc-servers";
const ALLOW_OOB: bool = false;
type Ok = Vec<VncInfo2>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct change_vnc_password {
#[serde(rename = "password")]
pub password: ::std::string::String,
}
impl crate::QmpCommand for change_vnc_password { }
impl ::qapi_spec::Command for change_vnc_password {
const NAME: &'static str = "change-vnc-password";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VNC_CONNECTED {
#[serde(rename = "server")]
pub server: VncServerInfo,
#[serde(rename = "client")]
pub client: VncBasicInfo,
}
impl ::qapi_spec::Event for VNC_CONNECTED {
const NAME: &'static str = "VNC_CONNECTED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VNC_INITIALIZED {
#[serde(rename = "client")]
pub client: VncClientInfo,
#[serde(rename = "server")]
pub server: VncServerInfo,
}
impl ::qapi_spec::Event for VNC_INITIALIZED {
const NAME: &'static str = "VNC_INITIALIZED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VNC_DISCONNECTED {
#[serde(rename = "server")]
pub server: VncServerInfo,
#[serde(rename = "client")]
pub client: VncClientInfo,
}
impl ::qapi_spec::Event for VNC_DISCONNECTED {
const NAME: &'static str = "VNC_DISCONNECTED";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_mice {
}
impl crate::QmpCommand for query_mice { }
impl ::qapi_spec::Command for query_mice {
const NAME: &'static str = "query-mice";
const ALLOW_OOB: bool = false;
type Ok = Vec<MouseInfo>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QKeyCode {
#[serde(rename = "unmapped")] unmapped,
#[serde(rename = "shift")] shift,
#[serde(rename = "shift_r")] shift_r,
#[serde(rename = "alt")] alt,
#[serde(rename = "alt_r")] alt_r,
#[serde(rename = "ctrl")] ctrl,
#[serde(rename = "ctrl_r")] ctrl_r,
#[serde(rename = "menu")] menu,
#[serde(rename = "esc")] esc,
#[serde(rename = "1")] _1,
#[serde(rename = "2")] _2,
#[serde(rename = "3")] _3,
#[serde(rename = "4")] _4,
#[serde(rename = "5")] _5,
#[serde(rename = "6")] _6,
#[serde(rename = "7")] _7,
#[serde(rename = "8")] _8,
#[serde(rename = "9")] _9,
#[serde(rename = "0")] _0,
#[serde(rename = "minus")] minus,
#[serde(rename = "equal")] equal,
#[serde(rename = "backspace")] backspace,
#[serde(rename = "tab")] tab,
#[serde(rename = "q")] q,
#[serde(rename = "w")] w,
#[serde(rename = "e")] e,
#[serde(rename = "r")] r,
#[serde(rename = "t")] t,
#[serde(rename = "y")] y,
#[serde(rename = "u")] u,
#[serde(rename = "i")] i,
#[serde(rename = "o")] o,
#[serde(rename = "p")] p,
#[serde(rename = "bracket_left")] bracket_left,
#[serde(rename = "bracket_right")] bracket_right,
#[serde(rename = "ret")] ret,
#[serde(rename = "a")] a,
#[serde(rename = "s")] s,
#[serde(rename = "d")] d,
#[serde(rename = "f")] f,
#[serde(rename = "g")] g,
#[serde(rename = "h")] h,
#[serde(rename = "j")] j,
#[serde(rename = "k")] k,
#[serde(rename = "l")] l,
#[serde(rename = "semicolon")] semicolon,
#[serde(rename = "apostrophe")] apostrophe,
#[serde(rename = "grave_accent")] grave_accent,
#[serde(rename = "backslash")] backslash,
#[serde(rename = "z")] z,
#[serde(rename = "x")] x,
#[serde(rename = "c")] c,
#[serde(rename = "v")] v,
#[serde(rename = "b")] b,
#[serde(rename = "n")] n,
#[serde(rename = "m")] m,
#[serde(rename = "comma")] comma,
#[serde(rename = "dot")] dot,
#[serde(rename = "slash")] slash,
#[serde(rename = "asterisk")] asterisk,
#[serde(rename = "spc")] spc,
#[serde(rename = "caps_lock")] caps_lock,
#[serde(rename = "f1")] f1,
#[serde(rename = "f2")] f2,
#[serde(rename = "f3")] f3,
#[serde(rename = "f4")] f4,
#[serde(rename = "f5")] f5,
#[serde(rename = "f6")] f6,
#[serde(rename = "f7")] f7,
#[serde(rename = "f8")] f8,
#[serde(rename = "f9")] f9,
#[serde(rename = "f10")] f10,
#[serde(rename = "num_lock")] num_lock,
#[serde(rename = "scroll_lock")] scroll_lock,
#[serde(rename = "kp_divide")] kp_divide,
#[serde(rename = "kp_multiply")] kp_multiply,
#[serde(rename = "kp_subtract")] kp_subtract,
#[serde(rename = "kp_add")] kp_add,
#[serde(rename = "kp_enter")] kp_enter,
#[serde(rename = "kp_decimal")] kp_decimal,
#[serde(rename = "sysrq")] sysrq,
#[serde(rename = "kp_0")] kp_0,
#[serde(rename = "kp_1")] kp_1,
#[serde(rename = "kp_2")] kp_2,
#[serde(rename = "kp_3")] kp_3,
#[serde(rename = "kp_4")] kp_4,
#[serde(rename = "kp_5")] kp_5,
#[serde(rename = "kp_6")] kp_6,
#[serde(rename = "kp_7")] kp_7,
#[serde(rename = "kp_8")] kp_8,
#[serde(rename = "kp_9")] kp_9,
#[serde(rename = "less")] less,
#[serde(rename = "f11")] f11,
#[serde(rename = "f12")] f12,
#[serde(rename = "print")] print,
#[serde(rename = "home")] home,
#[serde(rename = "pgup")] pgup,
#[serde(rename = "pgdn")] pgdn,
#[serde(rename = "end")] end,
#[serde(rename = "left")] left,
#[serde(rename = "up")] up,
#[serde(rename = "down")] down,
#[serde(rename = "right")] right,
#[serde(rename = "insert")] insert,
#[serde(rename = "delete")] delete,
#[serde(rename = "stop")] stop,
#[serde(rename = "again")] again,
#[serde(rename = "props")] props,
#[serde(rename = "undo")] undo,
#[serde(rename = "front")] front,
#[serde(rename = "copy")] copy,
#[serde(rename = "open")] open,
#[serde(rename = "paste")] paste,
#[serde(rename = "find")] find,
#[serde(rename = "cut")] cut,
#[serde(rename = "lf")] lf,
#[serde(rename = "help")] help,
#[serde(rename = "meta_l")] meta_l,
#[serde(rename = "meta_r")] meta_r,
#[serde(rename = "compose")] compose,
#[serde(rename = "pause")] pause,
#[serde(rename = "ro")] ro,
#[serde(rename = "hiragana")] hiragana,
#[serde(rename = "henkan")] henkan,
#[serde(rename = "yen")] yen,
#[serde(rename = "muhenkan")] muhenkan,
#[serde(rename = "katakanahiragana")] katakanahiragana,
#[serde(rename = "kp_comma")] kp_comma,
#[serde(rename = "kp_equals")] kp_equals,
#[serde(rename = "power")] power,
#[serde(rename = "sleep")] sleep,
#[serde(rename = "wake")] wake,
#[serde(rename = "audionext")] audionext,
#[serde(rename = "audioprev")] audioprev,
#[serde(rename = "audiostop")] audiostop,
#[serde(rename = "audioplay")] audioplay,
#[serde(rename = "audiomute")] audiomute,
#[serde(rename = "volumeup")] volumeup,
#[serde(rename = "volumedown")] volumedown,
#[serde(rename = "mediaselect")] mediaselect,
#[serde(rename = "mail")] mail,
#[serde(rename = "calculator")] calculator,
#[serde(rename = "computer")] computer,
#[serde(rename = "ac_home")] ac_home,
#[serde(rename = "ac_back")] ac_back,
#[serde(rename = "ac_forward")] ac_forward,
#[serde(rename = "ac_refresh")] ac_refresh,
#[serde(rename = "ac_bookmarks")] ac_bookmarks,
}
impl ::core::str::FromStr for QKeyCode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QKeyCode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 148;
const VARIANTS: &'static [Self] = &[
QKeyCode::unmapped,
QKeyCode::shift,
QKeyCode::shift_r,
QKeyCode::alt,
QKeyCode::alt_r,
QKeyCode::ctrl,
QKeyCode::ctrl_r,
QKeyCode::menu,
QKeyCode::esc,
QKeyCode::_1,
QKeyCode::_2,
QKeyCode::_3,
QKeyCode::_4,
QKeyCode::_5,
QKeyCode::_6,
QKeyCode::_7,
QKeyCode::_8,
QKeyCode::_9,
QKeyCode::_0,
QKeyCode::minus,
QKeyCode::equal,
QKeyCode::backspace,
QKeyCode::tab,
QKeyCode::q,
QKeyCode::w,
QKeyCode::e,
QKeyCode::r,
QKeyCode::t,
QKeyCode::y,
QKeyCode::u,
QKeyCode::i,
QKeyCode::o,
QKeyCode::p,
QKeyCode::bracket_left,
QKeyCode::bracket_right,
QKeyCode::ret,
QKeyCode::a,
QKeyCode::s,
QKeyCode::d,
QKeyCode::f,
QKeyCode::g,
QKeyCode::h,
QKeyCode::j,
QKeyCode::k,
QKeyCode::l,
QKeyCode::semicolon,
QKeyCode::apostrophe,
QKeyCode::grave_accent,
QKeyCode::backslash,
QKeyCode::z,
QKeyCode::x,
QKeyCode::c,
QKeyCode::v,
QKeyCode::b,
QKeyCode::n,
QKeyCode::m,
QKeyCode::comma,
QKeyCode::dot,
QKeyCode::slash,
QKeyCode::asterisk,
QKeyCode::spc,
QKeyCode::caps_lock,
QKeyCode::f1,
QKeyCode::f2,
QKeyCode::f3,
QKeyCode::f4,
QKeyCode::f5,
QKeyCode::f6,
QKeyCode::f7,
QKeyCode::f8,
QKeyCode::f9,
QKeyCode::f10,
QKeyCode::num_lock,
QKeyCode::scroll_lock,
QKeyCode::kp_divide,
QKeyCode::kp_multiply,
QKeyCode::kp_subtract,
QKeyCode::kp_add,
QKeyCode::kp_enter,
QKeyCode::kp_decimal,
QKeyCode::sysrq,
QKeyCode::kp_0,
QKeyCode::kp_1,
QKeyCode::kp_2,
QKeyCode::kp_3,
QKeyCode::kp_4,
QKeyCode::kp_5,
QKeyCode::kp_6,
QKeyCode::kp_7,
QKeyCode::kp_8,
QKeyCode::kp_9,
QKeyCode::less,
QKeyCode::f11,
QKeyCode::f12,
QKeyCode::print,
QKeyCode::home,
QKeyCode::pgup,
QKeyCode::pgdn,
QKeyCode::end,
QKeyCode::left,
QKeyCode::up,
QKeyCode::down,
QKeyCode::right,
QKeyCode::insert,
QKeyCode::delete,
QKeyCode::stop,
QKeyCode::again,
QKeyCode::props,
QKeyCode::undo,
QKeyCode::front,
QKeyCode::copy,
QKeyCode::open,
QKeyCode::paste,
QKeyCode::find,
QKeyCode::cut,
QKeyCode::lf,
QKeyCode::help,
QKeyCode::meta_l,
QKeyCode::meta_r,
QKeyCode::compose,
QKeyCode::pause,
QKeyCode::ro,
QKeyCode::hiragana,
QKeyCode::henkan,
QKeyCode::yen,
QKeyCode::muhenkan,
QKeyCode::katakanahiragana,
QKeyCode::kp_comma,
QKeyCode::kp_equals,
QKeyCode::power,
QKeyCode::sleep,
QKeyCode::wake,
QKeyCode::audionext,
QKeyCode::audioprev,
QKeyCode::audiostop,
QKeyCode::audioplay,
QKeyCode::audiomute,
QKeyCode::volumeup,
QKeyCode::volumedown,
QKeyCode::mediaselect,
QKeyCode::mail,
QKeyCode::calculator,
QKeyCode::computer,
QKeyCode::ac_home,
QKeyCode::ac_back,
QKeyCode::ac_forward,
QKeyCode::ac_refresh,
QKeyCode::ac_bookmarks,
];
const NAMES: &'static [&'static str] = &[
"unmapped",
"shift",
"shift_r",
"alt",
"alt_r",
"ctrl",
"ctrl_r",
"menu",
"esc",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"0",
"minus",
"equal",
"backspace",
"tab",
"q",
"w",
"e",
"r",
"t",
"y",
"u",
"i",
"o",
"p",
"bracket_left",
"bracket_right",
"ret",
"a",
"s",
"d",
"f",
"g",
"h",
"j",
"k",
"l",
"semicolon",
"apostrophe",
"grave_accent",
"backslash",
"z",
"x",
"c",
"v",
"b",
"n",
"m",
"comma",
"dot",
"slash",
"asterisk",
"spc",
"caps_lock",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"f7",
"f8",
"f9",
"f10",
"num_lock",
"scroll_lock",
"kp_divide",
"kp_multiply",
"kp_subtract",
"kp_add",
"kp_enter",
"kp_decimal",
"sysrq",
"kp_0",
"kp_1",
"kp_2",
"kp_3",
"kp_4",
"kp_5",
"kp_6",
"kp_7",
"kp_8",
"kp_9",
"less",
"f11",
"f12",
"print",
"home",
"pgup",
"pgdn",
"end",
"left",
"up",
"down",
"right",
"insert",
"delete",
"stop",
"again",
"props",
"undo",
"front",
"copy",
"open",
"paste",
"find",
"cut",
"lf",
"help",
"meta_l",
"meta_r",
"compose",
"pause",
"ro",
"hiragana",
"henkan",
"yen",
"muhenkan",
"katakanahiragana",
"kp_comma",
"kp_equals",
"power",
"sleep",
"wake",
"audionext",
"audioprev",
"audiostop",
"audioplay",
"audiomute",
"volumeup",
"volumedown",
"mediaselect",
"mail",
"calculator",
"computer",
"ac_home",
"ac_back",
"ac_forward",
"ac_refresh",
"ac_bookmarks",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum KeyValue {
#[serde(rename = "number")]
number { data: isize },
#[serde(rename = "qcode")]
qcode { data: QKeyCode },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct send_key {
#[serde(rename = "hold-time", default, skip_serializing_if = "Option::is_none")]
pub hold_time: Option<isize>,
#[serde(rename = "keys")]
pub keys: Vec<KeyValue>,
}
impl crate::QmpCommand for send_key { }
impl ::qapi_spec::Command for send_key {
const NAME: &'static str = "send-key";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum InputButton {
#[serde(rename = "left")] left,
#[serde(rename = "middle")] middle,
#[serde(rename = "right")] right,
#[serde(rename = "wheel-up")] wheel_up,
#[serde(rename = "wheel-down")] wheel_down,
#[serde(rename = "side")] side,
#[serde(rename = "extra")] extra,
}
impl ::core::str::FromStr for InputButton {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for InputButton {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
InputButton::left,
InputButton::middle,
InputButton::right,
InputButton::wheel_up,
InputButton::wheel_down,
InputButton::side,
InputButton::extra,
];
const NAMES: &'static [&'static str] = &[
"left",
"middle",
"right",
"wheel-up",
"wheel-down",
"side",
"extra",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum InputAxis {
#[serde(rename = "x")] x,
#[serde(rename = "y")] y,
}
impl ::core::str::FromStr for InputAxis {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for InputAxis {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
InputAxis::x,
InputAxis::y,
];
const NAMES: &'static [&'static str] = &[
"x",
"y",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum InputEvent {
#[serde(rename = "abs")]
abs { data: InputMoveEvent },
#[serde(rename = "key")]
key { data: InputKeyEvent },
#[serde(rename = "btn")]
btn { data: InputBtnEvent },
#[serde(rename = "rel")]
rel { data: InputMoveEvent },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct input_send_event {
#[serde(rename = "head", default, skip_serializing_if = "Option::is_none")]
pub head: Option<isize>,
#[serde(rename = "events")]
pub events: Vec<InputEvent>,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
}
impl crate::QmpCommand for input_send_event { }
impl ::qapi_spec::Command for input_send_event {
const NAME: &'static str = "input-send-event";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum GrabToggleKeys {
#[serde(rename = "ctrl-ctrl")] ctrl_ctrl,
#[serde(rename = "alt-alt")] alt_alt,
#[serde(rename = "shift-shift")] shift_shift,
#[serde(rename = "meta-meta")] meta_meta,
#[serde(rename = "scrolllock")] scrolllock,
#[serde(rename = "ctrl-scrolllock")] ctrl_scrolllock,
}
impl ::core::str::FromStr for GrabToggleKeys {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for GrabToggleKeys {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 6;
const VARIANTS: &'static [Self] = &[
GrabToggleKeys::ctrl_ctrl,
GrabToggleKeys::alt_alt,
GrabToggleKeys::shift_shift,
GrabToggleKeys::meta_meta,
GrabToggleKeys::scrolllock,
GrabToggleKeys::ctrl_scrolllock,
];
const NAMES: &'static [&'static str] = &[
"ctrl-ctrl",
"alt-alt",
"shift-shift",
"meta-meta",
"scrolllock",
"ctrl-scrolllock",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DisplayGLMode {
#[serde(rename = "off")] off,
#[serde(rename = "on")] on,
#[serde(rename = "core")] core,
#[serde(rename = "es")] es,
}
impl ::core::str::FromStr for DisplayGLMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for DisplayGLMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
DisplayGLMode::off,
DisplayGLMode::on,
DisplayGLMode::core,
DisplayGLMode::es,
];
const NAMES: &'static [&'static str] = &[
"off",
"on",
"core",
"es",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DisplayType {
#[serde(rename = "default")] default,
#[serde(rename = "none")] none,
#[serde(rename = "gtk")] gtk,
#[serde(rename = "sdl")] sdl,
#[serde(rename = "egl-headless")] egl_headless,
#[serde(rename = "curses")] curses,
#[serde(rename = "cocoa")] cocoa,
#[serde(rename = "spice-app")] spice_app,
}
impl ::core::str::FromStr for DisplayType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for DisplayType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 8;
const VARIANTS: &'static [Self] = &[
DisplayType::default,
DisplayType::none,
DisplayType::gtk,
DisplayType::sdl,
DisplayType::egl_headless,
DisplayType::curses,
DisplayType::cocoa,
DisplayType::spice_app,
];
const NAMES: &'static [&'static str] = &[
"default",
"none",
"gtk",
"sdl",
"egl-headless",
"curses",
"cocoa",
"spice-app",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_display_options {
}
impl crate::QmpCommand for query_display_options { }
impl ::qapi_spec::Command for query_display_options {
const NAME: &'static str = "query-display-options";
const ALLOW_OOB: bool = false;
type Ok = DisplayOptions;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QAuthZListPolicy {
#[serde(rename = "deny")] deny,
#[serde(rename = "allow")] allow,
}
impl ::core::str::FromStr for QAuthZListPolicy {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QAuthZListPolicy {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
QAuthZListPolicy::deny,
QAuthZListPolicy::allow,
];
const NAMES: &'static [&'static str] = &[
"deny",
"allow",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QAuthZListFormat {
#[serde(rename = "exact")] exact,
#[serde(rename = "glob")] glob,
}
impl ::core::str::FromStr for QAuthZListFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QAuthZListFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
QAuthZListFormat::exact,
QAuthZListFormat::glob,
];
const NAMES: &'static [&'static str] = &[
"exact",
"glob",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MigrationStatus {
#[serde(rename = "none")] none,
#[serde(rename = "setup")] setup,
#[serde(rename = "cancelling")] cancelling,
#[serde(rename = "cancelled")] cancelled,
#[serde(rename = "active")] active,
#[serde(rename = "postcopy-active")] postcopy_active,
#[serde(rename = "postcopy-paused")] postcopy_paused,
#[serde(rename = "postcopy-recover")] postcopy_recover,
#[serde(rename = "completed")] completed,
#[serde(rename = "failed")] failed,
#[serde(rename = "colo")] colo,
#[serde(rename = "pre-switchover")] pre_switchover,
#[serde(rename = "device")] device,
#[serde(rename = "wait-unplug")] wait_unplug,
}
impl ::core::str::FromStr for MigrationStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MigrationStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 14;
const VARIANTS: &'static [Self] = &[
MigrationStatus::none,
MigrationStatus::setup,
MigrationStatus::cancelling,
MigrationStatus::cancelled,
MigrationStatus::active,
MigrationStatus::postcopy_active,
MigrationStatus::postcopy_paused,
MigrationStatus::postcopy_recover,
MigrationStatus::completed,
MigrationStatus::failed,
MigrationStatus::colo,
MigrationStatus::pre_switchover,
MigrationStatus::device,
MigrationStatus::wait_unplug,
];
const NAMES: &'static [&'static str] = &[
"none",
"setup",
"cancelling",
"cancelled",
"active",
"postcopy-active",
"postcopy-paused",
"postcopy-recover",
"completed",
"failed",
"colo",
"pre-switchover",
"device",
"wait-unplug",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_migrate {
}
impl crate::QmpCommand for query_migrate { }
impl ::qapi_spec::Command for query_migrate {
const NAME: &'static str = "query-migrate";
const ALLOW_OOB: bool = false;
type Ok = MigrationInfo;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MigrationCapability {
#[serde(rename = "xbzrle")] xbzrle,
#[serde(rename = "rdma-pin-all")] rdma_pin_all,
#[serde(rename = "auto-converge")] auto_converge,
#[serde(rename = "zero-blocks")] zero_blocks,
#[serde(rename = "compress")] compress,
#[serde(rename = "events")] events,
#[serde(rename = "postcopy-ram")] postcopy_ram,
#[serde(rename = "x-colo")] x_colo,
#[serde(rename = "release-ram")] release_ram,
#[serde(rename = "block")] block,
#[serde(rename = "return-path")] return_path,
#[serde(rename = "pause-before-switchover")] pause_before_switchover,
#[serde(rename = "multifd")] multifd,
#[serde(rename = "dirty-bitmaps")] dirty_bitmaps,
#[serde(rename = "postcopy-blocktime")] postcopy_blocktime,
#[serde(rename = "late-block-activate")] late_block_activate,
#[serde(rename = "x-ignore-shared")] x_ignore_shared,
#[serde(rename = "validate-uuid")] validate_uuid,
}
impl ::core::str::FromStr for MigrationCapability {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MigrationCapability {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 18;
const VARIANTS: &'static [Self] = &[
MigrationCapability::xbzrle,
MigrationCapability::rdma_pin_all,
MigrationCapability::auto_converge,
MigrationCapability::zero_blocks,
MigrationCapability::compress,
MigrationCapability::events,
MigrationCapability::postcopy_ram,
MigrationCapability::x_colo,
MigrationCapability::release_ram,
MigrationCapability::block,
MigrationCapability::return_path,
MigrationCapability::pause_before_switchover,
MigrationCapability::multifd,
MigrationCapability::dirty_bitmaps,
MigrationCapability::postcopy_blocktime,
MigrationCapability::late_block_activate,
MigrationCapability::x_ignore_shared,
MigrationCapability::validate_uuid,
];
const NAMES: &'static [&'static str] = &[
"xbzrle",
"rdma-pin-all",
"auto-converge",
"zero-blocks",
"compress",
"events",
"postcopy-ram",
"x-colo",
"release-ram",
"block",
"return-path",
"pause-before-switchover",
"multifd",
"dirty-bitmaps",
"postcopy-blocktime",
"late-block-activate",
"x-ignore-shared",
"validate-uuid",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_set_capabilities {
#[serde(rename = "capabilities")]
pub capabilities: Vec<MigrationCapabilityStatus>,
}
impl crate::QmpCommand for migrate_set_capabilities { }
impl ::qapi_spec::Command for migrate_set_capabilities {
const NAME: &'static str = "migrate-set-capabilities";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_migrate_capabilities {
}
impl crate::QmpCommand for query_migrate_capabilities { }
impl ::qapi_spec::Command for query_migrate_capabilities {
const NAME: &'static str = "query-migrate-capabilities";
const ALLOW_OOB: bool = false;
type Ok = Vec<MigrationCapabilityStatus>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MultiFDCompression {
#[serde(rename = "none")] none,
#[serde(rename = "zlib")] zlib,
#[serde(rename = "zstd")] zstd,
}
impl ::core::str::FromStr for MultiFDCompression {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MultiFDCompression {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
MultiFDCompression::none,
MultiFDCompression::zlib,
MultiFDCompression::zstd,
];
const NAMES: &'static [&'static str] = &[
"none",
"zlib",
"zstd",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MigrationParameter {
#[serde(rename = "announce-initial")] announce_initial,
#[serde(rename = "announce-max")] announce_max,
#[serde(rename = "announce-rounds")] announce_rounds,
#[serde(rename = "announce-step")] announce_step,
#[serde(rename = "compress-level")] compress_level,
#[serde(rename = "compress-threads")] compress_threads,
#[serde(rename = "decompress-threads")] decompress_threads,
#[serde(rename = "compress-wait-thread")] compress_wait_thread,
#[serde(rename = "throttle-trigger-threshold")] throttle_trigger_threshold,
#[serde(rename = "cpu-throttle-initial")] cpu_throttle_initial,
#[serde(rename = "cpu-throttle-increment")] cpu_throttle_increment,
#[serde(rename = "cpu-throttle-tailslow")] cpu_throttle_tailslow,
#[serde(rename = "tls-creds")] tls_creds,
#[serde(rename = "tls-hostname")] tls_hostname,
#[serde(rename = "tls-authz")] tls_authz,
#[serde(rename = "max-bandwidth")] max_bandwidth,
#[serde(rename = "downtime-limit")] downtime_limit,
#[serde(rename = "x-checkpoint-delay")] x_checkpoint_delay,
#[serde(rename = "block-incremental")] block_incremental,
#[serde(rename = "multifd-channels")] multifd_channels,
#[serde(rename = "xbzrle-cache-size")] xbzrle_cache_size,
#[serde(rename = "max-postcopy-bandwidth")] max_postcopy_bandwidth,
#[serde(rename = "max-cpu-throttle")] max_cpu_throttle,
#[serde(rename = "multifd-compression")] multifd_compression,
#[serde(rename = "multifd-zlib-level")] multifd_zlib_level,
#[serde(rename = "multifd-zstd-level")] multifd_zstd_level,
#[serde(rename = "block-bitmap-mapping")] block_bitmap_mapping,
}
impl ::core::str::FromStr for MigrationParameter {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MigrationParameter {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 27;
const VARIANTS: &'static [Self] = &[
MigrationParameter::announce_initial,
MigrationParameter::announce_max,
MigrationParameter::announce_rounds,
MigrationParameter::announce_step,
MigrationParameter::compress_level,
MigrationParameter::compress_threads,
MigrationParameter::decompress_threads,
MigrationParameter::compress_wait_thread,
MigrationParameter::throttle_trigger_threshold,
MigrationParameter::cpu_throttle_initial,
MigrationParameter::cpu_throttle_increment,
MigrationParameter::cpu_throttle_tailslow,
MigrationParameter::tls_creds,
MigrationParameter::tls_hostname,
MigrationParameter::tls_authz,
MigrationParameter::max_bandwidth,
MigrationParameter::downtime_limit,
MigrationParameter::x_checkpoint_delay,
MigrationParameter::block_incremental,
MigrationParameter::multifd_channels,
MigrationParameter::xbzrle_cache_size,
MigrationParameter::max_postcopy_bandwidth,
MigrationParameter::max_cpu_throttle,
MigrationParameter::multifd_compression,
MigrationParameter::multifd_zlib_level,
MigrationParameter::multifd_zstd_level,
MigrationParameter::block_bitmap_mapping,
];
const NAMES: &'static [&'static str] = &[
"announce-initial",
"announce-max",
"announce-rounds",
"announce-step",
"compress-level",
"compress-threads",
"decompress-threads",
"compress-wait-thread",
"throttle-trigger-threshold",
"cpu-throttle-initial",
"cpu-throttle-increment",
"cpu-throttle-tailslow",
"tls-creds",
"tls-hostname",
"tls-authz",
"max-bandwidth",
"downtime-limit",
"x-checkpoint-delay",
"block-incremental",
"multifd-channels",
"xbzrle-cache-size",
"max-postcopy-bandwidth",
"max-cpu-throttle",
"multifd-compression",
"multifd-zlib-level",
"multifd-zstd-level",
"block-bitmap-mapping",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_set_parameters(pub MigrateSetParameters);
impl crate::QmpCommand for migrate_set_parameters { }
impl ::qapi_spec::Command for migrate_set_parameters {
const NAME: &'static str = "migrate-set-parameters";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_migrate_parameters {
}
impl crate::QmpCommand for query_migrate_parameters { }
impl ::qapi_spec::Command for query_migrate_parameters {
const NAME: &'static str = "query-migrate-parameters";
const ALLOW_OOB: bool = false;
type Ok = MigrationParameters;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct client_migrate_info {
#[serde(rename = "protocol")]
pub protocol: ::std::string::String,
#[serde(rename = "port", default, skip_serializing_if = "Option::is_none")]
pub port: Option<isize>,
#[serde(rename = "hostname")]
pub hostname: ::std::string::String,
#[serde(rename = "cert-subject", default, skip_serializing_if = "Option::is_none")]
pub cert_subject: Option<::std::string::String>,
#[serde(rename = "tls-port", default, skip_serializing_if = "Option::is_none")]
pub tls_port: Option<isize>,
}
impl crate::QmpCommand for client_migrate_info { }
impl ::qapi_spec::Command for client_migrate_info {
const NAME: &'static str = "client_migrate_info";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_start_postcopy {
}
impl crate::QmpCommand for migrate_start_postcopy { }
impl ::qapi_spec::Command for migrate_start_postcopy {
const NAME: &'static str = "migrate-start-postcopy";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MIGRATION {
#[serde(rename = "status")]
pub status: MigrationStatus,
}
impl ::qapi_spec::Event for MIGRATION {
const NAME: &'static str = "MIGRATION";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MIGRATION_PASS {
#[serde(rename = "pass")]
pub pass: isize,
}
impl ::qapi_spec::Event for MIGRATION_PASS {
const NAME: &'static str = "MIGRATION_PASS";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum COLOMessage {
#[serde(rename = "checkpoint-ready")] checkpoint_ready,
#[serde(rename = "checkpoint-request")] checkpoint_request,
#[serde(rename = "checkpoint-reply")] checkpoint_reply,
#[serde(rename = "vmstate-send")] vmstate_send,
#[serde(rename = "vmstate-size")] vmstate_size,
#[serde(rename = "vmstate-received")] vmstate_received,
#[serde(rename = "vmstate-loaded")] vmstate_loaded,
}
impl ::core::str::FromStr for COLOMessage {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for COLOMessage {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
COLOMessage::checkpoint_ready,
COLOMessage::checkpoint_request,
COLOMessage::checkpoint_reply,
COLOMessage::vmstate_send,
COLOMessage::vmstate_size,
COLOMessage::vmstate_received,
COLOMessage::vmstate_loaded,
];
const NAMES: &'static [&'static str] = &[
"checkpoint-ready",
"checkpoint-request",
"checkpoint-reply",
"vmstate-send",
"vmstate-size",
"vmstate-received",
"vmstate-loaded",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum COLOMode {
#[serde(rename = "none")] none,
#[serde(rename = "primary")] primary,
#[serde(rename = "secondary")] secondary,
}
impl ::core::str::FromStr for COLOMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for COLOMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
COLOMode::none,
COLOMode::primary,
COLOMode::secondary,
];
const NAMES: &'static [&'static str] = &[
"none",
"primary",
"secondary",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum FailoverStatus {
#[serde(rename = "none")] none,
#[serde(rename = "require")] require,
#[serde(rename = "active")] active,
#[serde(rename = "completed")] completed,
#[serde(rename = "relaunch")] relaunch,
}
impl ::core::str::FromStr for FailoverStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for FailoverStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
FailoverStatus::none,
FailoverStatus::require,
FailoverStatus::active,
FailoverStatus::completed,
FailoverStatus::relaunch,
];
const NAMES: &'static [&'static str] = &[
"none",
"require",
"active",
"completed",
"relaunch",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct COLO_EXIT {
#[serde(rename = "mode")]
pub mode: COLOMode,
#[serde(rename = "reason")]
pub reason: COLOExitReason,
}
impl ::qapi_spec::Event for COLO_EXIT {
const NAME: &'static str = "COLO_EXIT";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum COLOExitReason {
#[serde(rename = "none")] none,
#[serde(rename = "request")] request,
#[serde(rename = "error")] error,
#[serde(rename = "processing")] processing,
}
impl ::core::str::FromStr for COLOExitReason {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for COLOExitReason {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
COLOExitReason::none,
COLOExitReason::request,
COLOExitReason::error,
COLOExitReason::processing,
];
const NAMES: &'static [&'static str] = &[
"none",
"request",
"error",
"processing",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_colo_lost_heartbeat {
}
impl crate::QmpCommand for x_colo_lost_heartbeat { }
impl ::qapi_spec::Command for x_colo_lost_heartbeat {
const NAME: &'static str = "x-colo-lost-heartbeat";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_cancel {
}
impl crate::QmpCommand for migrate_cancel { }
impl ::qapi_spec::Command for migrate_cancel {
const NAME: &'static str = "migrate_cancel";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_continue {
#[serde(rename = "state")]
pub state: MigrationStatus,
}
impl crate::QmpCommand for migrate_continue { }
impl ::qapi_spec::Command for migrate_continue {
const NAME: &'static str = "migrate-continue";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct migrate_set_downtime {
#[serde(rename = "value")]
pub value: f64,
}
impl crate::QmpCommand for migrate_set_downtime { }
impl ::qapi_spec::Command for migrate_set_downtime {
const NAME: &'static str = "migrate_set_downtime";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct migrate_set_speed {
#[serde(rename = "value")]
pub value: isize,
}
impl crate::QmpCommand for migrate_set_speed { }
impl ::qapi_spec::Command for migrate_set_speed {
const NAME: &'static str = "migrate_set_speed";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct migrate_set_cache_size {
#[serde(rename = "value")]
pub value: isize,
}
impl crate::QmpCommand for migrate_set_cache_size { }
impl ::qapi_spec::Command for migrate_set_cache_size {
const NAME: &'static str = "migrate-set-cache-size";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct query_migrate_cache_size {
}
impl crate::QmpCommand for query_migrate_cache_size { }
impl ::qapi_spec::Command for query_migrate_cache_size {
const NAME: &'static str = "query-migrate-cache-size";
const ALLOW_OOB: bool = false;
type Ok = isize;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate {
#[serde(rename = "detach", default, skip_serializing_if = "Option::is_none")]
pub detach: Option<bool>,
#[serde(rename = "uri")]
pub uri: ::std::string::String,
#[serde(rename = "blk", default, skip_serializing_if = "Option::is_none")]
pub blk: Option<bool>,
#[serde(rename = "inc", default, skip_serializing_if = "Option::is_none")]
pub inc: Option<bool>,
#[serde(rename = "resume", default, skip_serializing_if = "Option::is_none")]
pub resume: Option<bool>,
}
impl crate::QmpCommand for migrate { }
impl ::qapi_spec::Command for migrate {
const NAME: &'static str = "migrate";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_incoming {
#[serde(rename = "uri")]
pub uri: ::std::string::String,
}
impl crate::QmpCommand for migrate_incoming { }
impl ::qapi_spec::Command for migrate_incoming {
const NAME: &'static str = "migrate-incoming";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct xen_save_devices_state {
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "live", default, skip_serializing_if = "Option::is_none")]
pub live: Option<bool>,
}
impl crate::QmpCommand for xen_save_devices_state { }
impl ::qapi_spec::Command for xen_save_devices_state {
const NAME: &'static str = "xen-save-devices-state";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct xen_set_global_dirty_log {
#[serde(rename = "enable")]
pub enable: bool,
}
impl crate::QmpCommand for xen_set_global_dirty_log { }
impl ::qapi_spec::Command for xen_set_global_dirty_log {
const NAME: &'static str = "xen-set-global-dirty-log";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct xen_load_devices_state {
#[serde(rename = "filename")]
pub filename: ::std::string::String,
}
impl crate::QmpCommand for xen_load_devices_state { }
impl ::qapi_spec::Command for xen_load_devices_state {
const NAME: &'static str = "xen-load-devices-state";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct xen_set_replication {
#[serde(rename = "enable")]
pub enable: bool,
#[serde(rename = "primary")]
pub primary: bool,
#[serde(rename = "failover", default, skip_serializing_if = "Option::is_none")]
pub failover: Option<bool>,
}
impl crate::QmpCommand for xen_set_replication { }
impl ::qapi_spec::Command for xen_set_replication {
const NAME: &'static str = "xen-set-replication";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_xen_replication_status {
}
impl crate::QmpCommand for query_xen_replication_status { }
impl ::qapi_spec::Command for query_xen_replication_status {
const NAME: &'static str = "query-xen-replication-status";
const ALLOW_OOB: bool = false;
type Ok = ReplicationStatus;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct xen_colo_do_checkpoint {
}
impl crate::QmpCommand for xen_colo_do_checkpoint { }
impl ::qapi_spec::Command for xen_colo_do_checkpoint {
const NAME: &'static str = "xen-colo-do-checkpoint";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_colo_status {
}
impl crate::QmpCommand for query_colo_status { }
impl ::qapi_spec::Command for query_colo_status {
const NAME: &'static str = "query-colo-status";
const ALLOW_OOB: bool = false;
type Ok = COLOStatus;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_recover {
#[serde(rename = "uri")]
pub uri: ::std::string::String,
}
impl crate::QmpCommand for migrate_recover { }
impl ::qapi_spec::Command for migrate_recover {
const NAME: &'static str = "migrate-recover";
const ALLOW_OOB: bool = true;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct migrate_pause {
}
impl crate::QmpCommand for migrate_pause { }
impl ::qapi_spec::Command for migrate_pause {
const NAME: &'static str = "migrate-pause";
const ALLOW_OOB: bool = true;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UNPLUG_PRIMARY {
#[serde(rename = "device-id")]
pub device_id: ::std::string::String,
}
impl ::qapi_spec::Event for UNPLUG_PRIMARY {
const NAME: &'static str = "UNPLUG_PRIMARY";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DirtyRateStatus {
#[serde(rename = "unstarted")] unstarted,
#[serde(rename = "measuring")] measuring,
#[serde(rename = "measured")] measured,
}
impl ::core::str::FromStr for DirtyRateStatus {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for DirtyRateStatus {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
DirtyRateStatus::unstarted,
DirtyRateStatus::measuring,
DirtyRateStatus::measured,
];
const NAMES: &'static [&'static str] = &[
"unstarted",
"measuring",
"measured",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct calc_dirty_rate {
#[serde(rename = "calc-time")]
pub calc_time: i64,
}
impl crate::QmpCommand for calc_dirty_rate { }
impl ::qapi_spec::Command for calc_dirty_rate {
const NAME: &'static str = "calc-dirty-rate";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_dirty_rate {
}
impl crate::QmpCommand for query_dirty_rate { }
impl ::qapi_spec::Command for query_dirty_rate {
const NAME: &'static str = "query-dirty-rate";
const ALLOW_OOB: bool = false;
type Ok = DirtyRateInfo;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ActionCompletionMode {
#[serde(rename = "individual")] individual,
#[serde(rename = "grouped")] grouped,
}
impl ::core::str::FromStr for ActionCompletionMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for ActionCompletionMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
ActionCompletionMode::individual,
ActionCompletionMode::grouped,
];
const NAMES: &'static [&'static str] = &[
"individual",
"grouped",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum TransactionAction {
#[serde(rename = "block-dirty-bitmap-clear")]
block_dirty_bitmap_clear { data: BlockDirtyBitmap },
#[serde(rename = "block-dirty-bitmap-enable")]
block_dirty_bitmap_enable { data: BlockDirtyBitmap },
#[serde(rename = "block-dirty-bitmap-disable")]
block_dirty_bitmap_disable { data: BlockDirtyBitmap },
#[serde(rename = "block-dirty-bitmap-merge")]
block_dirty_bitmap_merge { data: BlockDirtyBitmapMerge },
#[serde(rename = "drive-backup")]
drive_backup { data: DriveBackup },
#[serde(rename = "blockdev-snapshot-sync")]
blockdev_snapshot_sync { data: BlockdevSnapshotSync },
#[serde(rename = "blockdev-snapshot-internal-sync")]
blockdev_snapshot_internal_sync { data: BlockdevSnapshotInternal },
#[serde(rename = "block-dirty-bitmap-add")]
block_dirty_bitmap_add { data: BlockDirtyBitmapAdd },
#[serde(rename = "blockdev-backup")]
blockdev_backup { data: BlockdevBackup },
#[serde(rename = "block-dirty-bitmap-remove")]
block_dirty_bitmap_remove { data: BlockDirtyBitmap },
#[serde(rename = "blockdev-snapshot")]
blockdev_snapshot { data: BlockdevSnapshot },
#[serde(rename = "abort")]
abort { data: Abort },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct transaction {
#[serde(rename = "actions")]
pub actions: Vec<TransactionAction>,
#[serde(rename = "properties", default, skip_serializing_if = "Option::is_none")]
pub properties: Option<TransactionProperties>,
}
impl crate::QmpCommand for transaction { }
impl ::qapi_spec::Command for transaction {
const NAME: &'static str = "transaction";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum TraceEventState {
#[serde(rename = "unavailable")] unavailable,
#[serde(rename = "disabled")] disabled,
#[serde(rename = "enabled")] enabled,
}
impl ::core::str::FromStr for TraceEventState {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for TraceEventState {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
TraceEventState::unavailable,
TraceEventState::disabled,
TraceEventState::enabled,
];
const NAMES: &'static [&'static str] = &[
"unavailable",
"disabled",
"enabled",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct trace_event_get_state {
#[serde(rename = "vcpu", default, skip_serializing_if = "Option::is_none")]
pub vcpu: Option<isize>,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
impl crate::QmpCommand for trace_event_get_state { }
impl ::qapi_spec::Command for trace_event_get_state {
const NAME: &'static str = "trace-event-get-state";
const ALLOW_OOB: bool = false;
type Ok = Vec<TraceEventInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct trace_event_set_state {
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "enable")]
pub enable: bool,
#[serde(rename = "vcpu", default, skip_serializing_if = "Option::is_none")]
pub vcpu: Option<isize>,
#[serde(rename = "ignore-unavailable", default, skip_serializing_if = "Option::is_none")]
pub ignore_unavailable: Option<bool>,
}
impl crate::QmpCommand for trace_event_set_state { }
impl ::qapi_spec::Command for trace_event_set_state {
const NAME: &'static str = "trace-event-set-state";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct qmp_capabilities {
#[serde(rename = "enable", default, skip_serializing_if = "Option::is_none")]
pub enable: Option<Vec<QMPCapability>>,
}
impl crate::QmpCommand for qmp_capabilities { }
impl ::qapi_spec::Command for qmp_capabilities {
const NAME: &'static str = "qmp_capabilities";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum QMPCapability {
#[serde(rename = "oob")] oob,
}
impl ::core::str::FromStr for QMPCapability {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for QMPCapability {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 1;
const VARIANTS: &'static [Self] = &[
QMPCapability::oob,
];
const NAMES: &'static [&'static str] = &[
"oob",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_version {
}
impl crate::QmpCommand for query_version { }
impl ::qapi_spec::Command for query_version {
const NAME: &'static str = "query-version";
const ALLOW_OOB: bool = false;
type Ok = VersionInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_commands {
}
impl crate::QmpCommand for query_commands { }
impl ::qapi_spec::Command for query_commands {
const NAME: &'static str = "query-commands";
const ALLOW_OOB: bool = false;
type Ok = Vec<CommandInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct query_events {
}
impl crate::QmpCommand for query_events { }
impl ::qapi_spec::Command for query_events {
const NAME: &'static str = "query-events";
const ALLOW_OOB: bool = false;
type Ok = Vec<EventInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct quit {
}
impl crate::QmpCommand for quit { }
impl ::qapi_spec::Command for quit {
const NAME: &'static str = "quit";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MonitorMode {
#[serde(rename = "readline")] readline,
#[serde(rename = "control")] control,
}
impl ::core::str::FromStr for MonitorMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for MonitorMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
MonitorMode::readline,
MonitorMode::control,
];
const NAMES: &'static [&'static str] = &[
"readline",
"control",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_qmp_schema {
#[serde(flatten)]
pub arguments: ::qapi_spec::Dictionary,
}
impl crate::QmpCommand for query_qmp_schema { }
impl ::qapi_spec::Command for query_qmp_schema {
const NAME: &'static str = "query-qmp-schema";
const ALLOW_OOB: bool = false;
type Ok = Vec<SchemaInfo>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SchemaMetaType {
#[serde(rename = "builtin")] builtin,
#[serde(rename = "enum")] enum_,
#[serde(rename = "array")] array,
#[serde(rename = "object")] object,
#[serde(rename = "alternate")] alternate,
#[serde(rename = "command")] command,
#[serde(rename = "event")] event,
}
impl ::core::str::FromStr for SchemaMetaType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SchemaMetaType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
SchemaMetaType::builtin,
SchemaMetaType::enum_,
SchemaMetaType::array,
SchemaMetaType::object,
SchemaMetaType::alternate,
SchemaMetaType::command,
SchemaMetaType::event,
];
const NAMES: &'static [&'static str] = &[
"builtin",
"enum",
"array",
"object",
"alternate",
"command",
"event",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum JSONType {
#[serde(rename = "string")] string,
#[serde(rename = "number")] number,
#[serde(rename = "int")] int,
#[serde(rename = "boolean")] boolean,
#[serde(rename = "null")] null,
#[serde(rename = "object")] object,
#[serde(rename = "array")] array,
#[serde(rename = "value")] value,
}
impl ::core::str::FromStr for JSONType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for JSONType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 8;
const VARIANTS: &'static [Self] = &[
JSONType::string,
JSONType::number,
JSONType::int,
JSONType::boolean,
JSONType::null,
JSONType::object,
JSONType::array,
JSONType::value,
];
const NAMES: &'static [&'static str] = &[
"string",
"number",
"int",
"boolean",
"null",
"object",
"array",
"value",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct qom_list {
#[serde(rename = "path")]
pub path: ::std::string::String,
}
impl crate::QmpCommand for qom_list { }
impl ::qapi_spec::Command for qom_list {
const NAME: &'static str = "qom-list";
const ALLOW_OOB: bool = false;
type Ok = Vec<ObjectPropertyInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct qom_get {
#[serde(rename = "property")]
pub property: ::std::string::String,
#[serde(rename = "path")]
pub path: ::std::string::String,
}
impl crate::QmpCommand for qom_get { }
impl ::qapi_spec::Command for qom_get {
const NAME: &'static str = "qom-get";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Any;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct qom_set {
#[serde(rename = "value")]
pub value: ::qapi_spec::Any,
#[serde(rename = "path")]
pub path: ::std::string::String,
#[serde(rename = "property")]
pub property: ::std::string::String,
}
impl crate::QmpCommand for qom_set { }
impl ::qapi_spec::Command for qom_set {
const NAME: &'static str = "qom-set";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct qom_list_types {
#[serde(rename = "implements", default, skip_serializing_if = "Option::is_none")]
pub implements: Option<::std::string::String>,
#[serde(rename = "abstract", default, skip_serializing_if = "Option::is_none")]
pub abstract_: Option<bool>,
}
impl crate::QmpCommand for qom_list_types { }
impl ::qapi_spec::Command for qom_list_types {
const NAME: &'static str = "qom-list-types";
const ALLOW_OOB: bool = false;
type Ok = Vec<ObjectTypeInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct qom_list_properties {
#[serde(rename = "typename")]
pub typename: ::std::string::String,
}
impl crate::QmpCommand for qom_list_properties { }
impl ::qapi_spec::Command for qom_list_properties {
const NAME: &'static str = "qom-list-properties";
const ALLOW_OOB: bool = false;
type Ok = Vec<ObjectPropertyInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct object_add {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "qom-type")]
pub qom_type: ::std::string::String,
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
pub props: Option<::qapi_spec::Dictionary>,
#[serde(flatten)]
pub arguments: ::qapi_spec::Dictionary,
}
impl crate::QmpCommand for object_add { }
impl ::qapi_spec::Command for object_add {
const NAME: &'static str = "object-add";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct object_del {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for object_del { }
impl ::qapi_spec::Command for object_del {
const NAME: &'static str = "object-del";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct device_list_properties {
#[serde(rename = "typename")]
pub typename: ::std::string::String,
}
impl crate::QmpCommand for device_list_properties { }
impl ::qapi_spec::Command for device_list_properties {
const NAME: &'static str = "device-list-properties";
const ALLOW_OOB: bool = false;
type Ok = Vec<ObjectPropertyInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct device_add {
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "bus", default, skip_serializing_if = "Option::is_none")]
pub bus: Option<::std::string::String>,
#[serde(rename = "driver")]
pub driver: ::std::string::String,
#[serde(flatten)]
pub arguments: ::qapi_spec::Dictionary,
}
impl crate::QmpCommand for device_add { }
impl ::qapi_spec::Command for device_add {
const NAME: &'static str = "device_add";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct device_del {
#[serde(rename = "id")]
pub id: ::std::string::String,
}
impl crate::QmpCommand for device_del { }
impl ::qapi_spec::Command for device_del {
const NAME: &'static str = "device_del";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DEVICE_DELETED {
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
#[serde(rename = "path")]
pub path: ::std::string::String,
}
impl ::qapi_spec::Event for DEVICE_DELETED {
const NAME: &'static str = "DEVICE_DELETED";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SysEmuTarget {
#[serde(rename = "aarch64")] aarch64,
#[serde(rename = "alpha")] alpha,
#[serde(rename = "arm")] arm,
#[serde(rename = "avr")] avr,
#[serde(rename = "cris")] cris,
#[serde(rename = "hppa")] hppa,
#[serde(rename = "i386")] i386,
#[serde(rename = "lm32")] lm32,
#[serde(rename = "m68k")] m68k,
#[serde(rename = "microblaze")] microblaze,
#[serde(rename = "microblazeel")] microblazeel,
#[serde(rename = "mips")] mips,
#[serde(rename = "mips64")] mips64,
#[serde(rename = "mips64el")] mips64el,
#[serde(rename = "mipsel")] mipsel,
#[serde(rename = "moxie")] moxie,
#[serde(rename = "nios2")] nios2,
#[serde(rename = "or1k")] or1k,
#[serde(rename = "ppc")] ppc,
#[serde(rename = "ppc64")] ppc64,
#[serde(rename = "riscv32")] riscv32,
#[serde(rename = "riscv64")] riscv64,
#[serde(rename = "rx")] rx,
#[serde(rename = "s390x")] s390x,
#[serde(rename = "sh4")] sh4,
#[serde(rename = "sh4eb")] sh4eb,
#[serde(rename = "sparc")] sparc,
#[serde(rename = "sparc64")] sparc64,
#[serde(rename = "tricore")] tricore,
#[serde(rename = "unicore32")] unicore32,
#[serde(rename = "x86_64")] x86_64,
#[serde(rename = "xtensa")] xtensa,
#[serde(rename = "xtensaeb")] xtensaeb,
}
impl ::core::str::FromStr for SysEmuTarget {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SysEmuTarget {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 33;
const VARIANTS: &'static [Self] = &[
SysEmuTarget::aarch64,
SysEmuTarget::alpha,
SysEmuTarget::arm,
SysEmuTarget::avr,
SysEmuTarget::cris,
SysEmuTarget::hppa,
SysEmuTarget::i386,
SysEmuTarget::lm32,
SysEmuTarget::m68k,
SysEmuTarget::microblaze,
SysEmuTarget::microblazeel,
SysEmuTarget::mips,
SysEmuTarget::mips64,
SysEmuTarget::mips64el,
SysEmuTarget::mipsel,
SysEmuTarget::moxie,
SysEmuTarget::nios2,
SysEmuTarget::or1k,
SysEmuTarget::ppc,
SysEmuTarget::ppc64,
SysEmuTarget::riscv32,
SysEmuTarget::riscv64,
SysEmuTarget::rx,
SysEmuTarget::s390x,
SysEmuTarget::sh4,
SysEmuTarget::sh4eb,
SysEmuTarget::sparc,
SysEmuTarget::sparc64,
SysEmuTarget::tricore,
SysEmuTarget::unicore32,
SysEmuTarget::x86_64,
SysEmuTarget::xtensa,
SysEmuTarget::xtensaeb,
];
const NAMES: &'static [&'static str] = &[
"aarch64",
"alpha",
"arm",
"avr",
"cris",
"hppa",
"i386",
"lm32",
"m68k",
"microblaze",
"microblazeel",
"mips",
"mips64",
"mips64el",
"mipsel",
"moxie",
"nios2",
"or1k",
"ppc",
"ppc64",
"riscv32",
"riscv64",
"rx",
"s390x",
"sh4",
"sh4eb",
"sparc",
"sparc64",
"tricore",
"unicore32",
"x86_64",
"xtensa",
"xtensaeb",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum CpuInfoArch {
#[serde(rename = "x86")] x86,
#[serde(rename = "sparc")] sparc,
#[serde(rename = "ppc")] ppc,
#[serde(rename = "mips")] mips,
#[serde(rename = "tricore")] tricore,
#[serde(rename = "s390")] s390,
#[serde(rename = "riscv")] riscv,
#[serde(rename = "other")] other,
}
impl ::core::str::FromStr for CpuInfoArch {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for CpuInfoArch {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 8;
const VARIANTS: &'static [Self] = &[
CpuInfoArch::x86,
CpuInfoArch::sparc,
CpuInfoArch::ppc,
CpuInfoArch::mips,
CpuInfoArch::tricore,
CpuInfoArch::s390,
CpuInfoArch::riscv,
CpuInfoArch::other,
];
const NAMES: &'static [&'static str] = &[
"x86",
"sparc",
"ppc",
"mips",
"tricore",
"s390",
"riscv",
"other",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum CpuS390State {
#[serde(rename = "uninitialized")] uninitialized,
#[serde(rename = "stopped")] stopped,
#[serde(rename = "check-stop")] check_stop,
#[serde(rename = "operating")] operating,
#[serde(rename = "load")] load,
}
impl ::core::str::FromStr for CpuS390State {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for CpuS390State {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
CpuS390State::uninitialized,
CpuS390State::stopped,
CpuS390State::check_stop,
CpuS390State::operating,
CpuS390State::load,
];
const NAMES: &'static [&'static str] = &[
"uninitialized",
"stopped",
"check-stop",
"operating",
"load",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct query_cpus {
}
impl crate::QmpCommand for query_cpus { }
impl ::qapi_spec::Command for query_cpus {
const NAME: &'static str = "query-cpus";
const ALLOW_OOB: bool = false;
type Ok = Vec<CpuInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_cpus_fast {
}
impl crate::QmpCommand for query_cpus_fast { }
impl ::qapi_spec::Command for query_cpus_fast {
const NAME: &'static str = "query-cpus-fast";
const ALLOW_OOB: bool = false;
type Ok = Vec<CpuInfoFast>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_machines {
}
impl crate::QmpCommand for query_machines { }
impl ::qapi_spec::Command for query_machines {
const NAME: &'static str = "query-machines";
const ALLOW_OOB: bool = false;
type Ok = Vec<MachineInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_current_machine {
}
impl crate::QmpCommand for query_current_machine { }
impl ::qapi_spec::Command for query_current_machine {
const NAME: &'static str = "query-current-machine";
const ALLOW_OOB: bool = false;
type Ok = CurrentMachineParams;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_target {
}
impl crate::QmpCommand for query_target { }
impl ::qapi_spec::Command for query_target {
const NAME: &'static str = "query-target";
const ALLOW_OOB: bool = false;
type Ok = TargetInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_uuid {
}
impl crate::QmpCommand for query_uuid { }
impl ::qapi_spec::Command for query_uuid {
const NAME: &'static str = "query-uuid";
const ALLOW_OOB: bool = false;
type Ok = UuidInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_vm_generation_id {
}
impl crate::QmpCommand for query_vm_generation_id { }
impl ::qapi_spec::Command for query_vm_generation_id {
const NAME: &'static str = "query-vm-generation-id";
const ALLOW_OOB: bool = false;
type Ok = GuidInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct system_reset {
}
impl crate::QmpCommand for system_reset { }
impl ::qapi_spec::Command for system_reset {
const NAME: &'static str = "system_reset";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct system_powerdown {
}
impl crate::QmpCommand for system_powerdown { }
impl ::qapi_spec::Command for system_powerdown {
const NAME: &'static str = "system_powerdown";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct system_wakeup {
}
impl crate::QmpCommand for system_wakeup { }
impl ::qapi_spec::Command for system_wakeup {
const NAME: &'static str = "system_wakeup";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum LostTickPolicy {
#[serde(rename = "discard")] discard,
#[serde(rename = "delay")] delay,
#[serde(rename = "slew")] slew,
}
impl ::core::str::FromStr for LostTickPolicy {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for LostTickPolicy {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
LostTickPolicy::discard,
LostTickPolicy::delay,
LostTickPolicy::slew,
];
const NAMES: &'static [&'static str] = &[
"discard",
"delay",
"slew",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct inject_nmi {
}
impl crate::QmpCommand for inject_nmi { }
impl ::qapi_spec::Command for inject_nmi {
const NAME: &'static str = "inject-nmi";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_kvm {
}
impl crate::QmpCommand for query_kvm { }
impl ::qapi_spec::Command for query_kvm {
const NAME: &'static str = "query-kvm";
const ALLOW_OOB: bool = false;
type Ok = KvmInfo;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum NumaOptionsType {
#[serde(rename = "node")] node,
#[serde(rename = "dist")] dist,
#[serde(rename = "cpu")] cpu,
#[serde(rename = "hmat-lb")] hmat_lb,
#[serde(rename = "hmat-cache")] hmat_cache,
}
impl ::core::str::FromStr for NumaOptionsType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for NumaOptionsType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 5;
const VARIANTS: &'static [Self] = &[
NumaOptionsType::node,
NumaOptionsType::dist,
NumaOptionsType::cpu,
NumaOptionsType::hmat_lb,
NumaOptionsType::hmat_cache,
];
const NAMES: &'static [&'static str] = &[
"node",
"dist",
"cpu",
"hmat-lb",
"hmat-cache",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum X86CPURegister32 {
#[serde(rename = "EAX")] EAX,
#[serde(rename = "EBX")] EBX,
#[serde(rename = "ECX")] ECX,
#[serde(rename = "EDX")] EDX,
#[serde(rename = "ESP")] ESP,
#[serde(rename = "EBP")] EBP,
#[serde(rename = "ESI")] ESI,
#[serde(rename = "EDI")] EDI,
}
impl ::core::str::FromStr for X86CPURegister32 {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for X86CPURegister32 {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 8;
const VARIANTS: &'static [Self] = &[
X86CPURegister32::EAX,
X86CPURegister32::EBX,
X86CPURegister32::ECX,
X86CPURegister32::EDX,
X86CPURegister32::ESP,
X86CPURegister32::EBP,
X86CPURegister32::ESI,
X86CPURegister32::EDI,
];
const NAMES: &'static [&'static str] = &[
"EAX",
"EBX",
"ECX",
"EDX",
"ESP",
"EBP",
"ESI",
"EDI",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum HmatLBMemoryHierarchy {
#[serde(rename = "memory")] memory,
#[serde(rename = "first-level")] first_level,
#[serde(rename = "second-level")] second_level,
#[serde(rename = "third-level")] third_level,
}
impl ::core::str::FromStr for HmatLBMemoryHierarchy {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for HmatLBMemoryHierarchy {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
HmatLBMemoryHierarchy::memory,
HmatLBMemoryHierarchy::first_level,
HmatLBMemoryHierarchy::second_level,
HmatLBMemoryHierarchy::third_level,
];
const NAMES: &'static [&'static str] = &[
"memory",
"first-level",
"second-level",
"third-level",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum HmatLBDataType {
#[serde(rename = "access-latency")] access_latency,
#[serde(rename = "read-latency")] read_latency,
#[serde(rename = "write-latency")] write_latency,
#[serde(rename = "access-bandwidth")] access_bandwidth,
#[serde(rename = "read-bandwidth")] read_bandwidth,
#[serde(rename = "write-bandwidth")] write_bandwidth,
}
impl ::core::str::FromStr for HmatLBDataType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for HmatLBDataType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 6;
const VARIANTS: &'static [Self] = &[
HmatLBDataType::access_latency,
HmatLBDataType::read_latency,
HmatLBDataType::write_latency,
HmatLBDataType::access_bandwidth,
HmatLBDataType::read_bandwidth,
HmatLBDataType::write_bandwidth,
];
const NAMES: &'static [&'static str] = &[
"access-latency",
"read-latency",
"write-latency",
"access-bandwidth",
"read-bandwidth",
"write-bandwidth",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum HmatCacheAssociativity {
#[serde(rename = "none")] none,
#[serde(rename = "direct")] direct,
#[serde(rename = "complex")] complex,
}
impl ::core::str::FromStr for HmatCacheAssociativity {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for HmatCacheAssociativity {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
HmatCacheAssociativity::none,
HmatCacheAssociativity::direct,
HmatCacheAssociativity::complex,
];
const NAMES: &'static [&'static str] = &[
"none",
"direct",
"complex",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum HmatCacheWritePolicy {
#[serde(rename = "none")] none,
#[serde(rename = "write-back")] write_back,
#[serde(rename = "write-through")] write_through,
}
impl ::core::str::FromStr for HmatCacheWritePolicy {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for HmatCacheWritePolicy {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
HmatCacheWritePolicy::none,
HmatCacheWritePolicy::write_back,
HmatCacheWritePolicy::write_through,
];
const NAMES: &'static [&'static str] = &[
"none",
"write-back",
"write-through",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum HostMemPolicy {
#[serde(rename = "default")] default,
#[serde(rename = "preferred")] preferred,
#[serde(rename = "bind")] bind,
#[serde(rename = "interleave")] interleave,
}
impl ::core::str::FromStr for HostMemPolicy {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for HostMemPolicy {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
HostMemPolicy::default,
HostMemPolicy::preferred,
HostMemPolicy::bind,
HostMemPolicy::interleave,
];
const NAMES: &'static [&'static str] = &[
"default",
"preferred",
"bind",
"interleave",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct memsave {
#[serde(rename = "size")]
pub size: isize,
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "val")]
pub val: isize,
#[serde(rename = "cpu-index", default, skip_serializing_if = "Option::is_none")]
pub cpu_index: Option<isize>,
}
impl crate::QmpCommand for memsave { }
impl ::qapi_spec::Command for memsave {
const NAME: &'static str = "memsave";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct pmemsave {
#[serde(rename = "val")]
pub val: isize,
#[serde(rename = "size")]
pub size: isize,
#[serde(rename = "filename")]
pub filename: ::std::string::String,
}
impl crate::QmpCommand for pmemsave { }
impl ::qapi_spec::Command for pmemsave {
const NAME: &'static str = "pmemsave";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_memdev {
}
impl crate::QmpCommand for query_memdev { }
impl ::qapi_spec::Command for query_memdev {
const NAME: &'static str = "query-memdev";
const ALLOW_OOB: bool = false;
type Ok = Vec<Memdev>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_hotpluggable_cpus {
}
impl crate::QmpCommand for query_hotpluggable_cpus { }
impl ::qapi_spec::Command for query_hotpluggable_cpus {
const NAME: &'static str = "query-hotpluggable-cpus";
const ALLOW_OOB: bool = false;
type Ok = Vec<HotpluggableCPU>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct set_numa_node(pub NumaOptions);
impl crate::QmpCommand for set_numa_node { }
impl ::qapi_spec::Command for set_numa_node {
const NAME: &'static str = "set-numa-node";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct balloon {
#[serde(rename = "value")]
pub value: isize,
}
impl crate::QmpCommand for balloon { }
impl ::qapi_spec::Command for balloon {
const NAME: &'static str = "balloon";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_balloon {
}
impl crate::QmpCommand for query_balloon { }
impl ::qapi_spec::Command for query_balloon {
const NAME: &'static str = "query-balloon";
const ALLOW_OOB: bool = false;
type Ok = BalloonInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BALLOON_CHANGE {
#[serde(rename = "actual")]
pub actual: isize,
}
impl ::qapi_spec::Event for BALLOON_CHANGE {
const NAME: &'static str = "BALLOON_CHANGE";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_memory_size_summary {
}
impl crate::QmpCommand for query_memory_size_summary { }
impl ::qapi_spec::Command for query_memory_size_summary {
const NAME: &'static str = "query-memory-size-summary";
const ALLOW_OOB: bool = false;
type Ok = MemoryInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum MemoryDeviceInfo {
#[serde(rename = "dimm")]
dimm { data: PCDIMMDeviceInfo },
#[serde(rename = "virtio-pmem")]
virtio_pmem { data: VirtioPMEMDeviceInfo },
#[serde(rename = "nvdimm")]
nvdimm { data: PCDIMMDeviceInfo },
#[serde(rename = "virtio-mem")]
virtio_mem { data: VirtioMEMDeviceInfo },
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_memory_devices {
}
impl crate::QmpCommand for query_memory_devices { }
impl ::qapi_spec::Command for query_memory_devices {
const NAME: &'static str = "query-memory-devices";
const ALLOW_OOB: bool = false;
type Ok = Vec<MemoryDeviceInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MEMORY_DEVICE_SIZE_CHANGE {
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "size")]
pub size: usize,
}
impl ::qapi_spec::Event for MEMORY_DEVICE_SIZE_CHANGE {
const NAME: &'static str = "MEMORY_DEVICE_SIZE_CHANGE";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MEM_UNPLUG_ERROR {
#[serde(rename = "msg")]
pub msg: ::std::string::String,
#[serde(rename = "device")]
pub device: ::std::string::String,
}
impl ::qapi_spec::Event for MEM_UNPLUG_ERROR {
const NAME: &'static str = "MEM_UNPLUG_ERROR";
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum CpuModelExpansionType {
#[serde(rename = "static")] static_,
#[serde(rename = "full")] full,
}
impl ::core::str::FromStr for CpuModelExpansionType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for CpuModelExpansionType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
CpuModelExpansionType::static_,
CpuModelExpansionType::full,
];
const NAMES: &'static [&'static str] = &[
"static",
"full",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum CpuModelCompareResult {
#[serde(rename = "incompatible")] incompatible,
#[serde(rename = "identical")] identical,
#[serde(rename = "superset")] superset,
#[serde(rename = "subset")] subset,
}
impl ::core::str::FromStr for CpuModelCompareResult {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for CpuModelCompareResult {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
CpuModelCompareResult::incompatible,
CpuModelCompareResult::identical,
CpuModelCompareResult::superset,
CpuModelCompareResult::subset,
];
const NAMES: &'static [&'static str] = &[
"incompatible",
"identical",
"superset",
"subset",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_cpu_model_comparison {
#[serde(rename = "modela")]
pub modela: CpuModelInfo,
#[serde(rename = "modelb")]
pub modelb: CpuModelInfo,
}
impl crate::QmpCommand for query_cpu_model_comparison { }
impl ::qapi_spec::Command for query_cpu_model_comparison {
const NAME: &'static str = "query-cpu-model-comparison";
const ALLOW_OOB: bool = false;
type Ok = CpuModelCompareInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_cpu_model_baseline {
#[serde(rename = "modela")]
pub modela: CpuModelInfo,
#[serde(rename = "modelb")]
pub modelb: CpuModelInfo,
}
impl crate::QmpCommand for query_cpu_model_baseline { }
impl ::qapi_spec::Command for query_cpu_model_baseline {
const NAME: &'static str = "query-cpu-model-baseline";
const ALLOW_OOB: bool = false;
type Ok = CpuModelBaselineInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_cpu_model_expansion {
#[serde(rename = "type")]
pub type_: CpuModelExpansionType,
#[serde(rename = "model")]
pub model: CpuModelInfo,
}
impl crate::QmpCommand for query_cpu_model_expansion { }
impl ::qapi_spec::Command for query_cpu_model_expansion {
const NAME: &'static str = "query-cpu-model-expansion";
const ALLOW_OOB: bool = false;
type Ok = CpuModelExpansionInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_cpu_definitions {
}
impl crate::QmpCommand for query_cpu_definitions { }
impl ::qapi_spec::Command for query_cpu_definitions {
const NAME: &'static str = "query-cpu-definitions";
const ALLOW_OOB: bool = false;
type Ok = Vec<CpuDefinitionInfo>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ReplayMode {
#[serde(rename = "none")] none,
#[serde(rename = "record")] record,
#[serde(rename = "play")] play,
}
impl ::core::str::FromStr for ReplayMode {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for ReplayMode {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 3;
const VARIANTS: &'static [Self] = &[
ReplayMode::none,
ReplayMode::record,
ReplayMode::play,
];
const NAMES: &'static [&'static str] = &[
"none",
"record",
"play",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_replay {
}
impl crate::QmpCommand for query_replay { }
impl ::qapi_spec::Command for query_replay {
const NAME: &'static str = "query-replay";
const ALLOW_OOB: bool = false;
type Ok = ReplayInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct replay_break {
#[serde(rename = "icount")]
pub icount: isize,
}
impl crate::QmpCommand for replay_break { }
impl ::qapi_spec::Command for replay_break {
const NAME: &'static str = "replay-break";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct replay_delete_break {
}
impl crate::QmpCommand for replay_delete_break { }
impl ::qapi_spec::Command for replay_delete_break {
const NAME: &'static str = "replay-delete-break";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct replay_seek {
#[serde(rename = "icount")]
pub icount: isize,
}
impl crate::QmpCommand for replay_seek { }
impl ::qapi_spec::Command for replay_seek {
const NAME: &'static str = "replay-seek";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct add_client {
#[serde(rename = "protocol")]
pub protocol: ::std::string::String,
#[serde(rename = "fdname")]
pub fdname: ::std::string::String,
#[serde(rename = "skipauth", default, skip_serializing_if = "Option::is_none")]
pub skipauth: Option<bool>,
#[serde(rename = "tls", default, skip_serializing_if = "Option::is_none")]
pub tls: Option<bool>,
}
impl crate::QmpCommand for add_client { }
impl ::qapi_spec::Command for add_client {
const NAME: &'static str = "add_client";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_name {
}
impl crate::QmpCommand for query_name { }
impl ::qapi_spec::Command for query_name {
const NAME: &'static str = "query-name";
const ALLOW_OOB: bool = false;
type Ok = NameInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_iothreads {
}
impl crate::QmpCommand for query_iothreads { }
impl ::qapi_spec::Command for query_iothreads {
const NAME: &'static str = "query-iothreads";
const ALLOW_OOB: bool = false;
type Ok = Vec<IOThreadInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct stop {
}
impl crate::QmpCommand for stop { }
impl ::qapi_spec::Command for stop {
const NAME: &'static str = "stop";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct cont {
}
impl crate::QmpCommand for cont { }
impl ::qapi_spec::Command for cont {
const NAME: &'static str = "cont";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct x_exit_preconfig {
}
impl crate::QmpCommand for x_exit_preconfig { }
impl ::qapi_spec::Command for x_exit_preconfig {
const NAME: &'static str = "x-exit-preconfig";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct human_monitor_command {
#[serde(rename = "command-line")]
pub command_line: ::std::string::String,
#[serde(rename = "cpu-index", default, skip_serializing_if = "Option::is_none")]
pub cpu_index: Option<isize>,
}
impl crate::QmpCommand for human_monitor_command { }
impl ::qapi_spec::Command for human_monitor_command {
const NAME: &'static str = "human-monitor-command";
const ALLOW_OOB: bool = false;
type Ok = ::std::string::String;
}
#[derive(Debug, Clone, Serialize, Deserialize)] #[deprecated]
pub struct change {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "arg", default, skip_serializing_if = "Option::is_none")]
pub arg: Option<::std::string::String>,
#[serde(rename = "target")]
pub target: ::std::string::String,
}
impl crate::QmpCommand for change { }
impl ::qapi_spec::Command for change {
const NAME: &'static str = "change";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct getfd {
#[serde(rename = "fdname")]
pub fdname: ::std::string::String,
}
impl crate::QmpCommand for getfd { }
impl ::qapi_spec::Command for getfd {
const NAME: &'static str = "getfd";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct closefd {
#[serde(rename = "fdname")]
pub fdname: ::std::string::String,
}
impl crate::QmpCommand for closefd { }
impl ::qapi_spec::Command for closefd {
const NAME: &'static str = "closefd";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct add_fd {
#[serde(rename = "fdset-id", default, skip_serializing_if = "Option::is_none")]
pub fdset_id: Option<isize>,
#[serde(rename = "opaque", default, skip_serializing_if = "Option::is_none")]
pub opaque: Option<::std::string::String>,
}
impl crate::QmpCommand for add_fd { }
impl ::qapi_spec::Command for add_fd {
const NAME: &'static str = "add-fd";
const ALLOW_OOB: bool = false;
type Ok = AddfdInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct remove_fd {
#[serde(rename = "fd", default, skip_serializing_if = "Option::is_none")]
pub fd: Option<isize>,
#[serde(rename = "fdset-id")]
pub fdset_id: isize,
}
impl crate::QmpCommand for remove_fd { }
impl ::qapi_spec::Command for remove_fd {
const NAME: &'static str = "remove-fd";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_fdsets {
}
impl crate::QmpCommand for query_fdsets { }
impl ::qapi_spec::Command for query_fdsets {
const NAME: &'static str = "query-fdsets";
const ALLOW_OOB: bool = false;
type Ok = Vec<FdsetInfo>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum CommandLineParameterType {
#[serde(rename = "string")] string,
#[serde(rename = "boolean")] boolean,
#[serde(rename = "number")] number,
#[serde(rename = "size")] size,
}
impl ::core::str::FromStr for CommandLineParameterType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for CommandLineParameterType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 4;
const VARIANTS: &'static [Self] = &[
CommandLineParameterType::string,
CommandLineParameterType::boolean,
CommandLineParameterType::number,
CommandLineParameterType::size,
];
const NAMES: &'static [&'static str] = &[
"string",
"boolean",
"number",
"size",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_command_line_options {
#[serde(rename = "option", default, skip_serializing_if = "Option::is_none")]
pub option: Option<::std::string::String>,
}
impl crate::QmpCommand for query_command_line_options { }
impl ::qapi_spec::Command for query_command_line_options {
const NAME: &'static str = "query-command-line-options";
const ALLOW_OOB: bool = false;
type Ok = Vec<CommandLineOptionInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RTC_CHANGE {
#[serde(rename = "offset")]
pub offset: isize,
}
impl ::qapi_spec::Event for RTC_CHANGE {
const NAME: &'static str = "RTC_CHANGE";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct rtc_reset_reinjection {
}
impl crate::QmpCommand for rtc_reset_reinjection { }
impl ::qapi_spec::Command for rtc_reset_reinjection {
const NAME: &'static str = "rtc-reset-reinjection";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum SevState {
#[serde(rename = "uninit")] uninit,
#[serde(rename = "launch-update")] launch_update,
#[serde(rename = "launch-secret")] launch_secret,
#[serde(rename = "running")] running,
#[serde(rename = "send-update")] send_update,
#[serde(rename = "receive-update")] receive_update,
}
impl ::core::str::FromStr for SevState {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for SevState {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 6;
const VARIANTS: &'static [Self] = &[
SevState::uninit,
SevState::launch_update,
SevState::launch_secret,
SevState::running,
SevState::send_update,
SevState::receive_update,
];
const NAMES: &'static [&'static str] = &[
"uninit",
"launch-update",
"launch-secret",
"running",
"send-update",
"receive-update",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_sev {
}
impl crate::QmpCommand for query_sev { }
impl ::qapi_spec::Command for query_sev {
const NAME: &'static str = "query-sev";
const ALLOW_OOB: bool = false;
type Ok = SevInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_sev_launch_measure {
}
impl crate::QmpCommand for query_sev_launch_measure { }
impl ::qapi_spec::Command for query_sev_launch_measure {
const NAME: &'static str = "query-sev-launch-measure";
const ALLOW_OOB: bool = false;
type Ok = SevLaunchMeasureInfo;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_sev_capabilities {
}
impl crate::QmpCommand for query_sev_capabilities { }
impl ::qapi_spec::Command for query_sev_capabilities {
const NAME: &'static str = "query-sev-capabilities";
const ALLOW_OOB: bool = false;
type Ok = SevCapability;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct dump_skeys {
#[serde(rename = "filename")]
pub filename: ::std::string::String,
}
impl crate::QmpCommand for dump_skeys { }
impl ::qapi_spec::Command for dump_skeys {
const NAME: &'static str = "dump-skeys";
const ALLOW_OOB: bool = false;
type Ok = ::qapi_spec::Empty;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_gic_capabilities {
}
impl crate::QmpCommand for query_gic_capabilities { }
impl ::qapi_spec::Command for query_gic_capabilities {
const NAME: &'static str = "query-gic-capabilities";
const ALLOW_OOB: bool = false;
type Ok = Vec<GICCapability>;
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum AudioFormat {
#[serde(rename = "u8")] u8,
#[serde(rename = "s8")] s8,
#[serde(rename = "u16")] u16,
#[serde(rename = "s16")] s16,
#[serde(rename = "u32")] u32,
#[serde(rename = "s32")] s32,
#[serde(rename = "f32")] f32,
}
impl ::core::str::FromStr for AudioFormat {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for AudioFormat {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 7;
const VARIANTS: &'static [Self] = &[
AudioFormat::u8,
AudioFormat::s8,
AudioFormat::u16,
AudioFormat::s16,
AudioFormat::u32,
AudioFormat::s32,
AudioFormat::f32,
];
const NAMES: &'static [&'static str] = &[
"u8",
"s8",
"u16",
"s16",
"u32",
"s32",
"f32",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum AudiodevDriver {
#[serde(rename = "none")] none,
#[serde(rename = "alsa")] alsa,
#[serde(rename = "coreaudio")] coreaudio,
#[serde(rename = "dsound")] dsound,
#[serde(rename = "jack")] jack,
#[serde(rename = "oss")] oss,
#[serde(rename = "pa")] pa,
#[serde(rename = "sdl")] sdl,
#[serde(rename = "spice")] spice,
#[serde(rename = "wav")] wav,
}
impl ::core::str::FromStr for AudiodevDriver {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for AudiodevDriver {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 10;
const VARIANTS: &'static [Self] = &[
AudiodevDriver::none,
AudiodevDriver::alsa,
AudiodevDriver::coreaudio,
AudiodevDriver::dsound,
AudiodevDriver::jack,
AudiodevDriver::oss,
AudiodevDriver::pa,
AudiodevDriver::sdl,
AudiodevDriver::spice,
AudiodevDriver::wav,
];
const NAMES: &'static [&'static str] = &[
"none",
"alsa",
"coreaudio",
"dsound",
"jack",
"oss",
"pa",
"sdl",
"spice",
"wav",
];
}
#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ACPISlotType {
#[serde(rename = "DIMM")] DIMM,
#[serde(rename = "CPU")] CPU,
}
impl ::core::str::FromStr for ACPISlotType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
::qapi_spec::Enum::from_name(s).ok_or(())
}
}
unsafe impl ::qapi_spec::Enum for ACPISlotType {
fn discriminant(&self) -> usize { *self as usize }
const COUNT: usize = 2;
const VARIANTS: &'static [Self] = &[
ACPISlotType::DIMM,
ACPISlotType::CPU,
];
const NAMES: &'static [&'static str] = &[
"DIMM",
"CPU",
];
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_acpi_ospm_status {
}
impl crate::QmpCommand for query_acpi_ospm_status { }
impl ::qapi_spec::Command for query_acpi_ospm_status {
const NAME: &'static str = "query-acpi-ospm-status";
const ALLOW_OOB: bool = false;
type Ok = Vec<ACPIOSTInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ACPI_DEVICE_OST {
#[serde(rename = "info")]
pub info: ACPIOSTInfo,
}
impl ::qapi_spec::Event for ACPI_DEVICE_OST {
const NAME: &'static str = "ACPI_DEVICE_OST";
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct query_pci {
}
impl crate::QmpCommand for query_pci { }
impl ::qapi_spec::Command for query_pci {
const NAME: &'static str = "query-pci";
const ALLOW_OOB: bool = false;
type Ok = Vec<PciInfo>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SocketAddress {
#[serde(rename = "inet")]
inet {
#[serde(flatten)] #[serde(rename = "inet")]
inet: InetSocketAddress,
},
#[serde(rename = "vsock")]
vsock {
#[serde(flatten)] #[serde(rename = "vsock")]
vsock: VsockSocketAddress,
},
#[serde(rename = "fd")]
fd {
#[serde(flatten)] #[serde(rename = "fd")]
fd: String,
},
#[serde(rename = "unix")]
unix {
#[serde(flatten)] #[serde(rename = "unix")]
unix: UnixSocketAddress,
},
}
impl SocketAddress {
pub fn type_(&self) -> SocketAddressType {
match *self {
SocketAddress::inet { .. } => SocketAddressType::inet,
SocketAddress::vsock { .. } => SocketAddressType::vsock,
SocketAddress::fd { .. } => SocketAddressType::fd,
SocketAddress::unix { .. } => SocketAddressType::unix,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum GuestPanicInformation {
#[serde(rename = "s390")]
s390 {
#[serde(flatten)] #[serde(rename = "s390")]
s390: GuestPanicInformationS390,
},
#[serde(rename = "hyper-v")]
hyper_v {
#[serde(flatten)] #[serde(rename = "hyper-v")]
hyper_v: GuestPanicInformationHyperV,
},
}
impl GuestPanicInformation {
pub fn type_(&self) -> GuestPanicInformationType {
match *self {
GuestPanicInformation::s390 { .. } => GuestPanicInformationType::s390,
GuestPanicInformation::hyper_v { .. } => GuestPanicInformationType::hyper_v,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "format")]
pub enum QCryptoBlockOpenOptions {
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "base")]
base: QCryptoBlockOptionsBase,
#[serde(flatten)] #[serde(rename = "luks")]
luks: QCryptoBlockOptionsLUKS,
},
#[serde(rename = "qcow")]
qcow {
#[serde(flatten)] #[serde(rename = "base")]
base: QCryptoBlockOptionsBase,
#[serde(flatten)] #[serde(rename = "qcow")]
qcow: QCryptoBlockOptionsQCow,
},
}
impl QCryptoBlockOpenOptions {
pub fn format(&self) -> QCryptoBlockFormat {
match *self {
QCryptoBlockOpenOptions::luks { .. } => QCryptoBlockFormat::luks,
QCryptoBlockOpenOptions::qcow { .. } => QCryptoBlockFormat::qcow,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "format")]
pub enum QCryptoBlockCreateOptions {
#[serde(rename = "qcow")]
qcow {
#[serde(flatten)] #[serde(rename = "base")]
base: QCryptoBlockOptionsBase,
#[serde(flatten)] #[serde(rename = "qcow")]
qcow: QCryptoBlockOptionsQCow,
},
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "base")]
base: QCryptoBlockOptionsBase,
#[serde(flatten)] #[serde(rename = "luks")]
luks: QCryptoBlockCreateOptionsLUKS,
},
}
impl QCryptoBlockCreateOptions {
pub fn format(&self) -> QCryptoBlockFormat {
match *self {
QCryptoBlockCreateOptions::qcow { .. } => QCryptoBlockFormat::qcow,
QCryptoBlockCreateOptions::luks { .. } => QCryptoBlockFormat::luks,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "format")]
pub enum QCryptoBlockInfo {
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "base")]
base: QCryptoBlockInfoBase,
#[serde(flatten)] #[serde(rename = "luks")]
luks: QCryptoBlockInfoLUKS,
},
}
impl QCryptoBlockInfo {
pub fn format(&self) -> QCryptoBlockFormat {
match *self {
QCryptoBlockInfo::luks { .. } => QCryptoBlockFormat::luks,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "format")]
pub enum QCryptoBlockAmendOptions {
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "base")]
base: QCryptoBlockOptionsBase,
#[serde(flatten)] #[serde(rename = "luks")]
luks: QCryptoBlockAmendOptionsLUKS,
},
}
impl QCryptoBlockAmendOptions {
pub fn format(&self) -> QCryptoBlockFormat {
match *self {
QCryptoBlockAmendOptions::luks { .. } => QCryptoBlockFormat::luks,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "format")]
pub enum ImageInfoSpecificQCow2Encryption {
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "base")]
base: ImageInfoSpecificQCow2EncryptionBase,
#[serde(flatten)] #[serde(rename = "luks")]
luks: QCryptoBlockInfoLUKS,
},
}
impl ImageInfoSpecificQCow2Encryption {
pub fn format(&self) -> BlockdevQcow2EncryptionFormat {
match *self {
ImageInfoSpecificQCow2Encryption::luks { .. } => BlockdevQcow2EncryptionFormat::luks,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "driver")]
pub enum BlockStatsSpecific {
#[serde(rename = "host_device")]
host_device {
#[serde(flatten)] #[serde(rename = "host_device")]
host_device: BlockStatsSpecificFile,
},
#[serde(rename = "nvme")]
nvme {
#[serde(flatten)] #[serde(rename = "nvme")]
nvme: BlockStatsSpecificNvme,
},
#[serde(rename = "file")]
file {
#[serde(flatten)] #[serde(rename = "file")]
file: BlockStatsSpecificFile,
},
}
impl BlockStatsSpecific {
pub fn driver(&self) -> BlockdevDriver {
match *self {
BlockStatsSpecific::host_device { .. } => BlockdevDriver::host_device,
BlockStatsSpecific::nvme { .. } => BlockdevDriver::nvme,
BlockStatsSpecific::file { .. } => BlockdevDriver::file,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "format")]
pub enum BlockdevQcowEncryption {
#[serde(rename = "aes")]
aes {
#[serde(flatten)] #[serde(rename = "aes")]
aes: QCryptoBlockOptionsQCow,
},
}
impl BlockdevQcowEncryption {
pub fn format(&self) -> BlockdevQcowEncryptionFormat {
match *self {
BlockdevQcowEncryption::aes { .. } => BlockdevQcowEncryptionFormat::aes,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "format")]
pub enum BlockdevQcow2Encryption {
#[serde(rename = "aes")]
aes {
#[serde(flatten)] #[serde(rename = "aes")]
aes: QCryptoBlockOptionsQCow,
},
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "luks")]
luks: QCryptoBlockOptionsLUKS,
},
}
impl BlockdevQcow2Encryption {
pub fn format(&self) -> BlockdevQcow2EncryptionFormat {
match *self {
BlockdevQcow2Encryption::aes { .. } => BlockdevQcow2EncryptionFormat::aes,
BlockdevQcow2Encryption::luks { .. } => BlockdevQcow2EncryptionFormat::luks,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "mode")]
pub enum SshHostKeyCheck {
#[serde(rename = "hash")]
hash {
#[serde(flatten)] #[serde(rename = "hash")]
hash: SshHostKeyHash,
},
}
impl SshHostKeyCheck {
pub fn mode(&self) -> SshHostKeyCheckMode {
match *self {
SshHostKeyCheck::hash { .. } => SshHostKeyCheckMode::hash,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "driver")]
pub enum BlockdevOptions {
#[serde(rename = "ftp")]
ftp {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "ftp")]
ftp: BlockdevOptionsCurlFtp,
},
#[serde(rename = "http")]
http {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "http")]
http: BlockdevOptionsCurlHttp,
},
#[serde(rename = "blklogwrites")]
blklogwrites {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "blklogwrites")]
blklogwrites: BlockdevOptionsBlklogwrites,
},
#[serde(rename = "ssh")]
ssh {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "ssh")]
ssh: BlockdevOptionsSsh,
},
#[serde(rename = "luks")]
luks {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "luks")]
luks: BlockdevOptionsLUKS,
},
#[serde(rename = "vpc")]
vpc {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "vpc")]
vpc: BlockdevOptionsGenericFormat,
},
#[serde(rename = "qed")]
qed {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "qed")]
qed: BlockdevOptionsGenericCOWFormat,
},
#[serde(rename = "copy-on-read")]
copy_on_read {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "copy-on-read")]
copy_on_read: BlockdevOptionsGenericFormat,
},
#[serde(rename = "nbd")]
nbd {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "nbd")]
nbd: BlockdevOptionsNbd,
},
#[serde(rename = "vvfat")]
vvfat {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "vvfat")]
vvfat: BlockdevOptionsVVFAT,
},
#[serde(rename = "replication")]
replication {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "replication")]
replication: BlockdevOptionsReplication,
},
#[serde(rename = "host_device")]
host_device {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "host_device")]
host_device: BlockdevOptionsFile,
},
#[serde(rename = "nvme")]
nvme {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "nvme")]
nvme: BlockdevOptionsNVMe,
},
#[serde(rename = "rbd")]
rbd {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "rbd")]
rbd: BlockdevOptionsRbd,
},
#[serde(rename = "bochs")]
bochs {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "bochs")]
bochs: BlockdevOptionsGenericFormat,
},
#[serde(rename = "ftps")]
ftps {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "ftps")]
ftps: BlockdevOptionsCurlFtps,
},
#[serde(rename = "blkdebug")]
blkdebug {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "blkdebug")]
blkdebug: BlockdevOptionsBlkdebug,
},
#[serde(rename = "parallels")]
parallels {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "parallels")]
parallels: BlockdevOptionsGenericFormat,
},
#[serde(rename = "blkreplay")]
blkreplay {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "blkreplay")]
blkreplay: BlockdevOptionsBlkreplay,
},
#[serde(rename = "blkverify")]
blkverify {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "blkverify")]
blkverify: BlockdevOptionsBlkverify,
},
#[serde(rename = "https")]
https {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "https")]
https: BlockdevOptionsCurlHttps,
},
#[serde(rename = "qcow")]
qcow {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "qcow")]
qcow: BlockdevOptionsQcow,
},
#[serde(rename = "null-aio")]
null_aio {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "null-aio")]
null_aio: BlockdevOptionsNull,
},
#[serde(rename = "iscsi")]
iscsi {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "iscsi")]
iscsi: BlockdevOptionsIscsi,
},
#[serde(rename = "sheepdog")]
sheepdog {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "sheepdog")]
sheepdog: BlockdevOptionsSheepdog,
},
#[serde(rename = "throttle")]
throttle {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "throttle")]
throttle: BlockdevOptionsThrottle,
},
#[serde(rename = "gluster")]
gluster {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "gluster")]
gluster: BlockdevOptionsGluster,
},
#[serde(rename = "file")]
file {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "file")]
file: BlockdevOptionsFile,
},
#[serde(rename = "vdi")]
vdi {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "vdi")]
vdi: BlockdevOptionsGenericFormat,
},
#[serde(rename = "host_cdrom")]
host_cdrom {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "host_cdrom")]
host_cdrom: BlockdevOptionsFile,
},
#[serde(rename = "compress")]
compress {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "compress")]
compress: BlockdevOptionsGenericFormat,
},
#[serde(rename = "dmg")]
dmg {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "dmg")]
dmg: BlockdevOptionsGenericFormat,
},
#[serde(rename = "quorum")]
quorum {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "quorum")]
quorum: BlockdevOptionsQuorum,
},
#[serde(rename = "vhdx")]
vhdx {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "vhdx")]
vhdx: BlockdevOptionsGenericFormat,
},
#[serde(rename = "null-co")]
null_co {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "null-co")]
null_co: BlockdevOptionsNull,
},
#[serde(rename = "nfs")]
nfs {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "nfs")]
nfs: BlockdevOptionsNfs,
},
#[serde(rename = "qcow2")]
qcow2 {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "qcow2")]
qcow2: BlockdevOptionsQcow2,
},
#[serde(rename = "vmdk")]
vmdk {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "vmdk")]
vmdk: BlockdevOptionsGenericCOWFormat,
},
#[serde(rename = "raw")]
raw {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "raw")]
raw: BlockdevOptionsRaw,
},
#[serde(rename = "cloop")]
cloop {
#[serde(rename = "auto-read-only", default, skip_serializing_if = "Option::is_none")]
auto_read_only: Option<bool>,
#[serde(rename = "detect-zeroes", default, skip_serializing_if = "Option::is_none")]
detect_zeroes: Option<BlockdevDetectZeroesOptions>,
#[serde(rename = "force-share", default, skip_serializing_if = "Option::is_none")]
force_share: Option<bool>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
node_name: Option<::std::string::String>,
#[serde(rename = "read-only", default, skip_serializing_if = "Option::is_none")]
read_only: Option<bool>,
#[serde(rename = "cache", default, skip_serializing_if = "Option::is_none")]
cache: Option<BlockdevCacheOptions>,
#[serde(rename = "discard", default, skip_serializing_if = "Option::is_none")]
discard: Option<BlockdevDiscardOptions>,
#[serde(flatten)] #[serde(rename = "cloop")]
cloop: BlockdevOptionsGenericFormat,
},
}
impl BlockdevOptions {
pub fn driver(&self) -> BlockdevDriver {
match *self {
BlockdevOptions::ftp { .. } => BlockdevDriver::ftp,
BlockdevOptions::http { .. } => BlockdevDriver::http,
BlockdevOptions::blklogwrites { .. } => BlockdevDriver::blklogwrites,
BlockdevOptions::ssh { .. } => BlockdevDriver::ssh,
BlockdevOptions::luks { .. } => BlockdevDriver::luks,
BlockdevOptions::vpc { .. } => BlockdevDriver::vpc,
BlockdevOptions::qed { .. } => BlockdevDriver::qed,
BlockdevOptions::copy_on_read { .. } => BlockdevDriver::copy_on_read,
BlockdevOptions::nbd { .. } => BlockdevDriver::nbd,
BlockdevOptions::vvfat { .. } => BlockdevDriver::vvfat,
BlockdevOptions::replication { .. } => BlockdevDriver::replication,
BlockdevOptions::host_device { .. } => BlockdevDriver::host_device,
BlockdevOptions::nvme { .. } => BlockdevDriver::nvme,
BlockdevOptions::rbd { .. } => BlockdevDriver::rbd,
BlockdevOptions::bochs { .. } => BlockdevDriver::bochs,
BlockdevOptions::ftps { .. } => BlockdevDriver::ftps,
BlockdevOptions::blkdebug { .. } => BlockdevDriver::blkdebug,
BlockdevOptions::parallels { .. } => BlockdevDriver::parallels,
BlockdevOptions::blkreplay { .. } => BlockdevDriver::blkreplay,
BlockdevOptions::blkverify { .. } => BlockdevDriver::blkverify,
BlockdevOptions::https { .. } => BlockdevDriver::https,
BlockdevOptions::qcow { .. } => BlockdevDriver::qcow,
BlockdevOptions::null_aio { .. } => BlockdevDriver::null_aio,
BlockdevOptions::iscsi { .. } => BlockdevDriver::iscsi,
BlockdevOptions::sheepdog { .. } => BlockdevDriver::sheepdog,
BlockdevOptions::throttle { .. } => BlockdevDriver::throttle,
BlockdevOptions::gluster { .. } => BlockdevDriver::gluster,
BlockdevOptions::file { .. } => BlockdevDriver::file,
BlockdevOptions::vdi { .. } => BlockdevDriver::vdi,
BlockdevOptions::host_cdrom { .. } => BlockdevDriver::host_cdrom,
BlockdevOptions::compress { .. } => BlockdevDriver::compress,
BlockdevOptions::dmg { .. } => BlockdevDriver::dmg,
BlockdevOptions::quorum { .. } => BlockdevDriver::quorum,
BlockdevOptions::vhdx { .. } => BlockdevDriver::vhdx,
BlockdevOptions::null_co { .. } => BlockdevDriver::null_co,
BlockdevOptions::nfs { .. } => BlockdevDriver::nfs,
BlockdevOptions::qcow2 { .. } => BlockdevDriver::qcow2,
BlockdevOptions::vmdk { .. } => BlockdevDriver::vmdk,
BlockdevOptions::raw { .. } => BlockdevDriver::raw,
BlockdevOptions::cloop { .. } => BlockdevDriver::cloop,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SheepdogRedundancy {
#[serde(rename = "full")]
full {
#[serde(flatten)] #[serde(rename = "full")]
full: SheepdogRedundancyFull,
},
#[serde(rename = "erasure-coded")]
erasure_coded {
#[serde(flatten)] #[serde(rename = "erasure-coded")]
erasure_coded: SheepdogRedundancyErasureCoded,
},
}
impl SheepdogRedundancy {
pub fn type_(&self) -> SheepdogRedundancyType {
match *self {
SheepdogRedundancy::full { .. } => SheepdogRedundancyType::full,
SheepdogRedundancy::erasure_coded { .. } => SheepdogRedundancyType::erasure_coded,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "driver")]
pub enum BlockdevCreateOptions {
#[serde(rename = "vmdk")]
vmdk {
#[serde(flatten)] #[serde(rename = "vmdk")]
vmdk: BlockdevCreateOptionsVmdk,
},
#[serde(rename = "parallels")]
parallels {
#[serde(flatten)] #[serde(rename = "parallels")]
parallels: BlockdevCreateOptionsParallels,
},
#[serde(rename = "vpc")]
vpc {
#[serde(flatten)] #[serde(rename = "vpc")]
vpc: BlockdevCreateOptionsVpc,
},
#[serde(rename = "gluster")]
gluster {
#[serde(flatten)] #[serde(rename = "gluster")]
gluster: BlockdevCreateOptionsGluster,
},
#[serde(rename = "file")]
file {
#[serde(flatten)] #[serde(rename = "file")]
file: BlockdevCreateOptionsFile,
},
#[serde(rename = "vhdx")]
vhdx {
#[serde(flatten)] #[serde(rename = "vhdx")]
vhdx: BlockdevCreateOptionsVhdx,
},
#[serde(rename = "vdi")]
vdi {
#[serde(flatten)] #[serde(rename = "vdi")]
vdi: BlockdevCreateOptionsVdi,
},
#[serde(rename = "nfs")]
nfs {
#[serde(flatten)] #[serde(rename = "nfs")]
nfs: BlockdevCreateOptionsNfs,
},
#[serde(rename = "qcow2")]
qcow2 {
#[serde(flatten)] #[serde(rename = "qcow2")]
qcow2: BlockdevCreateOptionsQcow2,
},
#[serde(rename = "ssh")]
ssh {
#[serde(flatten)] #[serde(rename = "ssh")]
ssh: BlockdevCreateOptionsSsh,
},
#[serde(rename = "rbd")]
rbd {
#[serde(flatten)] #[serde(rename = "rbd")]
rbd: BlockdevCreateOptionsRbd,
},
#[serde(rename = "qcow")]
qcow {
#[serde(flatten)] #[serde(rename = "qcow")]
qcow: BlockdevCreateOptionsQcow,
},
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "luks")]
luks: BlockdevCreateOptionsLUKS,
},
#[serde(rename = "sheepdog")]
sheepdog {
#[serde(flatten)] #[serde(rename = "sheepdog")]
sheepdog: BlockdevCreateOptionsSheepdog,
},
#[serde(rename = "qed")]
qed {
#[serde(flatten)] #[serde(rename = "qed")]
qed: BlockdevCreateOptionsQed,
},
}
impl BlockdevCreateOptions {
pub fn driver(&self) -> BlockdevDriver {
match *self {
BlockdevCreateOptions::vmdk { .. } => BlockdevDriver::vmdk,
BlockdevCreateOptions::parallels { .. } => BlockdevDriver::parallels,
BlockdevCreateOptions::vpc { .. } => BlockdevDriver::vpc,
BlockdevCreateOptions::gluster { .. } => BlockdevDriver::gluster,
BlockdevCreateOptions::file { .. } => BlockdevDriver::file,
BlockdevCreateOptions::vhdx { .. } => BlockdevDriver::vhdx,
BlockdevCreateOptions::vdi { .. } => BlockdevDriver::vdi,
BlockdevCreateOptions::nfs { .. } => BlockdevDriver::nfs,
BlockdevCreateOptions::qcow2 { .. } => BlockdevDriver::qcow2,
BlockdevCreateOptions::ssh { .. } => BlockdevDriver::ssh,
BlockdevCreateOptions::rbd { .. } => BlockdevDriver::rbd,
BlockdevCreateOptions::qcow { .. } => BlockdevDriver::qcow,
BlockdevCreateOptions::luks { .. } => BlockdevDriver::luks,
BlockdevCreateOptions::sheepdog { .. } => BlockdevDriver::sheepdog,
BlockdevCreateOptions::qed { .. } => BlockdevDriver::qed,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "driver")]
pub enum BlockdevAmendOptions {
#[serde(rename = "luks")]
luks {
#[serde(flatten)] #[serde(rename = "luks")]
luks: BlockdevAmendOptionsLUKS,
},
#[serde(rename = "qcow2")]
qcow2 {
#[serde(flatten)] #[serde(rename = "qcow2")]
qcow2: BlockdevAmendOptionsQcow2,
},
}
impl BlockdevAmendOptions {
pub fn driver(&self) -> BlockdevDriver {
match *self {
BlockdevAmendOptions::luks { .. } => BlockdevDriver::luks,
BlockdevAmendOptions::qcow2 { .. } => BlockdevDriver::qcow2,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum BlockExportOptions {
#[serde(rename = "nbd")]
nbd {
#[serde(rename = "iothread", default, skip_serializing_if = "Option::is_none")]
iothread: Option<::std::string::String>,
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "node-name")]
node_name: ::std::string::String,
#[serde(rename = "writethrough", default, skip_serializing_if = "Option::is_none")]
writethrough: Option<bool>,
#[serde(rename = "fixed-iothread", default, skip_serializing_if = "Option::is_none")]
fixed_iothread: Option<bool>,
#[serde(rename = "writable", default, skip_serializing_if = "Option::is_none")]
writable: Option<bool>,
#[serde(flatten)] #[serde(rename = "nbd")]
nbd: BlockExportOptionsNbd,
},
#[serde(rename = "vhost-user-blk")]
vhost_user_blk {
#[serde(rename = "iothread", default, skip_serializing_if = "Option::is_none")]
iothread: Option<::std::string::String>,
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "node-name")]
node_name: ::std::string::String,
#[serde(rename = "writethrough", default, skip_serializing_if = "Option::is_none")]
writethrough: Option<bool>,
#[serde(rename = "fixed-iothread", default, skip_serializing_if = "Option::is_none")]
fixed_iothread: Option<bool>,
#[serde(rename = "writable", default, skip_serializing_if = "Option::is_none")]
writable: Option<bool>,
#[serde(flatten)] #[serde(rename = "vhost-user-blk")]
vhost_user_blk: BlockExportOptionsVhostUserBlk,
},
}
impl BlockExportOptions {
pub fn type_(&self) -> BlockExportType {
match *self {
BlockExportOptions::nbd { .. } => BlockExportType::nbd,
BlockExportOptions::vhost_user_blk { .. } => BlockExportType::vhost_user_blk,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum Netdev {
#[serde(rename = "vhost-vdpa")]
vhost_vdpa {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "vhost-vdpa")]
vhost_vdpa: NetdevVhostVDPAOptions,
},
#[serde(rename = "netmap")]
netmap {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "netmap")]
netmap: NetdevNetmapOptions,
},
#[serde(rename = "nic")]
nic {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "nic")]
nic: NetLegacyNicOptions,
},
#[serde(rename = "l2tpv3")]
l2tpv3 {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "l2tpv3")]
l2tpv3: NetdevL2TPv3Options,
},
#[serde(rename = "user")]
user {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "user")]
user: NetdevUserOptions,
},
#[serde(rename = "tap")]
tap {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "tap")]
tap: NetdevTapOptions,
},
#[serde(rename = "vde")]
vde {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "vde")]
vde: NetdevVdeOptions,
},
#[serde(rename = "socket")]
socket {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "socket")]
socket: NetdevSocketOptions,
},
#[serde(rename = "hubport")]
hubport {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "hubport")]
hubport: NetdevHubPortOptions,
},
#[serde(rename = "vhost-user")]
vhost_user {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "vhost-user")]
vhost_user: NetdevVhostUserOptions,
},
#[serde(rename = "bridge")]
bridge {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(flatten)] #[serde(rename = "bridge")]
bridge: NetdevBridgeOptions,
},
}
impl Netdev {
pub fn type_(&self) -> NetClientDriver {
match *self {
Netdev::vhost_vdpa { .. } => NetClientDriver::vhost_vdpa,
Netdev::netmap { .. } => NetClientDriver::netmap,
Netdev::nic { .. } => NetClientDriver::nic,
Netdev::l2tpv3 { .. } => NetClientDriver::l2tpv3,
Netdev::user { .. } => NetClientDriver::user,
Netdev::tap { .. } => NetClientDriver::tap,
Netdev::vde { .. } => NetClientDriver::vde,
Netdev::socket { .. } => NetClientDriver::socket,
Netdev::hubport { .. } => NetClientDriver::hubport,
Netdev::vhost_user { .. } => NetClientDriver::vhost_user,
Netdev::bridge { .. } => NetClientDriver::bridge,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum DisplayOptions {
#[serde(rename = "curses")]
curses {
#[serde(rename = "full-screen", default, skip_serializing_if = "Option::is_none")]
full_screen: Option<bool>,
#[serde(rename = "window-close", default, skip_serializing_if = "Option::is_none")]
window_close: Option<bool>,
#[serde(rename = "show-cursor", default, skip_serializing_if = "Option::is_none")]
show_cursor: Option<bool>,
#[serde(rename = "gl", default, skip_serializing_if = "Option::is_none")]
gl: Option<DisplayGLMode>,
#[serde(flatten)] #[serde(rename = "curses")]
curses: DisplayCurses,
},
#[serde(rename = "gtk")]
gtk {
#[serde(rename = "full-screen", default, skip_serializing_if = "Option::is_none")]
full_screen: Option<bool>,
#[serde(rename = "window-close", default, skip_serializing_if = "Option::is_none")]
window_close: Option<bool>,
#[serde(rename = "show-cursor", default, skip_serializing_if = "Option::is_none")]
show_cursor: Option<bool>,
#[serde(rename = "gl", default, skip_serializing_if = "Option::is_none")]
gl: Option<DisplayGLMode>,
#[serde(flatten)] #[serde(rename = "gtk")]
gtk: DisplayGTK,
},
#[serde(rename = "egl-headless")]
egl_headless {
#[serde(rename = "full-screen", default, skip_serializing_if = "Option::is_none")]
full_screen: Option<bool>,
#[serde(rename = "window-close", default, skip_serializing_if = "Option::is_none")]
window_close: Option<bool>,
#[serde(rename = "show-cursor", default, skip_serializing_if = "Option::is_none")]
show_cursor: Option<bool>,
#[serde(rename = "gl", default, skip_serializing_if = "Option::is_none")]
gl: Option<DisplayGLMode>,
#[serde(flatten)] #[serde(rename = "egl-headless")]
egl_headless: DisplayEGLHeadless,
},
}
impl DisplayOptions {
pub fn type_(&self) -> DisplayType {
match *self {
DisplayOptions::curses { .. } => DisplayType::curses,
DisplayOptions::gtk { .. } => DisplayType::gtk,
DisplayOptions::egl_headless { .. } => DisplayType::egl_headless,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "meta-type")]
pub enum SchemaInfo {
#[serde(rename = "object")]
object {
#[serde(rename = "name")]
name: ::std::string::String,
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
features: Option<Vec<::std::string::String>>,
#[serde(flatten)] #[serde(rename = "object")]
object: SchemaInfoObject,
},
#[serde(rename = "enum")]
enum_ {
#[serde(rename = "name")]
name: ::std::string::String,
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
features: Option<Vec<::std::string::String>>,
#[serde(flatten)] #[serde(rename = "enum")]
enum_: SchemaInfoEnum,
},
#[serde(rename = "alternate")]
alternate {
#[serde(rename = "name")]
name: ::std::string::String,
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
features: Option<Vec<::std::string::String>>,
#[serde(flatten)] #[serde(rename = "alternate")]
alternate: SchemaInfoAlternate,
},
#[serde(rename = "array")]
array {
#[serde(rename = "name")]
name: ::std::string::String,
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
features: Option<Vec<::std::string::String>>,
#[serde(flatten)] #[serde(rename = "array")]
array: SchemaInfoArray,
},
#[serde(rename = "event")]
event {
#[serde(rename = "name")]
name: ::std::string::String,
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
features: Option<Vec<::std::string::String>>,
#[serde(flatten)] #[serde(rename = "event")]
event: SchemaInfoEvent,
},
#[serde(rename = "command")]
command {
#[serde(rename = "name")]
name: ::std::string::String,
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
features: Option<Vec<::std::string::String>>,
#[serde(flatten)] #[serde(rename = "command")]
command: SchemaInfoCommand,
},
#[serde(rename = "builtin")]
builtin {
#[serde(rename = "name")]
name: ::std::string::String,
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
features: Option<Vec<::std::string::String>>,
#[serde(flatten)] #[serde(rename = "builtin")]
builtin: SchemaInfoBuiltin,
},
}
impl SchemaInfo {
pub fn meta_type(&self) -> SchemaMetaType {
match *self {
SchemaInfo::object { .. } => SchemaMetaType::object,
SchemaInfo::enum_ { .. } => SchemaMetaType::enum_,
SchemaInfo::alternate { .. } => SchemaMetaType::alternate,
SchemaInfo::array { .. } => SchemaMetaType::array,
SchemaInfo::event { .. } => SchemaMetaType::event,
SchemaInfo::command { .. } => SchemaMetaType::command,
SchemaInfo::builtin { .. } => SchemaMetaType::builtin,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "arch")]
pub enum CpuInfo {
#[serde(rename = "mips")]
mips {
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(rename = "qom_path")]
qom_path: ::std::string::String,
#[serde(rename = "CPU")]
CPU: isize,
#[serde(rename = "halted")]
halted: bool,
#[serde(rename = "current")]
current: bool,
#[serde(rename = "thread_id")]
thread_id: isize,
#[serde(flatten)] #[serde(rename = "mips")]
mips: CpuInfoMIPS,
},
#[serde(rename = "riscv")]
riscv {
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(rename = "qom_path")]
qom_path: ::std::string::String,
#[serde(rename = "CPU")]
CPU: isize,
#[serde(rename = "halted")]
halted: bool,
#[serde(rename = "current")]
current: bool,
#[serde(rename = "thread_id")]
thread_id: isize,
#[serde(flatten)] #[serde(rename = "riscv")]
riscv: CpuInfoRISCV,
},
#[serde(rename = "x86")]
x86 {
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(rename = "qom_path")]
qom_path: ::std::string::String,
#[serde(rename = "CPU")]
CPU: isize,
#[serde(rename = "halted")]
halted: bool,
#[serde(rename = "current")]
current: bool,
#[serde(rename = "thread_id")]
thread_id: isize,
#[serde(flatten)] #[serde(rename = "x86")]
x86: CpuInfoX86,
},
#[serde(rename = "tricore")]
tricore {
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(rename = "qom_path")]
qom_path: ::std::string::String,
#[serde(rename = "CPU")]
CPU: isize,
#[serde(rename = "halted")]
halted: bool,
#[serde(rename = "current")]
current: bool,
#[serde(rename = "thread_id")]
thread_id: isize,
#[serde(flatten)] #[serde(rename = "tricore")]
tricore: CpuInfoTricore,
},
#[serde(rename = "s390")]
s390 {
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(rename = "qom_path")]
qom_path: ::std::string::String,
#[serde(rename = "CPU")]
CPU: isize,
#[serde(rename = "halted")]
halted: bool,
#[serde(rename = "current")]
current: bool,
#[serde(rename = "thread_id")]
thread_id: isize,
#[serde(flatten)] #[serde(rename = "s390")]
s390: CpuInfoS390,
},
#[serde(rename = "sparc")]
sparc {
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(rename = "qom_path")]
qom_path: ::std::string::String,
#[serde(rename = "CPU")]
CPU: isize,
#[serde(rename = "halted")]
halted: bool,
#[serde(rename = "current")]
current: bool,
#[serde(rename = "thread_id")]
thread_id: isize,
#[serde(flatten)] #[serde(rename = "sparc")]
sparc: CpuInfoSPARC,
},
#[serde(rename = "ppc")]
ppc {
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(rename = "qom_path")]
qom_path: ::std::string::String,
#[serde(rename = "CPU")]
CPU: isize,
#[serde(rename = "halted")]
halted: bool,
#[serde(rename = "current")]
current: bool,
#[serde(rename = "thread_id")]
thread_id: isize,
#[serde(flatten)] #[serde(rename = "ppc")]
ppc: CpuInfoPPC,
},
}
impl CpuInfo {
pub fn arch(&self) -> CpuInfoArch {
match *self {
CpuInfo::mips { .. } => CpuInfoArch::mips,
CpuInfo::riscv { .. } => CpuInfoArch::riscv,
CpuInfo::x86 { .. } => CpuInfoArch::x86,
CpuInfo::tricore { .. } => CpuInfoArch::tricore,
CpuInfo::s390 { .. } => CpuInfoArch::s390,
CpuInfo::sparc { .. } => CpuInfoArch::sparc,
CpuInfo::ppc { .. } => CpuInfoArch::ppc,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "target")]
pub enum CpuInfoFast {
#[serde(rename = "s390x")]
s390x {
#[serde(rename = "cpu-index")]
cpu_index: isize,
#[serde(rename = "qom-path")]
qom_path: ::std::string::String,
#[serde(rename = "thread-id")]
thread_id: isize,
#[serde(rename = "arch")] #[deprecated]
arch: CpuInfoArch,
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
props: Option<CpuInstanceProperties>,
#[serde(flatten)] #[serde(rename = "s390x")]
s390x: CpuInfoS390,
},
}
impl CpuInfoFast {
pub fn target(&self) -> SysEmuTarget {
match *self {
CpuInfoFast::s390x { .. } => SysEmuTarget::s390x,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum NumaOptions {
#[serde(rename = "cpu")]
cpu {
#[serde(flatten)] #[serde(rename = "cpu")]
cpu: NumaCpuOptions,
},
#[serde(rename = "node")]
node {
#[serde(flatten)] #[serde(rename = "node")]
node: NumaNodeOptions,
},
#[serde(rename = "dist")]
dist {
#[serde(flatten)] #[serde(rename = "dist")]
dist: NumaDistOptions,
},
#[serde(rename = "hmat-lb")]
hmat_lb {
#[serde(flatten)] #[serde(rename = "hmat-lb")]
hmat_lb: NumaHmatLBOptions,
},
#[serde(rename = "hmat-cache")]
hmat_cache {
#[serde(flatten)] #[serde(rename = "hmat-cache")]
hmat_cache: NumaHmatCacheOptions,
},
}
impl NumaOptions {
pub fn type_(&self) -> NumaOptionsType {
match *self {
NumaOptions::cpu { .. } => NumaOptionsType::cpu,
NumaOptions::node { .. } => NumaOptionsType::node,
NumaOptions::dist { .. } => NumaOptionsType::dist,
NumaOptions::hmat_lb { .. } => NumaOptionsType::hmat_lb,
NumaOptions::hmat_cache { .. } => NumaOptionsType::hmat_cache,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "driver")]
pub enum Audiodev {
#[serde(rename = "coreaudio")]
coreaudio {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "coreaudio")]
coreaudio: AudiodevCoreaudioOptions,
},
#[serde(rename = "alsa")]
alsa {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "alsa")]
alsa: AudiodevAlsaOptions,
},
#[serde(rename = "dsound")]
dsound {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "dsound")]
dsound: AudiodevDsoundOptions,
},
#[serde(rename = "jack")]
jack {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "jack")]
jack: AudiodevJackOptions,
},
#[serde(rename = "oss")]
oss {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "oss")]
oss: AudiodevOssOptions,
},
#[serde(rename = "pa")]
pa {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "pa")]
pa: AudiodevPaOptions,
},
#[serde(rename = "sdl")]
sdl {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "sdl")]
sdl: AudiodevGenericOptions,
},
#[serde(rename = "none")]
none {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "none")]
none: AudiodevGenericOptions,
},
#[serde(rename = "spice")]
spice {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "spice")]
spice: AudiodevGenericOptions,
},
#[serde(rename = "wav")]
wav {
#[serde(rename = "id")]
id: ::std::string::String,
#[serde(rename = "timer-period", default, skip_serializing_if = "Option::is_none")]
timer_period: Option<u32>,
#[serde(flatten)] #[serde(rename = "wav")]
wav: AudiodevWavOptions,
},
}
impl Audiodev {
pub fn driver(&self) -> AudiodevDriver {
match *self {
Audiodev::coreaudio { .. } => AudiodevDriver::coreaudio,
Audiodev::alsa { .. } => AudiodevDriver::alsa,
Audiodev::dsound { .. } => AudiodevDriver::dsound,
Audiodev::jack { .. } => AudiodevDriver::jack,
Audiodev::oss { .. } => AudiodevDriver::oss,
Audiodev::pa { .. } => AudiodevDriver::pa,
Audiodev::sdl { .. } => AudiodevDriver::sdl,
Audiodev::none { .. } => AudiodevDriver::none,
Audiodev::spice { .. } => AudiodevDriver::spice,
Audiodev::wav { .. } => AudiodevDriver::wav,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct XBZRLECacheStats {
#[serde(rename = "pages")]
pub pages: isize,
#[serde(rename = "cache-size")]
pub cache_size: isize,
#[serde(rename = "cache-miss-rate")]
pub cache_miss_rate: f64,
#[serde(rename = "cache-miss")]
pub cache_miss: isize,
#[serde(rename = "encoding-rate")]
pub encoding_rate: f64,
#[serde(rename = "overflow")]
pub overflow: isize,
#[serde(rename = "bytes")]
pub bytes: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsGluster {
#[serde(rename = "location")]
pub location: BlockdevOptionsGluster,
#[serde(rename = "preallocation", default, skip_serializing_if = "Option::is_none")]
pub preallocation: Option<PreallocMode>,
#[serde(rename = "size")]
pub size: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KvmInfo {
#[serde(rename = "enabled")]
pub enabled: bool,
#[serde(rename = "present")]
pub present: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevReturn {
#[serde(rename = "pty", default, skip_serializing_if = "Option::is_none")]
pub pty: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsLUKS {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: QCryptoBlockCreateOptionsLUKS,
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "preallocation", default, skip_serializing_if = "Option::is_none")]
pub preallocation: Option<PreallocMode>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevUserOptions {
#[serde(rename = "dhcpstart", default, skip_serializing_if = "Option::is_none")]
pub dhcpstart: Option<::std::string::String>,
#[serde(rename = "tftp", default, skip_serializing_if = "Option::is_none")]
pub tftp: Option<::std::string::String>,
#[serde(rename = "dns", default, skip_serializing_if = "Option::is_none")]
pub dns: Option<::std::string::String>,
#[serde(rename = "dnssearch", default, skip_serializing_if = "Option::is_none")]
pub dnssearch: Option<Vec<String>>,
#[serde(rename = "host", default, skip_serializing_if = "Option::is_none")]
pub host: Option<::std::string::String>,
#[serde(rename = "restrict", default, skip_serializing_if = "Option::is_none")]
pub restrict: Option<bool>,
#[serde(rename = "bootfile", default, skip_serializing_if = "Option::is_none")]
pub bootfile: Option<::std::string::String>,
#[serde(rename = "domainname", default, skip_serializing_if = "Option::is_none")]
pub domainname: Option<::std::string::String>,
#[serde(rename = "ipv6", default, skip_serializing_if = "Option::is_none")]
pub ipv6: Option<bool>,
#[serde(rename = "ipv6-prefix", default, skip_serializing_if = "Option::is_none")]
pub ipv6_prefix: Option<::std::string::String>,
#[serde(rename = "ipv6-prefixlen", default, skip_serializing_if = "Option::is_none")]
pub ipv6_prefixlen: Option<isize>,
#[serde(rename = "ipv6-host", default, skip_serializing_if = "Option::is_none")]
pub ipv6_host: Option<::std::string::String>,
#[serde(rename = "ipv6-dns", default, skip_serializing_if = "Option::is_none")]
pub ipv6_dns: Option<::std::string::String>,
#[serde(rename = "net", default, skip_serializing_if = "Option::is_none")]
pub net: Option<::std::string::String>,
#[serde(rename = "smb", default, skip_serializing_if = "Option::is_none")]
pub smb: Option<::std::string::String>,
#[serde(rename = "smbserver", default, skip_serializing_if = "Option::is_none")]
pub smbserver: Option<::std::string::String>,
#[serde(rename = "hostfwd", default, skip_serializing_if = "Option::is_none")]
pub hostfwd: Option<Vec<String>>,
#[serde(rename = "tftp-server-name", default, skip_serializing_if = "Option::is_none")]
pub tftp_server_name: Option<::std::string::String>,
#[serde(rename = "ip", default, skip_serializing_if = "Option::is_none")]
pub ip: Option<::std::string::String>,
#[serde(rename = "hostname", default, skip_serializing_if = "Option::is_none")]
pub hostname: Option<::std::string::String>,
#[serde(rename = "guestfwd", default, skip_serializing_if = "Option::is_none")]
pub guestfwd: Option<Vec<String>>,
#[serde(rename = "ipv4", default, skip_serializing_if = "Option::is_none")]
pub ipv4: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockInfoLUKSSlot {
#[serde(rename = "iters", default, skip_serializing_if = "Option::is_none")]
pub iters: Option<isize>,
#[serde(rename = "active")]
pub active: bool,
#[serde(rename = "stripes", default, skip_serializing_if = "Option::is_none")]
pub stripes: Option<isize>,
#[serde(rename = "key-offset")]
pub key_offset: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockMeasureInfo {
#[serde(rename = "fully-allocated")]
pub fully_allocated: isize,
#[serde(rename = "required")]
pub required: isize,
#[serde(rename = "bitmaps", default, skip_serializing_if = "Option::is_none")]
pub bitmaps: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QAuthZListRuleListHack {
#[serde(rename = "unused")]
pub unused: Vec<QAuthZListRule>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoBuiltin {
#[serde(rename = "json-type")]
pub json_type: JSONType,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnnounceParameters {
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "initial")]
pub initial: isize,
#[serde(rename = "max")]
pub max: isize,
#[serde(rename = "rounds")]
pub rounds: isize,
#[serde(rename = "step")]
pub step: isize,
#[serde(rename = "interfaces", default, skip_serializing_if = "Option::is_none")]
pub interfaces: Option<Vec<::std::string::String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevInfo {
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "frontend-open")]
pub frontend_open: bool,
#[serde(rename = "label")]
pub label: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InputMoveEvent {
#[serde(rename = "axis")]
pub axis: InputAxis,
#[serde(rename = "value")]
pub value: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NumaNodeOptions {
#[serde(rename = "nodeid", default, skip_serializing_if = "Option::is_none")]
pub nodeid: Option<u16>,
#[serde(rename = "cpus", default, skip_serializing_if = "Option::is_none")]
pub cpus: Option<Vec<u16>>,
#[serde(rename = "memdev", default, skip_serializing_if = "Option::is_none")]
pub memdev: Option<::std::string::String>,
#[serde(rename = "mem", default, skip_serializing_if = "Option::is_none")]
pub mem: Option<usize>,
#[serde(rename = "initiator", default, skip_serializing_if = "Option::is_none")]
pub initiator: Option<u16>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsThrottle {
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "throttle-group")]
pub throttle_group: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsSheepdog {
#[serde(rename = "snap-id", default, skip_serializing_if = "Option::is_none")]
pub snap_id: Option<u32>,
#[serde(rename = "server")]
pub server: SocketAddress,
#[serde(rename = "vdi")]
pub vdi: ::std::string::String,
#[serde(rename = "tag", default, skip_serializing_if = "Option::is_none")]
pub tag: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevOssPerDirectionOptions {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: AudiodevPerDirectionOptions,
#[serde(rename = "dev", default, skip_serializing_if = "Option::is_none")]
pub dev: Option<::std::string::String>,
#[serde(rename = "try-poll", default, skip_serializing_if = "Option::is_none")]
pub try_poll: Option<bool>,
#[serde(rename = "buffer-count", default, skip_serializing_if = "Option::is_none")]
pub buffer_count: Option<u32>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciBusInfo {
#[serde(rename = "io_range")]
pub io_range: PciMemoryRange,
#[serde(rename = "subordinate")]
pub subordinate: isize,
#[serde(rename = "memory_range")]
pub memory_range: PciMemoryRange,
#[serde(rename = "number")]
pub number: isize,
#[serde(rename = "secondary")]
pub secondary: isize,
#[serde(rename = "prefetchable_range")]
pub prefetchable_range: PciMemoryRange,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommandInfo {
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsCurlHttps {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsCurlBase,
#[serde(rename = "sslverify", default, skip_serializing_if = "Option::is_none")]
pub sslverify: Option<bool>,
#[serde(rename = "cookie-secret", default, skip_serializing_if = "Option::is_none")]
pub cookie_secret: Option<::std::string::String>,
#[serde(rename = "cookie", default, skip_serializing_if = "Option::is_none")]
pub cookie: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NumaCpuOptions {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: CpuInstanceProperties,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SevInfo {
#[serde(rename = "state")]
pub state: SevState,
#[serde(rename = "handle")]
pub handle: u32,
#[serde(rename = "api-major")]
pub api_major: u8,
#[serde(rename = "build-id")]
pub build_id: u8,
#[serde(rename = "enabled")]
pub enabled: bool,
#[serde(rename = "api-minor")]
pub api_minor: u8,
#[serde(rename = "policy")]
pub policy: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SevCapability {
#[serde(rename = "cert-chain")]
pub cert_chain: ::std::string::String,
#[serde(rename = "pdh")]
pub pdh: ::std::string::String,
#[serde(rename = "reduced-phys-bits")]
pub reduced_phys_bits: isize,
#[serde(rename = "cbitpos")]
pub cbitpos: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TPMInfo {
#[serde(rename = "model")]
pub model: TpmModel,
#[serde(rename = "options")]
pub options: TpmTypeOptions,
#[serde(rename = "id")]
pub id: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevJackPerDirectionOptions {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: AudiodevPerDirectionOptions,
#[serde(rename = "client-name", default, skip_serializing_if = "Option::is_none")]
pub client_name: Option<::std::string::String>,
#[serde(rename = "exact-name", default, skip_serializing_if = "Option::is_none")]
pub exact_name: Option<bool>,
#[serde(rename = "start-server", default, skip_serializing_if = "Option::is_none")]
pub start_server: Option<bool>,
#[serde(rename = "server-name", default, skip_serializing_if = "Option::is_none")]
pub server_name: Option<::std::string::String>,
#[serde(rename = "connect-ports", default, skip_serializing_if = "Option::is_none")]
pub connect_ports: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MapEntry {
#[serde(rename = "zero")]
pub zero: bool,
#[serde(rename = "depth")]
pub depth: isize,
#[serde(rename = "offset", default, skip_serializing_if = "Option::is_none")]
pub offset: Option<isize>,
#[serde(rename = "start")]
pub start: isize,
#[serde(rename = "filename", default, skip_serializing_if = "Option::is_none")]
pub filename: Option<::std::string::String>,
#[serde(rename = "length")]
pub length: isize,
#[serde(rename = "data")]
pub data: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsQcow {
#[serde(rename = "backing-file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "encrypt", default, skip_serializing_if = "Option::is_none")]
pub encrypt: Option<QCryptoBlockCreateOptions>,
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "size")]
pub size: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FdsetFdInfo {
#[serde(rename = "opaque", default, skip_serializing_if = "Option::is_none")]
pub opaque: Option<::std::string::String>,
#[serde(rename = "fd")]
pub fd: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct XDbgBlockGraphEdge {
#[serde(rename = "perm")]
pub perm: Vec<BlockPermission>,
#[serde(rename = "parent")]
pub parent: u64,
#[serde(rename = "child")]
pub child: u64,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "shared-perm")]
pub shared_perm: Vec<BlockPermission>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InetSocketAddressBase {
#[serde(rename = "port")]
pub port: ::std::string::String,
#[serde(rename = "host")]
pub host: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QAuthZListRule {
#[serde(rename = "policy")]
pub policy: QAuthZListPolicy,
#[serde(rename = "match")]
pub match_: ::std::string::String,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<QAuthZListFormat>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommandLineParameterInfo {
#[serde(rename = "type")]
pub type_: CommandLineParameterType,
#[serde(rename = "help", default, skip_serializing_if = "Option::is_none")]
pub help: Option<::std::string::String>,
#[serde(rename = "default", default, skip_serializing_if = "Option::is_none")]
pub default: Option<::std::string::String>,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoArray {
#[serde(rename = "element-type")]
pub element_type: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevOssOptions {
#[serde(rename = "try-mmap", default, skip_serializing_if = "Option::is_none")]
pub try_mmap: Option<bool>,
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevOssPerDirectionOptions>,
#[serde(rename = "exclusive", default, skip_serializing_if = "Option::is_none")]
pub exclusive: Option<bool>,
#[serde(rename = "dsp-policy", default, skip_serializing_if = "Option::is_none")]
pub dsp_policy: Option<u32>,
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevOssPerDirectionOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct XDbgBlockGraphNode {
#[serde(rename = "type")]
pub type_: XDbgBlockGraphNodeType,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "id")]
pub id: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TraceEventInfo {
#[serde(rename = "vcpu")]
pub vcpu: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "state")]
pub state: TraceEventState,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TargetInfo {
#[serde(rename = "arch")]
pub arch: SysEmuTarget,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DumpQueryResult {
#[serde(rename = "completed")]
pub completed: isize,
#[serde(rename = "total")]
pub total: isize,
#[serde(rename = "status")]
pub status: DumpStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InputBtnEvent {
#[serde(rename = "down")]
pub down: bool,
#[serde(rename = "button")]
pub button: InputButton,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DisplayEGLHeadless {
#[serde(rename = "rendernode", default, skip_serializing_if = "Option::is_none")]
pub rendernode: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevBackup {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BackupCommon,
#[serde(rename = "target")]
pub target: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriveBackup {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BackupCommon,
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<NewImageMode>,
#[serde(rename = "target")]
pub target: ::std::string::String,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDirtyBitmap {
#[serde(rename = "node")]
pub node: ::std::string::String,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInfoS390 {
#[serde(rename = "cpu-state")]
pub cpu_state: CpuS390State,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciDeviceInfo {
#[serde(rename = "regions")]
pub regions: Vec<PciMemoryRegion>,
#[serde(rename = "bus")]
pub bus: isize,
#[serde(rename = "id")]
pub id: PciDeviceId,
#[serde(rename = "irq_pin")]
pub irq_pin: isize,
#[serde(rename = "qdev_id")]
pub qdev_id: ::std::string::String,
#[serde(rename = "function")]
pub function: isize,
#[serde(rename = "class_info")]
pub class_info: PciDeviceClass,
#[serde(rename = "irq", default, skip_serializing_if = "Option::is_none")]
pub irq: Option<isize>,
#[serde(rename = "slot")]
pub slot: isize,
#[serde(rename = "pci_bridge", default, skip_serializing_if = "Option::is_none")]
pub pci_bridge: Option<PciBridgeInfo>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct COLOStatus {
#[serde(rename = "reason")]
pub reason: COLOExitReason,
#[serde(rename = "mode")]
pub mode: COLOMode,
#[serde(rename = "last-mode")]
pub last_mode: COLOMode,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevBackendInfo {
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevSnapshotSync {
#[serde(rename = "snapshot-node-name", default, skip_serializing_if = "Option::is_none")]
pub snapshot_node_name: Option<::std::string::String>,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<::std::string::String>,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
#[serde(rename = "snapshot-file")]
pub snapshot_file: ::std::string::String,
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<NewImageMode>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsReplication {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsGenericFormat,
#[serde(rename = "top-id", default, skip_serializing_if = "Option::is_none")]
pub top_id: Option<::std::string::String>,
#[serde(rename = "mode")]
pub mode: ReplicationMode,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestPanicInformationS390 {
#[serde(rename = "core")]
pub core: u32,
#[serde(rename = "psw-mask")]
pub psw_mask: u64,
#[serde(rename = "psw-addr")]
pub psw_addr: u64,
#[serde(rename = "reason")]
pub reason: S390CrashReason,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsQcow {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsGenericCOWFormat,
#[serde(rename = "encrypt", default, skip_serializing_if = "Option::is_none")]
pub encrypt: Option<BlockdevQcowEncryption>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BitmapMigrationBitmapAlias {
#[serde(rename = "alias")]
pub alias: ::std::string::String,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MonitorOptions {
#[serde(rename = "chardev")]
pub chardev: ::std::string::String,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<MonitorMode>,
#[serde(rename = "pretty", default, skip_serializing_if = "Option::is_none")]
pub pretty: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsCurlFtp {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsCurlBase,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Qcow2BitmapInfo {
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "flags")]
pub flags: Vec<Qcow2BitmapInfoFlags>,
#[serde(rename = "granularity")]
pub granularity: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDeviceInfo {
#[serde(rename = "bps_max_length", default, skip_serializing_if = "Option::is_none")]
pub bps_max_length: Option<isize>,
#[serde(rename = "encryption_key_missing")] #[deprecated]
pub encryption_key_missing: bool,
#[serde(rename = "encrypted")]
pub encrypted: bool,
#[serde(rename = "bps_rd")]
pub bps_rd: isize,
#[serde(rename = "detect_zeroes")]
pub detect_zeroes: BlockdevDetectZeroesOptions,
#[serde(rename = "iops")]
pub iops: isize,
#[serde(rename = "dirty-bitmaps", default, skip_serializing_if = "Option::is_none")]
pub dirty_bitmaps: Option<Vec<BlockDirtyInfo>>,
#[serde(rename = "bps")]
pub bps: isize,
#[serde(rename = "image")]
pub image: ImageInfo,
#[serde(rename = "drv")]
pub drv: ::std::string::String,
#[serde(rename = "iops_rd_max_length", default, skip_serializing_if = "Option::is_none")]
pub iops_rd_max_length: Option<isize>,
#[serde(rename = "write_threshold")]
pub write_threshold: isize,
#[serde(rename = "bps_max", default, skip_serializing_if = "Option::is_none")]
pub bps_max: Option<isize>,
#[serde(rename = "backing_file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
#[serde(rename = "iops_max_length", default, skip_serializing_if = "Option::is_none")]
pub iops_max_length: Option<isize>,
#[serde(rename = "group", default, skip_serializing_if = "Option::is_none")]
pub group: Option<::std::string::String>,
#[serde(rename = "bps_rd_max_length", default, skip_serializing_if = "Option::is_none")]
pub bps_rd_max_length: Option<isize>,
#[serde(rename = "iops_rd")]
pub iops_rd: isize,
#[serde(rename = "iops_wr")]
pub iops_wr: isize,
#[serde(rename = "bps_rd_max", default, skip_serializing_if = "Option::is_none")]
pub bps_rd_max: Option<isize>,
#[serde(rename = "file")]
pub file: ::std::string::String,
#[serde(rename = "iops_wr_max_length", default, skip_serializing_if = "Option::is_none")]
pub iops_wr_max_length: Option<isize>,
#[serde(rename = "bps_wr")]
pub bps_wr: isize,
#[serde(rename = "bps_wr_max", default, skip_serializing_if = "Option::is_none")]
pub bps_wr_max: Option<isize>,
#[serde(rename = "cache")]
pub cache: BlockdevCacheInfo,
#[serde(rename = "iops_max", default, skip_serializing_if = "Option::is_none")]
pub iops_max: Option<isize>,
#[serde(rename = "bps_wr_max_length", default, skip_serializing_if = "Option::is_none")]
pub bps_wr_max_length: Option<isize>,
#[serde(rename = "ro")]
pub ro: bool,
#[serde(rename = "backing_file_depth")]
pub backing_file_depth: isize,
#[serde(rename = "iops_rd_max", default, skip_serializing_if = "Option::is_none")]
pub iops_rd_max: Option<isize>,
#[serde(rename = "iops_wr_max", default, skip_serializing_if = "Option::is_none")]
pub iops_wr_max: Option<isize>,
#[serde(rename = "iops_size", default, skip_serializing_if = "Option::is_none")]
pub iops_size: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MigrationCapabilityStatus {
#[serde(rename = "capability")]
pub capability: MigrationCapability,
#[serde(rename = "state")]
pub state: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObjectPropertyInfo {
#[serde(rename = "description", default, skip_serializing_if = "Option::is_none")]
pub description: Option<::std::string::String>,
#[serde(rename = "default-value", default, skip_serializing_if = "Option::is_none")]
pub default_value: Option<::qapi_spec::Any>,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "type")]
pub type_: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionInfo {
#[serde(rename = "package")]
pub package: ::std::string::String,
#[serde(rename = "qemu")]
pub qemu: VersionTriple,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevJackOptions {
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevJackPerDirectionOptions>,
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevJackPerDirectionOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InetSocketAddress {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: InetSocketAddressBase,
#[serde(rename = "ipv6", default, skip_serializing_if = "Option::is_none")]
pub ipv6: Option<bool>,
#[serde(rename = "numeric", default, skip_serializing_if = "Option::is_none")]
pub numeric: Option<bool>,
#[serde(rename = "ipv4", default, skip_serializing_if = "Option::is_none")]
pub ipv4: Option<bool>,
#[serde(rename = "keep-alive", default, skip_serializing_if = "Option::is_none")]
pub keep_alive: Option<bool>,
#[serde(rename = "to", default, skip_serializing_if = "Option::is_none")]
pub to: Option<u16>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsQcow2 {
#[serde(rename = "encrypt", default, skip_serializing_if = "Option::is_none")]
pub encrypt: Option<QCryptoBlockCreateOptions>,
#[serde(rename = "preallocation", default, skip_serializing_if = "Option::is_none")]
pub preallocation: Option<PreallocMode>,
#[serde(rename = "lazy-refcounts", default, skip_serializing_if = "Option::is_none")]
pub lazy_refcounts: Option<bool>,
#[serde(rename = "refcount-bits", default, skip_serializing_if = "Option::is_none")]
pub refcount_bits: Option<isize>,
#[serde(rename = "cluster-size", default, skip_serializing_if = "Option::is_none")]
pub cluster_size: Option<usize>,
#[serde(rename = "compression-type", default, skip_serializing_if = "Option::is_none")]
pub compression_type: Option<Qcow2CompressionType>,
#[serde(rename = "data-file-raw", default, skip_serializing_if = "Option::is_none")]
pub data_file_raw: Option<bool>,
#[serde(rename = "version", default, skip_serializing_if = "Option::is_none")]
pub version: Option<BlockdevQcow2Version>,
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "data-file", default, skip_serializing_if = "Option::is_none")]
pub data_file: Option<BlockdevRef>,
#[serde(rename = "extended-l2", default, skip_serializing_if = "Option::is_none")]
pub extended_l2: Option<bool>,
#[serde(rename = "backing-file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "backing-fmt", default, skip_serializing_if = "Option::is_none")]
pub backing_fmt: Option<BlockdevDriver>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RockerOfDpaFlowMask {
#[serde(rename = "in-pport", default, skip_serializing_if = "Option::is_none")]
pub in_pport: Option<u32>,
#[serde(rename = "eth-dst", default, skip_serializing_if = "Option::is_none")]
pub eth_dst: Option<::std::string::String>,
#[serde(rename = "tunnel-id", default, skip_serializing_if = "Option::is_none")]
pub tunnel_id: Option<u32>,
#[serde(rename = "ip-tos", default, skip_serializing_if = "Option::is_none")]
pub ip_tos: Option<u8>,
#[serde(rename = "eth-src", default, skip_serializing_if = "Option::is_none")]
pub eth_src: Option<::std::string::String>,
#[serde(rename = "vlan-id", default, skip_serializing_if = "Option::is_none")]
pub vlan_id: Option<u16>,
#[serde(rename = "ip-proto", default, skip_serializing_if = "Option::is_none")]
pub ip_proto: Option<u8>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RockerOfDpaFlowAction {
#[serde(rename = "out-pport", default, skip_serializing_if = "Option::is_none")]
pub out_pport: Option<u32>,
#[serde(rename = "group-id", default, skip_serializing_if = "Option::is_none")]
pub group_id: Option<u32>,
#[serde(rename = "tunnel-lport", default, skip_serializing_if = "Option::is_none")]
pub tunnel_lport: Option<u32>,
#[serde(rename = "vlan-id", default, skip_serializing_if = "Option::is_none")]
pub vlan_id: Option<u16>,
#[serde(rename = "goto-tbl", default, skip_serializing_if = "Option::is_none")]
pub goto_tbl: Option<u32>,
#[serde(rename = "new-vlan-id", default, skip_serializing_if = "Option::is_none")]
pub new_vlan_id: Option<u16>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InputKeyEvent {
#[serde(rename = "down")]
pub down: bool,
#[serde(rename = "key")]
pub key: KeyValue,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsCurlBase {
#[serde(rename = "readahead", default, skip_serializing_if = "Option::is_none")]
pub readahead: Option<isize>,
#[serde(rename = "timeout", default, skip_serializing_if = "Option::is_none")]
pub timeout: Option<isize>,
#[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
pub username: Option<::std::string::String>,
#[serde(rename = "proxy-username", default, skip_serializing_if = "Option::is_none")]
pub proxy_username: Option<::std::string::String>,
#[serde(rename = "proxy-password-secret", default, skip_serializing_if = "Option::is_none")]
pub proxy_password_secret: Option<::std::string::String>,
#[serde(rename = "url")]
pub url: ::std::string::String,
#[serde(rename = "password-secret", default, skip_serializing_if = "Option::is_none")]
pub password_secret: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObjectTypeInfo {
#[serde(rename = "abstract", default, skip_serializing_if = "Option::is_none")]
pub abstract_: Option<bool>,
#[serde(rename = "parent", default, skip_serializing_if = "Option::is_none")]
pub parent: Option<::std::string::String>,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCacheInfo {
#[serde(rename = "direct")]
pub direct: bool,
#[serde(rename = "writeback")]
pub writeback: bool,
#[serde(rename = "no-flush")]
pub no_flush: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SshHostKeyHash {
#[serde(rename = "type")]
pub type_: SshHostKeyCheckHashType,
#[serde(rename = "hash")]
pub hash: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevAlsaOptions {
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevAlsaPerDirectionOptions>,
#[serde(rename = "threshold", default, skip_serializing_if = "Option::is_none")]
pub threshold: Option<u32>,
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevAlsaPerDirectionOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VirtioMEMDeviceInfo {
#[serde(rename = "memaddr")]
pub memaddr: usize,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "requested-size")]
pub requested_size: usize,
#[serde(rename = "max-size")]
pub max_size: usize,
#[serde(rename = "memdev")]
pub memdev: ::std::string::String,
#[serde(rename = "node")]
pub node: isize,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "block-size")]
pub block_size: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockOptionsQCow {
#[serde(rename = "key-secret", default, skip_serializing_if = "Option::is_none")]
pub key_secret: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevSnapshot {
#[serde(rename = "node")]
pub node: ::std::string::String,
#[serde(rename = "overlay")]
pub overlay: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockExportOptionsNbdBase {
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
#[serde(rename = "description", default, skip_serializing_if = "Option::is_none")]
pub description: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevStdio {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "signal", default, skip_serializing_if = "Option::is_none")]
pub signal: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevSpiceChannel {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "type")]
pub type_: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MigrationInfo {
#[serde(rename = "expected-downtime", default, skip_serializing_if = "Option::is_none")]
pub expected_downtime: Option<isize>,
#[serde(rename = "total-time", default, skip_serializing_if = "Option::is_none")]
pub total_time: Option<isize>,
#[serde(rename = "downtime", default, skip_serializing_if = "Option::is_none")]
pub downtime: Option<isize>,
#[serde(rename = "postcopy-vcpu-blocktime", default, skip_serializing_if = "Option::is_none")]
pub postcopy_vcpu_blocktime: Option<Vec<u32>>,
#[serde(rename = "vfio", default, skip_serializing_if = "Option::is_none")]
pub vfio: Option<VfioStats>,
#[serde(rename = "cpu-throttle-percentage", default, skip_serializing_if = "Option::is_none")]
pub cpu_throttle_percentage: Option<isize>,
#[serde(rename = "status", default, skip_serializing_if = "Option::is_none")]
pub status: Option<MigrationStatus>,
#[serde(rename = "setup-time", default, skip_serializing_if = "Option::is_none")]
pub setup_time: Option<isize>,
#[serde(rename = "socket-address", default, skip_serializing_if = "Option::is_none")]
pub socket_address: Option<Vec<SocketAddress>>,
#[serde(rename = "disk", default, skip_serializing_if = "Option::is_none")]
pub disk: Option<MigrationStats>,
#[serde(rename = "postcopy-blocktime", default, skip_serializing_if = "Option::is_none")]
pub postcopy_blocktime: Option<u32>,
#[serde(rename = "compression", default, skip_serializing_if = "Option::is_none")]
pub compression: Option<CompressionStats>,
#[serde(rename = "xbzrle-cache", default, skip_serializing_if = "Option::is_none")]
pub xbzrle_cache: Option<XBZRLECacheStats>,
#[serde(rename = "error-desc", default, skip_serializing_if = "Option::is_none")]
pub error_desc: Option<::std::string::String>,
#[serde(rename = "ram", default, skip_serializing_if = "Option::is_none")]
pub ram: Option<MigrationStats>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsNfs {
#[serde(rename = "tcp-syn-count", default, skip_serializing_if = "Option::is_none")]
pub tcp_syn_count: Option<isize>,
#[serde(rename = "readahead-size", default, skip_serializing_if = "Option::is_none")]
pub readahead_size: Option<isize>,
#[serde(rename = "server")]
pub server: NFSServer,
#[serde(rename = "path")]
pub path: ::std::string::String,
#[serde(rename = "debug", default, skip_serializing_if = "Option::is_none")]
pub debug: Option<isize>,
#[serde(rename = "page-cache-size", default, skip_serializing_if = "Option::is_none")]
pub page_cache_size: Option<isize>,
#[serde(rename = "user", default, skip_serializing_if = "Option::is_none")]
pub user: Option<isize>,
#[serde(rename = "group", default, skip_serializing_if = "Option::is_none")]
pub group: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoObjectMember {
#[serde(rename = "features", default, skip_serializing_if = "Option::is_none")]
pub features: Option<Vec<::std::string::String>>,
#[serde(rename = "type")]
pub type_: ::std::string::String,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "default", default, skip_serializing_if = "Option::is_none")]
pub default: Option<::qapi_spec::Any>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevFile {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "out")]
pub out: ::std::string::String,
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<::std::string::String>,
#[serde(rename = "append", default, skip_serializing_if = "Option::is_none")]
pub append: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsCurlFtps {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsCurlBase,
#[serde(rename = "sslverify", default, skip_serializing_if = "Option::is_none")]
pub sslverify: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoAlternateMember {
#[serde(rename = "type")]
pub type_: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MouseInfo {
#[serde(rename = "current")]
pub current: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "index")]
pub index: isize,
#[serde(rename = "absolute")]
pub absolute: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UnixSocketAddress {
#[serde(rename = "path")]
pub path: ::std::string::String,
#[serde(rename = "abstract", default, skip_serializing_if = "Option::is_none")]
pub abstract_: Option<bool>,
#[serde(rename = "tight", default, skip_serializing_if = "Option::is_none")]
pub tight: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionTriple {
#[serde(rename = "minor")]
pub minor: isize,
#[serde(rename = "major")]
pub major: isize,
#[serde(rename = "micro")]
pub micro: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpiceInfo {
#[serde(rename = "port", default, skip_serializing_if = "Option::is_none")]
pub port: Option<isize>,
#[serde(rename = "tls-port", default, skip_serializing_if = "Option::is_none")]
pub tls_port: Option<isize>,
#[serde(rename = "compiled-version", default, skip_serializing_if = "Option::is_none")]
pub compiled_version: Option<::std::string::String>,
#[serde(rename = "host", default, skip_serializing_if = "Option::is_none")]
pub host: Option<::std::string::String>,
#[serde(rename = "channels", default, skip_serializing_if = "Option::is_none")]
pub channels: Option<Vec<SpiceChannel>>,
#[serde(rename = "mouse-mode")]
pub mouse_mode: SpiceQueryMouseMode,
#[serde(rename = "auth", default, skip_serializing_if = "Option::is_none")]
pub auth: Option<::std::string::String>,
#[serde(rename = "migrated")]
pub migrated: bool,
#[serde(rename = "enabled")]
pub enabled: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevVC {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "width", default, skip_serializing_if = "Option::is_none")]
pub width: Option<isize>,
#[serde(rename = "rows", default, skip_serializing_if = "Option::is_none")]
pub rows: Option<isize>,
#[serde(rename = "cols", default, skip_serializing_if = "Option::is_none")]
pub cols: Option<isize>,
#[serde(rename = "height", default, skip_serializing_if = "Option::is_none")]
pub height: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockInfoLUKS {
#[serde(rename = "payload-offset")]
pub payload_offset: isize,
#[serde(rename = "ivgen-alg")]
pub ivgen_alg: QCryptoIVGenAlgorithm,
#[serde(rename = "slots")]
pub slots: Vec<QCryptoBlockInfoLUKSSlot>,
#[serde(rename = "ivgen-hash-alg", default, skip_serializing_if = "Option::is_none")]
pub ivgen_hash_alg: Option<QCryptoHashAlgorithm>,
#[serde(rename = "cipher-alg")]
pub cipher_alg: QCryptoCipherAlgorithm,
#[serde(rename = "hash-alg")]
pub hash_alg: QCryptoHashAlgorithm,
#[serde(rename = "master-key-iters")]
pub master_key_iters: isize,
#[serde(rename = "cipher-mode")]
pub cipher_mode: QCryptoCipherMode,
#[serde(rename = "uuid")]
pub uuid: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsNVMe {
#[serde(rename = "namespace")]
pub namespace: isize,
#[serde(rename = "device")]
pub device: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsGenericCOWFormat {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsGenericFormat,
#[serde(rename = "backing", default, skip_serializing_if = "Option::is_none")]
pub backing: Option<BlockdevRefOrNull>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionProperties {
#[serde(rename = "completion-mode", default, skip_serializing_if = "Option::is_none")]
pub completion_mode: Option<ActionCompletionMode>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuDefinitionInfo {
#[serde(rename = "alias-of", default, skip_serializing_if = "Option::is_none")]
pub alias_of: Option<::std::string::String>,
#[serde(rename = "unavailable-features", default, skip_serializing_if = "Option::is_none")]
pub unavailable_features: Option<Vec<::std::string::String>>,
#[serde(rename = "deprecated")]
pub deprecated: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "migration-safe", default, skip_serializing_if = "Option::is_none")]
pub migration_safe: Option<bool>,
#[serde(rename = "typename")]
pub typename: ::std::string::String,
#[serde(rename = "static")]
pub static_: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VncInfo2 {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "vencrypt", default, skip_serializing_if = "Option::is_none")]
pub vencrypt: Option<VncVencryptSubAuth>,
#[serde(rename = "display", default, skip_serializing_if = "Option::is_none")]
pub display: Option<::std::string::String>,
#[serde(rename = "server")]
pub server: Vec<VncServerInfo2>,
#[serde(rename = "clients")]
pub clients: Vec<VncClientInfo>,
#[serde(rename = "auth")]
pub auth: VncPrimaryAuth,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsFile {
#[serde(rename = "nocow", default, skip_serializing_if = "Option::is_none")]
pub nocow: Option<bool>,
#[serde(rename = "extent-size-hint", default, skip_serializing_if = "Option::is_none")]
pub extent_size_hint: Option<usize>,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "preallocation", default, skip_serializing_if = "Option::is_none")]
pub preallocation: Option<PreallocMode>,
#[serde(rename = "filename")]
pub filename: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsQcow2 {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsGenericCOWFormat,
#[serde(rename = "overlap-check", default, skip_serializing_if = "Option::is_none")]
pub overlap_check: Option<Qcow2OverlapChecks>,
#[serde(rename = "pass-discard-request", default, skip_serializing_if = "Option::is_none")]
pub pass_discard_request: Option<bool>,
#[serde(rename = "l2-cache-size", default, skip_serializing_if = "Option::is_none")]
pub l2_cache_size: Option<isize>,
#[serde(rename = "pass-discard-snapshot", default, skip_serializing_if = "Option::is_none")]
pub pass_discard_snapshot: Option<bool>,
#[serde(rename = "lazy-refcounts", default, skip_serializing_if = "Option::is_none")]
pub lazy_refcounts: Option<bool>,
#[serde(rename = "cache-size", default, skip_serializing_if = "Option::is_none")]
pub cache_size: Option<isize>,
#[serde(rename = "l2-cache-entry-size", default, skip_serializing_if = "Option::is_none")]
pub l2_cache_entry_size: Option<isize>,
#[serde(rename = "refcount-cache-size", default, skip_serializing_if = "Option::is_none")]
pub refcount_cache_size: Option<isize>,
#[serde(rename = "cache-clean-interval", default, skip_serializing_if = "Option::is_none")]
pub cache_clean_interval: Option<isize>,
#[serde(rename = "encrypt", default, skip_serializing_if = "Option::is_none")]
pub encrypt: Option<BlockdevQcow2Encryption>,
#[serde(rename = "pass-discard-other", default, skip_serializing_if = "Option::is_none")]
pub pass_discard_other: Option<bool>,
#[serde(rename = "data-file", default, skip_serializing_if = "Option::is_none")]
pub data_file: Option<BlockdevRef>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockAmendOptionsLUKS {
#[serde(rename = "state")]
pub state: QCryptoBlockLUKSKeyslotState,
#[serde(rename = "new-secret", default, skip_serializing_if = "Option::is_none")]
pub new_secret: Option<::std::string::String>,
#[serde(rename = "old-secret", default, skip_serializing_if = "Option::is_none")]
pub old_secret: Option<::std::string::String>,
#[serde(rename = "iter-time", default, skip_serializing_if = "Option::is_none")]
pub iter_time: Option<isize>,
#[serde(rename = "keyslot", default, skip_serializing_if = "Option::is_none")]
pub keyslot: Option<isize>,
#[serde(rename = "secret", default, skip_serializing_if = "Option::is_none")]
pub secret: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsQed {
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "cluster-size", default, skip_serializing_if = "Option::is_none")]
pub cluster_size: Option<usize>,
#[serde(rename = "table-size", default, skip_serializing_if = "Option::is_none")]
pub table_size: Option<isize>,
#[serde(rename = "backing-file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "backing-fmt", default, skip_serializing_if = "Option::is_none")]
pub backing_fmt: Option<BlockdevDriver>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageInfoSpecificVmdk {
#[serde(rename = "cid")]
pub cid: isize,
#[serde(rename = "create-type")]
pub create_type: ::std::string::String,
#[serde(rename = "extents")]
pub extents: Vec<ImageInfo>,
#[serde(rename = "parent-cid")]
pub parent_cid: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockExportOptionsNbd {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockExportOptionsNbdBase,
#[serde(rename = "allocation-depth", default, skip_serializing_if = "Option::is_none")]
pub allocation_depth: Option<bool>,
#[serde(rename = "bitmaps", default, skip_serializing_if = "Option::is_none")]
pub bitmaps: Option<Vec<::std::string::String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MigrationStats {
#[serde(rename = "duplicate")]
pub duplicate: isize,
#[serde(rename = "total")]
pub total: isize,
#[serde(rename = "skipped")]
pub skipped: isize,
#[serde(rename = "normal-bytes")]
pub normal_bytes: isize,
#[serde(rename = "dirty-pages-rate")]
pub dirty_pages_rate: isize,
#[serde(rename = "mbps")]
pub mbps: f64,
#[serde(rename = "postcopy-requests")]
pub postcopy_requests: isize,
#[serde(rename = "transferred")]
pub transferred: isize,
#[serde(rename = "page-size")]
pub page_size: isize,
#[serde(rename = "multifd-bytes")]
pub multifd_bytes: u64,
#[serde(rename = "pages-per-second")]
pub pages_per_second: u64,
#[serde(rename = "remaining")]
pub remaining: isize,
#[serde(rename = "normal")]
pub normal: isize,
#[serde(rename = "dirty-sync-count")]
pub dirty_sync_count: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VirtioPMEMDeviceInfo {
#[serde(rename = "memaddr")]
pub memaddr: usize,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "memdev")]
pub memdev: ::std::string::String,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevSnapshotInternal {
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsNull {
#[serde(rename = "latency-ns", default, skip_serializing_if = "Option::is_none")]
pub latency_ns: Option<u64>,
#[serde(rename = "read-zeroes", default, skip_serializing_if = "Option::is_none")]
pub read_zeroes: Option<bool>,
#[serde(rename = "size", default, skip_serializing_if = "Option::is_none")]
pub size: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDirtyBitmapSha256 {
#[serde(rename = "sha256")]
pub sha256: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevBridgeOptions {
#[serde(rename = "helper", default, skip_serializing_if = "Option::is_none")]
pub helper: Option<::std::string::String>,
#[serde(rename = "br", default, skip_serializing_if = "Option::is_none")]
pub br: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MigrateSetParameters {
#[serde(rename = "max-bandwidth", default, skip_serializing_if = "Option::is_none")]
pub max_bandwidth: Option<isize>,
#[serde(rename = "xbzrle-cache-size", default, skip_serializing_if = "Option::is_none")]
pub xbzrle_cache_size: Option<usize>,
#[serde(rename = "multifd-zstd-level", default, skip_serializing_if = "Option::is_none")]
pub multifd_zstd_level: Option<isize>,
#[serde(rename = "block-bitmap-mapping", default, skip_serializing_if = "Option::is_none")]
pub block_bitmap_mapping: Option<Vec<BitmapMigrationNodeAlias>>,
#[serde(rename = "multifd-channels", default, skip_serializing_if = "Option::is_none")]
pub multifd_channels: Option<isize>,
#[serde(rename = "tls-authz", default, skip_serializing_if = "Option::is_none")]
pub tls_authz: Option<StrOrNull>,
#[serde(rename = "cpu-throttle-initial", default, skip_serializing_if = "Option::is_none")]
pub cpu_throttle_initial: Option<isize>,
#[serde(rename = "announce-rounds", default, skip_serializing_if = "Option::is_none")]
pub announce_rounds: Option<usize>,
#[serde(rename = "cpu-throttle-tailslow", default, skip_serializing_if = "Option::is_none")]
pub cpu_throttle_tailslow: Option<bool>,
#[serde(rename = "announce-initial", default, skip_serializing_if = "Option::is_none")]
pub announce_initial: Option<usize>,
#[serde(rename = "max-postcopy-bandwidth", default, skip_serializing_if = "Option::is_none")]
pub max_postcopy_bandwidth: Option<usize>,
#[serde(rename = "announce-max", default, skip_serializing_if = "Option::is_none")]
pub announce_max: Option<usize>,
#[serde(rename = "compress-threads", default, skip_serializing_if = "Option::is_none")]
pub compress_threads: Option<isize>,
#[serde(rename = "compress-wait-thread", default, skip_serializing_if = "Option::is_none")]
pub compress_wait_thread: Option<bool>,
#[serde(rename = "announce-step", default, skip_serializing_if = "Option::is_none")]
pub announce_step: Option<usize>,
#[serde(rename = "decompress-threads", default, skip_serializing_if = "Option::is_none")]
pub decompress_threads: Option<isize>,
#[serde(rename = "throttle-trigger-threshold", default, skip_serializing_if = "Option::is_none")]
pub throttle_trigger_threshold: Option<isize>,
#[serde(rename = "tls-creds", default, skip_serializing_if = "Option::is_none")]
pub tls_creds: Option<StrOrNull>,
#[serde(rename = "downtime-limit", default, skip_serializing_if = "Option::is_none")]
pub downtime_limit: Option<isize>,
#[serde(rename = "max-cpu-throttle", default, skip_serializing_if = "Option::is_none")]
pub max_cpu_throttle: Option<isize>,
#[serde(rename = "compress-level", default, skip_serializing_if = "Option::is_none")]
pub compress_level: Option<isize>,
#[serde(rename = "cpu-throttle-increment", default, skip_serializing_if = "Option::is_none")]
pub cpu_throttle_increment: Option<isize>,
#[serde(rename = "tls-hostname", default, skip_serializing_if = "Option::is_none")]
pub tls_hostname: Option<StrOrNull>,
#[serde(rename = "x-checkpoint-delay", default, skip_serializing_if = "Option::is_none")]
pub x_checkpoint_delay: Option<isize>,
#[serde(rename = "block-incremental", default, skip_serializing_if = "Option::is_none")]
pub block_incremental: Option<bool>,
#[serde(rename = "multifd-compression", default, skip_serializing_if = "Option::is_none")]
pub multifd_compression: Option<MultiFDCompression>,
#[serde(rename = "multifd-zlib-level", default, skip_serializing_if = "Option::is_none")]
pub multifd_zlib_level: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SevLaunchMeasureInfo {
#[serde(rename = "data")]
pub data: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCacheOptions {
#[serde(rename = "no-flush", default, skip_serializing_if = "Option::is_none")]
pub no_flush: Option<bool>,
#[serde(rename = "direct", default, skip_serializing_if = "Option::is_none")]
pub direct: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsVmdk {
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "backing-file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "hwversion", default, skip_serializing_if = "Option::is_none")]
pub hwversion: Option<::std::string::String>,
#[serde(rename = "subformat", default, skip_serializing_if = "Option::is_none")]
pub subformat: Option<BlockdevVmdkSubformat>,
#[serde(rename = "zeroed-grain", default, skip_serializing_if = "Option::is_none")]
pub zeroed_grain: Option<bool>,
#[serde(rename = "adapter-type", default, skip_serializing_if = "Option::is_none")]
pub adapter_type: Option<BlockdevVmdkAdapterType>,
#[serde(rename = "extents", default, skip_serializing_if = "Option::is_none")]
pub extents: Option<Vec<BlockdevRef>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RockerOfDpaGroup {
#[serde(rename = "group-ids", default, skip_serializing_if = "Option::is_none")]
pub group_ids: Option<Vec<u32>>,
#[serde(rename = "set-eth-dst", default, skip_serializing_if = "Option::is_none")]
pub set_eth_dst: Option<::std::string::String>,
#[serde(rename = "type")]
pub type_: u8,
#[serde(rename = "ttl-check", default, skip_serializing_if = "Option::is_none")]
pub ttl_check: Option<u8>,
#[serde(rename = "set-eth-src", default, skip_serializing_if = "Option::is_none")]
pub set_eth_src: Option<::std::string::String>,
#[serde(rename = "vlan-id", default, skip_serializing_if = "Option::is_none")]
pub vlan_id: Option<u16>,
#[serde(rename = "pport", default, skip_serializing_if = "Option::is_none")]
pub pport: Option<u32>,
#[serde(rename = "id")]
pub id: u32,
#[serde(rename = "index", default, skip_serializing_if = "Option::is_none")]
pub index: Option<u32>,
#[serde(rename = "out-pport", default, skip_serializing_if = "Option::is_none")]
pub out_pport: Option<u32>,
#[serde(rename = "group-id", default, skip_serializing_if = "Option::is_none")]
pub group_id: Option<u32>,
#[serde(rename = "set-vlan-id", default, skip_serializing_if = "Option::is_none")]
pub set_vlan_id: Option<u16>,
#[serde(rename = "pop-vlan", default, skip_serializing_if = "Option::is_none")]
pub pop_vlan: Option<u8>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevPaOptions {
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevPaPerDirectionOptions>,
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevPaPerDirectionOptions>,
#[serde(rename = "server", default, skip_serializing_if = "Option::is_none")]
pub server: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DummyForceArrays {
#[serde(rename = "unused")]
pub unused: Vec<X86CPUFeatureWordInfo>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInfoX86 {
#[serde(rename = "pc")]
pub pc: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Abort {
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockOptionsLUKS {
#[serde(rename = "key-secret", default, skip_serializing_if = "Option::is_none")]
pub key_secret: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockInfoBase {
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevMux {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "chardev")]
pub chardev: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciMemoryRange {
#[serde(rename = "base")]
pub base: isize,
#[serde(rename = "limit")]
pub limit: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsRbd {
#[serde(rename = "cluster-size", default, skip_serializing_if = "Option::is_none")]
pub cluster_size: Option<usize>,
#[serde(rename = "location")]
pub location: BlockdevOptionsRbd,
#[serde(rename = "size")]
pub size: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInfoSPARC {
#[serde(rename = "npc")]
pub npc: isize,
#[serde(rename = "pc")]
pub pc: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsNbd {
#[serde(rename = "server")]
pub server: SocketAddress,
#[serde(rename = "reconnect-delay", default, skip_serializing_if = "Option::is_none")]
pub reconnect_delay: Option<u32>,
#[serde(rename = "tls-creds", default, skip_serializing_if = "Option::is_none")]
pub tls_creds: Option<::std::string::String>,
#[serde(rename = "export", default, skip_serializing_if = "Option::is_none")]
pub export: Option<::std::string::String>,
#[serde(rename = "x-dirty-bitmap", default, skip_serializing_if = "Option::is_none")]
pub x_dirty_bitmap: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RockerOfDpaFlow {
#[serde(rename = "hits")]
pub hits: u64,
#[serde(rename = "cookie")]
pub cookie: u64,
#[serde(rename = "key")]
pub key: RockerOfDpaFlowKey,
#[serde(rename = "action")]
pub action: RockerOfDpaFlowAction,
#[serde(rename = "mask")]
pub mask: RockerOfDpaFlowMask,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDirtyInfo {
#[serde(rename = "recording")]
pub recording: bool,
#[serde(rename = "inconsistent", default, skip_serializing_if = "Option::is_none")]
pub inconsistent: Option<bool>,
#[serde(rename = "count")]
pub count: isize,
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
#[serde(rename = "status")] #[deprecated]
pub status: DirtyBitmapStatus,
#[serde(rename = "persistent")]
pub persistent: bool,
#[serde(rename = "granularity")]
pub granularity: u32,
#[serde(rename = "busy")]
pub busy: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoCommand {
#[serde(rename = "arg-type")]
pub arg_type: ::std::string::String,
#[serde(rename = "ret-type")]
pub ret_type: ::std::string::String,
#[serde(rename = "allow-oob", default, skip_serializing_if = "Option::is_none")]
pub allow_oob: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VncServerInfo2 {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: VncBasicInfo,
#[serde(rename = "vencrypt", default, skip_serializing_if = "Option::is_none")]
pub vencrypt: Option<VncVencryptSubAuth>,
#[serde(rename = "auth")]
pub auth: VncPrimaryAuth,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct String {
#[serde(rename = "str")]
pub str: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuidInfo {
#[serde(rename = "guid")]
pub guid: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AcpiTableOptions {
#[serde(rename = "oem_table_id", default, skip_serializing_if = "Option::is_none")]
pub oem_table_id: Option<::std::string::String>,
#[serde(rename = "oem_id", default, skip_serializing_if = "Option::is_none")]
pub oem_id: Option<::std::string::String>,
#[serde(rename = "asl_compiler_rev", default, skip_serializing_if = "Option::is_none")]
pub asl_compiler_rev: Option<u32>,
#[serde(rename = "data", default, skip_serializing_if = "Option::is_none")]
pub data: Option<::std::string::String>,
#[serde(rename = "asl_compiler_id", default, skip_serializing_if = "Option::is_none")]
pub asl_compiler_id: Option<::std::string::String>,
#[serde(rename = "oem_rev", default, skip_serializing_if = "Option::is_none")]
pub oem_rev: Option<u32>,
#[serde(rename = "sig", default, skip_serializing_if = "Option::is_none")]
pub sig: Option<::std::string::String>,
#[serde(rename = "rev", default, skip_serializing_if = "Option::is_none")]
pub rev: Option<u8>,
#[serde(rename = "file", default, skip_serializing_if = "Option::is_none")]
pub file: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MachineInfo {
#[serde(rename = "alias", default, skip_serializing_if = "Option::is_none")]
pub alias: Option<::std::string::String>,
#[serde(rename = "is-default", default, skip_serializing_if = "Option::is_none")]
pub is_default: Option<bool>,
#[serde(rename = "default-cpu-type", default, skip_serializing_if = "Option::is_none")]
pub default_cpu_type: Option<::std::string::String>,
#[serde(rename = "numa-mem-supported")]
pub numa_mem_supported: bool,
#[serde(rename = "hotpluggable-cpus")]
pub hotpluggable_cpus: bool,
#[serde(rename = "deprecated")]
pub deprecated: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "cpu-max")]
pub cpu_max: isize,
#[serde(rename = "default-ram-id", default, skip_serializing_if = "Option::is_none")]
pub default_ram_id: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TPMPassthroughOptions {
#[serde(rename = "cancel-path", default, skip_serializing_if = "Option::is_none")]
pub cancel_path: Option<::std::string::String>,
#[serde(rename = "path", default, skip_serializing_if = "Option::is_none")]
pub path: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInstanceProperties {
#[serde(rename = "thread-id", default, skip_serializing_if = "Option::is_none")]
pub thread_id: Option<isize>,
#[serde(rename = "core-id", default, skip_serializing_if = "Option::is_none")]
pub core_id: Option<isize>,
#[serde(rename = "socket-id", default, skip_serializing_if = "Option::is_none")]
pub socket_id: Option<isize>,
#[serde(rename = "node-id", default, skip_serializing_if = "Option::is_none")]
pub node_id: Option<isize>,
#[serde(rename = "die-id", default, skip_serializing_if = "Option::is_none")]
pub die_id: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageInfoSpecificQCow2 {
#[serde(rename = "compression-type")]
pub compression_type: Qcow2CompressionType,
#[serde(rename = "extended-l2", default, skip_serializing_if = "Option::is_none")]
pub extended_l2: Option<bool>,
#[serde(rename = "encrypt", default, skip_serializing_if = "Option::is_none")]
pub encrypt: Option<ImageInfoSpecificQCow2Encryption>,
#[serde(rename = "compat")]
pub compat: ::std::string::String,
#[serde(rename = "data-file", default, skip_serializing_if = "Option::is_none")]
pub data_file: Option<::std::string::String>,
#[serde(rename = "lazy-refcounts", default, skip_serializing_if = "Option::is_none")]
pub lazy_refcounts: Option<bool>,
#[serde(rename = "bitmaps", default, skip_serializing_if = "Option::is_none")]
pub bitmaps: Option<Vec<Qcow2BitmapInfo>>,
#[serde(rename = "corrupt", default, skip_serializing_if = "Option::is_none")]
pub corrupt: Option<bool>,
#[serde(rename = "data-file-raw", default, skip_serializing_if = "Option::is_none")]
pub data_file_raw: Option<bool>,
#[serde(rename = "refcount-bits")]
pub refcount_bits: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReplicationStatus {
#[serde(rename = "desc", default, skip_serializing_if = "Option::is_none")]
pub desc: Option<::std::string::String>,
#[serde(rename = "error")]
pub error: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsFile {
#[serde(rename = "drop-cache", default, skip_serializing_if = "Option::is_none")]
pub drop_cache: Option<bool>,
#[serde(rename = "locking", default, skip_serializing_if = "Option::is_none")]
pub locking: Option<OnOffAuto>,
#[serde(rename = "x-check-cache-dropped", default, skip_serializing_if = "Option::is_none")]
pub x_check_cache_dropped: Option<bool>,
#[serde(rename = "aio", default, skip_serializing_if = "Option::is_none")]
pub aio: Option<BlockdevAioOptions>,
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "pr-manager", default, skip_serializing_if = "Option::is_none")]
pub pr_manager: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevAlsaPerDirectionOptions {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: AudiodevPerDirectionOptions,
#[serde(rename = "period-length", default, skip_serializing_if = "Option::is_none")]
pub period_length: Option<u32>,
#[serde(rename = "dev", default, skip_serializing_if = "Option::is_none")]
pub dev: Option<::std::string::String>,
#[serde(rename = "try-poll", default, skip_serializing_if = "Option::is_none")]
pub try_poll: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThrottleLimits {
#[serde(rename = "bps-total", default, skip_serializing_if = "Option::is_none")]
pub bps_total: Option<isize>,
#[serde(rename = "bps-write", default, skip_serializing_if = "Option::is_none")]
pub bps_write: Option<isize>,
#[serde(rename = "bps-write-max", default, skip_serializing_if = "Option::is_none")]
pub bps_write_max: Option<isize>,
#[serde(rename = "iops-write-max-length", default, skip_serializing_if = "Option::is_none")]
pub iops_write_max_length: Option<isize>,
#[serde(rename = "iops-total-max", default, skip_serializing_if = "Option::is_none")]
pub iops_total_max: Option<isize>,
#[serde(rename = "bps-write-max-length", default, skip_serializing_if = "Option::is_none")]
pub bps_write_max_length: Option<isize>,
#[serde(rename = "iops-total", default, skip_serializing_if = "Option::is_none")]
pub iops_total: Option<isize>,
#[serde(rename = "iops-read-max", default, skip_serializing_if = "Option::is_none")]
pub iops_read_max: Option<isize>,
#[serde(rename = "iops-read", default, skip_serializing_if = "Option::is_none")]
pub iops_read: Option<isize>,
#[serde(rename = "bps-read", default, skip_serializing_if = "Option::is_none")]
pub bps_read: Option<isize>,
#[serde(rename = "iops-total-max-length", default, skip_serializing_if = "Option::is_none")]
pub iops_total_max_length: Option<isize>,
#[serde(rename = "iops-write", default, skip_serializing_if = "Option::is_none")]
pub iops_write: Option<isize>,
#[serde(rename = "bps-total-max-length", default, skip_serializing_if = "Option::is_none")]
pub bps_total_max_length: Option<isize>,
#[serde(rename = "bps-read-max", default, skip_serializing_if = "Option::is_none")]
pub bps_read_max: Option<isize>,
#[serde(rename = "bps-read-max-length", default, skip_serializing_if = "Option::is_none")]
pub bps_read_max_length: Option<isize>,
#[serde(rename = "iops-size", default, skip_serializing_if = "Option::is_none")]
pub iops_size: Option<isize>,
#[serde(rename = "iops-write-max", default, skip_serializing_if = "Option::is_none")]
pub iops_write_max: Option<isize>,
#[serde(rename = "iops-read-max-length", default, skip_serializing_if = "Option::is_none")]
pub iops_read_max_length: Option<isize>,
#[serde(rename = "bps-total-max", default, skip_serializing_if = "Option::is_none")]
pub bps_total_max: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciDeviceClass {
#[serde(rename = "class")]
pub class: isize,
#[serde(rename = "desc", default, skip_serializing_if = "Option::is_none")]
pub desc: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsSheepdog {
#[serde(rename = "object-size", default, skip_serializing_if = "Option::is_none")]
pub object_size: Option<usize>,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "location")]
pub location: BlockdevOptionsSheepdog,
#[serde(rename = "backing-file", default, skip_serializing_if = "Option::is_none")]
pub backing_file: Option<::std::string::String>,
#[serde(rename = "preallocation", default, skip_serializing_if = "Option::is_none")]
pub preallocation: Option<PreallocMode>,
#[serde(rename = "redundancy", default, skip_serializing_if = "Option::is_none")]
pub redundancy: Option<SheepdogRedundancy>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInfoRISCV {
#[serde(rename = "pc")]
pub pc: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockLatencyHistogramInfo {
#[serde(rename = "boundaries")]
pub boundaries: Vec<u64>,
#[serde(rename = "bins")]
pub bins: Vec<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDeviceStats {
#[serde(rename = "invalid_flush_operations")]
pub invalid_flush_operations: isize,
#[serde(rename = "failed_wr_operations")]
pub failed_wr_operations: isize,
#[serde(rename = "unmap_merged")]
pub unmap_merged: isize,
#[serde(rename = "invalid_wr_operations")]
pub invalid_wr_operations: isize,
#[serde(rename = "wr_latency_histogram", default, skip_serializing_if = "Option::is_none")]
pub wr_latency_histogram: Option<BlockLatencyHistogramInfo>,
#[serde(rename = "flush_latency_histogram", default, skip_serializing_if = "Option::is_none")]
pub flush_latency_histogram: Option<BlockLatencyHistogramInfo>,
#[serde(rename = "wr_highest_offset")]
pub wr_highest_offset: isize,
#[serde(rename = "account_failed")]
pub account_failed: bool,
#[serde(rename = "wr_bytes")]
pub wr_bytes: isize,
#[serde(rename = "rd_total_time_ns")]
pub rd_total_time_ns: isize,
#[serde(rename = "unmap_total_time_ns")]
pub unmap_total_time_ns: isize,
#[serde(rename = "invalid_rd_operations")]
pub invalid_rd_operations: isize,
#[serde(rename = "invalid_unmap_operations")]
pub invalid_unmap_operations: isize,
#[serde(rename = "flush_total_time_ns")]
pub flush_total_time_ns: isize,
#[serde(rename = "timed_stats")]
pub timed_stats: Vec<BlockDeviceTimedStats>,
#[serde(rename = "rd_latency_histogram", default, skip_serializing_if = "Option::is_none")]
pub rd_latency_histogram: Option<BlockLatencyHistogramInfo>,
#[serde(rename = "failed_rd_operations")]
pub failed_rd_operations: isize,
#[serde(rename = "rd_operations")]
pub rd_operations: isize,
#[serde(rename = "account_invalid")]
pub account_invalid: bool,
#[serde(rename = "wr_total_time_ns")]
pub wr_total_time_ns: isize,
#[serde(rename = "failed_unmap_operations")]
pub failed_unmap_operations: isize,
#[serde(rename = "rd_bytes")]
pub rd_bytes: isize,
#[serde(rename = "failed_flush_operations")]
pub failed_flush_operations: isize,
#[serde(rename = "idle_time_ns", default, skip_serializing_if = "Option::is_none")]
pub idle_time_ns: Option<isize>,
#[serde(rename = "unmap_bytes")]
pub unmap_bytes: isize,
#[serde(rename = "wr_operations")]
pub wr_operations: isize,
#[serde(rename = "rd_merged")]
pub rd_merged: isize,
#[serde(rename = "unmap_operations")]
pub unmap_operations: isize,
#[serde(rename = "wr_merged")]
pub wr_merged: isize,
#[serde(rename = "flush_operations")]
pub flush_operations: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevHostdev {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "device")]
pub device: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VncClientInfo {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: VncBasicInfo,
#[serde(rename = "x509_dname", default, skip_serializing_if = "Option::is_none")]
pub x509_dname: Option<::std::string::String>,
#[serde(rename = "sasl_username", default, skip_serializing_if = "Option::is_none")]
pub sasl_username: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VsockSocketAddress {
#[serde(rename = "cid")]
pub cid: ::std::string::String,
#[serde(rename = "port")]
pub port: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IOThreadInfo {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "poll-max-ns")]
pub poll_max_ns: isize,
#[serde(rename = "thread-id")]
pub thread_id: isize,
#[serde(rename = "poll-grow")]
pub poll_grow: isize,
#[serde(rename = "poll-shrink")]
pub poll_shrink: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RxFilterInfo {
#[serde(rename = "vlan")]
pub vlan: RxState,
#[serde(rename = "multicast-overflow")]
pub multicast_overflow: bool,
#[serde(rename = "vlan-table")]
pub vlan_table: Vec<isize>,
#[serde(rename = "unicast")]
pub unicast: RxState,
#[serde(rename = "promiscuous")]
pub promiscuous: bool,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "broadcast-allowed")]
pub broadcast_allowed: bool,
#[serde(rename = "main-mac")]
pub main_mac: ::std::string::String,
#[serde(rename = "unicast-table")]
pub unicast_table: Vec<::std::string::String>,
#[serde(rename = "unicast-overflow")]
pub unicast_overflow: bool,
#[serde(rename = "multicast-table")]
pub multicast_table: Vec<::std::string::String>,
#[serde(rename = "multicast")]
pub multicast: RxState,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevPerDirectionOptions {
#[serde(rename = "channels", default, skip_serializing_if = "Option::is_none")]
pub channels: Option<u32>,
#[serde(rename = "voices", default, skip_serializing_if = "Option::is_none")]
pub voices: Option<u32>,
#[serde(rename = "fixed-settings", default, skip_serializing_if = "Option::is_none")]
pub fixed_settings: Option<bool>,
#[serde(rename = "buffer-length", default, skip_serializing_if = "Option::is_none")]
pub buffer_length: Option<u32>,
#[serde(rename = "frequency", default, skip_serializing_if = "Option::is_none")]
pub frequency: Option<u32>,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<AudioFormat>,
#[serde(rename = "mixing-engine", default, skip_serializing_if = "Option::is_none")]
pub mixing_engine: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciMemoryRegion {
#[serde(rename = "size")]
pub size: isize,
#[serde(rename = "address")]
pub address: isize,
#[serde(rename = "prefetch", default, skip_serializing_if = "Option::is_none")]
pub prefetch: Option<bool>,
#[serde(rename = "mem_type_64", default, skip_serializing_if = "Option::is_none")]
pub mem_type_64: Option<bool>,
#[serde(rename = "bar")]
pub bar: isize,
#[serde(rename = "type")]
pub type_: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsVVFAT {
#[serde(rename = "dir")]
pub dir: ::std::string::String,
#[serde(rename = "label", default, skip_serializing_if = "Option::is_none")]
pub label: Option<::std::string::String>,
#[serde(rename = "fat-type", default, skip_serializing_if = "Option::is_none")]
pub fat_type: Option<isize>,
#[serde(rename = "floppy", default, skip_serializing_if = "Option::is_none")]
pub floppy: Option<bool>,
#[serde(rename = "rw", default, skip_serializing_if = "Option::is_none")]
pub rw: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NumaDistOptions {
#[serde(rename = "src")]
pub src: u16,
#[serde(rename = "dst")]
pub dst: u16,
#[serde(rename = "val")]
pub val: u8,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsBlkdebug {
#[serde(rename = "inject-error", default, skip_serializing_if = "Option::is_none")]
pub inject_error: Option<Vec<BlkdebugInjectErrorOptions>>,
#[serde(rename = "image")]
pub image: BlockdevRef,
#[serde(rename = "opt-discard", default, skip_serializing_if = "Option::is_none")]
pub opt_discard: Option<i32>,
#[serde(rename = "align", default, skip_serializing_if = "Option::is_none")]
pub align: Option<isize>,
#[serde(rename = "max-write-zero", default, skip_serializing_if = "Option::is_none")]
pub max_write_zero: Option<i32>,
#[serde(rename = "config", default, skip_serializing_if = "Option::is_none")]
pub config: Option<::std::string::String>,
#[serde(rename = "max-transfer", default, skip_serializing_if = "Option::is_none")]
pub max_transfer: Option<i32>,
#[serde(rename = "max-discard", default, skip_serializing_if = "Option::is_none")]
pub max_discard: Option<i32>,
#[serde(rename = "unshare-child-perms", default, skip_serializing_if = "Option::is_none")]
pub unshare_child_perms: Option<Vec<BlockPermission>>,
#[serde(rename = "set-state", default, skip_serializing_if = "Option::is_none")]
pub set_state: Option<Vec<BlkdebugSetStateOptions>>,
#[serde(rename = "opt-write-zero", default, skip_serializing_if = "Option::is_none")]
pub opt_write_zero: Option<i32>,
#[serde(rename = "take-child-perms", default, skip_serializing_if = "Option::is_none")]
pub take_child_perms: Option<Vec<BlockPermission>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpiceChannel {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: SpiceBasicInfo,
#[serde(rename = "connection-id")]
pub connection_id: isize,
#[serde(rename = "channel-id")]
pub channel_id: isize,
#[serde(rename = "tls")]
pub tls: bool,
#[serde(rename = "channel-type")]
pub channel_type: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirtyRateInfo {
#[serde(rename = "status")]
pub status: DirtyRateStatus,
#[serde(rename = "calc-time")]
pub calc_time: i64,
#[serde(rename = "dirty-rate", default, skip_serializing_if = "Option::is_none")]
pub dirty_rate: Option<i64>,
#[serde(rename = "start-time")]
pub start_time: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommandLineOptionInfo {
#[serde(rename = "parameters")]
pub parameters: Vec<CommandLineParameterInfo>,
#[serde(rename = "option")]
pub option: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsQuorum {
#[serde(rename = "vote-threshold")]
pub vote_threshold: isize,
#[serde(rename = "blkverify", default, skip_serializing_if = "Option::is_none")]
pub blkverify: Option<bool>,
#[serde(rename = "read-pattern", default, skip_serializing_if = "Option::is_none")]
pub read_pattern: Option<QuorumReadPattern>,
#[serde(rename = "rewrite-corrupted", default, skip_serializing_if = "Option::is_none")]
pub rewrite_corrupted: Option<bool>,
#[serde(rename = "children")]
pub children: Vec<BlockdevRef>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockExportInfo {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "type")]
pub type_: BlockExportType,
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
#[serde(rename = "shutting-down")]
pub shutting_down: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInfoTricore {
#[serde(rename = "PC")]
pub PC: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevUdp {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "local", default, skip_serializing_if = "Option::is_none")]
pub local: Option<SocketAddressLegacy>,
#[serde(rename = "remote")]
pub remote: SocketAddressLegacy,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageInfoSpecificQCow2EncryptionBase {
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SheepdogRedundancyErasureCoded {
#[serde(rename = "data-strips")]
pub data_strips: isize,
#[serde(rename = "parity-strips")]
pub parity_strips: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInfoPPC {
#[serde(rename = "nip")]
pub nip: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDirtyBitmapMerge {
#[serde(rename = "node")]
pub node: ::std::string::String,
#[serde(rename = "target")]
pub target: ::std::string::String,
#[serde(rename = "bitmaps")]
pub bitmaps: Vec<BlockDirtyBitmapMergeSource>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciBridgeInfo {
#[serde(rename = "devices", default, skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<PciDeviceInfo>>,
#[serde(rename = "bus")]
pub bus: PciBusInfo,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NbdServerAddOptions {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockExportOptionsNbdBase,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "bitmap", default, skip_serializing_if = "Option::is_none")]
pub bitmap: Option<::std::string::String>,
#[serde(rename = "writable", default, skip_serializing_if = "Option::is_none")]
pub writable: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevSocketOptions {
#[serde(rename = "listen", default, skip_serializing_if = "Option::is_none")]
pub listen: Option<::std::string::String>,
#[serde(rename = "mcast", default, skip_serializing_if = "Option::is_none")]
pub mcast: Option<::std::string::String>,
#[serde(rename = "localaddr", default, skip_serializing_if = "Option::is_none")]
pub localaddr: Option<::std::string::String>,
#[serde(rename = "udp", default, skip_serializing_if = "Option::is_none")]
pub udp: Option<::std::string::String>,
#[serde(rename = "connect", default, skip_serializing_if = "Option::is_none")]
pub connect: Option<::std::string::String>,
#[serde(rename = "fd", default, skip_serializing_if = "Option::is_none")]
pub fd: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoAlternate {
#[serde(rename = "members")]
pub members: Vec<SchemaInfoAlternateMember>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsSsh {
#[serde(rename = "location")]
pub location: BlockdevOptionsSsh,
#[serde(rename = "size")]
pub size: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsBlkverify {
#[serde(rename = "test")]
pub test: BlockdevRef,
#[serde(rename = "raw")]
pub raw: BlockdevRef,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoObjectVariant {
#[serde(rename = "type")]
pub type_: ::std::string::String,
#[serde(rename = "case")]
pub case: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NameInfo {
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsBlkreplay {
#[serde(rename = "image")]
pub image: BlockdevRef,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VfioStats {
#[serde(rename = "transferred")]
pub transferred: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsLUKS {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsGenericFormat,
#[serde(rename = "key-secret", default, skip_serializing_if = "Option::is_none")]
pub key_secret: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SheepdogRedundancyFull {
#[serde(rename = "copies")]
pub copies: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsSsh {
#[serde(rename = "user", default, skip_serializing_if = "Option::is_none")]
pub user: Option<::std::string::String>,
#[serde(rename = "host-key-check", default, skip_serializing_if = "Option::is_none")]
pub host_key_check: Option<SshHostKeyCheck>,
#[serde(rename = "path")]
pub path: ::std::string::String,
#[serde(rename = "server")]
pub server: InetSocketAddress,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockStatsSpecificFile {
#[serde(rename = "discard-bytes-ok")]
pub discard_bytes_ok: u64,
#[serde(rename = "discard-nb-ok")]
pub discard_nb_ok: u64,
#[serde(rename = "discard-nb-failed")]
pub discard_nb_failed: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevHubPortOptions {
#[serde(rename = "hubid")]
pub hubid: i32,
#[serde(rename = "netdev", default, skip_serializing_if = "Option::is_none")]
pub netdev: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UuidInfo {
#[serde(rename = "UUID")]
pub UUID: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevCoreaudioOptions {
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevCoreaudioPerDirectionOptions>,
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevCoreaudioPerDirectionOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevPaPerDirectionOptions {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: AudiodevPerDirectionOptions,
#[serde(rename = "stream-name", default, skip_serializing_if = "Option::is_none")]
pub stream_name: Option<::std::string::String>,
#[serde(rename = "latency", default, skip_serializing_if = "Option::is_none")]
pub latency: Option<u32>,
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDirtyBitmapAdd {
#[serde(rename = "granularity", default, skip_serializing_if = "Option::is_none")]
pub granularity: Option<u32>,
#[serde(rename = "persistent", default, skip_serializing_if = "Option::is_none")]
pub persistent: Option<bool>,
#[serde(rename = "disabled", default, skip_serializing_if = "Option::is_none")]
pub disabled: Option<bool>,
#[serde(rename = "node")]
pub node: ::std::string::String,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VncServerInfo {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: VncBasicInfo,
#[serde(rename = "auth", default, skip_serializing_if = "Option::is_none")]
pub auth: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoEvent {
#[serde(rename = "arg-type")]
pub arg_type: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsVhdx {
#[serde(rename = "block-state-zero", default, skip_serializing_if = "Option::is_none")]
pub block_state_zero: Option<bool>,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "block-size", default, skip_serializing_if = "Option::is_none")]
pub block_size: Option<usize>,
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "subformat", default, skip_serializing_if = "Option::is_none")]
pub subformat: Option<BlockdevVhdxSubformat>,
#[serde(rename = "log-size", default, skip_serializing_if = "Option::is_none")]
pub log_size: Option<usize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpiceServerInfo {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: SpiceBasicInfo,
#[serde(rename = "auth", default, skip_serializing_if = "Option::is_none")]
pub auth: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NumaHmatLBOptions {
#[serde(rename = "bandwidth", default, skip_serializing_if = "Option::is_none")]
pub bandwidth: Option<usize>,
#[serde(rename = "data-type")]
pub data_type: HmatLBDataType,
#[serde(rename = "hierarchy")]
pub hierarchy: HmatLBMemoryHierarchy,
#[serde(rename = "target")]
pub target: u16,
#[serde(rename = "latency", default, skip_serializing_if = "Option::is_none")]
pub latency: Option<u64>,
#[serde(rename = "initiator")]
pub initiator: u16,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddfdInfo {
#[serde(rename = "fd")]
pub fd: isize,
#[serde(rename = "fdset-id")]
pub fdset_id: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DumpGuestMemoryCapability {
#[serde(rename = "formats")]
pub formats: Vec<DumpGuestMemoryFormat>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevTapOptions {
#[serde(rename = "vhost", default, skip_serializing_if = "Option::is_none")]
pub vhost: Option<bool>,
#[serde(rename = "vhostforce", default, skip_serializing_if = "Option::is_none")]
pub vhostforce: Option<bool>,
#[serde(rename = "helper", default, skip_serializing_if = "Option::is_none")]
pub helper: Option<::std::string::String>,
#[serde(rename = "sndbuf", default, skip_serializing_if = "Option::is_none")]
pub sndbuf: Option<usize>,
#[serde(rename = "br", default, skip_serializing_if = "Option::is_none")]
pub br: Option<::std::string::String>,
#[serde(rename = "vhostfds", default, skip_serializing_if = "Option::is_none")]
pub vhostfds: Option<::std::string::String>,
#[serde(rename = "queues", default, skip_serializing_if = "Option::is_none")]
pub queues: Option<u32>,
#[serde(rename = "script", default, skip_serializing_if = "Option::is_none")]
pub script: Option<::std::string::String>,
#[serde(rename = "vnet_hdr", default, skip_serializing_if = "Option::is_none")]
pub vnet_hdr: Option<bool>,
#[serde(rename = "downscript", default, skip_serializing_if = "Option::is_none")]
pub downscript: Option<::std::string::String>,
#[serde(rename = "fds", default, skip_serializing_if = "Option::is_none")]
pub fds: Option<::std::string::String>,
#[serde(rename = "poll-us", default, skip_serializing_if = "Option::is_none")]
pub poll_us: Option<u32>,
#[serde(rename = "ifname", default, skip_serializing_if = "Option::is_none")]
pub ifname: Option<::std::string::String>,
#[serde(rename = "vhostfd", default, skip_serializing_if = "Option::is_none")]
pub vhostfd: Option<::std::string::String>,
#[serde(rename = "fd", default, skip_serializing_if = "Option::is_none")]
pub fd: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockIOThrottle {
#[serde(rename = "iops_max", default, skip_serializing_if = "Option::is_none")]
pub iops_max: Option<isize>,
#[serde(rename = "iops_wr")]
pub iops_wr: isize,
#[serde(rename = "bps_wr_max_length", default, skip_serializing_if = "Option::is_none")]
pub bps_wr_max_length: Option<isize>,
#[serde(rename = "bps_wr")]
pub bps_wr: isize,
#[serde(rename = "iops_wr_max", default, skip_serializing_if = "Option::is_none")]
pub iops_wr_max: Option<isize>,
#[serde(rename = "bps_wr_max", default, skip_serializing_if = "Option::is_none")]
pub bps_wr_max: Option<isize>,
#[serde(rename = "bps_max_length", default, skip_serializing_if = "Option::is_none")]
pub bps_max_length: Option<isize>,
#[serde(rename = "iops_max_length", default, skip_serializing_if = "Option::is_none")]
pub iops_max_length: Option<isize>,
#[serde(rename = "bps")]
pub bps: isize,
#[serde(rename = "iops_rd")]
pub iops_rd: isize,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub device: Option<::std::string::String>,
#[serde(rename = "iops_wr_max_length", default, skip_serializing_if = "Option::is_none")]
pub iops_wr_max_length: Option<isize>,
#[serde(rename = "iops_rd_max", default, skip_serializing_if = "Option::is_none")]
pub iops_rd_max: Option<isize>,
#[serde(rename = "bps_rd")]
pub bps_rd: isize,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "bps_rd_max", default, skip_serializing_if = "Option::is_none")]
pub bps_rd_max: Option<isize>,
#[serde(rename = "iops")]
pub iops: isize,
#[serde(rename = "group", default, skip_serializing_if = "Option::is_none")]
pub group: Option<::std::string::String>,
#[serde(rename = "bps_max", default, skip_serializing_if = "Option::is_none")]
pub bps_max: Option<isize>,
#[serde(rename = "bps_rd_max_length", default, skip_serializing_if = "Option::is_none")]
pub bps_rd_max_length: Option<isize>,
#[serde(rename = "iops_size", default, skip_serializing_if = "Option::is_none")]
pub iops_size: Option<isize>,
#[serde(rename = "iops_rd_max_length", default, skip_serializing_if = "Option::is_none")]
pub iops_rd_max_length: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevCoreaudioPerDirectionOptions {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: AudiodevPerDirectionOptions,
#[serde(rename = "buffer-count", default, skip_serializing_if = "Option::is_none")]
pub buffer_count: Option<u32>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevDsoundOptions {
#[serde(rename = "latency", default, skip_serializing_if = "Option::is_none")]
pub latency: Option<u32>,
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevPerDirectionOptions>,
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevPerDirectionOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsIscsi {
#[serde(rename = "header-digest", default, skip_serializing_if = "Option::is_none")]
pub header_digest: Option<IscsiHeaderDigest>,
#[serde(rename = "initiator-name", default, skip_serializing_if = "Option::is_none")]
pub initiator_name: Option<::std::string::String>,
#[serde(rename = "timeout", default, skip_serializing_if = "Option::is_none")]
pub timeout: Option<isize>,
#[serde(rename = "transport")]
pub transport: IscsiTransport,
#[serde(rename = "user", default, skip_serializing_if = "Option::is_none")]
pub user: Option<::std::string::String>,
#[serde(rename = "portal")]
pub portal: ::std::string::String,
#[serde(rename = "target")]
pub target: ::std::string::String,
#[serde(rename = "password-secret", default, skip_serializing_if = "Option::is_none")]
pub password_secret: Option<::std::string::String>,
#[serde(rename = "lun", default, skip_serializing_if = "Option::is_none")]
pub lun: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsNfs {
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "location")]
pub location: BlockdevOptionsNfs,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevVhostUserOptions {
#[serde(rename = "queues", default, skip_serializing_if = "Option::is_none")]
pub queues: Option<isize>,
#[serde(rename = "chardev")]
pub chardev: ::std::string::String,
#[serde(rename = "vhostforce", default, skip_serializing_if = "Option::is_none")]
pub vhostforce: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VncBasicInfo {
#[serde(rename = "host")]
pub host: ::std::string::String,
#[serde(rename = "service")]
pub service: ::std::string::String,
#[serde(rename = "family")]
pub family: NetworkAddressFamily,
#[serde(rename = "websocket")]
pub websocket: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StatusInfo {
#[serde(rename = "status")]
pub status: RunState,
#[serde(rename = "singlestep")]
pub singlestep: bool,
#[serde(rename = "running")]
pub running: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RockerPort {
#[serde(rename = "enabled")]
pub enabled: bool,
#[serde(rename = "speed")]
pub speed: u32,
#[serde(rename = "duplex")]
pub duplex: RockerPortDuplex,
#[serde(rename = "autoneg")]
pub autoneg: RockerPortAutoneg,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "link-up")]
pub link_up: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FdsetInfo {
#[serde(rename = "fdset-id")]
pub fdset_id: isize,
#[serde(rename = "fds")]
pub fds: Vec<FdsetFdInfo>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoEnum {
#[serde(rename = "values")]
pub values: Vec<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuModelExpansionInfo {
#[serde(rename = "model")]
pub model: CpuModelInfo,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsParallels {
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "cluster-size", default, skip_serializing_if = "Option::is_none")]
pub cluster_size: Option<usize>,
#[serde(rename = "file")]
pub file: BlockdevRef,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsVpc {
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "subformat", default, skip_serializing_if = "Option::is_none")]
pub subformat: Option<BlockdevVpcSubformat>,
#[serde(rename = "force-size", default, skip_serializing_if = "Option::is_none")]
pub force_size: Option<bool>,
#[serde(rename = "size")]
pub size: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GICCapability {
#[serde(rename = "kernel")]
pub kernel: bool,
#[serde(rename = "version")]
pub version: isize,
#[serde(rename = "emulated")]
pub emulated: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlkdebugSetStateOptions {
#[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
pub state: Option<isize>,
#[serde(rename = "new_state")]
pub new_state: isize,
#[serde(rename = "event")]
pub event: BlkdebugEvent,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockInfo {
#[serde(rename = "removable")]
pub removable: bool,
#[serde(rename = "inserted", default, skip_serializing_if = "Option::is_none")]
pub inserted: Option<BlockDeviceInfo>,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "type")]
pub type_: ::std::string::String,
#[serde(rename = "qdev", default, skip_serializing_if = "Option::is_none")]
pub qdev: Option<::std::string::String>,
#[serde(rename = "tray_open", default, skip_serializing_if = "Option::is_none")]
pub tray_open: Option<bool>,
#[serde(rename = "io-status", default, skip_serializing_if = "Option::is_none")]
pub io_status: Option<BlockDeviceIoStatus>,
#[serde(rename = "locked")]
pub locked: bool,
#[serde(rename = "dirty-bitmaps", default, skip_serializing_if = "Option::is_none")] #[deprecated]
pub dirty_bitmaps: Option<Vec<BlockDirtyInfo>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DisplayGTK {
#[serde(rename = "zoom-to-fit", default, skip_serializing_if = "Option::is_none")]
pub zoom_to_fit: Option<bool>,
#[serde(rename = "grab-on-hover", default, skip_serializing_if = "Option::is_none")]
pub grab_on_hover: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevGenericOptions {
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevPerDirectionOptions>,
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevPerDirectionOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevAmendOptionsQcow2 {
#[serde(rename = "encrypt", default, skip_serializing_if = "Option::is_none")]
pub encrypt: Option<QCryptoBlockAmendOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BitmapMigrationNodeAlias {
#[serde(rename = "bitmaps")]
pub bitmaps: Vec<BitmapMigrationBitmapAlias>,
#[serde(rename = "node-name")]
pub node_name: ::std::string::String,
#[serde(rename = "alias")]
pub alias: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NbdServerOptions {
#[serde(rename = "addr")]
pub addr: SocketAddress,
#[serde(rename = "max-connections", default, skip_serializing_if = "Option::is_none")]
pub max_connections: Option<u32>,
#[serde(rename = "tls-creds", default, skip_serializing_if = "Option::is_none")]
pub tls_creds: Option<::std::string::String>,
#[serde(rename = "tls-authz", default, skip_serializing_if = "Option::is_none")]
pub tls_authz: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockDeviceTimedStats {
#[serde(rename = "avg_rd_latency_ns")]
pub avg_rd_latency_ns: isize,
#[serde(rename = "avg_wr_queue_depth")]
pub avg_wr_queue_depth: f64,
#[serde(rename = "max_rd_latency_ns")]
pub max_rd_latency_ns: isize,
#[serde(rename = "max_flush_latency_ns")]
pub max_flush_latency_ns: isize,
#[serde(rename = "max_wr_latency_ns")]
pub max_wr_latency_ns: isize,
#[serde(rename = "min_rd_latency_ns")]
pub min_rd_latency_ns: isize,
#[serde(rename = "avg_flush_latency_ns")]
pub avg_flush_latency_ns: isize,
#[serde(rename = "avg_rd_queue_depth")]
pub avg_rd_queue_depth: f64,
#[serde(rename = "min_wr_latency_ns")]
pub min_wr_latency_ns: isize,
#[serde(rename = "avg_wr_latency_ns")]
pub avg_wr_latency_ns: isize,
#[serde(rename = "interval_length")]
pub interval_length: isize,
#[serde(rename = "min_flush_latency_ns")]
pub min_flush_latency_ns: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevCreateOptionsVdi {
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "preallocation", default, skip_serializing_if = "Option::is_none")]
pub preallocation: Option<PreallocMode>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryFailureFlags {
#[serde(rename = "action-required")]
pub action_required: bool,
#[serde(rename = "recursive")]
pub recursive: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Memdev {
#[serde(rename = "dump")]
pub dump: bool,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "prealloc")]
pub prealloc: bool,
#[serde(rename = "host-nodes")]
pub host_nodes: Vec<u16>,
#[serde(rename = "policy")]
pub policy: HostMemPolicy,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
#[serde(rename = "merge")]
pub merge: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsBlklogwrites {
#[serde(rename = "log-super-update-interval", default, skip_serializing_if = "Option::is_none")]
pub log_super_update_interval: Option<u64>,
#[serde(rename = "log-sector-size", default, skip_serializing_if = "Option::is_none")]
pub log_sector_size: Option<u32>,
#[serde(rename = "log")]
pub log: BlockdevRef,
#[serde(rename = "file")]
pub file: BlockdevRef,
#[serde(rename = "log-append", default, skip_serializing_if = "Option::is_none")]
pub log_append: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsGenericFormat {
#[serde(rename = "file")]
pub file: BlockdevRef,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DisplayCurses {
#[serde(rename = "charset", default, skip_serializing_if = "Option::is_none")]
pub charset: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfoObject {
#[serde(rename = "variants", default, skip_serializing_if = "Option::is_none")]
pub variants: Option<Vec<SchemaInfoObjectVariant>>,
#[serde(rename = "tag", default, skip_serializing_if = "Option::is_none")]
pub tag: Option<::std::string::String>,
#[serde(rename = "members")]
pub members: Vec<SchemaInfoObjectMember>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompressionStats {
#[serde(rename = "compression-rate")]
pub compression_rate: f64,
#[serde(rename = "pages")]
pub pages: isize,
#[serde(rename = "busy")]
pub busy: isize,
#[serde(rename = "busy-rate")]
pub busy_rate: f64,
#[serde(rename = "compressed-size")]
pub compressed_size: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciInfo {
#[serde(rename = "bus")]
pub bus: isize,
#[serde(rename = "devices")]
pub devices: Vec<PciDeviceInfo>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetLegacyNicOptions {
#[serde(rename = "model", default, skip_serializing_if = "Option::is_none")]
pub model: Option<::std::string::String>,
#[serde(rename = "netdev", default, skip_serializing_if = "Option::is_none")]
pub netdev: Option<::std::string::String>,
#[serde(rename = "macaddr", default, skip_serializing_if = "Option::is_none")]
pub macaddr: Option<::std::string::String>,
#[serde(rename = "vectors", default, skip_serializing_if = "Option::is_none")]
pub vectors: Option<u32>,
#[serde(rename = "addr", default, skip_serializing_if = "Option::is_none")]
pub addr: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockStats {
#[serde(rename = "parent", default, skip_serializing_if = "Option::is_none")]
pub parent: Option<Box<BlockStats>>,
#[serde(rename = "backing", default, skip_serializing_if = "Option::is_none")]
pub backing: Option<Box<BlockStats>>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
#[serde(rename = "qdev", default, skip_serializing_if = "Option::is_none")]
pub qdev: Option<::std::string::String>,
#[serde(rename = "stats")]
pub stats: BlockDeviceStats,
#[serde(rename = "driver-specific", default, skip_serializing_if = "Option::is_none")]
pub driver_specific: Option<BlockStatsSpecific>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuInfoMIPS {
#[serde(rename = "PC")]
pub PC: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsCurlHttp {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsCurlBase,
#[serde(rename = "cookie", default, skip_serializing_if = "Option::is_none")]
pub cookie: Option<::std::string::String>,
#[serde(rename = "cookie-secret", default, skip_serializing_if = "Option::is_none")]
pub cookie_secret: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsRaw {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: BlockdevOptionsGenericFormat,
#[serde(rename = "offset", default, skip_serializing_if = "Option::is_none")]
pub offset: Option<isize>,
#[serde(rename = "size", default, skip_serializing_if = "Option::is_none")]
pub size: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockOptionsBase {
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockExportOptionsVhostUserBlk {
#[serde(rename = "addr")]
pub addr: SocketAddress,
#[serde(rename = "logical-block-size", default, skip_serializing_if = "Option::is_none")]
pub logical_block_size: Option<usize>,
#[serde(rename = "num-queues", default, skip_serializing_if = "Option::is_none")]
pub num_queues: Option<u16>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriveMirror {
#[serde(rename = "unmap", default, skip_serializing_if = "Option::is_none")]
pub unmap: Option<bool>,
#[serde(rename = "copy-mode", default, skip_serializing_if = "Option::is_none")]
pub copy_mode: Option<MirrorCopyMode>,
#[serde(rename = "format", default, skip_serializing_if = "Option::is_none")]
pub format: Option<::std::string::String>,
#[serde(rename = "replaces", default, skip_serializing_if = "Option::is_none")]
pub replaces: Option<::std::string::String>,
#[serde(rename = "buf-size", default, skip_serializing_if = "Option::is_none")]
pub buf_size: Option<isize>,
#[serde(rename = "auto-finalize", default, skip_serializing_if = "Option::is_none")]
pub auto_finalize: Option<bool>,
#[serde(rename = "target")]
pub target: ::std::string::String,
#[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
pub speed: Option<isize>,
#[serde(rename = "sync")]
pub sync: MirrorSyncMode,
#[serde(rename = "auto-dismiss", default, skip_serializing_if = "Option::is_none")]
pub auto_dismiss: Option<bool>,
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<NewImageMode>,
#[serde(rename = "node-name", default, skip_serializing_if = "Option::is_none")]
pub node_name: Option<::std::string::String>,
#[serde(rename = "job-id", default, skip_serializing_if = "Option::is_none")]
pub job_id: Option<::std::string::String>,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "granularity", default, skip_serializing_if = "Option::is_none")]
pub granularity: Option<u32>,
#[serde(rename = "on-source-error", default, skip_serializing_if = "Option::is_none")]
pub on_source_error: Option<BlockdevOnError>,
#[serde(rename = "on-target-error", default, skip_serializing_if = "Option::is_none")]
pub on_target_error: Option<BlockdevOnError>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockJobInfo {
#[serde(rename = "type")]
pub type_: ::std::string::String,
#[serde(rename = "io-status")]
pub io_status: BlockDeviceIoStatus,
#[serde(rename = "paused")]
pub paused: bool,
#[serde(rename = "status")]
pub status: JobStatus,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "ready")]
pub ready: bool,
#[serde(rename = "auto-dismiss")]
pub auto_dismiss: bool,
#[serde(rename = "auto-finalize")]
pub auto_finalize: bool,
#[serde(rename = "offset")]
pub offset: isize,
#[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
pub error: Option<::std::string::String>,
#[serde(rename = "speed")]
pub speed: isize,
#[serde(rename = "busy")]
pub busy: bool,
#[serde(rename = "len")]
pub len: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevRingbuf {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "size", default, skip_serializing_if = "Option::is_none")]
pub size: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PRManagerInfo {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "connected")]
pub connected: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TPMEmulatorOptions {
#[serde(rename = "chardev")]
pub chardev: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuModelInfo {
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "props", default, skip_serializing_if = "Option::is_none")]
pub props: Option<::qapi_spec::Dictionary>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevNetmapOptions {
#[serde(rename = "devname", default, skip_serializing_if = "Option::is_none")]
pub devname: Option<::std::string::String>,
#[serde(rename = "ifname")]
pub ifname: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageInfo {
#[serde(rename = "backing-image", default, skip_serializing_if = "Option::is_none")]
pub backing_image: Option<Box<ImageInfo>>,
#[serde(rename = "format-specific", default, skip_serializing_if = "Option::is_none")]
pub format_specific: Option<ImageInfoSpecific>,
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "format")]
pub format: ::std::string::String,
#[serde(rename = "compressed", default, skip_serializing_if = "Option::is_none")]
pub compressed: Option<bool>,
#[serde(rename = "cluster-size", default, skip_serializing_if = "Option::is_none")]
pub cluster_size: Option<isize>,
#[serde(rename = "dirty-flag", default, skip_serializing_if = "Option::is_none")]
pub dirty_flag: Option<bool>,
#[serde(rename = "actual-size", default, skip_serializing_if = "Option::is_none")]
pub actual_size: Option<isize>,
#[serde(rename = "backing-filename", default, skip_serializing_if = "Option::is_none")]
pub backing_filename: Option<::std::string::String>,
#[serde(rename = "full-backing-filename", default, skip_serializing_if = "Option::is_none")]
pub full_backing_filename: Option<::std::string::String>,
#[serde(rename = "encrypted", default, skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "backing-filename-format", default, skip_serializing_if = "Option::is_none")]
pub backing_filename_format: Option<::std::string::String>,
#[serde(rename = "virtual-size")]
pub virtual_size: isize,
#[serde(rename = "snapshots", default, skip_serializing_if = "Option::is_none")]
pub snapshots: Option<Vec<SnapshotInfo>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockStatsSpecificNvme {
#[serde(rename = "aligned-accesses")]
pub aligned_accesses: u64,
#[serde(rename = "unaligned-accesses")]
pub unaligned_accesses: u64,
#[serde(rename = "completion-errors")]
pub completion_errors: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MigrationParameters {
#[serde(rename = "xbzrle-cache-size", default, skip_serializing_if = "Option::is_none")]
pub xbzrle_cache_size: Option<usize>,
#[serde(rename = "multifd-compression", default, skip_serializing_if = "Option::is_none")]
pub multifd_compression: Option<MultiFDCompression>,
#[serde(rename = "multifd-channels", default, skip_serializing_if = "Option::is_none")]
pub multifd_channels: Option<u8>,
#[serde(rename = "multifd-zstd-level", default, skip_serializing_if = "Option::is_none")]
pub multifd_zstd_level: Option<u8>,
#[serde(rename = "compress-threads", default, skip_serializing_if = "Option::is_none")]
pub compress_threads: Option<u8>,
#[serde(rename = "announce-max", default, skip_serializing_if = "Option::is_none")]
pub announce_max: Option<usize>,
#[serde(rename = "x-checkpoint-delay", default, skip_serializing_if = "Option::is_none")]
pub x_checkpoint_delay: Option<u32>,
#[serde(rename = "max-bandwidth", default, skip_serializing_if = "Option::is_none")]
pub max_bandwidth: Option<usize>,
#[serde(rename = "max-postcopy-bandwidth", default, skip_serializing_if = "Option::is_none")]
pub max_postcopy_bandwidth: Option<usize>,
#[serde(rename = "block-incremental", default, skip_serializing_if = "Option::is_none")]
pub block_incremental: Option<bool>,
#[serde(rename = "cpu-throttle-initial", default, skip_serializing_if = "Option::is_none")]
pub cpu_throttle_initial: Option<u8>,
#[serde(rename = "announce-initial", default, skip_serializing_if = "Option::is_none")]
pub announce_initial: Option<usize>,
#[serde(rename = "compress-level", default, skip_serializing_if = "Option::is_none")]
pub compress_level: Option<u8>,
#[serde(rename = "tls-creds", default, skip_serializing_if = "Option::is_none")]
pub tls_creds: Option<::std::string::String>,
#[serde(rename = "downtime-limit", default, skip_serializing_if = "Option::is_none")]
pub downtime_limit: Option<u64>,
#[serde(rename = "max-cpu-throttle", default, skip_serializing_if = "Option::is_none")]
pub max_cpu_throttle: Option<u8>,
#[serde(rename = "announce-step", default, skip_serializing_if = "Option::is_none")]
pub announce_step: Option<usize>,
#[serde(rename = "decompress-threads", default, skip_serializing_if = "Option::is_none")]
pub decompress_threads: Option<u8>,
#[serde(rename = "cpu-throttle-increment", default, skip_serializing_if = "Option::is_none")]
pub cpu_throttle_increment: Option<u8>,
#[serde(rename = "tls-authz", default, skip_serializing_if = "Option::is_none")]
pub tls_authz: Option<::std::string::String>,
#[serde(rename = "tls-hostname", default, skip_serializing_if = "Option::is_none")]
pub tls_hostname: Option<::std::string::String>,
#[serde(rename = "compress-wait-thread", default, skip_serializing_if = "Option::is_none")]
pub compress_wait_thread: Option<bool>,
#[serde(rename = "announce-rounds", default, skip_serializing_if = "Option::is_none")]
pub announce_rounds: Option<usize>,
#[serde(rename = "throttle-trigger-threshold", default, skip_serializing_if = "Option::is_none")]
pub throttle_trigger_threshold: Option<u8>,
#[serde(rename = "cpu-throttle-tailslow", default, skip_serializing_if = "Option::is_none")]
pub cpu_throttle_tailslow: Option<bool>,
#[serde(rename = "multifd-zlib-level", default, skip_serializing_if = "Option::is_none")]
pub multifd_zlib_level: Option<u8>,
#[serde(rename = "block-bitmap-mapping", default, skip_serializing_if = "Option::is_none")]
pub block_bitmap_mapping: Option<Vec<BitmapMigrationNodeAlias>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NFSServer {
#[serde(rename = "host")]
pub host: ::std::string::String,
#[serde(rename = "type")]
pub type_: NFSTransport,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageCheck {
#[serde(rename = "format")]
pub format: ::std::string::String,
#[serde(rename = "leaks-fixed", default, skip_serializing_if = "Option::is_none")]
pub leaks_fixed: Option<isize>,
#[serde(rename = "compressed-clusters", default, skip_serializing_if = "Option::is_none")]
pub compressed_clusters: Option<isize>,
#[serde(rename = "corruptions", default, skip_serializing_if = "Option::is_none")]
pub corruptions: Option<isize>,
#[serde(rename = "corruptions-fixed", default, skip_serializing_if = "Option::is_none")]
pub corruptions_fixed: Option<isize>,
#[serde(rename = "image-end-offset", default, skip_serializing_if = "Option::is_none")]
pub image_end_offset: Option<isize>,
#[serde(rename = "total-clusters", default, skip_serializing_if = "Option::is_none")]
pub total_clusters: Option<isize>,
#[serde(rename = "allocated-clusters", default, skip_serializing_if = "Option::is_none")]
pub allocated_clusters: Option<isize>,
#[serde(rename = "fragmented-clusters", default, skip_serializing_if = "Option::is_none")]
pub fragmented_clusters: Option<isize>,
#[serde(rename = "filename")]
pub filename: ::std::string::String,
#[serde(rename = "check-errors")]
pub check_errors: isize,
#[serde(rename = "leaks", default, skip_serializing_if = "Option::is_none")]
pub leaks: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevVdeOptions {
#[serde(rename = "port", default, skip_serializing_if = "Option::is_none")]
pub port: Option<u16>,
#[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")]
pub mode: Option<u16>,
#[serde(rename = "sock", default, skip_serializing_if = "Option::is_none")]
pub sock: Option<::std::string::String>,
#[serde(rename = "group", default, skip_serializing_if = "Option::is_none")]
pub group: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct X86CPUFeatureWordInfo {
#[serde(rename = "cpuid-input-eax")]
pub cpuid_input_eax: isize,
#[serde(rename = "features")]
pub features: isize,
#[serde(rename = "cpuid-input-ecx", default, skip_serializing_if = "Option::is_none")]
pub cpuid_input_ecx: Option<isize>,
#[serde(rename = "cpuid-register")]
pub cpuid_register: X86CPURegister32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevVhostVDPAOptions {
#[serde(rename = "vhostdev", default, skip_serializing_if = "Option::is_none")]
pub vhostdev: Option<::std::string::String>,
#[serde(rename = "queues", default, skip_serializing_if = "Option::is_none")]
pub queues: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlkdebugInjectErrorOptions {
#[serde(rename = "once", default, skip_serializing_if = "Option::is_none")]
pub once: Option<bool>,
#[serde(rename = "sector", default, skip_serializing_if = "Option::is_none")]
pub sector: Option<isize>,
#[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
pub state: Option<isize>,
#[serde(rename = "immediately", default, skip_serializing_if = "Option::is_none")]
pub immediately: Option<bool>,
#[serde(rename = "iotype", default, skip_serializing_if = "Option::is_none")]
pub iotype: Option<BlkdebugIOType>,
#[serde(rename = "event")]
pub event: BlkdebugEvent,
#[serde(rename = "errno", default, skip_serializing_if = "Option::is_none")]
pub errno: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SnapshotInfo {
#[serde(rename = "vm-clock-sec")]
pub vm_clock_sec: isize,
#[serde(rename = "date-sec")]
pub date_sec: isize,
#[serde(rename = "vm-clock-nsec")]
pub vm_clock_nsec: isize,
#[serde(rename = "icount", default, skip_serializing_if = "Option::is_none")]
pub icount: Option<isize>,
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "vm-state-size")]
pub vm_state_size: isize,
#[serde(rename = "name")]
pub name: ::std::string::String,
#[serde(rename = "date-nsec")]
pub date_nsec: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetdevL2TPv3Options {
#[serde(rename = "udp", default, skip_serializing_if = "Option::is_none")]
pub udp: Option<bool>,
#[serde(rename = "txcookie", default, skip_serializing_if = "Option::is_none")]
pub txcookie: Option<u64>,
#[serde(rename = "src")]
pub src: ::std::string::String,
#[serde(rename = "offset", default, skip_serializing_if = "Option::is_none")]
pub offset: Option<u32>,
#[serde(rename = "counter", default, skip_serializing_if = "Option::is_none")]
pub counter: Option<bool>,
#[serde(rename = "dst")]
pub dst: ::std::string::String,
#[serde(rename = "ipv6", default, skip_serializing_if = "Option::is_none")]
pub ipv6: Option<bool>,
#[serde(rename = "rxcookie", default, skip_serializing_if = "Option::is_none")]
pub rxcookie: Option<u64>,
#[serde(rename = "txsession")]
pub txsession: u32,
#[serde(rename = "dstport", default, skip_serializing_if = "Option::is_none")]
pub dstport: Option<::std::string::String>,
#[serde(rename = "cookie64", default, skip_serializing_if = "Option::is_none")]
pub cookie64: Option<bool>,
#[serde(rename = "rxsession", default, skip_serializing_if = "Option::is_none")]
pub rxsession: Option<u32>,
#[serde(rename = "srcport", default, skip_serializing_if = "Option::is_none")]
pub srcport: Option<::std::string::String>,
#[serde(rename = "pincounter", default, skip_serializing_if = "Option::is_none")]
pub pincounter: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsRbd {
#[serde(rename = "image")]
pub image: ::std::string::String,
#[serde(rename = "user", default, skip_serializing_if = "Option::is_none")]
pub user: Option<::std::string::String>,
#[serde(rename = "pool")]
pub pool: ::std::string::String,
#[serde(rename = "auth-client-required", default, skip_serializing_if = "Option::is_none")]
pub auth_client_required: Option<Vec<RbdAuthMode>>,
#[serde(rename = "server", default, skip_serializing_if = "Option::is_none")]
pub server: Option<Vec<InetSocketAddressBase>>,
#[serde(rename = "conf", default, skip_serializing_if = "Option::is_none")]
pub conf: Option<::std::string::String>,
#[serde(rename = "snapshot", default, skip_serializing_if = "Option::is_none")]
pub snapshot: Option<::std::string::String>,
#[serde(rename = "namespace", default, skip_serializing_if = "Option::is_none")]
pub namespace: Option<::std::string::String>,
#[serde(rename = "key-secret", default, skip_serializing_if = "Option::is_none")]
pub key_secret: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VncInfo {
#[serde(rename = "service", default, skip_serializing_if = "Option::is_none")]
pub service: Option<::std::string::String>,
#[serde(rename = "auth", default, skip_serializing_if = "Option::is_none")]
pub auth: Option<::std::string::String>,
#[serde(rename = "enabled")]
pub enabled: bool,
#[serde(rename = "family", default, skip_serializing_if = "Option::is_none")]
pub family: Option<NetworkAddressFamily>,
#[serde(rename = "clients", default, skip_serializing_if = "Option::is_none")]
pub clients: Option<Vec<VncClientInfo>>,
#[serde(rename = "host", default, skip_serializing_if = "Option::is_none")]
pub host: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BalloonInfo {
#[serde(rename = "actual")]
pub actual: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuModelCompareInfo {
#[serde(rename = "result")]
pub result: CpuModelCompareResult,
#[serde(rename = "responsible-properties")]
pub responsible_properties: Vec<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevAmendOptionsLUKS {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: QCryptoBlockAmendOptionsLUKS,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuModelBaselineInfo {
#[serde(rename = "model")]
pub model: CpuModelInfo,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpiceBasicInfo {
#[serde(rename = "port")]
pub port: ::std::string::String,
#[serde(rename = "family")]
pub family: NetworkAddressFamily,
#[serde(rename = "host")]
pub host: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ACPIOSTInfo {
#[serde(rename = "slot")]
pub slot: ::std::string::String,
#[serde(rename = "slot-type")]
pub slot_type: ACPISlotType,
#[serde(rename = "source")]
pub source: isize,
#[serde(rename = "device", default, skip_serializing_if = "Option::is_none")]
pub device: Option<::std::string::String>,
#[serde(rename = "status")]
pub status: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryInfo {
#[serde(rename = "base-memory")]
pub base_memory: usize,
#[serde(rename = "plugged-memory", default, skip_serializing_if = "Option::is_none")]
pub plugged_memory: Option<usize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JobInfo {
#[serde(rename = "id")]
pub id: ::std::string::String,
#[serde(rename = "total-progress")]
pub total_progress: isize,
#[serde(rename = "type")]
pub type_: JobType,
#[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
pub error: Option<::std::string::String>,
#[serde(rename = "status")]
pub status: JobStatus,
#[serde(rename = "current-progress")]
pub current_progress: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockdevOptionsGluster {
#[serde(rename = "path")]
pub path: ::std::string::String,
#[serde(rename = "server")]
pub server: Vec<SocketAddress>,
#[serde(rename = "debug", default, skip_serializing_if = "Option::is_none")]
pub debug: Option<isize>,
#[serde(rename = "logfile", default, skip_serializing_if = "Option::is_none")]
pub logfile: Option<::std::string::String>,
#[serde(rename = "volume")]
pub volume: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GuestPanicInformationHyperV {
#[serde(rename = "arg3")]
pub arg3: u64,
#[serde(rename = "arg1")]
pub arg1: u64,
#[serde(rename = "arg5")]
pub arg5: u64,
#[serde(rename = "arg4")]
pub arg4: u64,
#[serde(rename = "arg2")]
pub arg2: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevCommon {
#[serde(rename = "logappend", default, skip_serializing_if = "Option::is_none")]
pub logappend: Option<bool>,
#[serde(rename = "logfile", default, skip_serializing_if = "Option::is_none")]
pub logfile: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Qcow2OverlapCheckFlags {
#[serde(rename = "template", default, skip_serializing_if = "Option::is_none")]
pub template: Option<Qcow2OverlapCheckMode>,
#[serde(rename = "active-l2", default, skip_serializing_if = "Option::is_none")]
pub active_l2: Option<bool>,
#[serde(rename = "refcount-table", default, skip_serializing_if = "Option::is_none")]
pub refcount_table: Option<bool>,
#[serde(rename = "refcount-block", default, skip_serializing_if = "Option::is_none")]
pub refcount_block: Option<bool>,
#[serde(rename = "active-l1", default, skip_serializing_if = "Option::is_none")]
pub active_l1: Option<bool>,
#[serde(rename = "inactive-l1", default, skip_serializing_if = "Option::is_none")]
pub inactive_l1: Option<bool>,
#[serde(rename = "inactive-l2", default, skip_serializing_if = "Option::is_none")]
pub inactive_l2: Option<bool>,
#[serde(rename = "bitmap-directory", default, skip_serializing_if = "Option::is_none")]
pub bitmap_directory: Option<bool>,
#[serde(rename = "main-header", default, skip_serializing_if = "Option::is_none")]
pub main_header: Option<bool>,
#[serde(rename = "snapshot-table", default, skip_serializing_if = "Option::is_none")]
pub snapshot_table: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevSocket {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "nodelay", default, skip_serializing_if = "Option::is_none")]
pub nodelay: Option<bool>,
#[serde(rename = "wait", default, skip_serializing_if = "Option::is_none")]
pub wait: Option<bool>,
#[serde(rename = "addr")]
pub addr: SocketAddressLegacy,
#[serde(rename = "server", default, skip_serializing_if = "Option::is_none")]
pub server: Option<bool>,
#[serde(rename = "telnet", default, skip_serializing_if = "Option::is_none")]
pub telnet: Option<bool>,
#[serde(rename = "tls-creds", default, skip_serializing_if = "Option::is_none")]
pub tls_creds: Option<::std::string::String>,
#[serde(rename = "tn3270", default, skip_serializing_if = "Option::is_none")]
pub tn3270: Option<bool>,
#[serde(rename = "websocket", default, skip_serializing_if = "Option::is_none")]
pub websocket: Option<bool>,
#[serde(rename = "reconnect", default, skip_serializing_if = "Option::is_none")]
pub reconnect: Option<isize>,
#[serde(rename = "tls-authz", default, skip_serializing_if = "Option::is_none")]
pub tls_authz: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct XDbgBlockGraph {
#[serde(rename = "edges")]
pub edges: Vec<XDbgBlockGraphEdge>,
#[serde(rename = "nodes")]
pub nodes: Vec<XDbgBlockGraphNode>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HotpluggableCPU {
#[serde(rename = "props")]
pub props: CpuInstanceProperties,
#[serde(rename = "vcpus-count")]
pub vcpus_count: isize,
#[serde(rename = "type")]
pub type_: ::std::string::String,
#[serde(rename = "qom-path", default, skip_serializing_if = "Option::is_none")]
pub qom_path: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PciDeviceId {
#[serde(rename = "device")]
pub device: isize,
#[serde(rename = "vendor")]
pub vendor: isize,
#[serde(rename = "subsystem", default, skip_serializing_if = "Option::is_none")]
pub subsystem: Option<isize>,
#[serde(rename = "subsystem-vendor", default, skip_serializing_if = "Option::is_none")]
pub subsystem_vendor: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChardevSpicePort {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: ChardevCommon,
#[serde(rename = "fqdn")]
pub fqdn: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudiodevWavOptions {
#[serde(rename = "path", default, skip_serializing_if = "Option::is_none")]
pub path: Option<::std::string::String>,
#[serde(rename = "in", default, skip_serializing_if = "Option::is_none")]
pub in_: Option<AudiodevPerDirectionOptions>,
#[serde(rename = "out", default, skip_serializing_if = "Option::is_none")]
pub out: Option<AudiodevPerDirectionOptions>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PCDIMMDeviceInfo {
#[serde(rename = "addr")]
pub addr: isize,
#[serde(rename = "slot")]
pub slot: isize,
#[serde(rename = "size")]
pub size: isize,
#[serde(rename = "node")]
pub node: isize,
#[serde(rename = "hotplugged")]
pub hotplugged: bool,
#[serde(rename = "memdev")]
pub memdev: ::std::string::String,
#[serde(rename = "hotpluggable")]
pub hotpluggable: bool,
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<::std::string::String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NumaHmatCacheOptions {
#[serde(rename = "line")]
pub line: u16,
#[serde(rename = "node-id")]
pub node_id: u32,
#[serde(rename = "associativity")]
pub associativity: HmatCacheAssociativity,
#[serde(rename = "policy")]
pub policy: HmatCacheWritePolicy,
#[serde(rename = "size")]
pub size: usize,
#[serde(rename = "level")]
pub level: u8,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RockerOfDpaFlowKey {
#[serde(rename = "ip-dst", default, skip_serializing_if = "Option::is_none")]
pub ip_dst: Option<::std::string::String>,
#[serde(rename = "tunnel-id", default, skip_serializing_if = "Option::is_none")]
pub tunnel_id: Option<u32>,
#[serde(rename = "ip-proto", default, skip_serializing_if = "Option::is_none")]
pub ip_proto: Option<u8>,
#[serde(rename = "in-pport", default, skip_serializing_if = "Option::is_none")]
pub in_pport: Option<u32>,
#[serde(rename = "priority")]
pub priority: u32,
#[serde(rename = "eth-type", default, skip_serializing_if = "Option::is_none")]
pub eth_type: Option<u16>,
#[serde(rename = "eth-dst", default, skip_serializing_if = "Option::is_none")]
pub eth_dst: Option<::std::string::String>,
#[serde(rename = "eth-src", default, skip_serializing_if = "Option::is_none")]
pub eth_src: Option<::std::string::String>,
#[serde(rename = "tbl-id")]
pub tbl_id: u32,
#[serde(rename = "vlan-id", default, skip_serializing_if = "Option::is_none")]
pub vlan_id: Option<u16>,
#[serde(rename = "ip-tos", default, skip_serializing_if = "Option::is_none")]
pub ip_tos: Option<u8>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RockerSwitch {
#[serde(rename = "id")]
pub id: u64,
#[serde(rename = "ports")]
pub ports: u32,
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BackupCommon {
#[serde(rename = "filter-node-name", default, skip_serializing_if = "Option::is_none")]
pub filter_node_name: Option<::std::string::String>,
#[serde(rename = "compress", default, skip_serializing_if = "Option::is_none")]
pub compress: Option<bool>,
#[serde(rename = "bitmap", default, skip_serializing_if = "Option::is_none")]
pub bitmap: Option<::std::string::String>,
#[serde(rename = "speed", default, skip_serializing_if = "Option::is_none")]
pub speed: Option<isize>,
#[serde(rename = "sync")]
pub sync: MirrorSyncMode,
#[serde(rename = "job-id", default, skip_serializing_if = "Option::is_none")]
pub job_id: Option<::std::string::String>,
#[serde(rename = "device")]
pub device: ::std::string::String,
#[serde(rename = "on-source-error", default, skip_serializing_if = "Option::is_none")]
pub on_source_error: Option<BlockdevOnError>,
#[serde(rename = "on-target-error", default, skip_serializing_if = "Option::is_none")]
pub on_target_error: Option<BlockdevOnError>,
#[serde(rename = "auto-finalize", default, skip_serializing_if = "Option::is_none")]
pub auto_finalize: Option<bool>,
#[serde(rename = "bitmap-mode", default, skip_serializing_if = "Option::is_none")]
pub bitmap_mode: Option<BitmapSyncMode>,
#[serde(rename = "auto-dismiss", default, skip_serializing_if = "Option::is_none")]
pub auto_dismiss: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QCryptoBlockCreateOptionsLUKS {
#[serde(flatten)]
#[serde(rename = "base")]
pub base: QCryptoBlockOptionsLUKS,
#[serde(rename = "hash-alg", default, skip_serializing_if = "Option::is_none")]
pub hash_alg: Option<QCryptoHashAlgorithm>,
#[serde(rename = "ivgen-alg", default, skip_serializing_if = "Option::is_none")]
pub ivgen_alg: Option<QCryptoIVGenAlgorithm>,
#[serde(rename = "cipher-alg", default, skip_serializing_if = "Option::is_none")]
pub cipher_alg: Option<QCryptoCipherAlgorithm>,
#[serde(rename = "ivgen-hash-alg", default, skip_serializing_if = "Option::is_none")]
pub ivgen_hash_alg: Option<QCryptoHashAlgorithm>,
#[serde(rename = "cipher-mode", default, skip_serializing_if = "Option::is_none")]
pub cipher_mode: Option<QCryptoCipherMode>,
#[serde(rename = "iter-time", default, skip_serializing_if = "Option::is_none")]
pub iter_time: Option<isize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReplayInfo {
#[serde(rename = "mode")]
pub mode: ReplayMode,
#[serde(rename = "filename", default, skip_serializing_if = "Option::is_none")]
pub filename: Option<::std::string::String>,
#[serde(rename = "icount")]
pub icount: isize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EventInfo {
#[serde(rename = "name")]
pub name: ::std::string::String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CurrentMachineParams {
#[serde(rename = "wakeup-suspend-support")]
pub wakeup_suspend_support: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "event")]
pub enum Event {
#[serde(rename = "SHUTDOWN")] SHUTDOWN {
data: SHUTDOWN,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "POWERDOWN")] POWERDOWN {
#[serde(default)] data: POWERDOWN,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "RESET")] RESET {
data: RESET,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "STOP")] STOP {
#[serde(default)] data: STOP,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "RESUME")] RESUME {
#[serde(default)] data: RESUME,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "SUSPEND")] SUSPEND {
#[serde(default)] data: SUSPEND,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "SUSPEND_DISK")] SUSPEND_DISK {
#[serde(default)] data: SUSPEND_DISK,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "WAKEUP")] WAKEUP {
#[serde(default)] data: WAKEUP,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "WATCHDOG")] WATCHDOG {
data: WATCHDOG,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "GUEST_PANICKED")] GUEST_PANICKED {
data: GUEST_PANICKED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "GUEST_CRASHLOADED")] GUEST_CRASHLOADED {
data: GUEST_CRASHLOADED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "MEMORY_FAILURE")] MEMORY_FAILURE {
data: MEMORY_FAILURE,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "DEVICE_TRAY_MOVED")] DEVICE_TRAY_MOVED {
data: DEVICE_TRAY_MOVED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "PR_MANAGER_STATUS_CHANGED")] PR_MANAGER_STATUS_CHANGED {
data: PR_MANAGER_STATUS_CHANGED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_IMAGE_CORRUPTED")] BLOCK_IMAGE_CORRUPTED {
data: BLOCK_IMAGE_CORRUPTED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_IO_ERROR")] BLOCK_IO_ERROR {
data: BLOCK_IO_ERROR,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_JOB_COMPLETED")] BLOCK_JOB_COMPLETED {
data: BLOCK_JOB_COMPLETED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_JOB_CANCELLED")] BLOCK_JOB_CANCELLED {
data: BLOCK_JOB_CANCELLED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_JOB_ERROR")] BLOCK_JOB_ERROR {
data: BLOCK_JOB_ERROR,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_JOB_READY")] BLOCK_JOB_READY {
data: BLOCK_JOB_READY,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_JOB_PENDING")] BLOCK_JOB_PENDING {
data: BLOCK_JOB_PENDING,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_WRITE_THRESHOLD")] BLOCK_WRITE_THRESHOLD {
data: BLOCK_WRITE_THRESHOLD,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "QUORUM_FAILURE")] QUORUM_FAILURE {
data: QUORUM_FAILURE,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "QUORUM_REPORT_BAD")] QUORUM_REPORT_BAD {
data: QUORUM_REPORT_BAD,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "JOB_STATUS_CHANGE")] JOB_STATUS_CHANGE {
data: JOB_STATUS_CHANGE,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BLOCK_EXPORT_DELETED")] BLOCK_EXPORT_DELETED {
data: BLOCK_EXPORT_DELETED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "VSERPORT_CHANGE")] VSERPORT_CHANGE {
data: VSERPORT_CHANGE,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "DUMP_COMPLETED")] DUMP_COMPLETED {
data: DUMP_COMPLETED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "NIC_RX_FILTER_CHANGED")] NIC_RX_FILTER_CHANGED {
data: NIC_RX_FILTER_CHANGED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "FAILOVER_NEGOTIATED")] FAILOVER_NEGOTIATED {
data: FAILOVER_NEGOTIATED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "RDMA_GID_STATUS_CHANGED")] RDMA_GID_STATUS_CHANGED {
data: RDMA_GID_STATUS_CHANGED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "SPICE_CONNECTED")] SPICE_CONNECTED {
data: SPICE_CONNECTED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "SPICE_INITIALIZED")] SPICE_INITIALIZED {
data: SPICE_INITIALIZED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "SPICE_DISCONNECTED")] SPICE_DISCONNECTED {
data: SPICE_DISCONNECTED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "SPICE_MIGRATE_COMPLETED")] SPICE_MIGRATE_COMPLETED {
#[serde(default)] data: SPICE_MIGRATE_COMPLETED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "VNC_CONNECTED")] VNC_CONNECTED {
data: VNC_CONNECTED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "VNC_INITIALIZED")] VNC_INITIALIZED {
data: VNC_INITIALIZED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "VNC_DISCONNECTED")] VNC_DISCONNECTED {
data: VNC_DISCONNECTED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "MIGRATION")] MIGRATION {
data: MIGRATION,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "MIGRATION_PASS")] MIGRATION_PASS {
data: MIGRATION_PASS,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "COLO_EXIT")] COLO_EXIT {
data: COLO_EXIT,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "UNPLUG_PRIMARY")] UNPLUG_PRIMARY {
data: UNPLUG_PRIMARY,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "DEVICE_DELETED")] DEVICE_DELETED {
data: DEVICE_DELETED,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "BALLOON_CHANGE")] BALLOON_CHANGE {
data: BALLOON_CHANGE,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "MEMORY_DEVICE_SIZE_CHANGE")] MEMORY_DEVICE_SIZE_CHANGE {
data: MEMORY_DEVICE_SIZE_CHANGE,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "MEM_UNPLUG_ERROR")] MEM_UNPLUG_ERROR {
data: MEM_UNPLUG_ERROR,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "RTC_CHANGE")] RTC_CHANGE {
data: RTC_CHANGE,
timestamp: ::qapi_spec::Timestamp,
},
#[serde(rename = "ACPI_DEVICE_OST")] ACPI_DEVICE_OST {
data: ACPI_DEVICE_OST,
timestamp: ::qapi_spec::Timestamp,
},
}
impl Event {
pub fn timestamp(&self) -> ::qapi_spec::Timestamp {
match *self {
Event::SHUTDOWN { timestamp, .. } => timestamp,
Event::POWERDOWN { timestamp, .. } => timestamp,
Event::RESET { timestamp, .. } => timestamp,
Event::STOP { timestamp, .. } => timestamp,
Event::RESUME { timestamp, .. } => timestamp,
Event::SUSPEND { timestamp, .. } => timestamp,
Event::SUSPEND_DISK { timestamp, .. } => timestamp,
Event::WAKEUP { timestamp, .. } => timestamp,
Event::WATCHDOG { timestamp, .. } => timestamp,
Event::GUEST_PANICKED { timestamp, .. } => timestamp,
Event::GUEST_CRASHLOADED { timestamp, .. } => timestamp,
Event::MEMORY_FAILURE { timestamp, .. } => timestamp,
Event::DEVICE_TRAY_MOVED { timestamp, .. } => timestamp,
Event::PR_MANAGER_STATUS_CHANGED { timestamp, .. } => timestamp,
Event::BLOCK_IMAGE_CORRUPTED { timestamp, .. } => timestamp,
Event::BLOCK_IO_ERROR { timestamp, .. } => timestamp,
Event::BLOCK_JOB_COMPLETED { timestamp, .. } => timestamp,
Event::BLOCK_JOB_CANCELLED { timestamp, .. } => timestamp,
Event::BLOCK_JOB_ERROR { timestamp, .. } => timestamp,
Event::BLOCK_JOB_READY { timestamp, .. } => timestamp,
Event::BLOCK_JOB_PENDING { timestamp, .. } => timestamp,
Event::BLOCK_WRITE_THRESHOLD { timestamp, .. } => timestamp,
Event::QUORUM_FAILURE { timestamp, .. } => timestamp,
Event::QUORUM_REPORT_BAD { timestamp, .. } => timestamp,
Event::JOB_STATUS_CHANGE { timestamp, .. } => timestamp,
Event::BLOCK_EXPORT_DELETED { timestamp, .. } => timestamp,
Event::VSERPORT_CHANGE { timestamp, .. } => timestamp,
Event::DUMP_COMPLETED { timestamp, .. } => timestamp,
Event::NIC_RX_FILTER_CHANGED { timestamp, .. } => timestamp,
Event::FAILOVER_NEGOTIATED { timestamp, .. } => timestamp,
Event::RDMA_GID_STATUS_CHANGED { timestamp, .. } => timestamp,
Event::SPICE_CONNECTED { timestamp, .. } => timestamp,
Event::SPICE_INITIALIZED { timestamp, .. } => timestamp,
Event::SPICE_DISCONNECTED { timestamp, .. } => timestamp,
Event::SPICE_MIGRATE_COMPLETED { timestamp, .. } => timestamp,
Event::VNC_CONNECTED { timestamp, .. } => timestamp,
Event::VNC_INITIALIZED { timestamp, .. } => timestamp,
Event::VNC_DISCONNECTED { timestamp, .. } => timestamp,
Event::MIGRATION { timestamp, .. } => timestamp,
Event::MIGRATION_PASS { timestamp, .. } => timestamp,
Event::COLO_EXIT { timestamp, .. } => timestamp,
Event::UNPLUG_PRIMARY { timestamp, .. } => timestamp,
Event::DEVICE_DELETED { timestamp, .. } => timestamp,
Event::BALLOON_CHANGE { timestamp, .. } => timestamp,
Event::MEMORY_DEVICE_SIZE_CHANGE { timestamp, .. } => timestamp,
Event::MEM_UNPLUG_ERROR { timestamp, .. } => timestamp,
Event::RTC_CHANGE { timestamp, .. } => timestamp,
Event::ACPI_DEVICE_OST { timestamp, .. } => timestamp,
}
}
}