libvirt-go-xml: github.com/libvirt/libvirt-go-xml Index | Files

package libvirtxml

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: 

package main

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

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

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

package main

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

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

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

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

Index

Package Files

capabilities.go doc.go document.go domain.go domain_capabilities.go domain_snapshot.go interface.go network.go network_port.go node_device.go nwfilter.go nwfilter_binding.go secret.go storage_encryption.go storage_pool.go storage_vol.go xmlutil.go

type Caps Uses

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

func (*Caps) Marshal Uses

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

func (*Caps) Unmarshal Uses

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

type CapsGuest Uses

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

type CapsGuestArch Uses

❖
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 Uses

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

type CapsGuestFeatureACPI Uses

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

type CapsGuestFeatureAPIC Uses

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

type CapsGuestFeatureCPUSelection Uses

❖
type CapsGuestFeatureCPUSelection struct {
}

type CapsGuestFeatureDeviceBoot Uses

❖
type CapsGuestFeatureDeviceBoot struct {
}

type CapsGuestFeatureDiskSnapshot Uses

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

type CapsGuestFeatureIA64BE Uses

❖
type CapsGuestFeatureIA64BE struct {
}

type CapsGuestFeatureNonPAE Uses

❖
type CapsGuestFeatureNonPAE struct {
}

type CapsGuestFeaturePAE Uses

❖
type CapsGuestFeaturePAE struct {
}

type CapsGuestFeatures Uses

❖
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 Uses

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

type CapsHost Uses

❖
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 Uses

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

func (*CapsHostCPU) Marshal Uses

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

func (*CapsHostCPU) Unmarshal Uses

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

type CapsHostCPUFeature Uses

❖
type CapsHostCPUFeature struct {
}

type CapsHostCPUFeatureFlag Uses

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

type CapsHostCPUFeatures Uses

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

type CapsHostCPUMicrocode Uses

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

type CapsHostCPUPageSize Uses

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

type CapsHostCPUTopology Uses

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

type CapsHostCache Uses

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

type CapsHostCacheBank Uses

❖
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 Uses

❖
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 Uses

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

type CapsHostCacheMonitorFeature Uses

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

type CapsHostIOMMU Uses

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

type CapsHostMemoryBandwidth Uses

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

type CapsHostMemoryBandwidthMonitor Uses

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

type CapsHostMemoryBandwidthMonitorFeature Uses

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

type CapsHostMemoryBandwidthNode Uses

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

type CapsHostMemoryBandwidthNodeControl Uses

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

type CapsHostMigrationFeatures Uses

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

type CapsHostMigrationLive Uses

❖
type CapsHostMigrationLive struct {
}

type CapsHostMigrationURITransports Uses

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

type CapsHostNUMACPU Uses

❖
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 Uses

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

type CapsHostNUMACell Uses

❖
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 Uses

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

type CapsHostNUMADistances Uses

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

type CapsHostNUMAMemory Uses

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

type CapsHostNUMAPageInfo Uses

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

type CapsHostNUMASibling Uses

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

type CapsHostNUMATopology Uses

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

type CapsHostPowerManagement Uses

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

type CapsHostPowerManagementMode Uses

❖
type CapsHostPowerManagementMode struct {
}

type CapsHostSecModel Uses

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

type CapsHostSecModelLabel Uses

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

type Document Uses

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

type Domain Uses

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

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

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

func (*Domain) Marshal Uses

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

func (*Domain) Unmarshal Uses

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

type DomainACPI Uses

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

type DomainACPITable Uses

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

type DomainAddress Uses

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

func (*DomainAddress) MarshalXML Uses

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

func (*DomainAddress) UnmarshalXML Uses

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

type DomainAddressCCID Uses

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

func (*DomainAddressCCID) MarshalXML Uses

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

func (*DomainAddressCCID) UnmarshalXML Uses

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

type DomainAddressCCW Uses

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

func (*DomainAddressCCW) MarshalXML Uses

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

func (*DomainAddressCCW) UnmarshalXML Uses

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

type DomainAddressDIMM Uses

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

func (*DomainAddressDIMM) MarshalXML Uses

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

func (*DomainAddressDIMM) UnmarshalXML Uses

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

type DomainAddressDrive Uses

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

func (*DomainAddressDrive) MarshalXML Uses

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

func (*DomainAddressDrive) UnmarshalXML Uses

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

type DomainAddressISA Uses

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

func (*DomainAddressISA) MarshalXML Uses

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

func (*DomainAddressISA) UnmarshalXML Uses

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

type DomainAddressMDev Uses

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

type DomainAddressPCI Uses

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

func (*DomainAddressPCI) MarshalXML Uses

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

func (*DomainAddressPCI) UnmarshalXML Uses

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

type DomainAddressSpaprVIO Uses

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

func (*DomainAddressSpaprVIO) MarshalXML Uses

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

func (*DomainAddressSpaprVIO) UnmarshalXML Uses

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

type DomainAddressUSB Uses

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

func (*DomainAddressUSB) MarshalXML Uses

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

func (*DomainAddressUSB) UnmarshalXML Uses

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

type DomainAddressVirtioMMIO Uses

❖
type DomainAddressVirtioMMIO struct {
}

func (*DomainAddressVirtioMMIO) MarshalXML Uses

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

func (*DomainAddressVirtioMMIO) UnmarshalXML Uses

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

type DomainAddressVirtioS390 Uses

❖
type DomainAddressVirtioS390 struct {
}

func (*DomainAddressVirtioS390) MarshalXML Uses

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

func (*DomainAddressVirtioS390) UnmarshalXML Uses

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

type DomainAddressVirtioSerial Uses

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

func (*DomainAddressVirtioSerial) MarshalXML Uses

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

func (*DomainAddressVirtioSerial) UnmarshalXML Uses

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

type DomainAddressZPCI Uses

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

func (*DomainAddressZPCI) MarshalXML Uses

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

func (*DomainAddressZPCI) UnmarshalXML Uses

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

type DomainAlias Uses

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

type DomainBHyveCommandline Uses

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

type DomainBHyveCommandlineArg Uses

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

type DomainBHyveCommandlineEnv Uses

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

type DomainBIOS Uses

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

type DomainBlockIOTune Uses

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

type DomainBlockIOTuneDevice Uses

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

type DomainBootDevice Uses

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

type DomainBootMenu Uses

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

type DomainCPU Uses

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

func (*DomainCPU) Marshal Uses

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

func (*DomainCPU) Unmarshal Uses

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

type DomainCPUCache Uses

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

type DomainCPUCacheTune Uses

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

type DomainCPUCacheTuneCache Uses

❖
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 Uses

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

type DomainCPUFeature Uses

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

type DomainCPUMemoryTune Uses

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

type DomainCPUMemoryTuneNode Uses

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

type DomainCPUModel Uses

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

type DomainCPUTopology Uses

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

type DomainCPUTune Uses

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

type DomainCPUTuneEmulatorPin Uses

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

type DomainCPUTuneEmulatorSched Uses

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

type DomainCPUTuneIOThreadPin Uses

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

type DomainCPUTuneIOThreadSched Uses

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

type DomainCPUTunePeriod Uses

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

type DomainCPUTuneQuota Uses

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

type DomainCPUTuneShares Uses

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

type DomainCPUTuneVCPUPin Uses

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

type DomainCPUTuneVCPUSched Uses

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

type DomainCaps Uses

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

func (*DomainCaps) Marshal Uses

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

func (*DomainCaps) Unmarshal Uses

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

type DomainCapsCPU Uses

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

type DomainCapsCPUFeature Uses

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

type DomainCapsCPUMode Uses

❖
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 Uses

❖
type DomainCapsCPUModel struct {
    Name     string `xml:",chardata"`
    Usable   string `xml:"usable,attr,omitempty"`
    Fallback string `xml:"fallback,attr,omitempty"`
}

type DomainCapsDevice Uses

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

type DomainCapsDevices Uses

❖
type DomainCapsDevices struct {
    Disk     *DomainCapsDevice `xml:"disk"`
    Graphics *DomainCapsDevice `xml:"graphics"`
    Video    *DomainCapsDevice `xml:"video"`
    HostDev  *DomainCapsDevice `xml:"hostdev"`
    RNG      *DomainCapsDevice `xml:"rng"`
}

type DomainCapsEnum Uses

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

type DomainCapsFeatureBackingStoreInput Uses

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

type DomainCapsFeatureGIC Uses

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

type DomainCapsFeatureGenID Uses

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

type DomainCapsFeatureSEV Uses

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

type DomainCapsFeatureVMCoreInfo Uses

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

type DomainCapsFeatures Uses

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

type DomainCapsIOThreads Uses

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

type DomainCapsOS Uses

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

type DomainCapsOSLoader Uses

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

type DomainCapsVCPU Uses

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

type DomainCell Uses

❖
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 Uses

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

type DomainCellSibling Uses

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

type DomainChannel Uses

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

func (*DomainChannel) Marshal Uses

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

func (*DomainChannel) MarshalXML Uses

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

func (*DomainChannel) Unmarshal Uses

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

func (*DomainChannel) UnmarshalXML Uses

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

type DomainChannelTarget Uses

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

func (*DomainChannelTarget) MarshalXML Uses

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

func (*DomainChannelTarget) UnmarshalXML Uses

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

type DomainChannelTargetGuestFWD Uses

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

type DomainChannelTargetVirtIO Uses

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

type DomainChannelTargetXen Uses

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

type DomainChardevLog Uses

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

type DomainChardevProtocol Uses

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

type DomainChardevSource Uses

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

func (*DomainChardevSource) MarshalXML Uses

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

func (*DomainChardevSource) UnmarshalXML Uses

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

type DomainChardevSourceDev Uses

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

type DomainChardevSourceFile Uses

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

type DomainChardevSourceNMDM Uses

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

type DomainChardevSourceNull Uses

❖
type DomainChardevSourceNull struct {
}

type DomainChardevSourcePipe Uses

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

type DomainChardevSourcePty Uses

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

type DomainChardevSourceReconnect Uses

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

type DomainChardevSourceSpicePort Uses

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

type DomainChardevSourceSpiceVMC Uses

❖
type DomainChardevSourceSpiceVMC struct {
}

type DomainChardevSourceStdIO Uses

❖
type DomainChardevSourceStdIO struct {
}

type DomainChardevSourceTCP Uses

❖
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 Uses

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

type DomainChardevSourceUNIX Uses

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

type DomainChardevSourceVC Uses

❖
type DomainChardevSourceVC struct {
}

type DomainChardevTarget Uses

❖
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 Uses

❖
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 Uses

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

func (*DomainConsole) Marshal Uses

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

func (*DomainConsole) MarshalXML Uses

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

func (*DomainConsole) Unmarshal Uses

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

func (*DomainConsole) UnmarshalXML Uses

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

type DomainConsoleTarget Uses

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

type DomainController Uses

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

func (*DomainController) Marshal Uses

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

func (*DomainController) MarshalXML Uses

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

func (*DomainController) Unmarshal Uses

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

func (*DomainController) UnmarshalXML Uses

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

type DomainControllerDriver Uses

❖
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 Uses

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

type DomainControllerPCIHole64 Uses

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

type DomainControllerPCIModel Uses

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

type DomainControllerPCITarget Uses

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

func (*DomainControllerPCITarget) MarshalXML Uses

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

func (*DomainControllerPCITarget) UnmarshalXML Uses

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

type DomainControllerUSB Uses

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

type DomainControllerUSBMaster Uses

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

type DomainControllerVirtIOSerial Uses

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

type DomainControllerXenBus Uses

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

type DomainCurrentMemory Uses

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

type DomainDeviceBoot Uses

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

type DomainDeviceList Uses

❖
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 Uses

❖
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 Uses

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

func (*DomainDisk) Marshal Uses

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

func (*DomainDisk) MarshalXML Uses

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

func (*DomainDisk) Unmarshal Uses

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

func (*DomainDisk) UnmarshalXML Uses

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

type DomainDiskAuth Uses

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

type DomainDiskBackingStore Uses

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

func (*DomainDiskBackingStore) MarshalXML Uses

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

func (*DomainDiskBackingStore) UnmarshalXML Uses

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

type DomainDiskBlockIO Uses

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

type DomainDiskDriver Uses

❖
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 Uses

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

type DomainDiskFormat Uses

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

type DomainDiskGeometry Uses

❖
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 Uses

❖
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 Uses

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

func (*DomainDiskMirror) MarshalXML Uses

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

func (*DomainDiskMirror) UnmarshalXML Uses

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

type DomainDiskReadOnly Uses

❖
type DomainDiskReadOnly struct {
}

type DomainDiskReservations Uses

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

type DomainDiskReservationsSource Uses

❖
type DomainDiskReservationsSource DomainChardevSource

func (*DomainDiskReservationsSource) MarshalXML Uses

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

func (*DomainDiskReservationsSource) UnmarshalXML Uses

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

type DomainDiskSecret Uses

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

type DomainDiskShareable Uses

❖
type DomainDiskShareable struct {
}

type DomainDiskSource Uses

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

func (*DomainDiskSource) MarshalXML Uses

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

func (*DomainDiskSource) UnmarshalXML Uses

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

type DomainDiskSourceBlock Uses

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

type DomainDiskSourceDir Uses

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

type DomainDiskSourceFile Uses

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

type DomainDiskSourceHost Uses

❖
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 Uses

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

type DomainDiskSourceNetworkConfig Uses

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

type DomainDiskSourceNetworkIQN Uses

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

type DomainDiskSourceNetworkInitiator Uses

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

type DomainDiskSourceNetworkSnapshot Uses

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

type DomainDiskSourceVolume Uses

❖
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 Uses

❖
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 Uses

❖
type DomainDiskTransient struct {
}

type DomainFeature Uses

❖
type DomainFeature struct {
}

type DomainFeatureAPIC Uses

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

type DomainFeatureCapabilities Uses

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

type DomainFeatureCapability Uses

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

type DomainFeatureGIC Uses

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

type DomainFeatureHPT Uses

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

type DomainFeatureHPTPageSize Uses

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

type DomainFeatureHyperV Uses

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

type DomainFeatureHyperVSTimer Uses

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

type DomainFeatureHyperVSpinlocks Uses

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

type DomainFeatureHyperVVendorId Uses

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

type DomainFeatureIOAPIC Uses

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

type DomainFeatureKVM Uses

❖
type DomainFeatureKVM struct {
    Hidden        *DomainFeatureState `xml:"hidden"`
    HintDedicated *DomainFeatureState `xml:"hint-dedicated"`
}

type DomainFeatureList Uses

❖
type DomainFeatureList struct {
    PAE          *DomainFeature             `xml:"pae"`
    ACPI         *DomainFeature             `xml:"acpi"`
    APIC         *DomainFeatureAPIC         `xml:"apic"`
    HAP          *DomainFeatureState        `xml:"hap"`
    Viridian     *DomainFeature             `xml:"viridian"`
    PrivNet      *DomainFeature             `xml:"privnet"`
    HyperV       *DomainFeatureHyperV       `xml:"hyperv"`
    KVM          *DomainFeatureKVM          `xml:"kvm"`
    PVSpinlock   *DomainFeatureState        `xml:"pvspinlock"`
    PMU          *DomainFeatureState        `xml:"pmu"`
    VMPort       *DomainFeatureState        `xml:"vmport"`
    GIC          *DomainFeatureGIC          `xml:"gic"`
    SMM          *DomainFeatureSMM          `xml:"smm"`
    IOAPIC       *DomainFeatureIOAPIC       `xml:"ioapic"`
    HPT          *DomainFeatureHPT          `xml:"hpt"`
    HTM          *DomainFeatureState        `xml:"htm"`
    NestedHV     *DomainFeatureState        `xml:"nested-hv"`
    Capabilities *DomainFeatureCapabilities `xml:"capabilities"`
    VMCoreInfo   *DomainFeatureState        `xml:"vmcoreinfo"`
    MSRS         *DomainFeatureMSRS         `xml:"msrs"`
    CCFAssist    *DomainFeatureState        `xml:"ccf-assist"`
}

type DomainFeatureMSRS Uses

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

type DomainFeatureSMM Uses

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

type DomainFeatureSMMTSeg Uses

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

type DomainFeatureState Uses

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

type DomainFilesystem Uses

❖
type DomainFilesystem struct {
    XMLName        xml.Name                        `xml:"filesystem"`
    AccessMode     string                          `xml:"accessmode,attr,omitempty"`
    Model          string                          `xml:"model,attr,omitempty"`
    Driver         *DomainFilesystemDriver         `xml:"driver"`
    Source         *DomainFilesystemSource         `xml:"source"`
    Target         *DomainFilesystemTarget         `xml:"target"`
    ReadOnly       *DomainFilesystemReadOnly       `xml:"readonly"`
    SpaceHardLimit *DomainFilesystemSpaceHardLimit `xml:"space_hard_limit"`
    SpaceSoftLimit *DomainFilesystemSpaceSoftLimit `xml:"space_soft_limit"`
    Alias          *DomainAlias                    `xml:"alias"`
    Address        *DomainAddress                  `xml:"address"`
}

func (*DomainFilesystem) Marshal Uses

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

func (*DomainFilesystem) MarshalXML Uses

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

func (*DomainFilesystem) Unmarshal Uses

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

func (*DomainFilesystem) UnmarshalXML Uses

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

type DomainFilesystemDriver Uses

❖
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 Uses

❖
type DomainFilesystemReadOnly struct {
}

type DomainFilesystemSource Uses

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

func (*DomainFilesystemSource) MarshalXML Uses

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

func (*DomainFilesystemSource) UnmarshalXML Uses

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

type DomainFilesystemSourceBind Uses

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

type DomainFilesystemSourceBlock Uses

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

type DomainFilesystemSourceFile Uses

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

type DomainFilesystemSourceMount Uses

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

type DomainFilesystemSourceRAM Uses

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

type DomainFilesystemSourceTemplate Uses

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

type DomainFilesystemSourceVolume Uses

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

type DomainFilesystemSpaceHardLimit Uses

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

type DomainFilesystemSpaceSoftLimit Uses

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

type DomainFilesystemTarget Uses

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

type DomainGenID Uses

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

type DomainGraphic Uses

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

func (*DomainGraphic) Marshal Uses

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

func (*DomainGraphic) MarshalXML Uses

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

func (*DomainGraphic) Unmarshal Uses

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

func (*DomainGraphic) UnmarshalXML Uses

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

type DomainGraphicChannel Uses

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

type DomainGraphicDesktop Uses

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

type DomainGraphicEGLHeadless Uses

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

type DomainGraphicEGLHeadlessGL Uses

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

type DomainGraphicFileTransfer Uses

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

type DomainGraphicListener Uses

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

func (*DomainGraphicListener) MarshalXML Uses

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

func (*DomainGraphicListener) UnmarshalXML Uses

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

type DomainGraphicListenerAddress Uses

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

type DomainGraphicListenerNetwork Uses

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

type DomainGraphicListenerSocket Uses

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

type DomainGraphicRDP Uses

❖
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 Uses

❖
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 Uses

❖
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 Uses

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

type DomainGraphicSpiceClipBoard Uses

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

type DomainGraphicSpiceFileTransfer Uses

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

type DomainGraphicSpiceGL Uses

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

type DomainGraphicSpiceImage Uses

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

type DomainGraphicSpiceJPEG Uses

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

type DomainGraphicSpiceMouse Uses

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

type DomainGraphicSpicePlayback Uses

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

type DomainGraphicSpiceStreaming Uses

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

type DomainGraphicSpiceZLib Uses

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

type DomainGraphicVNC Uses

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

type DomainGraphicsSDLGL Uses

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

type DomainHostdev Uses

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

func (*DomainHostdev) Marshal Uses

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

func (*DomainHostdev) MarshalXML Uses

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

func (*DomainHostdev) Unmarshal Uses

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

func (*DomainHostdev) UnmarshalXML Uses

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

type DomainHostdevCapsMisc Uses

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

type DomainHostdevCapsMiscSource Uses

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

type DomainHostdevCapsNet Uses

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

type DomainHostdevCapsNetSource Uses

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

type DomainHostdevCapsStorage Uses

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

type DomainHostdevCapsStorageSource Uses

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

type DomainHostdevSubsysMDev Uses

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

type DomainHostdevSubsysMDevSource Uses

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

type DomainHostdevSubsysPCI Uses

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

type DomainHostdevSubsysPCIDriver Uses

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

type DomainHostdevSubsysPCISource Uses

❖
type DomainHostdevSubsysPCISource struct {
    Address *DomainAddressPCI `xml:"address"`
}

type DomainHostdevSubsysSCSI Uses

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

type DomainHostdevSubsysSCSIAdapter Uses

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

type DomainHostdevSubsysSCSIHost Uses

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

type DomainHostdevSubsysSCSIHostSource Uses

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

type DomainHostdevSubsysSCSISource Uses

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

func (*DomainHostdevSubsysSCSISource) MarshalXML Uses

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

func (*DomainHostdevSubsysSCSISource) UnmarshalXML Uses

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

type DomainHostdevSubsysSCSISourceHost Uses

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

type DomainHostdevSubsysSCSISourceISCSI Uses

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

type DomainHostdevSubsysUSB Uses

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

type DomainHostdevSubsysUSBSource Uses

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

type DomainHub Uses

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

type DomainIDMap Uses

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

type DomainIDMapRange Uses

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

type DomainIOMMU Uses

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

type DomainIOMMUDriver Uses

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

type DomainIOThread Uses

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

type DomainIOThreadIDs Uses

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

type DomainIP Uses

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

type DomainInput Uses

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

func (*DomainInput) Marshal Uses

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

func (*DomainInput) Unmarshal Uses

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

type DomainInputDriver Uses

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

type DomainInputSource Uses

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

type DomainInterface Uses

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

func (*DomainInterface) Marshal Uses

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

func (*DomainInterface) MarshalXML Uses

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

func (*DomainInterface) Unmarshal Uses

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

func (*DomainInterface) UnmarshalXML Uses

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

type DomainInterfaceBackend Uses

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

type DomainInterfaceBandwidth Uses

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

type DomainInterfaceBandwidthParams Uses

❖
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 Uses

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

type DomainInterfaceCoalesceRX Uses

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

type DomainInterfaceCoalesceRXFrames Uses

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

type DomainInterfaceDriver Uses

❖
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 Uses

❖
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 Uses

❖
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 Uses

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

type DomainInterfaceFilterRef Uses

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

type DomainInterfaceGuest Uses

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

type DomainInterfaceIP Uses

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

type DomainInterfaceMAC Uses

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

type DomainInterfaceMTU Uses

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

type DomainInterfaceModel Uses

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

type DomainInterfaceRoute Uses

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

type DomainInterfaceScript Uses

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

type DomainInterfaceSource Uses

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

func (*DomainInterfaceSource) MarshalXML Uses

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

func (*DomainInterfaceSource) UnmarshalXML Uses

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

type DomainInterfaceSourceBridge Uses

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

type DomainInterfaceSourceClient Uses

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

type DomainInterfaceSourceDirect Uses

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

type DomainInterfaceSourceEthernet Uses

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

type DomainInterfaceSourceHostdev Uses

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

func (*DomainInterfaceSourceHostdev) MarshalXML Uses

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

func (*DomainInterfaceSourceHostdev) UnmarshalXML Uses

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

type DomainInterfaceSourceInternal Uses

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

type DomainInterfaceSourceLocal Uses

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

type DomainInterfaceSourceMCast Uses

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

type DomainInterfaceSourceNetwork Uses

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

type DomainInterfaceSourceServer Uses

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

type DomainInterfaceSourceUDP Uses

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

type DomainInterfaceSourceUser Uses

❖
type DomainInterfaceSourceUser struct {
}

type DomainInterfaceTarget Uses

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

type DomainInterfaceTune Uses

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

type DomainInterfaceVLan Uses

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

type DomainInterfaceVLanTag Uses

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

type DomainInterfaceVirtualPort Uses

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

func (*DomainInterfaceVirtualPort) MarshalXML Uses

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

func (*DomainInterfaceVirtualPort) UnmarshalXML Uses

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

type DomainInterfaceVirtualPortParams Uses

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

func (*DomainInterfaceVirtualPortParams) MarshalXML Uses

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

func (*DomainInterfaceVirtualPortParams) UnmarshalXML Uses

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

type DomainInterfaceVirtualPortParamsAny Uses

❖
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 Uses

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

type DomainInterfaceVirtualPortParamsOpenVSwitch Uses

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

type DomainInterfaceVirtualPortParamsVEPA8021QBG Uses

❖
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 Uses

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

type DomainKeyWrap Uses

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

type DomainKeyWrapCipher Uses

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

type DomainLXCNamespace Uses

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

type DomainLXCNamespaceMap Uses

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

type DomainLaunchSecurity Uses

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

func (*DomainLaunchSecurity) MarshalXML Uses

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

func (*DomainLaunchSecurity) UnmarshalXML Uses

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

type DomainLaunchSecuritySEV Uses

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

func (*DomainLaunchSecuritySEV) MarshalXML Uses

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

func (*DomainLaunchSecuritySEV) UnmarshalXML Uses

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

type DomainLease Uses

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

type DomainLeaseTarget Uses

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

type DomainLoader Uses

❖
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 Uses

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

type DomainMemBalloon Uses

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

func (*DomainMemBalloon) Marshal Uses

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

func (*DomainMemBalloon) Unmarshal Uses

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

type DomainMemBalloonDriver Uses

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

type DomainMemBalloonStats Uses

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

type DomainMemory Uses

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

type DomainMemoryAccess Uses

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

type DomainMemoryAllocation Uses

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

type DomainMemoryBacking Uses

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

type DomainMemoryDiscard Uses

❖
type DomainMemoryDiscard struct {
}

type DomainMemoryHugepage Uses

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

type DomainMemoryHugepages Uses

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

type DomainMemoryLocked Uses

❖
type DomainMemoryLocked struct {
}

type DomainMemoryNosharepages Uses

❖
type DomainMemoryNosharepages struct {
}

type DomainMemorySource Uses

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

type DomainMemoryTune Uses

❖
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 Uses

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

type DomainMemorydev Uses

❖
type DomainMemorydev struct {
    XMLName xml.Name               `xml:"memory"`
    Model   string                 `xml:"model,attr"`
    Access  string                 `xml:"access,attr,omitempty"`
    Discard string                 `xml:"discard,attr,omitempty"`
    Source  *DomainMemorydevSource `xml:"source"`
    Target  *DomainMemorydevTarget `xml:"target"`
    Alias   *DomainAlias           `xml:"alias"`
    Address *DomainAddress         `xml:"address"`
}

func (*DomainMemorydev) Marshal Uses

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

func (*DomainMemorydev) Unmarshal Uses

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

type DomainMemorydevSource Uses

❖
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 Uses

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

type DomainMemorydevSourcePMem Uses

❖
type DomainMemorydevSourcePMem struct {
}

type DomainMemorydevSourcePagesize Uses

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

type DomainMemorydevTarget Uses

❖
type DomainMemorydevTarget struct {
    Size     *DomainMemorydevTargetSize     `xml:"size"`
    Node     *DomainMemorydevTargetNode     `xml:"node"`
    Label    *DomainMemorydevTargetLabel    `xml:"label"`
    ReadOnly *DomainMemorydevTargetReadOnly `xml:"readonly"`
}

type DomainMemorydevTargetLabel Uses

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

type DomainMemorydevTargetNode Uses

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

type DomainMemorydevTargetReadOnly Uses

❖
type DomainMemorydevTargetReadOnly struct {
}

type DomainMemorydevTargetSize Uses

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

type DomainMetadata Uses

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

type DomainNUMATune Uses

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

type DomainNUMATuneMemNode Uses

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

type DomainNUMATuneMemory Uses

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

type DomainNVRAM Uses

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

type DomainNVRam Uses

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

type DomainNuma Uses

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

type DomainOS Uses

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

type DomainOSInitEnv Uses

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

type DomainOSType Uses

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

type DomainPM Uses

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

type DomainPMPolicy Uses

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

type DomainPanic Uses

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

type DomainParallel Uses

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

func (*DomainParallel) Marshal Uses

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

func (*DomainParallel) MarshalXML Uses

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

func (*DomainParallel) Unmarshal Uses

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

func (*DomainParallel) UnmarshalXML Uses

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

type DomainParallelTarget Uses

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

type DomainPerf Uses

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

type DomainPerfEvent Uses

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

type DomainQEMUCapabilities Uses

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

type DomainQEMUCapabilitiesEntry Uses

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

type DomainQEMUCommandline Uses

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

type DomainQEMUCommandlineArg Uses

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

type DomainQEMUCommandlineEnv Uses

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

type DomainRNG Uses

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

func (*DomainRNG) Marshal Uses

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

func (*DomainRNG) Unmarshal Uses

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

type DomainRNGBackend Uses

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

func (*DomainRNGBackend) MarshalXML Uses

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

func (*DomainRNGBackend) UnmarshalXML Uses

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

type DomainRNGBackendEGD Uses

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

func (*DomainRNGBackendEGD) MarshalXML Uses

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

func (*DomainRNGBackendEGD) UnmarshalXML Uses

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

type DomainRNGBackendRandom Uses

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

type DomainRNGDriver Uses

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

type DomainRNGRate Uses

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

type DomainROM Uses

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

type DomainRedirDev Uses

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

func (*DomainRedirDev) Marshal Uses

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

func (*DomainRedirDev) MarshalXML Uses

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

func (*DomainRedirDev) Unmarshal Uses

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

func (*DomainRedirDev) UnmarshalXML Uses

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

type DomainRedirFilter Uses

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

type DomainRedirFilterUSB Uses

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

func (*DomainRedirFilterUSB) MarshalXML Uses

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

func (*DomainRedirFilterUSB) UnmarshalXML Uses

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

type DomainResource Uses

❖
type DomainResource struct {
    Partition string `xml:"partition,omitempty"`
}

type DomainRoute Uses

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

type DomainSMBios Uses

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

type DomainSecLabel Uses

❖
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 Uses

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

func (*DomainSerial) Marshal Uses

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

func (*DomainSerial) MarshalXML Uses

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

func (*DomainSerial) Unmarshal Uses

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

func (*DomainSerial) UnmarshalXML Uses

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

type DomainSerialTarget Uses

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

type DomainSerialTargetModel Uses

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

type DomainShmem Uses

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

func (*DomainShmem) Marshal Uses

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

func (*DomainShmem) Unmarshal Uses

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

type DomainShmemMSI Uses

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

type DomainShmemModel Uses

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

type DomainShmemServer Uses

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

type DomainShmemSize Uses

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

type DomainSmartcard Uses

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

func (*DomainSmartcard) Marshal Uses

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

func (*DomainSmartcard) MarshalXML Uses

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

func (*DomainSmartcard) Unmarshal Uses

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

func (*DomainSmartcard) UnmarshalXML Uses

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

type DomainSmartcardHost Uses

❖
type DomainSmartcardHost struct {
}

type DomainSmartcardHostCert Uses

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

type DomainSnapshot Uses

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

func (*DomainSnapshot) Marshal Uses

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

func (*DomainSnapshot) Unmarshal Uses

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

type DomainSnapshotDisk Uses

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

func (*DomainSnapshotDisk) MarshalXML Uses

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

func (*DomainSnapshotDisk) UnmarshalXML Uses

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

type DomainSnapshotDiskDriver Uses

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

type DomainSnapshotDisks Uses

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

type DomainSnapshotMemory Uses

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

type DomainSnapshotParent Uses

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

type DomainSound Uses

❖
type DomainSound struct {
    XMLName xml.Name           `xml:"sound"`
    Model   string             `xml:"model,attr"`
    Codec   []DomainSoundCodec `xml:"codec"`
    Alias   *DomainAlias       `xml:"alias"`
    Address *DomainAddress     `xml:"address"`
}

func (*DomainSound) Marshal Uses

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

func (*DomainSound) Unmarshal Uses

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

type DomainSoundCodec Uses

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

type DomainSysInfo Uses

❖
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 Uses

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

type DomainSysInfoBaseBoard Uses

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

type DomainSysInfoChassis Uses

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

type DomainSysInfoEntry Uses

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

type DomainSysInfoMemory Uses

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

type DomainSysInfoOEMStrings Uses

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

type DomainSysInfoProcessor Uses

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

type DomainSysInfoSystem Uses

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

type DomainTPM Uses

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

func (*DomainTPM) Marshal Uses

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

func (*DomainTPM) Unmarshal Uses

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

type DomainTPMBackend Uses

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

func (*DomainTPMBackend) MarshalXML Uses

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

func (*DomainTPMBackend) UnmarshalXML Uses

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

type DomainTPMBackendDevice Uses

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

type DomainTPMBackendEmulator Uses

❖
type DomainTPMBackendEmulator struct {
    Version    string                      `xml:"version,attr,omitempty"`
    Encryption *DomainTPMBackendEncryption `xml:"encryption"`
}

type DomainTPMBackendEncryption Uses

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

type DomainTPMBackendPassthrough Uses

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

type DomainTimer Uses

❖
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 Uses

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

type DomainVCPU Uses

❖
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 Uses

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

type DomainVCPUsVCPU Uses

❖
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 Uses

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

type DomainVSock Uses

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

func (*DomainVSock) Marshal Uses

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

func (*DomainVSock) Unmarshal Uses

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

type DomainVSockCID Uses

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

type DomainVideo Uses

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

func (*DomainVideo) Marshal Uses

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

func (*DomainVideo) Unmarshal Uses

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

type DomainVideoAccel Uses

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

type DomainVideoDriver Uses

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

type DomainVideoModel Uses

❖
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"`
    Resolution *DomainVideoResolution `xml:"resolution"`
}

type DomainVideoResolution Uses

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

type DomainWatchdog Uses

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

func (*DomainWatchdog) Marshal Uses

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

func (*DomainWatchdog) Unmarshal Uses

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

type Interface Uses

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

func (*Interface) Marshal Uses

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

func (*Interface) MarshalXML Uses

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

func (*Interface) Unmarshal Uses

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

type InterfaceAutoConf Uses

❖
type InterfaceAutoConf struct {
}

type InterfaceBond Uses

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

type InterfaceBondARPMon Uses

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

type InterfaceBondMIIMon Uses

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

type InterfaceBridge Uses

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

type InterfaceDHCP Uses

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

type InterfaceIP Uses

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

type InterfaceMAC Uses

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

type InterfaceMTU Uses

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

type InterfaceProtocol Uses

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

type InterfaceRoute Uses

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

type InterfaceStart Uses

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

type InterfaceVLAN Uses

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

type NWFilter Uses

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

func (*NWFilter) Marshal Uses

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

func (*NWFilter) MarshalXML Uses

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

func (*NWFilter) Unmarshal Uses

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

func (*NWFilter) UnmarshalXML Uses

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

type NWFilterBinding Uses

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

func (*NWFilterBinding) Marshal Uses

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

func (*NWFilterBinding) Unmarshal Uses

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

type NWFilterBindingFilterParam Uses

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

type NWFilterBindingFilterRef Uses

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

type NWFilterBindingMAC Uses

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

type NWFilterBindingOwner Uses

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

type NWFilterBindingPortDev Uses

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

type NWFilterEntry Uses

❖
type NWFilterEntry struct {
    Rule *NWFilterRule
    Ref  *NWFilterRef
}

type NWFilterField Uses

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

func (*NWFilterField) MarshalXMLAttr Uses

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

func (*NWFilterField) UnmarshalXMLAttr Uses

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

type NWFilterParameter Uses

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

type NWFilterRef Uses

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

type NWFilterRule Uses

❖
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 Uses

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

type NWFilterRuleAHIPv6 Uses

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

type NWFilterRuleARP Uses

❖
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 Uses

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

type NWFilterRuleAllIPv6 Uses

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

type NWFilterRuleCommonIP Uses

❖
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 Uses

❖
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 Uses

❖
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 Uses

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

type NWFilterRuleESPIPv6 Uses

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

type NWFilterRuleICMP Uses

❖
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 Uses

❖
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 Uses

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

type NWFilterRuleIP Uses

❖
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 Uses

❖
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 Uses

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

type NWFilterRuleRARP Uses

❖
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 Uses

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

type NWFilterRuleSCTPIPv6 Uses

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

type NWFilterRuleSTP Uses

❖
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 Uses

❖
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 Uses

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

type NWFilterRuleUDP Uses

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

type NWFilterRuleUDPIPv6 Uses

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

type NWFilterRuleUDPLite Uses

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

type NWFilterRuleUDPLiteIPv6 Uses

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

type NWFilterRuleVLAN Uses

❖
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 Uses

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

    DnsmasqOptions *NetworkDnsmasqOptions
}

func (*Network) Marshal Uses

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

func (*Network) Unmarshal Uses

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

type NetworkBandwidth Uses

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

type NetworkBandwidthParams Uses

❖
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 Uses

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

type NetworkBridge Uses

❖
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 Uses

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

type NetworkDHCPHost Uses

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

func (*NetworkDHCPHost) Marshal Uses

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

func (*NetworkDHCPHost) Unmarshal Uses

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

type NetworkDHCPRange Uses

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

func (*NetworkDHCPRange) Marshal Uses

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

func (*NetworkDHCPRange) Unmarshal Uses

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

type NetworkDNS Uses

❖
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 Uses

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

type NetworkDNSHost Uses

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

func (*NetworkDNSHost) Marshal Uses

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

func (*NetworkDNSHost) Unmarshal Uses

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

type NetworkDNSHostHostname Uses

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

type NetworkDNSSRV Uses

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

func (*NetworkDNSSRV) Marshal Uses

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

func (*NetworkDNSSRV) Unmarshal Uses

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

type NetworkDNSTXT Uses

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

func (*NetworkDNSTXT) Marshal Uses

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

func (*NetworkDNSTXT) Unmarshal Uses

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

type NetworkDnsmasqOption Uses

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

type NetworkDnsmasqOptions Uses

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

type NetworkDomain Uses

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

type NetworkForward Uses

❖
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 Uses

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

func (*NetworkForwardAddress) MarshalXML Uses

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

func (*NetworkForwardAddress) UnmarshalXML Uses

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

type NetworkForwardAddressPCI Uses

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

func (*NetworkForwardAddressPCI) MarshalXML Uses

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

func (*NetworkForwardAddressPCI) UnmarshalXML Uses

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

type NetworkForwardDriver Uses

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

type NetworkForwardInterface Uses

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

func (*NetworkForwardInterface) Marshal Uses

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

func (*NetworkForwardInterface) Unmarshal Uses

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

type NetworkForwardNAT Uses

❖
type NetworkForwardNAT struct {
    Addresses []NetworkForwardNATAddress `xml:"address"`
    Ports     []NetworkForwardNATPort    `xml:"port"`
}

type NetworkForwardNATAddress Uses

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

type NetworkForwardNATPort Uses

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

type NetworkForwardPF Uses

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

type NetworkIP Uses

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

type NetworkMAC Uses

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

type NetworkMTU Uses

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

type NetworkMetadata Uses

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

type NetworkPort Uses

❖
type NetworkPort struct {
    XMLName     xml.Name              `xml:"networkport"`
    UUID        string                `xml:"uuid,omitempty"`
    Owner       *NetworkPortOwner     `xml:"owner",`
    MAC         *NetworkPortMAC       `xml:"mac"`
    Group       string                `xml:"group,omitempty"`
    Bandwidth   *NetworkBandwidth     `xml:"bandwidth"`
    VirtualPort *NetworkVirtualPort   `xml:"virtualport"`
    RXFilters   *NetworkPortRXFilters `xml:"rxfilters"`
    Plug        *NetworkPortPlug      `xml:"plug"`
}

func (*NetworkPort) Marshal Uses

❖
func (s *NetworkPort) Marshal() (string, error)

func (*NetworkPort) Unmarshal Uses

❖
func (s *NetworkPort) Unmarshal(doc string) error

type NetworkPortGroup Uses

❖
type NetworkPortGroup struct {
    XMLName             xml.Name            `xml:"portgroup"`
    Name                string              `xml:"name,attr,omitempty"`
    Default             string              `xml:"default,attr,omitempty"`
    TrustGuestRxFilters string              `xml:"trustGuestRxFilters,attr,omitempty"`
    VLAN                *NetworkVLAN        `xml:"vlan"`
    VirtualPort         *NetworkVirtualPort `xml:"virtualport"`
}

func (*NetworkPortGroup) Marshal Uses

❖
func (s *NetworkPortGroup) Marshal() (string, error)

func (*NetworkPortGroup) Unmarshal Uses

❖
func (s *NetworkPortGroup) Unmarshal(doc string) error

type NetworkPortMAC Uses

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

type NetworkPortOwner Uses

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

type NetworkPortPlug Uses

❖
type NetworkPortPlug struct {
    Bridge     *NetworkPortPlugBridge     `xml:"-"`
    Network    *NetworkPortPlugNetwork    `xml:"-"`
    Direct     *NetworkPortPlugDirect     `xml:"-"`
    HostDevPCI *NetworkPortPlugHostDevPCI `xml:"-"`
}

func (*NetworkPortPlug) MarshalXML Uses

❖
func (p *NetworkPortPlug) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NetworkPortPlug) UnmarshalXML Uses

❖
func (p *NetworkPortPlug) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NetworkPortPlugBridge Uses

❖
type NetworkPortPlugBridge struct {
    Bridge          string `xml:"bridge,attr"`
    MacTableManager string `xml:"macTableManager,attr,omitempty"`
}

type NetworkPortPlugDirect Uses

❖
type NetworkPortPlugDirect struct {
    Dev  string `xml:"dev,attr"`
    Mode string `xml:"mode,attr"`
}

type NetworkPortPlugHostDevPCI Uses

❖
type NetworkPortPlugHostDevPCI struct {
    Managed string                            `xml:"managed,attr,omitempty"`
    Driver  *NetworkPortPlugHostDevPCIDriver  `xml:"driver"`
    Address *NetworkPortPlugHostDevPCIAddress `xml:"address"`
}

type NetworkPortPlugHostDevPCIAddress Uses

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

func (*NetworkPortPlugHostDevPCIAddress) MarshalXML Uses

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

func (*NetworkPortPlugHostDevPCIAddress) UnmarshalXML Uses

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

type NetworkPortPlugHostDevPCIDriver Uses

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

type NetworkPortPlugNetwork Uses

❖
type NetworkPortPlugNetwork struct {
    Bridge          string `xml:"bridge,attr"`
    MacTableManager string `xml:"macTableManager,attr,omitempty"`
}

type NetworkPortRXFilters Uses

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

type NetworkRoute Uses

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

type NetworkTFTP Uses

❖
type NetworkTFTP struct {
    Root string `xml:"root,attr,omitempty"`
}

type NetworkVLAN Uses

❖
type NetworkVLAN struct {
    Trunk string           `xml:"trunk,attr,omitempty"`
    Tags  []NetworkVLANTag `xml:"tag"`
}

type NetworkVLANTag Uses

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

type NetworkVirtualPort Uses

❖
type NetworkVirtualPort struct {
    Params *NetworkVirtualPortParams `xml:"parameters"`
}

func (*NetworkVirtualPort) MarshalXML Uses

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

func (*NetworkVirtualPort) UnmarshalXML Uses

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

type NetworkVirtualPortParams Uses

❖
type NetworkVirtualPortParams struct {
    Any          *NetworkVirtualPortParamsAny          `xml:"-"`
    VEPA8021QBG  *NetworkVirtualPortParamsVEPA8021QBG  `xml:"-"`
    VNTag8011QBH *NetworkVirtualPortParamsVNTag8021QBH `xml:"-"`
    OpenVSwitch  *NetworkVirtualPortParamsOpenVSwitch  `xml:"-"`
    MidoNet      *NetworkVirtualPortParamsMidoNet      `xml:"-"`
}

func (*NetworkVirtualPortParams) MarshalXML Uses

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

func (*NetworkVirtualPortParams) UnmarshalXML Uses

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

type NetworkVirtualPortParamsAny Uses

❖
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 Uses

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

type NetworkVirtualPortParamsOpenVSwitch Uses

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

type NetworkVirtualPortParamsVEPA8021QBG Uses

❖
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 Uses

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

type NodeDevice Uses

❖
type NodeDevice struct {
    XMLName    xml.Name             `xml:"device"`
    Name       string               `xml:"name"`
    Path       string               `xml:"path,omitempty"`
    DevNodes   []NodeDeviceDevNode  `xml:"devnode"`
    Parent     string               `xml:"parent,omitempty"`
    Driver     *NodeDeviceDriver    `xml:"driver"`
    Capability NodeDeviceCapability `xml:"capability"`
}

func (*NodeDevice) Marshal Uses

❖
func (c *NodeDevice) Marshal() (string, error)

func (*NodeDevice) Unmarshal Uses

❖
func (c *NodeDevice) Unmarshal(doc string) error

type NodeDeviceCCWCapability Uses

❖
type NodeDeviceCCWCapability struct {
    CSSID *uint `xml:"cssid"`
    SSID  *uint `xml:"ssid"`
    DevNo *uint `xml:"devno"`
}

func (*NodeDeviceCCWCapability) MarshalXML Uses

❖
func (c *NodeDeviceCCWCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCCWCapability) UnmarshalXML Uses

❖
func (c *NodeDeviceCCWCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceCapability Uses

❖
type NodeDeviceCapability struct {
    System     *NodeDeviceSystemCapability
    PCI        *NodeDevicePCICapability
    USB        *NodeDeviceUSBCapability
    USBDevice  *NodeDeviceUSBDeviceCapability
    Net        *NodeDeviceNetCapability
    SCSIHost   *NodeDeviceSCSIHostCapability
    SCSITarget *NodeDeviceSCSITargetCapability
    SCSI       *NodeDeviceSCSICapability
    Storage    *NodeDeviceStorageCapability
    DRM        *NodeDeviceDRMCapability
    CCW        *NodeDeviceCCWCapability
    MDev       *NodeDeviceMDevCapability
}

func (*NodeDeviceCapability) MarshalXML Uses

❖
func (c *NodeDeviceCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCapability) UnmarshalXML Uses

❖
func (c *NodeDeviceCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceDRMCapability Uses

❖
type NodeDeviceDRMCapability struct {
    Type string `xml:"type"`
}

type NodeDeviceDevNode Uses

❖
type NodeDeviceDevNode struct {
    Type string `xml:"type,attr,omitempty"`
    Path string `xml:",chardata"`
}

type NodeDeviceDriver Uses

❖
type NodeDeviceDriver struct {
    Name string `xml:"name"`
}

type NodeDeviceIDName Uses

❖
type NodeDeviceIDName struct {
    ID   string `xml:"id,attr"`
    Name string `xml:",chardata"`
}

type NodeDeviceIOMMUGroup Uses

❖
type NodeDeviceIOMMUGroup struct {
    Number  int                    `xml:"number,attr"`
    Address []NodeDevicePCIAddress `xml:"address"`
}

type NodeDeviceMDevCapability Uses

❖
type NodeDeviceMDevCapability struct {
    Type       *NodeDeviceMDevCapabilityType `xml:"type"`
    IOMMUGroup *NodeDeviceIOMMUGroup         `xml:"iommuGroup"`
}

type NodeDeviceMDevCapabilityType Uses

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

type NodeDeviceNUMA Uses

❖
type NodeDeviceNUMA struct {
    Node int `xml:"node,attr"`
}

type NodeDeviceNet80203Capability Uses

❖
type NodeDeviceNet80203Capability struct {
}

type NodeDeviceNet80211Capability Uses

❖
type NodeDeviceNet80211Capability struct {
}

type NodeDeviceNetCapability Uses

❖
type NodeDeviceNetCapability struct {
    Interface  string                         `xml:"interface"`
    Address    string                         `xml:"address"`
    Link       *NodeDeviceNetLink             `xml:"link"`
    Features   []NodeDeviceNetOffloadFeatures `xml:"feature,omitempty"`
    Capability []NodeDeviceNetSubCapability   `xml:"capability"`
}
❖
type NodeDeviceNetLink struct {
    State string `xml:"state,attr"`
    Speed string `xml:"speed,attr,omitempty"`
}

type NodeDeviceNetOffloadFeatures Uses

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

type NodeDeviceNetSubCapability Uses

❖
type NodeDeviceNetSubCapability struct {
    Wireless80211 *NodeDeviceNet80211Capability
    Ethernet80203 *NodeDeviceNet80203Capability
}

func (*NodeDeviceNetSubCapability) MarshalXML Uses

❖
func (c *NodeDeviceNetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceNetSubCapability) UnmarshalXML Uses

❖
func (c *NodeDeviceNetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIAddress Uses

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

func (*NodeDevicePCIAddress) MarshalXML Uses

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

func (*NodeDevicePCIAddress) UnmarshalXML Uses

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

type NodeDevicePCIBridgeCapability Uses

❖
type NodeDevicePCIBridgeCapability struct {
}

type NodeDevicePCICapability Uses

❖
type NodeDevicePCICapability struct {
    Class        string                       `xml:"class,omitempty"`
    Domain       *uint                        `xml:"domain"`
    Bus          *uint                        `xml:"bus"`
    Slot         *uint                        `xml:"slot"`
    Function     *uint                        `xml:"function"`
    Product      NodeDeviceIDName             `xml:"product,omitempty"`
    Vendor       NodeDeviceIDName             `xml:"vendor,omitempty"`
    IOMMUGroup   *NodeDeviceIOMMUGroup        `xml:"iommuGroup"`
    NUMA         *NodeDeviceNUMA              `xml:"numa"`
    PCIExpress   *NodeDevicePCIExpress        `xml:"pci-express"`
    Capabilities []NodeDevicePCISubCapability `xml:"capability"`
}

type NodeDevicePCIExpress Uses

❖
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 Uses

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

type NodeDevicePCIMDevTypesCapability Uses

❖
type NodeDevicePCIMDevTypesCapability struct {
    Types []NodeDevicePCIMDevType `xml:"type"`
}

type NodeDevicePCIPhysFunctionCapability Uses

❖
type NodeDevicePCIPhysFunctionCapability struct {
    Address NodeDevicePCIAddress `xml:"address,omitempty"`
}

type NodeDevicePCISubCapability Uses

❖
type NodeDevicePCISubCapability struct {
    VirtFunctions *NodeDevicePCIVirtFunctionsCapability
    PhysFunction  *NodeDevicePCIPhysFunctionCapability
    MDevTypes     *NodeDevicePCIMDevTypesCapability
    Bridge        *NodeDevicePCIBridgeCapability
}

func (*NodeDevicePCISubCapability) MarshalXML Uses

❖
func (c *NodeDevicePCISubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDevicePCISubCapability) UnmarshalXML Uses

❖
func (c *NodeDevicePCISubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIVirtFunctionsCapability Uses

❖
type NodeDevicePCIVirtFunctionsCapability struct {
    Address  []NodeDevicePCIAddress `xml:"address,omitempty"`
    MaxCount int                    `xml:"maxCount,attr,omitempty"`
}

type NodeDeviceSCSICapability Uses

❖
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 Uses

❖
type NodeDeviceSCSIFCHostCapability struct {
    WWNN      string `xml:"wwnn,omitempty"`
    WWPN      string `xml:"wwpn,omitempty"`
    FabricWWN string `xml:"fabric_wwn,omitempty"`
}

type NodeDeviceSCSIFCRemotePortCapability Uses

❖
type NodeDeviceSCSIFCRemotePortCapability struct {
    RPort string `xml:"rport"`
    WWPN  string `xml:"wwpn"`
}

type NodeDeviceSCSIHostCapability Uses

❖
type NodeDeviceSCSIHostCapability struct {
    Host       uint                              `xml:"host"`
    UniqueID   *uint                             `xml:"unique_id"`
    Capability []NodeDeviceSCSIHostSubCapability `xml:"capability"`
}

type NodeDeviceSCSIHostSubCapability Uses

❖
type NodeDeviceSCSIHostSubCapability struct {
    VPortOps *NodeDeviceSCSIVPortOpsCapability
    FCHost   *NodeDeviceSCSIFCHostCapability
}

func (*NodeDeviceSCSIHostSubCapability) MarshalXML Uses

❖
func (c *NodeDeviceSCSIHostSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceSCSIHostSubCapability) UnmarshalXML Uses

❖
func (c *NodeDeviceSCSIHostSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSCSITargetCapability Uses

❖
type NodeDeviceSCSITargetCapability struct {
    Target     string                              `xml:"target"`
    Capability []NodeDeviceSCSITargetSubCapability `xml:"capability"`
}

type NodeDeviceSCSITargetSubCapability Uses

❖
type NodeDeviceSCSITargetSubCapability struct {
    FCRemotePort *NodeDeviceSCSIFCRemotePortCapability
}

func (*NodeDeviceSCSITargetSubCapability) MarshalXML Uses

❖
func (c *NodeDeviceSCSITargetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceSCSITargetSubCapability) UnmarshalXML Uses

❖
func (c *NodeDeviceSCSITargetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSCSIVPortOpsCapability Uses

❖
type NodeDeviceSCSIVPortOpsCapability struct {
    VPorts    int `xml:"vports,omitempty"`
    MaxVPorts int `xml:"maxvports,omitempty"`
}

type NodeDeviceStorageCapability Uses

❖
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 Uses

❖
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 Uses

❖
type NodeDeviceStorageSubCapability struct {
    Removable *NodeDeviceStorageRemovableCapability
}

func (*NodeDeviceStorageSubCapability) MarshalXML Uses

❖
func (c *NodeDeviceStorageSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceStorageSubCapability) UnmarshalXML Uses

❖
func (c *NodeDeviceStorageSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSystemCapability Uses

❖
type NodeDeviceSystemCapability struct {
    Product  string                    `xml:"product,omitempty"`
    Hardware *NodeDeviceSystemHardware `xml:"hardware"`
    Firmware *NodeDeviceSystemFirmware `xml:"firmware"`
}

type NodeDeviceSystemFirmware Uses

❖
type NodeDeviceSystemFirmware struct {
    Vendor      string `xml:"vendor"`
    Version     string `xml:"version"`
    ReleaseData string `xml:"release_date"`
}

type NodeDeviceSystemHardware Uses

❖
type NodeDeviceSystemHardware struct {
    Vendor  string `xml:"vendor"`
    Version string `xml:"version"`
    Serial  string `xml:"serial"`
    UUID    string `xml:"uuid"`
}

type NodeDeviceUSBCapability Uses

❖
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 Uses

❖
type NodeDeviceUSBDeviceCapability struct {
    Bus     int              `xml:"bus"`
    Device  int              `xml:"device"`
    Product NodeDeviceIDName `xml:"product,omitempty"`
    Vendor  NodeDeviceIDName `xml:"vendor,omitempty"`
}

type Secret Uses

❖
type Secret struct {
    XMLName     xml.Name     `xml:"secret"`
    Ephemeral   string       `xml:"ephemeral,attr,omitempty"`
    Private     string       `xml:"private,attr,omitempty"`
    Description string       `xml:"description,omitempty"`
    UUID        string       `xml:"uuid,omitempty"`
    Usage       *SecretUsage `xml:"usage"`
}

func (*Secret) Marshal Uses

❖
func (s *Secret) Marshal() (string, error)

func (*Secret) Unmarshal Uses

❖
func (s *Secret) Unmarshal(doc string) error

type SecretUsage Uses

❖
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 Uses

❖
type StorageEncryption struct {
    Format string                   `xml:"format,attr"`
    Secret *StorageEncryptionSecret `xml:"secret"`
    Cipher *StorageEncryptionCipher `xml:"cipher"`
    Ivgen  *StorageEncryptionIvgen  `xml:"ivgen"`
}

type StorageEncryptionCipher Uses

❖
type StorageEncryptionCipher struct {
    Name string `xml:"name,attr"`
    Size uint64 `xml:"size,attr"`
    Mode string `xml:"mode,attr"`
    Hash string `xml:"hash,attr"`
}

type StorageEncryptionIvgen Uses

❖
type StorageEncryptionIvgen struct {
    Name string `xml:"name,attr"`
    Hash string `xml:"hash,attr"`
}

type StorageEncryptionSecret Uses

❖
type StorageEncryptionSecret struct {
    Type string `xml:"type,attr"`
    UUID string `xml:"uuid,attr"`
}

type StoragePool Uses

❖
type StoragePool struct {
    XMLName    xml.Name            `xml:"pool"`
    Type       string              `xml:"type,attr"`
    Name       string              `xml:"name,omitempty"`
    UUID       string              `xml:"uuid,omitempty"`
    Allocation *StoragePoolSize    `xml:"allocation"`
    Capacity   *StoragePoolSize    `xml:"capacity"`
    Available  *StoragePoolSize    `xml:"available"`
    Target     *StoragePoolTarget  `xml:"target"`
    Source     *StoragePoolSource  `xml:"source"`
    Refresh    *StoragePoolRefresh `xml:"refresh"`

    /* Pool backend namespcaes must be last */
    FSCommandline  *StoragePoolFSCommandline
    RBDCommandline *StoragePoolRBDCommandline
}

func (*StoragePool) Marshal Uses

❖
func (s *StoragePool) Marshal() (string, error)

func (*StoragePool) Unmarshal Uses

❖
func (s *StoragePool) Unmarshal(doc string) error

type StoragePoolFSCommandline Uses

❖
type StoragePoolFSCommandline struct {
    XMLName xml.Name                         `xml:"http://libvirt.org/schemas/storagepool/fs/1.0 mount_opts"`
    Options []StoragePoolFSCommandlineOption `xml:"option"`
}

type StoragePoolFSCommandlineOption Uses

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

type StoragePoolPCIAddress Uses

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

func (*StoragePoolPCIAddress) MarshalXML Uses

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

func (*StoragePoolPCIAddress) UnmarshalXML Uses

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

type StoragePoolRBDCommandline Uses

❖
type StoragePoolRBDCommandline struct {
    XMLName xml.Name                          `xml:"http://libvirt.org/schemas/storagepool/rbd/1.0 config_opts"`
    Options []StoragePoolRBDCommandlineOption `xml:"option"`
}

type StoragePoolRBDCommandlineOption Uses

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

type StoragePoolRefresh Uses

❖
type StoragePoolRefresh struct {
    Volume StoragePoolRefreshVol `xml:"volume"`
}

type StoragePoolRefreshVol Uses

❖
type StoragePoolRefreshVol struct {
    Allocation string `xml:"allocation,attr"`
}

type StoragePoolSize Uses

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

type StoragePoolSource Uses

❖
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    *