libvirtxml

package module
v1.10002.0 Latest Latest
Warning

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

 Go to latest Published: Apr 5, 2024 License: MIT Imports: 5 Imported by: 53

README 

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

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

Go API for manipulating libvirt XML documents

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


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

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

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


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

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

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

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


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

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

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

Documentation

Overview

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

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

Example creating a domain XML document from configuration: 

package main

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

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

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

package main

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

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

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

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

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Caps 

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

func (*Caps) Marshal 

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

func (*Caps) Unmarshal 

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

type CapsGuest 

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

type CapsGuestArch 

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

type CapsGuestDomain 

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

type CapsGuestFeatureACPI 

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

type CapsGuestFeatureAPIC 

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

type CapsGuestFeatureCPUSelection 

type CapsGuestFeatureCPUSelection struct {
}

type CapsGuestFeatureDeviceBoot 

type CapsGuestFeatureDeviceBoot struct {
}

type CapsGuestFeatureDiskSnapshot 

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

type CapsGuestFeatureIA64BE 

type CapsGuestFeatureIA64BE struct {
}

type CapsGuestFeatureNonPAE 

type CapsGuestFeatureNonPAE struct {
}

type CapsGuestFeaturePAE 

type CapsGuestFeaturePAE struct {
}

type CapsGuestFeatures 

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

type CapsGuestMachine 

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

type CapsHost 

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

type CapsHostCPU 

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

func (*CapsHostCPU) Marshal 

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

func (*CapsHostCPU) Unmarshal 

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

type CapsHostCPUCache added in v1.8007.0 

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

type CapsHostCPUCounter added in v1.8007.0 

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

type CapsHostCPUFeature 

type CapsHostCPUFeature struct {
}

type CapsHostCPUFeatureFlag 

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

type CapsHostCPUFeatures 

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

type CapsHostCPUMaxPhysAddr added in v1.8007.0 

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

type CapsHostCPUMicrocode 

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

type CapsHostCPUPageSize 

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

type CapsHostCPUSignature added in v1.8005.0 

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

type CapsHostCPUTopology 

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

type CapsHostCache 

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

type CapsHostCacheBank 

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

type CapsHostCacheControl 

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

type CapsHostCacheMonitor 

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

type CapsHostCacheMonitorFeature 

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

type CapsHostIOMMU 

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

type CapsHostMemoryBandwidth 

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

type CapsHostMemoryBandwidthMonitor 

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

type CapsHostMemoryBandwidthMonitorFeature 

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

type CapsHostMemoryBandwidthNode 

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

type CapsHostMemoryBandwidthNodeControl 

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

type CapsHostMigrationFeatures 

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

type CapsHostMigrationLive 

type CapsHostMigrationLive struct {
}

type CapsHostMigrationURITransports 

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

type CapsHostNUMACPU 

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

type CapsHostNUMACPUs 

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

type CapsHostNUMACache 

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

type CapsHostNUMACacheLine 

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

type CapsHostNUMACacheSize 

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

type CapsHostNUMACell 

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

type CapsHostNUMACells 

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

type CapsHostNUMADistances 

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

type CapsHostNUMAInterconnectBandwidth 

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

type CapsHostNUMAInterconnectLatency 

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

type CapsHostNUMAInterconnects 

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

type CapsHostNUMAMemory 

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

type CapsHostNUMAPageInfo 

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

type CapsHostNUMASibling 

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

type CapsHostNUMATopology 

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

type CapsHostPowerManagement 

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

type CapsHostPowerManagementMode 

type CapsHostPowerManagementMode struct {
}

type CapsHostSecModel 

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

type CapsHostSecModelLabel 

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

type Document 

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

type Domain 

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

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

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

func (*Domain) Marshal 

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

func (*Domain) Unmarshal 

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

type DomainACPI 

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

type DomainACPITable 

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

type DomainAddress 

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

func (*DomainAddress) MarshalXML 

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

func (*DomainAddress) UnmarshalXML 

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

type DomainAddressCCID 

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

func (*DomainAddressCCID) MarshalXML 

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

func (*DomainAddressCCID) UnmarshalXML 

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

type DomainAddressCCW 

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

func (*DomainAddressCCW) MarshalXML 

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

func (*DomainAddressCCW) UnmarshalXML 

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

type DomainAddressDIMM 

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

func (*DomainAddressDIMM) MarshalXML 

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

func (*DomainAddressDIMM) UnmarshalXML 

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

type DomainAddressDrive 

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

func (*DomainAddressDrive) MarshalXML 

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

func (*DomainAddressDrive) UnmarshalXML 

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

type DomainAddressISA 

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

func (*DomainAddressISA) MarshalXML 

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

func (*DomainAddressISA) UnmarshalXML 

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

type DomainAddressMDev 

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

type DomainAddressPCI 

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

func (*DomainAddressPCI) MarshalXML 

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

func (*DomainAddressPCI) UnmarshalXML 

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

type DomainAddressSpaprVIO 

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

func (*DomainAddressSpaprVIO) MarshalXML 

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

func (*DomainAddressSpaprVIO) UnmarshalXML 

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

type DomainAddressUSB 

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

func (*DomainAddressUSB) MarshalXML 

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

func (*DomainAddressUSB) UnmarshalXML 

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

type DomainAddressUnassigned 

type DomainAddressUnassigned struct {
}

func (*DomainAddressUnassigned) MarshalXML 

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

func (*DomainAddressUnassigned) UnmarshalXML 

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

type DomainAddressVirtioMMIO 

type DomainAddressVirtioMMIO struct {
}

func (*DomainAddressVirtioMMIO) MarshalXML 

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

func (*DomainAddressVirtioMMIO) UnmarshalXML 

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

type DomainAddressVirtioS390 

type DomainAddressVirtioS390 struct {
}

func (*DomainAddressVirtioS390) MarshalXML 

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

func (*DomainAddressVirtioS390) UnmarshalXML 

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

type DomainAddressVirtioSerial 

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

func (*DomainAddressVirtioSerial) MarshalXML 

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

func (*DomainAddressVirtioSerial) UnmarshalXML 

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

type DomainAddressZPCI 

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

func (*DomainAddressZPCI) MarshalXML 

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

func (*DomainAddressZPCI) UnmarshalXML 

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

type DomainAlias 

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

type DomainAudio 

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

func (*DomainAudio) MarshalXML 

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

func (*DomainAudio) UnmarshalXML 

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

type DomainAudioALSA 

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

type DomainAudioALSAChannel 

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

type DomainAudioChannel 

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

type DomainAudioChannelSettings 

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

type DomainAudioCoreAudio 

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

type DomainAudioCoreAudioChannel 

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

type DomainAudioDBus added in v1.8004.0 

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

type DomainAudioDBusChannel added in v1.8004.0 

type DomainAudioDBusChannel struct {
	DomainAudioChannel
}

type DomainAudioFile 

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

type DomainAudioFileChannel 

type DomainAudioFileChannel struct {
	DomainAudioChannel
}

type DomainAudioJack 

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

type DomainAudioJackChannel 

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

type DomainAudioNone 

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

type DomainAudioNoneChannel 

type DomainAudioNoneChannel struct {
	DomainAudioChannel
}

type DomainAudioOSS 

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

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

type DomainAudioOSSChannel 

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

type DomainAudioPipeWire added in v1.10000.0 

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

type DomainAudioPipeWireChannel added in v1.10000.0 

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

type DomainAudioPulseAudio 

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

type DomainAudioPulseAudioChannel 

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

type DomainAudioSDL 

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

type DomainAudioSDLChannel 

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

type DomainAudioSPICE 

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

type DomainAudioSPICEChannel 

type DomainAudioSPICEChannel struct {
	DomainAudioChannel
}

type DomainBHyveCommandline 

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

type DomainBHyveCommandlineArg 

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

type DomainBHyveCommandlineEnv 

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

type DomainBIOS 

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

type DomainBackendDomain 

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

type DomainBlockIOTune 

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

type DomainBlockIOTuneDevice 

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

type DomainBootDevice 

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

type DomainBootMenu 

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

type DomainCPU 

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

func (*DomainCPU) Marshal 

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

func (*DomainCPU) Unmarshal 

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

type DomainCPUCache 

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

type DomainCPUCacheTune 

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

type DomainCPUCacheTuneCache 

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

type DomainCPUCacheTuneMonitor 

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

type DomainCPUFeature 

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

type DomainCPUMaxPhysAddr added in v1.8007.0 

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

type DomainCPUMemoryTune 

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

type DomainCPUMemoryTuneMonitor 

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

type DomainCPUMemoryTuneNode 

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

type DomainCPUModel 

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

type DomainCPUTopology 

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

type DomainCPUTune 

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

type DomainCPUTuneEmulatorPin 

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

type DomainCPUTuneEmulatorSched 

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

type DomainCPUTuneIOThreadPin 

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

type DomainCPUTuneIOThreadSched 

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

type DomainCPUTunePeriod 

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

type DomainCPUTuneQuota 

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

type DomainCPUTuneShares 

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

type DomainCPUTuneVCPUPin 

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

type DomainCPUTuneVCPUSched 

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

type DomainCaps 

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

func (*DomainCaps) Marshal 

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

func (*DomainCaps) Unmarshal 

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

type DomainCapsCPU 

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

type DomainCapsCPUFeature 

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

type DomainCapsCPUMaxPhysAddr added in v1.9005.0 

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

type DomainCapsCPUMode 

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

type DomainCapsCPUModel 

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

type DomainCapsDevice 

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

type DomainCapsDevices 

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

type DomainCapsEnum 

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

type DomainCapsFeatureAsyncTeardown added in v1.9006.0 

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

type DomainCapsFeatureBackingStoreInput 

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

type DomainCapsFeatureBackup 

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

type DomainCapsFeatureGIC 

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

type DomainCapsFeatureGenID 

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

type DomainCapsFeatureHyperV added in v1.9000.0 

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

type DomainCapsFeatureS390PV added in v1.7006.0 

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

type DomainCapsFeatureSEV 

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

type DomainCapsFeatureSGX added in v1.8010.0 

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

type DomainCapsFeatureSGXFeature added in v1.8010.0 

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

type DomainCapsFeatureSGXSection added in v1.8010.0 

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

type DomainCapsFeatureSGXSectionSize added in v1.8010.0 

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

type DomainCapsFeatureVMCoreInfo 

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

type DomainCapsFeatures 

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

type DomainCapsIOThreads 

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

type DomainCapsMemoryBacking added in v1.7006.0 

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

type DomainCapsOS 

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

type DomainCapsOSLoader 

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

type DomainCapsVCPU 

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

type DomainCell 

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

type DomainCellCache 

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

type DomainCellCacheLine 

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

type DomainCellCacheSize 

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

type DomainCellDistances 

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

type DomainCellSibling 

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

type DomainChannel 

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

func (*DomainChannel) Marshal 

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

func (*DomainChannel) MarshalXML 

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

func (*DomainChannel) Unmarshal 

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

func (*DomainChannel) UnmarshalXML 

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

type DomainChannelTarget 

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

func (*DomainChannelTarget) MarshalXML 

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

func (*DomainChannelTarget) UnmarshalXML 

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

type DomainChannelTargetGuestFWD 

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

type DomainChannelTargetVirtIO 

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

type DomainChannelTargetXen 

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

type DomainChardevLog 

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

type DomainChardevProtocol 

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

type DomainChardevSource 

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

func (*DomainChardevSource) MarshalXML 

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

func (*DomainChardevSource) UnmarshalXML 

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

type DomainChardevSourceDBus added in v1.8004.0 

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

type DomainChardevSourceDev 

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

type DomainChardevSourceFile 

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

type DomainChardevSourceNMDM 

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

type DomainChardevSourceNull 

type DomainChardevSourceNull struct {
}

type DomainChardevSourcePipe 

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

type DomainChardevSourcePty 

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

type DomainChardevSourceQEMUVDAgent added in v1.8004.0 

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

type DomainChardevSourceQEMUVDAgentClipBoard added in v1.8004.0 

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

type DomainChardevSourceQEMUVDAgentMouse added in v1.8004.0 

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

type DomainChardevSourceReconnect 

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

type DomainChardevSourceSpicePort 

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

type DomainChardevSourceSpiceVMC 

type DomainChardevSourceSpiceVMC struct {
}

type DomainChardevSourceStdIO 

type DomainChardevSourceStdIO struct {
}

type DomainChardevSourceTCP 

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

type DomainChardevSourceUDP 

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

type DomainChardevSourceUNIX 

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

type DomainChardevSourceVC 

type DomainChardevSourceVC struct {
}

type DomainChardevTarget 

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

type DomainClock 

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

type DomainConsole 

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

func (*DomainConsole) Marshal 

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

func (*DomainConsole) MarshalXML 

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

func (*DomainConsole) Unmarshal 

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

func (*DomainConsole) UnmarshalXML 

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

type DomainConsoleTarget 

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

type DomainController 

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

func (*DomainController) Marshal 

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

func (*DomainController) MarshalXML 

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

func (*DomainController) Unmarshal 

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

func (*DomainController) UnmarshalXML 

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

type DomainControllerDriver 

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

type DomainControllerPCI 

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

type DomainControllerPCIHole64 

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

type DomainControllerPCIModel 

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

type DomainControllerPCITarget 

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

func (*DomainControllerPCITarget) MarshalXML 

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

func (*DomainControllerPCITarget) UnmarshalXML 

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

type DomainControllerUSB 

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

type DomainControllerUSBMaster 

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

type DomainControllerVirtIOSerial 

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

type DomainControllerXenBus 

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

type DomainCrypto added in v1.9001.0 

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

type DomainCryptoBackend added in v1.9001.0 

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

func (*DomainCryptoBackend) MarshalXML added in v1.9001.0 

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

func (*DomainCryptoBackend) UnmarshalXML added in v1.9001.0 

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

type DomainCryptoBackendBuiltIn added in v1.9001.0 

type DomainCryptoBackendBuiltIn struct {
}

type DomainCryptoBackendLKCF added in v1.9001.0 

type DomainCryptoBackendLKCF struct {
}

type DomainCurrentMemory 

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

type DomainDefaultIOThread added in v1.8005.0 

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

type DomainDeviceACPI 

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

type DomainDeviceBoot 

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

type DomainDeviceList 

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

type DomainDeviceSecLabel 

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

type DomainDisk 

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

func (*DomainDisk) Marshal 

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

func (*DomainDisk) MarshalXML 

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

func (*DomainDisk) Unmarshal 

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

func (*DomainDisk) UnmarshalXML 

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

type DomainDiskAuth 

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

type DomainDiskBackingStore 

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

func (*DomainDiskBackingStore) MarshalXML 

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

func (*DomainDiskBackingStore) UnmarshalXML 

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

type DomainDiskBlockIO 

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

type DomainDiskCookie 

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

type DomainDiskCookies 

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

type DomainDiskDriver 

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

type DomainDiskEncryption 

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

type DomainDiskFormat 

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

type DomainDiskGeometry 

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

type DomainDiskIOThread added in v1.10000.0 

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

type DomainDiskIOThreadQueue added in v1.10000.0 

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

type DomainDiskIOThreads added in v1.10000.0 

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

type DomainDiskIOTune 

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

type DomainDiskMetadataCache 

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

type DomainDiskMetadataCacheSize 

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

type DomainDiskMirror 

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

func (*DomainDiskMirror) MarshalXML 

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

func (*DomainDiskMirror) UnmarshalXML 

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

type DomainDiskReadOnly 

type DomainDiskReadOnly struct {
}

type DomainDiskReservations 

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

type DomainDiskReservationsSource 

type DomainDiskReservationsSource DomainChardevSource

func (*DomainDiskReservationsSource) MarshalXML 

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

func (*DomainDiskReservationsSource) UnmarshalXML 

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

type DomainDiskSecret 

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

type DomainDiskShareable 

type DomainDiskShareable struct {
}

type DomainDiskSlice 

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

type DomainDiskSlices 

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

type DomainDiskSource 

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

func (*DomainDiskSource) MarshalXML 

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

func (*DomainDiskSource) UnmarshalXML 

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

type DomainDiskSourceBlock 

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

type DomainDiskSourceDir 

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

type DomainDiskSourceFile 

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

type DomainDiskSourceHost 

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

type DomainDiskSourceNVME 

type DomainDiskSourceNVME struct {
	PCI *DomainDiskSourceNVMEPCI
}

type DomainDiskSourceNVMEPCI 

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

type DomainDiskSourceNetwork 

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

type DomainDiskSourceNetworkConfig 

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

type DomainDiskSourceNetworkIQN 

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

type DomainDiskSourceNetworkIdentity 

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

type DomainDiskSourceNetworkInitiator 

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

type DomainDiskSourceNetworkKnownHosts added in v1.9008.0 

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

type DomainDiskSourceNetworkReconnect added in v1.9002.0 

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

type DomainDiskSourceNetworkSnapshot 

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

type DomainDiskSourceReadahead 

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

type DomainDiskSourceSSL 

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

type DomainDiskSourceTimeout 

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

type DomainDiskSourceVHostUser 

type DomainDiskSourceVHostUser DomainChardevSource

func (*DomainDiskSourceVHostUser) MarshalXML 

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

func (*DomainDiskSourceVHostUser) UnmarshalXML 

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

type DomainDiskSourceVHostVDPA added in v1.9008.0 

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

type DomainDiskSourceVolume 

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

type DomainDiskTarget 

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

type DomainDiskTransient 

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

type DomainFeature 

type DomainFeature struct {
}

type DomainFeatureAPIC 

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

type DomainFeatureAsyncTeardown added in v1.9006.0 

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

type DomainFeatureCFPC 

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

type DomainFeatureCapabilities 

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

type DomainFeatureCapability 

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

type DomainFeatureGIC 

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

type DomainFeatureHPT 

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

type DomainFeatureHPTPageSize 

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

type DomainFeatureHyperV 

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

type DomainFeatureHyperVSTimer 

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

type DomainFeatureHyperVSpinlocks 

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

type DomainFeatureHyperVVendorId 

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

type DomainFeatureIBS 

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

type DomainFeatureIOAPIC 

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

type DomainFeatureKVM 

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

type DomainFeatureKVMDirtyRing added in v1.8000.0 

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

type DomainFeatureList 

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

type DomainFeatureMSRS 

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

type DomainFeatureSBBC 

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

type DomainFeatureSMM 

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

type DomainFeatureSMMTSeg 

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

type DomainFeatureState 

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

type DomainFeatureTCG added in v1.8000.0 

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

type DomainFeatureTCGTBCache added in v1.8000.0 

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

type DomainFeatureXen 

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

type DomainFeatureXenE820Host 

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

type DomainFeatureXenPassthrough 

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

type DomainFilesystem 

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

func (*DomainFilesystem) Marshal 

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

func (*DomainFilesystem) MarshalXML 

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

func (*DomainFilesystem) Unmarshal 

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

func (*DomainFilesystem) UnmarshalXML 

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

type DomainFilesystemBinary 

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

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 DomainFilesystemBinaryThreadPool added in v1.8005.0 

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

type DomainFilesystemDriver 

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

type DomainFilesystemIDMap added in v1.10000.0 

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

type DomainFilesystemIDMapEntry added in v1.10000.0 

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

type DomainFilesystemReadOnly 

type DomainFilesystemReadOnly struct {
}

type DomainFilesystemSource 

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

func (*DomainFilesystemSource) MarshalXML 

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

func (*DomainFilesystemSource) UnmarshalXML 

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

type DomainFilesystemSourceBind 

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

type DomainFilesystemSourceBlock 

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

type DomainFilesystemSourceFile 

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

type DomainFilesystemSourceMount 

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

type DomainFilesystemSourceRAM 

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

type DomainFilesystemSourceTemplate 

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

type DomainFilesystemSourceVolume 

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

type DomainFilesystemSpaceHardLimit 

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

type DomainFilesystemSpaceSoftLimit 

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

type DomainFilesystemTarget 

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

type DomainGenID 

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

type DomainGraphic 

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

func (*DomainGraphic) Marshal 

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

func (*DomainGraphic) MarshalXML 

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

func (*DomainGraphic) Unmarshal 

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

func (*DomainGraphic) UnmarshalXML 

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

type DomainGraphicAudio 

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

type DomainGraphicChannel 

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

type DomainGraphicDBus added in v1.8004.0 

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

type DomainGraphicDBusGL added in v1.8004.0 

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

type DomainGraphicDesktop 

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

type DomainGraphicEGLHeadless 

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

type DomainGraphicEGLHeadlessGL 

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

type DomainGraphicFileTransfer 

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

type DomainGraphicListener 

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

func (*DomainGraphicListener) MarshalXML 

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

func (*DomainGraphicListener) UnmarshalXML 

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

type DomainGraphicListenerAddress 

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

type DomainGraphicListenerNetwork 

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

type DomainGraphicListenerSocket 

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

type DomainGraphicRDP 

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

type DomainGraphicSDL 

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

type DomainGraphicSpice 

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

type DomainGraphicSpiceChannel 

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

type DomainGraphicSpiceClipBoard 

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

type DomainGraphicSpiceFileTransfer 

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

type DomainGraphicSpiceGL 

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

type DomainGraphicSpiceImage 

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

type DomainGraphicSpiceJPEG 

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

type DomainGraphicSpiceMouse 

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

type DomainGraphicSpicePlayback 

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

type DomainGraphicSpiceStreaming 

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

type DomainGraphicSpiceZLib 

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

type DomainGraphicVNC 

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

type DomainGraphicsSDLGL 

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

type DomainHostdev 

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

func (*DomainHostdev) Marshal 

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

func (*DomainHostdev) MarshalXML 

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

func (*DomainHostdev) Unmarshal 

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

func (*DomainHostdev) UnmarshalXML 

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

type DomainHostdevCapsMisc 

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

type DomainHostdevCapsMiscSource 

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

type DomainHostdevCapsNet 

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

type DomainHostdevCapsNetSource 

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

type DomainHostdevCapsStorage 

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

type DomainHostdevCapsStorageSource 

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

type DomainHostdevSubsysMDev 

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

type DomainHostdevSubsysMDevSource 

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

type DomainHostdevSubsysPCI 

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

type DomainHostdevSubsysPCIDriver 

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

type DomainHostdevSubsysPCISource 

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

type DomainHostdevSubsysSCSI 

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

type DomainHostdevSubsysSCSIAdapter 

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

type DomainHostdevSubsysSCSIHost 

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

type DomainHostdevSubsysSCSIHostSource 

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

type DomainHostdevSubsysSCSISource 

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

func (*DomainHostdevSubsysSCSISource) MarshalXML 

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

func (*DomainHostdevSubsysSCSISource) UnmarshalXML 

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

type DomainHostdevSubsysSCSISourceHost 

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

type DomainHostdevSubsysSCSISourceIQN 

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

type DomainHostdevSubsysSCSISourceISCSI 

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

type DomainHostdevSubsysSCSISourceInitiator 

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

type DomainHostdevSubsysUSB 

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

type DomainHostdevSubsysUSBSource 

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

type DomainHub 

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

type DomainIDMap 

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

type DomainIDMapRange 

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

type DomainIOMMU 

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

type DomainIOMMUDriver 

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

type DomainIOThread 

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

type DomainIOThreadIDs 

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

type DomainIOThreadPoll added in v1.9004.0 

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

type DomainIP 

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

type DomainInput 

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

func (*DomainInput) Marshal 

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

func (*DomainInput) MarshalXML 

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

func (*DomainInput) Unmarshal 

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

func (*DomainInput) UnmarshalXML 

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

type DomainInputDriver 

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

type DomainInputSource 

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

func (*DomainInputSource) MarshalXML 

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

func (*DomainInputSource) UnmarshalXML 

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

type DomainInputSourceEVDev 

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

type DomainInputSourcePassthrough 

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

type DomainInterface 

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

func (*DomainInterface) Marshal 

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

func (*DomainInterface) MarshalXML 

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

func (*DomainInterface) Unmarshal 

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

func (*DomainInterface) UnmarshalXML 

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

type DomainInterfaceBackend 

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

type DomainInterfaceBandwidth 

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

type DomainInterfaceBandwidthParams 

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

type DomainInterfaceCoalesce 

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

type DomainInterfaceCoalesceRX 

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

type DomainInterfaceCoalesceRXFrames 

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

type DomainInterfaceDriver 

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

type DomainInterfaceDriverGuest 

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

type DomainInterfaceDriverHost 

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

type DomainInterfaceFilterParam 

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

type DomainInterfaceFilterRef 

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

type DomainInterfaceGuest 

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

type DomainInterfaceIP 

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

type DomainInterfaceMAC 

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

type DomainInterfaceMTU 

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

type DomainInterfaceModel 

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

type DomainInterfacePortOptions 

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

type DomainInterfaceRoute 

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

type DomainInterfaceScript 

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

type DomainInterfaceSource 

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

func (*DomainInterfaceSource) MarshalXML 

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

func (*DomainInterfaceSource) UnmarshalXML 

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

type DomainInterfaceSourceBridge 

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

type DomainInterfaceSourceClient 

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

type DomainInterfaceSourceDirect 

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

type DomainInterfaceSourceEthernet 

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

type DomainInterfaceSourceHostdev 

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

func (*DomainInterfaceSourceHostdev) MarshalXML 

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

func (*DomainInterfaceSourceHostdev) UnmarshalXML 

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

type DomainInterfaceSourceInternal 

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

type DomainInterfaceSourceLocal 

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

type DomainInterfaceSourceMCast 

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

type DomainInterfaceSourceNetwork 

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

type DomainInterfaceSourceNull added in v1.8007.0 

type DomainInterfaceSourceNull struct {
}

type DomainInterfaceSourcePortForward added in v1.9000.0 

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

type DomainInterfaceSourcePortForwardRange added in v1.9000.0 

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

type DomainInterfaceSourceServer 

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

type DomainInterfaceSourceUDP 

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

type DomainInterfaceSourceUser 

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

type DomainInterfaceSourceVDPA 

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

type DomainInterfaceSourceVDS added in v1.8007.0 

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

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:"-"`
	S390PV *DomainLaunchSecurityS390PV `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 DomainLaunchSecurityS390PV added in v1.7006.0 

type DomainLaunchSecurityS390PV struct {
}

type DomainLaunchSecuritySEV 

type DomainLaunchSecuritySEV struct {
	KernelHashes    string `xml:"kernelHashes,attr,omitempty"`
	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"`
	Stateless string `xml:"stateless,attr,omitempty"`
	Type      string `xml:"type,attr,omitempty"`
	Format    string `xml:"format,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"`
	PagePerVQ string `xml:"page_per_vq,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"`
	Threads uint   `xml:"threads,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:"address"`
}

func (*DomainMemorydev) Marshal 

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

func (*DomainMemorydev) Unmarshal 

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

type DomainMemorydevSource 

type DomainMemorydevSource struct {
	NodeMask  string                          `xml:"nodemask,omitempty"`
	PageSize  *DomainMemorydevSourcePagesize  `xml:"pagesize"`
	Path      string                          `xml:"path,omitempty"`
	AlignSize *DomainMemorydevSourceAlignsize `xml:"alignsize"`
	PMem      *DomainMemorydevSourcePMem      `xml:"pmem"`
}

type DomainMemorydevSourceAlignsize 

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

type DomainMemorydevSourcePMem 

type DomainMemorydevSourcePMem struct {
}

type DomainMemorydevSourcePagesize 

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

type DomainMemorydevTarget 

type DomainMemorydevTarget struct {
	DynamicMemslots string                          `xml:"dynamicMemslots,attr,omitempty"`
	Size            *DomainMemorydevTargetSize      `xml:"size"`
	Node            *DomainMemorydevTargetNode      `xml:"node"`
	Label           *DomainMemorydevTargetLabel     `xml:"label"`
	Block           *DomainMemorydevTargetBlock     `xml:"block"`
	Requested       *DomainMemorydevTargetRequested `xml:"requested"`
	ReadOnly        *DomainMemorydevTargetReadOnly  `xml:"readonly"`
	Address         *DomainMemorydevTargetAddress   `xml:"address"`
}

type DomainMemorydevTargetAddress added in v1.9004.0 

type DomainMemorydevTargetAddress struct {
	Base *uint `xml:"base,attr"`
}

func (*DomainMemorydevTargetAddress) MarshalXML added in v1.9004.0 

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

func (*DomainMemorydevTargetAddress) UnmarshalXML added in v1.9004.0 

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

type DomainMemorydevTargetBlock added in v1.7009.0 

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

type DomainMemorydevTargetLabel 

type DomainMemorydevTargetLabel struct {
	Size *DomainMemorydevTargetSize `xml:"size"`
}

type DomainMemorydevTargetNode 

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

type DomainMemorydevTargetReadOnly 

type DomainMemorydevTargetReadOnly struct {
}

type DomainMemorydevTargetRequested added in v1.7009.0 

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

type DomainMemorydevTargetSize 

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

type DomainMetadata 

type DomainMetadata struct {
	XML string `xml:",innerxml"`
}

type DomainNUMAInterconnectBandwidth 

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

type DomainNUMAInterconnectLatency 

type DomainNUMAInterconnectLatency struct {
	Initiator uint   `xml:"initiator,attr"`
	Target    uint   `xml:"target,attr"`
	Cache     uint   `xml:"cache,attr,omitempty"`
	Type      string `xml:"type,attr"`
	Value     uint   `xml:"value,attr"`
}

type DomainNUMAInterconnects 

type DomainNUMAInterconnects struct {
	Latencies  []DomainNUMAInterconnectLatency   `xml:"latency"`
	Bandwidths []DomainNUMAInterconnectBandwidth `xml:"bandwidth"`
}

type DomainNUMATune 

type DomainNUMATune struct {
	Memory   *DomainNUMATuneMemory   `xml:"memory"`
	MemNodes []DomainNUMATuneMemNode `xml:"memnode"`
}

type DomainNUMATuneMemNode 

type DomainNUMATuneMemNode struct {
	CellID  uint   `xml:"cellid,attr"`
	Mode    string `xml:"mode,attr"`
	Nodeset string `xml:"nodeset,attr"`
}

type DomainNUMATuneMemory 

type DomainNUMATuneMemory struct {
	Mode      string `xml:"mode,attr,omitempty"`
	Nodeset   string `xml:"nodeset,attr,omitempty"`
	Placement string `xml:"placement,attr,omitempty"`
}

type DomainNVRAM 

type DomainNVRAM struct {
	ACPI    *DomainDeviceACPI `xml:"acpi"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

type DomainNVRam 

type DomainNVRam struct {
	NVRam    string            `xml:",chardata"`
	Source   *DomainDiskSource `xml:"source"`
	Template string            `xml:"template,attr,omitempty"`
	Format   string            `xml:"format,attr,omitempty"`
}

func (*DomainNVRam) MarshalXML added in v1.8005.0 

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

func (*DomainNVRam) UnmarshalXML added in v1.8005.0 

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

type DomainNuma 

type DomainNuma struct {
	Cell          []DomainCell             `xml:"cell"`
	Interconnects *DomainNUMAInterconnects `xml:"interconnects"`
}

type DomainOS 

type DomainOS struct {
	Type         *DomainOSType         `xml:"type"`
	Firmware     string                `xml:"firmware,attr,omitempty"`
	FirmwareInfo *DomainOSFirmwareInfo `xml:"firmware"`
	Init         string                `xml:"init,omitempty"`
	InitArgs     []string              `xml:"initarg"`
	InitEnv      []DomainOSInitEnv     `xml:"initenv"`
	InitDir      string                `xml:"initdir,omitempty"`
	InitUser     string                `xml:"inituser,omitempty"`
	InitGroup    string                `xml:"initgroup,omitempty"`
	Loader       *DomainLoader         `xml:"loader"`
	NVRam        *DomainNVRam          `xml:"nvram"`
	Kernel       string                `xml:"kernel,omitempty"`
	Initrd       string                `xml:"initrd,omitempty"`
	Cmdline      string                `xml:"cmdline,omitempty"`
	DTB          string                `xml:"dtb,omitempty"`
	ACPI         *DomainACPI           `xml:"acpi"`
	BootDevices  []DomainBootDevice    `xml:"boot"`
	BootMenu     *DomainBootMenu       `xml:"bootmenu"`
	BIOS         *DomainBIOS           `xml:"bios"`
	SMBios       *DomainSMBios         `xml:"smbios"`
}

type DomainOSFirmwareFeature 

type DomainOSFirmwareFeature struct {
	Enabled string `xml:"enabled,attr,omitempty"`
	Name    string `xml:"name,attr,omitempty"`
}

type DomainOSFirmwareInfo 

type DomainOSFirmwareInfo struct {
	Features []DomainOSFirmwareFeature `xml:"feature"`
}

type DomainOSInitEnv 

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

type DomainOSType 

type DomainOSType struct {
	Arch    string `xml:"arch,attr,omitempty"`
	Machine string `xml:"machine,attr,omitempty"`
	Type    string `xml:",chardata"`
}

type DomainPM 

type DomainPM struct {
	SuspendToMem  *DomainPMPolicy `xml:"suspend-to-mem"`
	SuspendToDisk *DomainPMPolicy `xml:"suspend-to-disk"`
}

type DomainPMPolicy 

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

type DomainPanic 

type DomainPanic struct {
	XMLName xml.Name          `xml:"panic"`
	Model   string            `xml:"model,attr,omitempty"`
	ACPI    *DomainDeviceACPI `xml:"acpi"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

type DomainParallel 

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

func (*DomainParallel) Marshal 

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

func (*DomainParallel) MarshalXML 

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

func (*DomainParallel) Unmarshal 

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

func (*DomainParallel) UnmarshalXML 

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

type DomainParallelTarget 

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

type DomainPerf 

type DomainPerf struct {
	Events []DomainPerfEvent `xml:"event"`
}

type DomainPerfEvent 

type DomainPerfEvent struct {
	Name    string `xml:"name,attr"`
	Enabled string `xml:"enabled,attr"`
}

type DomainQEMUCapabilities 

type DomainQEMUCapabilities struct {
	XMLName xml.Name                      `xml:"http://libvirt.org/schemas/domain/qemu/1.0 capabilities"`
	Add     []DomainQEMUCapabilitiesEntry `xml:"add"`
	Del     []DomainQEMUCapabilitiesEntry `xml:"del"`
}

type DomainQEMUCapabilitiesEntry 

type DomainQEMUCapabilitiesEntry struct {
	Name string `xml:"capability,attr"`
}

type DomainQEMUCommandline 

type DomainQEMUCommandline struct {
	XMLName xml.Name                   `xml:"http://libvirt.org/schemas/domain/qemu/1.0 commandline"`
	Args    []DomainQEMUCommandlineArg `xml:"arg"`
	Envs    []DomainQEMUCommandlineEnv `xml:"env"`
}

type DomainQEMUCommandlineArg 

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

type DomainQEMUCommandlineEnv 

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

type DomainQEMUDeprecation 

type DomainQEMUDeprecation struct {
	XMLName  xml.Name `xml:"http://libvirt.org/schemas/domain/qemu/1.0 deprecation"`
	Behavior string   `xml:"behavior,attr,omitempty"`
}

type DomainQEMUOverride added in v1.8002.0 

type DomainQEMUOverride struct {
	XMLName xml.Name                   `xml:"http://libvirt.org/schemas/domain/qemu/1.0 override"`
	Devices []DomainQEMUOverrideDevice `xml:"device"`
}

type DomainQEMUOverrideDevice added in v1.8002.0 

type DomainQEMUOverrideDevice struct {
	Alias    string                     `xml:"alias,attr"`
	Frontend DomainQEMUOverrideFrontend `xml:"frontend"`
}

type DomainQEMUOverrideFrontend added in v1.8002.0 

type DomainQEMUOverrideFrontend struct {
	Properties []DomainQEMUOverrideProperty `xml:"property"`
}

type DomainQEMUOverrideProperty added in v1.8002.0 

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

type DomainRNG 

type DomainRNG struct {
	XMLName xml.Name          `xml:"rng"`
	Model   string            `xml:"model,attr"`
	Driver  *DomainRNGDriver  `xml:"driver"`
	Rate    *DomainRNGRate    `xml:"rate"`
	Backend *DomainRNGBackend `xml:"backend"`
	ACPI    *DomainDeviceACPI `xml:"acpi"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

func (*DomainRNG) Marshal 

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

func (*DomainRNG) Unmarshal 

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

type DomainRNGBackend 

type DomainRNGBackend struct {
	Random  *DomainRNGBackendRandom  `xml:"-"`
	EGD     *DomainRNGBackendEGD     `xml:"-"`
	BuiltIn *DomainRNGBackendBuiltIn `xml:"-"`
}

func (*DomainRNGBackend) MarshalXML 

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

func (*DomainRNGBackend) UnmarshalXML 

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

type DomainRNGBackendBuiltIn 

type DomainRNGBackendBuiltIn struct {
}

type DomainRNGBackendEGD 

type DomainRNGBackendEGD struct {
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
}

func (*DomainRNGBackendEGD) MarshalXML 

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

func (*DomainRNGBackendEGD) UnmarshalXML 

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

type DomainRNGBackendRandom 

type DomainRNGBackendRandom struct {
	Device string `xml:",chardata"`
}

type DomainRNGDriver 

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

type DomainRNGRate 

type DomainRNGRate struct {
	Bytes  uint `xml:"bytes,attr"`
	Period uint `xml:"period,attr,omitempty"`
}

type DomainROM 

type DomainROM struct {
	Bar     string  `xml:"bar,attr,omitempty"`
	File    *string `xml:"file,attr"`
	Enabled string  `xml:"enabled,attr,omitempty"`
}

type DomainRedirDev 

type DomainRedirDev struct {
	XMLName  xml.Name               `xml:"redirdev"`
	Bus      string                 `xml:"bus,attr,omitempty"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Boot     *DomainDeviceBoot      `xml:"boot"`
	ACPI     *DomainDeviceACPI      `xml:"acpi"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

func (*DomainRedirDev) Marshal 

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

func (*DomainRedirDev) MarshalXML 

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

func (*DomainRedirDev) Unmarshal 

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

func (*DomainRedirDev) UnmarshalXML 

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

type DomainRedirFilter 

type DomainRedirFilter struct {
	USB []DomainRedirFilterUSB `xml:"usbdev"`
}

type DomainRedirFilterUSB 

type DomainRedirFilterUSB struct {
	Class   *uint  `xml:"class,attr"`
	Vendor  *uint  `xml:"vendor,attr"`
	Product *uint  `xml:"product,attr"`
	Version string `xml:"version,attr,omitempty"`
	Allow   string `xml:"allow,attr"`
}

func (*DomainRedirFilterUSB) MarshalXML 

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

func (*DomainRedirFilterUSB) UnmarshalXML 

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

type DomainResource 

type DomainResource struct {
	Partition    string                      `xml:"partition,omitempty"`
	FibreChannel *DomainResourceFibreChannel `xml:"fibrechannel"`
}

type DomainResourceFibreChannel added in v1.7007.0 

type DomainResourceFibreChannel struct {
	AppID string `xml:"appid,attr"`
}

type DomainRoute 

type DomainRoute struct {
	Family  string `xml:"family,attr,omitempty"`
	Address string `xml:"address,attr,omitempty"`
	Gateway string `xml:"gateway,attr,omitempty"`
}

type DomainSMBios 

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

type DomainSecLabel 

type DomainSecLabel struct {
	Type       string `xml:"type,attr,omitempty"`
	Model      string `xml:"model,attr,omitempty"`
	Relabel    string `xml:"relabel,attr,omitempty"`
	Label      string `xml:"label,omitempty"`
	ImageLabel string `xml:"imagelabel,omitempty"`
	BaseLabel  string `xml:"baselabel,omitempty"`
}

type DomainSerial 

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

func (*DomainSerial) Marshal 

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

func (*DomainSerial) MarshalXML 

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

func (*DomainSerial) Unmarshal 

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

func (*DomainSerial) UnmarshalXML 

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

type DomainSerialTarget 

type DomainSerialTarget struct {
	Type  string                   `xml:"type,attr,omitempty"`
	Port  *uint                    `xml:"port,attr"`
	Model *DomainSerialTargetModel `xml:"model"`
}

type DomainSerialTargetModel 

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

type DomainShmem 

type DomainShmem struct {
	XMLName xml.Name           `xml:"shmem"`
	Name    string             `xml:"name,attr"`
	Role    string             `xml:"role,attr,omitempty"`
	Size    *DomainShmemSize   `xml:"size"`
	Model   *DomainShmemModel  `xml:"model"`
	Server  *DomainShmemServer `xml:"server"`
	MSI     *DomainShmemMSI    `xml:"msi"`
	ACPI    *DomainDeviceACPI  `xml:"acpi"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

func (*DomainShmem) Marshal 

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

func (*DomainShmem) Unmarshal 

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

type DomainShmemMSI 

type DomainShmemMSI struct {
	Enabled   string `xml:"enabled,attr,omitempty"`
	Vectors   uint   `xml:"vectors,attr,omitempty"`
	IOEventFD string `xml:"ioeventfd,attr,omitempty"`
}

type DomainShmemModel 

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

type DomainShmemServer 

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

type DomainShmemSize 

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

type DomainSmartcard 

type DomainSmartcard struct {
	XMLName     xml.Name                  `xml:"smartcard"`
	Passthrough *DomainChardevSource      `xml:"source"`
	Protocol    *DomainChardevProtocol    `xml:"protocol"`
	Host        *DomainSmartcardHost      `xml:"-"`
	HostCerts   []DomainSmartcardHostCert `xml:"certificate"`
	Database    string                    `xml:"database,omitempty"`
	ACPI        *DomainDeviceACPI         `xml:"acpi"`
	Alias       *DomainAlias              `xml:"alias"`
	Address     *DomainAddress            `xml:"address"`
}

func (*DomainSmartcard) Marshal 

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

func (*DomainSmartcard) MarshalXML 

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

func (*DomainSmartcard) Unmarshal 

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

func (*DomainSmartcard) UnmarshalXML 

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

type DomainSmartcardHost 

type DomainSmartcardHost struct {
}

type DomainSmartcardHostCert 

type DomainSmartcardHostCert struct {
	File string `xml:",chardata"`
}

type DomainSnapshot 

type DomainSnapshot struct {
	XMLName        xml.Name                      `xml:"domainsnapshot"`
	Name           string                        `xml:"name,omitempty"`
	Description    string                        `xml:"description,omitempty"`
	State          string                        `xml:"state,omitempty"`
	CreationTime   string                        `xml:"creationTime,omitempty"`
	Parent         *DomainSnapshotParent         `xml:"parent"`
	Memory         *DomainSnapshotMemory         `xml:"memory"`
	Disks          *DomainSnapshotDisks          `xml:"disks"`
	Domain         *Domain                       `xml:"domain"`
	InactiveDomain *DomainSnapshotInactiveDomain `xml:"inactiveDomain"`
	Active         *uint                         `xml:"active"`
	Cookie         *DomainSnapshotCookie         `xml:"cookie"`
}

func (*DomainSnapshot) Marshal 

func (s *DomainSnapshot) Marshal() (string, error)

func (*DomainSnapshot) Unmarshal 

func (s *DomainSnapshot) Unmarshal(doc string) error

type DomainSnapshotCookie added in v1.8008.0 

type DomainSnapshotCookie struct {
	XML string `xml:",innerxml"`
}

type DomainSnapshotDisk 

type DomainSnapshotDisk struct {
	Name     string            `xml:"name,attr"`
	Snapshot string            `xml:"snapshot,attr,omitempty"`
	Driver   *DomainDiskDriver `xml:"driver"`
	Source   *DomainDiskSource `xml:"source"`
}

func (*DomainSnapshotDisk) MarshalXML 

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

func (*DomainSnapshotDisk) UnmarshalXML 

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

type DomainSnapshotDisks 

type DomainSnapshotDisks struct {
	Disks []DomainSnapshotDisk `xml:"disk"`
}

type DomainSnapshotInactiveDomain added in v1.8008.0 

type DomainSnapshotInactiveDomain struct {
	XMLName xml.Name `xml:"inactiveDomain"`
	Domain
}

type DomainSnapshotMemory 

type DomainSnapshotMemory struct {
	Snapshot string `xml:"snapshot,attr"`
	File     string `xml:"file,attr,omitempty"`
}

type DomainSnapshotParent 

type DomainSnapshotParent struct {
	Name string `xml:"name"`
}

type DomainSound 

type DomainSound struct {
	XMLName      xml.Name           `xml:"sound"`
	Model        string             `xml:"model,attr"`
	MultiChannel string             `xml:"multichannel,attr,omitempty"`
	Codec        []DomainSoundCodec `xml:"codec"`
	Audio        *DomainSoundAudio  `xml:"audio"`
	ACPI         *DomainDeviceACPI  `xml:"acpi"`
	Alias        *DomainAlias       `xml:"alias"`
	Address      *DomainAddress     `xml:"address"`
}

func (*DomainSound) Marshal 

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

func (*DomainSound) Unmarshal 

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

type DomainSoundAudio 

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

type DomainSoundCodec 

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

type DomainSysInfo 

type DomainSysInfo struct {
	SMBIOS *DomainSysInfoSMBIOS `xml:"-"`
	FWCfg  *DomainSysInfoFWCfg  `xml:"-"`
}

func (*DomainSysInfo) MarshalXML 

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

func (*DomainSysInfo) UnmarshalXML 

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

type DomainSysInfoBIOS 

type DomainSysInfoBIOS struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoBaseBoard 

type DomainSysInfoBaseBoard struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoChassis 

type DomainSysInfoChassis struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoEntry 

type DomainSysInfoEntry struct {
	Name  string `xml:"name,attr"`
	File  string `xml:"file,attr,omitempty"`
	Value string `xml:",chardata"`
}

type DomainSysInfoFWCfg 

type DomainSysInfoFWCfg struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoMemory 

type DomainSysInfoMemory struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoOEMStrings 

type DomainSysInfoOEMStrings struct {
	Entry []string `xml:"entry"`
}

type DomainSysInfoProcessor 

type DomainSysInfoProcessor struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoSMBIOS 

type DomainSysInfoSMBIOS struct {
	BIOS       *DomainSysInfoBIOS       `xml:"bios"`
	System     *DomainSysInfoSystem     `xml:"system"`
	BaseBoard  []DomainSysInfoBaseBoard `xml:"baseBoard"`
	Chassis    *DomainSysInfoChassis    `xml:"chassis"`
	Processor  []DomainSysInfoProcessor `xml:"processor"`
	Memory     []DomainSysInfoMemory    `xml:"memory"`
	OEMStrings *DomainSysInfoOEMStrings `xml:"oemStrings"`
}

type DomainSysInfoSystem 

type DomainSysInfoSystem struct {
	Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainTPM 

type DomainTPM struct {
	XMLName xml.Name          `xml:"tpm"`
	Model   string            `xml:"model,attr,omitempty"`
	Backend *DomainTPMBackend `xml:"backend"`
	ACPI    *DomainDeviceACPI `xml:"acpi"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

func (*DomainTPM) Marshal 

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

func (*DomainTPM) Unmarshal 

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

type DomainTPMBackend 

type DomainTPMBackend struct {
	Passthrough *DomainTPMBackendPassthrough `xml:"-"`
	Emulator    *DomainTPMBackendEmulator    `xml:"-"`
	External    *DomainTPMBackendExternal    `xml:"-"`
}

func (*DomainTPMBackend) MarshalXML 

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

func (*DomainTPMBackend) UnmarshalXML 

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

type DomainTPMBackendDevice 

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

type DomainTPMBackendEmulator 

type DomainTPMBackendEmulator struct {
	Version         string                      `xml:"version,attr,omitempty"`
	Encryption      *DomainTPMBackendEncryption `xml:"encryption"`
	PersistentState string                      `xml:"persistent_state,attr,omitempty"`
	ActivePCRBanks  *DomainTPMBackendPCRBanks   `xml:"active_pcr_banks"`
}

type DomainTPMBackendEncryption 

type DomainTPMBackendEncryption struct {
	Secret string `xml:"secret,attr"`
}

type DomainTPMBackendExternal added in v1.9000.0 

type DomainTPMBackendExternal struct {
	Source *DomainTPMBackendExternalSource `xml:"source"`
}

type DomainTPMBackendExternalSource added in v1.9000.0 

type DomainTPMBackendExternalSource DomainChardevSource

func (*DomainTPMBackendExternalSource) MarshalXML added in v1.9000.0 

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

func (*DomainTPMBackendExternalSource) UnmarshalXML added in v1.9000.0 

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

type DomainTPMBackendPCRBank added in v1.7010.0 

type DomainTPMBackendPCRBank struct {
}

type DomainTPMBackendPCRBanks added in v1.7010.0 

type DomainTPMBackendPCRBanks struct {
	SHA1   *DomainTPMBackendPCRBank `xml:"sha1"`
	SHA256 *DomainTPMBackendPCRBank `xml:"sha256"`
	SHA384 *DomainTPMBackendPCRBank `xml:"sha384"`
	SHA512 *DomainTPMBackendPCRBank `xml:"sha512"`
}

type DomainTPMBackendPassthrough 

type DomainTPMBackendPassthrough struct {
	Device *DomainTPMBackendDevice `xml:"device"`
}

type DomainTimer 

type DomainTimer struct {
	Name       string              `xml:"name,attr"`
	Track      string              `xml:"track,attr,omitempty"`
	TickPolicy string              `xml:"tickpolicy,attr,omitempty"`
	CatchUp    *DomainTimerCatchUp `xml:"catchup"`
	Frequency  uint64              `xml:"frequency,attr,omitempty"`
	Mode       string              `xml:"mode,attr,omitempty"`
	Present    string              `xml:"present,attr,omitempty"`
}

type DomainTimerCatchUp 

type DomainTimerCatchUp struct {
	Threshold uint `xml:"threshold,attr,omitempty"`
	Slew      uint `xml:"slew,attr,omitempty"`
	Limit     uint `xml:"limit,attr,omitempty"`
}

type DomainVCPU 

type DomainVCPU struct {
	Placement string `xml:"placement,attr,omitempty"`
	CPUSet    string `xml:"cpuset,attr,omitempty"`
	Current   uint   `xml:"current,attr,omitempty"`
	Value     uint   `xml:",chardata"`
}

type DomainVCPUs 

type DomainVCPUs struct {
	VCPU []DomainVCPUsVCPU `xml:"vcpu"`
}

type DomainVCPUsVCPU 

type DomainVCPUsVCPU struct {
	Id           *uint  `xml:"id,attr"`
	Enabled      string `xml:"enabled,attr,omitempty"`
	Hotpluggable string `xml:"hotpluggable,attr,omitempty"`
	Order        *uint  `xml:"order,attr"`
}

type DomainVMWareDataCenterPath 

type DomainVMWareDataCenterPath struct {
	XMLName xml.Name `xml:"http://libvirt.org/schemas/domain/vmware/1.0 datacenterpath"`
	Value   string   `xml:",chardata"`
}

type DomainVSock 

type DomainVSock struct {
	XMLName xml.Name           `xml:"vsock"`
	Model   string             `xml:"model,attr,omitempty"`
	CID     *DomainVSockCID    `xml:"cid"`
	Driver  *DomainVSockDriver `xml:"driver"`
	ACPI    *DomainDeviceACPI  `xml:"acpi"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

func (*DomainVSock) Marshal 

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

func (*DomainVSock) Unmarshal 

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

type DomainVSockCID 

type DomainVSockCID struct {
	Auto    string `xml:"auto,attr,omitempty"`
	Address string `xml:"address,attr,omitempty"`
}

type DomainVSockDriver 

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

type DomainVideo 

type DomainVideo struct {
	XMLName xml.Name           `xml:"video"`
	Model   DomainVideoModel   `xml:"model"`
	Driver  *DomainVideoDriver `xml:"driver"`
	ACPI    *DomainDeviceACPI  `xml:"acpi"`
	Alias   *DomainAlias       `xml:"alias"`
	Address *DomainAddress     `xml:"address"`
}

func (*DomainVideo) Marshal 

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

func (*DomainVideo) Unmarshal 

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

type DomainVideoAccel 

type DomainVideoAccel struct {
	Accel3D    string `xml:"accel3d,attr,omitempty"`
	Accel2D    string `xml:"accel2d,attr,omitempty"`
	RenderNode string `xml:"rendernode,attr,omitempty"`
}

type DomainVideoDriver 

type DomainVideoDriver struct {
	Name      string `xml:"name,attr,omitempty"`
	VGAConf   string `xml:"vgaconf,attr,omitempty"`
	IOMMU     string `xml:"iommu,attr,omitempty"`
	ATS       string `xml:"ats,attr,omitempty"`
	Packed    string `xml:"packed,attr,omitempty"`
	PagePerVQ string `xml:"page_per_vq,attr,omitempty"`
}

type DomainVideoModel 

type DomainVideoModel struct {
	Type       string                 `xml:"type,attr"`
	Heads      uint                   `xml:"heads,attr,omitempty"`
	Ram        uint                   `xml:"ram,attr,omitempty"`
	VRam       uint                   `xml:"vram,attr,omitempty"`
	VRam64     uint                   `xml:"vram64,attr,omitempty"`
	VGAMem     uint                   `xml:"vgamem,attr,omitempty"`
	Primary    string                 `xml:"primary,attr,omitempty"`
	Blob       string                 `xml:"blob,attr,omitempty"`
	Accel      *DomainVideoAccel      `xml:"acceleration"`
	Resolution *DomainVideoResolution `xml:"resolution"`
}

type DomainVideoResolution 

type DomainVideoResolution struct {
	X uint `xml:"x,attr"`
	Y uint `xml:"y,attr"`
}

type DomainWatchdog 

type DomainWatchdog struct {
	XMLName xml.Name          `xml:"watchdog"`
	Model   string            `xml:"model,attr"`
	Action  string            `xml:"action,attr,omitempty"`
	ACPI    *DomainDeviceACPI `xml:"acpi"`
	Alias   *DomainAlias      `xml:"alias"`
	Address *DomainAddress    `xml:"address"`
}

func (*DomainWatchdog) Marshal 

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

func (*DomainWatchdog) Unmarshal 

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

type DomainXenCommandline 

type DomainXenCommandline struct {
	XMLName xml.Name                  `xml:"http://libvirt.org/schemas/domain/xen/1.0 commandline"`
	Args    []DomainXenCommandlineArg `xml:"arg"`
}

type DomainXenCommandlineArg 

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

type Interface 

type Interface struct {
	XMLName  xml.Name            `xml:"interface"`
	Name     string              `xml:"name,attr,omitempty"`
	Start    *InterfaceStart     `xml:"start"`
	MTU      *InterfaceMTU       `xml:"mtu"`
	Protocol []InterfaceProtocol `xml:"protocol"`
	Link     *InterfaceLink      `xml:"link"`
	MAC      *InterfaceMAC       `xml:"mac"`
	Bond     *InterfaceBond      `xml:"bond"`
	Bridge   *InterfaceBridge    `xml:"bridge"`
	VLAN     *InterfaceVLAN      `xml:"vlan"`
}

func (*Interface) Marshal 

func (s *Interface) Marshal() (string, error)

func (*Interface) MarshalXML 

func (s *Interface) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Interface) Unmarshal 

func (s *Interface) Unmarshal(doc string) error

type InterfaceAutoConf 

type InterfaceAutoConf struct {
}

type InterfaceBond 

type InterfaceBond struct {
	Mode       string               `xml:"mode,attr,omitempty"`
	ARPMon     *InterfaceBondARPMon `xml:"arpmon"`
	MIIMon     *InterfaceBondMIIMon `xml:"miimon"`
	Interfaces []Interface          `xml:"interface"`
}

type InterfaceBondARPMon 

type InterfaceBondARPMon struct {
	Interval uint   `xml:"interval,attr,omitempty"`
	Target   string `xml:"target,attr,omitempty"`
	Validate string `xml:"validate,attr,omitempty"`
}

type InterfaceBondMIIMon 

type InterfaceBondMIIMon struct {
	Freq    uint   `xml:"freq,attr,omitempty"`
	UpDelay uint   `xml:"updelay,attr,omitempty"`
	Carrier string `xml:"carrier,attr,omitempty"`
}

type InterfaceBridge 

type InterfaceBridge struct {
	STP        string      `xml:"stp,attr,omitempty"`
	Delay      *float64    `xml:"delay,attr"`
	Interfaces []Interface `xml:"interface"`
}

type InterfaceDHCP 

type InterfaceDHCP struct {
	PeerDNS string `xml:"peerdns,attr,omitempty"`
}

type InterfaceIP 

type InterfaceIP struct {
	Address string `xml:"address,attr"`
	Prefix  uint   `xml:"prefix,attr,omitempty"`
}
type InterfaceLink struct {
	Speed uint   `xml:"speed,attr,omitempty"`
	State string `xml:"state,attr,omitempty"`
}

type InterfaceMAC 

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

type InterfaceMTU 

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

type InterfaceProtocol 

type InterfaceProtocol struct {
	Family   string             `xml:"family,attr,omitempty"`
	AutoConf *InterfaceAutoConf `xml:"autoconf"`
	DHCP     *InterfaceDHCP     `xml:"dhcp"`
	IPs      []InterfaceIP      `xml:"ip"`
	Route    []InterfaceRoute   `xml:"route"`
}

type InterfaceRoute 

type InterfaceRoute struct {
	Gateway string `xml:"gateway,attr"`
}

type InterfaceStart 

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

type InterfaceVLAN 

type InterfaceVLAN struct {
	Tag       *uint      `xml:"tag,attr"`
	Interface *Interface `xml:"interface"`
}

type NWFilter 

type NWFilter struct {
	XMLName  xml.Name `xml:"filter"`
	Name     string   `xml:"name,attr"`
	UUID     string   `xml:"uuid,omitempty"`
	Chain    string   `xml:"chain,attr,omitempty"`
	Priority int      `xml:"priority,attr,omitempty"`
	Entries  []NWFilterEntry
}

func (*NWFilter) Marshal 

func (s *NWFilter) Marshal() (string, error)

func (*NWFilter) MarshalXML 

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

func (*NWFilter) Unmarshal 

func (s *NWFilter) Unmarshal(doc string) error

func (*NWFilter) UnmarshalXML 

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

type NWFilterBinding 

type NWFilterBinding struct {
	XMLName   xml.Name                  `xml:"filterbinding"`
	Owner     *NWFilterBindingOwner     `xml:"owner"`
	PortDev   *NWFilterBindingPortDev   `xml:"portdev"`
	MAC       *NWFilterBindingMAC       `xml:"mac"`
	FilterRef *NWFilterBindingFilterRef `xml:"filterref"`
}

func (*NWFilterBinding) Marshal 

func (s *NWFilterBinding) Marshal() (string, error)

func (*NWFilterBinding) Unmarshal 

func (s *NWFilterBinding) Unmarshal(doc string) error

type NWFilterBindingFilterParam 

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

type NWFilterBindingFilterRef 

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

type NWFilterBindingMAC 

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

type NWFilterBindingOwner 

type NWFilterBindingOwner struct {
	UUID string `xml:"uuid,omitempty"`
	Name string `xml:"name,omitempty"`
}

type NWFilterBindingPortDev 

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

type NWFilterEntry 

type NWFilterEntry struct {
	Rule *NWFilterRule
	Ref  *NWFilterRef
}

type NWFilterField 

type NWFilterField struct {
	Var  string
	Str  string
	Uint *uint
}

func (*NWFilterField) MarshalXMLAttr 

func (s *NWFilterField) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (*NWFilterField) UnmarshalXMLAttr 

func (s *NWFilterField) UnmarshalXMLAttr(attr xml.Attr) error

type NWFilterParameter 

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

type NWFilterRef 

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

type NWFilterRule 

type NWFilterRule struct {
	Action     string `xml:"action,attr,omitempty"`
	Direction  string `xml:"direction,attr,omitempty"`
	Priority   int    `xml:"priority,attr,omitempty"`
	StateMatch string `xml:"statematch,attr,omitempty"`

	ARP         *NWFilterRuleARP         `xml:"arp"`
	RARP        *NWFilterRuleRARP        `xml:"rarp"`
	MAC         *NWFilterRuleMAC         `xml:"mac"`
	VLAN        *NWFilterRuleVLAN        `xml:"vlan"`
	STP         *NWFilterRuleSTP         `xml:"stp"`
	IP          *NWFilterRuleIP          `xml:"ip"`
	IPv6        *NWFilterRuleIPv6        `xml:"ipv6"`
	TCP         *NWFilterRuleTCP         `xml:"tcp"`
	UDP         *NWFilterRuleUDP         `xml:"udp"`
	UDPLite     *NWFilterRuleUDPLite     `xml:"udplite"`
	ESP         *NWFilterRuleESP         `xml:"esp"`
	AH          *NWFilterRuleAH          `xml:"ah"`
	SCTP        *NWFilterRuleSCTP        `xml:"sctp"`
	ICMP        *NWFilterRuleICMP        `xml:"icmp"`
	All         *NWFilterRuleAll         `xml:"all"`
	IGMP        *NWFilterRuleIGMP        `xml:"igmp"`
	TCPIPv6     *NWFilterRuleTCPIPv6     `xml:"tcp-ipv6"`
	UDPIPv6     *NWFilterRuleUDPIPv6     `xml:"udp-ipv6"`
	UDPLiteIPv6 *NWFilterRuleUDPLiteIPv6 `xml:"udplite-ipv6"`
	ESPIPv6     *NWFilterRuleESPIPv6     `xml:"esp-ipv6"`
	AHIPv6      *NWFilterRuleAHIPv6      `xml:"ah-ipv6"`
	SCTPIPv6    *NWFilterRuleSCTPIPv6    `xml:"sctp-ipv6"`
	ICMPv6      *NWFilterRuleICMPIPv6    `xml:"icmpv6"`
	AllIPv6     *NWFilterRuleAllIPv6     `xml:"all-ipv6"`
}

type NWFilterRuleAH 

type NWFilterRuleAH struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleAHIPv6 

type NWFilterRuleAHIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleARP 

type NWFilterRuleARP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	HWType        NWFilterField `xml:"hwtype,attr"`
	ProtocolType  NWFilterField `xml:"protocoltype,attr"`
	OpCode        NWFilterField `xml:"opcode,attr,omitempty"`
	ARPSrcMACAddr NWFilterField `xml:"arpsrcmacaddr,attr,omitempty"`
	ARPDstMACAddr NWFilterField `xml:"arpdstmacaddr,attr,omitempty"`
	ARPSrcIPAddr  NWFilterField `xml:"arpsrcipaddr,attr,omitempty"`
	ARPSrcIPMask  NWFilterField `xml:"arpsrcipmask,attr,omitempty"`
	ARPDstIPAddr  NWFilterField `xml:"arpdstipaddr,attr,omitempty"`
	ARPDstIPMask  NWFilterField `xml:"arpdstipmask,attr,omitempty"`
	Gratuitous    NWFilterField `xml:"gratuitous,attr,omitempty"`
	Comment       string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleAll 

type NWFilterRuleAll struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleAllIPv6 

type NWFilterRuleAllIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleCommonIP 

type NWFilterRuleCommonIP struct {
	SrcMACAddr     NWFilterField `xml:"srcmacaddr,attr,omitempty"`
	SrcIPAddr      NWFilterField `xml:"srcipaddr,attr,omitempty"`
	SrcIPMask      NWFilterField `xml:"srcipmask,attr,omitempty"`
	DstIPAddr      NWFilterField `xml:"dstipaddr,attr,omitempty"`
	DstIPMask      NWFilterField `xml:"dstipmask,attr,omitempty"`
	SrcIPFrom      NWFilterField `xml:"srcipfrom,attr,omitempty"`
	SrcIPTo        NWFilterField `xml:"srcipto,attr,omitempty"`
	DstIPFrom      NWFilterField `xml:"dstipfrom,attr,omitempty"`
	DstIPTo        NWFilterField `xml:"dstipto,attr,omitempty"`
	DSCP           NWFilterField `xml:"dscp,attr"`
	ConnLimitAbove NWFilterField `xml:"connlimit-above,attr"`
	State          NWFilterField `xml:"state,attr,omitempty"`
	IPSet          NWFilterField `xml:"ipset,attr,omitempty"`
	IPSetFlags     NWFilterField `xml:"ipsetflags,attr,omitempty"`
}

type NWFilterRuleCommonMAC 

type NWFilterRuleCommonMAC struct {
	SrcMACAddr NWFilterField `xml:"srcmacaddr,attr,omitempty"`
	SrcMACMask NWFilterField `xml:"srcmacmask,attr,omitempty"`
	DstMACAddr NWFilterField `xml:"dstmacaddr,attr,omitempty"`
	DstMACMask NWFilterField `xml:"dstmacmask,attr,omitempty"`
}

type NWFilterRuleCommonPort 

type NWFilterRuleCommonPort struct {
	SrcPortStart NWFilterField `xml:"srcportstart,attr"`
	SrcPortEnd   NWFilterField `xml:"srcportend,attr"`
	DstPortStart NWFilterField `xml:"dstportstart,attr"`
	DstPortEnd   NWFilterField `xml:"dstportend,attr"`
}

type NWFilterRuleESP 

type NWFilterRuleESP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleESPIPv6 

type NWFilterRuleESPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleICMP 

type NWFilterRuleICMP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Type    NWFilterField `xml:"type,attr"`
	Code    NWFilterField `xml:"code,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleICMPIPv6 

type NWFilterRuleICMPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Type    NWFilterField `xml:"type,attr"`
	Code    NWFilterField `xml:"code,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleIGMP 

type NWFilterRuleIGMP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleIP 

type NWFilterRuleIP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	SrcIPAddr NWFilterField `xml:"srcipaddr,attr,omitempty"`
	SrcIPMask NWFilterField `xml:"srcipmask,attr,omitempty"`
	DstIPAddr NWFilterField `xml:"dstipaddr,attr,omitempty"`
	DstIPMask NWFilterField `xml:"dstipmask,attr,omitempty"`
	Protocol  NWFilterField `xml:"protocol,attr,omitempty"`
	NWFilterRuleCommonPort
	DSCP    NWFilterField `xml:"dscp,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleIPv6 

type NWFilterRuleIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	SrcIPAddr NWFilterField `xml:"srcipaddr,attr,omitempty"`
	SrcIPMask NWFilterField `xml:"srcipmask,attr,omitempty"`
	DstIPAddr NWFilterField `xml:"dstipaddr,attr,omitempty"`
	DstIPMask NWFilterField `xml:"dstipmask,attr,omitempty"`
	Protocol  NWFilterField `xml:"protocol,attr,omitempty"`
	NWFilterRuleCommonPort
	Type    NWFilterField `xml:"type,attr"`
	TypeEnd NWFilterField `xml:"typeend,attr"`
	Code    NWFilterField `xml:"code,attr"`
	CodeEnd NWFilterField `xml:"codeend,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleMAC 

type NWFilterRuleMAC struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	ProtocolID NWFilterField `xml:"protocolid,attr,omitempty"`
	Comment    string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleRARP 

type NWFilterRuleRARP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	HWType        NWFilterField `xml:"hwtype,attr"`
	ProtocolType  NWFilterField `xml:"protocoltype,attr"`
	OpCode        NWFilterField `xml:"opcode,attr,omitempty"`
	ARPSrcMACAddr NWFilterField `xml:"arpsrcmacaddr,attr,omitempty"`
	ARPDstMACAddr NWFilterField `xml:"arpdstmacaddr,attr,omitempty"`
	ARPSrcIPAddr  NWFilterField `xml:"arpsrcipaddr,attr,omitempty"`
	ARPSrcIPMask  NWFilterField `xml:"arpsrcipmask,attr,omitempty"`
	ARPDstIPAddr  NWFilterField `xml:"arpdstipaddr,attr,omitempty"`
	ARPDstIPMask  NWFilterField `xml:"arpdstipmask,attr,omitempty"`
	Gratuitous    NWFilterField `xml:"gratuitous,attr,omitempty"`
	Comment       string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleSCTP 

type NWFilterRuleSCTP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	NWFilterRuleCommonPort
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleSCTPIPv6 

type NWFilterRuleSCTPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	NWFilterRuleCommonPort
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleSTP 

type NWFilterRuleSTP struct {
	Match             NWFilterField `xml:"match,attr,omitempty"`
	SrcMACAddr        NWFilterField `xml:"srcmacaddr,attr,omitempty"`
	SrcMACMask        NWFilterField `xml:"srcmacmask,attr,omitempty"`
	Type              NWFilterField `xml:"type,attr"`
	Flags             NWFilterField `xml:"flags,attr"`
	RootPriority      NWFilterField `xml:"root-priority,attr"`
	RootPriorityHi    NWFilterField `xml:"root-priority-hi,attr"`
	RootAddress       NWFilterField `xml:"root-address,attr,omitempty"`
	RootAddressMask   NWFilterField `xml:"root-address-mask,attr,omitempty"`
	RootCost          NWFilterField `xml:"root-cost,attr"`
	RootCostHi        NWFilterField `xml:"root-cost-hi,attr"`
	SenderPriority    NWFilterField `xml:"sender-priority,attr"`
	SenderPriorityHi  NWFilterField `xml:"sender-priority-hi,attr"`
	SenderAddress     NWFilterField `xml:"sender-address,attr,omitempty"`
	SenderAddressMask NWFilterField `xml:"sender-address-mask,attr,omitempty"`
	Port              NWFilterField `xml:"port,attr"`
	PortHi            NWFilterField `xml:"port-hi,attr"`
	Age               NWFilterField `xml:"age,attr"`
	AgeHi             NWFilterField `xml:"age-hi,attr"`
	MaxAge            NWFilterField `xml:"max-age,attr"`
	MaxAgeHi          NWFilterField `xml:"max-age-hi,attr"`
	HelloTime         NWFilterField `xml:"hello-time,attr"`
	HelloTimeHi       NWFilterField `xml:"hello-time-hi,attr"`
	ForwardDelay      NWFilterField `xml:"forward-delay,attr"`
	ForwardDelayHi    NWFilterField `xml:"forward-delay-hi,attr"`
	Comment           string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleTCP 

type NWFilterRuleTCP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	NWFilterRuleCommonPort
	Option  NWFilterField `xml:"option,attr"`
	Flags   NWFilterField `xml:"flags,attr,omitempty"`
	Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleTCPIPv6 

type NWFilterRuleTCPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	NWFilterRuleCommonPort
	Option  NWFilterField `xml:"option,attr"`
	Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDP 

type NWFilterRuleUDP struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	NWFilterRuleCommonPort
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDPIPv6 

type NWFilterRuleUDPIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	NWFilterRuleCommonPort
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDPLite 

type NWFilterRuleUDPLite struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDPLiteIPv6 

type NWFilterRuleUDPLiteIPv6 struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonIP
	Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleVLAN 

type NWFilterRuleVLAN struct {
	Match string `xml:"match,attr,omitempty"`
	NWFilterRuleCommonMAC
	VLANID        NWFilterField `xml:"vlanid,attr,omitempty"`
	EncapProtocol NWFilterField `xml:"encap-protocol,attr,omitempty"`
	Comment       string        `xml:"comment,attr,omitempty"`
}

type Network 

type Network struct {
	XMLName             xml.Name            `xml:"network"`
	IPv6                string              `xml:"ipv6,attr,omitempty"`
	TrustGuestRxFilters string              `xml:"trustGuestRxFilters,attr,omitempty"`
	Name                string              `xml:"name,omitempty"`
	UUID                string              `xml:"uuid,omitempty"`
	Metadata            *NetworkMetadata    `xml:"metadata"`
	Forward             *NetworkForward     `xml:"forward"`
	Bridge              *NetworkBridge      `xml:"bridge"`
	MTU                 *NetworkMTU         `xml:"mtu"`
	MAC                 *NetworkMAC         `xml:"mac"`
	Domain              *NetworkDomain      `xml:"domain"`
	DNS                 *NetworkDNS         `xml:"dns"`
	VLAN                *NetworkVLAN        `xml:"vlan"`
	Bandwidth           *NetworkBandwidth   `xml:"bandwidth"`
	PortOptions         *NetworkPortOptions `xml:"port"`
	IPs                 []NetworkIP         `xml:"ip"`
	Routes              []NetworkRoute      `xml:"route"`
	VirtualPort         *NetworkVirtualPort `xml:"virtualport"`
	PortGroups          []NetworkPortGroup  `xml:"portgroup"`

	DnsmasqOptions *NetworkDnsmasqOptions
}

func (*Network) Marshal 

func (s *Network) Marshal() (string, error)

func (*Network) Unmarshal 

func (s *Network) Unmarshal(doc string) error

type NetworkBandwidth 

type NetworkBandwidth struct {
	ClassID  uint                    `xml:"classID,attr,omitempty"`
	Inbound  *NetworkBandwidthParams `xml:"inbound"`
	Outbound *NetworkBandwidthParams `xml:"outbound"`
}

type NetworkBandwidthParams 

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

type NetworkBootp 

type NetworkBootp struct {
	File   string `xml:"file,attr,omitempty"`
	Server string `xml:"server,attr,omitempty"`
}

type NetworkBridge 

type NetworkBridge struct {
	Name            string `xml:"name,attr,omitempty"`
	STP             string `xml:"stp,attr,omitempty"`
	Delay           string `xml:"delay,attr,omitempty"`
	MACTableManager string `xml:"macTableManager,attr,omitempty"`
	Zone            string `xml:"zone,attr,omitempty"`
}

type NetworkDHCP 

type NetworkDHCP struct {
	Ranges []NetworkDHCPRange `xml:"range"`
	Hosts  []NetworkDHCPHost  `xml:"host"`
	Bootp  []NetworkBootp     `xml:"bootp"`
}

type NetworkDHCPHost 

type NetworkDHCPHost struct {
	XMLName xml.Name          `xml:"host"`
	ID      string            `xml:"id,attr,omitempty"`
	MAC     string            `xml:"mac,attr,omitempty"`
	Name    string            `xml:"name,attr,omitempty"`
	IP      string            `xml:"ip,attr,omitempty"`
	Lease   *NetworkDHCPLease `xml:"lease"`
}

func (*NetworkDHCPHost) Marshal 

func (s *NetworkDHCPHost) Marshal() (string, error)

func (*NetworkDHCPHost) Unmarshal 

func (s *NetworkDHCPHost) Unmarshal(doc string) error

type NetworkDHCPLease 

type NetworkDHCPLease struct {
	Expiry uint   `xml:"expiry,attr"`
	Unit   string `xml:"unit,attr,omitempty"`
}

type NetworkDHCPRange 

type NetworkDHCPRange struct {
	XMLName xml.Name          `xml:"range"`
	Start   string            `xml:"start,attr,omitempty"`
	End     string            `xml:"end,attr,omitempty"`
	Lease   *NetworkDHCPLease `xml:"lease"`
}

func (*NetworkDHCPRange) Marshal 

func (s *NetworkDHCPRange) Marshal() (string, error)

func (*NetworkDHCPRange) Unmarshal 

func (s *NetworkDHCPRange) Unmarshal(doc string) error

type NetworkDNS 

type NetworkDNS struct {
	Enable            string                `xml:"enable,attr,omitempty"`
	ForwardPlainNames string                `xml:"forwardPlainNames,attr,omitempty"`
	Forwarders        []NetworkDNSForwarder `xml:"forwarder"`
	TXTs              []NetworkDNSTXT       `xml:"txt"`
	Host              []NetworkDNSHost      `xml:"host"`
	SRVs              []NetworkDNSSRV       `xml:"srv"`
}

type NetworkDNSForwarder 

type NetworkDNSForwarder struct {
	Domain string `xml:"domain,attr,omitempty"`
	Addr   string `xml:"addr,attr,omitempty"`
}

type NetworkDNSHost 

type NetworkDNSHost struct {
	XMLName   xml.Name                 `xml:"host"`
	IP        string                   `xml:"ip,attr"`
	Hostnames []NetworkDNSHostHostname `xml:"hostname"`
}

func (*NetworkDNSHost) Marshal 

func (s *NetworkDNSHost) Marshal() (string, error)

func (*NetworkDNSHost) Unmarshal 

func (s *NetworkDNSHost) Unmarshal(doc string) error

type NetworkDNSHostHostname 

type NetworkDNSHostHostname struct {
	Hostname string `xml:",chardata"`
}

type NetworkDNSSRV 

type NetworkDNSSRV struct {
	XMLName  xml.Name `xml:"srv"`
	Service  string   `xml:"service,attr,omitempty"`
	Protocol string   `xml:"protocol,attr,omitempty"`
	Target   string   `xml:"target,attr,omitempty"`
	Port     uint     `xml:"port,attr,omitempty"`
	Priority uint     `xml:"priority,attr,omitempty"`
	Weight   uint     `xml:"weight,attr,omitempty"`
	Domain   string   `xml:"domain,attr,omitempty"`
}

func (*NetworkDNSSRV) Marshal 

func (s *NetworkDNSSRV) Marshal() (string, error)

func (*NetworkDNSSRV) Unmarshal 

func (s *NetworkDNSSRV) Unmarshal(doc string) error

type NetworkDNSTXT 

type NetworkDNSTXT struct {
	XMLName xml.Name `xml:"txt"`
	Name    string   `xml:"name,attr"`
	Value   string   `xml:"value,attr"`
}

func (*NetworkDNSTXT) Marshal 

func (s *NetworkDNSTXT) Marshal() (string, error)

func (*NetworkDNSTXT) Unmarshal 

func (s *NetworkDNSTXT) Unmarshal(doc string) error

type NetworkDnsmasqOption 

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

type NetworkDnsmasqOptions 

type NetworkDnsmasqOptions struct {
	XMLName xml.Name               `xml:"http://libvirt.org/schemas/network/dnsmasq/1.0 options"`
	Option  []NetworkDnsmasqOption `xml:"option"`
}

type NetworkDomain 

type NetworkDomain struct {
	Name      string `xml:"name,attr,omitempty"`
	LocalOnly string `xml:"localOnly,attr,omitempty"`
}

type NetworkForward 

type NetworkForward struct {
	Mode       string                    `xml:"mode,attr,omitempty"`
	Dev        string                    `xml:"dev,attr,omitempty"`
	Managed    string                    `xml:"managed,attr,omitempty"`
	Driver     *NetworkForwardDriver     `xml:"driver"`
	PFs        []NetworkForwardPF        `xml:"pf"`
	NAT        *NetworkForwardNAT        `xml:"nat"`
	Interfaces []NetworkForwardInterface `xml:"interface"`
	Addresses  []NetworkForwardAddress   `xml:"address"`
}

type NetworkForwardAddress 

type NetworkForwardAddress struct {
	PCI *NetworkForwardAddressPCI `xml:"-"`
}

func (*NetworkForwardAddress) MarshalXML 

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

func (*NetworkForwardAddress) UnmarshalXML 

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

type NetworkForwardAddressPCI 

type NetworkForwardAddressPCI struct {
	Domain   *uint `xml:"domain,attr"`
	Bus      *uint `xml:"bus,attr"`
	Slot     *uint `xml:"slot,attr"`
	Function *uint `xml:"function,attr"`
}

func (*NetworkForwardAddressPCI) MarshalXML 

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

func (*NetworkForwardAddressPCI) UnmarshalXML 

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

type NetworkForwardDriver 

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

type NetworkForwardInterface 

type NetworkForwardInterface struct {
	XMLName xml.Name `xml:"interface"`
	Dev     string   `xml:"dev,attr,omitempty"`
}

func (*NetworkForwardInterface) Marshal 

func (s *NetworkForwardInterface) Marshal() (string, error)

func (*NetworkForwardInterface) Unmarshal 

func (s *NetworkForwardInterface) Unmarshal(doc string) error

type NetworkForwardNAT 

type NetworkForwardNAT struct {
	IPv6      string                     `xml:"ipv6,attr,omitempty"`
	Addresses []NetworkForwardNATAddress `xml:"address"`
	Ports     []NetworkForwardNATPort    `xml:"port"`
}

type NetworkForwardNATAddress 

type NetworkForwardNATAddress struct {
	Start string `xml:"start,attr"`
	End   string `xml:"end,attr"`
}

type NetworkForwardNATPort 

type NetworkForwardNATPort struct {
	Start uint `xml:"start,attr"`
	End   uint `xml:"end,attr"`
}

type NetworkForwardPF 

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

type NetworkIP 

type NetworkIP struct {
	Address  string       `xml:"address,attr,omitempty"`
	Family   string       `xml:"family,attr,omitempty"`
	Netmask  string       `xml:"netmask,attr,omitempty"`
	Prefix   uint         `xml:"prefix,attr,omitempty"`
	LocalPtr string       `xml:"localPtr,attr,omitempty"`
	DHCP     *NetworkDHCP `xml:"dhcp"`
	TFTP     *NetworkTFTP `xml:"tftp"`
}

type NetworkMAC 

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

type NetworkMTU 

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

type NetworkMetadata 

type NetworkMetadata struct {
	XML string `xml:",innerxml"`
}

type NetworkPort 

type NetworkPort struct {
	XMLName     xml.Name                `xml:"networkport"`
	UUID        string                  `xml:"uuid,omitempty"`
	Owner       *NetworkPortOwner       `xml:"owner",`
	MAC         *NetworkPortMAC         `xml:"mac"`
	Group       string                  `xml:"group,omitempty"`
	Bandwidth   *NetworkBandwidth       `xml:"bandwidth"`
	VLAN        *NetworkPortVLAN        `xml:"vlan"`
	PortOptions *NetworkPortPortOptions `xml:"port"`
	VirtualPort *NetworkVirtualPort     `xml:"virtualport"`
	RXFilters   *NetworkPortRXFilters   `xml:"rxfilters"`
	Plug        *NetworkPortPlug        `xml:"plug"`
}

func (*NetworkPort) Marshal 

func (s *NetworkPort) Marshal() (string, error)

func (*NetworkPort) Unmarshal 

func (s *NetworkPort) Unmarshal(doc string) error

type NetworkPortGroup 

type NetworkPortGroup struct {
	XMLName             xml.Name            `xml:"portgroup"`
	Name                string              `xml:"name,attr,omitempty"`
	Default             string              `xml:"default,attr,omitempty"`
	TrustGuestRxFilters string              `xml:"trustGuestRxFilters,attr,omitempty"`
	VLAN                *NetworkVLAN        `xml:"vlan"`
	VirtualPort         *NetworkVirtualPort `xml:"virtualport"`
}

func (*NetworkPortGroup) Marshal 

func (s *NetworkPortGroup) Marshal() (string, error)

func (*NetworkPortGroup) Unmarshal 

func (s *NetworkPortGroup) Unmarshal(doc string) error

type NetworkPortMAC 

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

type NetworkPortOptions 

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

type NetworkPortOwner 

type NetworkPortOwner struct {
	UUID string `xml:"uuid,omitempty"`
	Name string `xml:"name,omitempty"`
}

type NetworkPortPlug 

type NetworkPortPlug struct {
	Bridge     *NetworkPortPlugBridge     `xml:"-"`
	Network    *NetworkPortPlugNetwork    `xml:"-"`
	Direct     *NetworkPortPlugDirect     `xml:"-"`
	HostDevPCI *NetworkPortPlugHostDevPCI `xml:"-"`
}

func (*NetworkPortPlug) MarshalXML 

func (p *NetworkPortPlug) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NetworkPortPlug) UnmarshalXML 

func (p *NetworkPortPlug) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NetworkPortPlugBridge 

type NetworkPortPlugBridge struct {
	Bridge          string `xml:"bridge,attr"`
	MacTableManager string `xml:"macTableManager,attr,omitempty"`
}

type NetworkPortPlugDirect 

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

type NetworkPortPlugHostDevPCI 

type NetworkPortPlugHostDevPCI struct {
	Managed string                            `xml:"managed,attr,omitempty"`
	Driver  *NetworkPortPlugHostDevPCIDriver  `xml:"driver"`
	Address *NetworkPortPlugHostDevPCIAddress `xml:"address"`
}

type NetworkPortPlugHostDevPCIAddress 

type NetworkPortPlugHostDevPCIAddress struct {
	Domain   *uint `xml:"domain,attr"`
	Bus      *uint `xml:"bus,attr"`
	Slot     *uint `xml:"slot,attr"`
	Function *uint `xml:"function,attr"`
}

func (*NetworkPortPlugHostDevPCIAddress) MarshalXML 

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

func (*NetworkPortPlugHostDevPCIAddress) UnmarshalXML 

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

type NetworkPortPlugHostDevPCIDriver 

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

type NetworkPortPlugNetwork 

type NetworkPortPlugNetwork struct {
	Bridge          string `xml:"bridge,attr"`
	MacTableManager string `xml:"macTableManager,attr,omitempty"`
}

type NetworkPortPortOptions 

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

type NetworkPortRXFilters 

type NetworkPortRXFilters struct {
	TrustGuest string `xml:"trustGuest,attr"`
}

type NetworkPortVLAN 

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

type NetworkPortVLANTag 

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

type NetworkRoute 

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

type NetworkTFTP 

type NetworkTFTP struct {
	Root string `xml:"root,attr,omitempty"`
}

type NetworkVLAN 

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

type NetworkVLANTag 

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

type NetworkVirtualPort 

type NetworkVirtualPort struct {
	Params *NetworkVirtualPortParams `xml:"parameters"`
}

func (*NetworkVirtualPort) MarshalXML 

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

func (*NetworkVirtualPort) UnmarshalXML 

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

type NetworkVirtualPortParams 

type NetworkVirtualPortParams struct {
	Any          *NetworkVirtualPortParamsAny          `xml:"-"`
	VEPA8021QBG  *NetworkVirtualPortParamsVEPA8021QBG  `xml:"-"`
	VNTag8011QBH *NetworkVirtualPortParamsVNTag8021QBH `xml:"-"`
	OpenVSwitch  *NetworkVirtualPortParamsOpenVSwitch  `xml:"-"`
	MidoNet      *NetworkVirtualPortParamsMidoNet      `xml:"-"`
}

func (*NetworkVirtualPortParams) MarshalXML 

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

func (*NetworkVirtualPortParams) UnmarshalXML 

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

type NetworkVirtualPortParamsAny 

type NetworkVirtualPortParamsAny 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 NetworkVirtualPortParamsMidoNet 

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

type NetworkVirtualPortParamsOpenVSwitch 

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

type NetworkVirtualPortParamsVEPA8021QBG 

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

type NetworkVirtualPortParamsVNTag8021QBH 

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

type NodeDevice 

type NodeDevice struct {
	XMLName    xml.Name             `xml:"device"`
	Name       string               `xml:"name"`
	Path       string               `xml:"path,omitempty"`
	DevNodes   []NodeDeviceDevNode  `xml:"devnode"`
	Parent     string               `xml:"parent,omitempty"`
	Driver     *NodeDeviceDriver    `xml:"driver"`
	Capability NodeDeviceCapability `xml:"capability"`
}

func (*NodeDevice) Marshal 

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

func (*NodeDevice) Unmarshal 

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

type NodeDeviceAPCardCapability 

type NodeDeviceAPCardCapability struct {
	APAdapter string `xml:"ap-adapter"`
}

type NodeDeviceAPMatrixCapability 

type NodeDeviceAPMatrixCapability struct {
	Capabilities []NodeDeviceAPMatrixSubCapability `xml:"capability"`
}

type NodeDeviceAPMatrixMDevTypesCapability 

type NodeDeviceAPMatrixMDevTypesCapability struct {
	Types []NodeDeviceMDevType `xml:"type"`
}

type NodeDeviceAPMatrixSubCapability 

type NodeDeviceAPMatrixSubCapability struct {
	MDevTypes *NodeDeviceAPMatrixMDevTypesCapability
}

func (*NodeDeviceAPMatrixSubCapability) MarshalXML 

func (c *NodeDeviceAPMatrixSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceAPMatrixSubCapability) UnmarshalXML 

func (c *NodeDeviceAPMatrixSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceAPQueueCapability 

type NodeDeviceAPQueueCapability struct {
	APAdapter string `xml:"ap-adapter"`
	APDomain  string `xml:"ap-domain"`
}

type NodeDeviceCCWCapability 

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

func (*NodeDeviceCCWCapability) MarshalXML 

func (c *NodeDeviceCCWCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCCWCapability) UnmarshalXML 

func (c *NodeDeviceCCWCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceCSSCapability 

type NodeDeviceCSSCapability struct {
	CSSID          *uint                        `xml:"cssid"`
	SSID           *uint                        `xml:"ssid"`
	DevNo          *uint                        `xml:"devno"`
	ChannelDevAddr *NodeDeviceCSSChannelDevAddr `xml:"channel_dev_addr"`
	Capabilities   []NodeDeviceCSSSubCapability `xml:"capability"`
}

func (*NodeDeviceCSSCapability) MarshalXML 

func (c *NodeDeviceCSSCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCSSCapability) UnmarshalXML 

func (c *NodeDeviceCSSCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceCSSChannelDevAddr added in v1.8004.0 

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

func (*NodeDeviceCSSChannelDevAddr) MarshalXML added in v1.8004.0 

func (c *NodeDeviceCSSChannelDevAddr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCSSChannelDevAddr) UnmarshalXML added in v1.8004.0 

func (c *NodeDeviceCSSChannelDevAddr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceCSSMDevTypesCapability 

type NodeDeviceCSSMDevTypesCapability struct {
	Types []NodeDeviceMDevType `xml:"type"`
}

type NodeDeviceCSSSubCapability 

type NodeDeviceCSSSubCapability struct {
	MDevTypes *NodeDeviceCSSMDevTypesCapability
}

func (*NodeDeviceCSSSubCapability) MarshalXML 

func (c *NodeDeviceCSSSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCSSSubCapability) UnmarshalXML 

func (c *NodeDeviceCSSSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceCapability 

type NodeDeviceCapability struct {
	System     *NodeDeviceSystemCapability
	PCI        *NodeDevicePCICapability
	USB        *NodeDeviceUSBCapability
	USBDevice  *NodeDeviceUSBDeviceCapability
	Net        *NodeDeviceNetCapability
	SCSIHost   *NodeDeviceSCSIHostCapability
	SCSITarget *NodeDeviceSCSITargetCapability
	SCSI       *NodeDeviceSCSICapability
	Storage    *NodeDeviceStorageCapability
	DRM        *NodeDeviceDRMCapability
	CCW        *NodeDeviceCCWCapability
	MDev       *NodeDeviceMDevCapability
	CSS        *NodeDeviceCSSCapability
	APQueue    *NodeDeviceAPQueueCapability
	APCard     *NodeDeviceAPCardCapability
	APMatrix   *NodeDeviceAPMatrixCapability
}

func (*NodeDeviceCapability) MarshalXML 

func (c *NodeDeviceCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCapability) UnmarshalXML 

func (c *NodeDeviceCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceDRMCapability 

type NodeDeviceDRMCapability struct {
	Type string `xml:"type"`
}

type NodeDeviceDevNode 

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

type NodeDeviceDriver 

type NodeDeviceDriver struct {
	Name string `xml:"name"`
}

type NodeDeviceIDName 

type NodeDeviceIDName struct {
	ID   string `xml:"id,attr"`
	Name string `xml:",chardata"`
}

type NodeDeviceIOMMUGroup 

type NodeDeviceIOMMUGroup struct {
	Number  int                    `xml:"number,attr"`
	Address []NodeDevicePCIAddress `xml:"address"`
}

type NodeDeviceMDevCapability 

type NodeDeviceMDevCapability struct {
	Type       *NodeDeviceMDevCapabilityType   `xml:"type"`
	IOMMUGroup *NodeDeviceIOMMUGroup           `xml:"iommuGroup"`
	UUID       string                          `xml:"uuid,omitempty"`
	ParentAddr string                          `xml:"parent_addr,omitempty"`
	Attrs      []NodeDeviceMDevCapabilityAttrs `xml:"attr,omitempty"`
}

type NodeDeviceMDevCapabilityAttrs 

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

type NodeDeviceMDevCapabilityType 

type NodeDeviceMDevCapabilityType struct {
	ID string `xml:"id,attr"`
}

type NodeDeviceMDevType 

type NodeDeviceMDevType struct {
	ID                 string `xml:"id,attr"`
	Name               string `xml:"name"`
	DeviceAPI          string `xml:"deviceAPI"`
	AvailableInstances uint   `xml:"availableInstances"`
}

type NodeDeviceNUMA 

type NodeDeviceNUMA struct {
	Node int `xml:"node,attr"`
}

type NodeDeviceNet80203Capability 

type NodeDeviceNet80203Capability struct {
}

type NodeDeviceNet80211Capability 

type NodeDeviceNet80211Capability struct {
}

type NodeDeviceNetCapability 

type NodeDeviceNetCapability struct {
	Interface  string                         `xml:"interface"`
	Address    string                         `xml:"address"`
	Link       *NodeDeviceNetLink             `xml:"link"`
	Features   []NodeDeviceNetOffloadFeatures `xml:"feature,omitempty"`
	Capability []NodeDeviceNetSubCapability   `xml:"capability"`
}
type NodeDeviceNetLink struct {
	State string `xml:"state,attr"`
	Speed string `xml:"speed,attr,omitempty"`
}

type NodeDeviceNetOffloadFeatures 

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

type NodeDeviceNetSubCapability 

type NodeDeviceNetSubCapability struct {
	Wireless80211 *NodeDeviceNet80211Capability
	Ethernet80203 *NodeDeviceNet80203Capability
}

func (*NodeDeviceNetSubCapability) MarshalXML 

func (c *NodeDeviceNetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceNetSubCapability) UnmarshalXML 

func (c *NodeDeviceNetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIAddress 

type NodeDevicePCIAddress struct {
	Domain   *uint `xml:"domain,attr"`
	Bus      *uint `xml:"bus,attr"`
	Slot     *uint `xml:"slot,attr"`
	Function *uint `xml:"function,attr"`
}

func (*NodeDevicePCIAddress) MarshalXML 

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

func (*NodeDevicePCIAddress) UnmarshalXML 

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

type NodeDevicePCIBridgeCapability 

type NodeDevicePCIBridgeCapability struct {
}

type NodeDevicePCICapability 

type NodeDevicePCICapability struct {
	Class        string                       `xml:"class,omitempty"`
	Domain       *uint                        `xml:"domain"`
	Bus          *uint                        `xml:"bus"`
	Slot         *uint                        `xml:"slot"`
	Function     *uint                        `xml:"function"`
	Product      NodeDeviceIDName             `xml:"product,omitempty"`
	Vendor       NodeDeviceIDName             `xml:"vendor,omitempty"`
	IOMMUGroup   *NodeDeviceIOMMUGroup        `xml:"iommuGroup"`
	NUMA         *NodeDeviceNUMA              `xml:"numa"`
	PCIExpress   *NodeDevicePCIExpress        `xml:"pci-express"`
	Capabilities []NodeDevicePCISubCapability `xml:"capability"`
}

type NodeDevicePCIExpress 

type NodeDevicePCIExpress struct {
	Links []NodeDevicePCIExpressLink `xml:"link"`
}
type NodeDevicePCIExpressLink struct {
	Validity string  `xml:"validity,attr,omitempty"`
	Speed    float64 `xml:"speed,attr,omitempty"`
	Port     *uint   `xml:"port,attr"`
	Width    *uint   `xml:"width,attr"`
}

type NodeDevicePCIMDevTypesCapability 

type NodeDevicePCIMDevTypesCapability struct {
	Types []NodeDeviceMDevType `xml:"type"`
}

type NodeDevicePCIPhysFunctionCapability 

type NodeDevicePCIPhysFunctionCapability struct {
	Address NodeDevicePCIAddress `xml:"address,omitempty"`
}

type NodeDevicePCISubCapability 

type NodeDevicePCISubCapability struct {
	VirtFunctions *NodeDevicePCIVirtFunctionsCapability
	PhysFunction  *NodeDevicePCIPhysFunctionCapability
	MDevTypes     *NodeDevicePCIMDevTypesCapability
	Bridge        *NodeDevicePCIBridgeCapability
	VPD           *NodeDevicePCIVPDCapability
}

func (*NodeDevicePCISubCapability) MarshalXML 

func (c *NodeDevicePCISubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDevicePCISubCapability) UnmarshalXML 

func (c *NodeDevicePCISubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIVPDCapability added in v1.7009.0 

type NodeDevicePCIVPDCapability struct {
	Name      string                    `xml:"name,omitempty"`
	ReadOnly  *NodeDevicePCIVPDFieldsRO `xml:"-"`
	ReadWrite *NodeDevicePCIVPDFieldsRW `xml:"-"`
}

func (*NodeDevicePCIVPDCapability) MarshalXML added in v1.7009.0 

func (c *NodeDevicePCIVPDCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDevicePCIVPDCapability) UnmarshalXML added in v1.7009.0 

func (c *NodeDevicePCIVPDCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIVPDCustomField added in v1.7009.0 

type NodeDevicePCIVPDCustomField struct {
	Index string `xml:"index,attr"`
	Value string `xml:",chardata"`
}

type NodeDevicePCIVPDFieldsRO added in v1.7009.0 

type NodeDevicePCIVPDFieldsRO struct {
	ChangeLevel   string                        `xml:"change_level,omitempty"`
	ManufactureID string                        `xml:"manufacture_id,omitempty"`
	PartNumber    string                        `xml:"part_number,omitempty"`
	SerialNumber  string                        `xml:"serial_number,omitempty"`
	VendorFields  []NodeDevicePCIVPDCustomField `xml:"vendor_field"`
}

type NodeDevicePCIVPDFieldsRW added in v1.7009.0 

type NodeDevicePCIVPDFieldsRW struct {
	AssetTag     string                        `xml:"asset_tag,omitempty"`
	VendorFields []NodeDevicePCIVPDCustomField `xml:"vendor_field"`
	SystemFields []NodeDevicePCIVPDCustomField `xml:"system_field"`
}

type NodeDevicePCIVirtFunctionsCapability 

type NodeDevicePCIVirtFunctionsCapability struct {
	Address  []NodeDevicePCIAddress `xml:"address,omitempty"`
	MaxCount int                    `xml:"maxCount,attr,omitempty"`
}

type NodeDeviceSCSICapability 

type NodeDeviceSCSICapability struct {
	Host   int    `xml:"host"`
	Bus    int    `xml:"bus"`
	Target int    `xml:"target"`
	Lun    int    `xml:"lun"`
	Type   string `xml:"type"`
}

type NodeDeviceSCSIFCHostCapability 

type NodeDeviceSCSIFCHostCapability struct {
	WWNN      string `xml:"wwnn,omitempty"`
	WWPN      string `xml:"wwpn,omitempty"`
	FabricWWN string `xml:"fabric_wwn,omitempty"`
}

type NodeDeviceSCSIFCRemotePortCapability 

type NodeDeviceSCSIFCRemotePortCapability struct {
	RPort string `xml:"rport"`
	WWPN  string `xml:"wwpn"`
}

type NodeDeviceSCSIHostCapability 

type NodeDeviceSCSIHostCapability struct {
	Host       uint                              `xml:"host"`
	UniqueID   *uint                             `xml:"unique_id"`
	Capability []NodeDeviceSCSIHostSubCapability `xml:"capability"`
}

type NodeDeviceSCSIHostSubCapability 

type NodeDeviceSCSIHostSubCapability struct {
	VPortOps *NodeDeviceSCSIVPortOpsCapability
	FCHost   *NodeDeviceSCSIFCHostCapability
}

func (*NodeDeviceSCSIHostSubCapability) MarshalXML 

func (c *NodeDeviceSCSIHostSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceSCSIHostSubCapability) UnmarshalXML 

func (c *NodeDeviceSCSIHostSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSCSITargetCapability 

type NodeDeviceSCSITargetCapability struct {
	Target     string                              `xml:"target"`
	Capability []NodeDeviceSCSITargetSubCapability `xml:"capability"`
}

type NodeDeviceSCSITargetSubCapability 

type NodeDeviceSCSITargetSubCapability struct {
	FCRemotePort *NodeDeviceSCSIFCRemotePortCapability
}

func (*NodeDeviceSCSITargetSubCapability) MarshalXML 

func (c *NodeDeviceSCSITargetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceSCSITargetSubCapability) UnmarshalXML 

func (c *NodeDeviceSCSITargetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSCSIVPortOpsCapability 

type NodeDeviceSCSIVPortOpsCapability struct {
	VPorts    int `xml:"vports"`
	MaxVPorts int `xml:"max_vports"`
}

type NodeDeviceStorageCapability 

type NodeDeviceStorageCapability struct {
	Block            string                           `xml:"block,omitempty"`
	Bus              string                           `xml:"bus,omitempty"`
	DriverType       string                           `xml:"drive_type,omitempty"`
	Model            string                           `xml:"model,omitempty"`
	Vendor           string                           `xml:"vendor,omitempty"`
	Serial           string                           `xml:"serial,omitempty"`
	Size             *uint                            `xml:"size"`
	LogicalBlockSize *uint                            `xml:"logical_block_size"`
	NumBlocks        *uint                            `xml:"num_blocks"`
	Capability       []NodeDeviceStorageSubCapability `xml:"capability"`
}

type NodeDeviceStorageRemovableCapability 

type NodeDeviceStorageRemovableCapability struct {
	MediaAvailable   *uint  `xml:"media_available"`
	MediaSize        *uint  `xml:"media_size"`
	MediaLabel       string `xml:"media_label,omitempty"`
	LogicalBlockSize *uint  `xml:"logical_block_size"`
	NumBlocks        *uint  `xml:"num_blocks"`
}

type NodeDeviceStorageSubCapability 

type NodeDeviceStorageSubCapability struct {
	Removable *NodeDeviceStorageRemovableCapability
}

func (*NodeDeviceStorageSubCapability) MarshalXML 

func (c *NodeDeviceStorageSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceStorageSubCapability) UnmarshalXML 

func (c *NodeDeviceStorageSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSystemCapability 

type NodeDeviceSystemCapability struct {
	Product  string                    `xml:"product,omitempty"`
	Hardware *NodeDeviceSystemHardware `xml:"hardware"`
	Firmware *NodeDeviceSystemFirmware `xml:"firmware"`
}

type NodeDeviceSystemFirmware 

type NodeDeviceSystemFirmware struct {
	Vendor      string `xml:"vendor"`
	Version     string `xml:"version"`
	ReleaseData string `xml:"release_date"`
}

type NodeDeviceSystemHardware 

type NodeDeviceSystemHardware struct {
	Vendor  string `xml:"vendor"`
	Version string `xml:"version"`
	Serial  string `xml:"serial"`
	UUID    string `xml:"uuid"`
}

type NodeDeviceUSBCapability 

type NodeDeviceUSBCapability struct {
	Number      int    `xml:"number"`
	Class       int    `xml:"class"`
	Subclass    int    `xml:"subclass"`
	Protocol    int    `xml:"protocol"`
	Description string `xml:"description,omitempty"`
}

type NodeDeviceUSBDeviceCapability 

type NodeDeviceUSBDeviceCapability struct {
	Bus     int              `xml:"bus"`
	Device  int              `xml:"device"`
	Product NodeDeviceIDName `xml:"product,omitempty"`
	Vendor  NodeDeviceIDName `xml:"vendor,omitempty"`
}

type Secret 

type Secret struct {
	XMLName     xml.Name     `xml:"secret"`
	Ephemeral   string       `xml:"ephemeral,attr,omitempty"`
	Private     string       `xml:"private,attr,omitempty"`
	Description string       `xml:"description,omitempty"`
	UUID        string       `xml:"uuid,omitempty"`
	Usage       *SecretUsage `xml:"usage"`
}

func (*Secret) Marshal 

func (s *Secret) Marshal() (string, error)

func (*Secret) Unmarshal 

func (s *Secret) Unmarshal(doc string) error

type SecretUsage 

type SecretUsage struct {
	Type   string `xml:"type,attr"`
	Volume string `xml:"volume,omitempty"`
	Name   string `xml:"name,omitempty"`
	Target string `xml:"target,omitempty"`
}

type StorageEncryption 

type StorageEncryption struct {
	Format string                   `xml:"format,attr"`
	Secret *StorageEncryptionSecret `xml:"secret"`
	Cipher *StorageEncryptionCipher `xml:"cipher"`
	Ivgen  *StorageEncryptionIvgen  `xml:"ivgen"`
}

type StorageEncryptionCipher 

type StorageEncryptionCipher struct {
	Name string `xml:"name,attr"`
	Size uint64 `xml:"size,attr"`
	Mode string `xml:"mode,attr"`
	Hash string `xml:"hash,attr"`
}

type StorageEncryptionIvgen 

type StorageEncryptionIvgen struct {
	Name string `xml:"name,attr"`
	Hash string `xml:"hash,attr"`
}

type StorageEncryptionSecret 

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

type StoragePool 

type StoragePool struct {
	XMLName    xml.Name             `xml:"pool"`
	Type       string               `xml:"type,attr"`
	Name       string               `xml:"name,omitempty"`
	UUID       string               `xml:"uuid,omitempty"`
	Allocation *StoragePoolSize     `xml:"allocation"`
	Capacity   *StoragePoolSize     `xml:"capacity"`
	Available  *StoragePoolSize     `xml:"available"`
	Features   *StoragePoolFeatures `xml:"features"`
	Target     *StoragePoolTarget   `xml:"target"`
	Source     *StoragePoolSource   `xml:"source"`
	Refresh    *StoragePoolRefresh  `xml:"refresh"`

	/* Pool backend namespcaes must be last */
	FSCommandline  *StoragePoolFSCommandline
	RBDCommandline *StoragePoolRBDCommandline
}

func (*StoragePool) Marshal 

func (s *StoragePool) Marshal() (string, error)

func (*StoragePool) Unmarshal 

func (s *StoragePool) Unmarshal(doc string) error

type StoragePoolFSCommandline 

type StoragePoolFSCommandline struct {
	XMLName xml.Name                         `xml:"http://libvirt.org/schemas/storagepool/fs/1.0 mount_opts"`
	Options []StoragePoolFSCommandlineOption `xml:"option"`
}

type StoragePoolFSCommandlineOption 

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

type StoragePoolFeatureCOW 

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

type StoragePoolFeatures 

type StoragePoolFeatures struct {
	COW StoragePoolFeatureCOW `xml:"cow"`
}

type StoragePoolPCIAddress 

type StoragePoolPCIAddress struct {
	Domain   *uint `xml:"domain,attr"`
	Bus      *uint `xml:"bus,attr"`
	Slot     *uint `xml:"slot,attr"`
	Function *uint `xml:"function,attr"`
}

func (*StoragePoolPCIAddress) MarshalXML 

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

func (*StoragePoolPCIAddress) UnmarshalXML 

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

type StoragePoolRBDCommandline 

type StoragePoolRBDCommandline struct {
	XMLName xml.Name                          `xml:"http://libvirt.org/schemas/storagepool/rbd/1.0 config_opts"`
	Options []StoragePoolRBDCommandlineOption `xml:"option"`
}

type StoragePoolRBDCommandlineOption 

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

type StoragePoolRefresh 

type StoragePoolRefresh struct {
	Volume StoragePoolRefreshVol `xml:"volume"`
}

type StoragePoolRefreshVol 

type StoragePoolRefreshVol struct {
	Allocation string `xml:"allocation,attr"`
}

type StoragePoolSize 

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

type StoragePoolSource 

type StoragePoolSource struct {
	Name      string                      `xml:"name,omitempty"`
	Dir       *StoragePoolSourceDir       `xml:"dir"`
	Host      []StoragePoolSourceHost     `xml:"host"`
	Device    []StoragePoolSourceDevice   `xml:"device"`
	Auth      *StoragePoolSourceAuth      `xml:"auth"`
	Vendor    *StoragePoolSourceVendor    `xml:"vendor"`
	Product   *StoragePoolSourceProduct   `xml:"product"`
	Format    *StoragePoolSourceFormat    `xml:"format"`
	Protocol  *StoragePoolSourceProtocol  `xml:"protocol"`
	Adapter   *StoragePoolSourceAdapter   `xml:"adapter"`
	Initiator *StoragePoolSourceInitiator `xml:"initiator"`
}

type StoragePoolSourceAdapter 

type StoragePoolSourceAdapter struct {
	Type       string                              `xml:"type,attr,omitempty"`
	Name       string                              `xml:"name,attr,omitempty"`
	Parent     string                              `xml:"parent,attr,omitempty"`
	Managed    string                              `xml:"managed,attr,omitempty"`
	WWNN       string                              `xml:"wwnn,attr,omitempty"`
	WWPN       string                              `xml:"wwpn,attr,omitempty"`
	ParentAddr *StoragePoolSourceAdapterParentAddr `xml:"parentaddr"`
}

type StoragePoolSourceAdapterParentAddr 

type StoragePoolSourceAdapterParentAddr struct {
	UniqueID uint64                 `xml:"unique_id,attr"`
	Address  *StoragePoolPCIAddress `xml:"address"`
}

type StoragePoolSourceAuth 

type StoragePoolSourceAuth struct {
	Type     string                       `xml:"type,attr"`
	Username string                       `xml:"username,attr"`
	Secret   *StoragePoolSourceAuthSecret `xml:"secret"`
}

type StoragePoolSourceAuthSecret 

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

type StoragePoolSourceDevice 

type StoragePoolSourceDevice struct {
	Path          string                              `xml:"path,attr"`
	PartSeparator string                              `xml:"part_separator,attr,omitempty"`
	FreeExtents   []StoragePoolSourceDeviceFreeExtent `xml:"freeExtent"`
}

type StoragePoolSourceDeviceFreeExtent 

type StoragePoolSourceDeviceFreeExtent struct {
	Start uint64 `xml:"start,attr"`
	End   uint64 `xml:"end,attr"`
}

type StoragePoolSourceDir 

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

type StoragePoolSourceFormat 

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

type StoragePoolSourceHost 

type StoragePoolSourceHost struct {
	Name string `xml:"name,attr"`
	Port string `xml:"port,attr,omitempty"`
}

type StoragePoolSourceInitiator 

type StoragePoolSourceInitiator struct {
	IQN StoragePoolSourceInitiatorIQN `xml:"iqn"`
}

type StoragePoolSourceInitiatorIQN 

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

type StoragePoolSourceProduct 

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

type StoragePoolSourceProtocol 

type StoragePoolSourceProtocol struct {
	Version string `xml:"ver,attr"`
}

type StoragePoolSourceVendor 

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

type StoragePoolTarget 

type StoragePoolTarget struct {
	Path        string                        `xml:"path,omitempty"`
	Permissions *StoragePoolTargetPermissions `xml:"permissions"`
	Timestamps  *StoragePoolTargetTimestamps  `xml:"timestamps"`
	Encryption  *StorageEncryption            `xml:"encryption"`
}

type StoragePoolTargetPermissions 

type StoragePoolTargetPermissions struct {
	Owner string `xml:"owner,omitempty"`
	Group string `xml:"group,omitempty"`
	Mode  string `xml:"mode,omitempty"`
	Label string `xml:"label,omitempty"`
}

type StoragePoolTargetTimestamps 

type StoragePoolTargetTimestamps struct {
	Atime string `xml:"atime"`
	Mtime string `xml:"mtime"`
	Ctime string `xml:"ctime"`
}

type StorageVolume 

type StorageVolume struct {
	XMLName      xml.Name                   `xml:"volume"`
	Type         string                     `xml:"type,attr,omitempty"`
	Name         string                     `xml:"name"`
	Key          string                     `xml:"key,omitempty"`
	Allocation   *StorageVolumeSize         `xml:"allocation"`
	Capacity     *StorageVolumeSize         `xml:"capacity"`
	Physical     *StorageVolumeSize         `xml:"physical"`
	Target       *StorageVolumeTarget       `xml:"target"`
	BackingStore *StorageVolumeBackingStore `xml:"backingStore"`
}

func (*StorageVolume) Marshal 

func (s *StorageVolume) Marshal() (string, error)

func (*StorageVolume) Unmarshal 

func (s *StorageVolume) Unmarshal(doc string) error

type StorageVolumeBackingStore 

type StorageVolumeBackingStore struct {
	Path        string                          `xml:"path"`
	Format      *StorageVolumeTargetFormat      `xml:"format"`
	Permissions *StorageVolumeTargetPermissions `xml:"permissions"`
}

type StorageVolumeSize 

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

type StorageVolumeTarget 

type StorageVolumeTarget struct {
	Path        string                          `xml:"path,omitempty"`
	Format      *StorageVolumeTargetFormat      `xml:"format"`
	Permissions *StorageVolumeTargetPermissions `xml:"permissions"`
	Timestamps  *StorageVolumeTargetTimestamps  `xml:"timestamps"`
	Compat      string                          `xml:"compat,omitempty"`
	ClusterSize *StorageVolumeTargetClusterSize `xml:"clusterSize"`
	NoCOW       *struct{}                       `xml:"nocow"`
	Features    []StorageVolumeTargetFeature    `xml:"features"`
	Encryption  *StorageEncryption              `xml:"encryption"`
}

type StorageVolumeTargetClusterSize added in v1.8000.0 

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

type StorageVolumeTargetFeature 

type StorageVolumeTargetFeature struct {
	LazyRefcounts *struct{} `xml:"lazy_refcounts"`
	ExtendedL2    *struct{} `xml:"extended_l2"`
}

type StorageVolumeTargetFormat 

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

type StorageVolumeTargetPermissions 

type StorageVolumeTargetPermissions struct {
	Owner string `xml:"owner,omitempty"`
	Group string `xml:"group,omitempty"`
	Mode  string `xml:"mode,omitempty"`
	Label string `xml:"label,omitempty"`
}

type StorageVolumeTargetTimestamps 

type StorageVolumeTargetTimestamps struct {
	Atime string `xml:"atime"`
	Mtime string `xml:"mtime"`
	Ctime string `xml:"ctime"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.