README 

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

.. image:: https://gitlab.com/libvirt/libvirt-go-xml/badges/master/pipeline.svg
   :target: https://gitlab.com/libvirt/libvirt-go-xml/pipelines
   :alt: Build Status
.. image:: https://img.shields.io/static/v1?label=godev&message=reference&color=00add8
   :target: https://pkg.go.dev/libvirt.org/libvirt-go-xml
   :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.


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

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

* `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 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
change at the same time. Bug fixes and other improvements to the
libvirt-go-xml library are welcome at any time.

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

Documentation

Overview

Package libvirt-go-xml 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/libvirt-go-xml"
)

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/libvirt-go"
  "libvirt.org/libvirt-go-xml"
  "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"`
	Topology     *CapsHostCPUTopology     `xml:"topology"`
	FeatureFlags []CapsHostCPUFeatureFlag `xml:"feature"`
	Features     *CapsHostCPUFeatures     `xml:"features"`
	PageSizes    []CapsHostCPUPageSize    `xml:"pages"`
	Microcode    *CapsHostCPUMicrocode    `xml:"microcode"`
}

func (*CapsHostCPU) Marshal 

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

func (*CapsHostCPU) Unmarshal 

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

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 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 CapsHostCPUTopology 

type CapsHostCPUTopology struct {
	Sockets int `xml:"sockets,attr"`
	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"`
	CoreID   *int   `xml:"core_id,attr"`
	Siblings string `xml:"siblings,attr,omitempty"`
}

type CapsHostNUMACPUs 

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

type CapsHostNUMACell 

type CapsHostNUMACell struct {
	ID        int                    `xml:"id,attr"`
	Memory    *CapsHostNUMAMemory    `xml:"memory"`
	PageInfo  []CapsHostNUMAPageInfo `xml:"pages"`
	Distances *CapsHostNUMADistances `xml:"distances"`
	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 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"`
}

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"`
	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
	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"`
	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:"-"`
}

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 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 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"`
	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"`
	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 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"`
	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"`
	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 DomainCapsCPUMode 

type DomainCapsCPUMode struct {
	Name      string                 `xml:"name,attr"`
	Supported string                 `xml:"supported,attr"`
	Models    []DomainCapsCPUModel   `xml:"model"`
	Vendor    string                 `xml:"vendor,omitempty"`
	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"`
}

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"`
}

type DomainCapsEnum 

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

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 DomainCapsFeatureSEV 

type DomainCapsFeatureSEV struct {
	Supported       string `xml:"supported,attr"`
	CBitPos         uint   `xml:"cbitpos,omitempty"`
	ReducedPhysBits uint   `xml:"reducedPhysBits,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"`
	SEV               *DomainCapsFeatureSEV               `xml:"sev"`
}

type DomainCapsIOThreads 

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

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:"-"`
}

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 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 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"`
	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"`
}

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
}

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 DomainCurrentMemory 

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

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"`
	Watchdog     *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"`
}

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"`
}

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"`
	IOThread      *uint                    `xml:"iothread,attr"`
	DetectZeros   string                   `xml:"detect_zeroes,attr,omitempty"`
	Queues        *uint                    `xml:"queues,attr"`
	IOMMU         string                   `xml:"iommu,attr,omitempty"`
	ATS           string                   `xml:"ats,attr,omitempty"`
	Packed        string                   `xml:"packed,attr,omitempty"`
	MetadataCache *DomainDiskMetadataCache `xml:"metadata_cache"`
}

type DomainDiskEncryption 

type DomainDiskEncryption struct {
	Format string            `xml:"format,attr,omitempty"`
	Secret *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 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:"-"`
	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"`
	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"`
	Hosts     []DomainDiskSourceHost            `xml:"host"`
	Identity  *DomainDiskSourceNetworkIdentity  `xml:"identity"`
	Initiator *DomainDiskSourceNetworkInitiator `xml:"initiator"`
	Snapshot  *DomainDiskSourceNetworkSnapshot  `xml:"snapshot"`
	Config    *DomainDiskSourceNetworkConfig    `xml:"config"`
	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"`
	Group string `xml:"group,attr"`
}

type DomainDiskSourceNetworkInitiator 

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

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 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 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
	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"`
}

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"`
}

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"`
}

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 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"`
	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"`
}

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 DomainFilesystemBinarySandbox 

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

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"`
	Queue    uint   `xml:"queue,attr,omitempty"`
}

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:"-"`
	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 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 {
	Driver  *DomainHostdevSubsysPCIDriver `xml:"driver"`
	Source  *DomainHostdevSubsysPCISource `xml:"source"`
	Teaming *DomainInterfaceTeaming       `xml:"teaming"`
}

type DomainHostdevSubsysPCIDriver 

type DomainHostdevSubsysPCIDriver struct {
	Name string `xml:"name,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 {
	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"`
}

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"`
}

type DomainIOThread 

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

type DomainIOThreadIDs 

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

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"`
}

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"`
	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"`
	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 {
	Tap   string `xml:"tap,attr,omitempty"`
	VHost string `xml:"vhost,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"`
	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:"-"`
}

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 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 {
}

type DomainInterfaceSourceVDPA 

type DomainInterfaceSourceVDPA struct {
	Device string `xml:"dev,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"`
}

type DomainLaunchSecurity 

type DomainLaunchSecurity struct {
	SEV *DomainLaunchSecuritySEV `xml:"-"`
}

func (*DomainLaunchSecurity) MarshalXML 

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

func (*DomainLaunchSecurity) UnmarshalXML 

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

type DomainLaunchSecuritySEV 

type DomainLaunchSecuritySEV struct {
	CBitPos         *uint  `xml:"cbitpos"`
	ReducedPhysBits *uint  `xml:"reducedPhysBits"`
	Policy          *uint  `xml:"policy"`
	DHCert          string `xml:"dhCert"`
	Session         string `xml:"sesion"`
}

func (*DomainLaunchSecuritySEV) MarshalXML 

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

func (*DomainLaunchSecuritySEV) UnmarshalXML 

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

type DomainLease 

type DomainLease struct {
	Lockspace string             `xml:"lockspace"`
	Key       string             `xml:"key"`
	Target    *DomainLeaseTarget `xml:"target"`
}

type DomainLeaseTarget 

type DomainLeaseTarget struct {
	Path   string `xml:"path,attr"`
	Offset uint64 `xml:"offset,attr,omitempty"`
}

type DomainLoader 

type DomainLoader struct {
	Path     string `xml:",chardata"`
	Readonly string `xml:"readonly,attr,omitempty"`
	Secure   string `xml:"secure,attr,omitempty"`
	Type     string `xml:"type,attr,omitempty"`
}

type DomainMaxMemory 

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

type DomainMemBalloon 

type DomainMemBalloon struct {
	XMLName           xml.Name                `xml:"memballoon"`
	Model             string                  `xml:"model,attr"`
	AutoDeflate       string                  `xml:"autodeflate,attr,omitempty"`
	FreePageReporting string                  `xml:"freePageReporting,attr,omitempty"`
	Driver            *DomainMemBalloonDriver `xml:"driver"`
	Stats             *DomainMemBalloonStats  `xml:"stats"`
	ACPI              *DomainDeviceACPI       `xml:"acpi"`
	Alias             *DomainAlias            `xml:"alias"`
	Address           *DomainAddress          `xml:"address"`
}

func (*DomainMemBalloon) Marshal 

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

func (*DomainMemBalloon) Unmarshal 

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

type DomainMemBalloonDriver 

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

type DomainMemBalloonStats 

type DomainMemBalloonStats struct {
	Period uint `xml:"period,attr"`
}

type DomainMemory 

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

type DomainMemoryAccess 

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

type DomainMemoryAllocation 

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

type DomainMemoryBacking 

type DomainMemoryBacking struct {
	MemoryHugePages    *DomainMemoryHugepages    `xml:"hugepages"`
	MemoryNosharepages *DomainMemoryNosharepages `xml:"nosharepages"`
	MemoryLocked       *DomainMemoryLocked       `xml:"locked"`
	MemorySource       *DomainMemorySource       `xml:"source"`
	MemoryAccess       *DomainMemoryAccess       `xml:"access"`
	MemoryAllocation   *DomainMemoryAllocation   `xml:"allocation"`
	MemoryDiscard      *DomainMemoryDiscard      `xml:"discard"`
}

type DomainMemoryDiscard 

type DomainMemoryDiscard struct {
}

type DomainMemoryHugepage 

type DomainMemoryHugepage struct {
	Size    uint   `xml:"size,attr"`
	Unit    string `xml:"unit,attr,omitempty"`
	Nodeset string `xml:"nodeset,attr,omitempty"`
}

type DomainMemoryHugepages 

type DomainMemoryHugepages struct {
	Hugepages []DomainMemoryHugepage `xml:"page"`
}

type DomainMemoryLocked 

type DomainMemoryLocked struct {
}

type DomainMemoryNosharepages 

type DomainMemoryNosharepages struct {
}

type DomainMemorySource 

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

type DomainMemoryTune 

type DomainMemoryTune struct {
	HardLimit     *DomainMemoryTuneLimit `xml:"hard_limit"`
	SoftLimit     *DomainMemoryTuneLimit `xml:"soft_limit"`
	MinGuarantee  *DomainMemoryTuneLimit `xml:"min_guarantee"`
	SwapHardLimit *DomainMemoryTuneLimit `xml:"swap_hard_limit"`
}

type DomainMemoryTuneLimit 

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

type DomainMemorydev 

type DomainMemorydev struct {
	XMLName xml.Name               `xml:"memory"`
	Model   string                 `xml:"model,attr"`
	Access  string                 `xml:"access,attr,omitempty"`
	Discard string                 `xml:"discard,attr,omitempty"`
	UUID    string                 `xml:"uuid,omitempty"`
	Source  *DomainMemorydevSource `xml:"source"`
	Target  *DomainMemorydevTarget `xml:"target"`
	ACPI    *DomainDeviceACPI      `xml:"acpi"`
	Alias   *DomainAlias           `xml:"alias"`
	Address *DomainAddress         `xml:"addres