libvirtxml

package module
v5.6.0+incompatible Latest Latest
Warning

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

 Go to latest Published: Jul 30, 2019 License: MIT Imports: 5 Imported by: 0

README

libvirt-go-xml Build Status GoDoc

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 dependancy on the libvirt library itself, so this can be used regardless of the way in which the application talks to libvirt.

Documentation

Contributing

The libvirt project aims to add support for new APIs to libvirt-go as soon as they are added to the main libvirt C library. If you are submitting changes to the libvirt C library API, please submit a libvirt-go change at the same time.

Bug fixes and other improvements to the libvirt-go library are welcome at any time. The preferred submission method is to use git send-email to submit patches to the libvir-list@redhat.com mailing list. eg. to send a single patch

  # git send-email --to libvir-list@redhat.com --subject-prefix "PATCH go-xml" \
       --smtp-server=$HOSTNAME -1

Or to send all patches on the current branch, against master

  $ git send-email --to libvir-list@redhat.com --subject-prefix "PATCH go-xml" \
       --smtp-server=$HOSTNAME --no-chain-reply-to --cover-letter --annotate \
       master..

Note the master GIT repository is at

   http://libvirt.org/git/?p=libvirt-go.git;a=summary

The following automatic read-only mirrors are available as a convenience to allow contributors to "fork" the repository:

  https://gitlab.com/libvirt/libvirt-go
  https://github.com/libvirt/libvirt-go

While you can send pull-requests to these mirrors, they will be re-submitted via emai to the mailing list for review before being merged, unless they are trivial/obvious bug fixes.

Documentation

Overview

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

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

Example creating a domain XML document from configuration: 

import (
 "github.com/libvirt/libvirt-go-xml"
)

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 

import (
  "github.com/libvirt/libvirt-go"
  "github.com/libvirt/libvirt-go-xml"
  "fmt"
)

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

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

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

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Caps 

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

func (*Caps) Marshal 

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

func (*Caps) Unmarshal 

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

type CapsGuest 

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

type CapsGuestArch 

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

type CapsGuestDomain 

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

type CapsGuestFeatureACPI 

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

type CapsGuestFeatureAPIC 

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

type CapsGuestFeatureCPUSelection 

type CapsGuestFeatureCPUSelection struct {
}

type CapsGuestFeatureDeviceBoot 

type CapsGuestFeatureDeviceBoot struct {
}

type CapsGuestFeatureDiskSnapshot 

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

type CapsGuestFeatureIA64BE 

type CapsGuestFeatureIA64BE struct {
}

type CapsGuestFeatureNonPAE 

type CapsGuestFeatureNonPAE struct {
}

type CapsGuestFeaturePAE 

type CapsGuestFeaturePAE struct {
}

type CapsGuestFeatures 

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

type CapsGuestMachine 

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

type CapsHost 

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

type CapsHostCPU 

type CapsHostCPU struct {
	XMLName      xml.Name                 `xml:"cpu"`
	Arch         string                   `xml:"arch,omitempty"`
	Model        string                   `xml:"model,omitempty"`
	Vendor       string                   `xml:"vendor,omitempty"`
	Topology     *CapsHostCPUTopology     `xml:"topology"`
	FeatureFlags []CapsHostCPUFeatureFlag `xml:"feature"`
	Features     *CapsHostCPUFeatures     `xml:"features"`
	PageSizes    []CapsHostCPUPageSize    `xml:"pages"`
	Microcode    *CapsHostCPUMicrocode    `xml:"microcode"`
}

func (*CapsHostCPU) Marshal 

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

func (*CapsHostCPU) Unmarshal 

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

type CapsHostCPUFeature 

type CapsHostCPUFeature struct {
}

type CapsHostCPUFeatureFlag 

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

type CapsHostCPUFeatures 

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

type CapsHostCPUMicrocode 

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

type CapsHostCPUPageSize 

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

type CapsHostCPUTopology 

type CapsHostCPUTopology struct {
	Sockets int `xml:"sockets,attr"`
	Cores   int `xml:"cores,attr"`
	Threads int `xml:"threads,attr"`
}

type CapsHostCache 

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

type CapsHostCacheBank 

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

type CapsHostCacheControl 

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

type CapsHostCacheMonitor 

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

type CapsHostCacheMonitorFeature 

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

type CapsHostIOMMU 

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

type CapsHostMemoryBandwidth 

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

type CapsHostMemoryBandwidthMonitor 

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

type CapsHostMemoryBandwidthMonitorFeature 

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

type CapsHostMemoryBandwidthNode 

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

type CapsHostMemoryBandwidthNodeControl 

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

type CapsHostMigrationFeatures 

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

type CapsHostMigrationLive 

type CapsHostMigrationLive struct {
}

type CapsHostMigrationURITransports 

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

type CapsHostNUMACPU 

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

type CapsHostNUMACPUs 

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

type CapsHostNUMACell 

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

type CapsHostNUMACells 

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

type CapsHostNUMADistances 

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

type CapsHostNUMAMemory 

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

type CapsHostNUMAPageInfo 

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

type CapsHostNUMASibling 

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

type CapsHostNUMATopology 

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

type CapsHostPowerManagement 

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

type CapsHostPowerManagementMode 

type CapsHostPowerManagementMode struct {
}

type CapsHostSecModel 

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

type CapsHostSecModelLabel 

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

type Document 

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

type Domain 

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

	/* Hypervisor namespaces must all be last */
	QEMUCommandline      *DomainQEMUCommandline
	QEMUCapabilities     *DomainQEMUCapabilities
	LXCNamespace         *DomainLXCNamespace
	BHyveCommandline     *DomainBHyveCommandline
	VMWareDataCenterPath *DomainVMWareDataCenterPath
}

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
}

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 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 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 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"`
	Model    *DomainCPUModel    `xml:"model"`
	Vendor   string             `xml:"vendor,omitempty"`
	Topology *DomainCPUTopology `xml:"topology"`
	Cache    *DomainCPUCache    `xml:"cache"`
	Features []DomainCPUFeature `xml:"feature"`
	Numa     *DomainNuma        `xml:"numa"`
}

func (*DomainCPU) Marshal 

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

func (*DomainCPU) Unmarshal 

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

type DomainCPUCache 

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

type DomainCPUCacheTune 

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

type DomainCPUCacheTuneCache 

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

type DomainCPUCacheTuneMonitor 

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

type DomainCPUFeature 

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

type DomainCPUMemoryTune 

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

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"`
	Cores   int `xml:"cores,attr,omitempty"`
	Threads int `xml:"threads,attr,omitempty"`
}

type DomainCPUTune 

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

type DomainCPUTuneEmulatorPin 

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

type DomainCPUTuneEmulatorSched 

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

type DomainCPUTuneIOThreadPin 

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

type DomainCPUTuneIOThreadSched 

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

type DomainCPUTunePeriod 

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

type DomainCPUTuneQuota 

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

type DomainCPUTuneShares 

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

type DomainCPUTuneVCPUPin 

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

type DomainCPUTuneVCPUSched 

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

type DomainCaps 

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

func (*DomainCaps) Marshal 

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

func (*DomainCaps) Unmarshal 

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

type DomainCapsCPU 

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

type DomainCapsCPUFeature 

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

type DomainCapsCPUMode 

type DomainCapsCPUMode struct {
	Name      string                 `xml:"name,attr"`
	Supported string                 `xml:"supported,attr"`
	Models    []DomainCapsCPUModel   `xml:"model"`
	Vendor    string                 `xml:"vendor,omitempty"`
	Features  []DomainCapsCPUFeature `xml:"feature"`
}

type DomainCapsCPUModel 

type DomainCapsCPUModel struct {
	Name     string `xml:",chardata"`
	Usable   string `xml:"usable,attr,omitempty"`
	Fallback string `xml:"fallback,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"`
}

type DomainCapsEnum 

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

type DomainCapsFeatureGIC 

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

type DomainCapsFeatureGenID 

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

type DomainCapsFeatureSEV 

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

type DomainCapsFeatureVMCoreInfo 

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

type DomainCapsFeatures 

type DomainCapsFeatures struct {
	GIC        *DomainCapsFeatureGIC        `xml:"gic"`
	VMCoreInfo *DomainCapsFeatureVMCoreInfo `xml:"vmcoreinfo"`
	GenID      *DomainCapsFeatureGenID      `xml:"genid"`
	SEV        *DomainCapsFeatureSEV        `xml:"sev"`
}

type DomainCapsIOThreads 

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

type DomainCapsOS 

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

type DomainCapsOSLoader 

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

type DomainCapsVCPU 

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

type DomainCell 

type DomainCell struct {
	ID        *uint                `xml:"id,attr"`
	CPUs      string               `xml:"cpus,attr"`
	Memory    string               `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"`
}

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"`
	Alias    *DomainAlias           `xml:"alias"`
	Address  *DomainAddress         `xml:"address"`
}

func (*DomainChannel) Marshal 

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

func (*DomainChannel) MarshalXML 

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

func (*DomainChannel) Unmarshal 

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

func (*DomainChannel) UnmarshalXML 

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

type DomainChannelTarget 

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

func (*DomainChannelTarget) MarshalXML 

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

func (*DomainChannelTarget) UnmarshalXML 

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

type DomainChannelTargetGuestFWD 

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

type DomainChannelTargetVirtIO 

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

type DomainChannelTargetXen 

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

type DomainChardevLog 

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

type DomainChardevProtocol 

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

type DomainChardevSource 

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

func (*DomainChardevSource) MarshalXML 

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

func (*DomainChardevSource) UnmarshalXML 

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

type DomainChardevSourceDev 

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

type DomainChardevSourceFile 

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

type DomainChardevSourceNMDM 

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

type DomainChardevSourceNull 

type DomainChardevSourceNull struct {
}

type DomainChardevSourcePipe 

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

type DomainChardevSourcePty 

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

type DomainChardevSourceReconnect 

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

type DomainChardevSourceSpicePort 

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

type DomainChardevSourceSpiceVMC 

type DomainChardevSourceSpiceVMC struct {
}

type DomainChardevSourceStdIO 

type DomainChardevSourceStdIO struct {
}

type DomainChardevSourceTCP 

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

type DomainChardevSourceUDP 

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

type DomainChardevSourceUNIX 

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

type DomainChardevSourceVC 

type DomainChardevSourceVC struct {
}

type DomainChardevTarget 

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

type DomainClock 

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

type DomainConsole 

type DomainConsole struct {
	XMLName  xml.Name               `xml:"console"`
	TTY      string                 `xml:"tty,attr,omitempty"`
	Source   *DomainChardevSource   `xml:"source"`
	Protocol *DomainChardevProtocol `xml:"protocol"`
	Target   *DomainConsoleTarget   `xml:"target"`
	Log      *DomainChardevLog      `xml:"log"`
	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:"-"`
	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"`
}

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
}

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

type DomainCurrentMemory 

type DomainCurrentMemory struct {
	Value uint   `xml:",chardata"`
	Unit  string `xml:"unit,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"`
	Videos       []DomainVideo       `xml:"video"`
	Hostdevs     []DomainHostdev     `xml:"hostdev"`
	RedirDevs    []DomainRedirDev    `xml:"redirdev"`
	RedirFilters []DomainRedirFilter `xml:"redirfilter"`
	Hubs         []DomainHub         `xml:"hub"`
	Watchdog     *DomainWatchdog     `xml:"watchdog"`
	MemBalloon   *DomainMemBalloon   `xml:"memballoon"`
	RNGs         []DomainRNG         `xml:"rng"`
	NVRAM        *DomainNVRAM        `xml:"nvram"`
	Panics       []DomainPanic       `xml:"panic"`
	Shmems       []DomainShmem       `xml:"shmem"`
	Memorydevs   []DomainMemorydev   `xml:"memory"`
	IOMMU        *DomainIOMMU        `xml:"iommu"`
	VSock        *DomainVSock        `xml:"vsock"`
}

type DomainDeviceSecLabel 

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

type DomainDisk 

type DomainDisk struct {
	XMLName      xml.Name                `xml:"disk"`
	Device       string                  `xml:"device,attr,omitempty"`
	RawIO        string                  `xml:"rawio,attr,omitempty"`
	SGIO         string                  `xml:"sgio,attr,omitempty"`
	Snapshot     string                  `xml:"snapshot,attr,omitempty"`
	Model        string                  `xml:"model,attr,omitempty"`
	Driver       *DomainDiskDriver       `xml:"driver"`
	Auth         *DomainDiskAuth         `xml:"auth"`
	Source       *DomainDiskSource       `xml:"source"`
	BackingStore *DomainDiskBackingStore `xml:"backingStore"`
	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"`
	Alias        *DomainAlias            `xml:"alias"`
	Address      *DomainAddress          `xml:"address"`
}

func (*DomainDisk) Marshal 

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

func (*DomainDisk) MarshalXML 

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

func (*DomainDisk) Unmarshal 

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

func (*DomainDisk) UnmarshalXML 

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

type DomainDiskAuth 

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

type DomainDiskBackingStore 

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

func (*DomainDiskBackingStore) MarshalXML 

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

func (*DomainDiskBackingStore) UnmarshalXML 

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

type DomainDiskBlockIO 

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

type DomainDiskDriver 

type DomainDiskDriver struct {
	Name         string `xml:"name,attr,omitempty"`
	Type         string `xml:"type,attr,omitempty"`
	Cache        string `xml:"cache,attr,omitempty"`
	ErrorPolicy  string `xml:"error_policy,attr,omitempty"`
	RErrorPolicy string `xml:"rerror_policy,attr,omitempty"`
	IO           string `xml:"io,attr,omitempty"`
	IOEventFD    string `xml:"ioeventfd,attr,omitempty"`
	EventIDX     string `xml:"event_idx,attr,omitempty"`
	CopyOnRead   string `xml:"copy_on_read,attr,omitempty"`
	Discard      string `xml:"discard,attr,omitempty"`
	IOThread     *uint  `xml:"iothread,attr"`
	DetectZeros  string `xml:"detect_zeroes,attr,omitempty"`
	Queues       *uint  `xml:"queues,attr"`
	IOMMU        string `xml:"iommu,attr,omitempty"`
	ATS          string `xml:"ats,attr,omitempty"`
}

type DomainDiskEncryption 

type DomainDiskEncryption struct {
	Format string            `xml:"format,attr,omitempty"`
	Secret *DomainDiskSecret `xml:"secret"`
}

type DomainDiskFormat 

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

type DomainDiskGeometry 

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

type DomainDiskIOTune 

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

type 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 DomainDiskSource 

type DomainDiskSource struct {
	File          *DomainDiskSourceFile    `xml:"-"`
	Block         *DomainDiskSourceBlock   `xml:"-"`
	Dir           *DomainDiskSourceDir     `xml:"-"`
	Network       *DomainDiskSourceNetwork `xml:"-"`
	Volume        *DomainDiskSourceVolume  `xml:"-"`
	StartupPolicy string                   `xml:"startupPolicy,attr,omitempty"`
	Index         uint                     `xml:"index,attr,omitempty"`
	Encryption    *DomainDiskEncryption    `xml:"encryption"`
	Reservations  *DomainDiskReservations  `xml:"reservations"`
}

func (*DomainDiskSource) MarshalXML 

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

func (*DomainDiskSource) UnmarshalXML 

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

type DomainDiskSourceBlock 

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

type DomainDiskSourceDir 

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

type DomainDiskSourceFile 

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

type DomainDiskSourceHost 

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

type DomainDiskSourceNetwork 

type DomainDiskSourceNetwork struct {
	Protocol  string                            `xml:"protocol,attr,omitempty"`
	Name      string                            `xml:"name,attr,omitempty"`
	TLS       string                            `xml:"tls,attr,omitempty"`
	Hosts     []DomainDiskSourceHost            `xml:"host"`
	Initiator *DomainDiskSourceNetworkInitiator `xml:"initiator"`
	Snapshot  *DomainDiskSourceNetworkSnapshot  `xml:"snapshot"`
	Config    *DomainDiskSourceNetworkConfig    `xml:"config"`
	Auth      *DomainDiskAuth                   `xml:"auth"`
}

type DomainDiskSourceNetworkConfig 

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

type DomainDiskSourceNetworkIQN 

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

type DomainDiskSourceNetworkInitiator 

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

type DomainDiskSourceNetworkSnapshot 

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

type DomainDiskTransient 

type DomainDiskTransient struct {
}

type DomainFeature 

type DomainFeature struct {
}

type DomainFeatureAPIC 

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

type DomainFeatureCapabilities 

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

type DomainFeatureCapability 

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

type DomainFeatureGIC 

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

type DomainFeatureHPT 

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

type DomainFeatureHPTPageSize 

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

type DomainFeatureHyperV 

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

type DomainFeatureHyperVSpinlocks 

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

type DomainFeatureHyperVVendorId 

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

type DomainFeatureIOAPIC 

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

type DomainFeatureKVM 

type DomainFeatureKVM struct {
	Hidden *DomainFeatureState `xml:"hidden"`
}

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

type DomainFeatureMSRS 

type DomainFeatureMSRS struct {
	Unknown string `xml:"unknown,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 DomainFilesystem 

type DomainFilesystem struct {
	XMLName        xml.Name                        `xml:"filesystem"`
	AccessMode     string                          `xml:"accessmode,attr,omitempty"`
	Model          string                          `xml:"model,attr,omitempty"`
	Driver         *DomainFilesystemDriver         `xml:"driver"`
	Source         *DomainFilesystemSource         `xml:"source"`
	Target         *DomainFilesystemTarget         `xml:"target"`
	ReadOnly       *DomainFilesystemReadOnly       `xml:"readonly"`
	SpaceHardLimit *DomainFilesystemSpaceHardLimit `xml:"space_hard_limit"`
	SpaceSoftLimit *DomainFilesystemSpaceSoftLimit `xml:"space_soft_limit"`
	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 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"`
}

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

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

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 DomainGraphicChannel 

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

type DomainGraphicDesktop 

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

type DomainGraphicEGLHeadless 

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

type DomainGraphicEGLHeadlessGL 

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

type DomainGraphicFileTransfer 

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

type DomainGraphicListener 

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

func (*DomainGraphicListener) MarshalXML 

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

func (*DomainGraphicListener) UnmarshalXML 

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

type DomainGraphicListenerAddress 

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

type DomainGraphicListenerNetwork 

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

type DomainGraphicListenerSocket 

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

type DomainGraphicRDP 

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

type DomainGraphicSDL 

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

type DomainGraphicSpice 

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

type DomainGraphicSpiceChannel 

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

type DomainGraphicSpiceClipBoard 

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

type DomainGraphicSpiceFileTransfer 

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

type DomainGraphicSpiceGL 

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

type DomainGraphicSpiceImage 

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

type DomainGraphicSpiceJPEG 

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

type DomainGraphicSpiceMouse 

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

type DomainGraphicSpicePlayback 

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

type DomainGraphicSpiceStreaming 

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

type DomainGraphicSpiceZLib 

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

type DomainGraphicVNC 

type DomainGraphicVNC struct {
	Socket        string                  `xml:"socket,attr,omitempty"`
	Port          int                     `xml:"port,attr,omitempty"`
	AutoPort      string                  `xml:"autoport,attr,omitempty"`
	WebSocket     int                     `xml:"websocket,attr,omitempty"`
	Keymap        string                  `xml:"keymap,attr,omitempty"`
	SharePolicy   string                  `xml:"sharePolicy,attr,omitempty"`
	Passwd        string                  `xml:"passwd,attr,omitempty"`
	PasswdValidTo string                  `xml:"passwdValidTo,attr,omitempty"`
	Connected     string                  `xml:"connected,attr,omitempty"`
	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"`
	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"`
	Source  *DomainHostdevSubsysMDevSource `xml:"source"`
}

type DomainHostdevSubsysMDevSource 

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

type DomainHostdevSubsysPCI 

type DomainHostdevSubsysPCI struct {
	Driver *DomainHostdevSubsysPCIDriver `xml:"driver"`
	Source *DomainHostdevSubsysPCISource `xml:"source"`
}

type DomainHostdevSubsysPCIDriver 

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

type DomainHostdevSubsysPCISource 

type DomainHostdevSubsysPCISource struct {
	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 DomainHostdevSubsysSCSISourceISCSI 

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

type DomainHostdevSubsysUSB 

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

type DomainHostdevSubsysUSBSource 

type DomainHostdevSubsysUSBSource struct {
	Address *DomainAddressUSB `xml:"address"`
}

type DomainHub 

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

type DomainIDMap 

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

type DomainIDMapRange 

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

type DomainIOMMU 

type DomainIOMMU struct {
	Model  string             `xml:"model,attr"`
	Driver *DomainIOMMUDriver `xml:"driver"`
}

type DomainIOMMUDriver 

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

type DomainIOThread 

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

type DomainIOThreadIDs 

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

type DomainIP 

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

type DomainInput 

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

func (*DomainInput) Marshal 

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

func (*DomainInput) Unmarshal 

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

type DomainInputDriver 

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

type DomainInputSource 

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

type DomainInterface 

type DomainInterface struct {
	XMLName             xml.Name                    `xml:"interface"`
	Managed             string                      `xml:"managed,attr,omitempty"`
	TrustGuestRXFilters string                      `xml:"trustGuestRxFilters,attr,omitempty"`
	MAC                 *DomainInterfaceMAC         `xml:"mac"`
	Source              *DomainInterfaceSource      `xml:"source"`
	Boot                *DomainDeviceBoot           `xml:"boot"`
	VLan                *DomainInterfaceVLan        `xml:"vlan"`
	VirtualPort         *DomainInterfaceVirtualPort `xml:"virtualport"`
	IP                  []DomainInterfaceIP         `xml:"ip"`
	Route               []DomainInterfaceRoute      `xml:"route"`
	Script              *DomainInterfaceScript      `xml:"script"`
	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"`
	Link                *DomainInterfaceLink        `xml:"link"`
	MTU                 *DomainInterfaceMTU         `xml:"mtu"`
	Bandwidth           *DomainInterfaceBandwidth   `xml:"bandwidth"`
	Coalesce            *DomainInterfaceCoalesce    `xml:"coalesce"`
	ROM                 *DomainROM                  `xml:"rom"`
	Alias               *DomainAlias                `xml:"alias"`
	Address             *DomainAddress              `xml:"address"`
}

func (*DomainInterface) Marshal 

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

func (*DomainInterface) MarshalXML 

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

func (*DomainInterface) Unmarshal 

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

func (*DomainInterface) UnmarshalXML 

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

type DomainInterfaceBackend 

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

type DomainInterfaceBandwidth 

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

type DomainInterfaceBandwidthParams 

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

type DomainInterfaceCoalesce 

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

type DomainInterfaceCoalesceRX 

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

type DomainInterfaceCoalesceRXFrames 

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

type DomainInterfaceDriver 

type DomainInterfaceDriver struct {
	Name        string                      `xml:"name,attr,omitempty"`
	TXMode      string                      `xml:"txmode,attr,omitempty"`
	IOEventFD   string                      `xml:"ioeventfd,attr,omitempty"`
	EventIDX    string                      `xml:"event_idx,attr,omitempty"`
	Queues      uint                        `xml:"queues,attr,omitempty"`
	RXQueueSize uint                        `xml:"rx_queue_size,attr,omitempty"`
	TXQueueSize uint                        `xml:"tx_queue_size,attr,omitempty"`
	IOMMU       string                      `xml:"iommu,attr,omitempty"`
	ATS         string                      `xml:"ats,attr,omitempty"`
	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 DomainInterfaceMTU 

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

type DomainInterfaceModel 

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

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

func (*DomainInterfaceSource) MarshalXML 

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

func (*DomainInterfaceSource) UnmarshalXML 

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

type DomainInterfaceSourceBridge 

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

type DomainInterfaceSourceClient 

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

type DomainInterfaceSourceDirect 

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

type DomainInterfaceSourceEthernet 

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

type DomainInterfaceSourceHostdev 

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

func (*DomainInterfaceSourceHostdev) MarshalXML 

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

func (*DomainInterfaceSourceHostdev) UnmarshalXML 

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

type DomainInterfaceSourceInternal 

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

type DomainInterfaceSourceLocal 

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

type DomainInterfaceSourceMCast 

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

type DomainInterfaceSourceNetwork 

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

type DomainInterfaceSourceServer 

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

type DomainInterfaceSourceUDP 

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

type DomainInterfaceSourceUser 

type DomainInterfaceSourceUser struct {
}

type DomainInterfaceTarget 

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

type DomainInterfaceTune 

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

type DomainInterfaceVLan 

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

type DomainInterfaceVLanTag 

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

type DomainInterfaceVirtualPort 

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

func (*DomainInterfaceVirtualPort) MarshalXML 

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

func (*DomainInterfaceVirtualPort) UnmarshalXML 

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

type DomainInterfaceVirtualPortParams 

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

func (*DomainInterfaceVirtualPortParams) MarshalXML 

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

func (*DomainInterfaceVirtualPortParams) UnmarshalXML 

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

type DomainInterfaceVirtualPortParamsAny 

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

type DomainInterfaceVirtualPortParamsMidoNet 

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

type DomainInterfaceVirtualPortParamsOpenVSwitch 

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

type DomainInterfaceVirtualPortParamsVEPA8021QBG 

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

type DomainInterfaceVirtualPortParamsVNTag8021QBH 

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

type DomainKeyWrap 

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

type DomainKeyWrapCipher 

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

type DomainLXCNamespace 

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

type DomainLXCNamespaceMap 

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

type DomainLaunchSecurity 

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

func (*DomainLaunchSecurity) MarshalXML 

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

func (*DomainLaunchSecurity) UnmarshalXML 

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

type DomainLaunchSecuritySEV 

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

func (*DomainLaunchSecuritySEV) MarshalXML 

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

func (*DomainLaunchSecuritySEV) UnmarshalXML 

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

type DomainLease 

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

type DomainLeaseTarget 

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

type DomainLoader 

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

type DomainMaxMemory 

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

type DomainMemBalloon 

type DomainMemBalloon struct {
	XMLName     xml.Name                `xml:"memballoon"`
	Model       string                  `xml:"model,attr"`
	AutoDeflate string                  `xml:"autodeflate,attr,omitempty"`
	Driver      *DomainMemBalloonDriver `xml:"driver"`
	Stats       *DomainMemBalloonStats  `xml:"stats"`
	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"`
}

type DomainMemBalloonStats 

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

type DomainMemory 

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

type DomainMemoryAccess 

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

type DomainMemoryAllocation 

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

type DomainMemoryBacking 

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

type DomainMemoryDiscard 

type DomainMemoryDiscard struct {
}

type DomainMemoryHugepage 

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

type DomainMemoryHugepages 

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

type DomainMemoryLocked 

type DomainMemoryLocked struct {
}

type DomainMemoryNosharepages 

type DomainMemoryNosharepages struct {
}

type DomainMemorySource 

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

type DomainMemoryTune 

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

type DomainMemoryTuneLimit 

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

type DomainMemorydev 

type DomainMemorydev struct {
	XMLName xml.Name               `xml:"memory"`
	Model   string                 `xml:"model,attr"`
	Access  string                 `xml:"access,attr,omitempty"`
	Discard string                 `xml:"discard,attr,omitempty"`
	Source  *DomainMemorydevSource `xml:"source"`
	Target  *DomainMemorydevTarget `xml:"target"`
	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 {
	Size     *DomainMemorydevTargetSize     `xml:"size"`
	Node     *DomainMemorydevTargetNode     `xml:"node"`
	Label    *DomainMemorydevTargetLabel    `xml:"label"`
	ReadOnly *DomainMemorydevTargetReadOnly `xml:"readonly"`
}

type DomainMemorydevTargetLabel 

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

type DomainMemorydevTargetNode 

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

type DomainMemorydevTargetReadOnly 

type DomainMemorydevTargetReadOnly struct {
}

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 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 {
	Alias   *DomainAlias   `xml:"alias"`
	Address *DomainAddress `xml:"address"`
}

type DomainNVRam 

type DomainNVRam struct {
	NVRam    string `xml:",chardata"`
	Template string `xml:"template,attr,omitempty"`
}

type DomainNuma 

type DomainNuma struct {
	Cell []DomainCell `xml:"cell"`
}

type DomainOS 

type DomainOS struct {
	Type        *DomainOSType      `xml:"type"`
	Firmware    string             `xml:"firmware,attr,omitempty"`
	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 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"`
	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"`
	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 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"`
	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:"-"`
}

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

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

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"`
	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"`
	Size    *DomainShmemSize   `xml:"size"`
	Model   *DomainShmemModel  `xml:"model"`
	Server  *DomainShmemServer `xml:"server"`
	MSI     *DomainShmemMSI    `xml:"msi"`
	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"`
	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"`
	Active       *uint                 `xml:"active"`
}

func (*DomainSnapshot) Marshal 

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

func (*DomainSnapshot) Unmarshal 

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

type DomainSnapshotDisk 

type DomainSnapshotDisk struct {
	Name     string                    `xml:"name,attr"`
	Snapshot string                    `xml:"snapshot,attr,omitempty"`
	Driver   *DomainSnapshotDiskDriver `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 DomainSnapshotDiskDriver 

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

type DomainSnapshotDisks 

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

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"`
	Codec   []DomainSoundCodec `xml:"codec"`
	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 DomainSoundCodec 

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

type DomainSysInfo 

type DomainSysInfo struct {
	Type       string                   `xml:"type,attr"`
	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 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"`
	Value string `xml:",chardata"`
}

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

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

type DomainTPMBackendEncryption 

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

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  uint32              `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   string `xml:"current,attr,omitempty"`
	Value     int    `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"`
	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 DomainVideo 

type DomainVideo struct {
	XMLName xml.Name           `xml:"video"`
	Model   DomainVideoModel   `xml:"model"`
	Driver  *DomainVideoDriver `xml:"driver"`
	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"`
}

type DomainVideoDriver 

type DomainVideoDriver struct {
	VGAConf string `xml:"vgaconf,attr,omitempty"`
	IOMMU   string `xml:"iommu,attr,omitempty"`
	ATS     string `xml:"ats,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"`
	Accel   *DomainVideoAccel `xml:"acceleration"`
}

type DomainWatchdog 

type DomainWatchdog struct {
	XMLName xml.Name       `xml:"watchdog"`
	Model   string         `xml:"model,attr"`
	Action  string         `xml:"action,attr,omitempty"`
	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 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"`
	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"`
}

func (*NetworkDHCPHost) Marshal 

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

func (*NetworkDHCPHost) Unmarshal 

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

type NetworkDHCPRange 

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

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

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 {
	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"`
	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 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 NetworkPortRXFilters 

type NetworkPortRXFilters struct {
	TrustGuest string `xml:"trustGuest,attr"`
}

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

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

type NodeDeviceMDevCapabilityType 

type NodeDeviceMDevCapabilityType struct {
	ID string `xml:"id,attr"`
}

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 NodeDevicePCIMDevType 

type NodeDevicePCIMDevType struct {
	ID                 string `xml:"id,attr"`
	Name               string `xml:"name"`
	DeviceAPI          string `xml:"deviceAPI"`
	AvailableInstances uint   `xml:"availableInstances"`
}

type NodeDevicePCIMDevTypesCapability 

type NodeDevicePCIMDevTypesCapability struct {
	Types []NodeDevicePCIMDevType `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
}

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 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,omitempty"`
	MaxVPorts int `xml:"maxvports,omitempty"`
}

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"`
	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 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"`
	NoCOW       *struct{}                       `xml:"nocow"`
	Features    []StorageVolumeTargetFeature    `xml:"features"`
	Encryption  *StorageEncryption              `xml:"encryption"`
}

type StorageVolumeTargetFeature 

type StorageVolumeTargetFeature struct {
	LazyRefcounts *struct{} `xml:"lazy_refcounts"`
}

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.