diff --git a/go.mod b/go.mod index e25ea9e6f..656174ae5 100644 --- a/go.mod +++ b/go.mod @@ -11,8 +11,8 @@ require ( github.com/golang/mock v1.2.0 github.com/golang/protobuf v1.4.2 // indirect github.com/json-iterator/go v1.1.9 // indirect - github.com/libvirt/libvirt-go v4.10.0+incompatible - github.com/libvirt/libvirt-go-xml v4.10.0+incompatible + github.com/libvirt/libvirt-go v5.10.0+incompatible + github.com/libvirt/libvirt-go-xml v5.10.0+incompatible github.com/openshift/machine-api-operator v0.2.1-0.20200513150041-09efe6c914b4 github.com/pkg/errors v0.9.1 // indirect github.com/spf13/cobra v1.0.0 // indirect @@ -35,8 +35,3 @@ require ( k8s.io/utils v0.0.0-20200414100711-2df71ebbae66 // indirect sigs.k8s.io/controller-runtime v0.5.1-0.20200330174416-a11a908d91e0 ) - -replace ( - github.com/libvirt/libvirt-go => github.com/libvirt/libvirt-go v4.6.0+incompatible - github.com/libvirt/libvirt-go-xml => github.com/libvirt/libvirt-go-xml v4.6.0+incompatible -) diff --git a/go.sum b/go.sum index 64aaf424c..6fbf632bf 100644 --- a/go.sum +++ b/go.sum @@ -295,10 +295,10 @@ github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kubernetes-sigs/kube-storage-version-migrator v0.0.0-20191127225502-51849bc15f17/go.mod h1:enH0BVV+4+DAgWdwSlMefG8bBzTfVMTr1lApzdLZ/cc= -github.com/libvirt/libvirt-go v4.6.0+incompatible h1:7OenwWTPRPSYIkJMMSX9loYLBBOaGdOjxZHTkXSe67E= -github.com/libvirt/libvirt-go v4.6.0+incompatible/go.mod h1:34zsnB4iGeOv7Byj6qotuW8Ya4v4Tr43ttjz/F0wjLE= -github.com/libvirt/libvirt-go-xml v4.6.0+incompatible h1:dL2JDzkEtsiZkPh42KHvLt208wgNfO40IsBjHtaXohs= -github.com/libvirt/libvirt-go-xml v4.6.0+incompatible/go.mod h1:oBlgD3xOA01ihiK5stbhFzvieyW+jVS6kbbsMVF623A= +github.com/libvirt/libvirt-go v5.10.0+incompatible h1:01fwkdUHH2hk4YyFNCr48OvSGqXYLzp9cofUpeyeLNc= +github.com/libvirt/libvirt-go v5.10.0+incompatible/go.mod h1:34zsnB4iGeOv7Byj6qotuW8Ya4v4Tr43ttjz/F0wjLE= +github.com/libvirt/libvirt-go-xml v5.10.0+incompatible h1:kcgVynR4a9cuh/kc7Ywl8XRBUxbqe05seR2qgN+yTno= +github.com/libvirt/libvirt-go-xml v5.10.0+incompatible/go.mod h1:oBlgD3xOA01ihiK5stbhFzvieyW+jVS6kbbsMVF623A= github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de h1:9TO3cAIGXtEhnIaL+V+BEER86oLrvS+kWobKpbJuye0= github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de/go.mod h1:zAbeS9B/r2mtpb6U+EI2rYA5OAXxsYw6wTamcNW+zcE= github.com/lithammer/dedent v1.1.0/go.mod h1:jrXYCQtgg0nJiN+StA2KgR7w6CiQNv9Fd/Z9BP0jIOc= diff --git a/pkg/cloud/libvirt/client/client.go b/pkg/cloud/libvirt/client/client.go index 47edf9f95..d5a0e6f8f 100644 --- a/pkg/cloud/libvirt/client/client.go +++ b/pkg/cloud/libvirt/client/client.go @@ -186,8 +186,13 @@ func (client *libvirtClient) CreateDomain(ctx context.Context, input CreateDomai return fmt.Errorf("Failed to newDomainDefForConnection: %s", err) } + arch, err := getHostArchitecture(client.connection) + if err != nil { + return fmt.Errorf("Error retrieving host architecture: %s", err) + } + // Get values from machineProviderConfig - if err := domainDefInit(&domainDef, input.DomainName, input.DomainMemory, input.DomainVcpu); err != nil { + if err := domainDefInit(&domainDef, &input, arch); err != nil { return fmt.Errorf("Failed to init domain definition from machineProviderConfig: %v", err) } @@ -203,11 +208,6 @@ func (client *libvirtClient) CreateDomain(ctx context.Context, input CreateDomai glog.Info("Create ignition configuration") - arch, err := getHostArchitecture(client.connection) - if err != nil { - return fmt.Errorf("Error retrieving host architecture: %s", err) - } - if input.Ignition != nil { if err := setIgnition(ctx, &domainDef, client, input.Ignition, input.KubeClient, input.MachineNamespace, input.IgnitionVolumeName, arch); err != nil { return err diff --git a/pkg/cloud/libvirt/client/domain.go b/pkg/cloud/libvirt/client/domain.go index 4c7d65618..2d613a796 100644 --- a/pkg/cloud/libvirt/client/domain.go +++ b/pkg/cloud/libvirt/client/domain.go @@ -460,35 +460,43 @@ type Config struct { URI string } -func domainDefInit(domainDef *libvirtxml.Domain, name string, memory, vcpu int) error { - if name != "" { - domainDef.Name = name +func setFirmware(input *CreateDomainInput, domainDef *libvirtxml.Domain, arch string) { + // for aarch64 speciffying this will automatically select the firmware and NVRAM file + // reference: https://libvirt.org/formatdomain.html#bios-bootloader + if arch == "aarch64" { + domainDef.OS.Firmware = "efi" + } +} + +func domainDefInit(domainDef *libvirtxml.Domain, input *CreateDomainInput, arch string) error { + if input.DomainName != "" { + domainDef.Name = input.DomainName } else { return fmt.Errorf("machine does not have an name set") } - if memory != 0 { + if input.DomainMemory != 0 { domainDef.Memory = &libvirtxml.DomainMemory{ - Value: uint(memory), + Value: uint(input.DomainMemory), Unit: "MiB", } } else { return fmt.Errorf("machine does not have an DomainMemory set") } - if vcpu != 0 { + if input.DomainVcpu != 0 { domainDef.VCPU = &libvirtxml.DomainVCPU{ - Value: vcpu, + Value: input.DomainVcpu, } } else { return fmt.Errorf("machine does not have an DomainVcpu set") } domainDef.CPU.Mode = "host-passthrough" + setFirmware(input, domainDef, arch) //setConsoles(d, &domainDef) //setCmdlineArgs(d, &domainDef) - //setFirmware(d, &domainDef) //setBootDevices(d, &domainDef) return nil diff --git a/vendor/github.com/libvirt/libvirt-go-xml/capabilities.go b/vendor/github.com/libvirt/libvirt-go-xml/capabilities.go index 2efaa997f..2244bd600 100644 --- a/vendor/github.com/libvirt/libvirt-go-xml/capabilities.go +++ b/vendor/github.com/libvirt/libvirt-go-xml/capabilities.go @@ -150,6 +150,7 @@ type CapsHost struct { MigrationFeatures *CapsHostMigrationFeatures `xml:"migration_features"` NUMA *CapsHostNUMATopology `xml:"topology"` Cache *CapsHostCache `xml:"cache"` + MemoryBandwidth *CapsHostMemoryBandwidth `xml:"memory_bandwidth"` SecModel []CapsHostSecModel `xml:"secmodel"` } @@ -167,7 +168,8 @@ type CapsHostIOMMU struct { } type CapsHostCache struct { - Banks []CapsHostCacheBank `xml:"bank"` + Banks []CapsHostCacheBank `xml:"bank"` + Monitor *CapsHostCacheMonitor `xml:"monitor"` } type CapsHostCacheBank struct { @@ -180,6 +182,17 @@ type CapsHostCacheBank struct { Control []CapsHostCacheControl `xml:"control"` } +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 struct { + Name string `xml:"name,attr"` +} + type CapsHostCacheControl struct { Granularity uint `xml:"granularity,attr"` Min uint `xml:"min,attr,omitempty"` @@ -188,6 +201,32 @@ type CapsHostCacheControl struct { MaxAllows uint `xml:"maxAllocs,attr"` } +type CapsHostMemoryBandwidth struct { + Nodes []CapsHostMemoryBandwidthNode `xml:"node"` + Monitor *CapsHostMemoryBandwidthMonitor `xml:"monitor"` +} + +type CapsHostMemoryBandwidthNode struct { + ID uint `xml:"id,attr"` + CPUs string `xml:"cpus,attr"` + Control *CapsHostMemoryBandwidthNodeControl `xml:"control"` +} + +type CapsHostMemoryBandwidthNodeControl struct { + Granularity uint `xml:"granularity,attr"` + Min uint `xml:"min,attr"` + MaxAllocs uint `xml:"maxAllocs,attr"` +} + +type CapsHostMemoryBandwidthMonitor struct { + MaxMonitors uint `xml:"maxMonitors,attr"` + Features []CapsHostMemoryBandwidthMonitorFeature `xml:"feature"` +} + +type CapsHostMemoryBandwidthMonitorFeature struct { + Name string `xml:"name,attr"` +} + type CapsGuestMachine struct { Name string `xml:",chardata"` MaxCPUs int `xml:"maxCpus,attr,omitempty"` diff --git a/vendor/github.com/libvirt/libvirt-go-xml/doc.go b/vendor/github.com/libvirt/libvirt-go-xml/doc.go index 2886c7924..25bc1d5f2 100644 --- a/vendor/github.com/libvirt/libvirt-go-xml/doc.go +++ b/vendor/github.com/libvirt/libvirt-go-xml/doc.go @@ -33,30 +33,38 @@ // // Example creating a domain XML document from configuration: // +// package main +// // import ( // "github.com/libvirt/libvirt-go-xml" // ) // -// domcfg := &libvirtxml.Domain{Type: "kvm", Name: "demo", -// UUID: "8f99e332-06c4-463a-9099-330fb244e1b3", -// ....} -// xmldoc, err := domcfg.Marshal() +// 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" // ) // -// conn, err := libvirt.NewConnect("qemu:///system") -// dom := conn.LookupDomainByName("demo") -// xmldoc, err := dom.GetXMLDesc(0) +// 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) +// domcfg := &libvirtxml.Domain{} +// err = domcfg.Unmarshal(xmldoc) // -// fmt.Printf("Virt type %s", domcfg.Type) +// fmt.Printf("Virt type %s\n", domcfg.Type) +// } // package libvirtxml diff --git a/vendor/github.com/libvirt/libvirt-go-xml/domain.go b/vendor/github.com/libvirt/libvirt-go-xml/domain.go index 5b0ab435c..49f0d5120 100644 --- a/vendor/github.com/libvirt/libvirt-go-xml/domain.go +++ b/vendor/github.com/libvirt/libvirt-go-xml/domain.go @@ -71,6 +71,10 @@ type DomainControllerVirtIOSerial struct { Vectors *uint `xml:"vectors,attr"` } +type DomainControllerXenBus struct { + MaxGrantFrames uint `xml:"maxGrantFrames,attr,omitempty"` +} + type DomainControllerDriver struct { Queues *uint `xml:"queues,attr"` CmdPerLUN *uint `xml:"cmd_per_lun,attr"` @@ -90,6 +94,7 @@ type DomainController struct { PCI *DomainControllerPCI `xml:"-"` USB *DomainControllerUSB `xml:"-"` VirtIOSerial *DomainControllerVirtIOSerial `xml:"-"` + XenBus *DomainControllerXenBus `xml:"-"` Alias *DomainAlias `xml:"alias"` Address *DomainAddress `xml:"address"` } @@ -127,6 +132,7 @@ type DomainDiskSource struct { 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"` } @@ -146,13 +152,22 @@ type DomainDiskSourceDir struct { } 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"` - Snapshot *DomainDiskSourceNetworkSnapshot `xml:"snapshot"` - Config *DomainDiskSourceNetworkConfig `xml:"config"` - Auth *DomainDiskAuth `xml:"auth"` + Protocol string `xml:"protocol,attr,omitempty"` + Name string `xml:"name,attr,omitempty"` + TLS string `xml:"tls,attr,omitempty"` + Hosts []DomainDiskSourceHost `xml:"host"` + Initiator *DomainDiskSourceNetworkInitiator `xml:"initiator"` + Snapshot *DomainDiskSourceNetworkSnapshot `xml:"snapshot"` + Config *DomainDiskSourceNetworkConfig `xml:"config"` + Auth *DomainDiskAuth `xml:"auth"` +} + +type DomainDiskSourceNetworkInitiator struct { + IQN *DomainDiskSourceNetworkIQN `xml:"iqn"` +} + +type DomainDiskSourceNetworkIQN struct { + Name string `xml:"name,attr,omitempty"` } type DomainDiskSourceNetworkSnapshot struct { @@ -256,10 +271,11 @@ type DomainDiskBackingStore struct { } type DomainDiskMirror struct { - Job string `xml:"job,attr,omitempty"` - Ready string `xml:"ready,attr,omitempty"` - Format *DomainDiskFormat `xml:"format"` - Source *DomainDiskSource `xml:"source"` + Job string `xml:"job,attr,omitempty"` + Ready string `xml:"ready,attr,omitempty"` + Format *DomainDiskFormat `xml:"format"` + Source *DomainDiskSource `xml:"source"` + BackingStore *DomainDiskBackingStore `xml:"backingStore"` } type DomainDisk struct { @@ -268,6 +284,7 @@ type DomainDisk struct { 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"` @@ -359,6 +376,7 @@ type DomainFilesystemSpaceSoftLimit struct { 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"` @@ -421,6 +439,8 @@ type DomainInterfaceSourceMCast struct { 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 DomainInterfaceSourceBridge struct { @@ -453,7 +473,8 @@ type DomainInterfaceSourceLocal struct { } type DomainInterfaceTarget struct { - Dev string `xml:"dev,attr"` + Dev string `xml:"dev,attr"` + Managed string `xml:"managed,attr,omitempty"` } type DomainInterfaceLink struct { @@ -722,7 +743,7 @@ type DomainChardevSourceTCP struct { type DomainChardevSourceUNIX struct { Mode string `xml:"mode,attr,omitempty"` - Path string `xml:"path,attr"` + Path string `xml:"path,attr,omitempty"` Reconnect *DomainChardevSourceReconnect `xml:"reconnect"` SecLabel []DomainDeviceSecLabel `xml:"seclabel"` } @@ -792,11 +813,17 @@ type DomainAlias struct { } 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"` + 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"` +} + +type DomainAddressZPCI struct { + UID *uint `xml:"uid,attr,omitempty"` + FID *uint `xml:"fid,attr,omitempty"` } type DomainAddressUSB struct { @@ -939,6 +966,7 @@ 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"` @@ -1086,7 +1114,12 @@ type DomainGraphicSpice struct { GL *DomainGraphicSpiceGL `xml:"gl"` } +type DomainGraphicEGLHeadlessGL struct { + RenderNode string `xml:"rendernode,attr,omitempty"` +} + type DomainGraphicEGLHeadless struct { + GL *DomainGraphicEGLHeadlessGL `xml:"gl"` } type DomainGraphic struct { @@ -1100,19 +1133,26 @@ type DomainGraphic struct { } type DomainVideoAccel struct { - Accel3D string `xml:"accel3d,attr,omitempty"` - Accel2D string `xml:"accel2d,attr,omitempty"` + Accel3D string `xml:"accel3d,attr,omitempty"` + Accel2D string `xml:"accel2d,attr,omitempty"` + RenderNode string `xml:"rendernode,attr,omitempty"` +} + +type DomainVideoResolution struct { + X uint `xml:"x,attr"` + Y uint `xml:"y,attr"` } type DomainVideoModel struct { - Type string `xml:"type,attr"` - Heads uint `xml:"heads,attr,omitempty"` - Ram uint `xml:"ram,attr,omitempty"` - VRam uint `xml:"vram,attr,omitempty"` - VRam64 uint `xml:"vram64,attr,omitempty"` - VGAMem uint `xml:"vgamem,attr,omitempty"` - Primary string `xml:"primary,attr,omitempty"` - Accel *DomainVideoAccel `xml:"acceleration"` + Type 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 DomainVideo struct { @@ -1124,6 +1164,7 @@ type DomainVideo struct { } 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"` @@ -1251,6 +1292,7 @@ type DomainHostdevSubsysSCSISourceISCSI struct { } type DomainHostdevSubsysSCSIHost struct { + Model string `xml:"model,attr,omitempty"` Source *DomainHostdevSubsysSCSIHostSource `xml:"source"` } @@ -1283,6 +1325,7 @@ type DomainHostdevSubsysMDevSource struct { 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"` } @@ -1341,9 +1384,14 @@ type DomainHostdev struct { } type DomainMemorydevSource struct { - NodeMask string `xml:"nodemask,omitempty"` - PageSize *DomainMemorydevSourcePagesize `xml:"pagesize"` - Path string `xml:"path,omitempty"` + NodeMask string `xml:"nodemask,omitempty"` + PageSize *DomainMemorydevSourcePagesize `xml:"pagesize"` + Path string `xml:"path,omitempty"` + AlignSize *DomainMemorydevSourceAlignsize `xml:"alignsize"` + PMem *DomainMemorydevSourcePMem `xml:"pmem"` +} + +type DomainMemorydevSourcePMem struct { } type DomainMemorydevSourcePagesize struct { @@ -1351,10 +1399,18 @@ type DomainMemorydevSourcePagesize struct { Unit string `xml:"unit,attr,omitempty"` } +type DomainMemorydevSourceAlignsize struct { + Value uint64 `xml:",chardata"` + Unit string `xml:"unit,attr,omitempty"` +} + type DomainMemorydevTargetNode struct { Value uint `xml:",chardata"` } +type DomainMemorydevTargetReadOnly struct { +} + type DomainMemorydevTargetSize struct { Value uint `xml:",chardata"` Unit string `xml:"unit,attr,omitempty"` @@ -1365,9 +1421,10 @@ type DomainMemorydevTargetLabel struct { } type DomainMemorydevTarget struct { - Size *DomainMemorydevTargetSize `xml:"size"` - Node *DomainMemorydevTargetNode `xml:"node"` - Label *DomainMemorydevTargetLabel `xml:"label"` + Size *DomainMemorydevTargetSize `xml:"size"` + Node *DomainMemorydevTargetNode `xml:"node"` + Label *DomainMemorydevTargetLabel `xml:"label"` + ReadOnly *DomainMemorydevTargetReadOnly `xml:"readonly"` } type DomainMemorydev struct { @@ -1459,7 +1516,12 @@ type DomainTPMBackendPassthrough struct { } type DomainTPMBackendEmulator struct { - Version string `xml:"version,attr,omitempty"` + Version string `xml:"version,attr,omitempty"` + Encryption *DomainTPMBackendEncryption `xml:"encryption"` +} + +type DomainTPMBackendEncryption struct { + Secret string `xml:"secret,attr"` } type DomainTPMBackendDevice struct { @@ -1682,6 +1744,7 @@ type DomainOSInitEnv struct { 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"` @@ -1826,21 +1889,32 @@ type DomainFeatureHyperVSpinlocks struct { Retries uint `xml:"retries,attr,omitempty"` } +type DomainFeatureHyperVSTimer struct { + DomainFeatureState + Direct *DomainFeatureState `xml:"direct"` +} + type DomainFeatureHyperV struct { DomainFeature - Relaxed *DomainFeatureState `xml:"relaxed"` - VAPIC *DomainFeatureState `xml:"vapic"` - Spinlocks *DomainFeatureHyperVSpinlocks `xml:"spinlocks"` - VPIndex *DomainFeatureState `xml:"vpindex"` - Runtime *DomainFeatureState `xml:"runtime"` - Synic *DomainFeatureState `xml:"synic"` - STimer *DomainFeatureState `xml:"stimer"` - Reset *DomainFeatureState `xml:"reset"` - VendorId *DomainFeatureHyperVVendorId `xml:"vendor_id"` + 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 DomainFeatureKVM struct { - Hidden *DomainFeatureState `xml:"hidden"` + Hidden *DomainFeatureState `xml:"hidden"` + HintDedicated *DomainFeatureState `xml:"hint-dedicated"` } type DomainFeatureGIC struct { @@ -1928,6 +2002,10 @@ type DomainFeatureCapabilities struct { WakeAlarm *DomainFeatureCapability `xml:"wake_alarm"` } +type DomainFeatureMSRS struct { + Unknown string `xml:"unknown,attr"` +} + type DomainFeatureList struct { PAE *DomainFeature `xml:"pae"` ACPI *DomainFeature `xml:"acpi"` @@ -1945,8 +2023,11 @@ type DomainFeatureList struct { 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 DomainCPUTuneShares struct { @@ -1987,9 +2068,15 @@ type DomainCPUTuneIOThreadSched struct { Priority *int `xml:"priority,attr"` } +type DomainCPUTuneEmulatorSched struct { + Scheduler string `xml:"scheduler,attr,omitempty"` + Priority *int `xml:"priority,attr"` +} + type DomainCPUCacheTune struct { - VCPUs string `xml:"vcpus,attr,omitempty"` - Cache []DomainCPUCacheTuneCache `xml:"cache"` + VCPUs string `xml:"vcpus,attr,omitempty"` + Cache []DomainCPUCacheTuneCache `xml:"cache"` + Monitor []DomainCPUCacheTuneMonitor `xml:"monitor"` } type DomainCPUCacheTuneCache struct { @@ -2000,6 +2087,21 @@ type DomainCPUCacheTuneCache struct { Unit string `xml:"unit,attr"` } +type DomainCPUCacheTuneMonitor struct { + Level uint `xml:"level,attr,omitempty"` + VCPUs string `xml:"vcpus,attr,omitempty"` +} + +type DomainCPUMemoryTune struct { + VCPUs string `xml:"vcpus,attr"` + Nodes []DomainCPUMemoryTuneNode `xml:"node"` +} + +type DomainCPUMemoryTuneNode struct { + ID uint `xml:"id,attr"` + Bandwidth uint `xml:"bandwidth,attr"` +} + type DomainCPUTune struct { Shares *DomainCPUTuneShares `xml:"shares"` Period *DomainCPUTunePeriod `xml:"period"` @@ -2014,8 +2116,10 @@ type DomainCPUTune struct { 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 DomainQEMUCommandlineArg struct { @@ -2033,6 +2137,15 @@ type DomainQEMUCommandline struct { Envs []DomainQEMUCommandlineEnv `xml:"env"` } +type DomainQEMUCapabilitiesEntry struct { + Name string `xml:"capability,attr"` +} +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 DomainLXCNamespace struct { XMLName xml.Name `xml:"http://libvirt.org/schemas/domain/lxc/1.0 namespace"` ShareNet *DomainLXCNamespaceMap `xml:"sharenet"` @@ -2045,6 +2158,21 @@ type DomainLXCNamespaceMap struct { Value string `xml:"value,attr"` } +type DomainBHyveCommandlineArg struct { + Value string `xml:"value,attr"` +} + +type DomainBHyveCommandlineEnv struct { + Name string `xml:"name,attr"` + Value string `xml:"value,attr,omitempty"` +} + +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 DomainBlockIOTune struct { Weight uint `xml:"weight,omitempty"` Device []DomainBlockIOTuneDevice `xml:"device"` @@ -2167,48 +2295,52 @@ type DomainGenID struct { // matching the order of XML elements that libvirt // will generate when dumping XML. 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"` + 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 - KeyWrap *DomainKeyWrap `xml:"keywrap"` - LaunchSecurity *DomainLaunchSecurity `xml:"launchSecurity"` } func (d *Domain) Unmarshal(doc string) error { @@ -2240,6 +2372,11 @@ type domainControllerVirtIOSerial struct { domainController } +type domainControllerXenBus struct { + DomainControllerXenBus + domainController +} + func (a *DomainControllerPCITarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error { marshalUintAttr(&start, "chassisNr", a.ChassisNr, "%d") marshalUintAttr(&start, "chassis", a.Chassis, "%d") @@ -2337,6 +2474,13 @@ func (a *DomainController) MarshalXML(e *xml.Encoder, start xml.StartElement) er vioserial.DomainControllerVirtIOSerial = *a.VirtIOSerial } return e.EncodeElement(vioserial, start) + } else if a.Type == "xenbus" { + xenbus := domainControllerXenBus{} + xenbus.domainController = domainController(*a) + if a.XenBus != nil { + xenbus.DomainControllerXenBus = *a.XenBus + } + return e.EncodeElement(xenbus, start) } else { gen := domainController(*a) return e.EncodeElement(gen, start) @@ -2384,6 +2528,15 @@ func (a *DomainController) UnmarshalXML(d *xml.Decoder, start xml.StartElement) *a = DomainController(vioserial.domainController) a.VirtIOSerial = &vioserial.DomainControllerVirtIOSerial return nil + } else if typ == "xenbus" { + var xenbus domainControllerXenBus + err := d.DecodeElement(&xenbus, &start) + if err != nil { + return err + } + *a = DomainController(xenbus.domainController) + a.XenBus = &xenbus.DomainControllerXenBus + return nil } else { var gen domainController err := d.DecodeElement(&gen, &start) @@ -3511,7 +3664,7 @@ func (a *DomainChardevSource) MarshalXML(e *xml.Encoder, start xml.StartElement) } else if a.TCP != nil { return e.EncodeElement(a.TCP, start) } else if a.UNIX != nil { - if a.UNIX.Path == "" { + if a.UNIX.Path == "" && a.UNIX.Mode == "" { return nil } return e.EncodeElement(a.UNIX, start) @@ -4489,6 +4642,22 @@ func (a *DomainAddressPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) er }) } e.EncodeToken(start) + if a.ZPCI != nil { + zpci := xml.StartElement{} + zpci.Name.Local = "zpci" + err := e.EncodeElement(a.ZPCI, zpci) + if err != nil { + return err + } + } + e.EncodeToken(start.End()) + return nil +} + +func (a *DomainAddressZPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + marshalUintAttr(&start, "uid", a.UID, "0x%04x") + marshalUintAttr(&start, "fid", a.FID, "0x%04x") + e.EncodeToken(start) e.EncodeToken(start.End()) return nil } @@ -4703,6 +4872,43 @@ func (a *DomainAddressPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) a.MultiFunction = attr.Value } } + + for { + tok, err := d.Token() + if err == io.EOF { + break + } + if err != nil { + return err + } + + switch tok := tok.(type) { + case xml.StartElement: + if tok.Name.Local == "zpci" { + a.ZPCI = &DomainAddressZPCI{} + err = d.DecodeElement(a.ZPCI, &tok) + if err != nil { + return err + } + } + } + } + return nil +} + +func (a *DomainAddressZPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + for _, attr := range start.Attr { + if attr.Name.Local == "fid" { + if err := unmarshalUintAttr(attr.Value, &a.FID, 0); err != nil { + return err + } + } else if attr.Name.Local == "uid" { + if err := unmarshalUintAttr(attr.Value, &a.UID, 0); err != nil { + return err + } + } + } + d.Skip() return nil } diff --git a/vendor/github.com/libvirt/libvirt-go-xml/domain_capabilities.go b/vendor/github.com/libvirt/libvirt-go-xml/domain_capabilities.go index 0faa06a24..1eed5d8d7 100644 --- a/vendor/github.com/libvirt/libvirt-go-xml/domain_capabilities.go +++ b/vendor/github.com/libvirt/libvirt-go-xml/domain_capabilities.go @@ -37,7 +37,7 @@ type DomainCaps struct { Arch string `xml:"arch"` VCPU *DomainCapsVCPU `xml:"vcpu"` IOThreads *DomainCapsIOThreads `xml:"iothreads"` - OS DomainCapsOS `xml:"os"` + OS *DomainCapsOS `xml:"os"` CPU *DomainCapsCPU `xml:"cpu"` Devices *DomainCapsDevices `xml:"devices"` Features *DomainCapsFeatures `xml:"features"` @@ -50,6 +50,7 @@ type DomainCapsVCPU struct { type DomainCapsOS struct { Supported string `xml:"supported,attr"` Loader *DomainCapsOSLoader `xml:"loader"` + Enums []DomainCapsEnum `xml:"enum"` } type DomainCapsOSLoader struct { @@ -95,6 +96,7 @@ type DomainCapsDevices struct { Graphics *DomainCapsDevice `xml:"graphics"` Video *DomainCapsDevice `xml:"video"` HostDev *DomainCapsDevice `xml:"hostdev"` + RNG *DomainCapsDevice `xml:"rng"` } type DomainCapsDevice struct { @@ -103,10 +105,11 @@ type DomainCapsDevice struct { } type DomainCapsFeatures struct { - GIC *DomainCapsFeatureGIC `xml:"gic"` - VMCoreInfo *DomainCapsFeatureVMCoreInfo `xml:"vmcoreinfo"` - GenID *DomainCapsFeatureGenID `xml:"genid"` - SEV *DomainCapsFeatureSEV `xml:"sev"` + GIC *DomainCapsFeatureGIC `xml:"gic"` + VMCoreInfo *DomainCapsFeatureVMCoreInfo `xml:"vmcoreinfo"` + GenID *DomainCapsFeatureGenID `xml:"genid"` + BackingStoreInput *DomainCapsFeatureBackingStoreInput `xml:"backingStoreInput"` + SEV *DomainCapsFeatureSEV `xml:"sev"` } type DomainCapsFeatureGIC struct { @@ -122,6 +125,10 @@ type DomainCapsFeatureGenID struct { Supported string `xml:"supported,attr"` } +type DomainCapsFeatureBackingStoreInput struct { + Supported string `xml:"supported,attr"` +} + type DomainCapsFeatureSEV struct { Supported string `xml:"supported,attr"` CBitPos uint `xml:"cbitpos,omitempty"` diff --git a/vendor/github.com/libvirt/libvirt-go-xml/network.go b/vendor/github.com/libvirt/libvirt-go-xml/network.go index 33851baba..c0c98ac5a 100644 --- a/vendor/github.com/libvirt/libvirt-go-xml/network.go +++ b/vendor/github.com/libvirt/libvirt-go-xml/network.go @@ -34,6 +34,7 @@ type NetworkBridge struct { 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 NetworkVirtualPort struct { @@ -252,6 +253,8 @@ type Network struct { Routes []NetworkRoute `xml:"route"` VirtualPort *NetworkVirtualPort `xml:"virtualport"` PortGroups []NetworkPortGroup `xml:"portgroup"` + + DnsmasqOptions *NetworkDnsmasqOptions } type NetworkPortGroup struct { @@ -281,10 +284,20 @@ type NetworkBandwidthParams struct { } type NetworkBandwidth struct { + ClassID uint `xml:"classID,attr,omitempty"` Inbound *NetworkBandwidthParams `xml:"inbound"` Outbound *NetworkBandwidthParams `xml:"outbound"` } +type NetworkDnsmasqOptions struct { + XMLName xml.Name `xml:"http://libvirt.org/schemas/network/dnsmasq/1.0 options"` + Option []NetworkDnsmasqOption `xml:"option"` +} + +type NetworkDnsmasqOption struct { + Value string `xml:"value,attr"` +} + func (a *NetworkVirtualPortParams) MarshalXML(e *xml.Encoder, start xml.StartElement) error { start.Name.Local = "parameters" if a.Any != nil { diff --git a/vendor/github.com/libvirt/libvirt-go-xml/network_port.go b/vendor/github.com/libvirt/libvirt-go-xml/network_port.go new file mode 100644 index 000000000..3cbc7fb14 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go-xml/network_port.go @@ -0,0 +1,200 @@ +/* + * This file is part of the libvirt-go-xml project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +package libvirtxml + +import ( + "encoding/xml" + "fmt" +) + +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"` +} + +type NetworkPortOwner struct { + UUID string `xml:"uuid,omitempty"` + Name string `xml:"name,omitempty"` +} + +type NetworkPortMAC struct { + Address string `xml:"address,attr"` +} + +type NetworkPortRXFilters struct { + TrustGuest string `xml:"trustGuest,attr"` +} + +type NetworkPortPlug struct { + Bridge *NetworkPortPlugBridge `xml:"-"` + Network *NetworkPortPlugNetwork `xml:"-"` + Direct *NetworkPortPlugDirect `xml:"-"` + HostDevPCI *NetworkPortPlugHostDevPCI `xml:"-"` +} + +type NetworkPortPlugBridge struct { + Bridge string `xml:"bridge,attr"` + MacTableManager string `xml:"macTableManager,attr,omitempty"` +} + +type NetworkPortPlugNetwork struct { + Bridge string `xml:"bridge,attr"` + MacTableManager string `xml:"macTableManager,attr,omitempty"` +} + +type NetworkPortPlugDirect struct { + Dev string `xml:"dev,attr"` + Mode string `xml:"mode,attr"` +} + +type NetworkPortPlugHostDevPCI struct { + Managed string `xml:"managed,attr,omitempty"` + Driver *NetworkPortPlugHostDevPCIDriver `xml:"driver"` + Address *NetworkPortPlugHostDevPCIAddress `xml:"address"` +} + +type NetworkPortPlugHostDevPCIDriver struct { + Name string `xml:"name,attr"` +} + +type NetworkPortPlugHostDevPCIAddress struct { + Domain *uint `xml:"domain,attr"` + Bus *uint `xml:"bus,attr"` + Slot *uint `xml:"slot,attr"` + Function *uint `xml:"function,attr"` +} + +func (a *NetworkPortPlugHostDevPCIAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + marshalUintAttr(&start, "domain", a.Domain, "0x%04x") + marshalUintAttr(&start, "bus", a.Bus, "0x%02x") + marshalUintAttr(&start, "slot", a.Slot, "0x%02x") + marshalUintAttr(&start, "function", a.Function, "0x%x") + e.EncodeToken(start) + e.EncodeToken(start.End()) + return nil +} + +func (a *NetworkPortPlugHostDevPCIAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + for _, attr := range start.Attr { + if attr.Name.Local == "domain" { + if err := unmarshalUintAttr(attr.Value, &a.Domain, 0); err != nil { + return err + } + } else if attr.Name.Local == "bus" { + if err := unmarshalUintAttr(attr.Value, &a.Bus, 0); err != nil { + return err + } + } else if attr.Name.Local == "slot" { + if err := unmarshalUintAttr(attr.Value, &a.Slot, 0); err != nil { + return err + } + } else if attr.Name.Local == "function" { + if err := unmarshalUintAttr(attr.Value, &a.Function, 0); err != nil { + return err + } + } + } + d.Skip() + return nil +} + +func (p *NetworkPortPlug) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + start.Name.Local = "plug" + if p.Bridge != nil { + start.Attr = append(start.Attr, xml.Attr{ + xml.Name{Local: "type"}, "bridge", + }) + return e.EncodeElement(p.Bridge, start) + } else if p.Network != nil { + start.Attr = append(start.Attr, xml.Attr{ + xml.Name{Local: "type"}, "network", + }) + return e.EncodeElement(p.Network, start) + } else if p.Direct != nil { + start.Attr = append(start.Attr, xml.Attr{ + xml.Name{Local: "type"}, "direct", + }) + return e.EncodeElement(p.Direct, start) + } else if p.HostDevPCI != nil { + start.Attr = append(start.Attr, xml.Attr{ + xml.Name{Local: "type"}, "hostdev-pci", + }) + return e.EncodeElement(p.HostDevPCI, start) + } + return nil +} + +func (p *NetworkPortPlug) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + typ, ok := getAttr(start.Attr, "type") + if !ok { + return fmt.Errorf("Missing type attribute on plug") + } else if typ == "bridge" { + var pb NetworkPortPlugBridge + if err := d.DecodeElement(&pb, &start); err != nil { + return err + } + p.Bridge = &pb + } else if typ == "network" { + var pn NetworkPortPlugNetwork + if err := d.DecodeElement(&pn, &start); err != nil { + return err + } + p.Network = &pn + } else if typ == "direct" { + var pd NetworkPortPlugDirect + if err := d.DecodeElement(&pd, &start); err != nil { + return err + } + p.Direct = &pd + } else if typ == "hostdev-pci" { + var ph NetworkPortPlugHostDevPCI + if err := d.DecodeElement(&ph, &start); err != nil { + return err + } + p.HostDevPCI = &ph + } + d.Skip() + return nil +} + +func (s *NetworkPort) Unmarshal(doc string) error { + return xml.Unmarshal([]byte(doc), s) +} + +func (s *NetworkPort) Marshal() (string, error) { + doc, err := xml.MarshalIndent(s, "", " ") + if err != nil { + return "", err + } + return string(doc), nil +} diff --git a/vendor/github.com/libvirt/libvirt-go-xml/node_device.go b/vendor/github.com/libvirt/libvirt-go-xml/node_device.go index 7aacd0b66..ae92dcea8 100644 --- a/vendor/github.com/libvirt/libvirt-go-xml/node_device.go +++ b/vendor/github.com/libvirt/libvirt-go-xml/node_device.go @@ -93,6 +93,7 @@ type NodeDeviceNUMA struct { } type NodeDevicePCICapability struct { + Class string `xml:"class,omitempty"` Domain *uint `xml:"domain"` Bus *uint `xml:"bus"` Slot *uint `xml:"slot"` diff --git a/vendor/github.com/libvirt/libvirt-go-xml/nwfilter_binding.go b/vendor/github.com/libvirt/libvirt-go-xml/nwfilter_binding.go new file mode 100644 index 000000000..918ab714c --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go-xml/nwfilter_binding.go @@ -0,0 +1,73 @@ +/* + * This file is part of the libvirt-go-xml project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2017 Lian Duan + * + */ + +package libvirtxml + +import ( + "encoding/xml" +) + +type NWFilterBinding struct { + XMLName xml.Name `xml:"filterbinding"` + Owner *NWFilterBindingOwner `xml:"owner"` + PortDev *NWFilterBindingPortDev `xml:"portdev"` + MAC *NWFilterBindingMAC `xml:"mac"` + FilterRef *NWFilterBindingFilterRef `xml:"filterref"` +} + +type NWFilterBindingOwner struct { + UUID string `xml:"uuid,omitempty"` + Name string `xml:"name,omitempty"` +} + +type NWFilterBindingPortDev struct { + Name string `xml:"name,attr"` +} + +type NWFilterBindingMAC struct { + Address string `xml:"address,attr"` +} + +type NWFilterBindingFilterRef struct { + Filter string `xml:"filter,attr"` + Parameters []NWFilterBindingFilterParam `xml:"parameter"` +} + +type NWFilterBindingFilterParam struct { + Name string `xml:"name,attr"` + Value string `xml:"value,attr"` +} + +func (s *NWFilterBinding) Unmarshal(doc string) error { + return xml.Unmarshal([]byte(doc), s) +} + +func (s *NWFilterBinding) Marshal() (string, error) { + doc, err := xml.MarshalIndent(s, "", " ") + if err != nil { + return "", err + } + return string(doc), nil +} diff --git a/vendor/github.com/libvirt/libvirt-go-xml/storage_pool.go b/vendor/github.com/libvirt/libvirt-go-xml/storage_pool.go index e1cad8c1b..f3314dab1 100644 --- a/vendor/github.com/libvirt/libvirt-go-xml/storage_pool.go +++ b/vendor/github.com/libvirt/libvirt-go-xml/storage_pool.go @@ -55,6 +55,11 @@ type StoragePoolTarget struct { type StoragePoolSourceFormat struct { Type string `xml:"type,attr"` } + +type StoragePoolSourceProtocol struct { + Version string `xml:"ver,attr"` +} + type StoragePoolSourceHost struct { Name string `xml:"name,attr"` Port string `xml:"port,attr,omitempty"` @@ -133,20 +138,53 @@ type StoragePoolSource struct { Vendor *StoragePoolSourceVendor `xml:"vendor"` Product *StoragePoolSourceProduct `xml:"product"` Format *StoragePoolSourceFormat `xml:"format"` + Protocol *StoragePoolSourceProtocol `xml:"protocol"` Adapter *StoragePoolSourceAdapter `xml:"adapter"` Initiator *StoragePoolSourceInitiator `xml:"initiator"` } +type StoragePoolRefreshVol struct { + Allocation string `xml:"allocation,attr"` +} + +type StoragePoolRefresh struct { + Volume StoragePoolRefreshVol `xml:"volume"` +} + 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"` + 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 +} + +type StoragePoolFSCommandlineOption struct { + Name string `xml:"name,attr"` +} + +type StoragePoolFSCommandline struct { + XMLName xml.Name `xml:"http://libvirt.org/schemas/storagepool/fs/1.0 mount_opts"` + Options []StoragePoolFSCommandlineOption `xml:"option"` +} + +type StoragePoolRBDCommandlineOption struct { + Name string `xml:"name,attr"` + Value string `xml:"value,attr"` +} + +type StoragePoolRBDCommandline struct { + XMLName xml.Name `xml:"http://libvirt.org/schemas/storagepool/rbd/1.0 config_opts"` + Options []StoragePoolRBDCommandlineOption `xml:"option"` } func (a *StoragePoolPCIAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error { diff --git a/vendor/github.com/libvirt/libvirt-go/.travis.yml b/vendor/github.com/libvirt/libvirt-go/.travis.yml index 1bdb48f96..e4bb9890d 100644 --- a/vendor/github.com/libvirt/libvirt-go/.travis.yml +++ b/vendor/github.com/libvirt/libvirt-go/.travis.yml @@ -1,21 +1,23 @@ language: go os: linux -dist: trusty +dist: xenial sudo: require go: - - 1.5 - - 1.6 - - 1.7 - - 1.8 - - 1.9 + - "1.5" + - "1.6" + - "1.7" + - "1.8" + - "1.9" + - "1.10" + - "1.11" env: - - LIBVIRT=1.2.0 EXT=gz - - LIBVIRT=1.2.10 EXT=gz - - LIBVIRT=1.2.20 EXT=gz - - LIBVIRT=2.5.0 EXT=xz - - LIBVIRT=3.6.0 EXT=xz + - LIBVIRT=1.2.0 EXT=gz TEST_ARGS= + - LIBVIRT=1.2.20 EXT=gz TEST_ARGS="-tags integration" + - LIBVIRT=2.5.0 EXT=xz TEST_ARGS="-tags integration" + - LIBVIRT=3.6.0 EXT=xz TEST_ARGS="-tags integration" + - LIBVIRT=4.10.0 EXT=xz TEST_ARGS="-tags integration" install: - sudo apt-get -qqy build-dep libvirt @@ -39,4 +41,4 @@ install: - echo "pass" | sudo saslpasswd2 -p -a libvirt user script: - go test -timeout 1m -tags "integration" -v + go test -timeout 1m $TEST_ARGS -v diff --git a/vendor/github.com/libvirt/libvirt-go/connect.go b/vendor/github.com/libvirt/libvirt-go/connect.go index 8cc7cc771..f3660808d 100644 --- a/vendor/github.com/libvirt/libvirt-go/connect.go +++ b/vendor/github.com/libvirt/libvirt-go/connect.go @@ -75,6 +75,8 @@ const ( CONNECT_LIST_DOMAINS_NO_AUTOSTART = ConnectListAllDomainsFlags(C.VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART) CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = ConnectListAllDomainsFlags(C.VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) CONNECT_LIST_DOMAINS_NO_SNAPSHOT = ConnectListAllDomainsFlags(C.VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) + CONNECT_LIST_DOMAINS_HAS_CHECKPOINT = ConnectListAllDomainsFlags(C.VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT) + CONNECT_LIST_DOMAINS_NO_CHECKPOINT = ConnectListAllDomainsFlags(C.VIR_CONNECT_LIST_DOMAINS_NO_CHECKPOINT) ) type ConnectListAllNetworksFlags int @@ -110,6 +112,7 @@ const ( CONNECT_LIST_STORAGE_POOLS_GLUSTER = ConnectListAllStoragePoolsFlags(C.VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER) CONNECT_LIST_STORAGE_POOLS_ZFS = ConnectListAllStoragePoolsFlags(C.VIR_CONNECT_LIST_STORAGE_POOLS_ZFS) CONNECT_LIST_STORAGE_POOLS_VSTORAGE = ConnectListAllStoragePoolsFlags(C.VIR_CONNECT_LIST_STORAGE_POOLS_VSTORAGE) + CONNECT_LIST_STORAGE_POOLS_ISCSI_DIRECT = ConnectListAllStoragePoolsFlags(C.VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI_DIRECT) ) type ConnectBaselineCPUFlags int @@ -492,6 +495,90 @@ func closeCallback(conn C.virConnectPtr, reason ConnectCloseReason, goCallbackId callback(&Connect{ptr: conn}, reason) } +type ConnectIdentity struct { + UserNameSet bool + UserName string + UNIXUserIDSet bool + UNIXUserID uint64 + GroupNameSet bool + GroupName string + UNIXGroupIDSet bool + UNIXGroupID uint64 + ProcessIDSet bool + ProcessID int64 + ProcessTimeSet bool + ProcessTime uint64 + SASLUserNameSet bool + SASLUserName string + X509DistinguishedNameSet bool + X509DistinguishedName string + SELinuxContextSet bool + SELinuxContext string +} + +func getConnectIdentityFieldInfo(params *ConnectIdentity) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + C.VIR_CONNECT_IDENTITY_USER_NAME: typedParamsFieldInfo{ + set: ¶ms.UserNameSet, + s: ¶ms.UserName, + }, + C.VIR_CONNECT_IDENTITY_UNIX_USER_ID: typedParamsFieldInfo{ + set: ¶ms.UNIXUserIDSet, + ul: ¶ms.UNIXUserID, + }, + C.VIR_CONNECT_IDENTITY_GROUP_NAME: typedParamsFieldInfo{ + set: ¶ms.GroupNameSet, + s: ¶ms.GroupName, + }, + C.VIR_CONNECT_IDENTITY_UNIX_GROUP_ID: typedParamsFieldInfo{ + set: ¶ms.UNIXGroupIDSet, + ul: ¶ms.UNIXGroupID, + }, + C.VIR_CONNECT_IDENTITY_PROCESS_ID: typedParamsFieldInfo{ + set: ¶ms.ProcessIDSet, + l: ¶ms.ProcessID, + }, + C.VIR_CONNECT_IDENTITY_PROCESS_TIME: typedParamsFieldInfo{ + set: ¶ms.ProcessTimeSet, + ul: ¶ms.ProcessTime, + }, + C.VIR_CONNECT_IDENTITY_SASL_USER_NAME: typedParamsFieldInfo{ + set: ¶ms.SASLUserNameSet, + s: ¶ms.SASLUserName, + }, + C.VIR_CONNECT_IDENTITY_X509_DISTINGUISHED_NAME: typedParamsFieldInfo{ + set: ¶ms.X509DistinguishedNameSet, + s: ¶ms.X509DistinguishedName, + }, + C.VIR_CONNECT_IDENTITY_SELINUX_CONTEXT: typedParamsFieldInfo{ + set: ¶ms.SELinuxContextSet, + s: ¶ms.SELinuxContext, + }, + } +} + +func (c *Connect) SetIdentity(ident *ConnectIdentity, flags uint) error { + if C.LIBVIR_VERSION_NUMBER < 5008000 { + return makeNotImplementedError("virConnectSetIdentity") + } + info := getConnectIdentityFieldInfo(ident) + + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr + } + + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virConnectSetIdentityWrapper(c.ptr, cparams, cnparams, C.uint(flags), &err) + if ret == -1 { + return makeError(&err) + } + + return nil +} + // See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetCapabilities func (c *Connect) GetCapabilities() (string, error) { var err C.virError @@ -1738,22 +1825,22 @@ type NodeCPUStats struct { // See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetCPUStats func (c *Connect) GetCPUStats(cpuNum int, flags uint32) (*NodeCPUStats, error) { - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), nil, &nparams, C.uint(0), &err) + ret := C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), nil, &cnparams, C.uint(0), &err) if ret == -1 { return nil, makeError(&err) } - params := make([]C.virNodeCPUStats, nparams) - ret = C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), (*C.virNodeCPUStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags), &err) + params := make([]C.virNodeCPUStats, cnparams) + ret = C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), (*C.virNodeCPUStats)(unsafe.Pointer(¶ms[0])), &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } stats := &NodeCPUStats{} - for i := 0; i < int(nparams); i++ { + for i := 0; i < int(cnparams); i++ { param := params[i] field := C.GoString((*C.char)(unsafe.Pointer(¶m.field))) switch field { @@ -1897,23 +1984,22 @@ func (c *Connect) GetMemoryParameters(flags uint32) (*NodeMemoryParameters, erro params := &NodeMemoryParameters{} info := getMemoryParameterFieldInfo(params) - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, C.uint(0), &err) + ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &cnparams, C.uint(0), &err) if ret == -1 { return nil, makeError(&err) } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret = C.virNodeGetMemoryParametersWrapper(c.ptr, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -1934,22 +2020,22 @@ type NodeMemoryStats struct { // See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetMemoryStats func (c *Connect) GetMemoryStats(cellNum int, flags uint32) (*NodeMemoryStats, error) { - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), nil, &nparams, 0, &err) + ret := C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), nil, &cnparams, 0, &err) if ret == -1 { return nil, makeError(&err) } - params := make([]C.virNodeMemoryStats, nparams) - ret = C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), (*C.virNodeMemoryStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags), &err) + params := make([]C.virNodeMemoryStats, cnparams) + ret = C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), (*C.virNodeMemoryStats)(unsafe.Pointer(¶ms[0])), &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } stats := &NodeMemoryStats{} - for i := 0; i < int(nparams); i++ { + for i := 0; i < int(cnparams); i++ { param := params[i] field := C.GoString((*C.char)(unsafe.Pointer(¶m.field))) switch field { @@ -1995,29 +2081,19 @@ func (c *Connect) GetSecurityModel() (*NodeSecurityModel, error) { func (c *Connect) SetMemoryParameters(params *NodeMemoryParameters, flags uint32) error { info := getMemoryParameterFieldInfo(params) - var nparams C.int - - var err C.virError - ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, 0, &err) - if ret == -1 { - return makeError(&err) + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virNodeSetMemoryParametersWrapper(c.ptr, cparams, cnparams, C.uint(flags), &err) if ret == -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) - if gerr != nil { - return gerr - } - - ret = C.virNodeSetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) - return nil } @@ -2049,7 +2125,7 @@ func (c *Connect) DomainSaveImageDefineXML(file string, xml string, flags Domain } // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSaveImageGetXMLDesc -func (c *Connect) DomainSaveImageGetXMLDesc(file string, flags DomainXMLFlags) (string, error) { +func (c *Connect) DomainSaveImageGetXMLDesc(file string, flags DomainSaveImageXMLFlags) (string, error) { cfile := C.CString(file) defer C.free(unsafe.Pointer(cfile)) @@ -2808,7 +2884,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, state := &DomainStatsState{} stateInfo := getDomainStatsStateFieldInfo(state) - count, gerr := typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), stateInfo) + count, gerr := typedParamsUnpack(cdomstats.params, cdomstats.nparams, stateInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2819,7 +2895,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, cpu := &DomainStatsCPU{} cpuInfo := getDomainStatsCPUFieldInfo(cpu) - count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), cpuInfo) + count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, cpuInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2830,7 +2906,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, balloon := &DomainStatsBalloon{} balloonInfo := getDomainStatsBalloonFieldInfo(balloon) - count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), balloonInfo) + count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, balloonInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2841,7 +2917,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, perf := &DomainStatsPerf{} perfInfo := getDomainStatsPerfFieldInfo(perf) - count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), perfInfo) + count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, perfInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2852,7 +2928,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, lengths := domainStatsLengths{} lengthsInfo := getDomainStatsLengthsFieldInfo(&lengths) - count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), lengthsInfo) + count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, lengthsInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2868,7 +2944,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, vcpu := DomainStatsVcpu{} vcpuInfo := getDomainStatsVcpuFieldInfo(j, &vcpu) - count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), vcpuInfo) + count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, vcpuInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2886,7 +2962,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, block := DomainStatsBlock{} blockInfo := getDomainStatsBlockFieldInfo(j, &block) - count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), blockInfo) + count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, blockInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2902,7 +2978,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes, net := DomainStatsNet{} netInfo := getDomainStatsNetFieldInfo(j, &net) - count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), netInfo) + count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, netInfo) if gerr != nil { return []DomainStats{}, gerr } @@ -2964,17 +3040,17 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSEVParameters, error) { info := getNodeSEVFieldInfo(params) var cparams *C.virTypedParameter - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virNodeGetSEVInfoWrapper(c.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret := C.virNodeGetSEVInfoWrapper(c.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) - _, gerr := typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -2996,3 +3072,20 @@ func (c *Connect) NWFilterBindingCreateXML(xmlConfig string, flags uint32) (*NWF } return &NWFilterBinding{ptr: ptr}, nil } + +// See also https://libvirt.org/html/libvirt-libvirt-storage.html#virConnectGetStoragePoolCapabilities +func (c *Connect) GetStoragePoolCapabilities(flags uint32) (string, error) { + if C.LIBVIR_VERSION_NUMBER < 5002000 { + return "", makeNotImplementedError("virConnectGetStoragePoolCapabilities") + } + + var err C.virError + ret := C.virConnectGetStoragePoolCapabilitiesWrapper(c.ptr, C.uint(flags), &err) + if ret == nil { + return "", makeError(&err) + } + + defer C.free(unsafe.Pointer(ret)) + + return C.GoString(ret), nil +} diff --git a/vendor/github.com/libvirt/libvirt-go/connect_compat.h b/vendor/github.com/libvirt/libvirt-go/connect_compat.h index 924b07ddd..6d804cc5e 100644 --- a/vendor/github.com/libvirt/libvirt-go/connect_compat.h +++ b/vendor/github.com/libvirt/libvirt-go/connect_compat.h @@ -197,4 +197,59 @@ typedef struct _virNWFilterBinding *virNWFilterBindingPtr; #define VIR_CONNECT_GET_ALL_DOMAINS_STATS_NOWAIT 1 << 29 #endif +/* 5.6.0 */ + +#ifndef VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI_DIRECT +#define VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI_DIRECT 1 << 19 +#endif + +#ifndef VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT +# define VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT (1 << 14) +#endif + +#ifndef VIR_CONNECT_LIST_DOMAINS_NO_CHECKPOINT +# define VIR_CONNECT_LIST_DOMAINS_NO_CHECKPOINT (1 << 15) +#endif + + +/* 5.8.0 */ + +#ifndef VIR_CONNECT_IDENTITY_USER_NAME +#define VIR_CONNECT_IDENTITY_USER_NAME "user-name" +#endif + +#ifndef VIR_CONNECT_IDENTITY_UNIX_USER_ID +#define VIR_CONNECT_IDENTITY_UNIX_USER_ID "unix-user-id" +#endif + +#ifndef VIR_CONNECT_IDENTITY_GROUP_NAME +#define VIR_CONNECT_IDENTITY_GROUP_NAME "group-name" +#endif + +#ifndef VIR_CONNECT_IDENTITY_UNIX_GROUP_ID +#define VIR_CONNECT_IDENTITY_UNIX_GROUP_ID "unix-group-id" +#endif + +#ifndef VIR_CONNECT_IDENTITY_PROCESS_ID +#define VIR_CONNECT_IDENTITY_PROCESS_ID "process-id" +#endif + +#ifndef VIR_CONNECT_IDENTITY_PROCESS_TIME +#define VIR_CONNECT_IDENTITY_PROCESS_TIME "process-time" +#endif + +#ifndef VIR_CONNECT_IDENTITY_SASL_USER_NAME +#define VIR_CONNECT_IDENTITY_SASL_USER_NAME "sasl-user-name" +#endif + +#ifndef VIR_CONNECT_IDENTITY_X509_DISTINGUISHED_NAME +#define VIR_CONNECT_IDENTITY_X509_DISTINGUISHED_NAME "x509-distinguished-name" +#endif + +#ifndef VIR_CONNECT_IDENTITY_SELINUX_CONTEXT +#define VIR_CONNECT_IDENTITY_SELINUX_CONTEXT "selinux-context" +#endif + + + #endif /* LIBVIRT_GO_CONNECT_COMPAT_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/connect_wrapper.go b/vendor/github.com/libvirt/libvirt-go/connect_wrapper.go index 89727d04a..2a657d81e 100644 --- a/vendor/github.com/libvirt/libvirt-go/connect_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/connect_wrapper.go @@ -1761,6 +1761,40 @@ virStreamNewWrapper(virConnectPtr conn, } +char * +virConnectGetStoragePoolCapabilitiesWrapper(virConnectPtr conn, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5002000 + assert(0); // Caller should have checked version +#else + char *ret = virConnectGetStoragePoolCapabilities(conn, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + +int +virConnectSetIdentityWrapper(virConnectPtr conn, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5008000 + assert(0); // Caller should have checked version +#else + int ret = virConnectSetIdentity(conn, params, nparams, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + //////////////////////////////////////////////// */ import "C" diff --git a/vendor/github.com/libvirt/libvirt-go/connect_wrapper.h b/vendor/github.com/libvirt/libvirt-go/connect_wrapper.h index 5c282d211..05d254e53 100644 --- a/vendor/github.com/libvirt/libvirt-go/connect_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/connect_wrapper.h @@ -726,5 +726,16 @@ virStreamNewWrapper(virConnectPtr conn, unsigned int flags, virErrorPtr err); +char * +virConnectGetStoragePoolCapabilitiesWrapper(virConnectPtr conn, + unsigned int flags, + virErrorPtr err); + +int +virConnectSetIdentityWrapper(virConnectPtr conn, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); #endif /* LIBVIRT_GO_CONNECT_WRAPPER_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/domain.go b/vendor/github.com/libvirt/libvirt-go/domain.go index 3a3ef5b74..02d5eaf8e 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain.go +++ b/vendor/github.com/libvirt/libvirt-go/domain.go @@ -117,10 +117,11 @@ const ( type DomainUndefineFlagsValues int const ( - DOMAIN_UNDEFINE_MANAGED_SAVE = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE) // Also remove any managed save - DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA) // If last use of domain, then also remove any snapshot metadata - DOMAIN_UNDEFINE_NVRAM = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_NVRAM) // Also remove any nvram file - DOMAIN_UNDEFINE_KEEP_NVRAM = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_KEEP_NVRAM) // Keep nvram file + DOMAIN_UNDEFINE_MANAGED_SAVE = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE) // Also remove any managed save + DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA) // If last use of domain, then also remove any snapshot metadata + DOMAIN_UNDEFINE_NVRAM = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_NVRAM) // Also remove any nvram file + DOMAIN_UNDEFINE_KEEP_NVRAM = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_KEEP_NVRAM) // Keep nvram file + DOMAIN_UNDEFINE_CHECKPOINTS_METADATA = DomainUndefineFlagsValues(C.VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA) // If last use of domain, then also remove any checkpoint metadata ) type DomainDeviceModifyFlags int @@ -365,19 +366,21 @@ const ( type DomainMemoryStatTags int const ( - DOMAIN_MEMORY_STAT_LAST = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_NR) - DOMAIN_MEMORY_STAT_SWAP_IN = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_SWAP_IN) - DOMAIN_MEMORY_STAT_SWAP_OUT = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_SWAP_OUT) - DOMAIN_MEMORY_STAT_MAJOR_FAULT = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT) - DOMAIN_MEMORY_STAT_MINOR_FAULT = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT) - DOMAIN_MEMORY_STAT_UNUSED = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_UNUSED) - DOMAIN_MEMORY_STAT_AVAILABLE = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_AVAILABLE) - DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON) - DOMAIN_MEMORY_STAT_RSS = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_RSS) - DOMAIN_MEMORY_STAT_USABLE = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_USABLE) - DOMAIN_MEMORY_STAT_LAST_UPDATE = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE) - DOMAIN_MEMORY_STAT_DISK_CACHES = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_DISK_CACHES) - DOMAIN_MEMORY_STAT_NR = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_NR) + DOMAIN_MEMORY_STAT_LAST = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_NR) + DOMAIN_MEMORY_STAT_SWAP_IN = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_SWAP_IN) + DOMAIN_MEMORY_STAT_SWAP_OUT = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_SWAP_OUT) + DOMAIN_MEMORY_STAT_MAJOR_FAULT = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT) + DOMAIN_MEMORY_STAT_MINOR_FAULT = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT) + DOMAIN_MEMORY_STAT_UNUSED = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_UNUSED) + DOMAIN_MEMORY_STAT_AVAILABLE = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_AVAILABLE) + DOMAIN_MEMORY_STAT_ACTUAL_BALLOON = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON) + DOMAIN_MEMORY_STAT_RSS = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_RSS) + DOMAIN_MEMORY_STAT_USABLE = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_USABLE) + DOMAIN_MEMORY_STAT_LAST_UPDATE = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE) + DOMAIN_MEMORY_STAT_DISK_CACHES = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_DISK_CACHES) + DOMAIN_MEMORY_STAT_HUGETLB_PGALLOC = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGALLOC) + DOMAIN_MEMORY_STAT_HUGETLB_PGFAIL = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGFAIL) + DOMAIN_MEMORY_STAT_NR = DomainMemoryStatTags(C.VIR_DOMAIN_MEMORY_STAT_NR) ) type DomainCPUStatsTags string @@ -593,6 +596,7 @@ const ( DOMAIN_SHUTOFF_SAVED = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_SAVED) DOMAIN_SHUTOFF_FAILED = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_FAILED) DOMAIN_SHUTOFF_FROM_SNAPSHOT = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT) + DOMAIN_SHUTOFF_DAEMON = DomainShutoffReason(C.VIR_DOMAIN_SHUTOFF_DAEMON) ) type DomainBlockCommitFlags int @@ -768,6 +772,7 @@ const ( DOMAIN_STATS_INTERFACE = DomainStatsTypes(C.VIR_DOMAIN_STATS_INTERFACE) DOMAIN_STATS_BLOCK = DomainStatsTypes(C.VIR_DOMAIN_STATS_BLOCK) DOMAIN_STATS_PERF = DomainStatsTypes(C.VIR_DOMAIN_STATS_PERF) + DOMAIN_STATS_IOTHREAD = DomainStatsTypes(C.VIR_DOMAIN_STATS_IOTHREAD) ) type DomainCoreDumpFlags int @@ -807,6 +812,19 @@ const ( MIGRATE_RDMA_PIN_ALL = DomainMigrateFlags(C.VIR_MIGRATE_RDMA_PIN_ALL) MIGRATE_POSTCOPY = DomainMigrateFlags(C.VIR_MIGRATE_POSTCOPY) MIGRATE_TLS = DomainMigrateFlags(C.VIR_MIGRATE_TLS) + MIGRATE_PARALLEL = DomainMigrateFlags(C.VIR_MIGRATE_PARALLEL) +) + +type DomainMigrateMaxSpeedFlags int + +const ( + MIGRATE_MAX_SPEED_POSTCOPY = DomainMigrateMaxSpeedFlags(C.VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY) +) + +type DomainSaveImageXMLFlags int + +const ( + DOMAIN_SAVE_IMAGE_XML_SECURE = DomainSaveImageXMLFlags(C.VIR_DOMAIN_SAVE_IMAGE_XML_SECURE) ) type VcpuState int @@ -858,6 +876,24 @@ type DomainVcpuInfo struct { CpuMap []bool } +type DomainGuestInfoTypes int + +const ( + DOMAIN_GUEST_INFO_USERS = DomainGuestInfoTypes(C.VIR_DOMAIN_GUEST_INFO_USERS) + DOMAIN_GUEST_INFO_OS = DomainGuestInfoTypes(C.VIR_DOMAIN_GUEST_INFO_OS) + DOMAIN_GUEST_INFO_TIMEZONE = DomainGuestInfoTypes(C.VIR_DOMAIN_GUEST_INFO_TIMEZONE) + DOMAIN_GUEST_INFO_HOSTNAME = DomainGuestInfoTypes(C.VIR_DOMAIN_GUEST_INFO_HOSTNAME) + DOMAIN_GUEST_INFO_FILESYSTEM = DomainGuestInfoTypes(C.VIR_DOMAIN_GUEST_INFO_FILESYSTEM) +) + +type DomainAgentSetResponseTimeoutValues int + +const ( + DOMAIN_AGENT_RESPONSE_TIMEOUT_BLOCK = DomainAgentSetResponseTimeoutValues(C.VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_BLOCK) + DOMAIN_AGENT_RESPONSE_TIMEOUT_DEFAULT = DomainAgentSetResponseTimeoutValues(C.VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_DEFAULT) + DOMAIN_AGENT_RESPONSE_TIMEOUT_NOWAIT = DomainAgentSetResponseTimeoutValues(C.VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_NOWAIT) +) + // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFree func (d *Domain) Free() error { var err C.virError @@ -1171,29 +1207,29 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags uint32) ([]DomainCP if ret == -1 { return []DomainCPUStats{}, makeError(&err) } - nparams := uint(ret) + cnparams := C.int(ret) - var cparams []C.virTypedParameter - var nallocparams uint + var cnallocparams C.int if startCpu == -1 { - nallocparams = nparams + cnallocparams = cnparams } else { - nallocparams = nparams * nCpus + cnallocparams = cnparams * C.int(nCpus) } - cparams = make([]C.virTypedParameter, nallocparams) - ret = C.virDomainGetCPUStatsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.uint(nparams), C.int(startCpu), C.uint(nCpus), C.uint(flags), &err) + cparams := typedParamsNew(cnallocparams) + defer C.virTypedParamsFree(cparams, cnallocparams) + ret = C.virDomainGetCPUStatsWrapper(d.ptr, cparams, C.uint(cnparams), C.int(startCpu), C.uint(nCpus), C.uint(flags), &err) if ret == -1 { return []DomainCPUStats{}, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.int(nallocparams)) - stats := make([]DomainCPUStats, nCpus) for i := 0; i < int(nCpus); i++ { - offset := i * int(nparams) + coffset := C.int(i) * cnparams info := getCPUStatsFieldInfo(&stats[i]) - cparamscpu := cparams[offset : offset+int(ret)] - _, gerr := typedParamsUnpack(cparamscpu, info) + var cparamscpu *C.virTypedParameter + cparamscpu = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) + + (unsafe.Sizeof(*cparams) * uintptr(coffset)))) + _, gerr := typedParamsUnpack(cparamscpu, cnparams, info) if gerr != nil { return []DomainCPUStats{}, gerr } @@ -1256,25 +1292,24 @@ func (d *Domain) GetInterfaceParameters(device string, flags DomainModificationI params := &DomainInterfaceParameters{} info := getInterfaceParameterFieldInfo(params) - var nparams C.int + var cnparams C.int cdevice := C.CString(device) defer C.free(unsafe.Pointer(cdevice)) var err C.virError - ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &nparams, C.uint(0), &err) + ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &cnparams, C.uint(0), &err) if ret == -1 { return nil, makeError(&err) } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -1286,30 +1321,21 @@ func (d *Domain) GetInterfaceParameters(device string, flags DomainModificationI func (d *Domain) SetInterfaceParameters(device string, params *DomainInterfaceParameters, flags DomainModificationImpact) error { info := getInterfaceParameterFieldInfo(params) - var nparams C.int - cdevice := C.CString(device) defer C.free(unsafe.Pointer(cdevice)) - var err C.virError - ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &nparams, 0, &err) - if ret == -1 { - return makeError(&err) - } - - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) - if ret == -1 { - return makeError(&err) - } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) + cparams, cnparams, gerr := typedParamsPackNew(info) if gerr != nil { return gerr } - ret = C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, cparams, cnparams, C.uint(flags), &err) + if ret == -1 { + return makeError(&err) + } return nil } @@ -1656,25 +1682,24 @@ func (d *Domain) BlockStatsFlags(disk string, flags uint32) (*DomainBlockStats, params := &DomainBlockStats{} info := getBlockStatsFieldInfo(params) - var nparams C.int + var cnparams C.int cdisk := C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) var err C.virError - ret := C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &nparams, C.uint(0), &err) + ret := C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &cnparams, C.uint(0), &err) if ret == -1 { return nil, makeError(&err) } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret = C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -1996,6 +2021,22 @@ func (d *Domain) SnapshotLookupByName(name string, flags uint32) (*DomainSnapsho return &DomainSnapshot{ptr: ptr}, nil } +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointLookupByName +func (d *Domain) CheckpointLookupByName(name string, flags uint32) (*DomainCheckpoint, error) { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return nil, makeNotImplementedError("virDomainCheckpointLookupByName") + } + + cName := C.CString(name) + defer C.free(unsafe.Pointer(cName)) + var err C.virError + ptr := C.virDomainCheckpointLookupByNameWrapper(d.ptr, cName, C.uint(flags), &err) + if ptr == nil { + return nil, makeError(&err) + } + return &DomainCheckpoint{ptr: ptr}, nil +} + // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotListNames func (d *Domain) SnapshotListNames(flags DomainSnapshotListFlags) ([]string, error) { const maxNames = 1024 @@ -2039,6 +2080,32 @@ func (d *Domain) ListAllSnapshots(flags DomainSnapshotListFlags) ([]DomainSnapsh return pools, nil } +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainListAllCheckpoints +func (d *Domain) ListAllCheckpoints(flags DomainCheckpointListFlags) ([]DomainCheckpoint, error) { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return []DomainCheckpoint{}, makeNotImplementedError("virDomainListAllCheckpoints") + } + + var cList *C.virDomainCheckpointPtr + var err C.virError + numCps := C.virDomainListAllCheckpointsWrapper(d.ptr, (**C.virDomainCheckpointPtr)(&cList), C.uint(flags), &err) + if numCps == -1 { + return nil, makeError(&err) + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numCps), + Cap: int(numCps), + } + var cps []DomainCheckpoint + slice := *(*[]C.virDomainCheckpointPtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + cps = append(cps, DomainCheckpoint{ptr}) + } + C.free(unsafe.Pointer(cList)) + return cps, nil +} + // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockCommit func (d *Domain) BlockCommit(disk string, base string, top string, bandwidth uint64, flags DomainBlockCommitFlags) error { cdisk := C.CString(disk) @@ -2099,16 +2166,15 @@ func (d *Domain) BlockCopy(disk string, destxml string, params *DomainBlockCopyP info := getBlockCopyParameterFieldInfo(params) - cparams, gerr := typedParamsPackNew(info) + cparams, cnparams, gerr := typedParamsPackNew(info) if gerr != nil { return gerr } - nparams := len(*cparams) - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams)) + defer C.virTypedParamsFree(cparams, cnparams) var err C.virError - ret := C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml, (*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.uint(flags), &err) + ret := C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml, cparams, cnparams, C.uint(flags), &err) if ret == -1 { return makeError(&err) } @@ -2295,6 +2361,8 @@ type DomainMigrateParameters struct { AutoConvergeInitial int AutoConvergeIncrementSet bool AutoConvergeIncrement int + ParallelConnectionsSet bool + ParallelConnections int } func getMigrateParameterFieldInfo(params *DomainMigrateParameters) map[string]typedParamsFieldInfo { @@ -2319,6 +2387,10 @@ func getMigrateParameterFieldInfo(params *DomainMigrateParameters) map[string]ty set: ¶ms.BandwidthSet, ul: ¶ms.Bandwidth, }, + C.VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY: typedParamsFieldInfo{ + set: ¶ms.BandwidthSet, + ul: ¶ms.Bandwidth, + }, C.VIR_MIGRATE_PARAM_GRAPHICS_URI: typedParamsFieldInfo{ set: ¶ms.GraphicsURISet, s: ¶ms.GraphicsURI, @@ -2363,6 +2435,10 @@ func getMigrateParameterFieldInfo(params *DomainMigrateParameters) map[string]ty set: ¶ms.AutoConvergeIncrementSet, i: ¶ms.AutoConvergeIncrement, }, + C.VIR_MIGRATE_PARAM_PARALLEL_CONNECTIONS: typedParamsFieldInfo{ + set: ¶ms.ParallelConnectionsSet, + i: ¶ms.ParallelConnections, + }, } } @@ -2370,16 +2446,15 @@ func getMigrateParameterFieldInfo(params *DomainMigrateParameters) map[string]ty func (d *Domain) Migrate3(dconn *Connect, params *DomainMigrateParameters, flags DomainMigrateFlags) (*Domain, error) { info := getMigrateParameterFieldInfo(params) - cparams, gerr := typedParamsPackNew(info) + cparams, cnparams, gerr := typedParamsPackNew(info) if gerr != nil { return nil, gerr } - nparams := len(*cparams) - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams)) + defer C.virTypedParamsFree(cparams, cnparams) var err C.virError - ret := C.virDomainMigrate3Wrapper(d.ptr, dconn.ptr, (*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags), &err) + ret := C.virDomainMigrate3Wrapper(d.ptr, dconn.ptr, cparams, C.uint(cnparams), C.uint(flags), &err) if ret == nil { return nil, makeError(&err) } @@ -2450,16 +2525,15 @@ func (d *Domain) MigrateToURI3(dconnuri string, params *DomainMigrateParameters, } info := getMigrateParameterFieldInfo(params) - cparams, gerr := typedParamsPackNew(info) + cparams, cnparams, gerr := typedParamsPackNew(info) if gerr != nil { return gerr } - nparams := len(*cparams) - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams)) + defer C.virTypedParamsFree(cparams, cnparams) var err C.virError - ret := C.virDomainMigrateToURI3Wrapper(d.ptr, cdconnuri, (*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags), &err) + ret := C.virDomainMigrateToURI3Wrapper(d.ptr, cdconnuri, cparams, C.uint(cnparams), C.uint(flags), &err) if ret == -1 { return makeError(&err) } @@ -2492,7 +2566,7 @@ func (d *Domain) MigrateSetCompressionCache(size uint64, flags uint32) error { } // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetMaxSpeed -func (d *Domain) MigrateGetMaxSpeed(flags uint32) (uint64, error) { +func (d *Domain) MigrateGetMaxSpeed(flags DomainMigrateMaxSpeedFlags) (uint64, error) { var maxSpeed C.ulong var err C.virError @@ -2505,7 +2579,7 @@ func (d *Domain) MigrateGetMaxSpeed(flags uint32) (uint64, error) { } // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxSpeed -func (d *Domain) MigrateSetMaxSpeed(speed uint64, flags uint32) error { +func (d *Domain) MigrateSetMaxSpeed(speed uint64, flags DomainMigrateMaxSpeedFlags) error { var err C.virError ret := C.virDomainMigrateSetMaxSpeedWrapper(d.ptr, C.ulong(speed), C.uint(flags), &err) if ret == -1 { @@ -2607,22 +2681,21 @@ func (d *Domain) GetBlkioParameters(flags DomainModificationImpact) (*DomainBlki params := &DomainBlkioParameters{} info := getBlkioParametersFieldInfo(params) - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &err) + ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &cnparams, 0, &err) if ret == -1 { return nil, makeError(&err) } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret = C.virDomainGetBlkioParametersWrapper(d.ptr, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -2634,29 +2707,19 @@ func (d *Domain) GetBlkioParameters(flags DomainModificationImpact) (*DomainBlki func (d *Domain) SetBlkioParameters(params *DomainBlkioParameters, flags DomainModificationImpact) error { info := getBlkioParametersFieldInfo(params) - var nparams C.int - - var err C.virError - ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &err) - if ret == -1 { - return makeError(&err) + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virDomainSetBlkioParametersWrapper(d.ptr, cparams, cnparams, C.uint(flags), &err) if ret == -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) - if gerr != nil { - return gerr - } - - ret = C.virDomainSetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) - return nil } @@ -2796,22 +2859,21 @@ func (d *Domain) GetBlockIoTune(disk string, flags DomainModificationImpact) (*D params := &DomainBlockIoTuneParameters{} info := getBlockIoTuneParametersFieldInfo(params) - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0, &err) + ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &cnparams, 0, &err) if ret == -1 { return nil, makeError(&err) } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -2826,29 +2888,19 @@ func (d *Domain) SetBlockIoTune(disk string, params *DomainBlockIoTuneParameters info := getBlockIoTuneParametersFieldInfo(params) - var nparams C.int - - var err C.virError - ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0, &err) - if ret == -1 { - return makeError(&err) + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, cparams, cnparams, C.uint(flags), &err) if ret == -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) - if gerr != nil { - return gerr - } - - ret = C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) - return nil } @@ -3014,6 +3066,8 @@ type DomainJobInfo struct { AutoConvergeThrottle int OperationSet bool Operation DomainJobOperationType + MemPostcopyReqsSet bool + MemPostcopyReqs uint64 } // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobInfo @@ -3175,25 +3229,29 @@ func getDomainJobInfoFieldInfo(params *DomainJobInfo) map[string]typedParamsFiel set: ¶ms.OperationSet, i: (*int)(¶ms.Operation), }, + C.VIR_DOMAIN_JOB_MEMORY_POSTCOPY_REQS: typedParamsFieldInfo{ + set: ¶ms.MemPostcopyReqsSet, + ul: ¶ms.MemPostcopyReqs, + }, } } // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobStats func (d *Domain) GetJobStats(flags DomainGetJobStatsFlags) (*DomainJobInfo, error) { - var cparams *C.virTypedParameter - var nparams C.int + var cparams C.virTypedParameterPtr + var cnparams C.int var jobtype C.int var err C.virError - ret := C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret := C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, &cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) params := DomainJobInfo{} info := getDomainJobInfoFieldInfo(¶ms) - _, gerr := typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -3273,22 +3331,21 @@ func (d *Domain) GetMemoryParameters(flags DomainModificationImpact) (*DomainMem params := &DomainMemoryParameters{} info := getDomainMemoryParametersFieldInfo(params) - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &err) + ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &cnparams, 0, &err) if ret == -1 { return nil, makeError(&err) } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret = C.virDomainGetMemoryParametersWrapper(d.ptr, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -3300,29 +3357,19 @@ func (d *Domain) GetMemoryParameters(flags DomainModificationImpact) (*DomainMem func (d *Domain) SetMemoryParameters(params *DomainMemoryParameters, flags DomainModificationImpact) error { info := getDomainMemoryParametersFieldInfo(params) - var nparams C.int - - var err C.virError - ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &err) - if ret == -1 { - return makeError(&err) + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virDomainSetMemoryParametersWrapper(d.ptr, cparams, cnparams, C.uint(flags), &err) if ret == -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) - if gerr != nil { - return gerr - } - - ret = C.virDomainSetMemoryParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) - return nil } @@ -3351,22 +3398,21 @@ func (d *Domain) GetNumaParameters(flags DomainModificationImpact) (*DomainNumaP params := &DomainNumaParameters{} info := getDomainNumaParametersFieldInfo(params) - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &err) + ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &cnparams, 0, &err) if ret == -1 { return nil, makeError(&err) } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret = C.virDomainGetNumaParametersWrapper(d.ptr, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -3378,29 +3424,19 @@ func (d *Domain) GetNumaParameters(flags DomainModificationImpact) (*DomainNumaP func (d *Domain) SetNumaParameters(params *DomainNumaParameters, flags DomainModificationImpact) error { info := getDomainNumaParametersFieldInfo(params) - var nparams C.int - - var err C.virError - ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &err) - if ret == -1 { - return makeError(&err) + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr } - cparams := make([]C.virTypedParameter, nparams) - ret = C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virDomainSetNumaParametersWrapper(d.ptr, cparams, cnparams, C.uint(flags), &err) if ret == -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) - if gerr != nil { - return gerr - } - - ret = C.virDomainSetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) - return nil } @@ -3555,17 +3591,17 @@ func (d *Domain) GetPerfEvents(flags DomainModificationImpact) (*DomainPerfEvent params := &DomainPerfEvents{} info := getDomainPerfEventsFieldInfo(params) - var cparams *C.virTypedParameter - var nparams C.int + var cparams C.virTypedParameterPtr + var cnparams C.int var err C.virError - ret := C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret := C.virDomainGetPerfEventsWrapper(d.ptr, &cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) - _, gerr := typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -3581,22 +3617,17 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEvents, flags DomainModificatio info := getDomainPerfEventsFieldInfo(params) - var cparams *C.virTypedParameter - var nparams C.int - var err C.virError - ret := C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) - if ret == -1 { - return makeError(&err) - } - - defer C.virTypedParamsFree(cparams, nparams) - - gerr := typedParamsPackLen(cparams, int(nparams), info) + cparams, cnparams, gerr := typedParamsPackNew(info) if gerr != nil { return gerr } + defer C.virTypedParamsFree(cparams, cnparams) - ret = C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(flags), &err) + var err C.virError + ret := C.virDomainSetPerfEventsWrapper(d.ptr, cparams, cnparams, C.uint(flags), &err) + if ret == -1 { + return makeError(&err) + } return nil } @@ -3699,28 +3730,28 @@ func (d *Domain) GetSchedulerParameters() (*DomainSchedulerParameters, error) { params := &DomainSchedulerParameters{} info := getDomainSchedulerParametersFieldInfo(params) - var nparams C.int + var cnparams C.int var err C.virError - schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) + schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) if schedtype == nil { return nil, makeError(&err) } defer C.free(unsafe.Pointer(schedtype)) - if nparams == 0 { + if cnparams == 0 { return &DomainSchedulerParameters{ Type: C.GoString(schedtype), }, nil } - cparams := make([]C.virTypedParameter, nparams) - ret := C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret := C.virDomainGetSchedulerParametersWrapper(d.ptr, cparams, &cnparams, &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -3733,28 +3764,28 @@ func (d *Domain) GetSchedulerParametersFlags(flags DomainModificationImpact) (*D params := &DomainSchedulerParameters{} info := getDomainSchedulerParametersFieldInfo(params) - var nparams C.int + var cnparams C.int var err C.virError - schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) + schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) if schedtype == nil { return nil, makeError(&err) } defer C.free(unsafe.Pointer(schedtype)) - if nparams == 0 { + if cnparams == 0 { return &DomainSchedulerParameters{ Type: C.GoString(schedtype), }, nil } - cparams := make([]C.virTypedParameter, nparams) - ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams := typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - _, gerr := typedParamsUnpack(cparams, info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } @@ -3766,31 +3797,18 @@ func (d *Domain) GetSchedulerParametersFlags(flags DomainModificationImpact) (*D func (d *Domain) SetSchedulerParameters(params *DomainSchedulerParameters) error { info := getDomainSchedulerParametersFieldInfo(params) - var nparams C.int - var err C.virError - schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) - if schedtype == nil { - return makeError(&err) + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr } - defer C.free(unsafe.Pointer(schedtype)) - if nparams == 0 { - return nil - } + defer C.virTypedParamsFree(cparams, cnparams) - cparams := make([]C.virTypedParameter, nparams) - ret := C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, &err) + var err C.virError + ret := C.virDomainSetSchedulerParametersWrapper(d.ptr, cparams, cnparams, &err) if ret == -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) - if gerr != nil { - return gerr - } - - ret = C.virDomainSetSchedulerParametersWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, &err) return nil } @@ -3799,31 +3817,18 @@ func (d *Domain) SetSchedulerParameters(params *DomainSchedulerParameters) error func (d *Domain) SetSchedulerParametersFlags(params *DomainSchedulerParameters, flags DomainModificationImpact) error { info := getDomainSchedulerParametersFieldInfo(params) - var nparams C.int - var err C.virError - schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) - if schedtype == nil { - return makeError(&err) + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr } - defer C.free(unsafe.Pointer(schedtype)) - if nparams == 0 { - return nil - } + defer C.virTypedParamsFree(cparams, cnparams) - cparams := make([]C.virTypedParameter, nparams) - ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + var err C.virError + ret := C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, cparams, cnparams, C.uint(flags), &err) if ret == -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams) - - gerr := typedParamsPack(cparams, info) - if gerr != nil { - return gerr - } - - ret = C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) return nil } @@ -4206,6 +4211,56 @@ func (d *Domain) DelIOThread(id uint, flags DomainModificationImpact) error { return nil } +// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetIOThreadParams + +type DomainSetIOThreadParams struct { + PollMaxNsSet bool + PollMaxNs uint64 + PollGrowSet bool + PollGrow uint + PollShrinkSet bool + PollShrink uint +} + +func getSetIOThreadParamsFieldInfo(params *DomainSetIOThreadParams) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + C.VIR_DOMAIN_IOTHREAD_POLL_MAX_NS: typedParamsFieldInfo{ + set: ¶ms.PollMaxNsSet, + ul: ¶ms.PollMaxNs, + }, + C.VIR_DOMAIN_IOTHREAD_POLL_GROW: typedParamsFieldInfo{ + set: ¶ms.PollGrowSet, + ui: ¶ms.PollGrow, + }, + C.VIR_DOMAIN_IOTHREAD_POLL_SHRINK: typedParamsFieldInfo{ + set: ¶ms.PollShrinkSet, + ui: ¶ms.PollShrink, + }, + } +} + +func (d *Domain) SetIOThreadParams(iothreadid uint, params *DomainSetIOThreadParams, flags DomainModificationImpact) error { + if C.LIBVIR_VERSION_NUMBER < 4010000 { + return makeNotImplementedError("virDomainSetIOThreadParams") + } + info := getSetIOThreadParamsFieldInfo(params) + + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr + } + + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virDomainSetIOThreadParamsWrapper(d.ptr, C.uint(iothreadid), cparams, cnparams, C.uint(flags), &err) + if ret == -1 { + return makeError(&err) + } + + return nil +} + // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetEmulatorPinInfo func (d *Domain) GetEmulatorPinInfo(flags DomainModificationImpact) ([]bool, error) { var cnodeinfo C.virNodeInfo @@ -4436,6 +4491,22 @@ func (d *Domain) CreateSnapshotXML(xml string, flags DomainSnapshotCreateFlags) return &DomainSnapshot{ptr: result}, nil } +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointCreateXML +func (d *Domain) CreateCheckpointXML(xml string, flags DomainCheckpointCreateFlags) (*DomainCheckpoint, error) { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return nil, makeNotImplementedError("virDomainCheckpointCreateXML") + } + + cXml := C.CString(xml) + defer C.free(unsafe.Pointer(cXml)) + var err C.virError + result := C.virDomainCheckpointCreateXMLWrapper(d.ptr, cXml, C.uint(flags), &err) + if result == nil { + return nil, makeError(&err) + } + return &DomainCheckpoint{ptr: result}, nil +} + // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSave func (d *Domain) Save(destFile string) error { cPath := C.CString(destFile) @@ -4463,23 +4534,26 @@ func (d *Domain) SaveFlags(destFile string, destXml string, flags DomainSaveRest } type DomainGuestVcpus struct { - Vcpus []bool - Online []bool - Offlinable []bool + VcpusSet bool + Vcpus []bool + OnlineSet bool + Online []bool + OfflinableSet bool + Offlinable []bool } -func getDomainGuestVcpusParametersFieldInfo(VcpusSet *bool, Vcpus *string, OnlineSet *bool, Online *string, OfflinableSet *bool, Offlinable *string) map[string]typedParamsFieldInfo { +func getDomainGuestVcpusParametersFieldInfo(vcpus *DomainGuestVcpus, Vcpus *string, Online *string, Offlinable *string) map[string]typedParamsFieldInfo { return map[string]typedParamsFieldInfo{ "vcpus": typedParamsFieldInfo{ - set: VcpusSet, + set: &vcpus.VcpusSet, s: Vcpus, }, "online": typedParamsFieldInfo{ - set: OnlineSet, + set: &vcpus.OnlineSet, s: Online, }, "offlinable": typedParamsFieldInfo{ - set: OfflinableSet, + set: &vcpus.OfflinableSet, s: Offlinable, }, } @@ -4548,26 +4622,48 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*DomainGuestVcpus, error) { return nil, makeNotImplementedError("virDomainGetGuestVcpus") } - var VcpusSet, OnlineSet, OfflinableSet bool + vcpus := &DomainGuestVcpus{} var VcpusStr, OnlineStr, OfflinableStr string - info := getDomainGuestVcpusParametersFieldInfo(&VcpusSet, &VcpusStr, &OnlineSet, &OnlineStr, &OfflinableSet, &OfflinableStr) + info := getDomainGuestVcpusParametersFieldInfo(vcpus, &VcpusStr, &OnlineStr, &OfflinableStr) var cparams C.virTypedParameterPtr - var nparams C.uint + var cnparams C.uint var err C.virError - ret := C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &nparams, C.uint(flags), &err) + ret := C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsFree(cparams, C.int(nparams)) + defer C.virTypedParamsFree(cparams, C.int(cnparams)) - _, gerr := typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr := typedParamsUnpack(cparams, C.int(cnparams), info) if gerr != nil { return nil, gerr } - return &DomainGuestVcpus{}, nil + if vcpus.VcpusSet { + mask, gerr := parseCPUString(VcpusStr) + if gerr != nil { + return nil, gerr + } + vcpus.Vcpus = mask + } + if vcpus.OnlineSet { + mask, gerr := parseCPUString(OnlineStr) + if gerr != nil { + return nil, gerr + } + vcpus.Online = mask + } + if vcpus.OfflinableSet { + mask, gerr := parseCPUString(OfflinableStr) + if gerr != nil { + return nil, gerr + } + vcpus.Offlinable = mask + } + + return vcpus, nil } // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetGuestVcpus @@ -4673,7 +4769,7 @@ func (d *Domain) ManagedSaveDefineXML(xml string, flags uint32) error { } // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSaveGetXMLDesc -func (d *Domain) ManagedSaveGetXMLDesc(flags uint32) (string, error) { +func (d *Domain) ManagedSaveGetXMLDesc(flags DomainSaveImageXMLFlags) (string, error) { if C.LIBVIR_VERSION_NUMBER < 3007000 { return "", makeNotImplementedError("virDomainManagedSaveGetXMLDesc") } @@ -4747,20 +4843,362 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32) (*DomainLaunchSecurityParam info := getDomainLaunchSecurityFieldInfo(params) var cparams *C.virTypedParameter - var nparams C.int + var cnparams C.int var err C.virError - ret := C.virDomainGetLaunchSecurityInfoWrapper(d.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret := C.virDomainGetLaunchSecurityInfoWrapper(d.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) if ret == -1 { return nil, makeError(&err) } - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) - _, gerr := typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr := typedParamsUnpack(cparams, cnparams, info) if gerr != nil { return nil, gerr } return params, nil } + +type DomainGuestInfoUser struct { + NameSet bool + Name string + DomainSet bool + Domain string + LoginTimeSet bool + LoginTime uint64 +} + +func getDomainGuestInfoUserFieldInfo(idx int, params *DomainGuestInfoUser) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + fmt.Sprintf("user.%d.name", idx): typedParamsFieldInfo{ + set: ¶ms.NameSet, + s: ¶ms.Name, + }, + fmt.Sprintf("user.%d.domain", idx): typedParamsFieldInfo{ + set: ¶ms.DomainSet, + s: ¶ms.Domain, + }, + fmt.Sprintf("user.%d.logintime", idx): typedParamsFieldInfo{ + set: ¶ms.LoginTimeSet, + ul: ¶ms.LoginTime, + }, + } +} + +type DomainGuestInfoOS struct { + IDSet bool + ID string + NameSet bool + Name string + PrettyNameSet bool + PrettyName string + VersionSet bool + Version string + VersionIDSet bool + VersionID string + KernelReleaseSet bool + KernelRelease string + KernelVersionSet bool + KernelVersion string + MachineSet bool + Machine string + VariantSet bool + Variant string + VariantIDSet bool + VariantID string +} + +func getDomainGuestInfoOSFieldInfo(params *DomainGuestInfoOS) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + "os.id": typedParamsFieldInfo{ + set: ¶ms.IDSet, + s: ¶ms.ID, + }, + "os.name": typedParamsFieldInfo{ + set: ¶ms.NameSet, + s: ¶ms.Name, + }, + "os.pretty-name": typedParamsFieldInfo{ + set: ¶ms.PrettyNameSet, + s: ¶ms.PrettyName, + }, + "os.version": typedParamsFieldInfo{ + set: ¶ms.VersionSet, + s: ¶ms.Version, + }, + "os.version-id": typedParamsFieldInfo{ + set: ¶ms.VersionIDSet, + s: ¶ms.VersionID, + }, + "os.kernel-release": typedParamsFieldInfo{ + set: ¶ms.KernelReleaseSet, + s: ¶ms.KernelRelease, + }, + "os.kernel-version": typedParamsFieldInfo{ + set: ¶ms.KernelVersionSet, + s: ¶ms.KernelVersion, + }, + "os.machine": typedParamsFieldInfo{ + set: ¶ms.MachineSet, + s: ¶ms.Machine, + }, + "os.variant": typedParamsFieldInfo{ + set: ¶ms.VariantSet, + s: ¶ms.Variant, + }, + "os.variant-id": typedParamsFieldInfo{ + set: ¶ms.VariantIDSet, + s: ¶ms.VariantID, + }, + } +} + +type DomainGuestInfoTimeZone struct { + NameSet bool + Name string + OffsetSet bool + Offset int +} + +func getDomainGuestInfoTimeZoneFieldInfo(params *DomainGuestInfoTimeZone) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + "timezone.name": typedParamsFieldInfo{ + set: ¶ms.NameSet, + s: ¶ms.Name, + }, + "timezone.offset": typedParamsFieldInfo{ + set: ¶ms.OffsetSet, + i: ¶ms.Offset, + }, + } +} + +type DomainGuestInfoFileSystemDisk struct { + AliasSet bool + Alias string + SerialSet bool + Serial string + DeviceSet bool + Device string +} + +func getDomainGuestInfoFileSystemDiskFieldInfo(idx1, idx2 int, params *DomainGuestInfoFileSystemDisk) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + fmt.Sprintf("fs.%d.disk.%d.alias", idx1, idx2): typedParamsFieldInfo{ + set: ¶ms.AliasSet, + s: ¶ms.Alias, + }, + fmt.Sprintf("fs.%d.disk.%d.serial", idx1, idx2): typedParamsFieldInfo{ + set: ¶ms.SerialSet, + s: ¶ms.Serial, + }, + fmt.Sprintf("fs.%d.disk.%d.device", idx1, idx2): typedParamsFieldInfo{ + set: ¶ms.DeviceSet, + s: ¶ms.Device, + }, + } +} + +type DomainGuestInfoFileSystem struct { + MountPointSet bool + MountPoint string + NameSet bool + Name string + FSTypeSet bool + FSType string + TotalBytesSet bool + TotalBytes uint64 + UsedBytesSet bool + UsedBytes uint64 + Disks []DomainGuestInfoFileSystemDisk +} + +func getDomainGuestInfoFileSystemFieldInfo(idx int, params *DomainGuestInfoFileSystem) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + fmt.Sprintf("fs.%d.disk.mountpoint", idx): typedParamsFieldInfo{ + set: ¶ms.MountPointSet, + s: ¶ms.MountPoint, + }, + fmt.Sprintf("fs.%d.disk.name", idx): typedParamsFieldInfo{ + set: ¶ms.NameSet, + s: ¶ms.Name, + }, + fmt.Sprintf("fs.%d.disk.fstype", idx): typedParamsFieldInfo{ + set: ¶ms.FSTypeSet, + s: ¶ms.FSType, + }, + fmt.Sprintf("fs.%d.disk.total-bytes", idx): typedParamsFieldInfo{ + set: ¶ms.TotalBytesSet, + ul: ¶ms.TotalBytes, + }, + fmt.Sprintf("fs.%d.disk.used-bytes", idx): typedParamsFieldInfo{ + set: ¶ms.UsedBytesSet, + ul: ¶ms.UsedBytes, + }, + } +} + +type domainGuestInfoFileSystemLengths struct { + DiskCountSet bool + DiskCount uint +} + +func getDomainGuestInfoFileSystemLengthsFieldInfo(idx int, params *domainGuestInfoFileSystemLengths) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + fmt.Sprintf("disk.%d.count", idx): typedParamsFieldInfo{ + set: ¶ms.DiskCountSet, + ui: ¶ms.DiskCount, + }, + } +} + +type DomainGuestInfo struct { + Users []DomainGuestInfoUser + OS *DomainGuestInfoOS + TimeZone *DomainGuestInfoTimeZone + HostnameSet bool + Hostname string + FileSystems []DomainGuestInfoFileSystem +} + +func getDomainGuestInfoFieldInfo(params *DomainGuestInfo) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + "hostname": typedParamsFieldInfo{ + set: ¶ms.HostnameSet, + s: ¶ms.Hostname, + }, + } +} + +type domainGuestInfoLengths struct { + UserCountSet bool + UserCount uint + FileSystemCountSet bool + FileSystemCount uint +} + +func getDomainGuestInfoLengthsFieldInfo(params *domainGuestInfoLengths) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + "user.count": typedParamsFieldInfo{ + set: ¶ms.UserCountSet, + ui: ¶ms.UserCount, + }, + "fs.count": typedParamsFieldInfo{ + set: ¶ms.FileSystemCountSet, + ui: ¶ms.FileSystemCount, + }, + } +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetGuestInfo +func (d *Domain) GetGuestInfo(types DomainGuestInfoTypes, flags uint32) (*DomainGuestInfo, error) { + if C.LIBVIR_VERSION_NUMBER < 5007000 { + return nil, makeNotImplementedError("virDomainGetGuestInfo") + } + + var cparams *C.virTypedParameter + var cnparams C.int + + var err C.virError + ret := C.virDomainGetGuestInfoWrapper(d.ptr, C.uint(types), (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) + if ret == -1 { + return nil, makeError(&err) + } + + defer C.virTypedParamsFree(cparams, cnparams) + + info := DomainGuestInfo{} + infoInfo := getDomainGuestInfoFieldInfo(&info) + + _, gerr := typedParamsUnpack(cparams, cnparams, infoInfo) + if gerr != nil { + return nil, gerr + } + + lengths := domainGuestInfoLengths{} + lengthsInfo := getDomainGuestInfoLengthsFieldInfo(&lengths) + + _, gerr = typedParamsUnpack(cparams, cnparams, lengthsInfo) + if gerr != nil { + return nil, gerr + } + + if lengths.UserCountSet && lengths.UserCount > 0 { + info.Users = make([]DomainGuestInfoUser, lengths.UserCount) + for i := 0; i < int(lengths.UserCount); i++ { + usersInfo := getDomainGuestInfoUserFieldInfo(i, &info.Users[i]) + + _, gerr = typedParamsUnpack(cparams, cnparams, usersInfo) + if gerr != nil { + return nil, gerr + } + } + } + + os := DomainGuestInfoOS{} + osInfo := getDomainGuestInfoOSFieldInfo(&os) + + _, gerr = typedParamsUnpack(cparams, cnparams, osInfo) + if gerr != nil { + return nil, gerr + } + + timezone := DomainGuestInfoTimeZone{} + timezoneInfo := getDomainGuestInfoTimeZoneFieldInfo(&timezone) + + _, gerr = typedParamsUnpack(cparams, cnparams, timezoneInfo) + if gerr != nil { + return nil, gerr + } + + if lengths.FileSystemCountSet && lengths.FileSystemCount > 0 { + info.FileSystems = make([]DomainGuestInfoFileSystem, lengths.FileSystemCount) + for i := 0; i < int(lengths.FileSystemCount); i++ { + fsInfo := getDomainGuestInfoFileSystemFieldInfo(i, &info.FileSystems[i]) + + _, gerr = typedParamsUnpack(cparams, cnparams, fsInfo) + if gerr != nil { + return nil, gerr + } + + fsLengths := domainGuestInfoFileSystemLengths{} + fsLengthsInfo := getDomainGuestInfoFileSystemLengthsFieldInfo(i, &fsLengths) + + _, gerr = typedParamsUnpack(cparams, cnparams, fsLengthsInfo) + if gerr != nil { + return nil, gerr + } + + if fsLengths.DiskCountSet && fsLengths.DiskCount > 0 { + info.FileSystems[i].Disks = make([]DomainGuestInfoFileSystemDisk, fsLengths.DiskCount) + for j := 0; j < int(fsLengths.DiskCount); j++ { + diskInfo := getDomainGuestInfoFileSystemDiskFieldInfo(i, j, &info.FileSystems[i].Disks[j]) + + _, gerr = typedParamsUnpack(cparams, cnparams, diskInfo) + if gerr != nil { + return nil, gerr + } + } + } + } + } + + return &info, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainAgentSetResponseTimeout +func (d *Domain) AgentSetResponseTimeout(timeout int, flags uint32) error { + if C.LIBVIR_VERSION_NUMBER < 5010000 { + return makeNotImplementedError("virDomainAgentSetResponseTimeout") + } + + var err C.virError + ret := C.virDomainAgentSetResponseTimeoutWrapper(d.ptr, C.int(timeout), C.uint(flags), &err) + if ret == -1 { + return makeError(&err) + } + + return nil +} diff --git a/vendor/github.com/libvirt/libvirt-go/domain_checkpoint.go b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint.go new file mode 100644 index 000000000..da876f9a8 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint.go @@ -0,0 +1,188 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (c) 2013 Alex Zorin + * Copyright (C) 2016-2019 Red Hat, Inc. + * + */ + +package libvirt + +/* +#cgo pkg-config: libvirt +#include +#include "domain_checkpoint_wrapper.h" +*/ +import "C" + +import ( + "reflect" + "unsafe" +) + +type DomainCheckpointCreateFlags int + +const ( + DOMAIN_CHECKPOINT_CREATE_REDEFINE = DomainCheckpointCreateFlags(C.VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE) + DOMAIN_CHECKPOINT_CREATE_QUIESCE = DomainCheckpointCreateFlags(C.VIR_DOMAIN_CHECKPOINT_CREATE_QUIESCE) +) + +type DomainCheckpointListFlags int + +const ( + DOMAIN_CHECKPOINT_LIST_ROOTS = DomainCheckpointListFlags(C.VIR_DOMAIN_CHECKPOINT_LIST_ROOTS) + DOMAIN_CHECKPOINT_LIST_DESCENDANTS = DomainCheckpointListFlags(C.VIR_DOMAIN_CHECKPOINT_LIST_DESCENDANTS) + DOMAIN_CHECKPOINT_LIST_LEAVES = DomainCheckpointListFlags(C.VIR_DOMAIN_CHECKPOINT_LIST_LEAVES) + DOMAIN_CHECKPOINT_LIST_NO_LEAVES = DomainCheckpointListFlags(C.VIR_DOMAIN_CHECKPOINT_LIST_NO_LEAVES) + DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL = DomainCheckpointListFlags(C.VIR_DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL) +) + +type DomainCheckpointDeleteFlags int + +const ( + DOMAIN_CHECKPOINT_DELETE_CHILDREN = DomainCheckpointDeleteFlags(C.VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN) + DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY = DomainCheckpointDeleteFlags(C.VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY) + DOMAIN_CHECKPOINT_DELETE_CHILDREN_ONLY = DomainCheckpointDeleteFlags(C.VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN_ONLY) +) + +type DomainCheckpointXMLFlags int + +const ( + DOMAIN_CHECKPOINT_XML_SECURE = DomainCheckpointXMLFlags(C.VIR_DOMAIN_CHECKPOINT_XML_SECURE) + DOMAIN_CHECKPOINT_XML_NO_DOMAIN = DomainCheckpointXMLFlags(C.VIR_DOMAIN_CHECKPOINT_XML_NO_DOMAIN) + DOMAIN_CHECKPOINT_XML_SIZE = DomainCheckpointXMLFlags(C.VIR_DOMAIN_CHECKPOINT_XML_SIZE) +) + +type DomainCheckpoint struct { + ptr C.virDomainCheckpointPtr +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointFree +func (s *DomainCheckpoint) Free() error { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return makeNotImplementedError("virDomainCheckpointFree") + } + + var err C.virError + ret := C.virDomainCheckpointFreeWrapper(s.ptr, &err) + if ret == -1 { + return makeError(&err) + } + return nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointRef +func (c *DomainCheckpoint) Ref() error { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return makeNotImplementedError("virDomainCheckpointRef") + } + + var err C.virError + ret := C.virDomainCheckpointRefWrapper(c.ptr, &err) + if ret == -1 { + return makeError(&err) + } + return nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointDelete +func (s *DomainCheckpoint) Delete(flags DomainCheckpointDeleteFlags) error { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return makeNotImplementedError("virDomainCheckpointDelete") + } + + var err C.virError + result := C.virDomainCheckpointDeleteWrapper(s.ptr, C.uint(flags), &err) + if result != 0 { + return makeError(&err) + } + return nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointGetXMLDesc +func (s *DomainCheckpoint) GetXMLDesc(flags DomainCheckpointXMLFlags) (string, error) { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return "", makeNotImplementedError("virDomainCheckpointGetXMLDesc") + } + + var err C.virError + result := C.virDomainCheckpointGetXMLDescWrapper(s.ptr, C.uint(flags), &err) + if result == nil { + return "", makeError(&err) + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointGetName +func (s *DomainCheckpoint) GetName() (string, error) { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return "", makeNotImplementedError("virDomainCheckpointGetName") + } + + var err C.virError + name := C.virDomainCheckpointGetNameWrapper(s.ptr, &err) + if name == nil { + return "", makeError(&err) + } + return C.GoString(name), nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointGetParent +func (s *DomainCheckpoint) GetParent(flags uint32) (*DomainCheckpoint, error) { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return nil, makeNotImplementedError("virDomainCheckpointGetParent") + } + + var err C.virError + ptr := C.virDomainCheckpointGetParentWrapper(s.ptr, C.uint(flags), &err) + if ptr == nil { + return nil, makeError(&err) + } + return &DomainCheckpoint{ptr: ptr}, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-domain-checkpoint.html#virDomainCheckpointListAllChildren +func (d *DomainCheckpoint) ListAllChildren(flags DomainCheckpointListFlags) ([]DomainCheckpoint, error) { + if C.LIBVIR_VERSION_NUMBER < 5006000 { + return []DomainCheckpoint{}, makeNotImplementedError("virDomainCheckpointListAllChildren") + } + + var cList *C.virDomainCheckpointPtr + var err C.virError + numVols := C.virDomainCheckpointListAllChildrenWrapper(d.ptr, (**C.virDomainCheckpointPtr)(&cList), C.uint(flags), &err) + if numVols == -1 { + return nil, makeError(&err) + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numVols), + Cap: int(numVols), + } + var pools []DomainCheckpoint + slice := *(*[]C.virDomainCheckpointPtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + pools = append(pools, DomainCheckpoint{ptr}) + } + C.free(unsafe.Pointer(cList)) + return pools, nil +} diff --git a/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_compat.h b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_compat.h new file mode 100644 index 000000000..7213da745 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_compat.h @@ -0,0 +1,95 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +#ifndef LIBVIRT_GO_DOMAIN_CHECKPOINT_COMPAT_H__ +#define LIBVIRT_GO_DOMAIN_CHECKPOINT_COMPAT_H__ + +/* 5.6.0 */ + +#if LIBVIR_VERSION_NUMBER < 5006000 +typedef struct _virDomainCheckpoint *virDomainCheckpointPtr; +#endif + + +#ifndef VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE +# define VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE (1 << 0) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_CREATE_QUIESCE +# define VIR_DOMAIN_CHECKPOINT_CREATE_QUIESCE (1 << 1) +#endif + + + +#ifndef VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN +# define VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN (1 << 0) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY +# define VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY (1 << 1) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN_ONLY +# define VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN_ONLY (1 << 2) +#endif + + + +#ifndef VIR_DOMAIN_CHECKPOINT_LIST_ROOTS +# define VIR_DOMAIN_CHECKPOINT_LIST_ROOTS (1 << 0) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_LIST_DESCENDANTS +# define VIR_DOMAIN_CHECKPOINT_LIST_DESCENDANTS (1 << 0) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL +# define VIR_DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL (1 << 1) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_LIST_LEAVES +# define VIR_DOMAIN_CHECKPOINT_LIST_LEAVES (1 << 2) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_LIST_NO_LEAVES +# define VIR_DOMAIN_CHECKPOINT_LIST_NO_LEAVES (1 << 3) +#endif + + + +#ifndef VIR_DOMAIN_CHECKPOINT_XML_SECURE +# define VIR_DOMAIN_CHECKPOINT_XML_SECURE (1 << 0) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_XML_NO_DOMAIN +# define VIR_DOMAIN_CHECKPOINT_XML_NO_DOMAIN (1 << 1) +#endif + +#ifndef VIR_DOMAIN_CHECKPOINT_XML_SIZE +# define VIR_DOMAIN_CHECKPOINT_XML_SIZE (1 << 2) +#endif + + +#endif /* LIBVIRT_GO_DOMAIN_CHECKPOINT_COMPAT_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_wrapper.go b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_wrapper.go new file mode 100644 index 000000000..b51f2dcda --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_wrapper.go @@ -0,0 +1,152 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2018 Red Hat, Inc. + * + */ + +package libvirt + +/* +#cgo pkg-config: libvirt +#include +#include "domain_checkpoint_wrapper.h" + + +int +virDomainCheckpointDeleteWrapper(virDomainCheckpointPtr checkpoint, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + int ret = virDomainCheckpointDelete(checkpoint, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainCheckpointFreeWrapper(virDomainCheckpointPtr checkpoint, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + int ret = virDomainCheckpointFree(checkpoint); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +const char * +virDomainCheckpointGetNameWrapper(virDomainCheckpointPtr checkpoint, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + const char * ret = virDomainCheckpointGetName(checkpoint); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +virDomainCheckpointPtr +virDomainCheckpointGetParentWrapper(virDomainCheckpointPtr checkpoint, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + virDomainCheckpointPtr ret = virDomainCheckpointGetParent(checkpoint, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +char * +virDomainCheckpointGetXMLDescWrapper(virDomainCheckpointPtr checkpoint, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + char * ret = virDomainCheckpointGetXMLDesc(checkpoint, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainCheckpointListAllChildrenWrapper(virDomainCheckpointPtr checkpoint, + virDomainCheckpointPtr **snaps, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + int ret = virDomainCheckpointListAllChildren(checkpoint, snaps, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainCheckpointRefWrapper(virDomainCheckpointPtr checkpoint, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + int ret = virDomainCheckpointRef(checkpoint); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +*/ +import "C" diff --git a/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_wrapper.h b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_wrapper.h new file mode 100644 index 000000000..fe9f99cf2 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/domain_checkpoint_wrapper.h @@ -0,0 +1,68 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2018 Red Hat, Inc. + * + */ + +#ifndef LIBVIRT_GO_DOMAIN_CHECKPOINT_WRAPPER_H__ +#define LIBVIRT_GO_DOMAIN_CHECKPOINT_WRAPPER_H__ + +#include +#include +#include "domain_compat.h" +#include "domain_checkpoint_compat.h" + +int +virDomainCheckpointDeleteWrapper(virDomainCheckpointPtr checkpoint, + unsigned int flags, + virErrorPtr err); + +int +virDomainCheckpointFreeWrapper(virDomainCheckpointPtr checkpoint, + virErrorPtr err); + +const char * +virDomainCheckpointGetNameWrapper(virDomainCheckpointPtr checkpoint, + virErrorPtr err); + +virDomainCheckpointPtr +virDomainCheckpointGetParentWrapper(virDomainCheckpointPtr checkpoint, + unsigned int flags, + virErrorPtr err); + +char * +virDomainCheckpointGetXMLDescWrapper(virDomainCheckpointPtr checkpoint, + unsigned int flags, + virErrorPtr err); + +int +virDomainCheckpointListAllChildrenWrapper(virDomainCheckpointPtr checkpoint, + virDomainCheckpointPtr **snaps, + unsigned int flags, + virErrorPtr err); + +int +virDomainCheckpointRefWrapper(virDomainCheckpointPtr checkpoint, + virErrorPtr err); + + +#endif /* LIBVIRT_GO_DOMAIN_CHECKPOINT_WRAPPER_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/domain_compat.h b/vendor/github.com/libvirt/libvirt-go/domain_compat.h index d20631fc1..3b91b15b0 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain_compat.h +++ b/vendor/github.com/libvirt/libvirt-go/domain_compat.h @@ -895,7 +895,7 @@ struct _virDomainInterface { #endif #ifndef VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP -#define VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP 1 +#define VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_ARP 2 #endif /* 4.5.0 */ @@ -911,4 +911,113 @@ struct _virDomainInterface { #define VIR_DOMAIN_MEMORY_STAT_DISK_CACHES 10 #endif +/* 4.10.0 */ + +#ifndef VIR_DOMAIN_SHUTOFF_DAEMON +#define VIR_DOMAIN_SHUTOFF_DAEMON 8 +#endif + +#ifndef VIR_DOMAIN_STATS_IOTHREAD +#define VIR_DOMAIN_STATS_IOTHREAD (1 << 7) +#endif + +#ifndef VIR_DOMAIN_IOTHREAD_POLL_GROW +#define VIR_DOMAIN_IOTHREAD_POLL_GROW "poll_grow" +#endif + +#ifndef VIR_DOMAIN_IOTHREAD_POLL_SHRINK +#define VIR_DOMAIN_IOTHREAD_POLL_SHRINK "poll_shrink" +#endif + +#ifndef VIR_DOMAIN_IOTHREAD_POLL_MAX_NS +#define VIR_DOMAIN_IOTHREAD_POLL_MAX_NS "poll_max_ns" +#endif + +/* 5.0.0 */ + +#ifndef VIR_DOMAIN_JOB_MEMORY_POSTCOPY_REQS +#define VIR_DOMAIN_JOB_MEMORY_POSTCOPY_REQS "memory_postcopy_requests" +#endif + +/* 5.1.0 */ +#ifndef VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY +#define VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY "bandwidth.postcopy" +#endif + +#ifndef VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY +#define VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY (1 << 0) +#endif + +#ifndef VIR_DOMAIN_SNAPSHOT_XML_SECURE +#define VIR_DOMAIN_SNAPSHOT_XML_SECURE (1 << 0) +#endif + +#ifndef VIR_DOMAIN_SAVE_IMAGE_XML_SECURE +#define VIR_DOMAIN_SAVE_IMAGE_XML_SECURE (1 << 0) +#endif + +/* 5.2.0 */ + +#ifndef VIR_MIGRATE_PARALLEL +#define VIR_MIGRATE_PARALLEL (1 << 17) +#endif + +#ifndef VIR_MIGRATE_PARAM_PARALLEL_CONNECTIONS +#define VIR_MIGRATE_PARAM_PARALLEL_CONNECTIONS "parallel.connections" +#endif + +/* 5.4.0 */ + +#ifndef VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGALLOC +#define VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGALLOC 11 +#endif + +#ifndef VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGFAIL +#define VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGFAIL 12 +#endif + + +/* 5.6.0 */ + +#ifndef VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA +# define VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA (1 << 4) +#endif + + +/* 5.7.0 */ + +#ifndef VIR_DOMAIN_GUEST_INFO_USERS +#define VIR_DOMAIN_GUEST_INFO_USERS (1 << 0) +#endif + +#ifndef VIR_DOMAIN_GUEST_INFO_OS +#define VIR_DOMAIN_GUEST_INFO_OS (1 << 1) +#endif + +#ifndef VIR_DOMAIN_GUEST_INFO_TIMEZONE +#define VIR_DOMAIN_GUEST_INFO_TIMEZONE (1 << 2) +#endif + +#ifndef VIR_DOMAIN_GUEST_INFO_HOSTNAME +#define VIR_DOMAIN_GUEST_INFO_HOSTNAME (1 << 3) +#endif + +#ifndef VIR_DOMAIN_GUEST_INFO_FILESYSTEM +#define VIR_DOMAIN_GUEST_INFO_FILESYSTEM (1 << 4) +#endif + +/* 5.10.0 */ + +#ifndef VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_BLOCK +#define VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_BLOCK -2 +#endif + +#ifndef VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_DEFAULT +#define VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_DEFAULT -1 +#endif + +#ifndef VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_NOWAIT +#define VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_NOWAIT 0 +#endif + #endif /* LIBVIRT_GO_DOMAIN_COMPAT_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/domain_events.go b/vendor/github.com/libvirt/libvirt-go/domain_events.go index fe46c5e24..2aff8e811 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain_events.go +++ b/vendor/github.com/libvirt/libvirt-go/domain_events.go @@ -758,12 +758,12 @@ func countPinInfo(cparams C.virTypedParameterPtr, nparams C.int) (int, int) { return maxvcpus + 1, maxiothreads + 1 } -func domainEventTunableGetPin(params C.virTypedParameterPtr, nparams C.int) *DomainEventTunableCpuPin { +func domainEventTunableGetPin(params C.virTypedParameterPtr, cnparams C.int) *DomainEventTunableCpuPin { var pin domainEventTunablePinTemp - numvcpus, numiothreads := countPinInfo(params, nparams) + numvcpus, numiothreads := countPinInfo(params, cnparams) pinInfo := getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin) - num, err := typedParamsUnpackLen(params, int(nparams), pinInfo) + num, err := typedParamsUnpack(params, cnparams, pinInfo) if num == 0 || err != nil { return nil } @@ -806,13 +806,13 @@ func domainEventTunableGetPin(params C.virTypedParameterPtr, nparams C.int) *Dom } //export domainEventTunableCallback -func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, params C.virTypedParameterPtr, nparams C.int, goCallbackId int) { +func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, params C.virTypedParameterPtr, cnparams C.int, goCallbackId int) { domain := &Domain{ptr: d} connection := &Connect{ptr: c} eventDetails := &DomainEventTunable{} - pin := domainEventTunableGetPin(params, nparams) + pin := domainEventTunableGetPin(params, cnparams) if pin != nil { eventDetails.CpuPin = pin } @@ -820,7 +820,7 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, params C.vi var sched DomainSchedulerParameters schedInfo := getDomainTuneSchedulerParametersFieldInfo(&sched) - num, _ := typedParamsUnpackLen(params, int(nparams), schedInfo) + num, _ := typedParamsUnpack(params, cnparams, schedInfo) if num > 0 { eventDetails.CpuSched = &sched } @@ -831,12 +831,12 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, params C.vi s: &eventDetails.BlkdevDisk, }, } - typedParamsUnpackLen(params, int(nparams), blknameInfo) + typedParamsUnpack(params, cnparams, blknameInfo) var blktune DomainBlockIoTuneParameters blktuneInfo := getTuneBlockIoTuneParametersFieldInfo(&blktune) - num, _ = typedParamsUnpackLen(params, int(nparams), blktuneInfo) + num, _ = typedParamsUnpack(params, cnparams, blktuneInfo) if num > 0 { eventDetails.BlkdevTune = &blktune } @@ -903,14 +903,14 @@ func domainEventMigrationIterationCallback(c C.virConnectPtr, d C.virDomainPtr, } //export domainEventJobCompletedCallback -func domainEventJobCompletedCallback(c C.virConnectPtr, d C.virDomainPtr, params C.virTypedParameterPtr, nparams C.int, goCallbackId int) { +func domainEventJobCompletedCallback(c C.virConnectPtr, d C.virDomainPtr, params C.virTypedParameterPtr, cnparams C.int, goCallbackId int) { domain := &Domain{ptr: d} connection := &Connect{ptr: c} eventDetails := &DomainEventJobCompleted{} info := getDomainJobInfoFieldInfo(&eventDetails.Info) - typedParamsUnpackLen(params, int(nparams), info) + typedParamsUnpack(params, cnparams, info) callbackFunc := getCallbackId(goCallbackId) callback, ok := callbackFunc.(DomainEventJobCompletedCallback) diff --git a/vendor/github.com/libvirt/libvirt-go/domain_snapshot.go b/vendor/github.com/libvirt/libvirt-go/domain_snapshot.go index 65fbbb5c9..20ca14c98 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain_snapshot.go +++ b/vendor/github.com/libvirt/libvirt-go/domain_snapshot.go @@ -50,6 +50,7 @@ const ( DOMAIN_SNAPSHOT_CREATE_QUIESCE = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE) DOMAIN_SNAPSHOT_CREATE_ATOMIC = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC) DOMAIN_SNAPSHOT_CREATE_LIVE = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_LIVE) + DOMAIN_SNAPSHOT_CREATE_VALIDATE = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE) ) type DomainSnapshotListFlags int @@ -66,6 +67,7 @@ const ( DOMAIN_SNAPSHOT_LIST_DISK_ONLY = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY) DOMAIN_SNAPSHOT_LIST_INTERNAL = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL) DOMAIN_SNAPSHOT_LIST_EXTERNAL = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL) + DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL) ) type DomainSnapshotRevertFlags int @@ -84,6 +86,12 @@ const ( DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = DomainSnapshotDeleteFlags(C.VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY) ) +type DomainSnapshotXMLFlags int + +const ( + DOMAIN_SNAPSHOT_XML_SECURE = DomainSnapshotXMLFlags(C.VIR_DOMAIN_SNAPSHOT_XML_SECURE) +) + type DomainSnapshot struct { ptr C.virDomainSnapshotPtr } @@ -155,7 +163,7 @@ func (s *DomainSnapshot) HasMetadata(flags uint32) (bool, error) { } // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotGetXMLDesc -func (s *DomainSnapshot) GetXMLDesc(flags DomainXMLFlags) (string, error) { +func (s *DomainSnapshot) GetXMLDesc(flags DomainSnapshotXMLFlags) (string, error) { var err C.virError result := C.virDomainSnapshotGetXMLDescWrapper(s.ptr, C.uint(flags), &err) if result == nil { diff --git a/vendor/github.com/libvirt/libvirt-go/domain_snapshot_compat.h b/vendor/github.com/libvirt/libvirt-go/domain_snapshot_compat.h new file mode 100644 index 000000000..d9f8271b7 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/domain_snapshot_compat.h @@ -0,0 +1,40 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +#ifndef LIBVIRT_GO_DOMAIN_SNAPSHOT_COMPAT_H__ +#define LIBVIRT_GO_DOMAIN_SNAPSHOT_COMPAT_H__ + +/* 5.2.0 */ +#ifndef VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL +# define VIR_DOMAIN_SNAPSHOT_LIST_TOPOLOGICAL (1 << 10) +#endif + +/* 5.6.0 */ + +#ifndef VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE +# define VIR_DOMAIN_SNAPSHOT_CREATE_VALIDATE (1 << 9) +#endif + +#endif /* LIBVIRT_GO_DOMAIN_SNAPSHOT_COMPAT_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.go b/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.go index a061dee07..04547de7f 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.go @@ -69,30 +69,6 @@ virDomainSnapshotFreeWrapper(virDomainSnapshotPtr snapshot, } -virConnectPtr -virDomainSnapshotGetConnectWrapper(virDomainSnapshotPtr snapshot, - virErrorPtr err) -{ - virConnectPtr ret = virDomainSnapshotGetConnect(snapshot); - if (!ret) { - virCopyLastError(err); - } - return ret; -} - - -virDomainPtr -virDomainSnapshotGetDomainWrapper(virDomainSnapshotPtr snapshot, - virErrorPtr err) -{ - virDomainPtr ret = virDomainSnapshotGetDomain(snapshot); - if (!ret) { - virCopyLastError(err); - } - return ret; -} - - const char * virDomainSnapshotGetNameWrapper(virDomainSnapshotPtr snapshot, virErrorPtr err) diff --git a/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.h b/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.h index fcf8036b4..7b07e510a 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/domain_snapshot_wrapper.h @@ -28,7 +28,8 @@ #include #include - +#include "domain_compat.h" +#include "domain_snapshot_compat.h" int virDomainRevertToSnapshotWrapper(virDomainSnapshotPtr snapshot, @@ -44,14 +45,6 @@ int virDomainSnapshotFreeWrapper(virDomainSnapshotPtr snapshot, virErrorPtr err); -virConnectPtr -virDomainSnapshotGetConnectWrapper(virDomainSnapshotPtr snapshot, - virErrorPtr err); - -virDomainPtr -virDomainSnapshotGetDomainWrapper(virDomainSnapshotPtr snapshot, - virErrorPtr err); - const char * virDomainSnapshotGetNameWrapper(virDomainSnapshotPtr snapshot, virErrorPtr err); diff --git a/vendor/github.com/libvirt/libvirt-go/domain_wrapper.go b/vendor/github.com/libvirt/libvirt-go/domain_wrapper.go index b42dd42f7..63573c33b 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/domain_wrapper.go @@ -1913,6 +1913,26 @@ virDomainSetGuestVcpusWrapper(virDomainPtr domain, } +int +virDomainSetIOThreadParamsWrapper(virDomainPtr domain, + unsigned int iothread_id, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 4010000 + assert(0); // Caller should have checked version +#else + int ret = virDomainSetIOThreadParams(domain, iothread_id, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + int virDomainSetInterfaceParametersWrapper(virDomainPtr domain, const char *device, @@ -2326,5 +2346,95 @@ virDomainUpdateDeviceFlagsWrapper(virDomainPtr domain, } +int +virDomainListAllCheckpointsWrapper(virDomainPtr domain, + virDomainCheckpointPtr **cps, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + int ret = virDomainListAllCheckpoints(domain, cps, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +virDomainCheckpointPtr +virDomainCheckpointCreateXMLWrapper(virDomainPtr domain, + const char *xmlDesc, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + virDomainCheckpointPtr ret = virDomainCheckpointCreateXML(domain, xmlDesc, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +virDomainCheckpointPtr +virDomainCheckpointLookupByNameWrapper(virDomainPtr domain, + const char *name, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5006000 + assert(0); // Caller should have checked version +#else + virDomainCheckpointPtr ret = virDomainCheckpointLookupByName(domain, name, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainGetGuestInfoWrapper(virDomainPtr domain, + unsigned int types, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5007000 + assert(0); // Caller should have checked version +#else + int ret = virDomainGetGuestInfo(domain, types, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + +int +virDomainAgentSetResponseTimeoutWrapper(virDomainPtr domain, + int timeout, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5010000 + assert(0); // Caller should have checked version +#else + int ret = virDomainAgentSetResponseTimeout(domain, timeout, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + */ import "C" diff --git a/vendor/github.com/libvirt/libvirt-go/domain_wrapper.h b/vendor/github.com/libvirt/libvirt-go/domain_wrapper.h index 7bd82826d..568910e6f 100644 --- a/vendor/github.com/libvirt/libvirt-go/domain_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/domain_wrapper.h @@ -30,6 +30,7 @@ #include #include #include "domain_compat.h" +#include "domain_checkpoint_compat.h" int virDomainAbortJobWrapper(virDomainPtr domain, @@ -813,6 +814,14 @@ virDomainSetGuestVcpusWrapper(virDomainPtr domain, unsigned int flags, virErrorPtr err); +int +virDomainSetIOThreadParamsWrapper(virDomainPtr domain, + unsigned int iothread_id, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); + int virDomainSetInterfaceParametersWrapper(virDomainPtr domain, const char *device, @@ -982,5 +991,36 @@ virDomainUpdateDeviceFlagsWrapper(virDomainPtr domain, unsigned int flags, virErrorPtr err); +int +virDomainListAllCheckpointsWrapper(virDomainPtr domain, + virDomainCheckpointPtr **cps, + unsigned int flags, + virErrorPtr err); + +virDomainCheckpointPtr +virDomainCheckpointCreateXMLWrapper(virDomainPtr domain, + const char *xmlDesc, + unsigned int flags, + virErrorPtr err); + +virDomainCheckpointPtr +virDomainCheckpointLookupByNameWrapper(virDomainPtr domain, + const char *name, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetGuestInfoWrapper(virDomainPtr domain, + unsigned int types, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainAgentSetResponseTimeoutWrapper(virDomainPtr domain, + int timeout, + unsigned int flags, + virErrorPtr err); #endif /* LIBVIRT_GO_DOMAIN_WRAPPER_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/error.go b/vendor/github.com/libvirt/libvirt-go/error.go index 1cfdf922e..4b057fba3 100644 --- a/vendor/github.com/libvirt/libvirt-go/error.go +++ b/vendor/github.com/libvirt/libvirt-go/error.go @@ -362,6 +362,24 @@ const ( // Requested nwfilter binding does not exist ERR_NO_NWFILTER_BINDING = ErrorNumber(C.VIR_ERR_NO_NWFILTER_BINDING) + + // invalid domain checkpoint + ERR_INVALID_DOMAIN_CHECKPOINT = ErrorNumber(C.VIR_ERR_INVALID_DOMAIN_CHECKPOINT) + + // domain checkpoint not found + ERR_NO_DOMAIN_CHECKPOINT = ErrorNumber(C.VIR_ERR_NO_DOMAIN_CHECKPOINT) + + // domain backup job id not found * + ERR_NO_DOMAIN_BACKUP = ErrorNumber(C.VIR_ERR_NO_DOMAIN_BACKUP) + + // invalid network port object + ERR_INVALID_NETWORK_PORT = ErrorNumber(C.VIR_ERR_INVALID_NETWORK_PORT) + + // network port already exists + ERR_NETWORK_PORT_EXIST = ErrorNumber(C.VIR_ERR_NETWORK_PORT_EXIST) + + // network port not found + ERR_NO_NETWORK_PORT = ErrorNumber(C.VIR_ERR_NO_NETWORK_PORT) ) type ErrorDomain int @@ -569,6 +587,18 @@ const ( // Error from resoruce control FROM_RESCTRL = ErrorDomain(C.VIR_FROM_RESCTRL) + + // Error from firewalld + FROM_FIREWALLD = ErrorDomain(C.VIR_FROM_FIREWALLD) + + // Error from domain checkpoint + FROM_DOMAIN_CHECKPOINT = ErrorDomain(C.VIR_FROM_DOMAIN_CHECKPOINT) + + // Error from TPM + FROM_TPM = ErrorDomain(C.VIR_FROM_TPM) + + // Error from BPF + FROM_BPF = ErrorDomain(C.VIR_FROM_BPF) ) type Error struct { diff --git a/vendor/github.com/libvirt/libvirt-go/error_compat.h b/vendor/github.com/libvirt/libvirt-go/error_compat.h index 0e4168038..038392538 100644 --- a/vendor/github.com/libvirt/libvirt-go/error_compat.h +++ b/vendor/github.com/libvirt/libvirt-go/error_compat.h @@ -163,4 +163,54 @@ #define VIR_ERR_NO_NWFILTER_BINDING 101 #endif +/* 5.1.0 */ + +#ifndef VIR_FROM_FIREWALLD +#define VIR_FROM_FIREWALLD 68 +#endif + +/* 5.2.0 */ + +#ifndef VIR_ERR_INVALID_DOMAIN_CHECKPOINT +#define VIR_ERR_INVALID_DOMAIN_CHECKPOINT 102 +#endif + +#ifndef VIR_ERR_NO_DOMAIN_CHECKPOINT +#define VIR_ERR_NO_DOMAIN_CHECKPOINT 103 +#endif + +#ifndef VIR_ERR_NO_DOMAIN_BACKUP +#define VIR_ERR_NO_DOMAIN_BACKUP 104 +#endif + +#ifndef VIR_FROM_DOMAIN_CHECKPOINT +#define VIR_FROM_DOMAIN_CHECKPOINT 69 +#endif + +/* 5.5.0 */ + +#ifndef VIR_ERR_INVALID_NETWORK_PORT +#define VIR_ERR_INVALID_NETWORK_PORT 105 +#endif + +#ifndef VIR_ERR_NETWORK_PORT_EXIST +#define VIR_ERR_NETWORK_PORT_EXIST 106 +#endif + +#ifndef VIR_ERR_NO_NETWORK_PORT +#define VIR_ERR_NO_NETWORK_PORT 107 +#endif + +/* 5.6.0 */ + +#ifndef VIR_FROM_TPM +#define VIR_FROM_TPM 70 +#endif + +/* 5.10.0 */ + +#ifndef VIR_FROM_BPF +#define VIR_FROM_BPF 71 +#endif + #endif /* LIBVIRT_GO_ERROR_COMPAT_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/events.go b/vendor/github.com/libvirt/libvirt-go/events.go index bf2c1f4ec..23d5bbbdf 100644 --- a/vendor/github.com/libvirt/libvirt-go/events.go +++ b/vendor/github.com/libvirt/libvirt-go/events.go @@ -45,6 +45,7 @@ const ( // See also https://libvirt.org/html/libvirt-libvirt-event.html#virEventRegisterDefaultImpl func EventRegisterDefaultImpl() error { var err C.virError + C.virInitialize() if i := int(C.virEventRegisterDefaultImplWrapper(&err)); i != 0 { return makeError(&err) } @@ -188,6 +189,7 @@ var eventLoopImpl EventLoop // See also https://libvirt.org/html/libvirt-libvirt-event.html#virEventRegisterImpl func EventRegisterImpl(impl EventLoop) { eventLoopImpl = impl + C.virInitialize() C.virEventRegisterImplWrapper() } diff --git a/vendor/github.com/libvirt/libvirt-go/interface_wrapper.go b/vendor/github.com/libvirt/libvirt-go/interface_wrapper.go index a33aea9e4..36eb16f10 100644 --- a/vendor/github.com/libvirt/libvirt-go/interface_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/interface_wrapper.go @@ -69,18 +69,6 @@ virInterfaceFreeWrapper(virInterfacePtr iface, } -virConnectPtr -virInterfaceGetConnectWrapper(virInterfacePtr iface, - virErrorPtr err) -{ - virConnectPtr ret = virInterfaceGetConnect(iface); - if (!ret) { - virCopyLastError(err); - } - return ret; -} - - const char * virInterfaceGetMACStringWrapper(virInterfacePtr iface, virErrorPtr err) diff --git a/vendor/github.com/libvirt/libvirt-go/interface_wrapper.h b/vendor/github.com/libvirt/libvirt-go/interface_wrapper.h index b7cef7613..8d47a224f 100644 --- a/vendor/github.com/libvirt/libvirt-go/interface_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/interface_wrapper.h @@ -43,10 +43,6 @@ int virInterfaceFreeWrapper(virInterfacePtr iface, virErrorPtr err); -virConnectPtr -virInterfaceGetConnectWrapper(virInterfacePtr iface, - virErrorPtr err); - const char * virInterfaceGetMACStringWrapper(virInterfacePtr iface, virErrorPtr err); diff --git a/vendor/github.com/libvirt/libvirt-go/network.go b/vendor/github.com/libvirt/libvirt-go/network.go index 99954aa5c..a0bc361b5 100644 --- a/vendor/github.com/libvirt/libvirt-go/network.go +++ b/vendor/github.com/libvirt/libvirt-go/network.go @@ -34,6 +34,7 @@ package libvirt import "C" import ( + "fmt" "reflect" "time" "unsafe" @@ -333,3 +334,82 @@ func (n *Network) GetDHCPLeases() ([]NetworkDHCPLease, error) { C.free(unsafe.Pointer(cLeases)) return leases, nil } + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortLookupByUUIDString +func (n *Network) LookupNetworkPortByUUIDString(uuid string) (*NetworkPort, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return nil, makeNotImplementedError("virNetworkPortLookupByUUIDString") + } + + cUuid := C.CString(uuid) + defer C.free(unsafe.Pointer(cUuid)) + var err C.virError + ptr := C.virNetworkPortLookupByUUIDStringWrapper(n.ptr, cUuid, &err) + if ptr == nil { + return nil, makeError(&err) + } + return &NetworkPort{ptr: ptr}, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortLookupByUUID +func (n *Network) LookupNetworkPortByUUID(uuid []byte) (*NetworkPort, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return nil, makeNotImplementedError("virNetworkPortLookupByUUID") + } + + if len(uuid) != C.VIR_UUID_BUFLEN { + return nil, fmt.Errorf("UUID must be exactly %d bytes in size", + int(C.VIR_UUID_BUFLEN)) + } + cUuid := make([]C.uchar, C.VIR_UUID_BUFLEN) + for i := 0; i < C.VIR_UUID_BUFLEN; i++ { + cUuid[i] = C.uchar(uuid[i]) + } + var err C.virError + ptr := C.virNetworkPortLookupByUUIDWrapper(n.ptr, &cUuid[0], &err) + if ptr == nil { + return nil, makeError(&err) + } + return &NetworkPort{ptr: ptr}, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortCreateXML +func (n *Network) PortCreateXML(xmlConfig string, flags uint) (*NetworkPort, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return nil, makeNotImplementedError("virNetworkPortCreateXML") + } + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + var err C.virError + ptr := C.virNetworkPortCreateXMLWrapper(n.ptr, cXml, C.uint(flags), &err) + if ptr == nil { + return nil, makeError(&err) + } + return &NetworkPort{ptr: ptr}, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkListAllPorts +func (n *Network) ListAllPorts(flags uint) ([]NetworkPort, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return []NetworkPort{}, makeNotImplementedError("virNetworkListAllPorts") + } + + var cList *C.virNetworkPortPtr + var err C.virError + numPorts := C.virNetworkListAllPortsWrapper(n.ptr, (**C.virNetworkPortPtr)(&cList), C.uint(flags), &err) + if numPorts == -1 { + return []NetworkPort{}, makeError(&err) + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numPorts), + Cap: int(numPorts), + } + var ports []NetworkPort + slice := *(*[]C.virNetworkPortPtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + ports = append(ports, NetworkPort{ptr}) + } + C.free(unsafe.Pointer(cList)) + return ports, nil +} diff --git a/vendor/github.com/libvirt/libvirt-go/network_port.go b/vendor/github.com/libvirt/libvirt-go/network_port.go new file mode 100644 index 000000000..5f9d54f11 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/network_port.go @@ -0,0 +1,258 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +package libvirt + +/* +#cgo pkg-config: libvirt +#include +#include "network_wrapper.h" +#include "network_port_wrapper.h" +*/ +import "C" + +import ( + "unsafe" +) + +type NetworkPortCreateFlags int + +const ( + NETWORK_PORT_CREATE_RECLAIM = NetworkPortCreateFlags(C.VIR_NETWORK_PORT_CREATE_RECLAIM) +) + +type NetworkPort struct { + ptr C.virNetworkPortPtr +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortFree +func (n *NetworkPort) Free() error { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return makeNotImplementedError("virNetworkPortFree") + } + + var err C.virError + ret := C.virNetworkPortFreeWrapper(n.ptr, &err) + if ret == -1 { + return makeError(&err) + } + return nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortRef +func (c *NetworkPort) Ref() error { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return makeNotImplementedError("virNetworkPortRef") + } + + var err C.virError + ret := C.virNetworkPortRefWrapper(c.ptr, &err) + if ret == -1 { + return makeError(&err) + } + return nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortGetNetwork +// +// Contrary to the native C API behaviour, the Go API will +// acquire a reference on the returned Network, which must +// be released by calling Free() +func (n *NetworkPort) GetNetwork() (*Network, error) { + var err C.virError + ptr := C.virNetworkPortGetNetworkWrapper(n.ptr, &err) + if ptr == nil { + return nil, makeError(&err) + } + + ret := C.virNetworkRefWrapper(ptr, &err) + if ret == -1 { + return nil, makeError(&err) + } + + return &Network{ptr: ptr}, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortGetUUID +func (n *NetworkPort) GetUUID() ([]byte, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return []byte{}, makeNotImplementedError("virNetworkPortGetUUID") + } + + var cUuid [C.VIR_UUID_BUFLEN](byte) + cuidPtr := unsafe.Pointer(&cUuid) + var err C.virError + result := C.virNetworkPortGetUUIDWrapper(n.ptr, (*C.uchar)(cuidPtr), &err) + if result != 0 { + return []byte{}, makeError(&err) + } + return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortGetUUIDString +func (n *NetworkPort) GetUUIDString() (string, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return "", makeNotImplementedError("virNetworkPortGetUUIDString") + } + + var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) + cuidPtr := unsafe.Pointer(&cUuid) + var err C.virError + result := C.virNetworkPortGetUUIDStringWrapper(n.ptr, (*C.char)(cuidPtr), &err) + if result != 0 { + return "", makeError(&err) + } + return C.GoString((*C.char)(cuidPtr)), nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortDelete +func (n *NetworkPort) Delete(flags uint) error { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return makeNotImplementedError("virNetworkPortDelete") + } + + var err C.virError + result := C.virNetworkPortDeleteWrapper(n.ptr, C.uint(flags), &err) + if result == -1 { + return makeError(&err) + } + return nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortGetXMLDesc +func (d *NetworkPort) GetXMLDesc(flags uint) (string, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return "", makeNotImplementedError("virNetworkPortDelete") + } + + var err C.virError + result := C.virNetworkPortGetXMLDescWrapper(d.ptr, C.uint(flags), &err) + if result == nil { + return "", makeError(&err) + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} + +type NetworkPortParameters struct { + BandwidthInAverageSet bool + BandwidthInAverage uint + BandwidthInPeakSet bool + BandwidthInPeak uint + BandwidthInBurstSet bool + BandwidthInBurst uint + BandwidthInFloorSet bool + BandwidthInFloor uint + BandwidthOutAverageSet bool + BandwidthOutAverage uint + BandwidthOutPeakSet bool + BandwidthOutPeak uint + BandwidthOutBurstSet bool + BandwidthOutBurst uint +} + +func getNetworkPortParametersFieldInfo(params *NetworkPortParameters) map[string]typedParamsFieldInfo { + return map[string]typedParamsFieldInfo{ + C.VIR_NETWORK_PORT_BANDWIDTH_IN_AVERAGE: typedParamsFieldInfo{ + set: ¶ms.BandwidthInAverageSet, + ui: ¶ms.BandwidthInAverage, + }, + C.VIR_NETWORK_PORT_BANDWIDTH_IN_PEAK: typedParamsFieldInfo{ + set: ¶ms.BandwidthInPeakSet, + ui: ¶ms.BandwidthInPeak, + }, + C.VIR_NETWORK_PORT_BANDWIDTH_IN_BURST: typedParamsFieldInfo{ + set: ¶ms.BandwidthInBurstSet, + ui: ¶ms.BandwidthInBurst, + }, + C.VIR_NETWORK_PORT_BANDWIDTH_IN_FLOOR: typedParamsFieldInfo{ + set: ¶ms.BandwidthInFloorSet, + ui: ¶ms.BandwidthInFloor, + }, + C.VIR_NETWORK_PORT_BANDWIDTH_OUT_AVERAGE: typedParamsFieldInfo{ + set: ¶ms.BandwidthOutAverageSet, + ui: ¶ms.BandwidthOutAverage, + }, + C.VIR_NETWORK_PORT_BANDWIDTH_OUT_PEAK: typedParamsFieldInfo{ + set: ¶ms.BandwidthOutPeakSet, + ui: ¶ms.BandwidthOutPeak, + }, + C.VIR_NETWORK_PORT_BANDWIDTH_OUT_BURST: typedParamsFieldInfo{ + set: ¶ms.BandwidthOutBurstSet, + ui: ¶ms.BandwidthOutBurst, + }, + } +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortGetParameters +func (d *NetworkPort) GetParameters(flags uint) (*NetworkPortParameters, error) { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return nil, makeNotImplementedError("virNetworkPortGetParameters") + } + + params := &NetworkPortParameters{} + info := getNetworkPortParametersFieldInfo(params) + + var cparams C.virTypedParameterPtr + var cnparams C.int + var err C.virError + ret := C.virNetworkPortGetParametersWrapper(d.ptr, &cparams, &cnparams, C.uint(flags), &err) + if ret == -1 { + return nil, makeError(&err) + } + + defer C.virTypedParamsFree(cparams, cnparams) + + _, gerr := typedParamsUnpack(cparams, cnparams, info) + if gerr != nil { + return nil, gerr + } + + return params, nil +} + +// See also https://libvirt.org/html/libvirt-libvirt-network.html#virNetworkPortSetParameters +func (d *NetworkPort) SetParameters(params *NetworkPortParameters, flags uint) error { + if C.LIBVIR_VERSION_NUMBER < 5005000 { + return makeNotImplementedError("virNetworkPortSetParameters") + } + + info := getNetworkPortParametersFieldInfo(params) + + cparams, cnparams, gerr := typedParamsPackNew(info) + if gerr != nil { + return gerr + } + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret := C.virNetworkPortSetParametersWrapper(d.ptr, cparams, cnparams, C.uint(flags), &err) + if ret == -1 { + return makeError(&err) + } + + return nil +} diff --git a/vendor/github.com/libvirt/libvirt-go/network_port_compat.h b/vendor/github.com/libvirt/libvirt-go/network_port_compat.h new file mode 100644 index 000000000..77f541b33 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/network_port_compat.h @@ -0,0 +1,67 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +#ifndef LIBVIRT_GO_NETWORK_PORT_COMPAT_H__ +#define LIBVIRT_GO_NETWORK_PORT_COMPAT_H__ + +/* 5.5.0 */ + +#if LIBVIR_VERSION_NUMBER < 5005000 +typedef struct _virNetworkPort *virNetworkPortPtr; +#endif + +#ifndef VIR_NETWORK_PORT_CREATE_RECLAIM +#define VIR_NETWORK_PORT_CREATE_RECLAIM (1 << 0) +#endif + +#ifndef VIR_NETWORK_PORT_BANDWIDTH_IN_AVERAGE +#define VIR_NETWORK_PORT_BANDWIDTH_IN_AVERAGE "inbound.average" +#endif + +#ifndef VIR_NETWORK_PORT_BANDWIDTH_IN_PEAK +#define VIR_NETWORK_PORT_BANDWIDTH_IN_PEAK "inbound.peak" +#endif + +#ifndef VIR_NETWORK_PORT_BANDWIDTH_IN_BURST +#define VIR_NETWORK_PORT_BANDWIDTH_IN_BURST "inbound.burst" +#endif + +#ifndef VIR_NETWORK_PORT_BANDWIDTH_IN_FLOOR +#define VIR_NETWORK_PORT_BANDWIDTH_IN_FLOOR "inbound.floor" +#endif + +#ifndef VIR_NETWORK_PORT_BANDWIDTH_OUT_AVERAGE +#define VIR_NETWORK_PORT_BANDWIDTH_OUT_AVERAGE "outbound.average" +#endif + +#ifndef VIR_NETWORK_PORT_BANDWIDTH_OUT_PEAK +#define VIR_NETWORK_PORT_BANDWIDTH_OUT_PEAK "outbound.peak" +#endif + +#ifndef VIR_NETWORK_PORT_BANDWIDTH_OUT_BURST +#define VIR_NETWORK_PORT_BANDWIDTH_OUT_BURST "outbound.burst" +#endif + +#endif /* LIBVIRT_GO_NETWORK_PORT_COMPAT_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/network_port_wrapper.go b/vendor/github.com/libvirt/libvirt-go/network_port_wrapper.go new file mode 100644 index 000000000..2b691675e --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/network_port_wrapper.go @@ -0,0 +1,197 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +package libvirt + +/* +#cgo pkg-config: libvirt +#include +#include "network_port_wrapper.h" + +virNetworkPtr +virNetworkPortGetNetworkWrapper(virNetworkPortPtr port, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + virNetworkPtr ret; + ret = virNetworkPortGetNetwork(port); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +char * +virNetworkPortGetXMLDescWrapper(virNetworkPortPtr port, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + char *ret; + ret = virNetworkPortGetXMLDesc(port, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkPortGetUUIDWrapper(virNetworkPortPtr port, + unsigned char *uuid, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkPortGetUUID(port, uuid); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkPortGetUUIDStringWrapper(virNetworkPortPtr port, + char *buf, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkPortGetUUIDString(port, buf); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkPortSetParametersWrapper(virNetworkPortPtr port, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkPortSetParameters(port, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkPortGetParametersWrapper(virNetworkPortPtr port, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkPortGetParameters(port, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkPortDeleteWrapper(virNetworkPortPtr port, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkPortDelete(port, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkPortFreeWrapper(virNetworkPortPtr port, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkPortFree(port); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkPortRefWrapper(virNetworkPortPtr port, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkPortRef(port); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +*/ +import "C" diff --git a/vendor/github.com/libvirt/libvirt-go/network_port_wrapper.h b/vendor/github.com/libvirt/libvirt-go/network_port_wrapper.h new file mode 100644 index 000000000..054d45906 --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/network_port_wrapper.h @@ -0,0 +1,79 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +#ifndef LIBVIRT_GO_NETWORK_PORT_WRAPPER_H__ +#define LIBVIRT_GO_NETWORK_PORT_WRAPPER_H__ + +#include +#include +#include "network_port_compat.h" + + +virNetworkPtr +virNetworkPortGetNetworkWrapper(virNetworkPortPtr port, + virErrorPtr err); + +char * +virNetworkPortGetXMLDescWrapper(virNetworkPortPtr port, + unsigned int flags, + virErrorPtr err); + +int +virNetworkPortGetUUIDWrapper(virNetworkPortPtr port, + unsigned char *uuid, + virErrorPtr err); +int +virNetworkPortGetUUIDStringWrapper(virNetworkPortPtr port, + char *buf, + virErrorPtr err); + +int +virNetworkPortSetParametersWrapper(virNetworkPortPtr port, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); +int +virNetworkPortGetParametersWrapper(virNetworkPortPtr port, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +int +virNetworkPortDeleteWrapper(virNetworkPortPtr port, + unsigned int flags, + virErrorPtr err); + +int +virNetworkPortFreeWrapper(virNetworkPortPtr port, + virErrorPtr err); + +int +virNetworkPortRefWrapper(virNetworkPortPtr port, + virErrorPtr err); + + +#endif /* LIBVIRT_GO_NETWORK_PORT_WRAPPER_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/network_wrapper.go b/vendor/github.com/libvirt/libvirt-go/network_wrapper.go index 2fc443f21..ed1741f20 100644 --- a/vendor/github.com/libvirt/libvirt-go/network_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/network_wrapper.go @@ -103,18 +103,6 @@ virNetworkGetBridgeNameWrapper(virNetworkPtr network, } -virConnectPtr -virNetworkGetConnectWrapper(virNetworkPtr net, - virErrorPtr err) -{ - virConnectPtr ret = virNetworkGetConnect(net); - if (!ret) { - virCopyLastError(err); - } - return ret; -} - - int virNetworkGetDHCPLeasesWrapper(virNetworkPtr network, const char *mac, @@ -263,5 +251,78 @@ virNetworkUpdateWrapper(virNetworkPtr network, } +virNetworkPortPtr +virNetworkPortLookupByUUIDWrapper(virNetworkPtr net, + const unsigned char *uuid, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + virNetworkPortPtr ret; + ret = virNetworkPortLookupByUUID(net, uuid); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + +virNetworkPortPtr +virNetworkPortLookupByUUIDStringWrapper(virNetworkPtr net, + const char *uuidstr, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + virNetworkPortPtr ret; + ret = virNetworkPortLookupByUUIDString(net, uuidstr); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +virNetworkPortPtr +virNetworkPortCreateXMLWrapper(virNetworkPtr net, + const char *xmldesc, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + virNetworkPortPtr ret; + ret = virNetworkPortCreateXML(net, xmldesc, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virNetworkListAllPortsWrapper(virNetworkPtr network, + virNetworkPortPtr **ports, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 5005000 + assert(0); // Caller should have checked version +#else + int ret; + ret = virNetworkListAllPorts(network, ports, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + */ import "C" diff --git a/vendor/github.com/libvirt/libvirt-go/network_wrapper.h b/vendor/github.com/libvirt/libvirt-go/network_wrapper.h index 405bf89a2..5d2f529d7 100644 --- a/vendor/github.com/libvirt/libvirt-go/network_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/network_wrapper.h @@ -30,6 +30,7 @@ #include #include #include "network_compat.h" +#include "network_port_compat.h" int virNetworkCreateWrapper(virNetworkPtr network, @@ -55,10 +56,6 @@ char * virNetworkGetBridgeNameWrapper(virNetworkPtr network, virErrorPtr err); -virConnectPtr -virNetworkGetConnectWrapper(virNetworkPtr net, - virErrorPtr err); - int virNetworkGetDHCPLeasesWrapper(virNetworkPtr network, const char *mac, @@ -115,5 +112,27 @@ virNetworkUpdateWrapper(virNetworkPtr network, unsigned int flags, virErrorPtr err); +virNetworkPortPtr +virNetworkPortLookupByUUIDWrapper(virNetworkPtr net, + const unsigned char *uuid, + virErrorPtr err); + +virNetworkPortPtr +virNetworkPortLookupByUUIDStringWrapper(virNetworkPtr net, + const char *uuidstr, + virErrorPtr err); + +virNetworkPortPtr +virNetworkPortCreateXMLWrapper(virNetworkPtr net, + const char *xmldesc, + unsigned int flags, + virErrorPtr err); + +int +virNetworkListAllPortsWrapper(virNetworkPtr network, + virNetworkPortPtr **ports, + unsigned int flags, + virErrorPtr err); + #endif /* LIBVIRT_GO_NETWORK_WRAPPER_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/secret.go b/vendor/github.com/libvirt/libvirt-go/secret.go index c4ef44bd5..53d82c7ea 100644 --- a/vendor/github.com/libvirt/libvirt-go/secret.go +++ b/vendor/github.com/libvirt/libvirt-go/secret.go @@ -45,6 +45,7 @@ const ( SECRET_USAGE_TYPE_CEPH = SecretUsageType(C.VIR_SECRET_USAGE_TYPE_CEPH) SECRET_USAGE_TYPE_ISCSI = SecretUsageType(C.VIR_SECRET_USAGE_TYPE_ISCSI) SECRET_USAGE_TYPE_TLS = SecretUsageType(C.VIR_SECRET_USAGE_TYPE_TLS) + SECRET_USAGE_TYPE_VTPM = SecretUsageType(C.VIR_SECRET_USAGE_TYPE_VTPM) ) type SecretEventLifecycleType int diff --git a/vendor/github.com/libvirt/libvirt-go/secret_compat.h b/vendor/github.com/libvirt/libvirt-go/secret_compat.h index ba38c68d3..507ab808b 100644 --- a/vendor/github.com/libvirt/libvirt-go/secret_compat.h +++ b/vendor/github.com/libvirt/libvirt-go/secret_compat.h @@ -58,4 +58,10 @@ typedef void (*virConnectSecretEventGenericCallback)(virConnectPtr conn, #define VIR_SECRET_USAGE_TYPE_TLS 4 #endif +/* 5.6.0 */ + +#ifndef VIR_SECRET_USAGE_TYPE_VTPM +#define VIR_SECRET_USAGE_TYPE_VTPM 5 +#endif + #endif /* LIBVIRT_GO_SECRET_COMPAT_H__ */ diff --git a/vendor/github.com/libvirt/libvirt-go/secret_wrapper.go b/vendor/github.com/libvirt/libvirt-go/secret_wrapper.go index 96f60f6f9..d95a168af 100644 --- a/vendor/github.com/libvirt/libvirt-go/secret_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/secret_wrapper.go @@ -43,18 +43,6 @@ virSecretFreeWrapper(virSecretPtr secret, } -virConnectPtr -virSecretGetConnectWrapper(virSecretPtr secret, - virErrorPtr err) -{ - virConnectPtr ret = virSecretGetConnect(secret); - if (!ret) { - virCopyLastError(err); - } - return ret; -} - - int virSecretGetUUIDWrapper(virSecretPtr secret, unsigned char *uuid, diff --git a/vendor/github.com/libvirt/libvirt-go/secret_wrapper.h b/vendor/github.com/libvirt/libvirt-go/secret_wrapper.h index eca6f0a4c..eee2a5eac 100644 --- a/vendor/github.com/libvirt/libvirt-go/secret_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/secret_wrapper.h @@ -34,10 +34,6 @@ int virSecretFreeWrapper(virSecretPtr secret, virErrorPtr err); -virConnectPtr -virSecretGetConnectWrapper(virSecretPtr secret, - virErrorPtr err); - int virSecretGetUUIDWrapper(virSecretPtr secret, unsigned char *uuid, diff --git a/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.go b/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.go index 8534f7c8c..1cb041eca 100644 --- a/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.go @@ -106,18 +106,6 @@ virStoragePoolGetAutostartWrapper(virStoragePoolPtr pool, } -virConnectPtr -virStoragePoolGetConnectWrapper(virStoragePoolPtr pool, - virErrorPtr err) -{ - virConnectPtr ret = virStoragePoolGetConnect(pool); - if (!ret) { - virCopyLastError(err); - } - return ret; -} - - int virStoragePoolGetInfoWrapper(virStoragePoolPtr pool, virStoragePoolInfoPtr info, diff --git a/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.h b/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.h index acd121bfb..62d4861f4 100644 --- a/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/storage_pool_wrapper.h @@ -58,10 +58,6 @@ virStoragePoolGetAutostartWrapper(virStoragePoolPtr pool, int *autostart, virErrorPtr err); -virConnectPtr -virStoragePoolGetConnectWrapper(virStoragePoolPtr pool, - virErrorPtr err); - int virStoragePoolGetInfoWrapper(virStoragePoolPtr pool, virStoragePoolInfoPtr info, diff --git a/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.go b/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.go index d41a8a7cf..875a89fc5 100644 --- a/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.go +++ b/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.go @@ -84,18 +84,6 @@ virStorageVolFreeWrapper(virStorageVolPtr vol, } -virConnectPtr -virStorageVolGetConnectWrapper(virStorageVolPtr vol, - virErrorPtr err) -{ - virConnectPtr ret = virStorageVolGetConnect(vol); - if (!ret) { - virCopyLastError(err); - } - return ret; -} - - int virStorageVolGetInfoWrapper(virStorageVolPtr vol, virStorageVolInfoPtr info, diff --git a/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.h b/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.h index b3ed2a9fc..c9183a48f 100644 --- a/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.h +++ b/vendor/github.com/libvirt/libvirt-go/storage_volume_wrapper.h @@ -52,10 +52,6 @@ int virStorageVolFreeWrapper(virStorageVolPtr vol, virErrorPtr err); -virConnectPtr -virStorageVolGetConnectWrapper(virStorageVolPtr vol, - virErrorPtr err); - int virStorageVolGetInfoWrapper(virStorageVolPtr vol, virStorageVolInfoPtr info, diff --git a/vendor/github.com/libvirt/libvirt-go/typedparams.go b/vendor/github.com/libvirt/libvirt-go/typedparams.go index e8ceae07e..ccceee1e5 100644 --- a/vendor/github.com/libvirt/libvirt-go/typedparams.go +++ b/vendor/github.com/libvirt/libvirt-go/typedparams.go @@ -32,6 +32,7 @@ package libvirt #include #include #include +#include "typedparams_wrapper.h" */ import "C" @@ -52,211 +53,159 @@ type typedParamsFieldInfo struct { sl *[]string } -func typedParamsUnpackLen(cparams *C.virTypedParameter, nparams int, infomap map[string]typedParamsFieldInfo) (uint, error) { +func typedParamsUnpack(cparams *C.virTypedParameter, cnparams C.int, infomap map[string]typedParamsFieldInfo) (uint, error) { count := uint(0) - for i := 0; i < nparams; i++ { - var cparam *C.virTypedParameter - cparam = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) + unsafe.Sizeof(*cparam)*uintptr(i))) - name := C.GoString((*C.char)(unsafe.Pointer(&cparam.field))) - info, ok := infomap[name] - if !ok { - // Ignore unknown keys so that we don't break if - // run against a newer libvirt that returns more - // parameters than we currently have code to - // consume - continue - } - switch cparam._type { - case C.VIR_TYPED_PARAM_INT: - if info.i == nil { - return 0, fmt.Errorf("field %s expects an int", name) - } - *info.i = int(*(*C.int)(unsafe.Pointer(&cparam.value))) - *info.set = true - case C.VIR_TYPED_PARAM_UINT: - if info.ui == nil { - return 0, fmt.Errorf("field %s expects a uint", name) - } - *info.ui = uint(*(*C.uint)(unsafe.Pointer(&cparam.value))) - *info.set = true - case C.VIR_TYPED_PARAM_LLONG: - if info.l == nil { - return 0, fmt.Errorf("field %s expects an int64", name) - } - *info.l = int64(*(*C.longlong)(unsafe.Pointer(&cparam.value))) - *info.set = true - case C.VIR_TYPED_PARAM_ULLONG: - if info.ul == nil { - return 0, fmt.Errorf("field %s expects a uint64", name) - } - *info.ul = uint64(*(*C.ulonglong)(unsafe.Pointer(&cparam.value))) - *info.set = true - case C.VIR_TYPED_PARAM_DOUBLE: - if info.d == nil { - return 0, fmt.Errorf("field %s expects a float64", name) + for name, value := range infomap { + var err C.virError + var ret C.int + cname := C.CString(name) + defer C.free(unsafe.Pointer(cname)) + if value.sl != nil { + for i := 0; i < int(cnparams); i++ { + var cparam *C.virTypedParameter + cparam = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) + + (unsafe.Sizeof(*cparam) * uintptr(i)))) + var cs *C.char + ret = C.virTypedParamsGetStringWrapper(cparam, 1, cname, &cs, &err) + if ret == 1 { + *value.sl = append(*value.sl, C.GoString(cs)) + *value.set = true + count++ + } } - *info.d = float64(*(*C.double)(unsafe.Pointer(&cparam.value))) - *info.set = true - case C.VIR_TYPED_PARAM_BOOLEAN: - if info.b == nil { - return 0, fmt.Errorf("field %s expects a bool", name) + } else { + if value.i != nil { + var ci C.int + ret = C.virTypedParamsGetIntWrapper(cparams, cnparams, cname, &ci, &err) + if ret == 1 { + *value.i = int(ci) + } + } else if value.ui != nil { + var cui C.uint + ret = C.virTypedParamsGetUIntWrapper(cparams, cnparams, cname, &cui, &err) + if ret == 1 { + *value.ui = uint(cui) + } + } else if value.l != nil { + var cl C.longlong + ret = C.virTypedParamsGetLLongWrapper(cparams, cnparams, cname, &cl, &err) + if ret == 1 { + *value.l = int64(cl) + } + } else if value.ul != nil { + var cul C.ulonglong + ret = C.virTypedParamsGetULLongWrapper(cparams, cnparams, cname, &cul, &err) + if ret == 1 { + *value.ul = uint64(cul) + } + } else if value.d != nil { + var cd C.double + ret = C.virTypedParamsGetDoubleWrapper(cparams, cnparams, cname, &cd, &err) + if ret == 1 { + *value.d = float64(cd) + } + } else if value.b != nil { + var cb C.int + ret = C.virTypedParamsGetBooleanWrapper(cparams, cnparams, cname, &cb, &err) + if ret == 1 { + if cb == 1 { + *value.b = true + } else { + *value.b = false + } + } + } else if value.s != nil { + var cs *C.char + ret = C.virTypedParamsGetStringWrapper(cparams, cnparams, cname, &cs, &err) + if ret == 1 { + *value.s = C.GoString(cs) + } } - *info.b = *(*C.char)(unsafe.Pointer(&cparam.value)) == 1 - *info.set = true - case C.VIR_TYPED_PARAM_STRING: - if info.s != nil { - *info.s = C.GoString(*(**C.char)(unsafe.Pointer(&cparam.value))) - *info.set = true - } else if info.sl != nil { - *info.sl = append(*info.sl, C.GoString(*(**C.char)(unsafe.Pointer(&cparam.value)))) - *info.set = true - } else { - return 0, fmt.Errorf("field %s expects a string/string list", name) + if ret == 1 { + *value.set = true + count++ } } - count++ } return count, nil } -func typedParamsUnpack(cparams []C.virTypedParameter, infomap map[string]typedParamsFieldInfo) (uint, error) { - return typedParamsUnpackLen(&cparams[0], len(cparams), infomap) -} - -func typedParamsPackLen(cparams *C.virTypedParameter, nparams int, infomap map[string]typedParamsFieldInfo) error { - stringOffsets := make(map[string]uint) - - for i := 0; i < nparams; i++ { - var cparam *C.virTypedParameter - cparam = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) + unsafe.Sizeof(*cparam)*uintptr(i))) - name := C.GoString((*C.char)(unsafe.Pointer(&cparam.field))) - info, ok := infomap[name] - if !ok { - // Ignore unknown keys so that we don't break if - // run against a newer libvirt that returns more - // parameters than we currently have code to - // consume - continue - } - if !*info.set { - continue - } - switch cparam._type { - case C.VIR_TYPED_PARAM_INT: - if info.i == nil { - return fmt.Errorf("field %s expects an int", name) - } - *(*C.int)(unsafe.Pointer(&cparam.value)) = C.int(*info.i) - case C.VIR_TYPED_PARAM_UINT: - if info.ui == nil { - return fmt.Errorf("field %s expects a uint", name) - } - *(*C.uint)(unsafe.Pointer(&cparam.value)) = C.uint(*info.ui) - case C.VIR_TYPED_PARAM_LLONG: - if info.l == nil { - return fmt.Errorf("field %s expects an int64", name) - } - *(*C.longlong)(unsafe.Pointer(&cparam.value)) = C.longlong(*info.l) - case C.VIR_TYPED_PARAM_ULLONG: - if info.ul == nil { - return fmt.Errorf("field %s expects a uint64", name) - } - *(*C.ulonglong)(unsafe.Pointer(&cparam.value)) = C.ulonglong(*info.ul) - case C.VIR_TYPED_PARAM_DOUBLE: - if info.d == nil { - return fmt.Errorf("field %s expects a float64", name) - } - *(*C.double)(unsafe.Pointer(&cparam.value)) = C.double(*info.d) - case C.VIR_TYPED_PARAM_BOOLEAN: - if info.b == nil { - return fmt.Errorf("field %s expects a bool", name) - } - if *info.b { - *(*C.char)(unsafe.Pointer(&cparam.value)) = 1 - } else { - *(*C.char)(unsafe.Pointer(&cparam.value)) = 0 - } - case C.VIR_TYPED_PARAM_STRING: - if info.s != nil { - *(**C.char)(unsafe.Pointer(&cparam.value)) = C.CString(*info.s) - } else if info.sl != nil { - count := stringOffsets[name] - *(**C.char)(unsafe.Pointer(&cparam.value)) = C.CString((*info.sl)[count]) - stringOffsets[name] = count + 1 - } else { - return fmt.Errorf("field %s expects a string", name) - } - } +func typedParamsNew(nparams C.int) *C.virTypedParameter { + var cparams *C.virTypedParameter + memlen := C.size_t(unsafe.Sizeof(*cparams) * uintptr(nparams)) + cparams = (*C.virTypedParameter)(C.malloc(memlen)) + if cparams == nil { + C.abort() } - - return nil -} - -func typedParamsPack(cparams []C.virTypedParameter, infomap map[string]typedParamsFieldInfo) error { - return typedParamsPackLen(&cparams[0], len(cparams), infomap) + C.memset(unsafe.Pointer(cparams), 0, memlen) + return cparams } -func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*[]C.virTypedParameter, error) { - nparams := 0 - for _, value := range infomap { - if !*value.set { - continue - } +func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*C.virTypedParameter, C.int, error) { + var cparams C.virTypedParameterPtr + var nparams C.int + var maxparams C.int - if value.sl != nil { - nparams += len(*value.sl) - } else { - nparams++ - } - } + defer C.virTypedParamsFree(cparams, nparams) - cparams := make([]C.virTypedParameter, nparams) - nparams = 0 - for key, value := range infomap { + for name, value := range infomap { if !*value.set { continue } - cfield := C.CString(key) - defer C.free(unsafe.Pointer(cfield)) - clen := len(key) + 1 - if clen > C.VIR_TYPED_PARAM_FIELD_LENGTH { - clen = C.VIR_TYPED_PARAM_FIELD_LENGTH - } + cname := C.CString(name) + defer C.free(unsafe.Pointer(cname)) if value.sl != nil { + /* We're not actually using virTypedParamsAddStringList, as it is + * easier to avoid creating a 'char **' in Go to hold all the strings. + * We none the less do a version check, because earlier libvirts + * would not expect to see multiple string values in a typed params + * list with the same field name + */ + if C.LIBVIR_VERSION_NUMBER < 1002017 { + return nil, 0, makeNotImplementedError("virTypedParamsAddStringList") + } for i := 0; i < len(*value.sl); i++ { - cparam := &cparams[nparams] - cparam._type = C.VIR_TYPED_PARAM_STRING - C.memcpy(unsafe.Pointer(&cparam.field[0]), unsafe.Pointer(cfield), C.size_t(clen)) - nparams++ + cvalue := C.CString((*value.sl)[i]) + defer C.free(unsafe.Pointer(cvalue)) + var err C.virError + ret := C.virTypedParamsAddStringWrapper(&cparams, &nparams, &maxparams, cname, cvalue, &err) + if ret < 0 { + return nil, 0, makeError(&err) + } } } else { - cparam := &cparams[nparams] + var err C.virError + var ret C.int if value.i != nil { - cparam._type = C.VIR_TYPED_PARAM_INT + ret = C.virTypedParamsAddIntWrapper(&cparams, &nparams, &maxparams, cname, C.int(*value.i), &err) } else if value.ui != nil { - cparam._type = C.VIR_TYPED_PARAM_UINT + ret = C.virTypedParamsAddUIntWrapper(&cparams, &nparams, &maxparams, cname, C.uint(*value.ui), &err) } else if value.l != nil { - cparam._type = C.VIR_TYPED_PARAM_LLONG + ret = C.virTypedParamsAddLLongWrapper(&cparams, &nparams, &maxparams, cname, C.longlong(*value.l), &err) } else if value.ul != nil { - cparam._type = C.VIR_TYPED_PARAM_ULLONG + ret = C.virTypedParamsAddULLongWrapper(&cparams, &nparams, &maxparams, cname, C.ulonglong(*value.ul), &err) } else if value.b != nil { - cparam._type = C.VIR_TYPED_PARAM_BOOLEAN + v := 0 + if *value.b { + v = 1 + } + ret = C.virTypedParamsAddBooleanWrapper(&cparams, &nparams, &maxparams, cname, C.int(v), &err) } else if value.d != nil { - cparam._type = C.VIR_TYPED_PARAM_DOUBLE + ret = C.virTypedParamsAddDoubleWrapper(&cparams, &nparams, &maxparams, cname, C.double(*value.i), &err) } else if value.s != nil { - cparam._type = C.VIR_TYPED_PARAM_STRING + cvalue := C.CString(*value.s) + defer C.free(unsafe.Pointer(cvalue)) + ret = C.virTypedParamsAddStringWrapper(&cparams, &nparams, &maxparams, cname, cvalue, &err) + } else { + return nil, 0, fmt.Errorf("No typed parameter value set for field '%s'", name) + } + if ret < 0 { + return nil, 0, makeError(&err) } - C.memcpy(unsafe.Pointer(&cparam.field[0]), unsafe.Pointer(cfield), C.size_t(clen)) - nparams++ } } - err := typedParamsPack(cparams, infomap) - if err != nil { - C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.int(nparams)) - return nil, err - } - return &cparams, nil + return cparams, nparams, nil } diff --git a/vendor/github.com/libvirt/libvirt-go/typedparams_wrapper.go b/vendor/github.com/libvirt/libvirt-go/typedparams_wrapper.go new file mode 100644 index 000000000..2209d604b --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/typedparams_wrapper.go @@ -0,0 +1,240 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +package libvirt + +/* +#cgo pkg-config: libvirt +#include +#include "typedparams_wrapper.h" + +int +virTypedParamsAddIntWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + int value, + virErrorPtr err) +{ + int ret = virTypedParamsAddInt(params, nparams, maxparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsAddUIntWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + unsigned int value, + virErrorPtr err) +{ + int ret = virTypedParamsAddUInt(params, nparams, maxparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsAddLLongWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + long long value, + virErrorPtr err) +{ + int ret = virTypedParamsAddLLong(params, nparams, maxparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsAddULLongWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + unsigned long long value, + virErrorPtr err) +{ + int ret = virTypedParamsAddULLong(params, nparams, maxparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsAddDoubleWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + double value, + virErrorPtr err) +{ + int ret = virTypedParamsAddDouble(params, nparams, maxparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsAddBooleanWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + int value, + virErrorPtr err) +{ + int ret = virTypedParamsAddBoolean(params, nparams, maxparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsAddStringWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + const char *value, + virErrorPtr err) +{ + int ret = virTypedParamsAddString(params, nparams, maxparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virTypedParamsGetIntWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + int *value, + virErrorPtr err) +{ + int ret = virTypedParamsGetInt(params, nparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsGetUIntWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + unsigned int *value, + virErrorPtr err) +{ + int ret = virTypedParamsGetUInt(params, nparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsGetLLongWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + long long *value, + virErrorPtr err) +{ + int ret = virTypedParamsGetLLong(params, nparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsGetULLongWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + unsigned long long *value, + virErrorPtr err) +{ + int ret = virTypedParamsGetULLong(params, nparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsGetDoubleWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + double *value, + virErrorPtr err) +{ + int ret = virTypedParamsGetDouble(params, nparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsGetBooleanWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + int *value, + virErrorPtr err) +{ + int ret = virTypedParamsGetBoolean(params, nparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + +int +virTypedParamsGetStringWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + const char **value, + virErrorPtr err) +{ + int ret = virTypedParamsGetString(params, nparams, name, value); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + + +*/ +import "C" diff --git a/vendor/github.com/libvirt/libvirt-go/typedparams_wrapper.h b/vendor/github.com/libvirt/libvirt-go/typedparams_wrapper.h new file mode 100644 index 000000000..ee626b1ba --- /dev/null +++ b/vendor/github.com/libvirt/libvirt-go/typedparams_wrapper.h @@ -0,0 +1,126 @@ +/* + * This file is part of the libvirt-go project + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +#ifndef LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ +#define LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ + +#include +#include + +int +virTypedParamsAddIntWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + int value, + virErrorPtr err); +int +virTypedParamsAddUIntWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + unsigned int value, + virErrorPtr err); +int +virTypedParamsAddLLongWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + long long value, + virErrorPtr err); +int +virTypedParamsAddULLongWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + unsigned long long value, + virErrorPtr err); +int +virTypedParamsAddDoubleWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + double value, + virErrorPtr err); +int +virTypedParamsAddBooleanWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + int value, + virErrorPtr err); +int +virTypedParamsAddStringWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + const char *value, + virErrorPtr err); + +int +virTypedParamsGetIntWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + int *value, + virErrorPtr err); +int +virTypedParamsGetUIntWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + unsigned int *value, + virErrorPtr err); +int +virTypedParamsGetLLongWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + long long *value, + virErrorPtr err); +int +virTypedParamsGetULLongWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + unsigned long long *value, + virErrorPtr err); +int +virTypedParamsGetDoubleWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + double *value, + virErrorPtr err); +int +virTypedParamsGetBooleanWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + int *value, + virErrorPtr err); +int +virTypedParamsGetStringWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + const char **value, + virErrorPtr err); + + +#endif /* LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ */ diff --git a/vendor/modules.txt b/vendor/modules.txt index fc44b6d06..6c0da9725 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -94,10 +94,10 @@ github.com/inconshreveable/mousetrap github.com/json-iterator/go # github.com/konsorten/go-windows-terminal-sequences v1.0.1 github.com/konsorten/go-windows-terminal-sequences -# github.com/libvirt/libvirt-go v4.10.0+incompatible => github.com/libvirt/libvirt-go v4.6.0+incompatible +# github.com/libvirt/libvirt-go v5.10.0+incompatible ## explicit github.com/libvirt/libvirt-go -# github.com/libvirt/libvirt-go-xml v4.10.0+incompatible => github.com/libvirt/libvirt-go-xml v4.6.0+incompatible +# github.com/libvirt/libvirt-go-xml v5.10.0+incompatible ## explicit github.com/libvirt/libvirt-go-xml # github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de @@ -137,7 +137,6 @@ github.com/openshift/machine-api-operator/pkg/controller/machine github.com/openshift/machine-api-operator/pkg/generated/clientset/versioned github.com/openshift/machine-api-operator/pkg/generated/clientset/versioned/scheme github.com/openshift/machine-api-operator/pkg/generated/clientset/versioned/typed/machine/v1beta1 -github.com/openshift/machine-api-operator/pkg/generated/clientset/versioned/typed/machine/v1beta1/ github.com/openshift/machine-api-operator/pkg/generated/clientset/versioned/typed/machine/v1beta1/fake github.com/openshift/machine-api-operator/pkg/util # github.com/peterbourgon/diskv v2.0.1+incompatible @@ -649,5 +648,3 @@ sigs.k8s.io/kustomize/pkg/types sigs.k8s.io/structured-merge-diff/v3/value # sigs.k8s.io/yaml v1.2.0 sigs.k8s.io/yaml -# github.com/libvirt/libvirt-go => github.com/libvirt/libvirt-go v4.6.0+incompatible -# github.com/libvirt/libvirt-go-xml => github.com/libvirt/libvirt-go-xml v4.6.0+incompatible