libvirtxml

package module
v1.10007.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 30, 2024 License: MIT Imports: 5 Imported by: 56

README 

=====================
libvirt-go-xml-module
=====================

.. image:: https://gitlab.com/libvirt/libvirt-go-xml-module/badges/master/pipeline.svg
   :target: https://gitlab.com/libvirt/libvirt-go-xml-module/pipelines
   :alt: Build Status
.. image:: https://img.shields.io/static/v1?label=godev&message=reference&color=00add8
   :target: https://pkg.go.dev/libvirt.org/go/libvirtxml
   :alt: API Documentation

Go API for manipulating libvirt XML documents

This package provides a Go API that defines a set of structs, annotated for use
with "encoding/xml", that can represent libvirt XML documents. There is no
dependency on the libvirt library itself, so this can be used regardless of
the way in which the application talks to libvirt.


Development status
==================

This API is considered to be production ready; note however that,
while unnecessary changes will be avoided, there are overall no
strong stability guarantees.

Please see the `VERSIONING <VERSIONING.rst>`_ file for information
about release schedule and versioning scheme.


Documentation
=============

* `API documentation for the bindings <https://pkg.go.dev/libvirt.org/go/libvirtxml>`_

* `Libvirt XML schema documentation <https://libvirt.org/format.html>`_

  * `capabilities <https://libvirt.org/formatcaps.html>`_
  * `domain <https://libvirt.org/formatdomain.html>`_
  * `domain capabilities <https://libvirt.org/formatdomaincaps.html>`_
  * `domain snapshot <https://libvirt.org/formatsnapshot.html>`_
  * `network <https://libvirt.org/formatnetwork.html>`_
  * `node device <https://libvirt.org/formatnode.html>`_
  * `nwfilter <https://libvirt.org/formatnwfilter.html>`_
  * `secret <https://libvirt.org/formatsecret.html>`_
  * `storage <https://libvirt.org/formatstorage.html>`_
  * `storage encryption <https://libvirt.org/formatstorageencryption.html>`_


Contributing
============

The libvirt project aims to add support for new XML elements to
libvirt-go-xml-module as soon as they are added to the main libvirt C
library. If you are submitting changes to the libvirt C library
that introduce new XML elements, please submit a libvirt-go-xml-module
change at the same time. Bug fixes and other improvements to the
libvirt-go-xml-module library are welcome at any time.

For more information, see the `CONTRIBUTING <CONTRIBUTING.rst>`_
file.

Documentation

Overview

Package libvirt-go-xml-module defines structs for parsing libvirt XML schemas

The libvirt API uses XML schemas/documents to describe the configuration of many of its managed objects. Thus when using the libvirt-go package, it is often neccessary to either parse or format XML documents. This package defines a set of Go structs which have been annotated for use with the encoding/xml API to manage libvirt XML documents.

Example creating a domain XML document from configuration: 

package main

import (
 "libvirt.org/go/libvirtxml"
)

func main() {
  domcfg := &libvirtxml.Domain{Type: "kvm", Name: "demo",
                               UUID: "8f99e332-06c4-463a-9099-330fb244e1b3",
                               ....}
  xmldoc, err := domcfg.Marshal()
}

Example parsing a domainXML document, in combination with libvirt-go 

package main

import (
  "libvirt.org/go/libvirt"
  "libvirt.org/go/libvirtxml"
  "fmt"
)

func main() {
  conn, err := libvirt.NewConnect("qemu:///system")
  dom, err := conn.LookupDomainByName("demo")
  xmldoc, err := dom.GetXMLDesc(0)

  domcfg := &libvirtxml.Domain{}
  err = domcfg.Unmarshal(xmldoc)

  fmt.Printf("Virt type %s\n", domcfg.Type)
}

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Caps 

type Caps struct {
	XMLName xml.Name    `xml:"capabilities"`
	Host    CapsHost    `xml:"host"`
	Guests  []CapsGuest `xml:"guest"`
}

func (*Caps) Marshal 

func (c *Caps) Marshal() (string, error)

func (*Caps) Unmarshal 

func (c *Caps) Unmarshal(doc string) error

type CapsGuest 

type CapsGuest struct {
	OSType   string             `xml:"os_type"`
	Arch     CapsGuestArch      `xml:"arch"`
	Features *CapsGuestFeatures `xml:"features"`
}

type CapsGuestArch 

type CapsGuestArch struct {
	Name     string             `xml:"name,attr"`
	WordSize string             `xml:"wordsize"`
	Emulator string             `xml:"emulator"`
	Loader   string             `xml:"loader,omitempty"`
	Machines []CapsGuestMachine `xml:"machine"`
	Domains  []CapsGuestDomain  `xml:"domain"`
}

type CapsGuestDomain 

type CapsGuestDomain struct {
	Type     string             `xml:"type,attr"`
	Emulator string             `xml:"emulator,omitempty"`
	Machines []CapsGuestMachine `xml:"machine"`
}

type CapsGuestFeatureACPI 

type CapsGuestFeatureACPI struct {
	Default string `xml:"default,attr,omitempty"`
	Toggle  string `xml:"toggle,attr,omitempty"`
}

type CapsGuestFeatureAPIC 

type CapsGuestFeatureAPIC struct {
	Default string `xml:"default,attr,omitempty"`
	Toggle  string `xml:"toggle,attr,omitempty"`
}

type CapsGuestFeatureCPUSelection 

type CapsGuestFeatureCPUSelection struct {
}

type CapsGuestFeatureDeviceBoot 

type CapsGuestFeatureDeviceBoot struct {
}

type CapsGuestFeatureDiskSnapshot 

type CapsGuestFeatureDiskSnapshot struct {
	Default string `xml:"default,attr,omitempty"`
	Toggle  string `xml:"toggle,attr,omitempty"`
}

type CapsGuestFeatureIA64BE 

type CapsGuestFeatureIA64BE struct {
}

type CapsGuestFeatureNonPAE 

type CapsGuestFeatureNonPAE struct {
}

type CapsGuestFeaturePAE 

type CapsGuestFeaturePAE struct {
}

type CapsGuestFeatures 

type CapsGuestFeatures struct {
	CPUSelection *CapsGuestFeatureCPUSelection `xml:"cpuselection"`
	DeviceBoot   *CapsGuestFeatureDeviceBoot   `xml:"deviceboot"`
	DiskSnapshot *CapsGuestFeatureDiskSnapshot `xml:"disksnapshot"`
	PAE          *CapsGuestFeaturePAE          `xml:"pae"`
	NonPAE       *CapsGuestFeatureNonPAE       `xml:"nonpae"`
	APIC         *CapsGuestFeatureAPIC         `xml:"apic"`
	ACPI         *CapsGuestFeatureACPI         `xml:"acpi"`
	IA64BE       *CapsGuestFeatureIA64BE       `xml:"ia64_be"`
}

type CapsGuestMachine 

type CapsGuestMachine struct {
	Name      string `xml:",chardata"`
	MaxCPUs   int    `xml:"maxCpus,attr,omitempty"`
	Canonical string `xml:"canonical,attr,omitempty"`
}

type CapsHost 

type CapsHost struct {
	UUID              string                     `xml:"uuid,omitempty"`
	CPU               *CapsHostCPU               `xml:"cpu"`
	PowerManagement   *CapsHostPowerManagement   `xml:"power_management"`
	IOMMU             *CapsHostIOMMU             `xml:"iommu"`
	MigrationFeatures *CapsHostMigrationFeatures `xml:"migration_features"`
	NUMA              *CapsHostNUMATopology      `xml:"topology"`
	Cache             *CapsHostCache             `xml:"cache"`
	MemoryBandwidth   *CapsHostMemoryBandwidth   `xml:"memory_bandwidth"`
	SecModel          []CapsHostSecModel         `xml:"secmodel"`
}

type CapsHostCPU 

type CapsHostCPU struct {
	XMLName      xml.Name                 `xml:"cpu"`
	Arch         string                   `xml:"arch,omitempty"`
	Model        string                   `xml:"model,omitempty"`
	Vendor       string                   `xml:"vendor,omitempty"`
	Microcode    *CapsHostCPUMicrocode    `xml:"microcode"`
	Signature    *CapsHostCPUSignature    `xml:"signature"`
	Counter      *CapsHostCPUCounter      `xml:"counter"`
	Topology     *CapsHostCPUTopology     `xml:"topology"`
	Cache        *CapsHostCPUCache        `xml:"cache"`
	MaxPhysAddr  *CapsHostCPUMaxPhysAddr  `xml:"maxphysaddr"`
	FeatureFlags []CapsHostCPUFeatureFlag `xml:"feature"`
	Features     *CapsHostCPUFeatures     `xml:"features"`
	PageSizes    []CapsHostCPUPageSize    `xml:"pages"`
}

func (*CapsHostCPU) Marshal 

func (c *CapsHostCPU) Marshal() (string, error)

func (*CapsHostCPU) Unmarshal 

func (c *CapsHostCPU) Unmarshal(doc string) error

type CapsHostCPUCache added in v1.8007.0 

type CapsHostCPUCache struct {
	Level *uint  `xml:"level,attr,omitempty"`
	Mode  string `xml:"mode,attr"`
}

type CapsHostCPUCounter added in v1.8007.0 

type CapsHostCPUCounter struct {
	Name      string `xml:"name,attr"`
	Frequency uint   `xml:"frequency,attr"`
	Scaling   string `xml:"scaling,attr,omitempty"`
}

type CapsHostCPUFeature 

type CapsHostCPUFeature struct {
}

type CapsHostCPUFeatureFlag 

type CapsHostCPUFeatureFlag struct {
	Name string `xml:"name,attr"`
}

type CapsHostCPUFeatures 

type CapsHostCPUFeatures struct {
	PAE    *CapsHostCPUFeature `xml:"pae"`
	NonPAE *CapsHostCPUFeature `xml:"nonpae"`
	SVM    *CapsHostCPUFeature `xml:"svm"`
	VMX    *CapsHostCPUFeature `xml:"vmx"`
}

type CapsHostCPUMaxPhysAddr added in v1.8007.0 

type CapsHostCPUMaxPhysAddr struct {
	Mode string `xml:"mode,attr"`
	Bits uint   `xml:"bits,attr,omitempty"`
}

type CapsHostCPUMicrocode 

type CapsHostCPUMicrocode struct {
	Version int `xml:"version,attr"`
}

type CapsHostCPUPageSize 

type CapsHostCPUPageSize struct {
	Size int    `xml:"size,attr"`
	Unit string `xml:"unit,attr"`
}

type CapsHostCPUSignature added in v1.8005.0 

type CapsHostCPUSignature struct {
	Family   int `xml:"family,attr"`
	Model    int `xml:"model,attr"`
	Stepping int `xml:"stepping,attr"`
}

type CapsHostCPUTopology 

type CapsHostCPUTopology struct {
	Sockets  int `xml:"sockets,attr"`
	Dies     int `xml:"dies,attr,omitempty"`
	Clusters int `xml:"clusters,attr,omitempty"`
	Cores    int `xml:"cores,attr"`
	Threads  int `xml:"threads,attr"`
}

type CapsHostCache 

type CapsHostCache struct {
	Banks   []CapsHostCacheBank   `xml:"bank"`
	Monitor *CapsHostCacheMonitor `xml:"monitor"`
}

type CapsHostCacheBank 

type CapsHostCacheBank struct {
	ID      uint                   `xml:"id,attr"`
	Level   uint                   `xml:"level,attr"`
	Type    string                 `xml:"type,attr"`
	Size    uint                   `xml:"size,attr"`
	Unit    string                 `xml:"unit,attr"`
	CPUs    string                 `xml:"cpus,attr"`
	Control []CapsHostCacheControl `xml:"control"`
}

type CapsHostCacheControl 

type CapsHostCacheControl struct {
	Granularity uint   `xml:"granularity,attr"`
	Min         uint   `xml:"min,attr,omitempty"`
	Unit        string `xml:"unit,attr"`
	Type        string `xml:"type,attr"`
	MaxAllows   uint   `xml:"maxAllocs,attr"`
}

type CapsHostCacheMonitor 

type CapsHostCacheMonitor struct {
	Level          uint                          `xml:"level,attr,omitempty"`
	ResueThreshold uint                          `xml:"reuseThreshold,attr,omitempty"`
	MaxMonitors    uint                          `xml:"maxMonitors,attr"`
	Features       []CapsHostCacheMonitorFeature `xml:"feature"`
}

type CapsHostCacheMonitorFeature 

type CapsHostCacheMonitorFeature struct {
	Name string `xml:"name,attr"`
}

type CapsHostIOMMU 

type CapsHostIOMMU struct {
	Support string `xml:"support,attr"`
}

type CapsHostMemoryBandwidth 

type CapsHostMemoryBandwidth struct {
	Nodes   []CapsHostMemoryBandwidthNode   `xml:"node"`
	Monitor *CapsHostMemoryBandwidthMonitor `xml:"monitor"`
}

type CapsHostMemoryBandwidthMonitor 

type CapsHostMemoryBandwidthMonitor struct {
	MaxMonitors uint                                    `xml:"maxMonitors,attr"`
	Features    []CapsHostMemoryBandwidthMonitorFeature `xml:"feature"`
}

type CapsHostMemoryBandwidthMonitorFeature 

type CapsHostMemoryBandwidthMonitorFeature struct {
	Name string `xml:"name,attr"`
}

type CapsHostMemoryBandwidthNode 

type CapsHostMemoryBandwidthNode struct {
	ID      uint                                `xml:"id,attr"`
	CPUs    string                              `xml:"cpus,attr"`
	Control *CapsHostMemoryBandwidthNodeControl `xml:"control"`
}

type CapsHostMemoryBandwidthNodeControl 

type CapsHostMemoryBandwidthNodeControl struct {
	Granularity uint `xml:"granularity,attr"`
	Min         uint `xml:"min,attr"`
	MaxAllocs   uint `xml:"maxAllocs,attr"`
}

type CapsHostMigrationFeatures 

type CapsHostMigrationFeatures struct {
	Live          *CapsHostMigrationLive          `xml:"live"`
	URITransports *CapsHostMigrationURITransports `xml:"uri_transports"`
}

type CapsHostMigrationLive 

type CapsHostMigrationLive struct {
}

type CapsHostMigrationURITransports 

type CapsHostMigrationURITransports struct {
	URI []string `xml:"uri_transport"`
}

type CapsHostNUMACPU 

type CapsHostNUMACPU struct {
	ID        int    `xml:"id,attr"`
	SocketID  *int   `xml:"socket_id,attr"`
	DieID     *int   `xml:"die_id,attr"`
	ClusterID *int   `xml:"cluster_id,attr"`
	CoreID    *int   `xml:"core_id,attr"`
	Siblings  string `xml:"siblings,attr,omitempty"`
}

type CapsHostNUMACPUs 

type CapsHostNUMACPUs struct {
	Num  uint              `xml:"num,attr"`
	CPUs []CapsHostNUMACPU `xml:"cpu"`
}

type CapsHostNUMACache 

type CapsHostNUMACache struct {
	Level         int                    `xml:"level,attr,omitempty"`
	Associativity string                 `xml:"associativity,attr,omitempty"`
	Policy        string                 `xml:"policy,attr,omitempty"`
	Size          *CapsHostNUMACacheSize `xml:"size"`
	Line          *CapsHostNUMACacheLine `xml:"line"`
}

type CapsHostNUMACacheLine 

type CapsHostNUMACacheLine struct {
	Value uint   `xml:"value,attr,omitempty"`
	Unit  string `xml:"unit,attr,omitempty"`
}

type CapsHostNUMACacheSize 

type CapsHostNUMACacheSize struct {
	Value uint   `xml:"value,attr,omitempty"`
	Unit  string `xml:"unit,attr,omitempty"`
}

type CapsHostNUMACell 

type CapsHostNUMACell struct {
	ID        int                    `xml:"id,attr"`
	Memory    *CapsHostNUMAMemory    `xml:"memory"`
	PageInfo  []CapsHostNUMAPageInfo `xml:"pages"`
	Distances *CapsHostNUMADistances `xml:"distances"`
	Cache     []CapsHostNUMACache    `xml:"cache"`
	CPUS      *CapsHostNUMACPUs      `xml:"cpus"`
}

type CapsHostNUMACells 

type CapsHostNUMACells struct {
	Num   uint               `xml:"num,attr,omitempty"`
	Cells []CapsHostNUMACell `xml:"cell"`
}

type CapsHostNUMADistances 

type CapsHostNUMADistances struct {
	Siblings []CapsHostNUMASibling `xml:"sibling"`
}

type CapsHostNUMAInterconnectBandwidth 

type CapsHostNUMAInterconnectBandwidth struct {
	Initiator uint   `xml:"initiator,attr"`
	Target    uint   `xml:"target,attr"`
	Type      string `xml:"type,attr"`
	Value     uint   `xml:"value,attr"`
	Unit      string `xml:"unit,attr"`
}

type CapsHostNUMAInterconnectLatency 

type CapsHostNUMAInterconnectLatency struct {
	Initiator uint   `xml:"initiator,attr"`
	Target    uint   `xml:"target,attr"`
	Type      string `xml:"type,attr"`
	Value     uint   `xml:"value,attr"`
}

type CapsHostNUMAInterconnects 

type CapsHostNUMAInterconnects struct {
	Latency   []CapsHostNUMAInterconnectLatency   `xml:"latency"`
	Bandwidth []CapsHostNUMAInterconnectBandwidth `xml:"bandwidth"`
}

type CapsHostNUMAMemory 

type CapsHostNUMAMemory struct {
	Size uint64 `xml:",chardata"`
	Unit string `xml:"unit,attr"`
}

type CapsHostNUMAPageInfo 

type CapsHostNUMAPageInfo struct {
	Size  int    `xml:"size,attr"`
	Unit  string `xml:"unit,attr"`
	Count uint64 `xml:",chardata"`
}

type CapsHostNUMASibling 

type CapsHostNUMASibling struct {
	ID    int `xml:"id,attr"`
	Value int `xml:"value,attr"`
}

type CapsHostNUMATopology 

type CapsHostNUMATopology struct {
	Cells         *CapsHostNUMACells         `xml:"cells"`
	Interconnects *CapsHostNUMAInterconnects `xml:"interconnects"`
}

type CapsHostPowerManagement 

type CapsHostPowerManagement struct {
	SuspendMem    *CapsHostPowerManagementMode `xml:"suspend_mem"`
	SuspendDisk   *CapsHostPowerManagementMode `xml:"suspend_disk"`
	SuspendHybrid *CapsHostPowerManagementMode `xml:"suspend_hybrid"`
}

type CapsHostPowerManagementMode 

type CapsHostPowerManagementMode struct {
}

type CapsHostSecModel 

type CapsHostSecModel struct {
	Name   string                  `xml:"model"`
	DOI    string                  `xml:"doi"`
	Labels []CapsHostSecModelLabel `xml:"baselabel"`
}

type CapsHostSecModelLabel 

type CapsHostSecModelLabel struct {
	Type  string `xml:"type,attr"`
	Value string `xml:",chardata"`
}

type Document 

type Document interface {
	Unmarshal(doc string) error
	Marshal() (string, error)
}

type Domain 

type Domain struct {
	XMLName         xml.Name               `xml:"domain"`
	Type            string                 `xml:"type,attr,omitempty"`
	ID              *int                   `xml:"id,attr"`
	Name            string                 `xml:"name,omitempty"`
	UUID            string                 `xml:"uuid,omitempty"`
	GenID           *DomainGenID           `xml:"genid"`
	Title           string                 `xml:"title,omitempty"`
	Description     string                 `xml:"description,omitempty"`
	Metadata        *DomainMetadata        `xml:"metadata"`
	MaximumMemory   *DomainMaxMemory       `xml:"maxMemory"`
	Memory          *DomainMemory          `xml:"memory"`
	CurrentMemory   *DomainCurrentMemory   `xml:"currentMemory"`
	BlockIOTune     *DomainBlockIOTune     `xml:"blkiotune"`
	MemoryTune      *DomainMemoryTune      `xml:"memtune"`
	MemoryBacking   *DomainMemoryBacking   `xml:"memoryBacking"`
	VCPU            *DomainVCPU            `xml:"vcpu"`
	VCPUs           *DomainVCPUs           `xml:"vcpus"`
	IOThreads       uint                   `xml:"iothreads,omitempty"`
	IOThreadIDs     *DomainIOThreadIDs     `xml:"iothreadids"`
	DefaultIOThread *DomainDefaultIOThread `xml:"defaultiothread"`
	CPUTune         *DomainCPUTune         `xml:"cputune"`
	NUMATune        *DomainNUMATune        `xml:"numatune"`
	Resource        *DomainResource        `xml:"resource"`
	SysInfo         []DomainSysInfo        `xml:"sysinfo"`
	Bootloader      string                 `xml:"bootloader,omitempty"`
	BootloaderArgs  string                 `xml:"bootloader_args,omitempty"`
	OS              *DomainOS              `xml:"os"`
	IDMap           *DomainIDMap           `xml:"idmap"`
	Features        *DomainFeatureList     `xml:"features"`
	CPU             *DomainCPU             `xml:"cpu"`
	Clock           *DomainClock           `xml:"clock"`
	OnPoweroff      string                 `xml:"on_poweroff,omitempty"`
	OnReboot        string                 `xml:"on_reboot,omitempty"`
	OnCrash         string                 `xml:"on_crash,omitempty"`
	PM              *DomainPM              `xml:"pm"`
	Perf            *DomainPerf            `xml:"perf"`
	Devices         *DomainDeviceList      `xml:"devices"`
	SecLabel        []DomainSecLabel       `xml:"seclabel"`
	KeyWrap         *DomainKeyWrap         `xml:"keywrap"`
	LaunchSecurity  *DomainLaunchSecurity  `xml:"launchSecurity"`

	/* Hypervisor namespaces must all be last */
	QEMUCommandline      *DomainQEMUCommandline
	QEMUCapabilities     *DomainQEMUCapabilities
	QEMUOverride         *DomainQEMUOverride
	QEMUDeprecation      *DomainQEMUDeprecation
	LXCNamespace         *DomainLXCNamespace
	BHyveCommandline     *DomainBHyveCommandline
	VMWareDataCenterPath *DomainVMWareDataCenterPath
	XenCommandline       *DomainXenCommandline
}

NB, try to keep the order of fields in this struct matching the order of XML elements that libvirt will generate when dumping XML.

func (*Domain) Marshal 

func (d *Domain) Marshal() (string, error)

func (*Domain) Unmarshal 

func (d *Domain) Unmarshal(doc string) error

type DomainACPI 

type DomainACPI struct {
	Tables []DomainACPITable `xml:"table"`
}

type DomainACPITable 

type DomainACPITable struct {
	Type string `xml:"type,attr"`
	Path string `xml:",chardata"`
}

type DomainAddress 

type DomainAddress struct {
	PCI          *DomainAddressPCI
	Drive        *DomainAddressDrive
	VirtioSerial *DomainAddressVirtioSerial
	CCID         *DomainAddressCCID
	USB          *DomainAddressUSB
	SpaprVIO     *DomainAddressSpaprVIO
	VirtioS390   *DomainAddressVirtioS390
	CCW          *DomainAddressCCW
	VirtioMMIO   *DomainAddressVirtioMMIO
	ISA          *DomainAddressISA
	DIMM         *DomainAddressDIMM
	Unassigned   *DomainAddressUnassigned
}

func (*DomainAddress) MarshalXML 

func (a *DomainAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddress) UnmarshalXML 

func (a *DomainAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressCCID 

type DomainAddressCCID struct {
	Controller *uint `xml:"controller,attr"`
	Slot       *uint `xml:"slot,attr"`
}

func (*DomainAddressCCID) MarshalXML 

func (a *DomainAddressCCID) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressCCID) UnmarshalXML 

func (a *DomainAddressCCID) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressCCW 

type DomainAddressCCW struct {
	CSSID *uint `xml:"cssid,attr"`
	SSID  *uint `xml:"ssid,attr"`
	DevNo *uint `xml:"devno,attr"`
}

func (*DomainAddressCCW) MarshalXML 

func (a *DomainAddressCCW) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressCCW) UnmarshalXML 

func (a *DomainAddressCCW) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressDIMM 

type DomainAddressDIMM struct {
	Slot *uint   `xml:"slot,attr"`
	Base *uint64 `xml:"base,attr"`
}

func (*DomainAddressDIMM) MarshalXML 

func (a *DomainAddressDIMM) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressDIMM) UnmarshalXML 

func (a *DomainAddressDIMM) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressDrive 

type DomainAddressDrive struct {
	Controller *uint `xml:"controller,attr"`
	Bus        *uint `xml:"bus,attr"`
	Target     *uint `xml:"target,attr"`
	Unit       *uint `xml:"unit,attr"`
}

func (*DomainAddressDrive) MarshalXML 

func (a *DomainAddressDrive) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressDrive) UnmarshalXML 

func (a *DomainAddressDrive) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressISA 

type DomainAddressISA struct {
	IOBase *uint `xml:"iobase,attr"`
	IRQ    *uint `xml:"irq,attr"`
}

func (*DomainAddressISA) MarshalXML 

func (a *DomainAddressISA) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressISA) UnmarshalXML 

func (a *DomainAddressISA) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressMDev 

type DomainAddressMDev struct {
	UUID string `xml:"uuid,attr"`
}

type DomainAddressPCI 

type DomainAddressPCI struct {
	Domain        *uint              `xml:"domain,attr"`
	Bus           *uint              `xml:"bus,attr"`
	Slot          *uint              `xml:"slot,attr"`
	Function      *uint              `xml:"function,attr"`
	MultiFunction string             `xml:"multifunction,attr,omitempty"`
	ZPCI          *DomainAddressZPCI `xml:"zpci"`
}

func (*DomainAddressPCI) MarshalXML 

func (a *DomainAddressPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressPCI) UnmarshalXML 

func (a *DomainAddressPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressSpaprVIO 

type DomainAddressSpaprVIO struct {
	Reg *uint64 `xml:"reg,attr"`
}

func (*DomainAddressSpaprVIO) MarshalXML 

func (a *DomainAddressSpaprVIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressSpaprVIO) UnmarshalXML 

func (a *DomainAddressSpaprVIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressUSB 

type DomainAddressUSB struct {
	Bus    *uint  `xml:"bus,attr"`
	Port   string `xml:"port,attr,omitempty"`
	Device *uint  `xml:"device,attr"`
}

func (*DomainAddressUSB) MarshalXML 

func (a *DomainAddressUSB) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressUSB) UnmarshalXML 

func (a *DomainAddressUSB) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressUnassigned 

type DomainAddressUnassigned struct {
}

func (*DomainAddressUnassigned) MarshalXML 

func (a *DomainAddressUnassigned) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressUnassigned) UnmarshalXML 

func (a *DomainAddressUnassigned) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressVirtioMMIO 

type DomainAddressVirtioMMIO struct {
}

func (*DomainAddressVirtioMMIO) MarshalXML 

func (a *DomainAddressVirtioMMIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressVirtioMMIO) UnmarshalXML 

func (a *DomainAddressVirtioMMIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressVirtioS390 

type DomainAddressVirtioS390 struct {
}

func (*DomainAddressVirtioS390) MarshalXML 

func (a *DomainAddressVirtioS390) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressVirtioS390) UnmarshalXML 

func (a *DomainAddressVirtioS390) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressVirtioSerial 

type DomainAddressVirtioSerial struct {
	Controller *uint `xml:"controller,attr"`
	Bus        *uint `xml:"bus,attr"`
	Port       *uint `xml:"port,attr"`
}

func (*DomainAddressVirtioSerial) MarshalXML 

func (a *DomainAddressVirtioSerial) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressVirtioSerial) UnmarshalXML 

func (a *DomainAddressVirtioSerial) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressZPCI 

type DomainAddressZPCI struct {
	UID *uint `xml:"uid,attr,omitempty"`
	FID *uint `xml:"fid,attr,omitempty"`
}

func (*DomainAddressZPCI) MarshalXML 

func (a *DomainAddressZPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressZPCI) UnmarshalXML 

func (a *DomainAddressZPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAlias 

type DomainAlias struct {
	Name string `xml:"name,attr"`
}

type DomainAudio 

type DomainAudio struct {
	XMLName     xml.Name               `xml:"audio"`
	ID          int                    `xml:"id,attr"`
	TimerPeriod uint                   `xml:"timerPeriod,attr,omitempty"`
	None        *DomainAudioNone       `xml:"-"`
	ALSA        *DomainAudioALSA       `xml:"-"`
	CoreAudio   *DomainAudioCoreAudio  `xml:"-"`
	Jack        *DomainAudioJack       `xml:"-"`
	OSS         *DomainAudioOSS        `xml:"-"`
	PulseAudio  *DomainAudioPulseAudio `xml:"-"`
	SDL         *DomainAudioSDL        `xml:"-"`
	SPICE       *DomainAudioSPICE      `xml:"-"`
	File        *DomainAudioFile       `xml:"-"`
	DBus        *DomainAudioDBus       `xml:"-"`
	PipeWire    *DomainAudioPipeWire   `xml:"-"`
}

func (*DomainAudio) MarshalXML 

func (a *DomainAudio) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAudio) UnmarshalXML 

func (a *DomainAudio) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAudioALSA 

type DomainAudioALSA struct {
	Input  *DomainAudioALSAChannel `xml:"input"`
	Output *DomainAudioALSAChannel `xml:"output"`
}

type DomainAudioALSAChannel 

type DomainAudioALSAChannel struct {
	DomainAudioChannel
	Dev string `xml:"dev,attr,omitempty"`
}

type DomainAudioChannel 

type DomainAudioChannel struct {
	MixingEngine  string                      `xml:"mixingEngine,attr,omitempty"`
	FixedSettings string                      `xml:"fixedSettings,attr,omitempty"`
	Voices        uint                        `xml:"voices,attr,omitempty"`
	Settings      *DomainAudioChannelSettings `xml:"settings"`
	BufferLength  uint                        `xml:"bufferLength,attr,omitempty"`
}

type DomainAudioChannelSettings 

type DomainAudioChannelSettings struct {
	Frequency uint   `xml:"frequency,attr,omitempty"`
	Channels  uint   `xml:"channels,attr,omitempty"`
	Format    string `xml:"format,attr,omitempty"`
}

type DomainAudioCoreAudio 

type DomainAudioCoreAudio struct {
	Input  *DomainAudioCoreAudioChannel `xml:"input"`
	Output *DomainAudioCoreAudioChannel `xml:"output"`
}

type DomainAudioCoreAudioChannel 

type DomainAudioCoreAudioChannel struct {
	DomainAudioChannel
	BufferCount uint `xml:"bufferCount,attr,omitempty"`
}

type DomainAudioDBus added in v1.8004.0 

type DomainAudioDBus struct {
	Input  *DomainAudioDBusChannel `xml:"input"`
	Output *DomainAudioDBusChannel `xml:"output"`
}

type DomainAudioDBusChannel added in v1.8004.0 

type DomainAudioDBusChannel struct {
	DomainAudioChannel
}

type DomainAudioFile 

type DomainAudioFile struct {
	Path   string                  `xml:"path,attr,omitempty"`
	Input  *DomainAudioFileChannel `xml:"input"`
	Output *DomainAudioFileChannel `xml:"output"`
}

type DomainAudioFileChannel 

type DomainAudioFileChannel struct {
	DomainAudioChannel
}

type DomainAudioJack 

type DomainAudioJack struct {
	Input  *DomainAudioJackChannel `xml:"input"`
	Output *DomainAudioJackChannel `xml:"output"`
}

type DomainAudioJackChannel 

type DomainAudioJackChannel struct {
	DomainAudioChannel
	ServerName   string `xml:"serverName,attr,omitempty"`
	ClientName   string `xml:"clientName,attr,omitempty"`
	ConnectPorts string `xml:"connectPorts,attr,omitempty"`
	ExactName    string `xml:"exactName,attr,omitempty"`
}

type DomainAudioNone 

type DomainAudioNone struct {
	Input  *DomainAudioNoneChannel `xml:"input"`
	Output *DomainAudioNoneChannel `xml:"output"`
}

type DomainAudioNoneChannel 

type DomainAudioNoneChannel struct {
	DomainAudioChannel
}

type DomainAudioOSS 

type DomainAudioOSS struct {
	TryMMap   string `xml:"tryMMap,attr,omitempty"`
	Exclusive string `xml:"exclusive,attr,omitempty"`
	DSPPolicy *int   `xml:"dspPolicy,attr"`

	Input  *DomainAudioOSSChannel `xml:"input"`
	Output *DomainAudioOSSChannel `xml:"output"`
}

type DomainAudioOSSChannel 

type DomainAudioOSSChannel struct {
	DomainAudioChannel
	Dev         string `xml:"dev,attr,omitempty"`
	BufferCount uint   `xml:"bufferCount,attr,omitempty"`
	TryPoll     string `xml:"tryPoll,attr,omitempty"`
}

type DomainAudioPipeWire added in v1.10000.0 

type DomainAudioPipeWire struct {
	RuntimeDir string                        `xml:"runtimeDir,attr,omitempty"`
	Input      *DomainAudioPulseAudioChannel `xml:"input"`
	Output     *DomainAudioPulseAudioChannel `xml:"output"`
}

type DomainAudioPipeWireChannel added in v1.10000.0 

type DomainAudioPipeWireChannel struct {
	DomainAudioChannel
	Name       string `xml:"name,attr,omitempty"`
	StreamName string `xml:"streamName,attr,omitempty"`
	Latency    uint   `xml:"latency,attr,omitempty"`
}

type DomainAudioPulseAudio 

type DomainAudioPulseAudio struct {
	ServerName string                        `xml:"serverName,attr,omitempty"`
	Input      *DomainAudioPulseAudioChannel `xml:"input"`
	Output     *DomainAudioPulseAudioChannel `xml:"output"`
}

type DomainAudioPulseAudioChannel 

type DomainAudioPulseAudioChannel struct {
	DomainAudioChannel
	Name       string `xml:"name,attr,omitempty"`
	StreamName string `xml:"streamName,attr,omitempty"`
	Latency    uint   `xml:"latency,attr,omitempty"`
}

type DomainAudioSDL 

type DomainAudioSDL struct {
	Driver string                 `xml:"driver,attr,omitempty"`
	Input  *DomainAudioSDLChannel `xml:"input"`
	Output *DomainAudioSDLChannel `xml:"output"`
}

type DomainAudioSDLChannel 

type DomainAudioSDLChannel struct {
	DomainAudioChannel
	BufferCount uint `xml:"bufferCount,attr,omitempty"`
}

type DomainAudioSPICE 

type DomainAudioSPICE struct {
	Input  *DomainAudioSPICEChannel `xml:"input"`
	Output *DomainAudioSPICEChannel `xml:"output"`
}

type DomainAudioSPICEChannel 

type DomainAudioSPICEChannel struct {
	DomainAudioChannel
}

type DomainBHyveCommandline 

type DomainBHyveCommandline struct {
	XMLName xml.Name                    `xml:"http://libvirt.org/schemas/domain/bhyve/1.0 commandline"`
	Args    []DomainBHyveCommandlineArg `xml:"arg"`
	Envs    []DomainBHyveCommandlineEnv `xml:"env"`
}

type DomainBHyveCommandlineArg 

type DomainBHyveCommandlineArg struct {
	Value string `xml:"value,attr"`
}

type DomainBHyveCommandlineEnv 

type DomainBHyveCommandlineEnv struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr,omitempty"`
}

type DomainBIOS 

type DomainBIOS struct {
	UseSerial     string `xml:"useserial,attr,omitempty"`
	RebootTimeout *int   `xml:"rebootTimeout,attr"`
}

type DomainBackendDomain 

type DomainBackendDomain struct {
	Name string `xml:"name,attr"`
}

type DomainBlockIOTune 

type DomainBlockIOTune struct {
	Weight uint                      `xml:"weight,omitempty"`
	Device []DomainBlockIOTuneDevice `xml:"device"`
}

type DomainBlockIOTuneDevice 

type DomainBlockIOTuneDevice struct {
	Path          string `xml:"path"`
	Weight        uint   `xml:"weight,omitempty"`
	ReadIopsSec   uint   `xml:"read_iops_sec,omitempty"`
	WriteIopsSec  uint   `xml:"write_iops_sec,omitempty"`
	ReadBytesSec  uint   `xml:"read_bytes_sec,omitempty"`
	WriteBytesSec uint   `xml:"write_bytes_sec,omitempty"`
}

type DomainBootDevice 

type DomainBootDevice struct {
	Dev string `xml:"dev,attr"`
}

type DomainBootMenu 

type DomainBootMenu struct {
	Enable  string `xml:"enable,attr,omitempty"`
	Timeout string `xml:"timeout,attr,omitempty"`
}

type DomainCPU 

type DomainCPU struct {
	XMLName     xml.Name              `xml:"cpu"`
	Match       string                `xml:"match,attr,omitempty"`
	Mode        string                `xml:"mode,attr,omitempty"`
	Check       string                `xml:"check,attr,omitempty"`
	Migratable  string                `xml:"migratable,attr,omitempty"`
	Model       *DomainCPUModel       `xml:"model"`
	Vendor      string                `xml:"vendor,omitempty"`
	Topology    *DomainCPUTopology    `xml:"topology"`
	Cache       *DomainCPUCache       `xml:"cache"`
	MaxPhysAddr *DomainCPUMaxPhysAddr `xml:"maxphysaddr"`
	Features    []DomainCPUFeature    `xml:"feature"`
	Numa        *DomainNuma           `xml:"numa"`
}

func (*DomainCPU) Marshal 

func (d *DomainCPU) Marshal() (string, error)

func (*DomainCPU) Unmarshal 

func (d *DomainCPU) Unmarshal(doc string) error

type DomainCPUCache 

type DomainCPUCache struct {
	Level uint   `xml:"level,attr,omitempty"`
	Mode  string `xml:"mode,attr"`
}

type DomainCPUCacheTune 

type DomainCPUCacheTune struct {
	VCPUs   string                      `xml:"vcpus,attr,omitempty"`
	ID      string                      `xml:"id,attr,omitempty"`
	Cache   []DomainCPUCacheTuneCache   `xml:"cache"`
	Monitor []DomainCPUCacheTuneMonitor `xml:"monitor"`
}

type DomainCPUCacheTuneCache 

type DomainCPUCacheTuneCache struct {
	ID    uint   `xml:"id,attr"`
	Level uint   `xml:"level,attr"`
	Type  string `xml:"type,attr"`
	Size  uint   `xml:"size,attr"`
	Unit  string `xml:"unit,attr"`
}

type DomainCPUCacheTuneMonitor 

type DomainCPUCacheTuneMonitor struct {
	Level uint   `xml:"level,attr,omitempty"`
	VCPUs string `xml:"vcpus,attr,omitempty"`
}

type DomainCPUFeature 

type DomainCPUFeature struct {
	Policy string `xml:"policy,attr,omitempty"`
	Name   string `xml:"name,attr,omitempty"`
}

type DomainCPUMaxPhysAddr added in v1.8007.0 

type DomainCPUMaxPhysAddr struct {
	Mode  string `xml:"mode,attr"`
	Bits  uint   `xml:"bits,attr,omitempty"`
	Limit uint   `xml:"limit,attr,omitempty"`
}

type DomainCPUMemoryTune 

type DomainCPUMemoryTune struct {
	VCPUs   string                       `xml:"vcpus,attr"`
	Nodes   []DomainCPUMemoryTuneNode    `xml:"node"`
	Monitor []DomainCPUMemoryTuneMonitor `xml:"monitor"`
}

type DomainCPUMemoryTuneMonitor 

type DomainCPUMemoryTuneMonitor struct {
	Level uint   `xml:"level,attr,omitempty"`
	VCPUs string `xml:"vcpus,attr,omitempty"`
}

type DomainCPUMemoryTuneNode 

type DomainCPUMemoryTuneNode struct {
	ID        uint `xml:"id,attr"`
	Bandwidth uint `xml:"bandwidth,attr"`
}

type DomainCPUModel 

type DomainCPUModel struct {
	Fallback string `xml:"fallback,attr,omitempty"`
	Value    string `xml:",chardata"`
	VendorID string `xml:"vendor_id,attr,omitempty"`
}

type DomainCPUTopology 

type DomainCPUTopology struct {
	Sockets  int `xml:"sockets,attr,omitempty"`
	Dies     int `xml:"dies,attr,omitempty"`
	Clusters int `xml:"clusters,attr,omitempty"`
	Cores    int `xml:"cores,attr,omitempty"`
	Threads  int `xml:"threads,attr,omitempty"`
}

type DomainCPUTune 

type DomainCPUTune struct {
	Shares         *DomainCPUTuneShares         `xml:"shares"`
	Period         *DomainCPUTunePeriod         `xml:"period"`
	Quota          *DomainCPUTuneQuota          `xml:"quota"`
	GlobalPeriod   *DomainCPUTunePeriod         `xml:"global_period"`
	GlobalQuota    *DomainCPUTuneQuota          `xml:"global_quota"`
	EmulatorPeriod *DomainCPUTunePeriod         `xml:"emulator_period"`
	EmulatorQuota  *DomainCPUTuneQuota          `xml:"emulator_quota"`
	IOThreadPeriod *DomainCPUTunePeriod         `xml:"iothread_period"`
	IOThreadQuota  *DomainCPUTuneQuota          `xml:"iothread_quota"`
	VCPUPin        []DomainCPUTuneVCPUPin       `xml:"vcpupin"`
	EmulatorPin    *DomainCPUTuneEmulatorPin    `xml:"emulatorpin"`
	IOThreadPin    []DomainCPUTuneIOThreadPin   `xml:"iothreadpin"`
	VCPUSched      []DomainCPUTuneVCPUSched     `xml:"vcpusched"`
	EmulatorSched  *DomainCPUTuneEmulatorSched  `xml:"emulatorsched"`
	IOThreadSched  []DomainCPUTuneIOThreadSched `xml:"iothreadsched"`
	CacheTune      []DomainCPUCacheTune         `xml:"cachetune"`
	MemoryTune     []DomainCPUMemoryTune        `xml:"memorytune"`
}

type DomainCPUTuneEmulatorPin 

type DomainCPUTuneEmulatorPin struct {
	CPUSet string `xml:"cpuset,attr"`
}

type DomainCPUTuneEmulatorSched 

type DomainCPUTuneEmulatorSched struct {
	Scheduler string `xml:"scheduler,attr,omitempty"`
	Priority  *int   `xml:"priority,attr"`
}

type DomainCPUTuneIOThreadPin 

type DomainCPUTuneIOThreadPin struct {
	IOThread uint   `xml:"iothread,attr"`
	CPUSet   string `xml:"cpuset,attr"`
}

type DomainCPUTuneIOThreadSched 

type DomainCPUTuneIOThreadSched struct {
	IOThreads string `xml:"iothreads,attr"`
	Scheduler string `xml:"scheduler,attr,omitempty"`
	Priority  *int   `xml:"priority,attr"`
}

type DomainCPUTunePeriod 

type DomainCPUTunePeriod struct {
	Value uint64 `xml:",chardata"`
}

type DomainCPUTuneQuota 

type DomainCPUTuneQuota struct {
	Value int64 `xml:",chardata"`
}

type DomainCPUTuneShares 

type DomainCPUTuneShares struct {
	Value uint `xml:",chardata"`
}

type DomainCPUTuneVCPUPin 

type DomainCPUTuneVCPUPin struct {
	VCPU   uint   `xml:"vcpu,attr"`
	CPUSet string `xml:"cpuset,attr"`
}

type DomainCPUTuneVCPUSched 

type DomainCPUTuneVCPUSched struct {
	VCPUs     string `xml:"vcpus,attr"`
	Scheduler string `xml:"scheduler,attr,omitempty"`
	Priority  *int   `xml:"priority,attr"`
}

type DomainCaps 

type DomainCaps struct {
	XMLName       xml.Name                 `xml:"domainCapabilities"`
	Path          string                   `xml:"path"`
	Domain        string                   `xml:"domain"`
	Machine       string                   `xml:"machine,omitempty"`
	Arch          string                   `xml:"arch"`
	VCPU          *DomainCapsVCPU          `xml:"vcpu"`
	IOThreads     *DomainCapsIOThreads     `xml:"iothreads"`
	OS            *DomainCapsOS            `xml:"os"`
	CPU           *DomainCapsCPU           `xml:"cpu"`
	MemoryBacking *DomainCapsMemoryBacking `xml:"memoryBacking"`
	Devices       *DomainCapsDevices       `xml:"devices"`
	Features      *DomainCapsFeatures      `xml:"features"`
}

func (*DomainCaps) Marshal 

func (c *DomainCaps) Marshal() (string, error)

func (*DomainCaps) Unmarshal 

func (c *DomainCaps) Unmarshal(doc string) error

type DomainCapsCPU 

type DomainCapsCPU struct {
	Modes []DomainCapsCPUMode `xml:"mode"`
}

type DomainCapsCPUFeature 

type DomainCapsCPUFeature struct {
	Policy string `xml:"policy,attr,omitempty"`
	Name   string `xml:"name,attr"`
}

type DomainCapsCPUMaxPhysAddr added in v1.9005.0 

type DomainCapsCPUMaxPhysAddr struct {
	Mode  string `xml:"mode,attr"`
	Limit uint   `xml:"limit,attr"`
}

type DomainCapsCPUMode 

type DomainCapsCPUMode struct {
	Name        string                    `xml:"name,attr"`
	Supported   string                    `xml:"supported,attr"`
	Models      []DomainCapsCPUModel      `xml:"model"`
	Vendor      string                    `xml:"vendor,omitempty"`
	MaxPhysAddr *DomainCapsCPUMaxPhysAddr `xml:"maxphysaddr"`
	Features    []DomainCapsCPUFeature    `xml:"feature"`
	Enums       []DomainCapsEnum          `xml:"enum"`
}

type DomainCapsCPUModel 

type DomainCapsCPUModel struct {
	Name       string `xml:",chardata"`
	Usable     string `xml:"usable,attr,omitempty"`
	Fallback   string `xml:"fallback,attr,omitempty"`
	Deprecated string `xml:"deprecated,attr,omitempty"`
	Vendor     string `xml:"vendor,attr,omitempty"`
}

type DomainCapsDevice 

type DomainCapsDevice struct {
	Supported string           `xml:"supported,attr"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsDevices 

type DomainCapsDevices struct {
	Disk       *DomainCapsDevice `xml:"disk"`
	Graphics   *DomainCapsDevice `xml:"graphics"`
	Video      *DomainCapsDevice `xml:"video"`
	HostDev    *DomainCapsDevice `xml:"hostdev"`
	RNG        *DomainCapsDevice `xml:"rng"`
	FileSystem *DomainCapsDevice `xml:"filesystem"`
	TPM        *DomainCapsDevice `xml:"tpm"`
	Redirdev   *DomainCapsDevice `xml:"redirdev"`
	Channel    *DomainCapsDevice `xml:"channel"`
	Crypto     *DomainCapsDevice `xml:"crypto"`
	Interface  *DomainCapsDevice `xml:"interface"`
}

type DomainCapsEnum 

type DomainCapsEnum struct {
	Name   string   `xml:"name,attr"`
	Values []string `xml:"value"`
}

type DomainCapsFeatureAsyncTeardown added in v1.9006.0 

type DomainCapsFeatureAsyncTeardown struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsFeatureBackingStoreInput 

type DomainCapsFeatureBackingStoreInput struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsFeatureBackup 

type DomainCapsFeatureBackup struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsFeatureGIC 

type DomainCapsFeatureGIC struct {
	Supported string           `xml:"supported,attr"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsFeatureGenID 

type DomainCapsFeatureGenID struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsFeatureHyperV added in v1.9000.0 

type DomainCapsFeatureHyperV struct {
	Supported string           `xml:"supported,attr"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsFeatureLaunchSecurity added in v1.10005.0 

type DomainCapsFeatureLaunchSecurity struct {
	Supported string           `xml:"supported,attr"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsFeaturePS2 added in v1.10007.0 

type DomainCapsFeaturePS2 struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsFeatureS390PV added in v1.7006.0 

type DomainCapsFeatureS390PV struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsFeatureSEV 

type DomainCapsFeatureSEV struct {
	Supported       string `xml:"supported,attr"`
	CBitPos         uint   `xml:"cbitpos,omitempty"`
	ReducedPhysBits uint   `xml:"reducedPhysBits,omitempty"`
	MaxGuests       uint   `xml:"maxGuests,omitempty"`
	MaxESGuests     uint   `xml:"maxESGuests,omitempty"`
}

type DomainCapsFeatureSGX added in v1.8010.0 

type DomainCapsFeatureSGX struct {
	Supported   string                           `xml:"supported,attr"`
	FLC         *DomainCapsFeatureSGXFeature     `xml:"flc"`
	SGX1        *DomainCapsFeatureSGXFeature     `xml:"sgx1"`
	SGX2        *DomainCapsFeatureSGXFeature     `xml:"sgx2"`
	SectionSize *DomainCapsFeatureSGXSectionSize `xml:"section_size"`
	Sections    *[]DomainCapsFeatureSGXSection   `xml:"sections>section"`
}

type DomainCapsFeatureSGXFeature added in v1.8010.0 

type DomainCapsFeatureSGXFeature struct {
	Supported string `xml:",chardata"`
}

type DomainCapsFeatureSGXSection added in v1.8010.0 

type DomainCapsFeatureSGXSection struct {
	Node uint   `xml:"node,attr"`
	Size uint   `xml:"size,attr"`
	Unit string `xml:"unit,attr"`
}

type DomainCapsFeatureSGXSectionSize added in v1.8010.0 

type DomainCapsFeatureSGXSectionSize struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

type DomainCapsFeatureVMCoreInfo 

type DomainCapsFeatureVMCoreInfo struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsFeatures 

type DomainCapsFeatures struct {
	GIC               *DomainCapsFeatureGIC               `xml:"gic"`
	VMCoreInfo        *DomainCapsFeatureVMCoreInfo        `xml:"vmcoreinfo"`
	GenID             *DomainCapsFeatureGenID             `xml:"genid"`
	BackingStoreInput *DomainCapsFeatureBackingStoreInput `xml:"backingStoreInput"`
	Backup            *DomainCapsFeatureBackup            `xml:"backup"`
	AsyncTeardown     *DomainCapsFeatureAsyncTeardown     `xml:"async-teardown"`
	S390PV            *DomainCapsFeatureS390PV            `xml:"s390-pv"`
	PS2               *DomainCapsFeaturePS2               `xml:"ps2"`
	SEV               *DomainCapsFeatureSEV               `xml:"sev"`
	SGX               *DomainCapsFeatureSGX               `xml:"sgx"`
	HyperV            *DomainCapsFeatureHyperV            `xml:"hyperv"`
	LaunchSecurity    *DomainCapsFeatureLaunchSecurity    `xml:"launchSecurity"`
}

type DomainCapsIOThreads 

type DomainCapsIOThreads struct {
	Supported string `xml:"supported,attr"`
}

type DomainCapsMemoryBacking added in v1.7006.0 

type DomainCapsMemoryBacking struct {
	Supported string           `xml:"supported,attr"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsOS 

type DomainCapsOS struct {
	Supported string              `xml:"supported,attr"`
	Loader    *DomainCapsOSLoader `xml:"loader"`
	Enums     []DomainCapsEnum    `xml:"enum"`
}

type DomainCapsOSLoader 

type DomainCapsOSLoader struct {
	Supported string           `xml:"supported,attr"`
	Values    []string         `xml:"value"`
	Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsVCPU 

type DomainCapsVCPU struct {
	Max uint `xml:"max,attr"`
}

type DomainCell 

type DomainCell struct {
	ID        *uint                `xml:"id,attr"`
	CPUs      string               `xml:"cpus,attr,omitempty"`
	Memory    uint                 `xml:"memory,attr"`
	Unit      string               `xml:"unit,attr,omitempty"`
	MemAccess string               `xml:"memAccess,attr,omitempty"`
	Discard   string               `xml:"discard,attr,omitempty"`
	Distances *DomainCellDistances `xml:"distances"`
	Caches    []DomainCellCache    `xml:"cache"`
}

type DomainCellCache 

type DomainCellCache struct {
	Level         uint                `xml:"level,attr"`
	Associativity string              `xml:"associativity,attr"`
	Policy        string              `xml:"policy,attr"`
	Size          DomainCellCacheSize `xml:"size"`
	Line          DomainCellCacheLine `xml:"line"`
}

type DomainCellCacheLine 

type DomainCellCacheLine struct {
	Value string `xml:"value,attr"`
	Unit  string `xml:"unit,attr"`
}

type DomainCellCacheSize 

type DomainCellCacheSize struct {
	Value string `xml:"value,attr"`
	Unit  string `xml:"unit,attr"`
}

type DomainCellDistances 

type DomainCellDistances struct {
	Siblings []DomainCellSibling `xml:"sibling"`
}

type DomainCellSibling 

type DomainCellSibling struct {
	ID    uint `xml:"id,attr"`
	Value uint `xml:"value,attr"`
}

type DomainChannel 

type DomainChannel struct {
	XMLName  xml.Name               `xml:"channel"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Target   *DomainChannelTarget   `xml:"target"`
	Log      *DomainChardevLog      `xml:"log"`
	ACPI     *DomainDeviceACPI      `xml:"acpi"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

func (*DomainChannel) Marshal 

func (d *DomainChannel) Marshal() (string, error)

func (*DomainChannel) MarshalXML 

func (a *DomainChannel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainChannel) Unmarshal 

func (d *DomainChannel) Unmarshal(doc string) error

func (*DomainChannel) UnmarshalXML 

func (a *DomainChannel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainChannelTarget 

type DomainChannelTarget struct {
	VirtIO   *DomainChannelTargetVirtIO   `xml:"-"`
	Xen      *DomainChannelTargetXen      `xml:"-"`
	GuestFWD *DomainChannelTargetGuestFWD `xml:"-"`
}

func (*DomainChannelTarget) MarshalXML 

func (a *DomainChannelTarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainChannelTarget) UnmarshalXML 

func (a *DomainChannelTarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainChannelTargetGuestFWD 

type DomainChannelTargetGuestFWD struct {
	Address string `xml:"address,attr,omitempty"`
	Port    string `xml:"port,attr,omitempty"`
}

type DomainChannelTargetVirtIO 

type DomainChannelTargetVirtIO struct {
	Name  string `xml:"name,attr,omitempty"`
	State string `xml:"state,attr,omitempty"` // is guest agent connected?
}

type DomainChannelTargetXen 

type DomainChannelTargetXen struct {
	Name  string `xml:"name,attr,omitempty"`
	State string `xml:"state,attr,omitempty"` // is guest agent connected?
}

type DomainChardevLog 

type DomainChardevLog struct {
	File   string `xml:"file,attr"`
	Append string `xml:"append,attr,omitempty"`
}

type DomainChardevProtocol 

type DomainChardevProtocol struct {
	Type string `xml:"type,attr"`
}

type DomainChardevSource 

type DomainChardevSource struct {
	Null        *DomainChardevSourceNull        `xml:"-"`
	VC          *DomainChardevSourceVC          `xml:"-"`
	Pty         *DomainChardevSourcePty         `xml:"-"`
	Dev         *DomainChardevSourceDev         `xml:"-"`
	File        *DomainChardevSourceFile        `xml:"-"`
	Pipe        *DomainChardevSourcePipe        `xml:"-"`
	StdIO       *DomainChardevSourceStdIO       `xml:"-"`
	UDP         *DomainChardevSourceUDP         `xml:"-"`
	TCP         *DomainChardevSourceTCP         `xml:"-"`
	UNIX        *DomainChardevSourceUNIX        `xml:"-"`
	SpiceVMC    *DomainChardevSourceSpiceVMC    `xml:"-"`
	SpicePort   *DomainChardevSourceSpicePort   `xml:"-"`
	NMDM        *DomainChardevSourceNMDM        `xml:"-"`
	QEMUVDAgent *DomainChardevSourceQEMUVDAgent `xml:"-"`
	DBus        *DomainChardevSourceDBus        `xml:"-"`
}

func (*DomainChardevSource) MarshalXML 

func (a *DomainChardevSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainChardevSource) UnmarshalXML 

func (a *DomainChardevSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainChardevSourceDBus added in v1.8004.0 

type DomainChardevSourceDBus struct {
	Channel string `xml:"channel,attr,omitempty"`
}

type DomainChardevSourceDev 

type DomainChardevSourceDev struct {
	Path     string                 `xml:"path,attr"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourceFile 

type DomainChardevSourceFile struct {
	Path     string                 `xml:"path,attr"`
	Append   string                 `xml:"append,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourceNMDM 

type DomainChardevSourceNMDM struct {
	Master string `xml:"master,attr"`
	Slave  string `xml:"slave,attr"`
}

type DomainChardevSourceNull 

type DomainChardevSourceNull struct {
}

type DomainChardevSourcePipe 

type DomainChardevSourcePipe struct {
	Path     string                 `xml:"path,attr"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourcePty 

type DomainChardevSourcePty struct {
	Path     string                 `xml:"path,attr"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourceQEMUVDAgent added in v1.8004.0 

type DomainChardevSourceQEMUVDAgent struct {
	Mouse     *DomainChardevSourceQEMUVDAgentMouse     `xml:"mouse"`
	ClipBoard *DomainChardevSourceQEMUVDAgentClipBoard `xml:"clipboard"`
}

type DomainChardevSourceQEMUVDAgentClipBoard added in v1.8004.0 

type DomainChardevSourceQEMUVDAgentClipBoard struct {
	CopyPaste string `xml:"copypaste,attr"`
}

type DomainChardevSourceQEMUVDAgentMouse added in v1.8004.0 

type DomainChardevSourceQEMUVDAgentMouse struct {
	Mode string `xml:"mode,attr"`
}

type DomainChardevSourceReconnect 

type DomainChardevSourceReconnect struct {
	Enabled string `xml:"enabled,attr"`
	Timeout *uint  `xml:"timeout,attr"`
}

type DomainChardevSourceSpicePort 

type DomainChardevSourceSpicePort struct {
	Channel string `xml:"channel,attr"`
}

type DomainChardevSourceSpiceVMC 

type DomainChardevSourceSpiceVMC struct {
}

type DomainChardevSourceStdIO 

type DomainChardevSourceStdIO struct {
}

type DomainChardevSourceTCP 

type DomainChardevSourceTCP struct {
	Mode      string                        `xml:"mode,attr,omitempty"`
	Host      string                        `xml:"host,attr,omitempty"`
	Service   string                        `xml:"service,attr,omitempty"`
	TLS       string                        `xml:"tls,attr,omitempty"`
	Reconnect *DomainChardevSourceReconnect `xml:"reconnect"`
}

type DomainChardevSourceUDP 

type DomainChardevSourceUDP struct {
	BindHost       string `xml:"-"`
	BindService    string `xml:"-"`
	ConnectHost    string `xml:"-"`
	ConnectService string `xml:"-"`
}

type DomainChardevSourceUNIX 

type DomainChardevSourceUNIX struct {
	Mode      string                        `xml:"mode,attr,omitempty"`
	Path      string                        `xml:"path,attr,omitempty"`
	Reconnect *DomainChardevSourceReconnect `xml:"reconnect"`
	SecLabel  []DomainDeviceSecLabel        `xml:"seclabel"`
}

type DomainChardevSourceVC 

type DomainChardevSourceVC struct {
}

type DomainChardevTarget 

type DomainChardevTarget struct {
	Type  string `xml:"type,attr,omitempty"`
	Name  string `xml:"name,attr,omitempty"`
	State string `xml:"state,attr,omitempty"` // is guest agent connected?
	Port  *uint  `xml:"port,attr"`
}

type DomainClock 

type DomainClock struct {
	Offset     string        `xml:"offset,attr,omitempty"`
	Basis      string        `xml:"basis,attr,omitempty"`
	Adjustment string        `xml:"adjustment,attr,omitempty"`
	TimeZone   string        `xml:"timezone,attr,omitempty"`
	Start      uint          `xml:"start,attr,omitempty"`
	Timer      []DomainTimer `xml:"timer"`
}

type DomainConsole 

type DomainConsole struct {
	XMLName  xml.Name               `xml:"console"`
	TTY      string                 `xml:"tty,attr,omitempty"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Target   *DomainConsoleTarget   `xml:"target"`
	Log      *DomainChardevLog      `xml:"log"`
	ACPI     *DomainDeviceACPI      `xml:"acpi"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

func (*DomainConsole) Marshal 

func (d *DomainConsole) Marshal() (string, error)

func (*DomainConsole) MarshalXML 

func (a *DomainConsole) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainConsole) Unmarshal 

func (d *DomainConsole) Unmarshal(doc string) error

func (*DomainConsole) UnmarshalXML 

func (a *DomainConsole) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainConsoleTarget 

type DomainConsoleTarget struct {
	Type string `xml:"type,attr,omitempty"`
	Port *uint  `xml:"port,attr"`
}

type DomainController 

type DomainController struct {
	XMLName      xml.Name                      `xml:"controller"`
	Type         string                        `xml:"type,attr"`
	Index        *uint                         `xml:"index,attr"`
	Model        string                        `xml:"model,attr,omitempty"`
	Driver       *DomainControllerDriver       `xml:"driver"`
	PCI          *DomainControllerPCI          `xml:"-"`
	USB          *DomainControllerUSB          `xml:"-"`
	VirtIOSerial *DomainControllerVirtIOSerial `xml:"-"`
	XenBus       *DomainControllerXenBus       `xml:"-"`
	ACPI         *DomainDeviceACPI             `xml:"acpi"`
	Alias        *DomainAlias                  `xml:"alias"`
	Address      *DomainAddress                `xml:"address"`
}

func (*DomainController) Marshal 

func (d *DomainController) Marshal() (string, error)

func (*DomainController) MarshalXML 

func (a *DomainController) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainController) Unmarshal 

func (d *DomainController) Unmarshal(doc string) error

func (*DomainController) UnmarshalXML 

func (a *DomainController) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainControllerDriver 

type DomainControllerDriver struct {
	Queues     *uint  `xml:"queues,attr"`
	CmdPerLUN  *uint  `xml:"cmd_per_lun,attr"`
	MaxSectors *uint  `xml:"max_sectors,attr"`
	IOEventFD  string `xml:"ioeventfd,attr,omitempty"`
	IOThread   uint   `xml:"iothread,attr,omitempty"`
	IOMMU      string `xml:"iommu,attr,omitempty"`
	ATS        string `xml:"ats,attr,omitempty"`
	Packed     string `xml:"packed,attr,omitempty"`
	PagePerVQ  string `xml:"page_per_vq,attr,omitempty"`
}

type DomainControllerPCI 

type DomainControllerPCI struct {
	Model  *DomainControllerPCIModel  `xml:"model"`
	Target *DomainControllerPCITarget `xml:"target"`
	Hole64 *DomainControllerPCIHole64 `xml:"pcihole64"`
}

type DomainControllerPCIHole64 

type DomainControllerPCIHole64 struct {
	Size uint64 `xml:",chardata"`
	Unit string `xml:"unit,attr,omitempty"`
}

type DomainControllerPCIModel 

type DomainControllerPCIModel struct {
	Name string `xml:"name,attr"`
}

type DomainControllerPCITarget 

type DomainControllerPCITarget struct {
	ChassisNr  *uint
	Chassis    *uint
	Port       *uint
	BusNr      *uint
	Index      *uint
	NUMANode   *uint
	Hotplug    string
	MemReserve *uint64
}

func (*DomainControllerPCITarget) MarshalXML 

func (a *DomainControllerPCITarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainControllerPCITarget) UnmarshalXML 

func (a *DomainControllerPCITarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainControllerUSB 

type DomainControllerUSB struct {
	Port   *uint                      `xml:"ports,attr"`
	Master *DomainControllerUSBMaster `xml:"master"`
}

type DomainControllerUSBMaster 

type DomainControllerUSBMaster struct {
	StartPort uint `xml:"startport,attr"`
}

type DomainControllerVirtIOSerial 

type DomainControllerVirtIOSerial struct {
	Ports   *uint `xml:"ports,attr"`
	Vectors *uint `xml:"vectors,attr"`
}

type DomainControllerXenBus 

type DomainControllerXenBus struct {
	MaxGrantFrames   uint `xml:"maxGrantFrames,attr,omitempty"`
	MaxEventChannels uint `xml:"maxEventChannels,attr,omitempty"`
}

type DomainCrypto added in v1.9001.0 

type DomainCrypto struct {
	Model   string               `xml:"model,attr,omitempty"`
	Type    string               `xml:"type,attr,omitempty"`
	Backend *DomainCryptoBackend `xml:"backend"`
	Alias   *DomainAlias         `xml:"alias"`
	Address *DomainAddress       `xml:"address"`
}

type DomainCryptoBackend added in v1.9001.0 

type DomainCryptoBackend struct {
	BuiltIn *DomainCryptoBackendBuiltIn `xml:"-"`
	LKCF    *DomainCryptoBackendLKCF    `xml:"-"`
	Queues  uint                        `xml:"queues,attr,omitempty"`
}

func (*DomainCryptoBackend) MarshalXML added in v1.9001.0 

func (a *DomainCryptoBackend) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainCryptoBackend) UnmarshalXML added in v1.9001.0 

func (a *DomainCryptoBackend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainCryptoBackendBuiltIn added in v1.9001.0 

type DomainCryptoBackendBuiltIn struct {
}

type DomainCryptoBackendLKCF added in v1.9001.0 

type DomainCryptoBackendLKCF struct {
}

type DomainCurrentMemory 

type DomainCurrentMemory struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

type DomainDefaultIOThread added in v1.8005.0 

type DomainDefaultIOThread struct {
	PoolMin *uint `xml:"thread_pool_min,attr"`
	PoolMax *uint `xml:"thread_pool_max,attr"`
}

type DomainDeviceACPI 

type DomainDeviceACPI struct {
	Index uint `xml:"index,attr,omitempty"`
}

type DomainDeviceBoot 

type DomainDeviceBoot struct {
	Order    uint   `xml:"order,attr"`
	LoadParm string `xml:"loadparm,attr,omitempty"`
}

type DomainDeviceList 

type DomainDeviceList struct {
	Emulator     string              `xml:"emulator,omitempty"`
	Disks        []DomainDisk        `xml:"disk"`
	Controllers  []DomainController  `xml:"controller"`
	Leases       []DomainLease       `xml:"lease"`
	Filesystems  []DomainFilesystem  `xml:"filesystem"`
	Interfaces   []DomainInterface   `xml:"interface"`
	Smartcards   []DomainSmartcard   `xml:"smartcard"`
	Serials      []DomainSerial      `xml:"serial"`
	Parallels    []DomainParallel    `xml:"parallel"`
	Consoles     []DomainConsole     `xml:"console"`
	Channels     []DomainChannel     `xml:"channel"`
	Inputs       []DomainInput       `xml:"input"`
	TPMs         []DomainTPM         `xml:"tpm"`
	Graphics     []DomainGraphic     `xml:"graphics"`
	Sounds       []DomainSound       `xml:"sound"`
	Audios       []DomainAudio       `xml:"audio"`
	Videos       []DomainVideo       `xml:"video"`
	Hostdevs     []DomainHostdev     `xml:"hostdev"`
	RedirDevs    []DomainRedirDev    `xml:"redirdev"`
	RedirFilters []DomainRedirFilter `xml:"redirfilter"`
	Hubs         []DomainHub         `xml:"hub"`
	Watchdogs    []DomainWatchdog    `xml:"watchdog"`
	MemBalloon   *DomainMemBalloon   `xml:"memballoon"`
	RNGs         []DomainRNG         `xml:"rng"`
	NVRAM        *DomainNVRAM        `xml:"nvram"`
	Panics       []DomainPanic       `xml:"panic"`
	Shmems       []DomainShmem       `xml:"shmem"`
	Memorydevs   []DomainMemorydev   `xml:"memory"`
	IOMMU        *DomainIOMMU        `xml:"iommu"`
	VSock        *DomainVSock        `xml:"vsock"`
	Crypto       []DomainCrypto      `xml:"crypto"`
	PStore       *DomainPStore       `xml:"pstore"`
}

type DomainDeviceSecLabel 

type DomainDeviceSecLabel struct {
	Model     string `xml:"model,attr,omitempty"`
	LabelSkip string `xml:"labelskip,attr,omitempty"`
	Relabel   string `xml:"relabel,attr,omitempty"`
	Label     string `xml:"label,omitempty"`
}

type DomainDisk 

type DomainDisk struct {
	XMLName       xml.Name                `xml:"disk"`
	Device        string                  `xml:"device,attr,omitempty"`
	RawIO         string                  `xml:"rawio,attr,omitempty"`
	SGIO          string                  `xml:"sgio,attr,omitempty"`
	Snapshot      string                  `xml:"snapshot,attr,omitempty"`
	Model         string                  `xml:"model,attr,omitempty"`
	Driver        *DomainDiskDriver       `xml:"driver"`
	Auth          *DomainDiskAuth         `xml:"auth"`
	Source        *DomainDiskSource       `xml:"source"`
	BackingStore  *DomainDiskBackingStore `xml:"backingStore"`
	BackendDomain *DomainBackendDomain    `xml:"backenddomain"`
	Geometry      *DomainDiskGeometry     `xml:"geometry"`
	BlockIO       *DomainDiskBlockIO      `xml:"blockio"`
	Mirror        *DomainDiskMirror       `xml:"mirror"`
	Target        *DomainDiskTarget       `xml:"target"`
	IOTune        *DomainDiskIOTune       `xml:"iotune"`
	ReadOnly      *DomainDiskReadOnly     `xml:"readonly"`
	Shareable     *DomainDiskShareable    `xml:"shareable"`
	Transient     *DomainDiskTransient    `xml:"transient"`
	Serial        string                  `xml:"serial,omitempty"`
	WWN           string                  `xml:"wwn,omitempty"`
	Vendor        string                  `xml:"vendor,omitempty"`
	Product       string                  `xml:"product,omitempty"`
	Encryption    *DomainDiskEncryption   `xml:"encryption"`
	Boot          *DomainDeviceBoot       `xml:"boot"`
	ACPI          *DomainDeviceACPI       `xml:"acpi"`
	Alias         *DomainAlias            `xml:"alias"`
	Address       *DomainAddress          `xml:"address"`
}

func (*DomainDisk) Marshal 

func (d *DomainDisk) Marshal() (string, error)

func (*DomainDisk) MarshalXML 

func (a *DomainDisk) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDisk) Unmarshal 

func (d *DomainDisk) Unmarshal(doc string) error

func (*DomainDisk) UnmarshalXML 

func (a *DomainDisk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskAuth 

type DomainDiskAuth struct {
	Username string            `xml:"username,attr,omitempty"`
	Secret   *DomainDiskSecret `xml:"secret"`
}

type DomainDiskBackingStore 

type DomainDiskBackingStore struct {
	Index        uint                    `xml:"index,attr,omitempty"`
	Format       *DomainDiskFormat       `xml:"format"`
	Source       *DomainDiskSource       `xml:"source"`
	BackingStore *DomainDiskBackingStore `xml:"backingStore"`
}

func (*DomainDiskBackingStore) MarshalXML 

func (a *DomainDiskBackingStore) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskBackingStore) UnmarshalXML 

func (a *DomainDiskBackingStore) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskBlockIO 

type DomainDiskBlockIO struct {
	LogicalBlockSize   uint `xml:"logical_block_size,attr,omitempty"`
	PhysicalBlockSize  uint `xml:"physical_block_size,attr,omitempty"`
	DiscardGranularity uint `xml:"discard_granularity,attr,omitempty"`
}

type DomainDiskCookie 

type DomainDiskCookie struct {
	Name  string `xml:"name,attr"`
	Value string `xml:",chardata"`
}

type DomainDiskCookies 

type DomainDiskCookies struct {
	Cookies []DomainDiskCookie `xml:"cookie"`
}

type DomainDiskDriver 

type DomainDiskDriver struct {
	Name           string                   `xml:"name,attr,omitempty"`
	Type           string                   `xml:"type,attr,omitempty"`
	Cache          string                   `xml:"cache,attr,omitempty"`
	ErrorPolicy    string                   `xml:"error_policy,attr,omitempty"`
	RErrorPolicy   string                   `xml:"rerror_policy,attr,omitempty"`
	IO             string                   `xml:"io,attr,omitempty"`
	IOEventFD      string                   `xml:"ioeventfd,attr,omitempty"`
	EventIDX       string                   `xml:"event_idx,attr,omitempty"`
	CopyOnRead     string                   `xml:"copy_on_read,attr,omitempty"`
	Discard        string                   `xml:"discard,attr,omitempty"`
	DiscardNoUnref string                   `xml:"discard_no_unref,attr,omitempty"`
	IOThread       *uint                    `xml:"iothread,attr"`
	IOThreads      *DomainDiskIOThreads     `xml:"iothreads"`
	DetectZeros    string                   `xml:"detect_zeroes,attr,omitempty"`
	Queues         *uint                    `xml:"queues,attr"`
	QueueSize      *uint                    `xml:"queue_size,attr"`
	IOMMU          string                   `xml:"iommu,attr,omitempty"`
	ATS            string                   `xml:"ats,attr,omitempty"`
	Packed         string                   `xml:"packed,attr,omitempty"`
	PagePerVQ      string                   `xml:"page_per_vq,attr,omitempty"`
	MetadataCache  *DomainDiskMetadataCache `xml:"metadata_cache"`
}

type DomainDiskEncryption 

type DomainDiskEncryption struct {
	Format  string             `xml:"format,attr,omitempty"`
	Engine  string             `xml:"engine,attr,omitempty"`
	Secrets []DomainDiskSecret `xml:"secret"`
}

type DomainDiskFormat 

type DomainDiskFormat struct {
	Type          string                   `xml:"type,attr"`
	MetadataCache *DomainDiskMetadataCache `xml:"metadata_cache"`
}

type DomainDiskGeometry 

type DomainDiskGeometry struct {
	Cylinders uint   `xml:"cyls,attr"`
	Headers   uint   `xml:"heads,attr"`
	Sectors   uint   `xml:"secs,attr"`
	Trans     string `xml:"trans,attr,omitempty"`
}

type DomainDiskIOThread added in v1.10000.0 

type DomainDiskIOThread struct {
	ID     uint                      `xml:"id,attr"`
	Queues []DomainDiskIOThreadQueue `xml:"queue"`
}

type DomainDiskIOThreadQueue added in v1.10000.0 

type DomainDiskIOThreadQueue struct {
	ID uint `xml:"id,attr"`
}

type DomainDiskIOThreads added in v1.10000.0 

type DomainDiskIOThreads struct {
	IOThread []DomainDiskIOThread `xml:"iothread"`
}

type DomainDiskIOTune 

type DomainDiskIOTune struct {
	TotalBytesSec          uint64 `xml:"total_bytes_sec,omitempty"`
	ReadBytesSec           uint64 `xml:"read_bytes_sec,omitempty"`
	WriteBytesSec          uint64 `xml:"write_bytes_sec,omitempty"`
	TotalIopsSec           uint64 `xml:"total_iops_sec,omitempty"`
	ReadIopsSec            uint64 `xml:"read_iops_sec,omitempty"`
	WriteIopsSec           uint64 `xml:"write_iops_sec,omitempty"`
	TotalBytesSecMax       uint64 `xml:"total_bytes_sec_max,omitempty"`
	ReadBytesSecMax        uint64 `xml:"read_bytes_sec_max,omitempty"`
	WriteBytesSecMax       uint64 `xml:"write_bytes_sec_max,omitempty"`
	TotalIopsSecMax        uint64 `xml:"total_iops_sec_max,omitempty"`
	ReadIopsSecMax         uint64 `xml:"read_iops_sec_max,omitempty"`
	WriteIopsSecMax        uint64 `xml:"write_iops_sec_max,omitempty"`
	TotalBytesSecMaxLength uint64 `xml:"total_bytes_sec_max_length,omitempty"`
	ReadBytesSecMaxLength  uint64 `xml:"read_bytes_sec_max_length,omitempty"`
	WriteBytesSecMaxLength uint64 `xml:"write_bytes_sec_max_length,omitempty"`
	TotalIopsSecMaxLength  uint64 `xml:"total_iops_sec_max_length,omitempty"`
	ReadIopsSecMaxLength   uint64 `xml:"read_iops_sec_max_length,omitempty"`
	WriteIopsSecMaxLength  uint64 `xml:"write_iops_sec_max_length,omitempty"`
	SizeIopsSec            uint64 `xml:"size_iops_sec,omitempty"`
	GroupName              string `xml:"group_name,omitempty"`
}

type DomainDiskMetadataCache 

type DomainDiskMetadataCache struct {
	MaxSize *DomainDiskMetadataCacheSize `xml:"max_size"`
}

type DomainDiskMetadataCacheSize 

type DomainDiskMetadataCacheSize struct {
	Unit  string `xml:"unit,attr,omitempty"`
	Value int    `xml:",cdata"`
}

type DomainDiskMirror 

type DomainDiskMirror struct {
	Job          string                  `xml:"job,attr,omitempty"`
	Ready        string                  `xml:"ready,attr,omitempty"`
	Format       *DomainDiskFormat       `xml:"format"`
	Source       *DomainDiskSource       `xml:"source"`
	BackingStore *DomainDiskBackingStore `xml:"backingStore"`
}

func (*DomainDiskMirror) MarshalXML 

func (a *DomainDiskMirror) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskMirror) UnmarshalXML 

func (a *DomainDiskMirror) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskReadOnly 

type DomainDiskReadOnly struct {
}

type DomainDiskReservations 

type DomainDiskReservations struct {
	Enabled string                        `xml:"enabled,attr,omitempty"`
	Managed string                        `xml:"managed,attr,omitempty"`
	Source  *DomainDiskReservationsSource `xml:"source"`
}

type DomainDiskReservationsSource 

type DomainDiskReservationsSource DomainChardevSource

func (*DomainDiskReservationsSource) MarshalXML 

func (a *DomainDiskReservationsSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskReservationsSource) UnmarshalXML 

func (a *DomainDiskReservationsSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskSecret 

type DomainDiskSecret struct {
	Type  string `xml:"type,attr,omitempty"`
	Usage string `xml:"usage,attr,omitempty"`
	UUID  string `xml:"uuid,attr,omitempty"`
}

type DomainDiskShareable 

type DomainDiskShareable struct {
}

type DomainDiskSlice 

type DomainDiskSlice struct {
	Type   string `xml:"type,attr"`
	Offset uint   `xml:"offset,attr"`
	Size   uint   `xml:"size,attr"`
}

type DomainDiskSlices 

type DomainDiskSlices struct {
	Slices []DomainDiskSlice `xml:"slice"`
}

type DomainDiskSource 

type DomainDiskSource struct {
	File          *DomainDiskSourceFile      `xml:"-"`
	Block         *DomainDiskSourceBlock     `xml:"-"`
	Dir           *DomainDiskSourceDir       `xml:"-"`
	Network       *DomainDiskSourceNetwork   `xml:"-"`
	Volume        *DomainDiskSourceVolume    `xml:"-"`
	NVME          *DomainDiskSourceNVME      `xml:"-"`
	VHostUser     *DomainDiskSourceVHostUser `xml:"-"`
	VHostVDPA     *DomainDiskSourceVHostVDPA `xml:"-"`
	StartupPolicy string                     `xml:"startupPolicy,attr,omitempty"`
	Index         uint                       `xml:"index,attr,omitempty"`
	Encryption    *DomainDiskEncryption      `xml:"encryption"`
	Reservations  *DomainDiskReservations    `xml:"reservations"`
	Slices        *DomainDiskSlices          `xml:"slices"`
	SSL           *DomainDiskSourceSSL       `xml:"ssl"`
	Cookies       *DomainDiskCookies         `xml:"cookies"`
	Readahead     *DomainDiskSourceReadahead `xml:"readahead"`
	Timeout       *DomainDiskSourceTimeout   `xml:"timeout"`
}

func (*DomainDiskSource) MarshalXML 

func (a *DomainDiskSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskSource) UnmarshalXML 

func (a *DomainDiskSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskSourceBlock 

type DomainDiskSourceBlock struct {
	Dev      string                 `xml:"dev,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainDiskSourceDir 

type DomainDiskSourceDir struct {
	Dir string `xml:"dir,attr,omitempty"`
}

type DomainDiskSourceFile 

type DomainDiskSourceFile struct {
	File     string                 `xml:"file,attr,omitempty"`
	FDGroup  string                 `xml:"fdgroup,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainDiskSourceHost 

type DomainDiskSourceHost struct {
	Transport string `xml:"transport,attr,omitempty"`
	Name      string `xml:"name,attr,omitempty"`
	Port      string `xml:"port,attr,omitempty"`
	Socket    string `xml:"socket,attr,omitempty"`
}

type DomainDiskSourceNVME 

type DomainDiskSourceNVME struct {
	PCI *DomainDiskSourceNVMEPCI
}

type DomainDiskSourceNVMEPCI 

type DomainDiskSourceNVMEPCI struct {
	Managed   string            `xml:"managed,attr,omitempty"`
	Namespace uint64            `xml:"namespace,attr,omitempty"`
	Address   *DomainAddressPCI `xml:"address"`
}

type DomainDiskSourceNetwork 

type DomainDiskSourceNetwork struct {
	Protocol    string                             `xml:"protocol,attr,omitempty"`
	Name        string                             `xml:"name,attr,omitempty"`
	Query       string                             `xml:"query,attr,omitempty"`
	TLS         string                             `xml:"tls,attr,omitempty"`
	TLSHostname string                             `xml:"tlsHostname,attr,omitempty"`
	Hosts       []DomainDiskSourceHost             `xml:"host"`
	Identity    *DomainDiskSourceNetworkIdentity   `xml:"identity"`
	KnownHosts  *DomainDiskSourceNetworkKnownHosts `xml:"knownHosts"`
	Initiator   *DomainDiskSourceNetworkInitiator  `xml:"initiator"`
	Snapshot    *DomainDiskSourceNetworkSnapshot   `xml:"snapshot"`
	Config      *DomainDiskSourceNetworkConfig     `xml:"config"`
	Reconnect   *DomainDiskSourceNetworkReconnect  `xml:"reconnect"`
	Auth        *DomainDiskAuth                    `xml:"auth"`
}

type DomainDiskSourceNetworkConfig 

type DomainDiskSourceNetworkConfig struct {
	File string `xml:"file,attr"`
}

type DomainDiskSourceNetworkIQN 

type DomainDiskSourceNetworkIQN struct {
	Name string `xml:"name,attr,omitempty"`
}

type DomainDiskSourceNetworkIdentity 

type DomainDiskSourceNetworkIdentity struct {
	User      string `xml:"user,attr,omitempty"`
	Group     string `xml:"group,attr,omitempty"`
	UserName  string `xml:"username,attr,omitempty"`
	Keyfile   string `xml:"keyfile,attr,omitempty"`
	AgentSock string `xml:"agentsock,attr,omitempty"`
}

type DomainDiskSourceNetworkInitiator 

type DomainDiskSourceNetworkInitiator struct {
	IQN *DomainDiskSourceNetworkIQN `xml:"iqn"`
}

type DomainDiskSourceNetworkKnownHosts added in v1.9008.0 

type DomainDiskSourceNetworkKnownHosts struct {
	Path string `xml:"path,attr"`
}

type DomainDiskSourceNetworkReconnect added in v1.9002.0 

type DomainDiskSourceNetworkReconnect struct {
	Delay string `xml:"delay,attr"`
}

type DomainDiskSourceNetworkSnapshot 

type DomainDiskSourceNetworkSnapshot struct {
	Name string `xml:"name,attr"`
}

type DomainDiskSourceReadahead 

type DomainDiskSourceReadahead struct {
	Size string `xml:"size,attr"`
}

type DomainDiskSourceSSL 

type DomainDiskSourceSSL struct {
	Verify string `xml:"verify,attr"`
}

type DomainDiskSourceTimeout 

type DomainDiskSourceTimeout struct {
	Seconds string `xml:"seconds,attr"`
}

type DomainDiskSourceVHostUser 

type DomainDiskSourceVHostUser DomainChardevSource

func (*DomainDiskSourceVHostUser) MarshalXML 

func (a *DomainDiskSourceVHostUser) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskSourceVHostUser) UnmarshalXML 

func (a *DomainDiskSourceVHostUser) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskSourceVHostVDPA added in v1.9008.0 

type DomainDiskSourceVHostVDPA struct {
	Dev string `xml:"dev,attr"`
}

type DomainDiskSourceVolume 

type DomainDiskSourceVolume struct {
	Pool     string                 `xml:"pool,attr,omitempty"`
	Volume   string                 `xml:"volume,attr,omitempty"`
	Mode     string                 `xml:"mode,attr,omitempty"`
	SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainDiskTarget 

type DomainDiskTarget struct {
	Dev          string `xml:"dev,attr,omitempty"`
	Bus          string `xml:"bus,attr,omitempty"`
	Tray         string `xml:"tray,attr,omitempty"`
	Removable    string `xml:"removable,attr,omitempty"`
	RotationRate uint   `xml:"rotation_rate,attr,omitempty"`
}

type DomainDiskTransient 

type DomainDiskTransient struct {
	ShareBacking string `xml:"shareBacking,attr,omitempty"`
}

type DomainFeature 

type DomainFeature struct {
}

type DomainFeatureAPIC 

type DomainFeatureAPIC struct {
	EOI string `xml:"eoi,attr,omitempty"`
}

type DomainFeatureAsyncTeardown added in v1.9006.0 

type DomainFeatureAsyncTeardown struct {
	Enabled string `xml:"enabled,attr,omitempty"`
}

type DomainFeatureCFPC 

type DomainFeatureCFPC struct {
	Value string `xml:"value,attr"`
}

type DomainFeatureCapabilities 

type DomainFeatureCapabilities struct {
	Policy         string                   `xml:"policy,attr,omitempty"`
	AuditControl   *DomainFeatureCapability `xml:"audit_control"`
	AuditWrite     *DomainFeatureCapability `xml:"audit_write"`
	BlockSuspend   *DomainFeatureCapability `xml:"block_suspend"`
	Chown          *DomainFeatureCapability `xml:"chown"`
	DACOverride    *DomainFeatureCapability `xml:"dac_override"`
	DACReadSearch  *DomainFeatureCapability `xml:"dac_read_Search"`
	FOwner         *DomainFeatureCapability `xml:"fowner"`
	FSetID         *DomainFeatureCapability `xml:"fsetid"`
	IPCLock        *DomainFeatureCapability `xml:"ipc_lock"`
	IPCOwner       *DomainFeatureCapability `xml:"ipc_owner"`
	Kill           *DomainFeatureCapability `xml:"kill"`
	Lease          *DomainFeatureCapability `xml:"lease"`
	LinuxImmutable *DomainFeatureCapability `xml:"linux_immutable"`
	MACAdmin       *DomainFeatureCapability `xml:"mac_admin"`
	MACOverride    *DomainFeatureCapability `xml:"mac_override"`
	MkNod          *DomainFeatureCapability `xml:"mknod"`
	NetAdmin       *DomainFeatureCapability `xml:"net_admin"`
	NetBindService *DomainFeatureCapability `xml:"net_bind_service"`
	NetBroadcast   *DomainFeatureCapability `xml:"net_broadcast"`
	NetRaw         *DomainFeatureCapability `xml:"net_raw"`
	SetGID         *DomainFeatureCapability `xml:"setgid"`
	SetFCap        *DomainFeatureCapability `xml:"setfcap"`
	SetPCap        *DomainFeatureCapability `xml:"setpcap"`
	SetUID         *DomainFeatureCapability `xml:"setuid"`
	SysAdmin       *DomainFeatureCapability `xml:"sys_admin"`
	SysBoot        *DomainFeatureCapability `xml:"sys_boot"`
	SysChRoot      *DomainFeatureCapability `xml:"sys_chroot"`
	SysModule      *DomainFeatureCapability `xml:"sys_module"`
	SysNice        *DomainFeatureCapability `xml:"sys_nice"`
	SysPAcct       *DomainFeatureCapability `xml:"sys_pacct"`
	SysPTrace      *DomainFeatureCapability `xml:"sys_ptrace"`
	SysRawIO       *DomainFeatureCapability `xml:"sys_rawio"`
	SysResource    *DomainFeatureCapability `xml:"sys_resource"`
	SysTime        *DomainFeatureCapability `xml:"sys_time"`
	SysTTYCnofig   *DomainFeatureCapability `xml:"sys_tty_config"`
	SysLog         *DomainFeatureCapability `xml:"syslog"`
	WakeAlarm      *DomainFeatureCapability `xml:"wake_alarm"`
}

type DomainFeatureCapability 

type DomainFeatureCapability struct {
	State string `xml:"state,attr,omitempty"`
}

type DomainFeatureGIC 

type DomainFeatureGIC struct {
	Version string `xml:"version,attr,omitempty"`
}

type DomainFeatureHPT 

type DomainFeatureHPT struct {
	Resizing    string                    `xml:"resizing,attr,omitempty"`
	MaxPageSize *DomainFeatureHPTPageSize `xml:"maxpagesize"`
}

type DomainFeatureHPTPageSize 

type DomainFeatureHPTPageSize struct {
	Unit  string `xml:"unit,attr,omitempty"`
	Value string `xml:",chardata"`
}

type DomainFeatureHyperV 

type DomainFeatureHyperV struct {
	DomainFeature
	Mode            string                        `xml:"mode,attr,omitempty"`
	Relaxed         *DomainFeatureState           `xml:"relaxed"`
	VAPIC           *DomainFeatureState           `xml:"vapic"`
	Spinlocks       *DomainFeatureHyperVSpinlocks `xml:"spinlocks"`
	VPIndex         *DomainFeatureState           `xml:"vpindex"`
	Runtime         *DomainFeatureState           `xml:"runtime"`
	Synic           *DomainFeatureState           `xml:"synic"`
	STimer          *DomainFeatureHyperVSTimer    `xml:"stimer"`
	Reset           *DomainFeatureState           `xml:"reset"`
	VendorId        *DomainFeatureHyperVVendorId  `xml:"vendor_id"`
	Frequencies     *DomainFeatureState           `xml:"frequencies"`
	ReEnlightenment *DomainFeatureState           `xml:"reenlightenment"`
	TLBFlush        *DomainFeatureState           `xml:"tlbflush"`
	IPI             *DomainFeatureState           `xml:"ipi"`
	EVMCS           *DomainFeatureState           `xml:"evmcs"`
	AVIC            *DomainFeatureState           `xml:"avic"`
	EMSRBitmap      *DomainFeatureState           `xml:"emsr_bitmap"`
	XMMInput        *DomainFeatureState           `xml:"xmm_input"`
}

type DomainFeatureHyperVSTimer 

type DomainFeatureHyperVSTimer struct {
	DomainFeatureState
	Direct *DomainFeatureState `xml:"direct"`
}

type DomainFeatureHyperVSpinlocks 

type DomainFeatureHyperVSpinlocks struct {
	DomainFeatureState
	Retries uint `xml:"retries,attr,omitempty"`
}

type DomainFeatureHyperVVendorId 

type DomainFeatureHyperVVendorId struct {
	DomainFeatureState
	Value string `xml:"value,attr,omitempty"`
}

type DomainFeatureIBS 

type DomainFeatureIBS struct {
	Value string `xml:"value,attr"`
}

type DomainFeatureIOAPIC 

type DomainFeatureIOAPIC struct {
	Driver string `xml:"driver,attr,omitempty"`
}

type DomainFeatureKVM 

type DomainFeatureKVM struct {
	Hidden        *DomainFeatureState        `xml:"hidden"`
	HintDedicated *DomainFeatureState        `xml:"hint-dedicated"`
	PollControl   *DomainFeatureState        `xml:"poll-control"`
	PVIPI         *DomainFeatureState        `xml:"pv-ipi"`
	DirtyRing     *DomainFeatureKVMDirtyRing `xml:"dirty-ring"`
}

type DomainFeatureKVMDirtyRing added in v1.8000.0 

type DomainFeatureKVMDirtyRing struct {
	DomainFeatureState
	Size uint `xml:"size,attr,omitempty"`
}

type DomainFeatureList 

type DomainFeatureList struct {
	PAE           *DomainFeature              `xml:"pae"`
	ACPI          *DomainFeature              `xml:"acpi"`
	APIC          *DomainFeatureAPIC          `xml:"apic"`
	HAP           *DomainFeatureState         `xml:"hap"`
	Viridian      *DomainFeature              `xml:"viridian"`
	PrivNet       *DomainFeature              `xml:"privnet"`
	HyperV        *DomainFeatureHyperV        `xml:"hyperv"`
	KVM           *DomainFeatureKVM           `xml:"kvm"`
	Xen           *DomainFeatureXen           `xml:"xen"`
	PVSpinlock    *DomainFeatureState         `xml:"pvspinlock"`
	PMU           *DomainFeatureState         `xml:"pmu"`
	VMPort        *DomainFeatureState         `xml:"vmport"`
	GIC           *DomainFeatureGIC           `xml:"gic"`
	SMM           *DomainFeatureSMM           `xml:"smm"`
	IOAPIC        *DomainFeatureIOAPIC        `xml:"ioapic"`
	HPT           *DomainFeatureHPT           `xml:"hpt"`
	HTM           *DomainFeatureState         `xml:"htm"`
	NestedHV      *DomainFeatureState         `xml:"nested-hv"`
	Capabilities  *DomainFeatureCapabilities  `xml:"capabilities"`
	VMCoreInfo    *DomainFeatureState         `xml:"vmcoreinfo"`
	MSRS          *DomainFeatureMSRS          `xml:"msrs"`
	CCFAssist     *DomainFeatureState         `xml:"ccf-assist"`
	CFPC          *DomainFeatureCFPC          `xml:"cfpc"`
	SBBC          *DomainFeatureSBBC          `xml:"sbbc"`
	IBS           *DomainFeatureIBS           `xml:"ibs"`
	TCG           *DomainFeatureTCG           `xml:"tcg"`
	AsyncTeardown *DomainFeatureAsyncTeardown `xml:"async-teardown"`
	RAS           *DomainFeatureState         `xml:"ras"`
	PS2           *DomainFeatureState         `xml:"ps2"`
}

type DomainFeatureMSRS 

type DomainFeatureMSRS struct {
	Unknown string `xml:"unknown,attr"`
}

type DomainFeatureSBBC 

type DomainFeatureSBBC struct {
	Value string `xml:"value,attr"`
}

type DomainFeatureSMM 

type DomainFeatureSMM struct {
	State string                `xml:"state,attr,omitempty"`
	TSeg  *DomainFeatureSMMTSeg `xml:"tseg"`
}

type DomainFeatureSMMTSeg 

type DomainFeatureSMMTSeg struct {
	Unit  string `xml:"unit,attr,omitempty"`
	Value uint   `xml:",chardata"`
}

type DomainFeatureState 

type DomainFeatureState struct {
	State string `xml:"state,attr,omitempty"`
}

type DomainFeatureTCG added in v1.8000.0 

type DomainFeatureTCG struct {
	TBCache *DomainFeatureTCGTBCache `xml:"tb-cache"`
}

type DomainFeatureTCGTBCache added in v1.8000.0 

type DomainFeatureTCGTBCache struct {
	Unit string `xml:"unit,attr,omitempty"`
	Size uint   `xml:",chardata"`
}

type DomainFeatureXen 

type DomainFeatureXen struct {
	E820Host    *DomainFeatureXenE820Host    `xml:"e820_host"`
	Passthrough *DomainFeatureXenPassthrough `xml:"passthrough"`
}

type DomainFeatureXenE820Host 

type DomainFeatureXenE820Host struct {
	State string `xml:"state,attr"`
}

type DomainFeatureXenPassthrough 

type DomainFeatureXenPassthrough struct {
	State string `xml:"state,attr,omitempty"`
	Mode  string `xml:"mode,attr,omitempty"`
}

type DomainFilesystem 

type DomainFilesystem struct {
	XMLName        xml.Name                        `xml:"filesystem"`
	AccessMode     string                          `xml:"accessmode,attr,omitempty"`
	Model          string                          `xml:"model,attr,omitempty"`
	MultiDevs      string                          `xml:"multidevs,attr,omitempty"`
	FMode          string                          `xml:"fmode,attr,omitempty"`
	DMode          string                          `xml:"dmode,attr,omitempty"`
	Driver         *DomainFilesystemDriver         `xml:"driver"`
	Binary         *DomainFilesystemBinary         `xml:"binary"`
	IDMap          *DomainFilesystemIDMap          `xml:"idmap"`
	Source         *DomainFilesystemSource         `xml:"source"`
	Target         *DomainFilesystemTarget         `xml:"target"`
	ReadOnly       *DomainFilesystemReadOnly       `xml:"readonly"`
	SpaceHardLimit *DomainFilesystemSpaceHardLimit `xml:"space_hard_limit"`
	SpaceSoftLimit *DomainFilesystemSpaceSoftLimit `xml:"space_soft_limit"`
	Boot           *DomainDeviceBoot               `xml:"boot"`
	ACPI           *DomainDeviceACPI               `xml:"acpi"`
	Alias          *DomainAlias                    `xml:"alias"`
	Address        *DomainAddress                  `xml:"address"`
}

func (*DomainFilesystem) Marshal 

func (d *DomainFilesystem) Marshal() (string, error)

func (*DomainFilesystem) MarshalXML 

func (a *DomainFilesystem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainFilesystem) Unmarshal 

func (d *DomainFilesystem) Unmarshal(doc string) error

func (*DomainFilesystem) UnmarshalXML 

func (a *DomainFilesystem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainFilesystemBinary 

type DomainFilesystemBinary struct {
	Path       string                            `xml:"path,attr,omitempty"`
	XAttr      string                            `xml:"xattr,attr,omitempty"`
	Cache      *DomainFilesystemBinaryCache      `xml:"cache"`
	Sandbox    *DomainFilesystemBinarySandbox    `xml:"sandbox"`
	Lock       *DomainFilesystemBinaryLock       `xml:"lock"`
	ThreadPool *DomainFilesystemBinaryThreadPool `xml:"thread_pool"`
	OpenFiles  *DomainFilesystemBinaryOpenFiles  `xml:"openfiles"`
}

type DomainFilesystemBinaryCache 

type DomainFilesystemBinaryCache struct {
	Mode string `xml:"mode,attr"`
}

type DomainFilesystemBinaryLock 

type DomainFilesystemBinaryLock struct {
	POSIX string `xml:"posix,attr,omitempty"`
	Flock string `xml:"flock,attr,omitempty"`
}

type DomainFilesystemBinaryOpenFiles added in v1.10006.0 

type DomainFilesystemBinaryOpenFiles struct {
	Max uint `xml:"max,attr,"`
}

type DomainFilesystemBinarySandbox 

type DomainFilesystemBinarySandbox struct {
	Mode string `xml:"mode,attr"`
}

type DomainFilesystemBinaryThreadPool added in v1.8005.0 

type DomainFilesystemBinaryThreadPool struct {
	Size uint `xml:"size,attr,omitempty"`
}

type DomainFilesystemDriver 

type DomainFilesystemDriver struct {
	Type      string `xml:"type,attr,omitempty"`
	Format    string `xml:"format,attr,omitempty"`
	Name      string `xml:"name,attr,omitempty"`
	WRPolicy  string `xml:"wrpolicy,attr,omitempty"`
	IOMMU     string `xml:"iommu,attr,omitempty"`
	ATS       string `xml:"ats,attr,omitempty"`
	Packed    string `xml:"packed,attr,omitempty"`
	PagePerVQ string `xml:"page_per_vq,attr,omitempty"`
	Queue     uint   `xml:"queue,attr,omitempty"`
}

type DomainFilesystemIDMap added in v1.10000.0 

type DomainFilesystemIDMap struct {
	UID []DomainFilesystemIDMapEntry `xml:"uid"`
	GID []DomainFilesystemIDMapEntry `xml:"gid"`
}

type DomainFilesystemIDMapEntry added in v1.10000.0 

type DomainFilesystemIDMapEntry struct {
	Start  uint `xml:"start,attr"`
	Target uint `xml:"target,attr"`
	Count  uint `xml:"count,attr"`
}

type DomainFilesystemReadOnly 

type DomainFilesystemReadOnly struct {
}

type DomainFilesystemSource 

type DomainFilesystemSource struct {
	Mount    *DomainFilesystemSourceMount    `xml:"-"`
	Block    *DomainFilesystemSourceBlock    `xml:"-"`
	File     *DomainFilesystemSourceFile     `xml:"-"`
	Template *DomainFilesystemSourceTemplate `xml:"-"`
	RAM      *DomainFilesystemSourceRAM      `xml:"-"`
	Bind     *DomainFilesystemSourceBind     `xml:"-"`
	Volume   *DomainFilesystemSourceVolume   `xml:"-"`
}

func (*DomainFilesystemSource) MarshalXML 

func (a *DomainFilesystemSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainFilesystemSource) UnmarshalXML 

func (a *DomainFilesystemSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainFilesystemSourceBind 

type DomainFilesystemSourceBind struct {
	Dir string `xml:"dir,attr"`
}

type DomainFilesystemSourceBlock 

type DomainFilesystemSourceBlock struct {
	Dev string `xml:"dev,attr"`
}

type DomainFilesystemSourceFile 

type DomainFilesystemSourceFile struct {
	File string `xml:"file,attr"`
}

type DomainFilesystemSourceMount 

type DomainFilesystemSourceMount struct {
	Dir    string `xml:"dir,attr,omitempty"`
	Socket string `xml:"socket,attr,omitempty"`
}

type DomainFilesystemSourceRAM 

type DomainFilesystemSourceRAM struct {
	Usage uint   `xml:"usage,attr"`
	Units string `xml:"units,attr,omitempty"`
}

type DomainFilesystemSourceTemplate 

type DomainFilesystemSourceTemplate struct {
	Name string `xml:"name,attr"`
}

type DomainFilesystemSourceVolume 

type DomainFilesystemSourceVolume struct {
	Pool   string `xml:"pool,attr"`
	Volume string `xml:"volume,attr"`
}

type DomainFilesystemSpaceHardLimit 

type DomainFilesystemSpaceHardLimit struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

type DomainFilesystemSpaceSoftLimit 

type DomainFilesystemSpaceSoftLimit struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,attr,omitempty"`
}

type DomainFilesystemTarget 

type DomainFilesystemTarget struct {
	Dir string `xml:"dir,attr"`
}

type DomainGenID 

type DomainGenID struct {
	Value string `xml:",chardata"`
}

type DomainGraphic 

type DomainGraphic struct {
	XMLName     xml.Name                  `xml:"graphics"`
	SDL         *DomainGraphicSDL         `xml:"-"`
	VNC         *DomainGraphicVNC         `xml:"-"`
	RDP         *DomainGraphicRDP         `xml:"-"`
	Desktop     *DomainGraphicDesktop     `xml:"-"`
	Spice       *DomainGraphicSpice       `xml:"-"`
	EGLHeadless *DomainGraphicEGLHeadless `xml:"-"`
	DBus        *DomainGraphicDBus        `xml:"-"`
	Audio       *DomainGraphicAudio       `xml:"audio"`
}

func (*DomainGraphic) Marshal 

func (d *DomainGraphic) Marshal() (string, error)

func (*DomainGraphic) MarshalXML 

func (a *DomainGraphic) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainGraphic) Unmarshal 

func (d *DomainGraphic) Unmarshal(doc string) error

func (*DomainGraphic) UnmarshalXML 

func (a *DomainGraphic) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainGraphicAudio 

type DomainGraphicAudio struct {
	ID uint `xml:"id,attr,omitempty"`
}

type DomainGraphicChannel 

type DomainGraphicChannel struct {
	Name string `xml:"name,attr,omitempty"`
	Mode string `xml:"mode,attr,omitempty"`
}

type DomainGraphicDBus added in v1.8004.0 

type DomainGraphicDBus struct {
	Address string               `xml:"address,attr,omitempty"`
	P2P     string               `xml:"p2p,attr,omitempty"`
	GL      *DomainGraphicDBusGL `xml:"gl"`
}

type DomainGraphicDBusGL added in v1.8004.0 

type DomainGraphicDBusGL struct {
	Enable     string `xml:"enable,attr,omitempty"`
	RenderNode string `xml:"rendernode,attr,omitempty"`
}

type DomainGraphicDesktop 

type DomainGraphicDesktop struct {
	Display    string `xml:"display,attr,omitempty"`
	FullScreen string `xml:"fullscreen,attr,omitempty"`
}

type DomainGraphicEGLHeadless 

type DomainGraphicEGLHeadless struct {
	GL *DomainGraphicEGLHeadlessGL `xml:"gl"`
}

type DomainGraphicEGLHeadlessGL 

type DomainGraphicEGLHeadlessGL struct {
	RenderNode string `xml:"rendernode,attr,omitempty"`
}

type DomainGraphicFileTransfer 

type DomainGraphicFileTransfer struct {
	Enable string `xml:"enable,attr,omitempty"`
}

type DomainGraphicListener 

type DomainGraphicListener struct {
	Address *DomainGraphicListenerAddress `xml:"-"`
	Network *DomainGraphicListenerNetwork `xml:"-"`
	Socket  *DomainGraphicListenerSocket  `xml:"-"`
}

func (*DomainGraphicListener) MarshalXML 

func (a *DomainGraphicListener) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainGraphicListener) UnmarshalXML 

func (a *DomainGraphicListener) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainGraphicListenerAddress 

type DomainGraphicListenerAddress struct {
	Address string `xml:"address,attr,omitempty"`
}

type DomainGraphicListenerNetwork 

type DomainGraphicListenerNetwork struct {
	Address string `xml:"address,attr,omitempty"`
	Network string `xml:"network,attr,omitempty"`
}

type DomainGraphicListenerSocket 

type DomainGraphicListenerSocket struct {
	Socket string `xml:"socket,attr,omitempty"`
}

type DomainGraphicRDP 

type DomainGraphicRDP struct {
	Port        int                     `xml:"port,attr,omitempty"`
	AutoPort    string                  `xml:"autoport,attr,omitempty"`
	ReplaceUser string                  `xml:"replaceUser,attr,omitempty"`
	MultiUser   string                  `xml:"multiUser,attr,omitempty"`
	Listen      string                  `xml:"listen,attr,omitempty"`
	Listeners   []DomainGraphicListener `xml:"listen"`
}

type DomainGraphicSDL 

type DomainGraphicSDL struct {
	Display    string               `xml:"display,attr,omitempty"`
	XAuth      string               `xml:"xauth,attr,omitempty"`
	FullScreen string               `xml:"fullscreen,attr,omitempty"`
	GL         *DomainGraphicsSDLGL `xml:"gl"`
}

type DomainGraphicSpice 

type DomainGraphicSpice struct {
	Port          int                             `xml:"port,attr,omitempty"`
	TLSPort       int                             `xml:"tlsPort,attr,omitempty"`
	AutoPort      string                          `xml:"autoport,attr,omitempty"`
	Listen        string                          `xml:"listen,attr,omitempty"`
	Keymap        string                          `xml:"keymap,attr,omitempty"`
	DefaultMode   string                          `xml:"defaultMode,attr,omitempty"`
	Passwd        string                          `xml:"passwd,attr,omitempty"`
	PasswdValidTo string                          `xml:"passwdValidTo,attr,omitempty"`
	Connected     string                          `xml:"connected,attr,omitempty"`
	Listeners     []DomainGraphicListener         `xml:"listen"`
	Channel       []DomainGraphicSpiceChannel     `xml:"channel"`
	Image         *DomainGraphicSpiceImage        `xml:"image"`
	JPEG          *DomainGraphicSpiceJPEG         `xml:"jpeg"`
	ZLib          *DomainGraphicSpiceZLib         `xml:"zlib"`
	Playback      *DomainGraphicSpicePlayback     `xml:"playback"`
	Streaming     *DomainGraphicSpiceStreaming    `xml:"streaming"`
	Mouse         *DomainGraphicSpiceMouse        `xml:"mouse"`
	ClipBoard     *DomainGraphicSpiceClipBoard    `xml:"clipboard"`
	FileTransfer  *DomainGraphicSpiceFileTransfer `xml:"filetransfer"`
	GL            *DomainGraphicSpiceGL           `xml:"gl"`
}

type DomainGraphicSpiceChannel 

type DomainGraphicSpiceChannel struct {
	Name string `xml:"name,attr"`
	Mode string `xml:"mode,attr"`
}

type DomainGraphicSpiceClipBoard 

type DomainGraphicSpiceClipBoard struct {
	CopyPaste string `xml:"copypaste,attr"`
}

type DomainGraphicSpiceFileTransfer 

type DomainGraphicSpiceFileTransfer struct {
	Enable string `xml:"enable,attr"`
}

type DomainGraphicSpiceGL 

type DomainGraphicSpiceGL struct {
	Enable     string `xml:"enable,attr,omitempty"`
	RenderNode string `xml:"rendernode,attr,omitempty"`
}

type DomainGraphicSpiceImage 

type DomainGraphicSpiceImage struct {
	Compression string `xml:"compression,attr"`
}

type DomainGraphicSpiceJPEG 

type DomainGraphicSpiceJPEG struct {
	Compression string `xml:"compression,attr"`
}

type DomainGraphicSpiceMouse 

type DomainGraphicSpiceMouse struct {
	Mode string `xml:"mode,attr"`
}

type DomainGraphicSpicePlayback 

type DomainGraphicSpicePlayback struct {
	Compression string `xml:"compression,attr"`
}

type DomainGraphicSpiceStreaming 

type DomainGraphicSpiceStreaming struct {
	Mode string `xml:"mode,attr"`
}

type DomainGraphicSpiceZLib 

type DomainGraphicSpiceZLib struct {
	Compression string `xml:"compression,attr"`
}

type DomainGraphicVNC 

type DomainGraphicVNC struct {
	Socket        string                  `xml:"socket,attr,omitempty"`
	Port          int                     `xml:"port,attr,omitempty"`
	AutoPort      string                  `xml:"autoport,attr,omitempty"`
	WebSocket     int                     `xml:"websocket,attr,omitempty"`
	Keymap        string                  `xml:"keymap,attr,omitempty"`
	SharePolicy   string                  `xml:"sharePolicy,attr,omitempty"`
	Passwd        string                  `xml:"passwd,attr,omitempty"`
	PasswdValidTo string                  `xml:"passwdValidTo,attr,omitempty"`
	Connected     string                  `xml:"connected,attr,omitempty"`
	PowerControl  string                  `xml:"powerControl,attr,omitempty"`
	Listen        string                  `xml:"listen,attr,omitempty"`
	Listeners     []DomainGraphicListener `xml:"listen"`
}

type DomainGraphicsSDLGL 

type DomainGraphicsSDLGL struct {
	Enable string `xml:"enable,attr,omitempty"`
}

type DomainHostdev 

type DomainHostdev struct {
	Managed        string                       `xml:"managed,attr,omitempty"`
	SubsysUSB      *DomainHostdevSubsysUSB      `xml:"-"`
	SubsysSCSI     *DomainHostdevSubsysSCSI     `xml:"-"`
	SubsysSCSIHost *DomainHostdevSubsysSCSIHost `xml:"-"`
	SubsysPCI      *DomainHostdevSubsysPCI      `xml:"-"`
	SubsysMDev     *DomainHostdevSubsysMDev     `xml:"-"`
	CapsStorage    *DomainHostdevCapsStorage    `xml:"-"`
	CapsMisc       *DomainHostdevCapsMisc       `xml:"-"`
	CapsNet        *DomainHostdevCapsNet        `xml:"-"`
	Boot           *DomainDeviceBoot            `xml:"boot"`
	ROM            *DomainROM                   `xml:"rom"`
	ACPI           *DomainDeviceACPI            `xml:"acpi"`
	Alias          *DomainAlias                 `xml:"alias"`
	Address        *DomainAddress               `xml:"address"`
}

func (*DomainHostdev) Marshal 

func (d *DomainHostdev) Marshal() (string, error)

func (*DomainHostdev) MarshalXML 

func (a *DomainHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainHostdev) Unmarshal 

func (d *DomainHostdev) Unmarshal(doc string) error

func (*DomainHostdev) UnmarshalXML 

func (a *DomainHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainHostdevCapsMisc 

type DomainHostdevCapsMisc struct {
	Source *DomainHostdevCapsMiscSource `xml:"source"`
}

type DomainHostdevCapsMiscSource 

type DomainHostdevCapsMiscSource struct {
	Char string `xml:"char"`
}

type DomainHostdevCapsNet 

type DomainHostdevCapsNet struct {
	Source *DomainHostdevCapsNetSource `xml:"source"`
	IP     []DomainIP                  `xml:"ip"`
	Route  []DomainRoute               `xml:"route"`
}

type DomainHostdevCapsNetSource 

type DomainHostdevCapsNetSource struct {
	Interface string `xml:"interface"`
}

type DomainHostdevCapsStorage 

type DomainHostdevCapsStorage struct {
	Source *DomainHostdevCapsStorageSource `xml:"source"`
}

type DomainHostdevCapsStorageSource 

type DomainHostdevCapsStorageSource struct {
	Block string `xml:"block"`
}

type DomainHostdevSubsysMDev 

type DomainHostdevSubsysMDev struct {
	Model   string                         `xml:"model,attr,omitempty"`
	Display string                         `xml:"display,attr,omitempty"`
	RamFB   string                         `xml:"ramfb,attr,omitempty"`
	Source  *DomainHostdevSubsysMDevSource `xml:"source"`
}

type DomainHostdevSubsysMDevSource 

type DomainHostdevSubsysMDevSource struct {
	Address *DomainAddressMDev `xml:"address"`
}

type DomainHostdevSubsysPCI 

type DomainHostdevSubsysPCI struct {
	Display string                        `xml:"display,attr,omitempty"`
	RamFB   string                        `xml:"ramfb,attr,omitempty"`
	Driver  *DomainHostdevSubsysPCIDriver `xml:"driver"`
	Source  *DomainHostdevSubsysPCISource `xml:"source"`
	Teaming *DomainInterfaceTeaming       `xml:"teaming"`
}

type DomainHostdevSubsysPCIDriver 

type DomainHostdevSubsysPCIDriver struct {
	Name  string `xml:"name,attr,omitempty"`
	Model string `xml:"model,attr,omitempty"`
}

type DomainHostdevSubsysPCISource 

type DomainHostdevSubsysPCISource struct {
	WriteFiltering string            `xml:"writeFiltering,attr,omitempty"`
	Address        *DomainAddressPCI `xml:"address"`
}

type DomainHostdevSubsysSCSI 

type DomainHostdevSubsysSCSI struct {
	SGIO      string                         `xml:"sgio,attr,omitempty"`
	RawIO     string                         `xml:"rawio,attr,omitempty"`
	Source    *DomainHostdevSubsysSCSISource `xml:"source"`
	ReadOnly  *DomainDiskReadOnly            `xml:"readonly"`
	Shareable *DomainDiskShareable           `xml:"shareable"`
}

type DomainHostdevSubsysSCSIAdapter 

type DomainHostdevSubsysSCSIAdapter struct {
	Name string `xml:"name,attr"`
}

type DomainHostdevSubsysSCSIHost 

type DomainHostdevSubsysSCSIHost struct {
	Model  string                             `xml:"model,attr,omitempty"`
	Source *DomainHostdevSubsysSCSIHostSource `xml:"source"`
}

type DomainHostdevSubsysSCSIHostSource 

type DomainHostdevSubsysSCSIHostSource struct {
	Protocol string `xml:"protocol,attr,omitempty"`
	WWPN     string `xml:"wwpn,attr,omitempty"`
}

type DomainHostdevSubsysSCSISource 

type DomainHostdevSubsysSCSISource struct {
	Host  *DomainHostdevSubsysSCSISourceHost  `xml:"-"`
	ISCSI *DomainHostdevSubsysSCSISourceISCSI `xml:"-"`
}

func (*DomainHostdevSubsysSCSISource) MarshalXML 

func (a *DomainHostdevSubsysSCSISource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainHostdevSubsysSCSISource) UnmarshalXML 

func (a *DomainHostdevSubsysSCSISource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainHostdevSubsysSCSISourceHost 

type DomainHostdevSubsysSCSISourceHost struct {
	Adapter *DomainHostdevSubsysSCSIAdapter `xml:"adapter"`
	Address *DomainAddressDrive             `xml:"address"`
}

type DomainHostdevSubsysSCSISourceIQN 

type DomainHostdevSubsysSCSISourceIQN struct {
	Name string `xml:"name,attr"`
}

type DomainHostdevSubsysSCSISourceISCSI 

type DomainHostdevSubsysSCSISourceISCSI struct {
	Name      string                                  `xml:"name,attr"`
	Host      []DomainDiskSourceHost                  `xml:"host"`
	Auth      *DomainDiskAuth                         `xml:"auth"`
	Initiator *DomainHostdevSubsysSCSISourceInitiator `xml:"initiator"`
}

type DomainHostdevSubsysSCSISourceInitiator 

type DomainHostdevSubsysSCSISourceInitiator struct {
	IQN DomainHostdevSubsysSCSISourceIQN `xml:"iqn"`
}

type DomainHostdevSubsysUSB 

type DomainHostdevSubsysUSB struct {
	Source *DomainHostdevSubsysUSBSource `xml:"source"`
}

type DomainHostdevSubsysUSBSource 

type DomainHostdevSubsysUSBSource struct {
	GuestReset string            `xml:"guestReset,attr,omitempty"`
	Address    *DomainAddressUSB `xml:"address"`
}

type DomainHub 

type DomainHub struct {
	Type    string            `xml:"type,attr"`
	ACPI    *DomainDeviceACPI `xml:"acpi"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

type DomainIDMap 

type DomainIDMap struct {
	UIDs []DomainIDMapRange `xml:"uid"`
	GIDs []DomainIDMapRange `xml:"gid"`
}

type DomainIDMapRange 

type DomainIDMapRange struct {
	Start  uint `xml:"start,attr"`
	Target uint `xml:"target,attr"`
	Count  uint `xml:"count,attr"`
}

type DomainIOMMU 

type DomainIOMMU struct {
	Model   string             `xml:"model,attr"`
	Driver  *DomainIOMMUDriver `xml:"driver"`
	ACPI    *DomainDeviceACPI  `xml:"acpi"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

type DomainIOMMUDriver 

type DomainIOMMUDriver struct {
	IntRemap       string `xml:"intremap,attr,omitempty"`
	CachingMode    string `xml:"caching_mode,attr,omitempty"`
	EIM            string `xml:"eim,attr,omitempty"`
	IOTLB          string `xml:"iotlb,attr,omitempty"`
	AWBits         uint   `xml:"aw_bits,attr,omitempty"`
	DMATranslation string `xml:"dma_translation,attr,omitempty"`
}

type DomainIOThread 

type DomainIOThread struct {
	ID      uint                `xml:"id,attr"`
	PoolMin *uint               `xml:"thread_pool_min,attr"`
	PoolMax *uint               `xml:"thread_pool_max,attr"`
	Poll    *DomainIOThreadPoll `xml:"poll"`
}

type DomainIOThreadIDs 

type DomainIOThreadIDs struct {
	IOThreads []DomainIOThread `xml:"iothread"`
}

type DomainIOThreadPoll added in v1.9004.0 

type DomainIOThreadPoll struct {
	Max    *uint `xml:"max,attr"`
	Grow   *uint `xml:"grow,attr"`
	Shrink *uint `xml:"shrink,attr"`
}

type DomainIP 

type DomainIP struct {
	Address string `xml:"address,attr,omitempty"`
	Family  string `xml:"family,attr,omitempty"`
	Prefix  *uint  `xml:"prefix,attr"`
}

type DomainInput 

type DomainInput struct {
	XMLName xml.Name           `xml:"input"`
	Type    string             `xml:"type,attr"`
	Bus     string             `xml:"bus,attr,omitempty"`
	Model   string             `xml:"model,attr,omitempty"`
	Driver  *DomainInputDriver `xml:"driver"`
	Source  *DomainInputSource `xml:"source"`
	ACPI    *DomainDeviceACPI  `xml:"acpi"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

func (*DomainInput) Marshal 

func (d *DomainInput) Marshal() (string, error)

func (*DomainInput) MarshalXML 

func (a *DomainInput) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInput) Unmarshal 

func (d *DomainInput) Unmarshal(doc string) error

func (*DomainInput) UnmarshalXML 

func (a *DomainInput) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInputDriver 

type DomainInputDriver struct {
	IOMMU     string `xml:"iommu,attr,omitempty"`
	ATS       string `xml:"ats,attr,omitempty"`
	Packed    string `xml:"packed,attr,omitempty"`
	PagePerVQ string `xml:"page_per_vq,attr,omitempty"`
}

type DomainInputSource 

type DomainInputSource struct {
	Passthrough *DomainInputSourcePassthrough `xml:"-"`
	EVDev       *DomainInputSourceEVDev       `xml:"-"`
}

func (*DomainInputSource) MarshalXML 

func (a *DomainInputSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInputSource) UnmarshalXML 

func (a *DomainInputSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInputSourceEVDev 

type DomainInputSourceEVDev struct {
	Dev        string `xml:"dev,attr"`
	Grab       string `xml:"grab,attr,omitempty"`
	GrabToggle string `xml:"grabToggle,attr,omitempty"`
	Repeat     string `xml:"repeat,attr,omitempty"`
}

type DomainInputSourcePassthrough 

type DomainInputSourcePassthrough struct {
	EVDev string `xml:"evdev,attr"`
}

type DomainInterface 

type DomainInterface struct {
	XMLName             xml.Name                           `xml:"interface"`
	Managed             string                             `xml:"managed,attr,omitempty"`
	TrustGuestRXFilters string                             `xml:"trustGuestRxFilters,attr,omitempty"`
	MAC                 *DomainInterfaceMAC                `xml:"mac"`
	Source              *DomainInterfaceSource             `xml:"source"`
	Boot                *DomainDeviceBoot                  `xml:"boot"`
	VLan                *DomainInterfaceVLan               `xml:"vlan"`
	VirtualPort         *DomainInterfaceVirtualPort        `xml:"virtualport"`
	IP                  []DomainInterfaceIP                `xml:"ip"`
	Route               []DomainInterfaceRoute             `xml:"route"`
	PortForward         []DomainInterfaceSourcePortForward `xml:"portForward"`
	Script              *DomainInterfaceScript             `xml:"script"`
	DownScript          *DomainInterfaceScript             `xml:"downscript"`
	BackendDomain       *DomainBackendDomain               `xml:"backenddomain"`
	Target              *DomainInterfaceTarget             `xml:"target"`
	Guest               *DomainInterfaceGuest              `xml:"guest"`
	Model               *DomainInterfaceModel              `xml:"model"`
	Driver              *DomainInterfaceDriver             `xml:"driver"`
	Backend             *DomainInterfaceBackend            `xml:"backend"`
	FilterRef           *DomainInterfaceFilterRef          `xml:"filterref"`
	Tune                *DomainInterfaceTune               `xml:"tune"`
	Teaming             *DomainInterfaceTeaming            `xml:"teaming"`
	Link                *DomainInterfaceLink               `xml:"link"`
	MTU                 *DomainInterfaceMTU                `xml:"mtu"`
	Bandwidth           *DomainInterfaceBandwidth          `xml:"bandwidth"`
	PortOptions         *DomainInterfacePortOptions        `xml:"port"`
	Coalesce            *DomainInterfaceCoalesce           `xml:"coalesce"`
	ROM                 *DomainROM                         `xml:"rom"`
	ACPI                *DomainDeviceACPI                  `xml:"acpi"`
	Alias               *DomainAlias                       `xml:"alias"`
	Address             *DomainAddress                     `xml:"address"`
}

func (*DomainInterface) Marshal 

func (d *DomainInterface) Marshal() (string, error)

func (*DomainInterface) MarshalXML 

func (a *DomainInterface) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterface) Unmarshal 

func (d *DomainInterface) Unmarshal(doc string) error

func (*DomainInterface) UnmarshalXML 

func (a *DomainInterface) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceBackend 

type DomainInterfaceBackend struct {
	Type    string `xml:"type,attr,omitempty"`
	Tap     string `xml:"tap,attr,omitempty"`
	VHost   string `xml:"vhost,attr,omitempty"`
	LogFile string `xml:"logFile,attr,omitempty"`
}

type DomainInterfaceBandwidth 

type DomainInterfaceBandwidth struct {
	Inbound  *DomainInterfaceBandwidthParams `xml:"inbound"`
	Outbound *DomainInterfaceBandwidthParams `xml:"outbound"`
}

type DomainInterfaceBandwidthParams 

type DomainInterfaceBandwidthParams struct {
	Average *int `xml:"average,attr"`
	Peak    *int `xml:"peak,attr"`
	Burst   *int `xml:"burst,attr"`
	Floor   *int `xml:"floor,attr"`
}

type DomainInterfaceCoalesce 

type DomainInterfaceCoalesce struct {
	RX *DomainInterfaceCoalesceRX `xml:"rx"`
}

type DomainInterfaceCoalesceRX 

type DomainInterfaceCoalesceRX struct {
	Frames *DomainInterfaceCoalesceRXFrames `xml:"frames"`
}

type DomainInterfaceCoalesceRXFrames 

type DomainInterfaceCoalesceRXFrames struct {
	Max *uint `xml:"max,attr"`
}

type DomainInterfaceDriver 

type DomainInterfaceDriver struct {
	Name          string                      `xml:"name,attr,omitempty"`
	TXMode        string                      `xml:"txmode,attr,omitempty"`
	IOEventFD     string                      `xml:"ioeventfd,attr,omitempty"`
	EventIDX      string                      `xml:"event_idx,attr,omitempty"`
	Queues        uint                        `xml:"queues,attr,omitempty"`
	RXQueueSize   uint                        `xml:"rx_queue_size,attr,omitempty"`
	TXQueueSize   uint                        `xml:"tx_queue_size,attr,omitempty"`
	IOMMU         string                      `xml:"iommu,attr,omitempty"`
	ATS           string                      `xml:"ats,attr,omitempty"`
	Packed        string                      `xml:"packed,attr,omitempty"`
	PagePerVQ     string                      `xml:"page_per_vq,attr,omitempty"`
	RSS           string                      `xml:"rss,attr,omitempty"`
	RSSHashReport string                      `xml:"rss_hash_report,attr,omitempty"`
	Host          *DomainInterfaceDriverHost  `xml:"host"`
	Guest         *DomainInterfaceDriverGuest `xml:"guest"`
}

type DomainInterfaceDriverGuest 

type DomainInterfaceDriverGuest struct {
	CSum string `xml:"csum,attr,omitempty"`
	TSO4 string `xml:"tso4,attr,omitempty"`
	TSO6 string `xml:"tso6,attr,omitempty"`
	ECN  string `xml:"ecn,attr,omitempty"`
	UFO  string `xml:"ufo,attr,omitempty"`
}

type DomainInterfaceDriverHost 

type DomainInterfaceDriverHost struct {
	CSum     string `xml:"csum,attr,omitempty"`
	GSO      string `xml:"gso,attr,omitempty"`
	TSO4     string `xml:"tso4,attr,omitempty"`
	TSO6     string `xml:"tso6,attr,omitempty"`
	ECN      string `xml:"ecn,attr,omitempty"`
	UFO      string `xml:"ufo,attr,omitempty"`
	MrgRXBuf string `xml:"mrg_rxbuf,attr,omitempty"`
}

type DomainInterfaceFilterParam 

type DomainInterfaceFilterParam struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr"`
}

type DomainInterfaceFilterRef 

type DomainInterfaceFilterRef struct {
	Filter     string                       `xml:"filter,attr"`
	Parameters []DomainInterfaceFilterParam `xml:"parameter"`
}

type DomainInterfaceGuest 

type DomainInterfaceGuest struct {
	Dev    string `xml:"dev,attr,omitempty"`
	Actual string `xml:"actual,attr,omitempty"`
}

type DomainInterfaceIP 

type DomainInterfaceIP struct {
	Address string `xml:"address,attr"`
	Family  string `xml:"family,attr,omitempty"`
	Prefix  uint   `xml:"prefix,attr,omitempty"`
	Peer    string `xml:"peer,attr,omitempty"`
}
type DomainInterfaceLink struct {
	State string `xml:"state,attr"`
}

type DomainInterfaceMAC 

type DomainInterfaceMAC struct {
	Address string `xml:"address,attr"`
	Type    string `xml:"type,attr,omitempty"`
	Check   string `xml:"check,attr,omitempty"`
}

type DomainInterfaceMTU 

type DomainInterfaceMTU struct {
	Size uint `xml:"size,attr"`
}

type DomainInterfaceModel 

type DomainInterfaceModel struct {
	Type string `xml:"type,attr"`
}

type DomainInterfacePortOptions 

type DomainInterfacePortOptions struct {
	Isolated string `xml:"isolated,attr,omitempty"`
}

type DomainInterfaceRoute 

type DomainInterfaceRoute struct {
	Family  string `xml:"family,attr,omitempty"`
	Address string `xml:"address,attr"`
	Netmask string `xml:"netmask,attr,omitempty"`
	Prefix  uint   `xml:"prefix,attr,omitempty"`
	Gateway string `xml:"gateway,attr"`
	Metric  uint   `xml:"metric,attr,omitempty"`
}

type DomainInterfaceScript 

type DomainInterfaceScript struct {
	Path string `xml:"path,attr"`
}

type DomainInterfaceSource 

type DomainInterfaceSource struct {
	User      *DomainInterfaceSourceUser     `xml:"-"`
	Ethernet  *DomainInterfaceSourceEthernet `xml:"-"`
	VHostUser *DomainChardevSource           `xml:"-"`
	Server    *DomainInterfaceSourceServer   `xml:"-"`
	Client    *DomainInterfaceSourceClient   `xml:"-"`
	MCast     *DomainInterfaceSourceMCast    `xml:"-"`
	Network   *DomainInterfaceSourceNetwork  `xml:"-"`
	Bridge    *DomainInterfaceSourceBridge   `xml:"-"`
	Internal  *DomainInterfaceSourceInternal `xml:"-"`
	Direct    *DomainInterfaceSourceDirect   `xml:"-"`
	Hostdev   *DomainInterfaceSourceHostdev  `xml:"-"`
	UDP       *DomainInterfaceSourceUDP      `xml:"-"`
	VDPA      *DomainInterfaceSourceVDPA     `xml:"-"`
	Null      *DomainInterfaceSourceNull     `xml:"-"`
	VDS       *DomainInterfaceSourceVDS      `xml:"-"`
}

func (*DomainInterfaceSource) MarshalXML 

func (a *DomainInterfaceSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceSource) UnmarshalXML 

func (a *DomainInterfaceSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceSourceBridge 

type DomainInterfaceSourceBridge struct {
	Bridge string `xml:"bridge,attr"`
}

type DomainInterfaceSourceClient 

type DomainInterfaceSourceClient struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceDirect 

type DomainInterfaceSourceDirect struct {
	Dev  string `xml:"dev,attr,omitempty"`
	Mode string `xml:"mode,attr,omitempty"`
}

type DomainInterfaceSourceEthernet 

type DomainInterfaceSourceEthernet struct {
	IP    []DomainInterfaceIP    `xml:"ip"`
	Route []DomainInterfaceRoute `xml:"route"`
}

type DomainInterfaceSourceHostdev 

type DomainInterfaceSourceHostdev struct {
	PCI *DomainHostdevSubsysPCISource `xml:"-"`
	USB *DomainHostdevSubsysUSBSource `xml:"-"`
}

func (*DomainInterfaceSourceHostdev) MarshalXML 

func (a *DomainInterfaceSourceHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceSourceHostdev) UnmarshalXML 

func (a *DomainInterfaceSourceHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceSourceInternal 

type DomainInterfaceSourceInternal struct {
	Name string `xml:"name,attr,omitempty"`
}

type DomainInterfaceSourceLocal 

type DomainInterfaceSourceLocal struct {
	Address string `xml:"address,attr,omitempty"`
	Port    uint   `xml:"port,attr,omitempty"`
}

type DomainInterfaceSourceMCast 

type DomainInterfaceSourceMCast struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceNetwork 

type DomainInterfaceSourceNetwork struct {
	Network   string `xml:"network,attr,omitempty"`
	PortGroup string `xml:"portgroup,attr,omitempty"`
	Bridge    string `xml:"bridge,attr,omitempty"`
	PortID    string `xml:"portid,attr,omitempty"`
}

type DomainInterfaceSourceNull added in v1.8007.0 

type DomainInterfaceSourceNull struct {
}

type DomainInterfaceSourcePortForward added in v1.9000.0 

type DomainInterfaceSourcePortForward struct {
	Proto   string                                  `xml:"proto,attr"`
	Address string                                  `xml:"address,attr,omitempty"`
	Dev     string                                  `xml:"dev,attr,omitempty"`
	Ranges  []DomainInterfaceSourcePortForwardRange `xml:"range"`
}

type DomainInterfaceSourcePortForwardRange added in v1.9000.0 

type DomainInterfaceSourcePortForwardRange struct {
	Start   uint   `xml:"start,attr"`
	End     uint   `xml:"end,attr,omitempty"`
	To      uint   `xml:"to,attr,omitempty"`
	Exclude string `xml:"exclude,attr,omitempty"`
}

type DomainInterfaceSourceServer 

type DomainInterfaceSourceServer struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceUDP 

type DomainInterfaceSourceUDP struct {
	Address string                      `xml:"address,attr,omitempty"`
	Port    uint                        `xml:"port,attr,omitempty"`
	Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceUser 

type DomainInterfaceSourceUser struct {
	Dev string `xml:"dev,attr,omitempty"`
}

type DomainInterfaceSourceVDPA 

type DomainInterfaceSourceVDPA struct {
	Device string `xml:"dev,attr,omitempty"`
}

type DomainInterfaceSourceVDS added in v1.8007.0 

type DomainInterfaceSourceVDS struct {
	SwitchID     string `xml:"switchid,attr"`
	PortID       int    `xml:"portid,attr,omitempty"`
	PortGroupID  string `xml:"portgroupid,attr,omitempty"`
	ConnectionID int    `xml:"connectionid,attr,omitempty"`
}

type DomainInterfaceTarget 

type DomainInterfaceTarget struct {
	Dev     string `xml:"dev,attr"`
	Managed string `xml:"managed,attr,omitempty"`
}

type DomainInterfaceTeaming 

type DomainInterfaceTeaming struct {
	Type       string `xml:"type,attr"`
	Persistent string `xml:"persistent,attr,omitempty"`
}

type DomainInterfaceTune 

type DomainInterfaceTune struct {
	SndBuf uint `xml:"sndbuf"`
}

type DomainInterfaceVLan 

type DomainInterfaceVLan struct {
	Trunk string                   `xml:"trunk,attr,omitempty"`
	Tags  []DomainInterfaceVLanTag `xml:"tag"`
}

type DomainInterfaceVLanTag 

type DomainInterfaceVLanTag struct {
	ID         uint   `xml:"id,attr"`
	NativeMode string `xml:"nativeMode,attr,omitempty"`
}

type DomainInterfaceVirtualPort 

type DomainInterfaceVirtualPort struct {
	Params *DomainInterfaceVirtualPortParams `xml:"parameters"`
}

func (*DomainInterfaceVirtualPort) MarshalXML 

func (a *DomainInterfaceVirtualPort) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceVirtualPort) UnmarshalXML 

func (a *DomainInterfaceVirtualPort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceVirtualPortParams 

type DomainInterfaceVirtualPortParams struct {
	Any          *DomainInterfaceVirtualPortParamsAny          `xml:"-"`
	VEPA8021QBG  *DomainInterfaceVirtualPortParamsVEPA8021QBG  `xml:"-"`
	VNTag8011QBH *DomainInterfaceVirtualPortParamsVNTag8021QBH `xml:"-"`
	OpenVSwitch  *DomainInterfaceVirtualPortParamsOpenVSwitch  `xml:"-"`
	MidoNet      *DomainInterfaceVirtualPortParamsMidoNet      `xml:"-"`
}

func (*DomainInterfaceVirtualPortParams) MarshalXML 

func (a *DomainInterfaceVirtualPortParams) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceVirtualPortParams) UnmarshalXML 

func (a *DomainInterfaceVirtualPortParams) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceVirtualPortParamsAny 

type DomainInterfaceVirtualPortParamsAny struct {
	ManagerID     *uint  `xml:"managerid,attr"`
	TypeID        *uint  `xml:"typeid,attr"`
	TypeIDVersion *uint  `xml:"typeidversion,attr"`
	InstanceID    string `xml:"instanceid,attr,omitempty"`
	ProfileID     string `xml:"profileid,attr,omitempty"`
	InterfaceID   string `xml:"interfaceid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsMidoNet 

type DomainInterfaceVirtualPortParamsMidoNet struct {
	InterfaceID string `xml:"interfaceid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsOpenVSwitch 

type DomainInterfaceVirtualPortParamsOpenVSwitch struct {
	InterfaceID string `xml:"interfaceid,attr,omitempty"`
	ProfileID   string `xml:"profileid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsVEPA8021QBG 

type DomainInterfaceVirtualPortParamsVEPA8021QBG struct {
	ManagerID     *uint  `xml:"managerid,attr"`
	TypeID        *uint  `xml:"typeid,attr"`
	TypeIDVersion *uint  `xml:"typeidversion,attr"`
	InstanceID    string `xml:"instanceid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsVNTag8021QBH 

type DomainInterfaceVirtualPortParamsVNTag8021QBH struct {
	ProfileID string `xml:"profileid,attr,omitempty"`
}

type DomainKeyWrap 

type DomainKeyWrap struct {
	Ciphers []DomainKeyWrapCipher `xml:"cipher"`
}

type DomainKeyWrapCipher 

type DomainKeyWrapCipher struct {
	Name  string `xml:"name,attr"`
	State string `xml:"state,attr"`
}

type DomainLXCNamespace 

type DomainLXCNamespace struct {
	XMLName  xml.Name               `xml:"http://libvirt.org/schemas/domain/lxc/1.0 namespace"`
	ShareNet *DomainLXCNamespaceMap `xml:"sharenet"`
	ShareIPC *DomainLXCNamespaceMap `xml:"shareipc"`
	ShareUTS *DomainLXCNamespaceMap `xml:"shareuts"`
}

type DomainLXCNamespaceMap 

type DomainLXCNamespaceMap struct {
	Type  string `xml:"type,attr"`
	Value string `xml:"value,attr"`
}