import "github.com/libvirt/libvirt-go-xml"
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)
capabilities.go doc.go document.go domain.go domain_capabilities.go domain_snapshot.go interface.go network.go node_device.go nwfilter.go secret.go storage_encryption.go storage_pool.go storage_vol.go xmlutil.go
type Caps struct { XMLName xml.Name `xml:"capabilities"` Host CapsHost `xml:"host"` Guests []CapsGuest `xml:"guest"` }
type CapsGuest struct { OSType string `xml:"os_type"` Arch CapsGuestArch `xml:"arch"` Features *CapsGuestFeatures `xml:"features"` }
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 struct { Type string `xml:"type,attr"` Emulator string `xml:"emulator,omitempty"` Machines []CapsGuestMachine `xml:"machine"` }
type CapsGuestFeatureACPI struct { Default string `xml:"default,attr,omitempty"` Toggle string `xml:"toggle,attr,omitempty"` }
type CapsGuestFeatureAPIC struct { Default string `xml:"default,attr,omitempty"` Toggle string `xml:"toggle,attr,omitempty"` }
type CapsGuestFeatureCPUSelection struct { }
type CapsGuestFeatureDeviceBoot struct { }
type CapsGuestFeatureDiskSnapshot struct { Default string `xml:"default,attr,omitempty"` Toggle string `xml:"toggle,attr,omitempty"` }
type CapsGuestFeatureIA64BE struct { }
type CapsGuestFeatureNonPAE struct { }
type CapsGuestFeaturePAE struct { }
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 struct { Name string `xml:",chardata"` MaxCPUs int `xml:"maxCpus,attr,omitempty"` Canonical string `xml:"canonical,attr,omitempty"` }
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 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 (c *CapsHostCPU) Marshal() (string, error)
func (c *CapsHostCPU) Unmarshal(doc string) error
type CapsHostCPUFeature struct { }
type CapsHostCPUFeatures struct { PAE *CapsHostCPUFeature `xml:"pae"` NonPAE *CapsHostCPUFeature `xml:"nonpae"` SVM *CapsHostCPUFeature `xml:"svm"` VMX *CapsHostCPUFeature `xml:"vmx"` }
type CapsHostCPUTopology struct { Sockets int `xml:"sockets,attr"` Cores int `xml:"cores,attr"` Threads int `xml:"threads,attr"` }
type CapsHostCache struct { Banks []CapsHostCacheBank `xml:"bank"` Monitor *CapsHostCacheMonitor `xml:"monitor"` }
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 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 struct { Level uint `xml:"level,attr,omitempty"` ResueThreshold uint `xml:"reuseThreshold,attr,omitempty"` MaxMonitors uint `xml:"maxMonitors,attr"` Features []CapsHostCacheMonitorFeature `xml:"feature"` }
type CapsHostMemoryBandwidth struct { Nodes []CapsHostMemoryBandwidthNode `xml:"node"` Monitor *CapsHostMemoryBandwidthMonitor `xml:"monitor"` }
type CapsHostMemoryBandwidthMonitor struct { MaxMonitors uint `xml:"maxMonitors,attr"` Features []CapsHostMemoryBandwidthMonitorFeature `xml:"feature"` }
type CapsHostMemoryBandwidthNode struct { ID uint `xml:"id,attr"` CPUs string `xml:"cpus,attr"` Control *CapsHostMemoryBandwidthNodeControl `xml:"control"` }
type CapsHostMemoryBandwidthNodeControl struct { Granularity uint `xml:"granularity,attr"` Min uint `xml:"min,attr"` MaxAllocs uint `xml:"maxAllocs,attr"` }
type CapsHostMigrationFeatures struct { Live *CapsHostMigrationLive `xml:"live"` URITransports *CapsHostMigrationURITransports `xml:"uri_transports"` }
type CapsHostMigrationLive struct { }
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 struct { Num uint `xml:"num,attr,omitempty"` CPUs []CapsHostNUMACPU `xml:"cpu"` }
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 struct { Num uint `xml:"num,attr,omitempty"` Cells []CapsHostNUMACell `xml:"cell"` }
type CapsHostNUMADistances struct { Siblings []CapsHostNUMASibling `xml:"sibling"` }
type CapsHostNUMAPageInfo struct { Size int `xml:"size,attr"` Unit string `xml:"unit,attr"` Count uint64 `xml:",chardata"` }
type CapsHostNUMATopology struct { Cells *CapsHostNUMACells `xml:"cells"` }
type CapsHostPowerManagement struct { SuspendMem *CapsHostPowerManagementMode `xml:"suspend_mem"` SuspendDisk *CapsHostPowerManagementMode `xml:"suspend_disk"` SuspendHybrid *CapsHostPowerManagementMode `xml:"suspend_hybrid"` }
type CapsHostPowerManagementMode struct { }
type CapsHostSecModel struct { Name string `xml:"model"` DOI string `xml:"doi"` Labels []CapsHostSecModelLabel `xml:"baselabel"` }
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 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.
type DomainACPI struct { Tables []DomainACPITable `xml:"table"` }
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 (a *DomainAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressCCID struct { Controller *uint `xml:"controller,attr"` Slot *uint `xml:"slot,attr"` }
func (a *DomainAddressCCID) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressCCID) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressCCW struct { CSSID *uint `xml:"cssid,attr"` SSID *uint `xml:"ssid,attr"` DevNo *uint `xml:"devno,attr"` }
func (a *DomainAddressCCW) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressCCW) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
func (a *DomainAddressDIMM) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressDIMM) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressDrive struct { Controller *uint `xml:"controller,attr"` Bus *uint `xml:"bus,attr"` Target *uint `xml:"target,attr"` Unit *uint `xml:"unit,attr"` }
func (a *DomainAddressDrive) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressDrive) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
func (a *DomainAddressISA) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressISA) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
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 (a *DomainAddressPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
func (a *DomainAddressSpaprVIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressSpaprVIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressUSB struct { Bus *uint `xml:"bus,attr"` Port string `xml:"port,attr,omitempty"` Device *uint `xml:"device,attr"` }
func (a *DomainAddressUSB) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressUSB) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressVirtioMMIO struct { }
func (a *DomainAddressVirtioMMIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressVirtioMMIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressVirtioS390 struct { }
func (a *DomainAddressVirtioS390) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressVirtioS390) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressVirtioSerial struct { Controller *uint `xml:"controller,attr"` Bus *uint `xml:"bus,attr"` Port *uint `xml:"port,attr"` }
func (a *DomainAddressVirtioSerial) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressVirtioSerial) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainAddressZPCI struct { UID *uint `xml:"uid,attr,omitempty"` FID *uint `xml:"fid,attr,omitempty"` }
func (a *DomainAddressZPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainAddressZPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
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 DomainBHyveCommandlineEnv struct { Name string `xml:"name,attr"` Value string `xml:"value,attr,omitempty"` }
type DomainBIOS struct { UseSerial string `xml:"useserial,attr,omitempty"` RebootTimeout *int `xml:"rebootTimeout,attr"` }
type DomainBlockIOTune struct { Weight uint `xml:"weight,omitempty"` Device []DomainBlockIOTuneDevice `xml:"device"` }
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 DomainBootMenu struct { Enable string `xml:"enable,attr,omitempty"` Timeout string `xml:"timeout,attr,omitempty"` }
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"` }
type DomainCPUCache struct { Level uint `xml:"level,attr,omitempty"` Mode string `xml:"mode,attr"` }
type DomainCPUCacheTune struct { VCPUs string `xml:"vcpus,attr,omitempty"` Cache []DomainCPUCacheTuneCache `xml:"cache"` Monitor []DomainCPUCacheTuneMonitor `xml:"monitor"` }
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 struct { Level uint `xml:"level,attr,omitempty"` VCPUs string `xml:"vcpus,attr,omitempty"` }
type DomainCPUFeature struct { Policy string `xml:"policy,attr,omitempty"` Name string `xml:"name,attr,omitempty"` }
type DomainCPUMemoryTune struct { VCPUs string `xml:"vcpus,attr"` Nodes []DomainCPUMemoryTuneNode `xml:"node"` }
type DomainCPUMemoryTuneNode struct { ID uint `xml:"id,attr"` Bandwidth uint `xml:"bandwidth,attr"` }
type DomainCPUModel struct { Fallback string `xml:"fallback,attr,omitempty"` Value string `xml:",chardata"` VendorID string `xml:"vendor_id,attr,omitempty"` }
type DomainCPUTopology struct { Sockets int `xml:"sockets,attr,omitempty"` Cores int `xml:"cores,attr,omitempty"` Threads int `xml:"threads,attr,omitempty"` }
type DomainCPUTune struct { 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"` IOThreadSched []DomainCPUTuneIOThreadSched `xml:"iothreadsched"` CacheTune []DomainCPUCacheTune `xml:"cachetune"` MemoryTune []DomainCPUMemoryTune `xml:"memorytune"` }*
type DomainCPUTuneIOThreadPin struct { IOThread uint `xml:"iothread,attr"` CPUSet string `xml:"cpuset,attr"` }
type DomainCPUTuneIOThreadSched struct { IOThreads string `xml:"iothreads,attr"` Scheduler string `xml:"scheduler,attr,omitempty"` Priority *int `xml:"priority,attr"` }
type DomainCPUTuneVCPUSched struct { VCPUs string `xml:"vcpus,attr"` Scheduler string `xml:"scheduler,attr,omitempty"` Priority *int `xml:"priority,attr"` }
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 (c *DomainCaps) Marshal() (string, error)
func (c *DomainCaps) Unmarshal(doc string) error
type DomainCapsCPU struct { Modes []DomainCapsCPUMode `xml:"mode"` }
type DomainCapsCPUFeature struct { Policy string `xml:"policy,attr,omitempty"` Name string `xml:"name,attr"` }
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 struct { Name string `xml:",chardata"` Usable string `xml:"usable,attr,omitempty"` Fallback string `xml:"fallback,attr,omitempty"` }
type DomainCapsDevice struct { Supported string `xml:"supported,attr"` Enums []DomainCapsEnum `xml:"enum"` }
type DomainCapsDevices struct { Disk *DomainCapsDevice `xml:"disk"` Graphics *DomainCapsDevice `xml:"graphics"` Video *DomainCapsDevice `xml:"video"` HostDev *DomainCapsDevice `xml:"hostdev"` }
type DomainCapsFeatureGIC struct { Supported string `xml:"supported,attr"` Enums []DomainCapsEnum `xml:"enum"` }
type DomainCapsFeatureSEV struct { Supported string `xml:"supported,attr"` CBitPos uint `xml:"cbitpos,omitempty"` ReducedPhysBits uint `xml:"reducedPhysBits,omitempty"` }
type DomainCapsFeatures struct { GIC *DomainCapsFeatureGIC `xml:"gic"` VMCoreInfo *DomainCapsFeatureVMCoreInfo `xml:"vmcoreinfo"` GenID *DomainCapsFeatureGenID `xml:"genid"` SEV *DomainCapsFeatureSEV `xml:"sev"` }
type DomainCapsOS struct { Supported string `xml:"supported,attr"` Loader *DomainCapsOSLoader `xml:"loader"` }
type DomainCapsOSLoader struct { Supported string `xml:"supported,attr"` Values []string `xml:"value"` Enums []DomainCapsEnum `xml:"enum"` }
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 struct { Siblings []DomainCellSibling `xml:"sibling"` }
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 (d *DomainChannel) Marshal() (string, error)
func (a *DomainChannel) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainChannel) Unmarshal(doc string) error
func (a *DomainChannel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainChannelTarget struct { VirtIO *DomainChannelTargetVirtIO `xml:"-"` Xen *DomainChannelTargetXen `xml:"-"` GuestFWD *DomainChannelTargetGuestFWD `xml:"-"` }
func (a *DomainChannelTarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainChannelTarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainChannelTargetGuestFWD struct { Address string `xml:"address,attr,omitempty"` Port string `xml:"port,attr,omitempty"` }
type DomainChannelTargetVirtIO struct { Name string `xml:"name,attr,omitempty"` State string `xml:"state,attr,omitempty"` // is guest agent connected? }
type DomainChannelTargetXen struct { Name string `xml:"name,attr,omitempty"` State string `xml:"state,attr,omitempty"` // is guest agent connected? }
type DomainChardevLog struct { File string `xml:"file,attr"` Append string `xml:"append,attr,omitempty"` }
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 (a *DomainChardevSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainChardevSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainChardevSourceDev struct { Path string `xml:"path,attr"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` }
type DomainChardevSourceFile struct { Path string `xml:"path,attr"` Append string `xml:"append,attr,omitempty"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` }
type DomainChardevSourceNMDM struct { Master string `xml:"master,attr"` Slave string `xml:"slave,attr"` }
type DomainChardevSourceNull struct { }
type DomainChardevSourcePipe struct { Path string `xml:"path,attr"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` }
type DomainChardevSourcePty struct { Path string `xml:"path,attr"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` }
type DomainChardevSourceReconnect struct { Enabled string `xml:"enabled,attr"` Timeout *uint `xml:"timeout,attr"` }
type DomainChardevSourceSpiceVMC struct { }
type DomainChardevSourceStdIO struct { }
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 struct { BindHost string `xml:"-"` BindService string `xml:"-"` ConnectHost string `xml:"-"` ConnectService string `xml:"-"` }
type DomainChardevSourceUNIX struct { Mode string `xml:"mode,attr,omitempty"` Path string `xml:"path,attr"` Reconnect *DomainChardevSourceReconnect `xml:"reconnect"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` }
type DomainChardevSourceVC struct { }
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 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 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 (d *DomainConsole) Marshal() (string, error)
func (a *DomainConsole) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainConsole) Unmarshal(doc string) error
func (a *DomainConsole) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainConsoleTarget struct { Type string `xml:"type,attr,omitempty"` Port *uint `xml:"port,attr"` }
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:"-"` Alias *DomainAlias `xml:"alias"` Address *DomainAddress `xml:"address"` }
func (d *DomainController) Marshal() (string, error)
func (a *DomainController) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainController) Unmarshal(doc string) error
func (a *DomainController) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
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 struct { Model *DomainControllerPCIModel `xml:"model"` Target *DomainControllerPCITarget `xml:"target"` Hole64 *DomainControllerPCIHole64 `xml:"pcihole64"` }
type DomainControllerPCIHole64 struct { Size uint64 `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
type DomainControllerPCITarget struct { ChassisNr *uint Chassis *uint Port *uint BusNr *uint Index *uint NUMANode *uint }
func (a *DomainControllerPCITarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainControllerPCITarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainControllerUSB struct { Port *uint `xml:"ports,attr"` Master *DomainControllerUSBMaster `xml:"master"` }
type DomainControllerVirtIOSerial struct { Ports *uint `xml:"ports,attr"` Vectors *uint `xml:"vectors,attr"` }
type DomainCurrentMemory struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
type DomainDeviceBoot struct { Order uint `xml:"order,attr"` LoadParm string `xml:"loadparm,attr,omitempty"` }
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 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 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"` 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"` *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 (d *DomainDisk) Marshal() (string, error)
func (a *DomainDisk) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainDisk) Unmarshal(doc string) error
func (a *DomainDisk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainDiskAuth struct { Username string `xml:"username,attr,omitempty"` Secret *DomainDiskSecret `xml:"secret"` }
type DomainDiskBackingStore struct { Index uint `xml:"index,attr,omitempty"` Format *DomainDiskFormat `xml:"format"` Source *DomainDiskSource `xml:"source"` BackingStore *DomainDiskBackingStore `xml:"backingStore"` }
func (a *DomainDiskBackingStore) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainDiskBackingStore) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainDiskBlockIO struct { LogicalBlockSize uint `xml:"logical_block_size,attr,omitempty"` PhysicalBlockSize uint `xml:"physical_block_size,attr,omitempty"` }
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 struct { Format string `xml:"format,attr,omitempty"` Secret *DomainDiskSecret `xml:"secret"` }
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 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 struct { Job string `xml:"job,attr,omitempty"` Ready string `xml:"ready,attr,omitempty"` Format *DomainDiskFormat `xml:"format"` Source *DomainDiskSource `xml:"source"` }
func (a *DomainDiskMirror) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainDiskMirror) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainDiskReadOnly struct { }
type DomainDiskReservations struct { Enabled string `xml:"enabled,attr,omitempty"` Managed string `xml:"managed,attr,omitempty"` Source *DomainDiskReservationsSource `xml:"source"` }
type DomainDiskReservationsSource DomainChardevSource
func (a *DomainDiskReservationsSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainDiskReservationsSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainDiskSecret struct { Type string `xml:"type,attr,omitempty"` Usage string `xml:"usage,attr,omitempty"` UUID string `xml:"uuid,attr,omitempty"` }
type DomainDiskShareable struct { }
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 (a *DomainDiskSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainDiskSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainDiskSourceBlock struct { Dev string `xml:"dev,attr,omitempty"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` }
type DomainDiskSourceFile struct { File string `xml:"file,attr,omitempty"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` }
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 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 DomainDiskSourceNetworkInitiator struct { IQN *DomainDiskSourceNetworkIQN `xml:"iqn"` }
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 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 struct { }
type DomainFeature struct { }
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 DomainFeatureHPT struct { Resizing string `xml:"resizing,attr,omitempty"` MaxPageSize *DomainFeatureHPTPageSize `xml:"maxpagesize"` }
type DomainFeatureHPTPageSize struct { Unit string `xml:"unit,attr,omitempty"` Value string `xml:",chardata"` }
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 struct { DomainFeatureState Retries uint `xml:"retries,attr,omitempty"` }
type DomainFeatureHyperVVendorId struct { DomainFeatureState Value string `xml:"value,attr,omitempty"` }
type DomainFeatureKVM struct { Hidden *DomainFeatureState `xml:"hidden"` }
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"` }
type DomainFeatureSMM struct { State string `xml:"state,attr,omitempty"` TSeg *DomainFeatureSMMTSeg `xml:"tseg"` }
type DomainFeatureSMMTSeg struct { Unit string `xml:"unit,attr,omitempty"` Value uint `xml:",chardata"` }
type DomainFilesystem struct { XMLName xml.Name `xml:"filesystem"` AccessMode string `xml:"accessmode,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 (d *DomainFilesystem) Marshal() (string, error)
func (a *DomainFilesystem) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainFilesystem) Unmarshal(doc string) error
func (a *DomainFilesystem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
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 struct { }
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 (a *DomainFilesystemSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainFilesystemSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainFilesystemSourceRAM struct { Usage uint `xml:"usage,attr"` Units string `xml:"units,attr,omitempty"` }
type DomainFilesystemSourceVolume struct { Pool string `xml:"pool,attr"` Volume string `xml:"volume,attr"` }
type DomainFilesystemSpaceHardLimit struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
type DomainFilesystemSpaceSoftLimit struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
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 (d *DomainGraphic) Marshal() (string, error)
func (a *DomainGraphic) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainGraphic) Unmarshal(doc string) error
func (a *DomainGraphic) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainGraphicChannel struct { Name string `xml:"name,attr,omitempty"` Mode string `xml:"mode,attr,omitempty"` }
type DomainGraphicDesktop struct { Display string `xml:"display,attr,omitempty"` FullScreen string `xml:"fullscreen,attr,omitempty"` }
type DomainGraphicEGLHeadless struct { GL *DomainGraphicEGLHeadlessGL `xml:"gl"` }
type DomainGraphicListener struct { Address *DomainGraphicListenerAddress `xml:"-"` Network *DomainGraphicListenerNetwork `xml:"-"` Socket *DomainGraphicListenerSocket `xml:"-"` }
func (a *DomainGraphicListener) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainGraphicListener) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainGraphicListenerNetwork struct { Address string `xml:"address,attr,omitempty"` Network string `xml:"network,attr,omitempty"` }
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 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 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 struct { Name string `xml:"name,attr"` Mode string `xml:"mode,attr"` }
type DomainGraphicSpiceGL struct { Enable string `xml:"enable,attr,omitempty"` RenderNode string `xml:"rendernode,attr,omitempty"` }
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"` 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 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 (d *DomainHostdev) Marshal() (string, error)
func (a *DomainHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainHostdev) Unmarshal(doc string) error
func (a *DomainHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainHostdevCapsMisc struct { Source *DomainHostdevCapsMiscSource `xml:"source"` }
type DomainHostdevCapsNet struct { Source *DomainHostdevCapsNetSource `xml:"source"` IP []DomainIP `xml:"ip"` Route []DomainRoute `xml:"route"` }
type DomainHostdevCapsStorage struct { Source *DomainHostdevCapsStorageSource `xml:"source"` }
type DomainHostdevSubsysMDev struct { Model string `xml:"model,attr,omitempty"` Display string `xml:"display,attr,omitempty"` Source *DomainHostdevSubsysMDevSource `xml:"source"` }
type DomainHostdevSubsysMDevSource struct { Address *DomainAddressMDev `xml:"address"` }
type DomainHostdevSubsysPCI struct { Driver *DomainHostdevSubsysPCIDriver `xml:"driver"` Source *DomainHostdevSubsysPCISource `xml:"source"` }
type DomainHostdevSubsysPCISource struct { Address *DomainAddressPCI `xml:"address"` }
type DomainHostdevSubsysSCSI struct { SGIO string `xml:"sgio,attr,omitempty"` RawIO string `xml:"rawio,attr,omitempty"` Source *DomainHostdevSubsysSCSISource `xml:"source"` ReadOnly *DomainDiskReadOnly `xml:"readonly"` *DomainDiskShareable `xml:"shareable"` }
type DomainHostdevSubsysSCSIHost struct { Source *DomainHostdevSubsysSCSIHostSource `xml:"source"` }
type DomainHostdevSubsysSCSIHostSource struct { Protocol string `xml:"protocol,attr,omitempty"` WWPN string `xml:"wwpn,attr,omitempty"` }
type DomainHostdevSubsysSCSISource struct { Host *DomainHostdevSubsysSCSISourceHost `xml:"-"` ISCSI *DomainHostdevSubsysSCSISourceISCSI `xml:"-"` }
func (a *DomainHostdevSubsysSCSISource) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainHostdevSubsysSCSISource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainHostdevSubsysSCSISourceHost struct { Adapter *DomainHostdevSubsysSCSIAdapter `xml:"adapter"` Address *DomainAddressDrive `xml:"address"` }
type DomainHostdevSubsysSCSISourceISCSI struct { Name string `xml:"name,attr"` Host []DomainDiskSourceHost `xml:"host"` Auth *DomainDiskAuth `xml:"auth"` }
type DomainHostdevSubsysUSB struct { Source *DomainHostdevSubsysUSBSource `xml:"source"` }
type DomainHostdevSubsysUSBSource struct { Address *DomainAddressUSB `xml:"address"` }
type DomainHub struct { Type string `xml:"type,attr"` Alias *DomainAlias `xml:"alias"` Address *DomainAddress `xml:"address"` }
type DomainIDMap struct { UIDs []DomainIDMapRange `xml:"uid"` GIDs []DomainIDMapRange `xml:"gid"` }
type DomainIDMapRange struct { Start uint `xml:"start,attr"` Target uint `xml:"target,attr"` Count uint `xml:"count,attr"` }
type DomainIOMMU struct { Model string `xml:"model,attr"` Driver *DomainIOMMUDriver `xml:"driver"` }
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 DomainIOThreadIDs struct { IOThreads []DomainIOThread `xml:"iothread"` }
type DomainIP struct { Address string `xml:"address,attr,omitempty"` Family string `xml:"family,attr,omitempty"` Prefix *uint `xml:"prefix,attr"` }
type DomainInput struct { XMLName xml.Name `xml:"input"` Type string `xml:"type,attr"` Bus string `xml:"bus,attr,omitempty"` Driver *DomainInputDriver `xml:"driver"` Source *DomainInputSource `xml:"source"` Alias *DomainAlias `xml:"alias"` Address *DomainAddress `xml:"address"` }
func (d *DomainInput) Marshal() (string, error)
func (d *DomainInput) Unmarshal(doc string) error
type DomainInputDriver struct { IOMMU string `xml:"iommu,attr,omitempty"` ATS string `xml:"ats,attr,omitempty"` }
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 (d *DomainInterface) Marshal() (string, error)
func (a *DomainInterface) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainInterface) Unmarshal(doc string) error
func (a *DomainInterface) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainInterfaceBackend struct { Tap string `xml:"tap,attr,omitempty"` VHost string `xml:"vhost,attr,omitempty"` }
type DomainInterfaceBandwidth struct { Inbound *DomainInterfaceBandwidthParams `xml:"inbound"` Outbound *DomainInterfaceBandwidthParams `xml:"outbound"` }
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 struct { RX *DomainInterfaceCoalesceRX `xml:"rx"` }
type DomainInterfaceCoalesceRX struct { Frames *DomainInterfaceCoalesceRXFrames `xml:"frames"` }
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 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 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 struct { Name string `xml:"name,attr"` Value string `xml:"value,attr"` }
type DomainInterfaceFilterRef struct { Filter string `xml:"filter,attr"` Parameters []DomainInterfaceFilterParam `xml:"parameter"` }
type DomainInterfaceGuest struct { Dev string `xml:"dev,attr,omitempty"` Actual string `xml:"actual,attr,omitempty"` }
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 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 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 (a *DomainInterfaceSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainInterfaceSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainInterfaceSourceClient struct { Address string `xml:"address,attr,omitempty"` Port uint `xml:"port,attr,omitempty"` Local *DomainInterfaceSourceLocal `xml:"local"` }
type DomainInterfaceSourceDirect struct { Dev string `xml:"dev,attr,omitempty"` Mode string `xml:"mode,attr,omitempty"` }
type DomainInterfaceSourceEthernet struct { IP []DomainInterfaceIP `xml:"ip"` Route []DomainInterfaceRoute `xml:"route"` }
type DomainInterfaceSourceHostdev struct { PCI *DomainHostdevSubsysPCISource `xml:"-"` USB *DomainHostdevSubsysUSBSource `xml:"-"` }
func (a *DomainInterfaceSourceHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainInterfaceSourceHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainInterfaceSourceLocal struct { Address string `xml:"address,attr,omitempty"` Port uint `xml:"port,attr,omitempty"` }
type DomainInterfaceSourceMCast struct { Address string `xml:"address,attr,omitempty"` Port uint `xml:"port,attr,omitempty"` Local *DomainInterfaceSourceLocal `xml:"local"` }
type DomainInterfaceSourceNetwork struct { Network string `xml:"network,attr,omitempty"` PortGroup string `xml:"portgroup,attr,omitempty"` Bridge string `xml:"bridge,attr,omitempty"` }
type DomainInterfaceSourceServer struct { Address string `xml:"address,attr,omitempty"` Port uint `xml:"port,attr,omitempty"` Local *DomainInterfaceSourceLocal `xml:"local"` }
type DomainInterfaceSourceUDP struct { Address string `xml:"address,attr,omitempty"` Port uint `xml:"port,attr,omitempty"` Local *DomainInterfaceSourceLocal `xml:"local"` }
type DomainInterfaceSourceUser struct { }
type DomainInterfaceVLan struct { Trunk string `xml:"trunk,attr,omitempty"` Tags []DomainInterfaceVLanTag `xml:"tag"` }
type DomainInterfaceVLanTag struct { ID uint `xml:"id,attr"` NativeMode string `xml:"nativeMode,attr,omitempty"` }
type DomainInterfaceVirtualPort struct { Params *DomainInterfaceVirtualPortParams `xml:"parameters"` }
func (a *DomainInterfaceVirtualPort) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainInterfaceVirtualPort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainInterfaceVirtualPortParams struct { Any *DomainInterfaceVirtualPortParamsAny `xml:"-"` VEPA8021QBG *DomainInterfaceVirtualPortParamsVEPA8021QBG `xml:"-"` VNTag8011QBH *DomainInterfaceVirtualPortParamsVNTag8021QBH `xml:"-"` OpenVSwitch *DomainInterfaceVirtualPortParamsOpenVSwitch `xml:"-"` MidoNet *DomainInterfaceVirtualPortParamsMidoNet `xml:"-"` }
func (a *DomainInterfaceVirtualPortParams) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainInterfaceVirtualPortParams) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
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 struct { InterfaceID string `xml:"interfaceid,attr,omitempty"` }
type DomainInterfaceVirtualPortParamsOpenVSwitch struct { InterfaceID string `xml:"interfaceid,attr,omitempty"` ProfileID string `xml:"profileid,attr,omitempty"` }
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 struct { ProfileID string `xml:"profileid,attr,omitempty"` }
type DomainKeyWrap struct { Ciphers []DomainKeyWrapCipher `xml:"cipher"` }
type DomainLXCNamespace struct { XMLName xml.Name `xml:"http://libvirt.org/schemas/domain/lxc/1.0 namespace"` *DomainLXCNamespaceMap `xml:"sharenet"` *DomainLXCNamespaceMap `xml:"shareipc"` *DomainLXCNamespaceMap `xml:"shareuts"` }
type DomainLXCNamespaceMap struct { Type string `xml:"type,attr"` Value string `xml:"value,attr"` }
type DomainLaunchSecurity struct { SEV *DomainLaunchSecuritySEV `xml:"-"` }
func (a *DomainLaunchSecurity) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainLaunchSecurity) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainLaunchSecuritySEV struct { CBitPos *uint `xml:"cbitpos"` ReducedPhysBits *uint `xml:"reducedPhysBits"` Policy *uint `xml:"policy"` DHCert string `xml:"dhCert"` Session string `xml:"sesion"` }
func (a *DomainLaunchSecuritySEV) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainLaunchSecuritySEV) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainLease struct { Lockspace string `xml:"lockspace"` Key string `xml:"key"` Target *DomainLeaseTarget `xml:"target"` }
type DomainLeaseTarget struct { Path string `xml:"path,attr"` Offset uint64 `xml:"offset,attr,omitempty"` }
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 struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` Slots uint `xml:"slots,attr,omitempty"` }
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 (d *DomainMemBalloon) Marshal() (string, error)
func (d *DomainMemBalloon) Unmarshal(doc string) error
type DomainMemBalloonDriver struct { IOMMU string `xml:"iommu,attr,omitempty"` ATS string `xml:"ats,attr,omitempty"` }
type DomainMemory struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` DumpCore string `xml:"dumpCore,attr,omitempty"` }
type DomainMemoryBacking struct { MemoryHugePages *DomainMemoryHugepages `xml:"hugepages"` *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 struct { }
type DomainMemoryHugepage struct { Size uint `xml:"size,attr"` Unit string `xml:"unit,attr,omitempty"` Nodeset string `xml:"nodeset,attr,omitempty"` }
type DomainMemoryHugepages struct { Hugepages []DomainMemoryHugepage `xml:"page"` }
type DomainMemoryLocked struct { }
type DomainMemoryNosharepages struct { }
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 struct { Value uint64 `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
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 (d *DomainMemorydev) Marshal() (string, error)
func (d *DomainMemorydev) Unmarshal(doc string) error
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 struct { Value uint64 `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
type DomainMemorydevSourcePMem struct { }
type DomainMemorydevSourcePagesize struct { Value uint64 `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
type DomainMemorydevTarget struct { Size *DomainMemorydevTargetSize `xml:"size"` Node *DomainMemorydevTargetNode `xml:"node"` Label *DomainMemorydevTargetLabel `xml:"label"` ReadOnly *DomainMemorydevTargetReadOnly `xml:"readonly"` }
type DomainMemorydevTargetLabel struct { Size *DomainMemorydevTargetSize `xml:"size"` }
type DomainMemorydevTargetReadOnly struct { }
type DomainMemorydevTargetSize struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
type DomainNUMATune struct { Memory *DomainNUMATuneMemory `xml:"memory"` MemNodes []DomainNUMATuneMemNode `xml:"memnode"` }
type DomainNUMATuneMemNode struct { CellID uint `xml:"cellid,attr"` Mode string `xml:"mode,attr"` Nodeset string `xml:"nodeset,attr"` }
type DomainNUMATuneMemory struct { Mode string `xml:"mode,attr,omitempty"` Nodeset string `xml:"nodeset,attr,omitempty"` Placement string `xml:"placement,attr,omitempty"` }
type DomainNVRAM struct { Alias *DomainAlias `xml:"alias"` Address *DomainAddress `xml:"address"` }
type DomainNVRam struct { NVRam string `xml:",chardata"` Template string `xml:"template,attr,omitempty"` }
type DomainNuma struct { Cell []DomainCell `xml:"cell"` }
type DomainOS struct { Type *DomainOSType `xml:"type"` 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 DomainOSType struct { Arch string `xml:"arch,attr,omitempty"` Machine string `xml:"machine,attr,omitempty"` Type string `xml:",chardata"` }
type DomainPM struct { SuspendToMem *DomainPMPolicy `xml:"suspend-to-mem"` SuspendToDisk *DomainPMPolicy `xml:"suspend-to-disk"` }
type DomainPanic struct { XMLName xml.Name `xml:"panic"` Model string `xml:"model,attr,omitempty"` Alias *DomainAlias `xml:"alias"` Address *DomainAddress `xml:"address"` }
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 (d *DomainParallel) Marshal() (string, error)
func (a *DomainParallel) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainParallel) Unmarshal(doc string) error
func (a *DomainParallel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainParallelTarget struct { Type string `xml:"type,attr,omitempty"` Port *uint `xml:"port,attr"` }
type DomainPerf struct { Events []DomainPerfEvent `xml:"event"` }
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 DomainQEMUCommandlineEnv struct { Name string `xml:"name,attr"` Value string `xml:"value,attr,omitempty"` }
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"` }
type DomainRNGBackend struct { Random *DomainRNGBackendRandom `xml:"-"` EGD *DomainRNGBackendEGD `xml:"-"` }
func (a *DomainRNGBackend) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainRNGBackend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainRNGBackendEGD struct { Source *DomainChardevSource `xml:"source"` Protocol *DomainChardevProtocol `xml:"protocol"` }
func (a *DomainRNGBackendEGD) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainRNGBackendEGD) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainRNGDriver struct { IOMMU string `xml:"iommu,attr,omitempty"` ATS string `xml:"ats,attr,omitempty"` }
type DomainRNGRate struct { Bytes uint `xml:"bytes,attr"` Period uint `xml:"period,attr,omitempty"` }
type DomainROM struct { Bar string `xml:"bar,attr,omitempty"` File string `xml:"file,attr,omitempty"` Enabled string `xml:"enabled,attr,omitempty"` }
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 (d *DomainRedirDev) Marshal() (string, error)
func (a *DomainRedirDev) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainRedirDev) Unmarshal(doc string) error
func (a *DomainRedirDev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainRedirFilter struct { USB []DomainRedirFilterUSB `xml:"usbdev"` }
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 (a *DomainRedirFilterUSB) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainRedirFilterUSB) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainRoute struct { Family string `xml:"family,attr,omitempty"` Address string `xml:"address,attr,omitempty"` Gateway string `xml:"gateway,attr,omitempty"` }
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 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 (d *DomainSerial) Marshal() (string, error)
func (a *DomainSerial) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainSerial) Unmarshal(doc string) error
func (a *DomainSerial) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainSerialTarget struct { Type string `xml:"type,attr,omitempty"` Port *uint `xml:"port,attr"` Model *DomainSerialTargetModel `xml:"model"` }
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 (d *DomainShmem) Marshal() (string, error)
func (d *DomainShmem) Unmarshal(doc string) error
type DomainShmemMSI struct { Enabled string `xml:"enabled,attr,omitempty"` Vectors uint `xml:"vectors,attr,omitempty"` IOEventFD string `xml:"ioeventfd,attr,omitempty"` }
type DomainShmemSize struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` }
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 (d *DomainSmartcard) Marshal() (string, error)
func (a *DomainSmartcard) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (d *DomainSmartcard) Unmarshal(doc string) error
func (a *DomainSmartcard) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainSmartcardHost struct { }
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 (s *DomainSnapshot) Marshal() (string, error)
func (s *DomainSnapshot) Unmarshal(doc string) error
type DomainSnapshotDisk struct { Name string `xml:"name,attr"` Snapshot string `xml:"snapshot,attr,omitempty"` Driver *DomainSnapshotDiskDriver `xml:"driver"` Source *DomainDiskSource `xml:"source"` }
func (a *DomainSnapshotDisk) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainSnapshotDisk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainSnapshotDisks struct { Disks []DomainSnapshotDisk `xml:"disk"` }
type DomainSnapshotMemory struct { Snapshot string `xml:"snapshot,attr"` File string `xml:"file,attr,omitempty"` }
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 (d *DomainSound) Marshal() (string, error)
func (d *DomainSound) Unmarshal(doc string) error
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 struct { Entry []DomainSysInfoEntry `xml:"entry"` }
type DomainSysInfoBaseBoard struct { Entry []DomainSysInfoEntry `xml:"entry"` }
type DomainSysInfoChassis struct { Entry []DomainSysInfoEntry `xml:"entry"` }
type DomainSysInfoMemory struct { Entry []DomainSysInfoEntry `xml:"entry"` }
type DomainSysInfoProcessor struct { Entry []DomainSysInfoEntry `xml:"entry"` }
type DomainSysInfoSystem struct { Entry []DomainSysInfoEntry `xml:"entry"` }
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"` }
type DomainTPMBackend struct { Passthrough *DomainTPMBackendPassthrough `xml:"-"` Emulator *DomainTPMBackendEmulator `xml:"-"` }
func (a *DomainTPMBackend) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *DomainTPMBackend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type DomainTPMBackendPassthrough struct { Device *DomainTPMBackendDevice `xml:"device"` }
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 struct { Threshold uint `xml:"threshold,attr,omitempty"` Slew uint `xml:"slew,attr,omitempty"` Limit uint `xml:"limit,attr,omitempty"` }
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 struct { VCPU []DomainVCPUsVCPU `xml:"vcpu"` }
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 struct { XMLName xml.Name `xml:"http://libvirt.org/schemas/domain/vmware/1.0 datacenterpath"` Value string `xml:",chardata"` }
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 (d *DomainVSock) Marshal() (string, error)
func (d *DomainVSock) Unmarshal(doc string) error
type DomainVSockCID struct { Auto string `xml:"auto,attr,omitempty"` Address string `xml:"address,attr,omitempty"` }
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 (d *DomainVideo) Marshal() (string, error)
func (d *DomainVideo) Unmarshal(doc string) error
type DomainVideoAccel struct { Accel3D string `xml:"accel3d,attr,omitempty"` Accel2D string `xml:"accel2d,attr,omitempty"` }
type DomainVideoDriver struct { VGAConf string `xml:"vgaconf,attr,omitempty"` IOMMU string `xml:"iommu,attr,omitempty"` ATS string `xml:"ats,attr,omitempty"` }
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 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 (d *DomainWatchdog) Marshal() (string, error)
func (d *DomainWatchdog) Unmarshal(doc string) error
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"` }
type InterfaceAutoConf struct { }
type InterfaceBond struct { Mode string `xml:"mode,attr,omitempty"` ARPMon *InterfaceBondARPMon `xml:"arpmon"` MIIMon *InterfaceBondMIIMon `xml:"miimon"` Interfaces []Interface `xml:"interface"` }
type InterfaceBondARPMon struct { Interval uint `xml:"interval,attr,omitempty"` Target string `xml:"target,attr,omitempty"` Validate string `xml:"validate,attr,omitempty"` }
type InterfaceBondMIIMon struct { Freq uint `xml:"freq,attr,omitempty"` UpDelay uint `xml:"updelay,attr,omitempty"` Carrier string `xml:"carrier,attr,omitempty"` }
type InterfaceBridge struct { STP string `xml:"stp,attr,omitempty"` Delay *float64 `xml:"delay,attr"` Interfaces []Interface `xml:"interface"` }
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 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 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 }
type NWFilterEntry struct { Rule *NWFilterRule Ref *NWFilterRef }
func (s *NWFilterField) UnmarshalXMLAttr(attr xml.Attr) error
type NWFilterRef struct { Filter string `xml:"filter,attr"` Parameters []NWFilterParameter `xml:"parameter"` }
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 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleAHIPv6 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
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 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleAllIPv6 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
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 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 struct { SrcPortStart NWFilterField `xml:"srcportstart,attr"` SrcPortEnd NWFilterField `xml:"srcportend,attr"` DstPortStart NWFilterField `xml:"dstportstart,attr"` DstPortEnd NWFilterField `xml:"dstportend,attr"` }
type NWFilterRuleESP struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleESPIPv6 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
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 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 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
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 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 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonMAC ProtocolID NWFilterField `xml:"protocolid,attr,omitempty"` Comment string `xml:"comment,attr,omitempty"` }
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 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP NWFilterRuleCommonPort Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleSCTPIPv6 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP NWFilterRuleCommonPort Comment string `xml:"comment,attr,omitempty"` }
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 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 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP NWFilterRuleCommonPort Option NWFilterField `xml:"option,attr"` Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleUDP struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP NWFilterRuleCommonPort Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleUDPIPv6 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP NWFilterRuleCommonPort Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleUDPLite struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
type NWFilterRuleUDPLiteIPv6 struct { Match string `xml:"match,attr,omitempty"` NWFilterRuleCommonIP Comment string `xml:"comment,attr,omitempty"` }
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 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"` }
type NetworkBandwidth struct { Inbound *NetworkBandwidthParams `xml:"inbound"` Outbound *NetworkBandwidthParams `xml:"outbound"` }
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 struct { File string `xml:"file,attr,omitempty"` Server string `xml:"server,attr,omitempty"` }
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 struct { Ranges []NetworkDHCPRange `xml:"range"` Hosts []NetworkDHCPHost `xml:"host"` Bootp []NetworkBootp `xml:"bootp"` }
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 (s *NetworkDHCPHost) Marshal() (string, error)
func (s *NetworkDHCPHost) Unmarshal(doc string) error
type NetworkDHCPRange struct { XMLName xml.Name `xml:"range"` Start string `xml:"start,attr,omitempty"` End string `xml:"end,attr,omitempty"` }
func (s *NetworkDHCPRange) Marshal() (string, error)
func (s *NetworkDHCPRange) Unmarshal(doc string) error
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 struct { Domain string `xml:"domain,attr,omitempty"` Addr string `xml:"addr,attr,omitempty"` }
type NetworkDNSHost struct { XMLName xml.Name `xml:"host"` IP string `xml:"ip,attr"` Hostnames []NetworkDNSHostHostname `xml:"hostname"` }
func (s *NetworkDNSHost) Marshal() (string, error)
func (s *NetworkDNSHost) Unmarshal(doc string) error
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 (s *NetworkDNSSRV) Marshal() (string, error)
func (s *NetworkDNSSRV) Unmarshal(doc string) error
type NetworkDNSTXT struct { XMLName xml.Name `xml:"txt"` Name string `xml:"name,attr"` Value string `xml:"value,attr"` }
func (s *NetworkDNSTXT) Marshal() (string, error)
func (s *NetworkDNSTXT) Unmarshal(doc string) error
type NetworkDomain struct { Name string `xml:"name,attr,omitempty"` LocalOnly string `xml:"localOnly,attr,omitempty"` }
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 struct { PCI *NetworkForwardAddressPCI `xml:"-"` }
func (a *NetworkForwardAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *NetworkForwardAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NetworkForwardAddressPCI struct { Domain *uint `xml:"domain,attr"` Bus *uint `xml:"bus,attr"` Slot *uint `xml:"slot,attr"` Function *uint `xml:"function,attr"` }
func (a *NetworkForwardAddressPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *NetworkForwardAddressPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NetworkForwardInterface struct { XMLName xml.Name `xml:"interface"` Dev string `xml:"dev,attr,omitempty"` }
func (s *NetworkForwardInterface) Marshal() (string, error)
func (s *NetworkForwardInterface) Unmarshal(doc string) error
type NetworkForwardNAT struct { Addresses []NetworkForwardNATAddress `xml:"address"` Ports []NetworkForwardNATPort `xml:"port"` }
type NetworkForwardNATAddress struct { Start string `xml:"start,attr"` End string `xml:"end,attr"` }
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 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 (s *NetworkPortGroup) Marshal() (string, error)
func (s *NetworkPortGroup) Unmarshal(doc string) error
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 NetworkVLAN struct { Trunk string `xml:"trunk,attr,omitempty"` Tags []NetworkVLANTag `xml:"tag"` }
type NetworkVLANTag struct { ID uint `xml:"id,attr"` NativeMode string `xml:"nativeMode,attr,omitempty"` }
type NetworkVirtualPort struct { Params *NetworkVirtualPortParams `xml:"parameters"` }
func (a *NetworkVirtualPort) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *NetworkVirtualPort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NetworkVirtualPortParams struct { Any *NetworkVirtualPortParamsAny `xml:"-"` VEPA8021QBG *NetworkVirtualPortParamsVEPA8021QBG `xml:"-"` VNTag8011QBH *NetworkVirtualPortParamsVNTag8021QBH `xml:"-"` OpenVSwitch *NetworkVirtualPortParamsOpenVSwitch `xml:"-"` MidoNet *NetworkVirtualPortParamsMidoNet `xml:"-"` }
func (a *NetworkVirtualPortParams) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *NetworkVirtualPortParams) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
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 struct { InterfaceID string `xml:"interfaceid,attr,omitempty"` }
type NetworkVirtualPortParamsOpenVSwitch struct { InterfaceID string `xml:"interfaceid,attr,omitempty"` ProfileID string `xml:"profileid,attr,omitempty"` }
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 struct { ProfileID string `xml:"profileid,attr,omitempty"` }
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 (c *NodeDevice) Marshal() (string, error)
func (c *NodeDevice) Unmarshal(doc string) error
type NodeDeviceCCWCapability struct { CSSID *uint `xml:"cssid"` SSID *uint `xml:"ssid"` DevNo *uint `xml:"devno"` }
func (c *NodeDeviceCCWCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (c *NodeDeviceCCWCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
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 (c *NodeDeviceCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (c *NodeDeviceCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NodeDeviceDevNode struct { Type string `xml:"type,attr,omitempty"` Path string `xml:",chardata"` }
type NodeDeviceIOMMUGroup struct { Number int `xml:"number,attr"` Address []NodeDevicePCIAddress `xml:"address"` }
type NodeDeviceMDevCapability struct { Type *NodeDeviceMDevCapabilityType `xml:"type"` IOMMUGroup *NodeDeviceIOMMUGroup `xml:"iommuGroup"` }
type NodeDeviceNet80203Capability struct { }
type NodeDeviceNet80211Capability struct { }
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 NodeDeviceNetSubCapability struct { Wireless80211 *NodeDeviceNet80211Capability Ethernet80203 *NodeDeviceNet80203Capability }
func (c *NodeDeviceNetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (c *NodeDeviceNetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NodeDevicePCIAddress struct { Domain *uint `xml:"domain,attr"` Bus *uint `xml:"bus,attr"` Slot *uint `xml:"slot,attr"` Function *uint `xml:"function,attr"` }
func (a *NodeDevicePCIAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *NodeDevicePCIAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NodeDevicePCIBridgeCapability struct { }
type NodeDevicePCICapability struct { 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 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 struct { ID string `xml:"id,attr"` Name string `xml:"name"` DeviceAPI string `xml:"deviceAPI"` AvailableInstances uint `xml:"availableInstances"` }
type NodeDevicePCIMDevTypesCapability struct { Types []NodeDevicePCIMDevType `xml:"type"` }
type NodeDevicePCIPhysFunctionCapability struct { Address NodeDevicePCIAddress `xml:"address,omitempty"` }
type NodeDevicePCISubCapability struct { VirtFunctions *NodeDevicePCIVirtFunctionsCapability PhysFunction *NodeDevicePCIPhysFunctionCapability MDevTypes *NodeDevicePCIMDevTypesCapability Bridge *NodeDevicePCIBridgeCapability }
func (c *NodeDevicePCISubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (c *NodeDevicePCISubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NodeDevicePCIVirtFunctionsCapability struct { Address []NodeDevicePCIAddress `xml:"address,omitempty"` MaxCount int `xml:"maxCount,attr,omitempty"` }
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 struct { WWNN string `xml:"wwnn,omitempty"` WWPN string `xml:"wwpn,omitempty"` FabricWWN string `xml:"fabric_wwn,omitempty"` }
type NodeDeviceSCSIFCRemotePortCapability struct { RPort string `xml:"rport"` WWPN string `xml:"wwpn"` }
type NodeDeviceSCSIHostCapability struct { Host uint `xml:"host"` UniqueID *uint `xml:"unique_id"` Capability []NodeDeviceSCSIHostSubCapability `xml:"capability"` }
type NodeDeviceSCSIHostSubCapability struct { VPortOps *NodeDeviceSCSIVPortOpsCapability FCHost *NodeDeviceSCSIFCHostCapability }
func (c *NodeDeviceSCSIHostSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (c *NodeDeviceSCSIHostSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NodeDeviceSCSITargetCapability struct { Target string `xml:"target"` Capability []NodeDeviceSCSITargetSubCapability `xml:"capability"` }
type NodeDeviceSCSITargetSubCapability struct { FCRemotePort *NodeDeviceSCSIFCRemotePortCapability }
func (c *NodeDeviceSCSITargetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (c *NodeDeviceSCSITargetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NodeDeviceSCSIVPortOpsCapability struct { VPorts int `xml:"vports,omitempty"` MaxVPorts int `xml:"maxvports,omitempty"` }
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 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 struct { Removable *NodeDeviceStorageRemovableCapability }
func (c *NodeDeviceStorageSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (c *NodeDeviceStorageSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type NodeDeviceSystemCapability struct { Product string `xml:"product,omitempty"` Hardware *NodeDeviceSystemHardware `xml:"hardware"` Firmware *NodeDeviceSystemFirmware `xml:"firmware"` }
type NodeDeviceSystemFirmware struct { Vendor string `xml:"vendor"` Version string `xml:"version"` ReleaseData string `xml:"release_date"` }
type NodeDeviceSystemHardware struct { Vendor string `xml:"vendor"` Version string `xml:"version"` Serial string `xml:"serial"` UUID string `xml:"uuid"` }
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 struct { Bus int `xml:"bus"` Device int `xml:"device"` Product NodeDeviceIDName `xml:"product,omitempty"` Vendor NodeDeviceIDName `xml:"vendor,omitempty"` }
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"` }
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 struct { Format string `xml:"format,attr"` Secret *StorageEncryptionSecret `xml:"secret"` Cipher *StorageEncryptionCipher `xml:"cipher"` Ivgen *StorageEncryptionIvgen `xml:"ivgen"` }
type StorageEncryptionCipher struct { Name string `xml:"name,attr"` Size uint64 `xml:"size,attr"` Mode string `xml:"mode,attr"` Hash string `xml:"hash,attr"` }
type StorageEncryptionSecret struct { Type string `xml:"type,attr"` UUID string `xml:"uuid,attr"` }
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"` /* Pool backend namespcaes must be last */ FSCommandline *StoragePoolFSCommandline RBDCommandline *StoragePoolRBDCommandline }
func (s *StoragePool) Marshal() (string, error)
func (s *StoragePool) Unmarshal(doc string) error
type StoragePoolFSCommandline struct { XMLName xml.Name `xml:"http://libvirt.org/schemas/storagepool/fs/1.0 mount_opts"` Options []StoragePoolFSCommandlineOption `xml:"option"` }
type StoragePoolPCIAddress struct { Domain *uint `xml:"domain,attr"` Bus *uint `xml:"bus,attr"` Slot *uint `xml:"slot,attr"` Function *uint `xml:"function,attr"` }
func (a *StoragePoolPCIAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error
func (a *StoragePoolPCIAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
type StoragePoolRBDCommandline struct { XMLName xml.Name `xml:"http://libvirt.org/schemas/storagepool/rbd/1.0 config_opts"` Options []StoragePoolRBDCommandlineOption `xml:"option"` }
type StoragePoolRBDCommandlineOption struct { Name string `xml:"name,attr"` Value string `xml:"value,attr"` }
type StoragePoolSize struct { Unit string `xml:"unit,attr,omitempty"` Value uint64 `xml:",chardata"` }
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 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 struct { UniqueID uint64 `xml:"unique_id,attr"` Address *StoragePoolPCIAddress `xml:"address"` }
type StoragePoolSourceAuth struct { Type string `xml:"type,attr"` Username string `xml:"username,attr"` Secret *StoragePoolSourceAuthSecret `xml:"secret"` }
type StoragePoolSourceAuthSecret struct { Usage string `xml:"usage,attr,omitempty"` UUID string `xml:"uuid,attr,omitempty"` }
type StoragePoolSourceDevice struct { Path string `xml:"path,attr"` PartSeparator string `xml:"part_separator,attr,omitempty"` FreeExtents []StoragePoolSourceDeviceFreeExtent `xml:"freeExtent"` }
type StoragePoolSourceDeviceFreeExtent struct { Start uint64 `xml:"start,attr"` End uint64 `xml:"end,attr"` }
type StoragePoolSourceHost struct { Name string `xml:"name,attr"` Port string `xml:"port,attr,omitempty"` }
type StoragePoolSourceInitiator struct { IQN StoragePoolSourceInitiatorIQN `xml:"iqn"` }
type StoragePoolTarget struct { Path string `xml:"path,omitempty"` Permissions *StoragePoolTargetPermissions `xml:"permissions"` Timestamps *StoragePoolTargetTimestamps `xml:"timestamps"` Encryption *StorageEncryption `xml:"encryption"` }
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 struct { Atime string `xml:"atime"` Mtime string `xml:"mtime"` Ctime string `xml:"ctime"` }
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 (s *StorageVolume) Marshal() (string, error)
func (s *StorageVolume) Unmarshal(doc string) error
type StorageVolumeBackingStore struct { Path string `xml:"path"` Format *StorageVolumeTargetFormat `xml:"format"` Permissions *StorageVolumeTargetPermissions `xml:"permissions"` }
type StorageVolumeSize struct { Unit string `xml:"unit,attr,omitempty"` Value uint64 `xml:",chardata"` }
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 struct {
LazyRefcounts *struct{} `xml:"lazy_refcounts"`
}
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 struct { Atime string `xml:"atime"` Mtime string `xml:"mtime"` Ctime string `xml:"ctime"` }
Package libvirtxml imports 5 packages (graph) and is imported by 17 packages. Updated 2019-02-05. Refresh now. Tools for package owners.