[libvirt] [go PATCH 30/37] connect: fix error reporting thread safety
Daniel P. Berrangé
berrange at redhat.com
Mon Jul 16 13:24:16 UTC 2018
Create wrapper functions for each connect C API that accepts a
virErrorPtr parameter. This avoids accessing a thread local from a
goroutine which may race with other goroutines doing native API calls in
the same OS thread.
Signed-off-by: Daniel P. Berrangé <berrange at redhat.com>
---
connect.go | 700 ++++++++++--------
connect_wrapper.go | 1725 +++++++++++++++++++++++++++++++++++++++++---
connect_wrapper.h | 697 ++++++++++++++++--
error_test.go | 44 --
4 files changed, 2677 insertions(+), 489 deletions(-)
delete mode 100644 error_test.go
diff --git a/connect.go b/connect.go
index 5ea8c48..29e4fb0 100644
--- a/connect.go
+++ b/connect.go
@@ -309,8 +309,10 @@ func releaseConnectionData(c *Connect) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virGetVersion
func GetVersion() (uint32, error) {
var version C.ulong
- if err := C.virGetVersion(&version, nil, nil); err < 0 {
- return 0, GetLastError()
+ var err C.virError
+ ret := C.virGetVersionWrapper(&version, nil, nil, &err)
+ if ret < 0 {
+ return 0, makeError(&err)
}
return uint32(version), nil
}
@@ -322,9 +324,10 @@ func NewConnect(uri string) (*Connect, error) {
cUri = C.CString(uri)
defer C.free(unsafe.Pointer(cUri))
}
- ptr := C.virConnectOpen(cUri)
+ var err C.virError
+ ptr := C.virConnectOpenWrapper(cUri, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Connect{ptr: ptr}, nil
}
@@ -395,10 +398,11 @@ func NewConnectWithAuth(uri string, auth *ConnectAuth, flags ConnectFlags) (*Con
callbackID := registerCallbackId(auth.Callback)
- ptr := C.virConnectOpenAuthWrapper(cUri, &ccredtype[0], C.uint(len(auth.CredType)), C.int(callbackID), C.uint(flags))
+ var err C.virError
+ ptr := C.virConnectOpenAuthWrapper(cUri, &ccredtype[0], C.uint(len(auth.CredType)), C.int(callbackID), C.uint(flags), &err)
freeCallbackId(callbackID)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Connect{ptr: ptr}, nil
}
@@ -410,18 +414,20 @@ func NewConnectReadOnly(uri string) (*Connect, error) {
cUri = C.CString(uri)
defer C.free(unsafe.Pointer(cUri))
}
- ptr := C.virConnectOpenReadOnly(cUri)
+ var err C.virError
+ ptr := C.virConnectOpenReadOnlyWrapper(cUri, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Connect{ptr: ptr}, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectClose
func (c *Connect) Close() (int, error) {
- result := int(C.virConnectClose(c.ptr))
+ var err C.virError
+ result := int(C.virConnectCloseWrapper(c.ptr, &err))
if result == -1 {
- return result, GetLastError()
+ return result, makeError(&err)
}
if result == 0 {
// No more reference to this connection, release data.
@@ -433,9 +439,10 @@ func (c *Connect) Close() (int, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectRef
func (c *Connect) Ref() error {
- ret := C.virConnectRef(c.ptr)
+ var err C.virError
+ ret := C.virConnectRefWrapper(c.ptr, &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
return nil
}
@@ -449,11 +456,11 @@ type CloseCallback func(conn *Connect, reason ConnectCloseReason)
func (c *Connect) RegisterCloseCallback(callback CloseCallback) error {
c.UnregisterCloseCallback()
goCallbackId := registerCallbackId(callback)
- callbackPtr := unsafe.Pointer(C.closeCallbackHelper)
- res := C.virConnectRegisterCloseCallbackHelper(c.ptr, C.virConnectCloseFunc(callbackPtr), C.long(goCallbackId))
+ var err C.virError
+ res := C.virConnectRegisterCloseCallbackWrapper(c.ptr, C.long(goCallbackId), &err)
if res != 0 {
freeCallbackId(goCallbackId)
- return GetLastError()
+ return makeError(&err)
}
connData := getConnectionData(c)
connData.closeCallbackId = &goCallbackId
@@ -466,10 +473,10 @@ func (c *Connect) UnregisterCloseCallback() error {
if connData.closeCallbackId == nil {
return nil
}
- callbackPtr := unsafe.Pointer(C.closeCallbackHelper)
- res := C.virConnectUnregisterCloseCallback(c.ptr, C.virConnectCloseFunc(callbackPtr))
+ var err C.virError
+ res := C.virConnectUnregisterCloseCallbackWrapper(c.ptr, &err)
if res != 0 {
- return GetLastError()
+ return makeError(&err)
}
connData.closeCallbackId = nil
return nil
@@ -487,9 +494,10 @@ func closeCallback(conn C.virConnectPtr, reason ConnectCloseReason, goCallbackId
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetCapabilities
func (c *Connect) GetCapabilities() (string, error) {
- str := C.virConnectGetCapabilities(c.ptr)
+ var err C.virError
+ str := C.virConnectGetCapabilitiesWrapper(c.ptr, &err)
if str == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
capabilities := C.GoString(str)
C.free(unsafe.Pointer(str))
@@ -499,9 +507,10 @@ func (c *Connect) GetCapabilities() (string, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetInfo
func (c *Connect) GetNodeInfo() (*NodeInfo, error) {
var cinfo C.virNodeInfo
- result := C.virNodeGetInfo(c.ptr, &cinfo)
+ var err C.virError
+ result := C.virNodeGetInfoWrapper(c.ptr, &cinfo, &err)
if result == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NodeInfo{
Model: C.GoString((*C.char)(unsafe.Pointer(&cinfo.model[0]))),
@@ -521,9 +530,10 @@ func (ni *NodeInfo) GetMaxCPUs() uint32 {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetHostname
func (c *Connect) GetHostname() (string, error) {
- str := C.virConnectGetHostname(c.ptr)
+ var err C.virError
+ str := C.virConnectGetHostnameWrapper(c.ptr, &err)
if str == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
hostname := C.GoString(str)
C.free(unsafe.Pointer(str))
@@ -533,17 +543,20 @@ func (c *Connect) GetHostname() (string, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetLibVersion
func (c *Connect) GetLibVersion() (uint32, error) {
var version C.ulong
- if err := C.virConnectGetLibVersion(c.ptr, &version); err < 0 {
- return 0, GetLastError()
+ var err C.virError
+ ret := C.virConnectGetLibVersionWrapper(c.ptr, &version, &err)
+ if ret < 0 {
+ return 0, makeError(&err)
}
return uint32(version), nil
}
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetType
func (c *Connect) GetType() (string, error) {
- str := C.virConnectGetType(c.ptr)
+ var err C.virError
+ str := C.virConnectGetTypeWrapper(c.ptr, &err)
if str == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
hypDriver := C.GoString(str)
return hypDriver, nil
@@ -551,9 +564,10 @@ func (c *Connect) GetType() (string, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectIsAlive
func (c *Connect) IsAlive() (bool, error) {
- result := C.virConnectIsAlive(c.ptr)
+ var err C.virError
+ result := C.virConnectIsAliveWrapper(c.ptr, &err)
if result == -1 {
- return false, GetLastError()
+ return false, makeError(&err)
}
if result == 1 {
return true, nil
@@ -563,9 +577,10 @@ func (c *Connect) IsAlive() (bool, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectIsEncrypted
func (c *Connect) IsEncrypted() (bool, error) {
- result := C.virConnectIsEncrypted(c.ptr)
+ var err C.virError
+ result := C.virConnectIsEncryptedWrapper(c.ptr, &err)
if result == -1 {
- return false, GetLastError()
+ return false, makeError(&err)
}
if result == 1 {
return true, nil
@@ -575,9 +590,10 @@ func (c *Connect) IsEncrypted() (bool, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectIsSecure
func (c *Connect) IsSecure() (bool, error) {
- result := C.virConnectIsSecure(c.ptr)
+ var err C.virError
+ result := C.virConnectIsSecureWrapper(c.ptr, &err)
if result == -1 {
- return false, GetLastError()
+ return false, makeError(&err)
}
if result == 1 {
return true, nil
@@ -589,12 +605,13 @@ func (c *Connect) IsSecure() (bool, error) {
func (c *Connect) ListDefinedDomains() ([]string, error) {
var names [1024](*C.char)
namesPtr := unsafe.Pointer(&names)
- numDomains := C.virConnectListDefinedDomains(
+ var err C.virError
+ numDomains := C.virConnectListDefinedDomainsWrapper(
c.ptr,
(**C.char)(namesPtr),
- 1024)
+ 1024, &err)
if numDomains == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numDomains)
for k := 0; k < int(numDomains); k++ {
@@ -608,9 +625,10 @@ func (c *Connect) ListDefinedDomains() ([]string, error) {
func (c *Connect) ListDomains() ([]uint32, error) {
var cDomainsIds [512](uint32)
cDomainsPointer := unsafe.Pointer(&cDomainsIds)
- numDomains := C.virConnectListDomains(c.ptr, (*C.int)(cDomainsPointer), 512)
+ var err C.virError
+ numDomains := C.virConnectListDomainsWrapper(c.ptr, (*C.int)(cDomainsPointer), 512, &err)
if numDomains == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return cDomainsIds[:numDomains], nil
@@ -621,12 +639,13 @@ func (c *Connect) ListInterfaces() ([]string, error) {
const maxIfaces = 1024
var names [maxIfaces](*C.char)
namesPtr := unsafe.Pointer(&names)
- numIfaces := C.virConnectListInterfaces(
+ var err C.virError
+ numIfaces := C.virConnectListInterfacesWrapper(
c.ptr,
(**C.char)(namesPtr),
- maxIfaces)
+ maxIfaces, &err)
if numIfaces == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numIfaces)
for k := 0; k < int(numIfaces); k++ {
@@ -641,12 +660,13 @@ func (c *Connect) ListNetworks() ([]string, error) {
const maxNets = 1024
var names [maxNets](*C.char)
namesPtr := unsafe.Pointer(&names)
- numNetworks := C.virConnectListNetworks(
+ var err C.virError
+ numNetworks := C.virConnectListNetworksWrapper(
c.ptr,
(**C.char)(namesPtr),
- maxNets)
+ maxNets, &err)
if numNetworks == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numNetworks)
for k := 0; k < int(numNetworks); k++ {
@@ -661,12 +681,13 @@ func (c *Connect) ListNWFilters() ([]string, error) {
const maxFilters = 1024
var names [maxFilters](*C.char)
namesPtr := unsafe.Pointer(&names)
- numNWFilters := C.virConnectListNWFilters(
+ var err C.virError
+ numNWFilters := C.virConnectListNWFiltersWrapper(
c.ptr,
(**C.char)(namesPtr),
- maxFilters)
+ maxFilters, &err)
if numNWFilters == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numNWFilters)
for k := 0; k < int(numNWFilters); k++ {
@@ -681,12 +702,13 @@ func (c *Connect) ListStoragePools() ([]string, error) {
const maxPools = 1024
var names [maxPools](*C.char)
namesPtr := unsafe.Pointer(&names)
- numStoragePools := C.virConnectListStoragePools(
+ var err C.virError
+ numStoragePools := C.virConnectListStoragePoolsWrapper(
c.ptr,
(**C.char)(namesPtr),
- maxPools)
+ maxPools, &err)
if numStoragePools == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numStoragePools)
for k := 0; k < int(numStoragePools); k++ {
@@ -701,12 +723,13 @@ func (c *Connect) ListSecrets() ([]string, error) {
const maxSecrets = 1024
var uuids [maxSecrets](*C.char)
uuidsPtr := unsafe.Pointer(&uuids)
- numSecrets := C.virConnectListSecrets(
+ var err C.virError
+ numSecrets := C.virConnectListSecretsWrapper(
c.ptr,
(**C.char)(uuidsPtr),
- maxSecrets)
+ maxSecrets, &err)
if numSecrets == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goUuids := make([]string, numSecrets)
for k := 0; k < int(numSecrets); k++ {
@@ -723,12 +746,13 @@ func (c *Connect) ListDevices(cap string, flags uint32) ([]string, error) {
const maxNodeDevices = 1024
var uuids [maxNodeDevices](*C.char)
uuidsPtr := unsafe.Pointer(&uuids)
- numNodeDevices := C.virNodeListDevices(
+ var err C.virError
+ numNodeDevices := C.virNodeListDevicesWrapper(
c.ptr, ccap,
(**C.char)(uuidsPtr),
- maxNodeDevices, C.uint(flags))
+ maxNodeDevices, C.uint(flags), &err)
if numNodeDevices == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goUuids := make([]string, numNodeDevices)
for k := 0; k < int(numNodeDevices); k++ {
@@ -740,9 +764,10 @@ func (c *Connect) ListDevices(cap string, flags uint32) ([]string, error) {
// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainLookupByID
func (c *Connect) LookupDomainById(id uint32) (*Domain, error) {
- ptr := C.virDomainLookupByID(c.ptr, C.int(id))
+ var err C.virError
+ ptr := C.virDomainLookupByIDWrapper(c.ptr, C.int(id), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -751,9 +776,10 @@ func (c *Connect) LookupDomainById(id uint32) (*Domain, error) {
func (c *Connect) LookupDomainByName(id string) (*Domain, error) {
cName := C.CString(id)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virDomainLookupByName(c.ptr, cName)
+ var err C.virError
+ ptr := C.virDomainLookupByNameWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -762,9 +788,10 @@ func (c *Connect) LookupDomainByName(id string) (*Domain, error) {
func (c *Connect) LookupDomainByUUIDString(uuid string) (*Domain, error) {
cUuid := C.CString(uuid)
defer C.free(unsafe.Pointer(cUuid))
- ptr := C.virDomainLookupByUUIDString(c.ptr, cUuid)
+ var err C.virError
+ ptr := C.virDomainLookupByUUIDStringWrapper(c.ptr, cUuid, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -779,9 +806,10 @@ func (c *Connect) LookupDomainByUUID(uuid []byte) (*Domain, error) {
for i := 0; i < C.VIR_UUID_BUFLEN; i++ {
cUuid[i] = C.uchar(uuid[i])
}
- ptr := C.virDomainLookupByUUID(c.ptr, &cUuid[0])
+ var err C.virError
+ ptr := C.virDomainLookupByUUIDWrapper(c.ptr, &cUuid[0], &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -790,9 +818,10 @@ func (c *Connect) LookupDomainByUUID(uuid []byte) (*Domain, error) {
func (c *Connect) DomainCreateXML(xmlConfig string, flags DomainCreateFlags) (*Domain, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virDomainCreateXML(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virDomainCreateXMLWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -805,9 +834,10 @@ func (c *Connect) DomainCreateXMLWithFiles(xmlConfig string, files []os.File, fl
for i := 0; i < len(files); i++ {
cfiles[i] = C.int(files[i].Fd())
}
- ptr := C.virDomainCreateXMLWithFiles(c.ptr, cXml, C.uint(len(files)), (&cfiles[0]), C.uint(flags))
+ var err C.virError
+ ptr := C.virDomainCreateXMLWithFilesWrapper(c.ptr, cXml, C.uint(len(files)), (&cfiles[0]), C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -816,9 +846,10 @@ func (c *Connect) DomainCreateXMLWithFiles(xmlConfig string, files []os.File, fl
func (c *Connect) DomainDefineXML(xmlConfig string) (*Domain, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virDomainDefineXML(c.ptr, cXml)
+ var err C.virError
+ ptr := C.virDomainDefineXMLWrapper(c.ptr, cXml, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -830,9 +861,10 @@ func (c *Connect) DomainDefineXMLFlags(xmlConfig string, flags DomainDefineFlags
}
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virDomainDefineXMLFlagsWrapper(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virDomainDefineXMLFlagsWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Domain{ptr: ptr}, nil
}
@@ -842,12 +874,13 @@ func (c *Connect) ListDefinedInterfaces() ([]string, error) {
const maxIfaces = 1024
var names [maxIfaces](*C.char)
namesPtr := unsafe.Pointer(&names)
- numIfaces := C.virConnectListDefinedInterfaces(
+ var err C.virError
+ numIfaces := C.virConnectListDefinedInterfacesWrapper(
c.ptr,
(**C.char)(namesPtr),
- maxIfaces)
+ maxIfaces, &err)
if numIfaces == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numIfaces)
for k := 0; k < int(numIfaces); k++ {
@@ -862,12 +895,13 @@ func (c *Connect) ListDefinedNetworks() ([]string, error) {
const maxNets = 1024
var names [maxNets](*C.char)
namesPtr := unsafe.Pointer(&names)
- numNetworks := C.virConnectListDefinedNetworks(
+ var err C.virError
+ numNetworks := C.virConnectListDefinedNetworksWrapper(
c.ptr,
(**C.char)(namesPtr),
- maxNets)
+ maxNets, &err)
if numNetworks == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numNetworks)
for k := 0; k < int(numNetworks); k++ {
@@ -882,12 +916,13 @@ func (c *Connect) ListDefinedStoragePools() ([]string, error) {
const maxPools = 1024
var names [maxPools](*C.char)
namesPtr := unsafe.Pointer(&names)
- numStoragePools := C.virConnectListDefinedStoragePools(
+ var err C.virError
+ numStoragePools := C.virConnectListDefinedStoragePoolsWrapper(
c.ptr,
(**C.char)(namesPtr),
- maxPools)
+ maxPools, &err)
if numStoragePools == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
goNames := make([]string, numStoragePools)
for k := 0; k < int(numStoragePools); k++ {
@@ -899,90 +934,100 @@ func (c *Connect) ListDefinedStoragePools() ([]string, error) {
// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virConnectNumOfDefinedDomains
func (c *Connect) NumOfDefinedDomains() (int, error) {
- result := int(C.virConnectNumOfDefinedDomains(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfDefinedDomainsWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-interface.html#virConnectNumOfDefinedInterfaces
func (c *Connect) NumOfDefinedInterfaces() (int, error) {
- result := int(C.virConnectNumOfDefinedInterfaces(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfDefinedInterfacesWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-network.html#virConnectNumOfDefinedNetworks
func (c *Connect) NumOfDefinedNetworks() (int, error) {
- result := int(C.virConnectNumOfDefinedNetworks(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfDefinedNetworksWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-storage.html#virConnectNumOfDefinedStoragePools
func (c *Connect) NumOfDefinedStoragePools() (int, error) {
- result := int(C.virConnectNumOfDefinedStoragePools(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfDefinedStoragePoolsWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virConnectNumOfDomains
func (c *Connect) NumOfDomains() (int, error) {
- result := int(C.virConnectNumOfDomains(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfDomainsWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-storage.html#virConnectNumOfStoragePools
func (c *Connect) NumOfStoragePools() (int, error) {
- result := int(C.virConnectNumOfStoragePools(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfStoragePoolsWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-interface.html#virConnectNumOfInterfaces
func (c *Connect) NumOfInterfaces() (int, error) {
- result := int(C.virConnectNumOfInterfaces(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfInterfacesWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-network.html#virConnectNumOfNetworks
func (c *Connect) NumOfNetworks() (int, error) {
- result := int(C.virConnectNumOfNetworks(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfNetworksWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-nwfilter.html#virConnectNumOfNWFilters
func (c *Connect) NumOfNWFilters() (int, error) {
- result := int(C.virConnectNumOfNWFilters(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfNWFiltersWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-secret.html#virConnectNumOfSecrets
func (c *Connect) NumOfSecrets() (int, error) {
- result := int(C.virConnectNumOfSecrets(c.ptr))
+ var err C.virError
+ result := int(C.virConnectNumOfSecretsWrapper(c.ptr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
@@ -991,9 +1036,10 @@ func (c *Connect) NumOfSecrets() (int, error) {
func (c *Connect) NumOfDevices(cap string, flags uint32) (int, error) {
ccap := C.CString(cap)
defer C.free(unsafe.Pointer(ccap))
- result := int(C.virNodeNumOfDevices(c.ptr, ccap, C.uint(flags)))
+ var err C.virError
+ result := int(C.virNodeNumOfDevicesWrapper(c.ptr, ccap, C.uint(flags), &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
@@ -1002,9 +1048,10 @@ func (c *Connect) NumOfDevices(cap string, flags uint32) (int, error) {
func (c *Connect) NetworkDefineXML(xmlConfig string) (*Network, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virNetworkDefineXML(c.ptr, cXml)
+ var err C.virError
+ ptr := C.virNetworkDefineXMLWrapper(c.ptr, cXml, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Network{ptr: ptr}, nil
}
@@ -1013,9 +1060,10 @@ func (c *Connect) NetworkDefineXML(xmlConfig string) (*Network, error) {
func (c *Connect) NetworkCreateXML(xmlConfig string) (*Network, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virNetworkCreateXML(c.ptr, cXml)
+ var err C.virError
+ ptr := C.virNetworkCreateXMLWrapper(c.ptr, cXml, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Network{ptr: ptr}, nil
}
@@ -1024,9 +1072,10 @@ func (c *Connect) NetworkCreateXML(xmlConfig string) (*Network, error) {
func (c *Connect) LookupNetworkByName(name string) (*Network, error) {
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virNetworkLookupByName(c.ptr, cName)
+ var err C.virError
+ ptr := C.virNetworkLookupByNameWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Network{ptr: ptr}, nil
}
@@ -1035,9 +1084,10 @@ func (c *Connect) LookupNetworkByName(name string) (*Network, error) {
func (c *Connect) LookupNetworkByUUIDString(uuid string) (*Network, error) {
cUuid := C.CString(uuid)
defer C.free(unsafe.Pointer(cUuid))
- ptr := C.virNetworkLookupByUUIDString(c.ptr, cUuid)
+ var err C.virError
+ ptr := C.virNetworkLookupByUUIDStringWrapper(c.ptr, cUuid, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Network{ptr: ptr}, nil
}
@@ -1052,29 +1102,32 @@ func (c *Connect) LookupNetworkByUUID(uuid []byte) (*Network, error) {
for i := 0; i < C.VIR_UUID_BUFLEN; i++ {
cUuid[i] = C.uchar(uuid[i])
}
- ptr := C.virNetworkLookupByUUID(c.ptr, &cUuid[0])
+ var err C.virError
+ ptr := C.virNetworkLookupByUUIDWrapper(c.ptr, &cUuid[0], &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Network{ptr: ptr}, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectSetKeepAlive
func (c *Connect) SetKeepAlive(interval int, count uint) error {
- res := int(C.virConnectSetKeepAlive(c.ptr, C.int(interval), C.uint(count)))
+ var err C.virError
+ res := int(C.virConnectSetKeepAliveWrapper(c.ptr, C.int(interval), C.uint(count), &err))
switch res {
case 0:
return nil
default:
- return GetLastError()
+ return makeError(&err)
}
}
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetSysinfo
func (c *Connect) GetSysinfo(flags uint32) (string, error) {
- cStr := C.virConnectGetSysinfo(c.ptr, C.uint(flags))
+ var err C.virError
+ cStr := C.virConnectGetSysinfoWrapper(c.ptr, C.uint(flags), &err)
if cStr == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
info := C.GoString(cStr)
C.free(unsafe.Pointer(cStr))
@@ -1083,9 +1136,10 @@ func (c *Connect) GetSysinfo(flags uint32) (string, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetURI
func (c *Connect) GetURI() (string, error) {
- cStr := C.virConnectGetURI(c.ptr)
+ var err C.virError
+ cStr := C.virConnectGetURIWrapper(c.ptr, &err)
if cStr == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
uri := C.GoString(cStr)
C.free(unsafe.Pointer(cStr))
@@ -1099,9 +1153,10 @@ func (c *Connect) GetMaxVcpus(typeAttr string) (int, error) {
cTypeAttr = C.CString(typeAttr)
defer C.free(unsafe.Pointer(cTypeAttr))
}
- result := int(C.virConnectGetMaxVcpus(c.ptr, cTypeAttr))
+ var err C.virError
+ result := int(C.virConnectGetMaxVcpusWrapper(c.ptr, cTypeAttr, &err))
if result == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return result, nil
}
@@ -1110,9 +1165,10 @@ func (c *Connect) GetMaxVcpus(typeAttr string) (int, error) {
func (c *Connect) InterfaceDefineXML(xmlConfig string, flags uint32) (*Interface, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virInterfaceDefineXML(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virInterfaceDefineXMLWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Interface{ptr: ptr}, nil
}
@@ -1121,9 +1177,10 @@ func (c *Connect) InterfaceDefineXML(xmlConfig string, flags uint32) (*Interface
func (c *Connect) LookupInterfaceByName(name string) (*Interface, error) {
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virInterfaceLookupByName(c.ptr, cName)
+ var err C.virError
+ ptr := C.virInterfaceLookupByNameWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Interface{ptr: ptr}, nil
}
@@ -1132,9 +1189,10 @@ func (c *Connect) LookupInterfaceByName(name string) (*Interface, error) {
func (c *Connect) LookupInterfaceByMACString(mac string) (*Interface, error) {
cName := C.CString(mac)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virInterfaceLookupByMACString(c.ptr, cName)
+ var err C.virError
+ ptr := C.virInterfaceLookupByMACStringWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Interface{ptr: ptr}, nil
}
@@ -1143,9 +1201,10 @@ func (c *Connect) LookupInterfaceByMACString(mac string) (*Interface, error) {
func (c *Connect) StoragePoolDefineXML(xmlConfig string, flags uint32) (*StoragePool, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virStoragePoolDefineXML(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virStoragePoolDefineXMLWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StoragePool{ptr: ptr}, nil
}
@@ -1154,9 +1213,10 @@ func (c *Connect) StoragePoolDefineXML(xmlConfig string, flags uint32) (*Storage
func (c *Connect) StoragePoolCreateXML(xmlConfig string, flags StoragePoolCreateFlags) (*StoragePool, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virStoragePoolCreateXML(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virStoragePoolCreateXMLWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StoragePool{ptr: ptr}, nil
}
@@ -1165,9 +1225,10 @@ func (c *Connect) StoragePoolCreateXML(xmlConfig string, flags StoragePoolCreate
func (c *Connect) LookupStoragePoolByName(name string) (*StoragePool, error) {
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virStoragePoolLookupByName(c.ptr, cName)
+ var err C.virError
+ ptr := C.virStoragePoolLookupByNameWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StoragePool{ptr: ptr}, nil
}
@@ -1176,9 +1237,10 @@ func (c *Connect) LookupStoragePoolByName(name string) (*StoragePool, error) {
func (c *Connect) LookupStoragePoolByUUIDString(uuid string) (*StoragePool, error) {
cUuid := C.CString(uuid)
defer C.free(unsafe.Pointer(cUuid))
- ptr := C.virStoragePoolLookupByUUIDString(c.ptr, cUuid)
+ var err C.virError
+ ptr := C.virStoragePoolLookupByUUIDStringWrapper(c.ptr, cUuid, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StoragePool{ptr: ptr}, nil
}
@@ -1193,9 +1255,10 @@ func (c *Connect) LookupStoragePoolByUUID(uuid []byte) (*StoragePool, error) {
for i := 0; i < C.VIR_UUID_BUFLEN; i++ {
cUuid[i] = C.uchar(uuid[i])
}
- ptr := C.virStoragePoolLookupByUUID(c.ptr, &cUuid[0])
+ var err C.virError
+ ptr := C.virStoragePoolLookupByUUIDWrapper(c.ptr, &cUuid[0], &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StoragePool{ptr: ptr}, nil
}
@@ -1207,9 +1270,10 @@ func (c *Connect) LookupStoragePoolByTargetPath(path string) (*StoragePool, erro
}
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
- ptr := C.virStoragePoolLookupByTargetPathWrapper(c.ptr, cPath)
+ var err C.virError
+ ptr := C.virStoragePoolLookupByTargetPathWrapper(c.ptr, cPath, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StoragePool{ptr: ptr}, nil
}
@@ -1218,9 +1282,10 @@ func (c *Connect) LookupStoragePoolByTargetPath(path string) (*StoragePool, erro
func (c *Connect) NWFilterDefineXML(xmlConfig string) (*NWFilter, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virNWFilterDefineXML(c.ptr, cXml)
+ var err C.virError
+ ptr := C.virNWFilterDefineXMLWrapper(c.ptr, cXml, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NWFilter{ptr: ptr}, nil
}
@@ -1229,9 +1294,10 @@ func (c *Connect) NWFilterDefineXML(xmlConfig string) (*NWFilter, error) {
func (c *Connect) LookupNWFilterByName(name string) (*NWFilter, error) {
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virNWFilterLookupByName(c.ptr, cName)
+ var err C.virError
+ ptr := C.virNWFilterLookupByNameWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NWFilter{ptr: ptr}, nil
}
@@ -1240,9 +1306,10 @@ func (c *Connect) LookupNWFilterByName(name string) (*NWFilter, error) {
func (c *Connect) LookupNWFilterByUUIDString(uuid string) (*NWFilter, error) {
cUuid := C.CString(uuid)
defer C.free(unsafe.Pointer(cUuid))
- ptr := C.virNWFilterLookupByUUIDString(c.ptr, cUuid)
+ var err C.virError
+ ptr := C.virNWFilterLookupByUUIDStringWrapper(c.ptr, cUuid, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NWFilter{ptr: ptr}, nil
}
@@ -1257,9 +1324,10 @@ func (c *Connect) LookupNWFilterByUUID(uuid []byte) (*NWFilter, error) {
for i := 0; i < C.VIR_UUID_BUFLEN; i++ {
cUuid[i] = C.uchar(uuid[i])
}
- ptr := C.virNWFilterLookupByUUID(c.ptr, &cUuid[0])
+ var err C.virError
+ ptr := C.virNWFilterLookupByUUIDWrapper(c.ptr, &cUuid[0], &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NWFilter{ptr: ptr}, nil
}
@@ -1271,9 +1339,10 @@ func (c *Connect) LookupNWFilterBindingByPortDev(name string) (*NWFilterBinding,
}
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virNWFilterBindingLookupByPortDevWrapper(c.ptr, cName)
+ var err C.virError
+ ptr := C.virNWFilterBindingLookupByPortDevWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NWFilterBinding{ptr: ptr}, nil
}
@@ -1282,9 +1351,10 @@ func (c *Connect) LookupNWFilterBindingByPortDev(name string) (*NWFilterBinding,
func (c *Connect) LookupStorageVolByKey(key string) (*StorageVol, error) {
cKey := C.CString(key)
defer C.free(unsafe.Pointer(cKey))
- ptr := C.virStorageVolLookupByKey(c.ptr, cKey)
+ var err C.virError
+ ptr := C.virStorageVolLookupByKeyWrapper(c.ptr, cKey, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StorageVol{ptr: ptr}, nil
}
@@ -1293,9 +1363,10 @@ func (c *Connect) LookupStorageVolByKey(key string) (*StorageVol, error) {
func (c *Connect) LookupStorageVolByPath(path string) (*StorageVol, error) {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
- ptr := C.virStorageVolLookupByPath(c.ptr, cPath)
+ var err C.virError
+ ptr := C.virStorageVolLookupByPathWrapper(c.ptr, cPath, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &StorageVol{ptr: ptr}, nil
}
@@ -1304,9 +1375,10 @@ func (c *Connect) LookupStorageVolByPath(path string) (*StorageVol, error) {
func (c *Connect) SecretDefineXML(xmlConfig string, flags uint32) (*Secret, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virSecretDefineXML(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virSecretDefineXMLWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Secret{ptr: ptr}, nil
}
@@ -1321,9 +1393,10 @@ func (c *Connect) LookupSecretByUUID(uuid []byte) (*Secret, error) {
for i := 0; i < C.VIR_UUID_BUFLEN; i++ {
cUuid[i] = C.uchar(uuid[i])
}
- ptr := C.virSecretLookupByUUID(c.ptr, &cUuid[0])
+ var err C.virError
+ ptr := C.virSecretLookupByUUIDWrapper(c.ptr, &cUuid[0], &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Secret{ptr: ptr}, nil
}
@@ -1332,9 +1405,10 @@ func (c *Connect) LookupSecretByUUID(uuid []byte) (*Secret, error) {
func (c *Connect) LookupSecretByUUIDString(uuid string) (*Secret, error) {
cUuid := C.CString(uuid)
defer C.free(unsafe.Pointer(cUuid))
- ptr := C.virSecretLookupByUUIDString(c.ptr, cUuid)
+ var err C.virError
+ ptr := C.virSecretLookupByUUIDStringWrapper(c.ptr, cUuid, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Secret{ptr: ptr}, nil
}
@@ -1343,9 +1417,10 @@ func (c *Connect) LookupSecretByUUIDString(uuid string) (*Secret, error) {
func (c *Connect) LookupSecretByUsage(usageType SecretUsageType, usageID string) (*Secret, error) {
cUsageID := C.CString(usageID)
defer C.free(unsafe.Pointer(cUsageID))
- ptr := C.virSecretLookupByUsage(c.ptr, C.int(usageType), cUsageID)
+ var err C.virError
+ ptr := C.virSecretLookupByUsageWrapper(c.ptr, C.int(usageType), cUsageID, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Secret{ptr: ptr}, nil
}
@@ -1354,9 +1429,10 @@ func (c *Connect) LookupSecretByUsage(usageType SecretUsageType, usageID string)
func (c *Connect) LookupDeviceByName(id string) (*NodeDevice, error) {
cName := C.CString(id)
defer C.free(unsafe.Pointer(cName))
- ptr := C.virNodeDeviceLookupByName(c.ptr, cName)
+ var err C.virError
+ ptr := C.virNodeDeviceLookupByNameWrapper(c.ptr, cName, &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NodeDevice{ptr: ptr}, nil
}
@@ -1367,9 +1443,10 @@ func (c *Connect) LookupDeviceSCSIHostByWWN(wwnn, wwpn string, flags uint32) (*N
cWwpn := C.CString(wwpn)
defer C.free(unsafe.Pointer(cWwnn))
defer C.free(unsafe.Pointer(cWwpn))
- ptr := C.virNodeDeviceLookupSCSIHostByWWN(c.ptr, cWwnn, cWwpn, C.uint(flags))
+ var err C.virError
+ ptr := C.virNodeDeviceLookupSCSIHostByWWNWrapper(c.ptr, cWwnn, cWwpn, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NodeDevice{ptr: ptr}, nil
}
@@ -1378,9 +1455,10 @@ func (c *Connect) LookupDeviceSCSIHostByWWN(wwnn, wwpn string, flags uint32) (*N
func (c *Connect) DeviceCreateXML(xmlConfig string, flags uint32) (*NodeDevice, error) {
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virNodeDeviceCreateXML(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virNodeDeviceCreateXMLWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NodeDevice{ptr: ptr}, nil
}
@@ -1388,9 +1466,10 @@ func (c *Connect) DeviceCreateXML(xmlConfig string, flags uint32) (*NodeDevice,
// See also https://libvirt.org/html/libvirt-libvirt-interface.html#virConnectListAllInterfaces
func (c *Connect) ListAllInterfaces(flags ConnectListAllInterfacesFlags) ([]Interface, error) {
var cList *C.virInterfacePtr
- numIfaces := C.virConnectListAllInterfaces(c.ptr, (**C.virInterfacePtr)(&cList), C.uint(flags))
+ var err C.virError
+ numIfaces := C.virConnectListAllInterfacesWrapper(c.ptr, (**C.virInterfacePtr)(&cList), C.uint(flags), &err)
if numIfaces == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1409,9 +1488,10 @@ func (c *Connect) ListAllInterfaces(flags ConnectListAllInterfacesFlags) ([]Inte
// See also https://libvirt.org/html/libvirt-libvirt-network.html#virConnectListAllNetworks
func (c *Connect) ListAllNetworks(flags ConnectListAllNetworksFlags) ([]Network, error) {
var cList *C.virNetworkPtr
- numNets := C.virConnectListAllNetworks(c.ptr, (**C.virNetworkPtr)(&cList), C.uint(flags))
+ var err C.virError
+ numNets := C.virConnectListAllNetworksWrapper(c.ptr, (**C.virNetworkPtr)(&cList), C.uint(flags), &err)
if numNets == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1430,9 +1510,10 @@ func (c *Connect) ListAllNetworks(flags ConnectListAllNetworksFlags) ([]Network,
// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virConnectListAllDomains
func (c *Connect) ListAllDomains(flags ConnectListAllDomainsFlags) ([]Domain, error) {
var cList *C.virDomainPtr
- numDomains := C.virConnectListAllDomains(c.ptr, (**C.virDomainPtr)(&cList), C.uint(flags))
+ var err C.virError
+ numDomains := C.virConnectListAllDomainsWrapper(c.ptr, (**C.virDomainPtr)(&cList), C.uint(flags), &err)
if numDomains == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1451,9 +1532,10 @@ func (c *Connect) ListAllDomains(flags ConnectListAllDomainsFlags) ([]Domain, er
// See also https://libvirt.org/html/libvirt-libvirt-nwfilter.html#virConnectListAllNWFilters
func (c *Connect) ListAllNWFilters(flags uint32) ([]NWFilter, error) {
var cList *C.virNWFilterPtr
- numNWFilters := C.virConnectListAllNWFilters(c.ptr, (**C.virNWFilterPtr)(&cList), C.uint(flags))
+ var err C.virError
+ numNWFilters := C.virConnectListAllNWFiltersWrapper(c.ptr, (**C.virNWFilterPtr)(&cList), C.uint(flags), &err)
if numNWFilters == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1475,9 +1557,10 @@ func (c *Connect) ListAllNWFilterBindings(flags uint32) ([]NWFilterBinding, erro
if C.LIBVIR_VERSION_NUMBER < 4005000 {
return []NWFilterBinding{}, GetNotImplementedError("virConnectListAllNWFilterBindings")
}
- numNWFilters := C.virConnectListAllNWFilterBindingsWrapper(c.ptr, (**C.virNWFilterBindingPtr)(&cList), C.uint(flags))
+ var err C.virError
+ numNWFilters := C.virConnectListAllNWFilterBindingsWrapper(c.ptr, (**C.virNWFilterBindingPtr)(&cList), C.uint(flags), &err)
if numNWFilters == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1496,9 +1579,10 @@ func (c *Connect) ListAllNWFilterBindings(flags uint32) ([]NWFilterBinding, erro
// See also https://libvirt.org/html/libvirt-libvirt-storage.html#virConnectListAllStoragePools
func (c *Connect) ListAllStoragePools(flags ConnectListAllStoragePoolsFlags) ([]StoragePool, error) {
var cList *C.virStoragePoolPtr
- numPools := C.virConnectListAllStoragePools(c.ptr, (**C.virStoragePoolPtr)(&cList), C.uint(flags))
+ var err C.virError
+ numPools := C.virConnectListAllStoragePoolsWrapper(c.ptr, (**C.virStoragePoolPtr)(&cList), C.uint(flags), &err)
if numPools == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1517,9 +1601,10 @@ func (c *Connect) ListAllStoragePools(flags ConnectListAllStoragePoolsFlags) ([]
// See also https://libvirt.org/html/libvirt-libvirt-secret.html#virConnectListAllSecrets
func (c *Connect) ListAllSecrets(flags ConnectListAllSecretsFlags) ([]Secret, error) {
var cList *C.virSecretPtr
- numPools := C.virConnectListAllSecrets(c.ptr, (**C.virSecretPtr)(&cList), C.uint(flags))
+ var err C.virError
+ numPools := C.virConnectListAllSecretsWrapper(c.ptr, (**C.virSecretPtr)(&cList), C.uint(flags), &err)
if numPools == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1538,9 +1623,10 @@ func (c *Connect) ListAllSecrets(flags ConnectListAllSecretsFlags) ([]Secret, er
// See also https://libvirt.org/html/libvirt-libvirt-nodedev.html#virConnectListAllNodeDevices
func (c *Connect) ListAllNodeDevices(flags ConnectListAllNodeDeviceFlags) ([]NodeDevice, error) {
var cList *C.virNodeDevicePtr
- numPools := C.virConnectListAllNodeDevices(c.ptr, (**C.virNodeDevicePtr)(&cList), C.uint(flags))
+ var err C.virError
+ numPools := C.virConnectListAllNodeDevicesWrapper(c.ptr, (**C.virNodeDevicePtr)(&cList), C.uint(flags), &err)
if numPools == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(cList)),
@@ -1558,27 +1644,30 @@ func (c *Connect) ListAllNodeDevices(flags ConnectListAllNodeDeviceFlags) ([]Nod
// See also https://libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceChangeBegin
func (c *Connect) InterfaceChangeBegin(flags uint32) error {
- ret := C.virInterfaceChangeBegin(c.ptr, C.uint(flags))
+ var err C.virError
+ ret := C.virInterfaceChangeBeginWrapper(c.ptr, C.uint(flags), &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
return nil
}
// See also https://libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceChangeCommit
func (c *Connect) InterfaceChangeCommit(flags uint32) error {
- ret := C.virInterfaceChangeCommit(c.ptr, C.uint(flags))
+ var err C.virError
+ ret := C.virInterfaceChangeCommitWrapper(c.ptr, C.uint(flags), &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
return nil
}
// See also https://libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceChangeRollback
func (c *Connect) InterfaceChangeRollback(flags uint32) error {
- ret := C.virInterfaceChangeRollback(c.ptr, C.uint(flags))
+ var err C.virError
+ ret := C.virInterfaceChangeRollbackWrapper(c.ptr, C.uint(flags), &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
return nil
}
@@ -1598,10 +1687,11 @@ func (c *Connect) AllocPages(pageSizes map[int]int64, startCell int, cellCount u
i++
}
+ var err C.virError
ret := C.virNodeAllocPagesWrapper(c.ptr, C.uint(len(pageSizes)), (*C.uint)(unsafe.Pointer(&cpages)),
- (*C.ulonglong)(unsafe.Pointer(&ccounts)), C.int(startCell), C.uint(cellCount), C.uint(flags))
+ (*C.ulonglong)(unsafe.Pointer(&ccounts)), C.int(startCell), C.uint(cellCount), C.uint(flags), &err)
if ret == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return int(ret), nil
@@ -1611,9 +1701,10 @@ func (c *Connect) AllocPages(pageSizes map[int]int64, startCell int, cellCount u
func (c *Connect) GetCPUMap(flags uint32) (map[int]bool, uint, error) {
var ccpumap *C.uchar
var conline C.uint
- ret := C.virNodeGetCPUMap(c.ptr, &ccpumap, &conline, C.uint(flags))
+ var err C.virError
+ ret := C.virNodeGetCPUMapWrapper(c.ptr, &ccpumap, &conline, C.uint(flags), &err)
if ret == -1 {
- return map[int]bool{}, 0, GetLastError()
+ return map[int]bool{}, 0, makeError(&err)
}
defer C.free(unsafe.Pointer(ccpumap))
@@ -1649,15 +1740,16 @@ type NodeCPUStats struct {
func (c *Connect) GetCPUStats(cpuNum int, flags uint32) (*NodeCPUStats, error) {
var nparams C.int
- ret := C.virNodeGetCPUStats(c.ptr, C.int(cpuNum), nil, &nparams, C.uint(0))
+ var err C.virError
+ ret := C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), nil, &nparams, C.uint(0), &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
params := make([]C.virNodeCPUStats, nparams)
- ret = C.virNodeGetCPUStats(c.ptr, C.int(cpuNum), (*C.virNodeCPUStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags))
+ ret = C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), (*C.virNodeCPUStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags), &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
stats := &NodeCPUStats{}
@@ -1692,9 +1784,10 @@ func (c *Connect) GetCPUStats(cpuNum int, flags uint32) (*NodeCPUStats, error) {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetCellsFreeMemory
func (c *Connect) GetCellsFreeMemory(startCell int, maxCells int) ([]uint64, error) {
cmem := make([]C.ulonglong, maxCells)
- ret := C.virNodeGetCellsFreeMemory(c.ptr, (*C.ulonglong)(unsafe.Pointer(&cmem[0])), C.int(startCell), C.int(maxCells))
+ var err C.virError
+ ret := C.virNodeGetCellsFreeMemoryWrapper(c.ptr, (*C.ulonglong)(unsafe.Pointer(&cmem[0])), C.int(startCell), C.int(maxCells), &err)
if ret == -1 {
- return []uint64{}, GetLastError()
+ return []uint64{}, makeError(&err)
}
mem := make([]uint64, ret)
@@ -1707,9 +1800,10 @@ func (c *Connect) GetCellsFreeMemory(startCell int, maxCells int) ([]uint64, err
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetFreeMemory
func (c *Connect) GetFreeMemory() (uint64, error) {
- ret := C.virNodeGetFreeMemory(c.ptr)
+ var err C.virError
+ ret := C.virNodeGetFreeMemoryWrapper(c.ptr, &err)
if ret == 0 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return (uint64)(ret), nil
@@ -1727,10 +1821,11 @@ func (c *Connect) GetFreePages(pageSizes []uint64, startCell int, maxCells uint,
cpageSizes[i] = C.uint(pageSizes[i])
}
+ var err C.virError
ret := C.virNodeGetFreePagesWrapper(c.ptr, C.uint(len(pageSizes)), (*C.uint)(unsafe.Pointer(&cpageSizes)), C.int(startCell),
- C.uint(maxCells), (*C.ulonglong)(unsafe.Pointer(&ccounts)), C.uint(flags))
+ C.uint(maxCells), (*C.ulonglong)(unsafe.Pointer(&ccounts)), C.uint(flags), &err)
if ret == -1 {
- return []uint64{}, GetLastError()
+ return []uint64{}, makeError(&err)
}
counts := make([]uint64, ret)
@@ -1804,22 +1899,23 @@ func (c *Connect) GetMemoryParameters(flags uint32) (*NodeMemoryParameters, erro
var nparams C.int
- ret := C.virNodeGetMemoryParameters(c.ptr, nil, &nparams, C.uint(0))
+ var err C.virError
+ ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, C.uint(0), &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
cparams := make([]C.virTypedParameter, nparams)
- ret = C.virNodeGetMemoryParameters(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags))
+ ret = C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
- _, err := typedParamsUnpack(cparams, info)
- if err != nil {
- return nil, err
+ _, gerr := typedParamsUnpack(cparams, info)
+ if gerr != nil {
+ return nil, gerr
}
return params, nil
@@ -1840,15 +1936,16 @@ type NodeMemoryStats struct {
func (c *Connect) GetMemoryStats(cellNum int, flags uint32) (*NodeMemoryStats, error) {
var nparams C.int
- ret := C.virNodeGetMemoryStats(c.ptr, C.int(cellNum), nil, &nparams, 0)
+ var err C.virError
+ ret := C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), nil, &nparams, 0, &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
params := make([]C.virNodeMemoryStats, nparams)
- ret = C.virNodeGetMemoryStats(c.ptr, C.int(cellNum), (*C.virNodeMemoryStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags))
+ ret = C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), (*C.virNodeMemoryStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags), &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
stats := &NodeMemoryStats{}
@@ -1882,9 +1979,10 @@ type NodeSecurityModel struct {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetSecurityModel
func (c *Connect) GetSecurityModel() (*NodeSecurityModel, error) {
var cmodel C.virSecurityModel
- ret := C.virNodeGetSecurityModel(c.ptr, &cmodel)
+ var err C.virError
+ ret := C.virNodeGetSecurityModelWrapper(c.ptr, &cmodel, &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NodeSecurityModel{
@@ -1899,34 +1997,36 @@ func (c *Connect) SetMemoryParameters(params *NodeMemoryParameters, flags uint32
var nparams C.int
- ret := C.virNodeGetMemoryParameters(c.ptr, nil, &nparams, 0)
+ var err C.virError
+ ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, 0, &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
cparams := make([]C.virTypedParameter, nparams)
- ret = C.virNodeGetMemoryParameters(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0)
+ ret = C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams)
- err := typedParamsPack(cparams, info)
- if err != nil {
- return err
+ gerr := typedParamsPack(cparams, info)
+ if gerr != nil {
+ return gerr
}
- ret = C.virNodeSetMemoryParameters(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags))
+ ret = C.virNodeSetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err)
return nil
}
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeSuspendForDuration
func (c *Connect) SuspendForDuration(target NodeSuspendTarget, duration uint64, flags uint32) error {
- ret := C.virNodeSuspendForDuration(c.ptr, C.uint(target), C.ulonglong(duration), C.uint(flags))
+ var err C.virError
+ ret := C.virNodeSuspendForDurationWrapper(c.ptr, C.uint(target), C.ulonglong(duration), C.uint(flags), &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
return nil
}
@@ -1938,10 +2038,11 @@ func (c *Connect) DomainSaveImageDefineXML(file string, xml string, flags Domain
cxml := C.CString(xml)
defer C.free(unsafe.Pointer(cxml))
- ret := C.virDomainSaveImageDefineXML(c.ptr, cfile, cxml, C.uint(flags))
+ var err C.virError
+ ret := C.virDomainSaveImageDefineXMLWrapper(c.ptr, cfile, cxml, C.uint(flags), &err)
if ret == -1 {
- return GetLastError()
+ return makeError(&err)
}
return nil
@@ -1952,10 +2053,11 @@ func (c *Connect) DomainSaveImageGetXMLDesc(file string, flags DomainXMLFlags) (
cfile := C.CString(file)
defer C.free(unsafe.Pointer(cfile))
- ret := C.virDomainSaveImageGetXMLDesc(c.ptr, cfile, C.uint(flags))
+ var err C.virError
+ ret := C.virDomainSaveImageGetXMLDescWrapper(c.ptr, cfile, C.uint(flags), &err)
if ret == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
defer C.free(unsafe.Pointer(ret))
@@ -1971,9 +2073,10 @@ func (c *Connect) BaselineCPU(xmlCPUs []string, flags ConnectBaselineCPUFlags) (
defer C.free(unsafe.Pointer(cxmlCPUs[i]))
}
- ret := C.virConnectBaselineCPU(c.ptr, &cxmlCPUs[0], C.uint(len(xmlCPUs)), C.uint(flags))
+ var err C.virError
+ ret := C.virConnectBaselineCPUWrapper(c.ptr, &cxmlCPUs[0], C.uint(len(xmlCPUs)), C.uint(flags), &err)
if ret == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
defer C.free(unsafe.Pointer(ret))
@@ -2010,10 +2113,11 @@ func (c *Connect) BaselineHypervisorCPU(emulator string, arch string, machine st
defer C.free(unsafe.Pointer(cxmlCPUs[i]))
}
+ var err C.virError
ret := C.virConnectBaselineHypervisorCPUWrapper(c.ptr, cemulator, carch, cmachine, cvirttype,
- &cxmlCPUs[0], C.uint(len(xmlCPUs)), C.uint(flags))
+ &cxmlCPUs[0], C.uint(len(xmlCPUs)), C.uint(flags), &err)
if ret == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
defer C.free(unsafe.Pointer(ret))
@@ -2026,9 +2130,10 @@ func (c *Connect) CompareCPU(xmlDesc string, flags ConnectCompareCPUFlags) (CPUC
cxmlDesc := C.CString(xmlDesc)
defer C.free(unsafe.Pointer(cxmlDesc))
- ret := C.virConnectCompareCPU(c.ptr, cxmlDesc, C.uint(flags))
+ var err C.virError
+ ret := C.virConnectCompareCPUWrapper(c.ptr, cxmlDesc, C.uint(flags), &err)
if ret == C.VIR_CPU_COMPARE_ERROR {
- return CPU_COMPARE_ERROR, GetLastError()
+ return CPU_COMPARE_ERROR, makeError(&err)
}
return CPUCompareResult(ret), nil
@@ -2061,9 +2166,10 @@ func (c *Connect) CompareHypervisorCPU(emulator string, arch string, machine str
cxmlDesc := C.CString(xmlDesc)
defer C.free(unsafe.Pointer(cxmlDesc))
- ret := C.virConnectCompareHypervisorCPUWrapper(c.ptr, cemulator, carch, cmachine, cvirttype, cxmlDesc, C.uint(flags))
+ var err C.virError
+ ret := C.virConnectCompareHypervisorCPUWrapper(c.ptr, cemulator, carch, cmachine, cvirttype, cxmlDesc, C.uint(flags), &err)
if ret == C.VIR_CPU_COMPARE_ERROR {
- return CPU_COMPARE_ERROR, GetLastError()
+ return CPU_COMPARE_ERROR, makeError(&err)
}
return CPUCompareResult(ret), nil
@@ -2076,9 +2182,10 @@ func (c *Connect) DomainXMLFromNative(nativeFormat string, nativeConfig string,
cnativeConfig := C.CString(nativeConfig)
defer C.free(unsafe.Pointer(cnativeConfig))
- ret := C.virConnectDomainXMLFromNative(c.ptr, cnativeFormat, cnativeConfig, C.uint(flags))
+ var err C.virError
+ ret := C.virConnectDomainXMLFromNativeWrapper(c.ptr, cnativeFormat, cnativeConfig, C.uint(flags), &err)
if ret == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
defer C.free(unsafe.Pointer(ret))
@@ -2093,9 +2200,10 @@ func (c *Connect) DomainXMLToNative(nativeFormat string, domainXml string, flags
cdomainXml := C.CString(domainXml)
defer C.free(unsafe.Pointer(cdomainXml))
- ret := C.virConnectDomainXMLToNative(c.ptr, cnativeFormat, cdomainXml, C.uint(flags))
+ var err C.virError
+ ret := C.virConnectDomainXMLToNativeWrapper(c.ptr, cnativeFormat, cdomainXml, C.uint(flags), &err)
if ret == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
defer C.free(unsafe.Pointer(ret))
@@ -2109,9 +2217,10 @@ func (c *Connect) GetCPUModelNames(arch string, flags uint32) ([]string, error)
defer C.free(unsafe.Pointer(carch))
var cmodels **C.char
- ret := C.virConnectGetCPUModelNames(c.ptr, carch, &cmodels, C.uint(flags))
+ var err C.virError
+ ret := C.virConnectGetCPUModelNamesWrapper(c.ptr, carch, &cmodels, C.uint(flags), &err)
if ret == -1 {
- return []string{}, GetLastError()
+ return []string{}, makeError(&err)
}
models := make([]string, int(ret))
@@ -2152,9 +2261,10 @@ func (c *Connect) GetDomainCapabilities(emulatorbin string, arch string, machine
defer C.free(unsafe.Pointer(cvirttype))
}
- ret := C.virConnectGetDomainCapabilitiesWrapper(c.ptr, cemulatorbin, carch, cmachine, cvirttype, C.uint(flags))
+ var err C.virError
+ ret := C.virConnectGetDomainCapabilitiesWrapper(c.ptr, cemulatorbin, carch, cmachine, cvirttype, C.uint(flags), &err)
if ret == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
defer C.free(unsafe.Pointer(ret))
@@ -2165,9 +2275,10 @@ func (c *Connect) GetDomainCapabilities(emulatorbin string, arch string, machine
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virConnectGetVersion
func (c *Connect) GetVersion() (uint32, error) {
var hvVer C.ulong
- ret := C.virConnectGetVersion(c.ptr, &hvVer)
+ var err C.virError
+ ret := C.virConnectGetVersionWrapper(c.ptr, &hvVer, &err)
if ret == -1 {
- return 0, GetLastError()
+ return 0, makeError(&err)
}
return uint32(hvVer), nil
@@ -2182,9 +2293,10 @@ func (c *Connect) FindStoragePoolSources(pooltype string, srcSpec string, flags
csrcSpec := C.CString(srcSpec)
defer C.free(unsafe.Pointer(csrcSpec))
}
- ret := C.virConnectFindStoragePoolSources(c.ptr, cpooltype, csrcSpec, C.uint(flags))
+ var err C.virError
+ ret := C.virConnectFindStoragePoolSourcesWrapper(c.ptr, cpooltype, csrcSpec, C.uint(flags), &err)
if ret == nil {
- return "", GetLastError()
+ return "", makeError(&err)
}
defer C.free(unsafe.Pointer(ret))
@@ -2196,8 +2308,9 @@ func (c *Connect) FindStoragePoolSources(pooltype string, srcSpec string, flags
func (c *Connect) DomainRestore(srcFile string) error {
cPath := C.CString(srcFile)
defer C.free(unsafe.Pointer(cPath))
- if result := C.virDomainRestore(c.ptr, cPath); result == -1 {
- return GetLastError()
+ var err C.virError
+ if result := C.virDomainRestoreWrapper(c.ptr, cPath, &err); result == -1 {
+ return makeError(&err)
}
return nil
}
@@ -2211,17 +2324,19 @@ func (c *Connect) DomainRestoreFlags(srcFile, xmlConf string, flags DomainSaveRe
cXmlConf = C.CString(xmlConf)
defer C.free(unsafe.Pointer(cXmlConf))
}
- if result := C.virDomainRestoreFlags(c.ptr, cPath, cXmlConf, C.uint(flags)); result == -1 {
- return GetLastError()
+ var err C.virError
+ if result := C.virDomainRestoreFlagsWrapper(c.ptr, cPath, cXmlConf, C.uint(flags), &err); result == -1 {
+ return makeError(&err)
}
return nil
}
// See also https://libvirt.org/html/libvirt-libvirt-stream.html#virStreamNew
func (c *Connect) NewStream(flags StreamFlags) (*Stream, error) {
- virStream := C.virStreamNew(c.ptr, C.uint(flags))
+ var err C.virError
+ virStream := C.virStreamNewWrapper(c.ptr, C.uint(flags), &err)
if virStream == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &Stream{
@@ -2665,18 +2780,19 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
}
var ret C.int
var cstats *C.virDomainStatsRecordPtr
+ var err C.virError
if len(doms) > 0 {
cdoms := make([]C.virDomainPtr, len(doms)+1)
for i := 0; i < len(doms); i++ {
cdoms[i] = doms[i].ptr
}
- ret = C.virDomainListGetStatsWrapper(&cdoms[0], C.uint(statsTypes), &cstats, C.uint(flags))
+ ret = C.virDomainListGetStatsWrapper(&cdoms[0], C.uint(statsTypes), &cstats, C.uint(flags), &err)
} else {
- ret = C.virConnectGetAllDomainStatsWrapper(c.ptr, C.uint(statsTypes), &cstats, C.uint(flags))
+ ret = C.virConnectGetAllDomainStatsWrapper(c.ptr, C.uint(statsTypes), &cstats, C.uint(flags), &err)
}
if ret == -1 {
- return []DomainStats{}, GetLastError()
+ return []DomainStats{}, makeError(&err)
}
defer C.virDomainStatsRecordListFreeWrapper(cstats)
@@ -2692,9 +2808,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
state := &DomainStatsState{}
stateInfo := getDomainStatsStateFieldInfo(state)
- count, err := typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), stateInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr := typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), stateInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if count != 0 {
domstats.State = state
@@ -2703,9 +2819,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
cpu := &DomainStatsCPU{}
cpuInfo := getDomainStatsCPUFieldInfo(cpu)
- count, err = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), cpuInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), cpuInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if count != 0 {
domstats.Cpu = cpu
@@ -2714,9 +2830,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
balloon := &DomainStatsBalloon{}
balloonInfo := getDomainStatsBalloonFieldInfo(balloon)
- count, err = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), balloonInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), balloonInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if count != 0 {
domstats.Balloon = balloon
@@ -2725,9 +2841,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
perf := &DomainStatsPerf{}
perfInfo := getDomainStatsPerfFieldInfo(perf)
- count, err = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), perfInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), perfInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if count != 0 {
domstats.Perf = perf
@@ -2736,9 +2852,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
lengths := domainStatsLengths{}
lengthsInfo := getDomainStatsLengthsFieldInfo(&lengths)
- count, err = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), lengthsInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), lengthsInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if !lengths.VcpuMaximumSet && lengths.VcpuCurrentSet {
@@ -2752,9 +2868,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
vcpu := DomainStatsVcpu{}
vcpuInfo := getDomainStatsVcpuFieldInfo(j, &vcpu)
- count, err = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), vcpuInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), vcpuInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if count == 0 {
vcpu.StateSet = true
@@ -2770,9 +2886,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
block := DomainStatsBlock{}
blockInfo := getDomainStatsBlockFieldInfo(j, &block)
- count, err = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), blockInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), blockInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if count != 0 {
domstats.Block[j] = block
@@ -2786,9 +2902,9 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes DomainStatsTypes,
net := DomainStatsNet{}
netInfo := getDomainStatsNetFieldInfo(j, &net)
- count, err = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), netInfo)
- if err != nil {
- return []DomainStats{}, err
+ count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), netInfo)
+ if gerr != nil {
+ return []DomainStats{}, gerr
}
if count != 0 {
domstats.Net[j] = net
@@ -2846,16 +2962,17 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSEVParameters, error) {
var cparams *C.virTypedParameter
var nparams C.int
- ret := C.virNodeGetSEVInfoWrapper(c.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags))
+ var err C.virError
+ ret := C.virNodeGetSEVInfoWrapper(c.ptr, (*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err)
if ret == -1 {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
defer C.virTypedParamsFree(cparams, nparams)
- _, err := typedParamsUnpackLen(cparams, int(nparams), info)
- if err != nil {
- return nil, err
+ _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
+ if gerr != nil {
+ return nil, gerr
}
return params, nil
@@ -2868,9 +2985,10 @@ func (c *Connect) NWFilterBindingCreateXML(xmlConfig string, flags uint32) (*NWF
}
cXml := C.CString(string(xmlConfig))
defer C.free(unsafe.Pointer(cXml))
- ptr := C.virNWFilterBindingCreateXMLWrapper(c.ptr, cXml, C.uint(flags))
+ var err C.virError
+ ptr := C.virNWFilterBindingCreateXMLWrapper(c.ptr, cXml, C.uint(flags), &err)
if ptr == nil {
- return nil, GetLastError()
+ return nil, makeError(&err)
}
return &NWFilterBinding{ptr: ptr}, nil
}
diff --git a/connect_wrapper.go b/connect_wrapper.go
index d714fb9..17800a2 100644
--- a/connect_wrapper.go
+++ b/connect_wrapper.go
@@ -29,6 +29,7 @@ package libvirt
/*
#cgo pkg-config: libvirt
#include <assert.h>
+#include <stdio.h>
#include "connect_wrapper.h"
#include "callbacks_wrapper.h"
@@ -38,14 +39,6 @@ void closeCallbackHelper(virConnectPtr conn, int reason, void *opaque)
closeCallback(conn, reason, (long)opaque);
}
-int virConnectRegisterCloseCallbackHelper(virConnectPtr c, virConnectCloseFunc cb, long goCallbackId)
-{
- void *id = (void*)goCallbackId;
- return virConnectRegisterCloseCallback(c, cb, id, freeGoCallbackHelper);
-}
-
-#include <stdio.h>
-
extern int connectAuthCallback(virConnectCredentialPtr, unsigned int, int);
int connectAuthCallbackHelper(virConnectCredentialPtr cred, unsigned int ncred, void *cbdata)
{
@@ -54,188 +47,1720 @@ int connectAuthCallbackHelper(virConnectCredentialPtr cred, unsigned int ncred,
return connectAuthCallback(cred, ncred, *callbackID);
}
-virConnectPtr virConnectOpenAuthWrapper(const char *name, int *credtype, uint ncredtype, int callbackID, unsigned int flags)
-{
- virConnectAuth auth = {
- .credtype = credtype,
- .ncredtype = ncredtype,
- .cb = connectAuthCallbackHelper,
- .cbdata = &callbackID,
- };
- return virConnectOpenAuth(name, &auth, flags);
+char *
+virConnectBaselineCPUWrapper(virConnectPtr conn,
+ const char **xmlCPUs,
+ unsigned int ncpus,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ char * ret = virConnectBaselineCPU(conn, xmlCPUs, ncpus, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
}
-int virNodeGetFreePagesWrapper(virConnectPtr conn,
- unsigned int npages,
- unsigned int *pages,
- int startcell,
- unsigned int cellcount,
- unsigned long long *counts,
- unsigned int flags)
+char *
+virConnectBaselineHypervisorCPUWrapper(virConnectPtr conn,
+ const char *emulator,
+ const char *arch,
+ const char *machine,
+ const char *virttype,
+ const char **xmlCPUs,
+ unsigned int ncpus,
+ unsigned int flags,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 1002006
+#if LIBVIR_VERSION_NUMBER < 4004000
assert(0); // Caller should have checked version
#else
- return virNodeGetFreePages(conn, npages, pages, startcell, cellcount, counts, flags);
+ char * ret = virConnectBaselineHypervisorCPU(conn, emulator, arch, machine, virttype, xmlCPUs, ncpus, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-char * virConnectGetDomainCapabilitiesWrapper(virConnectPtr conn,
- const char *emulatorbin,
- const char *arch,
- const char *machine,
- const char *virttype,
- unsigned int flags)
+
+int
+virConnectCloseWrapper(virConnectPtr conn,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 1002007
+ int ret = virConnectClose(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectCompareCPUWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectCompareCPU(conn, xmlDesc, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectCompareHypervisorCPUWrapper(virConnectPtr conn,
+ const char *emulator,
+ const char *arch,
+ const char *machine,
+ const char *virttype,
+ const char *xmlCPU,
+ unsigned int flags,
+ virErrorPtr err)
+{
+#if LIBVIR_VERSION_NUMBER < 4004000
assert(0); // Caller should have checked version
#else
- return virConnectGetDomainCapabilities(conn, emulatorbin, arch, machine, virttype, flags);
+ int ret = virConnectCompareHypervisorCPU(conn, emulator, arch, machine, virttype, xmlCPU, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-int virConnectGetAllDomainStatsWrapper(virConnectPtr conn,
- unsigned int stats,
- virDomainStatsRecordPtr **retStats,
- unsigned int flags)
+
+char *
+virConnectDomainXMLFromNativeWrapper(virConnectPtr conn,
+ const char *nativeFormat,
+ const char *nativeConfig,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ char * ret = virConnectDomainXMLFromNative(conn, nativeFormat, nativeConfig, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+char *
+virConnectDomainXMLToNativeWrapper(virConnectPtr conn,
+ const char *nativeFormat,
+ const char *domainXml,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ char * ret = virConnectDomainXMLToNative(conn, nativeFormat, domainXml, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+char *
+virConnectFindStoragePoolSourcesWrapper(virConnectPtr conn,
+ const char *type,
+ const char *srcSpec,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ char * ret = virConnectFindStoragePoolSources(conn, type, srcSpec, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectGetAllDomainStatsWrapper(virConnectPtr conn,
+ unsigned int stats,
+ virDomainStatsRecordPtr **retStats,
+ unsigned int flags,
+ virErrorPtr err)
{
#if LIBVIR_VERSION_NUMBER < 1002008
assert(0); // Caller should have checked version
#else
- return virConnectGetAllDomainStats(conn, stats, retStats, flags);
+ int ret = virConnectGetAllDomainStats(conn, stats, retStats, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-int virDomainListGetStatsWrapper(virDomainPtr *doms,
- unsigned int stats,
- virDomainStatsRecordPtr **retStats,
- unsigned int flags)
+
+int
+virConnectGetCPUModelNamesWrapper(virConnectPtr conn,
+ const char *arch,
+ char ** *models,
+ unsigned int flags,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 1002008
+ int ret = virConnectGetCPUModelNames(conn, arch, models, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+char *
+virConnectGetCapabilitiesWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ char * ret = virConnectGetCapabilities(conn);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+char *
+virConnectGetDomainCapabilitiesWrapper(virConnectPtr conn,
+ const char *emulatorbin,
+ const char *arch,
+ const char *machine,
+ const char *virttype,
+ unsigned int flags,
+ virErrorPtr err)
+{
+#if LIBVIR_VERSION_NUMBER < 1002007
assert(0); // Caller should have checked version
#else
- return virDomainListGetStats(doms, stats, retStats, flags);
+ char * ret = virConnectGetDomainCapabilities(conn, emulatorbin, arch, machine, virttype, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-void virDomainStatsRecordListFreeWrapper(virDomainStatsRecordPtr *stats)
+
+char *
+virConnectGetHostnameWrapper(virConnectPtr conn,
+ virErrorPtr err)
{
+ char * ret = virConnectGetHostname(conn);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
}
-int virNodeAllocPagesWrapper(virConnectPtr conn,
- unsigned int npages,
- unsigned int *pageSizes,
- unsigned long long *pageCounts,
- int startCell,
- unsigned int cellCount,
- unsigned int flags)
+
+int
+virConnectGetLibVersionWrapper(virConnectPtr conn,
+ unsigned long *libVer,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 1002009
+ int ret = virConnectGetLibVersion(conn, libVer);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectGetMaxVcpusWrapper(virConnectPtr conn,
+ const char *type,
+ virErrorPtr err)
+{
+ int ret = virConnectGetMaxVcpus(conn, type);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+char *
+virConnectGetSysinfoWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ char * ret = virConnectGetSysinfo(conn, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+const char *
+virConnectGetTypeWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ const char * ret = virConnectGetType(conn);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+char *
+virConnectGetURIWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ char * ret = virConnectGetURI(conn);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectGetVersionWrapper(virConnectPtr conn,
+ unsigned long *hvVer,
+ virErrorPtr err)
+{
+ int ret = virConnectGetVersion(conn, hvVer);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectIsAliveWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectIsAlive(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectIsEncryptedWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectIsEncrypted(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectIsSecureWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectIsSecure(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListAllDomainsWrapper(virConnectPtr conn,
+ virDomainPtr **domains,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectListAllDomains(conn, domains, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListAllInterfacesWrapper(virConnectPtr conn,
+ virInterfacePtr **ifaces,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectListAllInterfaces(conn, ifaces, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListAllNWFilterBindingsWrapper(virConnectPtr conn,
+ virNWFilterBindingPtr **bindings,
+ unsigned int flags,
+ virErrorPtr err)
+{
+#if LIBVIR_VERSION_NUMBER < 4005000
assert(0); // Caller should have checked version
#else
- return virNodeAllocPages(conn, npages, pageSizes, pageCounts, startCell, cellCount, flags);
+ int ret = virConnectListAllNWFilterBindings(conn, bindings, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-virDomainPtr virDomainDefineXMLFlagsWrapper(virConnectPtr conn,
- const char *xml,
- unsigned int flags)
+int
+virConnectListAllNWFiltersWrapper(virConnectPtr conn,
+ virNWFilterPtr **filters,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectListAllNWFilters(conn, filters, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListAllNetworksWrapper(virConnectPtr conn,
+ virNetworkPtr **nets,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectListAllNetworks(conn, nets, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListAllNodeDevicesWrapper(virConnectPtr conn,
+ virNodeDevicePtr **devices,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectListAllNodeDevices(conn, devices, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListAllSecretsWrapper(virConnectPtr conn,
+ virSecretPtr **secrets,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectListAllSecrets(conn, secrets, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListAllStoragePoolsWrapper(virConnectPtr conn,
+ virStoragePoolPtr **pools,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virConnectListAllStoragePools(conn, pools, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListDefinedDomainsWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListDefinedDomains(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListDefinedInterfacesWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListDefinedInterfaces(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListDefinedNetworksWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListDefinedNetworks(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListDefinedStoragePoolsWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListDefinedStoragePools(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListDomainsWrapper(virConnectPtr conn,
+ int *ids,
+ int maxids,
+ virErrorPtr err)
+{
+ int ret = virConnectListDomains(conn, ids, maxids);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListInterfacesWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListInterfaces(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListNWFiltersWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListNWFilters(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListNetworksWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListNetworks(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListSecretsWrapper(virConnectPtr conn,
+ char **uuids,
+ int maxuuids,
+ virErrorPtr err)
+{
+ int ret = virConnectListSecrets(conn, uuids, maxuuids);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectListStoragePoolsWrapper(virConnectPtr conn,
+ char ** const names,
+ int maxnames,
+ virErrorPtr err)
+{
+ int ret = virConnectListStoragePools(conn, names, maxnames);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfDefinedDomainsWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfDefinedDomains(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfDefinedInterfacesWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfDefinedInterfaces(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfDefinedNetworksWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfDefinedNetworks(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfDefinedStoragePoolsWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfDefinedStoragePools(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfDomainsWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfDomains(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfInterfacesWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfInterfaces(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfNWFiltersWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfNWFilters(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfNetworksWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfNetworks(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfSecretsWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfSecrets(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectNumOfStoragePoolsWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectNumOfStoragePools(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virConnectPtr
+virConnectOpenWrapper(const char *name,
+ virErrorPtr err)
+{
+ virConnectPtr ret = virConnectOpen(name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virConnectPtr
+virConnectOpenAuthWrapper(const char *name,
+ int *credtype,
+ uint ncredtype,
+ int callbackID,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virConnectAuth auth = {
+ .credtype = credtype,
+ .ncredtype = ncredtype,
+ .cb = connectAuthCallbackHelper,
+ .cbdata = &callbackID,
+ };
+
+ virConnectPtr ret = virConnectOpenAuth(name, &auth, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virConnectPtr
+virConnectOpenReadOnlyWrapper(const char *name,
+ virErrorPtr err)
+{
+ virConnectPtr ret = virConnectOpenReadOnly(name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectRefWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectRef(conn);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectRegisterCloseCallbackWrapper(virConnectPtr conn,
+ long goCallbackId,
+ virErrorPtr err)
+{
+ void *id = (void*)goCallbackId;
+ int ret = virConnectRegisterCloseCallback(conn, closeCallbackHelper, id, freeGoCallbackHelper);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectSetKeepAliveWrapper(virConnectPtr conn,
+ int interval,
+ unsigned int count,
+ virErrorPtr err)
+{
+ int ret = virConnectSetKeepAlive(conn, interval, count);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virConnectUnregisterCloseCallbackWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ int ret = virConnectUnregisterCloseCallback(conn, closeCallbackHelper);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainCreateLinuxWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virDomainPtr ret = virDomainCreateLinux(conn, xmlDesc, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virDomainPtr ret = virDomainCreateXML(conn, xmlDesc, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainCreateXMLWithFilesWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int nfiles,
+ int *files,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virDomainPtr ret = virDomainCreateXMLWithFiles(conn, xmlDesc, nfiles, files, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ virErrorPtr err)
+{
+ virDomainPtr ret = virDomainDefineXML(conn, xml);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainDefineXMLFlagsWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err)
{
#if LIBVIR_VERSION_NUMBER < 1002012
assert(0); // Caller should have checked version
#else
- return virDomainDefineXMLFlags(conn, xml, flags);
+ virDomainPtr ret = virDomainDefineXMLFlags(conn, xml, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-virStoragePoolPtr virStoragePoolLookupByTargetPathWrapper(virConnectPtr conn,
- const char *path)
+
+int
+virDomainListGetStatsWrapper(virDomainPtr *doms,
+ unsigned int stats,
+ virDomainStatsRecordPtr **retStats,
+ unsigned int flags,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 4001000
+#if LIBVIR_VERSION_NUMBER < 1002008
assert(0); // Caller should have checked version
#else
- return virStoragePoolLookupByTargetPath(conn, path);
+ int ret = virDomainListGetStats(doms, stats, retStats, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-char *virConnectBaselineHypervisorCPUWrapper(virConnectPtr conn,
- const char *emulator,
- const char *arch,
- const char *machine,
- const char *virttype,
- const char **xmlCPUs,
- unsigned int ncpus,
- unsigned int flags)
+
+virDomainPtr
+virDomainLookupByIDWrapper(virConnectPtr conn,
+ int id,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 4004000
+ virDomainPtr ret = virDomainLookupByID(conn, id);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err)
+{
+ virDomainPtr ret = virDomainLookupByName(conn, name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err)
+{
+ virDomainPtr ret = virDomainLookupByUUID(conn, uuid);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virDomainPtr
+virDomainLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err)
+{
+ virDomainPtr ret = virDomainLookupByUUIDString(conn, uuidstr);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virDomainRestoreWrapper(virConnectPtr conn,
+ const char *from,
+ virErrorPtr err)
+{
+ int ret = virDomainRestore(conn, from);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virDomainRestoreFlagsWrapper(virConnectPtr conn,
+ const char *from,
+ const char *dxml,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virDomainRestoreFlags(conn, from, dxml, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virDomainSaveImageDefineXMLWrapper(virConnectPtr conn,
+ const char *file,
+ const char *dxml,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virDomainSaveImageDefineXML(conn, file, dxml, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+char *
+virDomainSaveImageGetXMLDescWrapper(virConnectPtr conn,
+ const char *file,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ char * ret = virDomainSaveImageGetXMLDesc(conn, file, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+void
+virDomainStatsRecordListFreeWrapper(virDomainStatsRecordPtr *stats)
+{
+#if LIBVIR_VERSION_NUMBER < 1002008
assert(0); // Caller should have checked version
#else
- return virConnectBaselineHypervisorCPU(conn, emulator, arch, machine, virttype, xmlCPUs, ncpus, flags);
+ virDomainStatsRecordListFree(stats);
#endif
}
-int virConnectCompareHypervisorCPUWrapper(virConnectPtr conn,
- const char *emulator,
- const char *arch,
- const char *machine,
- const char *virttype,
- const char *xmlCPU,
- unsigned int flags)
+
+int
+virGetVersionWrapper(unsigned long *libVer,
+ const char *type,
+ unsigned long *typeVer,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 4004000
+ int ret = virGetVersion(libVer, type, typeVer);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virInterfaceChangeBeginWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virInterfaceChangeBegin(conn, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virInterfaceChangeCommitWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virInterfaceChangeCommit(conn, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virInterfaceChangeRollbackWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virInterfaceChangeRollback(conn, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virInterfacePtr
+virInterfaceDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virInterfacePtr ret = virInterfaceDefineXML(conn, xml, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virInterfacePtr
+virInterfaceLookupByMACStringWrapper(virConnectPtr conn,
+ const char *macstr,
+ virErrorPtr err)
+{
+ virInterfacePtr ret = virInterfaceLookupByMACString(conn, macstr);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virInterfacePtr
+virInterfaceLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err)
+{
+ virInterfacePtr ret = virInterfaceLookupByName(conn, name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNWFilterBindingPtr
+virNWFilterBindingCreateXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err)
+{
+#if LIBVIR_VERSION_NUMBER < 4005000
assert(0); // Caller should have checked version
#else
- return virConnectCompareHypervisorCPU(conn, emulator, arch, machine, virttype, xmlCPU, flags);
+ virNWFilterBindingPtr ret = virNWFilterBindingCreateXML(conn, xml, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-int virNodeGetSEVInfoWrapper(virConnectPtr conn,
- virTypedParameterPtr *params,
- int *nparams,
- unsigned int flags)
+
+virNWFilterBindingPtr
+virNWFilterBindingLookupByPortDevWrapper(virConnectPtr conn,
+ const char *portdev,
+ virErrorPtr err)
{
#if LIBVIR_VERSION_NUMBER < 4005000
assert(0); // Caller should have checked version
#else
- return virNodeGetSEVInfo(conn, params, nparams, flags);
+ virNWFilterBindingPtr ret = virNWFilterBindingLookupByPortDev(conn, portdev);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-int virConnectListAllNWFilterBindingsWrapper(virConnectPtr conn,
- virNWFilterBindingPtr **bindings,
- unsigned int flags)
+
+virNWFilterPtr
+virNWFilterDefineXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 4005000
+ virNWFilterPtr ret = virNWFilterDefineXML(conn, xmlDesc);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNWFilterPtr
+virNWFilterLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err)
+{
+ virNWFilterPtr ret = virNWFilterLookupByName(conn, name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNWFilterPtr
+virNWFilterLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err)
+{
+ virNWFilterPtr ret = virNWFilterLookupByUUID(conn, uuid);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNWFilterPtr
+virNWFilterLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err)
+{
+ virNWFilterPtr ret = virNWFilterLookupByUUIDString(conn, uuidstr);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNetworkPtr
+virNetworkCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ virErrorPtr err)
+{
+ virNetworkPtr ret = virNetworkCreateXML(conn, xmlDesc);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNetworkPtr
+virNetworkDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ virErrorPtr err)
+{
+ virNetworkPtr ret = virNetworkDefineXML(conn, xml);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNetworkPtr
+virNetworkLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err)
+{
+ virNetworkPtr ret = virNetworkLookupByName(conn, name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNetworkPtr
+virNetworkLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err)
+{
+ virNetworkPtr ret = virNetworkLookupByUUID(conn, uuid);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNetworkPtr
+virNetworkLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err)
+{
+ virNetworkPtr ret = virNetworkLookupByUUIDString(conn, uuidstr);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeAllocPagesWrapper(virConnectPtr conn,
+ unsigned int npages,
+ unsigned int *pageSizes,
+ unsigned long long *pageCounts,
+ int startCell,
+ unsigned int cellCount,
+ unsigned int flags,
+ virErrorPtr err)
+{
+#if LIBVIR_VERSION_NUMBER < 1002009
assert(0); // Caller should have checked version
#else
- return virConnectListAllNWFilterBindings(conn, bindings, flags);
+ int ret = virNodeAllocPages(conn, npages, pageSizes, pageCounts, startCell, cellCount, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-virNWFilterBindingPtr virNWFilterBindingCreateXMLWrapper(virConnectPtr conn,
- const char *xml,
- unsigned int flags)
+
+virNodeDevicePtr
+virNodeDeviceCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err)
{
-#if LIBVIR_VERSION_NUMBER < 4005000
+ virNodeDevicePtr ret = virNodeDeviceCreateXML(conn, xmlDesc, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNodeDevicePtr
+virNodeDeviceLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err)
+{
+ virNodeDevicePtr ret = virNodeDeviceLookupByName(conn, name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virNodeDevicePtr
+virNodeDeviceLookupSCSIHostByWWNWrapper(virConnectPtr conn,
+ const char *wwnn,
+ const char *wwpn,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virNodeDevicePtr ret = virNodeDeviceLookupSCSIHostByWWN(conn, wwnn, wwpn, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeGetCPUMapWrapper(virConnectPtr conn,
+ unsigned char **cpumap,
+ unsigned int *online,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeGetCPUMap(conn, cpumap, online, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeGetCPUStatsWrapper(virConnectPtr conn,
+ int cpuNum,
+ virNodeCPUStatsPtr params,
+ int *nparams,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeGetCPUStats(conn, cpuNum, params, nparams, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeGetCellsFreeMemoryWrapper(virConnectPtr conn,
+ unsigned long long *freeMems,
+ int startCell,
+ int maxCells,
+ virErrorPtr err)
+{
+ int ret = virNodeGetCellsFreeMemory(conn, freeMems, startCell, maxCells);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+unsigned long long
+virNodeGetFreeMemoryWrapper(virConnectPtr conn,
+ virErrorPtr err)
+{
+ unsigned long long ret = virNodeGetFreeMemory(conn);
+ if (ret == 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeGetFreePagesWrapper(virConnectPtr conn,
+ unsigned int npages,
+ unsigned int *pages,
+ int startCell,
+ unsigned int cellCount,
+ unsigned long long *counts,
+ unsigned int flags,
+ virErrorPtr err)
+{
+#if LIBVIR_VERSION_NUMBER < 1002006
assert(0); // Caller should have checked version
#else
- return virNWFilterBindingCreateXML(conn, xml, flags);
+ int ret = virNodeGetFreePages(conn, npages, pages, startCell, cellCount, counts, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
-virNWFilterBindingPtr virNWFilterBindingLookupByPortDevWrapper(virConnectPtr conn,
- const char *portdev)
+
+int
+virNodeGetInfoWrapper(virConnectPtr conn,
+ virNodeInfoPtr info,
+ virErrorPtr err)
+{
+ int ret = virNodeGetInfo(conn, info);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeGetMemoryParametersWrapper(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeGetMemoryParameters(conn, params, nparams, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeGetMemoryStatsWrapper(virConnectPtr conn,
+ int cellNum,
+ virNodeMemoryStatsPtr params,
+ int *nparams,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeGetMemoryStats(conn, cellNum, params, nparams, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeGetSEVInfoWrapper(virConnectPtr conn,
+ virTypedParameterPtr *params,
+ int *nparams,
+ unsigned int flags,
+ virErrorPtr err)
{
#if LIBVIR_VERSION_NUMBER < 4005000
assert(0); // Caller should have checked version
#else
- return virNWFilterBindingLookupByPortDev(conn, portdev);
+ int ret = virNodeGetSEVInfo(conn, params, nparams, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+#endif
+}
+
+
+int
+virNodeGetSecurityModelWrapper(virConnectPtr conn,
+ virSecurityModelPtr secmodel,
+ virErrorPtr err)
+{
+ int ret = virNodeGetSecurityModel(conn, secmodel);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeListDevicesWrapper(virConnectPtr conn,
+ const char *cap,
+ char ** const names,
+ int maxnames,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeListDevices(conn, cap, names, maxnames, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeNumOfDevicesWrapper(virConnectPtr conn,
+ const char *cap,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeNumOfDevices(conn, cap, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeSetMemoryParametersWrapper(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeSetMemoryParameters(conn, params, nparams, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+int
+virNodeSuspendForDurationWrapper(virConnectPtr conn,
+ unsigned int target,
+ unsigned long long duration,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ int ret = virNodeSuspendForDuration(conn, target, duration, flags);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virSecretPtr
+virSecretDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virSecretPtr ret = virSecretDefineXML(conn, xml, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virSecretPtr
+virSecretLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err)
+{
+ virSecretPtr ret = virSecretLookupByUUID(conn, uuid);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virSecretPtr
+virSecretLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err)
+{
+ virSecretPtr ret = virSecretLookupByUUIDString(conn, uuidstr);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virSecretPtr
+virSecretLookupByUsageWrapper(virConnectPtr conn,
+ int usageType,
+ const char *usageID,
+ virErrorPtr err)
+{
+ virSecretPtr ret = virSecretLookupByUsage(conn, usageType, usageID);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStoragePoolPtr
+virStoragePoolCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virStoragePoolPtr ret = virStoragePoolCreateXML(conn, xmlDesc, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStoragePoolPtr
+virStoragePoolDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virStoragePoolPtr ret = virStoragePoolDefineXML(conn, xml, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStoragePoolPtr
+virStoragePoolLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err)
+{
+ virStoragePoolPtr ret = virStoragePoolLookupByName(conn, name);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStoragePoolPtr
+virStoragePoolLookupByTargetPathWrapper(virConnectPtr conn,
+ const char *path,
+ virErrorPtr err)
+{
+#if LIBVIR_VERSION_NUMBER < 4001000
+ assert(0); // Caller should have checked version
+#else
+ virStoragePoolPtr ret = virStoragePoolLookupByTargetPath(conn, path);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
#endif
}
+virStoragePoolPtr
+virStoragePoolLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err)
+{
+ virStoragePoolPtr ret = virStoragePoolLookupByUUID(conn, uuid);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStoragePoolPtr
+virStoragePoolLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err)
+{
+ virStoragePoolPtr ret = virStoragePoolLookupByUUIDString(conn, uuidstr);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStorageVolPtr
+virStorageVolLookupByKeyWrapper(virConnectPtr conn,
+ const char *key,
+ virErrorPtr err)
+{
+ virStorageVolPtr ret = virStorageVolLookupByKey(conn, key);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStorageVolPtr
+virStorageVolLookupByPathWrapper(virConnectPtr conn,
+ const char *path,
+ virErrorPtr err)
+{
+ virStorageVolPtr ret = virStorageVolLookupByPath(conn, path);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+virStreamPtr
+virStreamNewWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err)
+{
+ virStreamPtr ret = virStreamNew(conn, flags);
+ if (!ret) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+////////////////////////////////////////////////
*/
import "C"
diff --git a/connect_wrapper.h b/connect_wrapper.h
index 726d29c..e91811f 100644
--- a/connect_wrapper.h
+++ b/connect_wrapper.h
@@ -41,21 +41,82 @@ virConnectRegisterCloseCallbackHelper(virConnectPtr c,
virConnectCloseFunc cb,
long goCallbackId);
-virConnectPtr
-virConnectOpenAuthWrapper(const char *name,
- int *credtype,
- uint ncredtype,
- int callbackID,
- unsigned int flags);
+char *
+virConnectBaselineCPUWrapper(virConnectPtr conn,
+ const char **xmlCPUs,
+ unsigned int ncpus,
+ unsigned int flags,
+ virErrorPtr err);
+
+char *
+virConnectBaselineHypervisorCPUWrapper(virConnectPtr conn,
+ const char *emulator,
+ const char *arch,
+ const char *machine,
+ const char *virttype,
+ const char **xmlCPUs,
+ unsigned int ncpus,
+ unsigned int flags,
+ virErrorPtr err);
int
-virNodeGetFreePagesWrapper(virConnectPtr conn,
- unsigned int npages,
- unsigned int *pages,
- int startcell,
- unsigned int cellcount,
- unsigned long long *counts,
- unsigned int flags);
+virConnectCloseWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectCompareCPUWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectCompareHypervisorCPUWrapper(virConnectPtr conn,
+ const char *emulator,
+ const char *arch,
+ const char *machine,
+ const char *virttype,
+ const char *xmlCPU,
+ unsigned int flags,
+ virErrorPtr err);
+
+char *
+virConnectDomainXMLFromNativeWrapper(virConnectPtr conn,
+ const char *nativeFormat,
+ const char *nativeConfig,
+ unsigned int flags,
+ virErrorPtr err);
+
+char *
+virConnectDomainXMLToNativeWrapper(virConnectPtr conn,
+ const char *nativeFormat,
+ const char *domainXml,
+ unsigned int flags,
+ virErrorPtr err);
+
+char *
+virConnectFindStoragePoolSourcesWrapper(virConnectPtr conn,
+ const char *type,
+ const char *srcSpec,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectGetAllDomainStatsWrapper(virConnectPtr conn,
+ unsigned int stats,
+ virDomainStatsRecordPtr **retStats,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectGetCPUModelNamesWrapper(virConnectPtr conn,
+ const char *arch,
+ char ***models,
+ unsigned int flags,
+ virErrorPtr err);
+
+char *
+virConnectGetCapabilitiesWrapper(virConnectPtr conn,
+ virErrorPtr err);
char *
virConnectGetDomainCapabilitiesWrapper(virConnectPtr conn,
@@ -63,24 +124,415 @@ virConnectGetDomainCapabilitiesWrapper(virConnectPtr conn,
const char *arch,
const char *machine,
const char *virttype,
- unsigned int flags);
+ unsigned int flags,
+ virErrorPtr err);
+
+char *
+virConnectGetHostnameWrapper(virConnectPtr conn,
+ virErrorPtr err);
int
-virConnectGetAllDomainStatsWrapper(virConnectPtr conn,
- unsigned int stats,
- virDomainStatsRecordPtr **retStats,
- unsigned int flags);
+virConnectGetLibVersionWrapper(virConnectPtr conn,
+ unsigned long *libVer,
+ virErrorPtr err);
int
+virConnectGetMaxVcpusWrapper(virConnectPtr conn,
+ const char *type,
+ virErrorPtr err);
+
+char *
+virConnectGetSysinfoWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err);
+const char *
+virConnectGetTypeWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+char *
+virConnectGetURIWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectGetVersionWrapper(virConnectPtr conn,
+ unsigned long *hvVer,
+ virErrorPtr err);
+
+int
+virConnectIsAliveWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectIsEncryptedWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectIsSecureWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectListAllDomainsWrapper(virConnectPtr conn,
+ virDomainPtr **domains,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListAllInterfacesWrapper(virConnectPtr conn,
+ virInterfacePtr **ifaces,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListAllNWFilterBindingsWrapper(virConnectPtr conn,
+ virNWFilterBindingPtr **bindings,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListAllNWFiltersWrapper(virConnectPtr conn,
+ virNWFilterPtr **filters,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListAllNetworksWrapper(virConnectPtr conn,
+ virNetworkPtr **nets,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListAllNodeDevicesWrapper(virConnectPtr conn,
+ virNodeDevicePtr **devices,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListAllSecretsWrapper(virConnectPtr conn,
+ virSecretPtr **secrets,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListAllStoragePoolsWrapper(virConnectPtr conn,
+ virStoragePoolPtr **pools,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virConnectListDefinedDomainsWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectListDefinedInterfacesWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectListDefinedNetworksWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectListDefinedStoragePoolsWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectListDomainsWrapper(virConnectPtr conn,
+ int *ids,
+ int maxids,
+ virErrorPtr err);
+
+int
+virConnectListInterfacesWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectListNWFiltersWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectListNetworksWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectListSecretsWrapper(virConnectPtr conn,
+ char **uuids,
+ int maxuuids,
+ virErrorPtr err);
+
+int
+virConnectListStoragePoolsWrapper(virConnectPtr conn,
+ char **const names,
+ int maxnames,
+ virErrorPtr err);
+
+int
+virConnectNumOfDefinedDomainsWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfDefinedInterfacesWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfDefinedNetworksWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfDefinedStoragePoolsWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfDomainsWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfInterfacesWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfNWFiltersWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfNetworksWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfSecretsWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectNumOfStoragePoolsWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+virConnectPtr
+virConnectOpenWrapper(const char *name,
+ virErrorPtr err);
+
+virConnectPtr
+virConnectOpenAuthWrapper(const char *name,
+ int *credtype,
+ uint ncredtype,
+ int callbackID,
+ unsigned int flags,
+ virErrorPtr err);
+
+virConnectPtr
+virConnectOpenReadOnlyWrapper(const char *name,
+ virErrorPtr err);
+
+int
+virConnectRefWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virConnectRegisterCloseCallbackWrapper(virConnectPtr conn,
+ long goCallbackId,
+ virErrorPtr err);
+
+int
+virConnectSetKeepAliveWrapper(virConnectPtr conn,
+ int interval,
+ unsigned int count,
+ virErrorPtr err);
+
+int
+virConnectUnregisterCloseCallbackWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainCreateLinuxWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainCreateXMLWithFilesWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int nfiles,
+ int *files,
+ unsigned int flags,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainDefineXMLFlagsWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
virDomainListGetStatsWrapper(virDomainPtr *doms,
unsigned int stats,
virDomainStatsRecordPtr **retStats,
- unsigned int flags);
+ unsigned int flags,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainLookupByIDWrapper(virConnectPtr conn,
+ int id,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err);
+
+virDomainPtr
+virDomainLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err);
+
+int
+virDomainRestoreWrapper(virConnectPtr conn,
+ const char *from,
+ virErrorPtr err);
+
+int
+virDomainRestoreFlagsWrapper(virConnectPtr conn,
+ const char *from,
+ const char *dxml,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virDomainSaveImageDefineXMLWrapper(virConnectPtr conn,
+ const char *file,
+ const char *dxml,
+ unsigned int flags,
+ virErrorPtr err);
+
+char *
+virDomainSaveImageGetXMLDescWrapper(virConnectPtr conn,
+ const char *file,
+ unsigned int flags,
+ virErrorPtr err);
void
virDomainStatsRecordListFreeWrapper(virDomainStatsRecordPtr *stats);
+int
+virGetVersionWrapper(unsigned long *libVer,
+ const char *type,
+ unsigned long *typeVer,
+ virErrorPtr err);
+
+int
+virInterfaceChangeBeginWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virInterfaceChangeCommitWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virInterfaceChangeRollbackWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err);
+
+virInterfacePtr
+virInterfaceDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err);
+
+virInterfacePtr
+virInterfaceLookupByMACStringWrapper(virConnectPtr conn,
+ const char *macstr,
+ virErrorPtr err);
+
+virInterfacePtr
+virInterfaceLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err);
+
+virNWFilterBindingPtr
+virNWFilterBindingCreateXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err);
+
+virNWFilterBindingPtr
+virNWFilterBindingLookupByPortDevWrapper(virConnectPtr conn,
+ const char *portdev,
+ virErrorPtr err);
+
+virNWFilterPtr
+virNWFilterDefineXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ virErrorPtr err);
+
+virNWFilterPtr
+virNWFilterLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err);
+
+virNWFilterPtr
+virNWFilterLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err);
+
+virNWFilterPtr
+virNWFilterLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err);
+
+virNetworkPtr
+virNetworkCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ virErrorPtr err);
+
+virNetworkPtr
+virNetworkDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ virErrorPtr err);
+
+virNetworkPtr
+virNetworkLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err);
+
+virNetworkPtr
+virNetworkLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err);
+
+virNetworkPtr
+virNetworkLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err);
+
int
virNodeAllocPagesWrapper(virConnectPtr conn,
unsigned int npages,
@@ -88,54 +540,191 @@ virNodeAllocPagesWrapper(virConnectPtr conn,
unsigned long long *pageCounts,
int startCell,
unsigned int cellCount,
- unsigned int flags);
+ unsigned int flags,
+ virErrorPtr err);
-virDomainPtr
-virDomainDefineXMLFlagsWrapper(virConnectPtr conn,
- const char *xml,
- unsigned int flags);
+virNodeDevicePtr
+virNodeDeviceCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err);
-virStoragePoolPtr
-virStoragePoolLookupByTargetPathWrapper(virConnectPtr conn,
- const char *path);
+virNodeDevicePtr
+virNodeDeviceLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err);
-char *
-virConnectBaselineHypervisorCPUWrapper(virConnectPtr conn,
- const char *emulator,
- const char *arch,
- const char *machine,
- const char *virttype,
- const char **xmlCPUs,
- unsigned int ncpus,
- unsigned int flags);
+virNodeDevicePtr
+virNodeDeviceLookupSCSIHostByWWNWrapper(virConnectPtr conn,
+ const char *wwnn,
+ const char *wwpn,
+ unsigned int flags,
+ virErrorPtr err);
int
-virConnectCompareHypervisorCPUWrapper(virConnectPtr conn,
- const char *emulator,
- const char *arch,
- const char *machine,
- const char *virttype,
- const char *xmlCPU,
- unsigned int flags);
+virNodeGetCPUMapWrapper(virConnectPtr conn,
+ unsigned char **cpumap,
+ unsigned int *online,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virNodeGetCPUStatsWrapper(virConnectPtr conn,
+ int cpuNum,
+ virNodeCPUStatsPtr params,
+ int *nparams,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virNodeGetCellsFreeMemoryWrapper(virConnectPtr conn,
+ unsigned long long *freeMems,
+ int startCell,
+ int maxCells,
+ virErrorPtr err);
+
+unsigned long long
+virNodeGetFreeMemoryWrapper(virConnectPtr conn,
+ virErrorPtr err);
+
+int
+virNodeGetFreePagesWrapper(virConnectPtr conn,
+ unsigned int npages,
+ unsigned int *pages,
+ int startCell,
+ unsigned int cellCount,
+ unsigned long long *counts,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virNodeGetInfoWrapper(virConnectPtr conn,
+ virNodeInfoPtr info,
+ virErrorPtr err);
+
+int
+virNodeGetMemoryParametersWrapper(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virNodeGetMemoryStatsWrapper(virConnectPtr conn,
+ int cellNum,
+ virNodeMemoryStatsPtr params,
+ int *nparams,
+ unsigned int flags,
+ virErrorPtr err);
int
virNodeGetSEVInfoWrapper(virConnectPtr conn,
virTypedParameterPtr *params,
int *nparams,
- unsigned int flags);
+ unsigned int flags,
+ virErrorPtr err);
int
-virConnectListAllNWFilterBindingsWrapper(virConnectPtr conn,
- virNWFilterBindingPtr **bindings,
- unsigned int flags);
+virNodeGetSecurityModelWrapper(virConnectPtr conn,
+ virSecurityModelPtr secmodel,
+ virErrorPtr err);
-virNWFilterBindingPtr
-virNWFilterBindingCreateXMLWrapper(virConnectPtr conn,
- const char *xml,
- unsigned int flags);
+int
+virNodeListDevicesWrapper(virConnectPtr conn,
+ const char *cap,
+ char **const names,
+ int maxnames,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virNodeNumOfDevicesWrapper(virConnectPtr conn,
+ const char *cap,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virNodeSetMemoryParametersWrapper(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags,
+ virErrorPtr err);
+
+int
+virNodeSuspendForDurationWrapper(virConnectPtr conn,
+ unsigned int target,
+ unsigned long long duration,
+ unsigned int flags,
+ virErrorPtr err);
+
+virSecretPtr
+virSecretDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err);
+
+virSecretPtr
+virSecretLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err);
+
+virSecretPtr
+virSecretLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err);
+
+virSecretPtr
+virSecretLookupByUsageWrapper(virConnectPtr conn,
+ int usageType,
+ const char *usageID,
+ virErrorPtr err);
+
+virStoragePoolPtr
+virStoragePoolCreateXMLWrapper(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags,
+ virErrorPtr err);
+
+virStoragePoolPtr
+virStoragePoolDefineXMLWrapper(virConnectPtr conn,
+ const char *xml,
+ unsigned int flags,
+ virErrorPtr err);
+
+virStoragePoolPtr
+virStoragePoolLookupByNameWrapper(virConnectPtr conn,
+ const char *name,
+ virErrorPtr err);
+
+virStoragePoolPtr
+virStoragePoolLookupByTargetPathWrapper(virConnectPtr conn,
+ const char *path,
+ virErrorPtr err);
+
+virStoragePoolPtr
+virStoragePoolLookupByUUIDWrapper(virConnectPtr conn,
+ const unsigned char *uuid,
+ virErrorPtr err);
+
+virStoragePoolPtr
+virStoragePoolLookupByUUIDStringWrapper(virConnectPtr conn,
+ const char *uuidstr,
+ virErrorPtr err);
+
+virStorageVolPtr
+virStorageVolLookupByKeyWrapper(virConnectPtr conn,
+ const char *key,
+ virErrorPtr err);
+
+virStorageVolPtr
+virStorageVolLookupByPathWrapper(virConnectPtr conn,
+ const char *path,
+ virErrorPtr err);
+
+virStreamPtr
+virStreamNewWrapper(virConnectPtr conn,
+ unsigned int flags,
+ virErrorPtr err);
-virNWFilterBindingPtr
-virNWFilterBindingLookupByPortDevWrapper(virConnectPtr conn,
- const char *portdev);
#endif /* LIBVIRT_GO_CONNECT_WRAPPER_H__ */
diff --git a/error_test.go b/error_test.go
deleted file mode 100644
index c2ea462..0000000
--- a/error_test.go
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * 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 Red Hat, Inc.
- *
- */
-
-package libvirt
-
-import (
- "reflect"
- "testing"
-)
-
-func TestGetLastError(t *testing.T) {
- _, err := NewConnect("invalid_transport:///default")
- if err == nil {
- t.Fatalf("Expected an error when creating invalid connection")
- }
- got := GetLastError()
- expected := Error{0, 0, "Missing error", 0}
- if !reflect.DeepEqual(got, expected) {
- t.Errorf("Expected error %+v, got %+v", expected, got)
- }
-}
--
2.17.1
More information about the libvir-list
mailing list