7:16 a.m.
Go 1.12 breaks our current typed parameter handling as it appears to be
deciding some various are no longer live & free'ing them. Mixing go
allocated memory with C API calls often trips with this kind of thing.
This series thus changes the code to use C allocated memory for typed
parameter arrays and use the libvirt APIs where possible.
I'm not sure if anyone on list feels like reviewing this Go code or not.
Most of the time I've just pushed Go changes directly, but I figure putting
it out for review might help people spread the knowledge of the Go
bindings
Daniel P. Berrangé (8):
Fix GetGuestVcpus to actually return some data
Add missing error reporting when setting typed parameters
Change typedParamsPackNew to use a C allocated array
Switch typedParamsUnpackLen to use accessor methods
Use 'cnparams' for virTypedParameters array length variables
Simplify setting of typed parameters
Switch remaining typed parameter code to use C allocs
Rename typedParamsUnpackLen to typedParamsUnpack
connect.go | 81 ++++----
domain.go | 429 +++++++++++++++++------------------------
domain_events.go | 20 +-
typedparams.go | 295 ++++++++++++----------------
typedparams_test.go | 8 +-
typedparams_wrapper.go | 240 +++++++++++++++++++++++
typedparams_wrapper.h | 126 ++++++++++++
7 files changed, 721 insertions(+), 478 deletions(-)
create mode 100644 typedparams_wrapper.go
create mode 100644 typedparams_wrapper.h
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 1/8] Fix GetGuestVcpus to actually return some data
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
domain.go | 45 +++++++++++++++++++++++++++++++++++----------
1 file changed, 35 insertions(+), 10 deletions(-)
diff --git a/domain.go b/domain.go
index ed10553..07b9697 100644
--- a/domain.go
+++ b/domain.go
@@ -4522,23 +4522,26 @@ func (d *Domain) SaveFlags(destFile string, destXml string, flags
DomainSaveRest
}
type DomainGuestVcpus struct {
- Vcpus []bool
- Online []bool
- Offlinable []bool
+ VcpusSet bool
+ Vcpus []bool
+ OnlineSet bool
+ Online []bool
+ OfflinableSet bool
+ Offlinable []bool
}
-func getDomainGuestVcpusParametersFieldInfo(VcpusSet *bool, Vcpus *string, OnlineSet
*bool, Online *string, OfflinableSet *bool, Offlinable *string)
map[string]typedParamsFieldInfo {
+func getDomainGuestVcpusParametersFieldInfo(vcpus *DomainGuestVcpus, Vcpus *string,
Online *string, Offlinable *string) map[string]typedParamsFieldInfo {
return map[string]typedParamsFieldInfo{
"vcpus": typedParamsFieldInfo{
- set: VcpusSet,
+ set: &vcpus.VcpusSet,
s: Vcpus,
},
"online": typedParamsFieldInfo{
- set: OnlineSet,
+ set: &vcpus.OnlineSet,
s: Online,
},
"offlinable": typedParamsFieldInfo{
- set: OfflinableSet,
+ set: &vcpus.OfflinableSet,
s: Offlinable,
},
}
@@ -4607,9 +4610,9 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*DomainGuestVcpus,
error) {
return nil, makeNotImplementedError("virDomainGetGuestVcpus")
}
- var VcpusSet, OnlineSet, OfflinableSet bool
+ vcpus := &DomainGuestVcpus{}
var VcpusStr, OnlineStr, OfflinableStr string
- info := getDomainGuestVcpusParametersFieldInfo(&VcpusSet, &VcpusStr,
&OnlineSet, &OnlineStr, &OfflinableSet, &OfflinableStr)
+ info := getDomainGuestVcpusParametersFieldInfo(vcpus, &VcpusStr, &OnlineStr,
&OfflinableStr)
var cparams C.virTypedParameterPtr
var nparams C.uint
@@ -4626,7 +4629,29 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*DomainGuestVcpus,
error) {
return nil, gerr
}
- return &DomainGuestVcpus{}, nil
+ if vcpus.VcpusSet {
+ mask, gerr := parseCPUString(VcpusStr)
+ if gerr != nil {
+ return nil, gerr
+ }
+ vcpus.Vcpus = mask
+ }
+ if vcpus.OnlineSet {
+ mask, gerr := parseCPUString(OnlineStr)
+ if gerr != nil {
+ return nil, gerr
+ }
+ vcpus.Online = mask
+ }
+ if vcpus.OfflinableSet {
+ mask, gerr := parseCPUString(OfflinableStr)
+ if gerr != nil {
+ return nil, gerr
+ }
+ vcpus.Offlinable = mask
+ }
+
+ return vcpus, nil
}
// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetGuestVcpus
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 2/8] Add missing error reporting when setting typed parameters
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
connect.go | 3 +++
domain.go | 24 ++++++++++++++++++++++++
2 files changed, 27 insertions(+)
diff --git a/connect.go b/connect.go
index 8cc7cc7..5044def 100644
--- a/connect.go
+++ b/connect.go
@@ -2017,6 +2017,9 @@ func (c *Connect) SetMemoryParameters(params *NodeMemoryParameters,
flags uint32
}
ret = C.virNodeSetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
diff --git a/domain.go b/domain.go
index 07b9697..b39de47 100644
--- a/domain.go
+++ b/domain.go
@@ -1312,6 +1312,9 @@ func (d *Domain) SetInterfaceParameters(device string, params
*DomainInterfacePa
}
ret = C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
@@ -2658,6 +2661,9 @@ func (d *Domain) SetBlkioParameters(params *DomainBlkioParameters,
flags DomainM
}
ret = C.virDomainSetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
@@ -2850,6 +2856,9 @@ func (d *Domain) SetBlockIoTune(disk string, params
*DomainBlockIoTuneParameters
}
ret = C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
@@ -3330,6 +3339,9 @@ func (d *Domain) SetMemoryParameters(params *DomainMemoryParameters,
flags Domai
}
ret = C.virDomainSetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
@@ -3408,6 +3420,9 @@ func (d *Domain) SetNumaParameters(params *DomainNumaParameters,
flags DomainMod
}
ret = C.virDomainSetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
@@ -3605,6 +3620,9 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEvents, flags
DomainModificatio
}
ret = C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(flags), &err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
@@ -3799,6 +3817,9 @@ func (d *Domain) SetSchedulerParameters(params
*DomainSchedulerParameters) error
}
ret = C.virDomainSetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, &err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
@@ -3832,6 +3853,9 @@ func (d *Domain) SetSchedulerParametersFlags(params
*DomainSchedulerParameters,
}
ret = C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ if ret == -1 {
+ return makeError(&err)
+ }
return nil
}
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 3/8] Change typedParamsPackNew to use a C allocated array
Stop mixing Go allocated memory with C operations for typed parameters
and exclusively rely on C allocated memory. This greatly reduces the
number of type casts giving clearer code.
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
domain.go | 28 ++++-----
typedparams.go | 87 ++++++++++++++------------
typedparams_test.go | 8 ++-
typedparams_wrapper.go | 139 +++++++++++++++++++++++++++++++++++++++++
typedparams_wrapper.h | 82 ++++++++++++++++++++++++
5 files changed, 285 insertions(+), 59 deletions(-)
create mode 100644 typedparams_wrapper.go
create mode 100644 typedparams_wrapper.h
diff --git a/domain.go b/domain.go
index b39de47..8f7f030 100644
--- a/domain.go
+++ b/domain.go
@@ -2104,16 +2104,15 @@ func (d *Domain) BlockCopy(disk string, destxml string, params
*DomainBlockCopyP
info := getBlockCopyParameterFieldInfo(params)
- cparams, gerr := typedParamsPackNew(info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- nparams := len(*cparams)
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])),
C.int(nparams))
+ defer C.virTypedParamsFree(cparams, cnparams)
var err C.virError
- ret := C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml,
(*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.uint(flags),
&err)
+ ret := C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml, cparams, cnparams,
C.uint(flags), &err)
if ret == -1 {
return makeError(&err)
}
@@ -2375,16 +2374,15 @@ func getMigrateParameterFieldInfo(params *DomainMigrateParameters)
map[string]ty
func (d *Domain) Migrate3(dconn *Connect, params *DomainMigrateParameters, flags
DomainMigrateFlags) (*Domain, error) {
info := getMigrateParameterFieldInfo(params)
- cparams, gerr := typedParamsPackNew(info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return nil, gerr
}
- nparams := len(*cparams)
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])),
C.int(nparams))
+ defer C.virTypedParamsFree(cparams, cnparams)
var err C.virError
- ret := C.virDomainMigrate3Wrapper(d.ptr, dconn.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams),
C.uint(flags), &err)
+ ret := C.virDomainMigrate3Wrapper(d.ptr, dconn.ptr, cparams, C.uint(cnparams),
C.uint(flags), &err)
if ret == nil {
return nil, makeError(&err)
}
@@ -2455,16 +2453,15 @@ func (d *Domain) MigrateToURI3(dconnuri string, params
*DomainMigrateParameters,
}
info := getMigrateParameterFieldInfo(params)
- cparams, gerr := typedParamsPackNew(info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- nparams := len(*cparams)
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])),
C.int(nparams))
+ defer C.virTypedParamsFree(cparams, cnparams)
var err C.virError
- ret := C.virDomainMigrateToURI3Wrapper(d.ptr, cdconnuri,
(*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams),
C.uint(flags), &err)
+ ret := C.virDomainMigrateToURI3Wrapper(d.ptr, cdconnuri, cparams, C.uint(cnparams),
C.uint(flags), &err)
if ret == -1 {
return makeError(&err)
}
@@ -4272,16 +4269,15 @@ func (d *Domain) SetIOThreadParams(iothreadid uint, params
*DomainSetIOThreadPar
}
info := getSetIOThreadParamsFieldInfo(params)
- cparams, gerr := typedParamsPackNew(info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- nparams := len(*cparams)
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])),
C.int(nparams))
+ defer C.virTypedParamsFree(cparams, cnparams)
var err C.virError
- ret := C.virDomainSetIOThreadParamsWrapper(d.ptr, C.uint(iothreadid),
(*C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.uint(flags),
&err)
+ ret := C.virDomainSetIOThreadParamsWrapper(d.ptr, C.uint(iothreadid), cparams, cnparams,
C.uint(flags), &err)
if ret == -1 {
return makeError(&err)
}
diff --git a/typedparams.go b/typedparams.go
index e8ceae0..a1bdffd 100644
--- a/typedparams.go
+++ b/typedparams.go
@@ -32,6 +32,7 @@ package libvirt
#include <libvirt/virterror.h>
#include <stdlib.h>
#include <string.h>
+#include "typedparams_wrapper.h"
*/
import "C"
@@ -197,66 +198,70 @@ func typedParamsPack(cparams []C.virTypedParameter, infomap
map[string]typedPara
return typedParamsPackLen(&cparams[0], len(cparams), infomap)
}
-func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*[]C.virTypedParameter,
error) {
- nparams := 0
- for _, value := range infomap {
- if !*value.set {
- continue
- }
+func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*C.virTypedParameter,
C.int, error) {
+ var cparams C.virTypedParameterPtr
+ var nparams C.int
+ var maxparams C.int
- if value.sl != nil {
- nparams += len(*value.sl)
- } else {
- nparams++
- }
- }
+ defer C.virTypedParamsFree(cparams, nparams)
- cparams := make([]C.virTypedParameter, nparams)
- nparams = 0
- for key, value := range infomap {
+ for name, value := range infomap {
if !*value.set {
continue
}
- cfield := C.CString(key)
- defer C.free(unsafe.Pointer(cfield))
- clen := len(key) + 1
- if clen > C.VIR_TYPED_PARAM_FIELD_LENGTH {
- clen = C.VIR_TYPED_PARAM_FIELD_LENGTH
- }
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
if value.sl != nil {
+ /* We're not actually using virTypedParamsAddStringList, as it is
+ * easier to avoid creating a 'char **' in Go to hold all the strings.
+ * We none the less do a version check, because earlier libvirts
+ * would not expect to see multiple string values in a typed params
+ * list with the same field name
+ */
+ if C.LIBVIR_VERSION_NUMBER < 1002017 {
+ return nil, 0, makeNotImplementedError("virTypedParamsAddStringList")
+ }
for i := 0; i < len(*value.sl); i++ {
- cparam := &cparams[nparams]
- cparam._type = C.VIR_TYPED_PARAM_STRING
- C.memcpy(unsafe.Pointer(&cparam.field[0]), unsafe.Pointer(cfield),
C.size_t(clen))
- nparams++
+ cvalue := C.CString((*value.sl)[i])
+ defer C.free(unsafe.Pointer(cvalue))
+ var err C.virError
+ ret := C.virTypedParamsAddStringWrapper(&cparams, &nparams, &maxparams,
cname, cvalue, &err)
+ if ret < 0 {
+ return nil, 0, makeError(&err)
+ }
}
} else {
- cparam := &cparams[nparams]
+ var err C.virError
+ var ret C.int
if value.i != nil {
- cparam._type = C.VIR_TYPED_PARAM_INT
+ ret = C.virTypedParamsAddIntWrapper(&cparams, &nparams, &maxparams,
cname, C.int(*value.i), &err)
} else if value.ui != nil {
- cparam._type = C.VIR_TYPED_PARAM_UINT
+ ret = C.virTypedParamsAddUIntWrapper(&cparams, &nparams, &maxparams,
cname, C.uint(*value.ui), &err)
} else if value.l != nil {
- cparam._type = C.VIR_TYPED_PARAM_LLONG
+ ret = C.virTypedParamsAddLLongWrapper(&cparams, &nparams, &maxparams,
cname, C.longlong(*value.l), &err)
} else if value.ul != nil {
- cparam._type = C.VIR_TYPED_PARAM_ULLONG
+ ret = C.virTypedParamsAddULLongWrapper(&cparams, &nparams, &maxparams,
cname, C.ulonglong(*value.ul), &err)
} else if value.b != nil {
- cparam._type = C.VIR_TYPED_PARAM_BOOLEAN
+ v := 0
+ if *value.b {
+ v = 1
+ }
+ ret = C.virTypedParamsAddBooleanWrapper(&cparams, &nparams, &maxparams,
cname, C.int(v), &err)
} else if value.d != nil {
- cparam._type = C.VIR_TYPED_PARAM_DOUBLE
+ ret = C.virTypedParamsAddDoubleWrapper(&cparams, &nparams, &maxparams,
cname, C.double(*value.i), &err)
} else if value.s != nil {
- cparam._type = C.VIR_TYPED_PARAM_STRING
+ cvalue := C.CString(*value.s)
+ defer C.free(unsafe.Pointer(cvalue))
+ ret = C.virTypedParamsAddStringWrapper(&cparams, &nparams, &maxparams,
cname, cvalue, &err)
+ } else {
+ return nil, 0, fmt.Errorf("No typed parameter value set for field
'%s'", name)
+ }
+ if ret < 0 {
+ return nil, 0, makeError(&err)
}
- C.memcpy(unsafe.Pointer(&cparam.field[0]), unsafe.Pointer(cfield),
C.size_t(clen))
- nparams++
}
}
- err := typedParamsPack(cparams, infomap)
- if err != nil {
- C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
C.int(nparams))
- return nil, err
- }
- return &cparams, nil
+ return cparams, nparams, nil
}
diff --git a/typedparams_test.go b/typedparams_test.go
index 8bc980a..ff3783b 100644
--- a/typedparams_test.go
+++ b/typedparams_test.go
@@ -77,12 +77,16 @@ func TestPackUnpack(t *testing.T) {
sl: &got3,
}
- params, err := typedParamsPackNew(infoin)
+ params, nparams, err := typedParamsPackNew(infoin)
if err != nil {
+ lverr, ok := err.(Error)
+ if ok && lverr.Code == ERR_NO_SUPPORT {
+ return
+ }
t.Fatal(err)
}
- nout, err := typedParamsUnpack(*params, infoout)
+ nout, err := typedParamsUnpackLen(params, int(nparams), infoout)
if err != nil {
t.Fatal(err)
}
diff --git a/typedparams_wrapper.go b/typedparams_wrapper.go
new file mode 100644
index 0000000..c0248ce
--- /dev/null
+++ b/typedparams_wrapper.go
@@ -0,0 +1,139 @@
+/*
+ * This file is part of the libvirt-go project
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ */
+
+package libvirt
+
+/*
+#cgo pkg-config: libvirt
+#include <assert.h>
+#include "typedparams_wrapper.h"
+
+int
+virTypedParamsAddIntWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ int value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsAddInt(params, nparams, maxparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsAddUIntWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ unsigned int value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsAddUInt(params, nparams, maxparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsAddLLongWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ long long value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsAddLLong(params, nparams, maxparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsAddULLongWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ unsigned long long value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsAddULLong(params, nparams, maxparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsAddDoubleWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ double value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsAddDouble(params, nparams, maxparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsAddBooleanWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ int value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsAddBoolean(params, nparams, maxparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsAddStringWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ const char *value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsAddString(params, nparams, maxparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+*/
+import "C"
diff --git a/typedparams_wrapper.h b/typedparams_wrapper.h
new file mode 100644
index 0000000..d2ef7d6
--- /dev/null
+++ b/typedparams_wrapper.h
@@ -0,0 +1,82 @@
+/*
+ * This file is part of the libvirt-go project
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ */
+
+#ifndef LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__
+#define LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__
+
+#include <libvirt/libvirt.h>
+#include <libvirt/virterror.h>
+
+int
+virTypedParamsAddIntWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ int value,
+ virErrorPtr err);
+int
+virTypedParamsAddUIntWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ unsigned int value,
+ virErrorPtr err);
+int
+virTypedParamsAddLLongWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ long long value,
+ virErrorPtr err);
+int
+virTypedParamsAddULLongWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ unsigned long long value,
+ virErrorPtr err);
+int
+virTypedParamsAddDoubleWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ double value,
+ virErrorPtr err);
+int
+virTypedParamsAddBooleanWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ int value,
+ virErrorPtr err);
+int
+virTypedParamsAddStringWrapper(virTypedParameterPtr *params,
+ int *nparams,
+ int *maxparams,
+ const char *name,
+ const char *value,
+ virErrorPtr err);
+
+#endif /* LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ */
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 4/8] Switch typedParamsUnpackLen to use accessor methods
Stop playing games accessing struct fields directly from go and call the
supported libvirt APIs instead. This makes the code clearer and safer
from Go.
The string list code still needs direct pointer games, since libvirt
does not expose any virTypedParamsGetStringList() method, as none of its
APIs actually require this feature yet. The Go binding still wants this
impl at least for the test suite in order to validate the packing of
string lists.
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
connect.go | 18 +++---
domain.go | 8 +--
domain_events.go | 10 ++--
typedparams.go | 128 ++++++++++++++++++++++-------------------
typedparams_test.go | 2 +-
typedparams_wrapper.go | 101 ++++++++++++++++++++++++++++++++
typedparams_wrapper.h | 44 ++++++++++++++
7 files changed, 233 insertions(+), 78 deletions(-)
diff --git a/connect.go b/connect.go
index 5044def..e2ff88a 100644
--- a/connect.go
+++ b/connect.go
@@ -2811,7 +2811,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
state := &DomainStatsState{}
stateInfo := getDomainStatsStateFieldInfo(state)
- count, gerr := typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams),
stateInfo)
+ count, gerr := typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, stateInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2822,7 +2822,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
cpu := &DomainStatsCPU{}
cpuInfo := getDomainStatsCPUFieldInfo(cpu)
- count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), cpuInfo)
+ count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, cpuInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2833,7 +2833,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
balloon := &DomainStatsBalloon{}
balloonInfo := getDomainStatsBalloonFieldInfo(balloon)
- count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams),
balloonInfo)
+ count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, balloonInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2844,7 +2844,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
perf := &DomainStatsPerf{}
perfInfo := getDomainStatsPerfFieldInfo(perf)
- count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams), perfInfo)
+ count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, perfInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2855,7 +2855,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
lengths := domainStatsLengths{}
lengthsInfo := getDomainStatsLengthsFieldInfo(&lengths)
- count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams),
lengthsInfo)
+ count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, lengthsInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2871,7 +2871,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
vcpu := DomainStatsVcpu{}
vcpuInfo := getDomainStatsVcpuFieldInfo(j, &vcpu)
- count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams),
vcpuInfo)
+ count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, vcpuInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2889,7 +2889,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
block := DomainStatsBlock{}
blockInfo := getDomainStatsBlockFieldInfo(j, &block)
- count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams),
blockInfo)
+ count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, blockInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2905,7 +2905,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
net := DomainStatsNet{}
netInfo := getDomainStatsNetFieldInfo(j, &net)
- count, gerr = typedParamsUnpackLen(cdomstats.params, int(cdomstats.nparams),
netInfo)
+ count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, netInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2977,7 +2977,7 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSEVParameters,
error) {
defer C.virTypedParamsFree(cparams, nparams)
- _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
+ _, gerr := typedParamsUnpackLen(cparams, nparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/domain.go b/domain.go
index 8f7f030..09d6a71 100644
--- a/domain.go
+++ b/domain.go
@@ -3207,7 +3207,7 @@ func (d *Domain) GetJobStats(flags DomainGetJobStatsFlags)
(*DomainJobInfo, erro
params := DomainJobInfo{}
info := getDomainJobInfoFieldInfo(¶ms)
- _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
+ _, gerr := typedParamsUnpackLen(cparams, nparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3585,7 +3585,7 @@ func (d *Domain) GetPerfEvents(flags DomainModificationImpact)
(*DomainPerfEvent
defer C.virTypedParamsFree(cparams, nparams)
- _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
+ _, gerr := typedParamsUnpackLen(cparams, nparams, info)
if gerr != nil {
return nil, gerr
}
@@ -4644,7 +4644,7 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*DomainGuestVcpus,
error) {
defer C.virTypedParamsFree(cparams, C.int(nparams))
- _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
+ _, gerr := typedParamsUnpackLen(cparams, C.int(nparams), info)
if gerr != nil {
return nil, gerr
}
@@ -4861,7 +4861,7 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32)
(*DomainLaunchSecurityParam
defer C.virTypedParamsFree(cparams, nparams)
- _, gerr := typedParamsUnpackLen(cparams, int(nparams), info)
+ _, gerr := typedParamsUnpackLen(cparams, nparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/domain_events.go b/domain_events.go
index fe46c5e..b4bff7b 100644
--- a/domain_events.go
+++ b/domain_events.go
@@ -763,7 +763,7 @@ func domainEventTunableGetPin(params C.virTypedParameterPtr, nparams
C.int) *Dom
numvcpus, numiothreads := countPinInfo(params, nparams)
pinInfo := getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin)
- num, err := typedParamsUnpackLen(params, int(nparams), pinInfo)
+ num, err := typedParamsUnpackLen(params, nparams, pinInfo)
if num == 0 || err != nil {
return nil
}
@@ -820,7 +820,7 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr,
params C.vi
var sched DomainSchedulerParameters
schedInfo := getDomainTuneSchedulerParametersFieldInfo(&sched)
- num, _ := typedParamsUnpackLen(params, int(nparams), schedInfo)
+ num, _ := typedParamsUnpackLen(params, nparams, schedInfo)
if num > 0 {
eventDetails.CpuSched = &sched
}
@@ -831,12 +831,12 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr,
params C.vi
s: &eventDetails.BlkdevDisk,
},
}
- typedParamsUnpackLen(params, int(nparams), blknameInfo)
+ typedParamsUnpackLen(params, nparams, blknameInfo)
var blktune DomainBlockIoTuneParameters
blktuneInfo := getTuneBlockIoTuneParametersFieldInfo(&blktune)
- num, _ = typedParamsUnpackLen(params, int(nparams), blktuneInfo)
+ num, _ = typedParamsUnpackLen(params, nparams, blktuneInfo)
if num > 0 {
eventDetails.BlkdevTune = &blktune
}
@@ -910,7 +910,7 @@ func domainEventJobCompletedCallback(c C.virConnectPtr, d
C.virDomainPtr, params
eventDetails := &DomainEventJobCompleted{}
info := getDomainJobInfoFieldInfo(&eventDetails.Info)
- typedParamsUnpackLen(params, int(nparams), info)
+ typedParamsUnpackLen(params, nparams, info)
callbackFunc := getCallbackId(goCallbackId)
callback, ok := callbackFunc.(DomainEventJobCompletedCallback)
diff --git a/typedparams.go b/typedparams.go
index a1bdffd..bda785f 100644
--- a/typedparams.go
+++ b/typedparams.go
@@ -53,76 +53,86 @@ type typedParamsFieldInfo struct {
sl *[]string
}
-func typedParamsUnpackLen(cparams *C.virTypedParameter, nparams int, infomap
map[string]typedParamsFieldInfo) (uint, error) {
+func typedParamsUnpackLen(cparams *C.virTypedParameter, cnparams C.int, infomap
map[string]typedParamsFieldInfo) (uint, error) {
count := uint(0)
- for i := 0; i < nparams; i++ {
- var cparam *C.virTypedParameter
- cparam = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) +
unsafe.Sizeof(*cparam)*uintptr(i)))
- name := C.GoString((*C.char)(unsafe.Pointer(&cparam.field)))
- info, ok := infomap[name]
- if !ok {
- // Ignore unknown keys so that we don't break if
- // run against a newer libvirt that returns more
- // parameters than we currently have code to
- // consume
- continue
- }
- switch cparam._type {
- case C.VIR_TYPED_PARAM_INT:
- if info.i == nil {
- return 0, fmt.Errorf("field %s expects an int", name)
- }
- *info.i = int(*(*C.int)(unsafe.Pointer(&cparam.value)))
- *info.set = true
- case C.VIR_TYPED_PARAM_UINT:
- if info.ui == nil {
- return 0, fmt.Errorf("field %s expects a uint", name)
- }
- *info.ui = uint(*(*C.uint)(unsafe.Pointer(&cparam.value)))
- *info.set = true
- case C.VIR_TYPED_PARAM_LLONG:
- if info.l == nil {
- return 0, fmt.Errorf("field %s expects an int64", name)
- }
- *info.l = int64(*(*C.longlong)(unsafe.Pointer(&cparam.value)))
- *info.set = true
- case C.VIR_TYPED_PARAM_ULLONG:
- if info.ul == nil {
- return 0, fmt.Errorf("field %s expects a uint64", name)
- }
- *info.ul = uint64(*(*C.ulonglong)(unsafe.Pointer(&cparam.value)))
- *info.set = true
- case C.VIR_TYPED_PARAM_DOUBLE:
- if info.d == nil {
- return 0, fmt.Errorf("field %s expects a float64", name)
+ for name, value := range infomap {
+ var err C.virError
+ var ret C.int
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ if value.sl != nil {
+ for i := 0; i < int(cnparams); i++ {
+ var cparam *C.virTypedParameter
+ cparam = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) +
+ (unsafe.Sizeof(*cparam) * uintptr(i))))
+ var cs *C.char
+ ret = C.virTypedParamsGetStringWrapper(cparam, 1, cname, &cs, &err)
+ if ret == 1 {
+ *value.sl = append(*value.sl, C.GoString(cs))
+ *value.set = true
+ count++
+ }
}
- *info.d = float64(*(*C.double)(unsafe.Pointer(&cparam.value)))
- *info.set = true
- case C.VIR_TYPED_PARAM_BOOLEAN:
- if info.b == nil {
- return 0, fmt.Errorf("field %s expects a bool", name)
+ } else {
+ if value.i != nil {
+ var ci C.int
+ ret = C.virTypedParamsGetIntWrapper(cparams, cnparams, cname, &ci, &err)
+ if ret == 1 {
+ *value.i = int(ci)
+ }
+ } else if value.ui != nil {
+ var cui C.uint
+ ret = C.virTypedParamsGetUIntWrapper(cparams, cnparams, cname, &cui, &err)
+ if ret == 1 {
+ *value.ui = uint(cui)
+ }
+ } else if value.l != nil {
+ var cl C.longlong
+ ret = C.virTypedParamsGetLLongWrapper(cparams, cnparams, cname, &cl, &err)
+ if ret == 1 {
+ *value.l = int64(cl)
+ }
+ } else if value.ul != nil {
+ var cul C.ulonglong
+ ret = C.virTypedParamsGetULLongWrapper(cparams, cnparams, cname, &cul, &err)
+ if ret == 1 {
+ *value.ul = uint64(cul)
+ }
+ } else if value.d != nil {
+ var cd C.double
+ ret = C.virTypedParamsGetDoubleWrapper(cparams, cnparams, cname, &cd, &err)
+ if ret == 1 {
+ *value.d = float64(cd)
+ }
+ } else if value.b != nil {
+ var cb C.int
+ ret = C.virTypedParamsGetBooleanWrapper(cparams, cnparams, cname, &cb, &err)
+ if ret == 1 {
+ if cb == 1 {
+ *value.b = true
+ } else {
+ *value.b = false
+ }
+ }
+ } else if value.s != nil {
+ var cs *C.char
+ ret = C.virTypedParamsGetStringWrapper(cparams, cnparams, cname, &cs, &err)
+ if ret == 1 {
+ *value.s = C.GoString(cs)
+ }
}
- *info.b = *(*C.char)(unsafe.Pointer(&cparam.value)) == 1
- *info.set = true
- case C.VIR_TYPED_PARAM_STRING:
- if info.s != nil {
- *info.s = C.GoString(*(**C.char)(unsafe.Pointer(&cparam.value)))
- *info.set = true
- } else if info.sl != nil {
- *info.sl = append(*info.sl,
C.GoString(*(**C.char)(unsafe.Pointer(&cparam.value))))
- *info.set = true
- } else {
- return 0, fmt.Errorf("field %s expects a string/string list", name)
+ if ret == 1 {
+ *value.set = true
+ count++
}
}
- count++
}
return count, nil
}
func typedParamsUnpack(cparams []C.virTypedParameter, infomap
map[string]typedParamsFieldInfo) (uint, error) {
- return typedParamsUnpackLen(&cparams[0], len(cparams), infomap)
+ return typedParamsUnpackLen(&cparams[0], C.int(len(cparams)), infomap)
}
func typedParamsPackLen(cparams *C.virTypedParameter, nparams int, infomap
map[string]typedParamsFieldInfo) error {
diff --git a/typedparams_test.go b/typedparams_test.go
index ff3783b..dca65b2 100644
--- a/typedparams_test.go
+++ b/typedparams_test.go
@@ -86,7 +86,7 @@ func TestPackUnpack(t *testing.T) {
t.Fatal(err)
}
- nout, err := typedParamsUnpackLen(params, int(nparams), infoout)
+ nout, err := typedParamsUnpackLen(params, nparams, infoout)
if err != nil {
t.Fatal(err)
}
diff --git a/typedparams_wrapper.go b/typedparams_wrapper.go
index c0248ce..2209d60 100644
--- a/typedparams_wrapper.go
+++ b/typedparams_wrapper.go
@@ -135,5 +135,106 @@ virTypedParamsAddStringWrapper(virTypedParameterPtr *params,
return ret;
}
+
+int
+virTypedParamsGetIntWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ int *value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsGetInt(params, nparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsGetUIntWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ unsigned int *value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsGetUInt(params, nparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsGetLLongWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ long long *value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsGetLLong(params, nparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsGetULLongWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ unsigned long long *value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsGetULLong(params, nparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsGetDoubleWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ double *value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsGetDouble(params, nparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsGetBooleanWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ int *value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsGetBoolean(params, nparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+int
+virTypedParamsGetStringWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ const char **value,
+ virErrorPtr err)
+{
+ int ret = virTypedParamsGetString(params, nparams, name, value);
+ if (ret < 0) {
+ virCopyLastError(err);
+ }
+ return ret;
+}
+
+
+
*/
import "C"
diff --git a/typedparams_wrapper.h b/typedparams_wrapper.h
index d2ef7d6..ee626b1 100644
--- a/typedparams_wrapper.h
+++ b/typedparams_wrapper.h
@@ -79,4 +79,48 @@ virTypedParamsAddStringWrapper(virTypedParameterPtr *params,
const char *value,
virErrorPtr err);
+int
+virTypedParamsGetIntWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ int *value,
+ virErrorPtr err);
+int
+virTypedParamsGetUIntWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ unsigned int *value,
+ virErrorPtr err);
+int
+virTypedParamsGetLLongWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ long long *value,
+ virErrorPtr err);
+int
+virTypedParamsGetULLongWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ unsigned long long *value,
+ virErrorPtr err);
+int
+virTypedParamsGetDoubleWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ double *value,
+ virErrorPtr err);
+int
+virTypedParamsGetBooleanWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ int *value,
+ virErrorPtr err);
+int
+virTypedParamsGetStringWrapper(virTypedParameterPtr params,
+ int nparams,
+ const char *name,
+ const char **value,
+ virErrorPtr err);
+
+
#endif /* LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ */
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 5/8] Use 'cnparams' for virTypedParameters array length variables
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
connect.go | 50 +++++------
domain.go | 224 +++++++++++++++++++++++------------------------
domain_events.go | 20 ++---
3 files changed, 147 insertions(+), 147 deletions(-)
diff --git a/connect.go b/connect.go
index e2ff88a..11a6a8c 100644
--- a/connect.go
+++ b/connect.go
@@ -1738,22 +1738,22 @@ type NodeCPUStats struct {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetCPUStats
func (c *Connect) GetCPUStats(cpuNum int, flags uint32) (*NodeCPUStats, error) {
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), nil, &nparams, C.uint(0),
&err)
+ ret := C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), nil, &cnparams, C.uint(0),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- params := make([]C.virNodeCPUStats, nparams)
- ret = C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum),
(*C.virNodeCPUStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags),
&err)
+ params := make([]C.virNodeCPUStats, cnparams)
+ ret = C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum),
(*C.virNodeCPUStats)(unsafe.Pointer(¶ms[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
stats := &NodeCPUStats{}
- for i := 0; i < int(nparams); i++ {
+ for i := 0; i < int(cnparams); i++ {
param := params[i]
field := C.GoString((*C.char)(unsafe.Pointer(¶m.field)))
switch field {
@@ -1897,21 +1897,21 @@ func (c *Connect) GetMemoryParameters(flags uint32)
(*NodeMemoryParameters, erro
params := &NodeMemoryParameters{}
info := getMemoryParameterFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, C.uint(0),
&err)
+ ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &cnparams, C.uint(0),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virNodeGetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virNodeGetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -1934,22 +1934,22 @@ type NodeMemoryStats struct {
// See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetMemoryStats
func (c *Connect) GetMemoryStats(cellNum int, flags uint32) (*NodeMemoryStats, error) {
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), nil, &nparams, 0,
&err)
+ ret := C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), nil, &cnparams, 0,
&err)
if ret == -1 {
return nil, makeError(&err)
}
- params := make([]C.virNodeMemoryStats, nparams)
- ret = C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum),
(*C.virNodeMemoryStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags),
&err)
+ params := make([]C.virNodeMemoryStats, cnparams)
+ ret = C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum),
(*C.virNodeMemoryStats)(unsafe.Pointer(¶ms[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
stats := &NodeMemoryStats{}
- for i := 0; i < int(nparams); i++ {
+ for i := 0; i < int(cnparams); i++ {
param := params[i]
field := C.GoString((*C.char)(unsafe.Pointer(¶m.field)))
switch field {
@@ -1995,28 +1995,28 @@ func (c *Connect) GetSecurityModel() (*NodeSecurityModel, error)
{
func (c *Connect) SetMemoryParameters(params *NodeMemoryParameters, flags uint32) error
{
info := getMemoryParameterFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, 0, &err)
+ ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virNodeGetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virNodeGetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virNodeSetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ ret = C.virNodeSetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -2967,17 +2967,17 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSEVParameters,
error) {
info := getNodeSEVFieldInfo(params)
var cparams *C.virTypedParameter
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virNodeGetSEVInfoWrapper(c.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags),
&err)
+ ret := C.virNodeGetSEVInfoWrapper(c.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsFree(cparams, nparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
- _, gerr := typedParamsUnpackLen(cparams, nparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/domain.go b/domain.go
index 09d6a71..6c40f10 100644
--- a/domain.go
+++ b/domain.go
@@ -1173,17 +1173,17 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags
uint32) ([]DomainCP
if ret == -1 {
return []DomainCPUStats{}, makeError(&err)
}
- nparams := uint(ret)
+ cnparams := uint(ret)
var cparams []C.virTypedParameter
var nallocparams uint
if startCpu == -1 {
- nallocparams = nparams
+ nallocparams = cnparams
} else {
- nallocparams = nparams * nCpus
+ nallocparams = cnparams * nCpus
}
cparams = make([]C.virTypedParameter, nallocparams)
- ret = C.virDomainGetCPUStatsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.uint(nparams), C.int(startCpu),
C.uint(nCpus), C.uint(flags), &err)
+ ret = C.virDomainGetCPUStatsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.uint(cnparams),
C.int(startCpu), C.uint(nCpus), C.uint(flags), &err)
if ret == -1 {
return []DomainCPUStats{}, makeError(&err)
}
@@ -1192,7 +1192,7 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags uint32)
([]DomainCP
stats := make([]DomainCPUStats, nCpus)
for i := 0; i < int(nCpus); i++ {
- offset := i * int(nparams)
+ offset := i * int(cnparams)
info := getCPUStatsFieldInfo(&stats[i])
cparamscpu := cparams[offset : offset+int(ret)]
_, gerr := typedParamsUnpack(cparamscpu, info)
@@ -1258,23 +1258,23 @@ func (d *Domain) GetInterfaceParameters(device string, flags
DomainModificationI
params := &DomainInterfaceParameters{}
info := getInterfaceParameterFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
cdevice := C.CString(device)
defer C.free(unsafe.Pointer(cdevice))
var err C.virError
- ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &nparams,
C.uint(0), &err)
+ ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &cnparams,
C.uint(0), &err)
if ret == -1 {
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -1288,30 +1288,30 @@ func (d *Domain) GetInterfaceParameters(device string, flags
DomainModificationI
func (d *Domain) SetInterfaceParameters(device string, params *DomainInterfaceParameters,
flags DomainModificationImpact) error {
info := getInterfaceParameterFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
cdevice := C.CString(device)
defer C.free(unsafe.Pointer(cdevice))
var err C.virError
- ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &nparams, 0,
&err)
+ ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &cnparams, 0,
&err)
if ret == -1 {
return makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ ret = C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -1661,23 +1661,23 @@ func (d *Domain) BlockStatsFlags(disk string, flags uint32)
(*DomainBlockStats,
params := &DomainBlockStats{}
info := getBlockStatsFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
cdisk := C.CString(disk)
defer C.free(unsafe.Pointer(cdisk))
var err C.virError
- ret := C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &nparams, C.uint(0),
&err)
+ ret := C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &cnparams, C.uint(0),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -2609,20 +2609,20 @@ func (d *Domain) GetBlkioParameters(flags
DomainModificationImpact) (*DomainBlki
params := &DomainBlkioParameters{}
info := getBlkioParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &err)
+ ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
if ret == -1 {
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -2636,28 +2636,28 @@ func (d *Domain) GetBlkioParameters(flags
DomainModificationImpact) (*DomainBlki
func (d *Domain) SetBlkioParameters(params *DomainBlkioParameters, flags
DomainModificationImpact) error {
info := getBlkioParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &err)
+ ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ ret = C.virDomainSetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -2801,20 +2801,20 @@ func (d *Domain) GetBlockIoTune(disk string, flags
DomainModificationImpact) (*D
params := &DomainBlockIoTuneParameters{}
info := getBlockIoTuneParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0, &err)
+ ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &cnparams, 0, &err)
if ret == -1 {
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -2831,28 +2831,28 @@ func (d *Domain) SetBlockIoTune(disk string, params
*DomainBlockIoTuneParameters
info := getBlockIoTuneParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0, &err)
+ ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ ret = C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3195,19 +3195,19 @@ func getDomainJobInfoFieldInfo(params *DomainJobInfo)
map[string]typedParamsFiel
// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobStats
func (d *Domain) GetJobStats(flags DomainGetJobStatsFlags) (*DomainJobInfo, error) {
var cparams *C.virTypedParameter
- var nparams C.int
+ var cnparams C.int
var jobtype C.int
var err C.virError
- ret := C.virDomainGetJobStatsWrapper(d.ptr, &jobtype,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags),
&err)
+ ret := C.virDomainGetJobStatsWrapper(d.ptr, &jobtype,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsFree(cparams, nparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
params := DomainJobInfo{}
info := getDomainJobInfoFieldInfo(¶ms)
- _, gerr := typedParamsUnpackLen(cparams, nparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3287,20 +3287,20 @@ func (d *Domain) GetMemoryParameters(flags
DomainModificationImpact) (*DomainMem
params := &DomainMemoryParameters{}
info := getDomainMemoryParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &err)
+ ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
if ret == -1 {
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -3314,28 +3314,28 @@ func (d *Domain) GetMemoryParameters(flags
DomainModificationImpact) (*DomainMem
func (d *Domain) SetMemoryParameters(params *DomainMemoryParameters, flags
DomainModificationImpact) error {
info := getDomainMemoryParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &err)
+ ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ ret = C.virDomainSetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3368,20 +3368,20 @@ func (d *Domain) GetNumaParameters(flags DomainModificationImpact)
(*DomainNumaP
params := &DomainNumaParameters{}
info := getDomainNumaParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &err)
+ ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
if ret == -1 {
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -3395,28 +3395,28 @@ func (d *Domain) GetNumaParameters(flags DomainModificationImpact)
(*DomainNumaP
func (d *Domain) SetNumaParameters(params *DomainNumaParameters, flags
DomainModificationImpact) error {
info := getDomainNumaParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &err)
+ ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- cparams := make([]C.virTypedParameter, nparams)
- ret = C.virDomainGetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret = C.virDomainGetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ ret = C.virDomainSetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3576,16 +3576,16 @@ func (d *Domain) GetPerfEvents(flags DomainModificationImpact)
(*DomainPerfEvent
info := getDomainPerfEventsFieldInfo(params)
var cparams *C.virTypedParameter
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetPerfEventsWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags),
&err)
+ ret := C.virDomainGetPerfEventsWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsFree(cparams, nparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
- _, gerr := typedParamsUnpackLen(cparams, nparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3602,21 +3602,21 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEvents, flags
DomainModificatio
info := getDomainPerfEventsFieldInfo(params)
var cparams *C.virTypedParameter
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetPerfEventsWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags),
&err)
+ ret := C.virDomainGetPerfEventsWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsFree(cparams, nparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
- gerr := typedParamsPackLen(cparams, int(nparams), info)
+ gerr := typedParamsPackLen(cparams, int(cnparams), info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(flags), &err)
+ ret = C.virDomainSetPerfEventsWrapper(d.ptr, cparams, cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3722,26 +3722,26 @@ func (d *Domain) GetSchedulerParameters()
(*DomainSchedulerParameters, error) {
params := &DomainSchedulerParameters{}
info := getDomainSchedulerParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
+ schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err)
if schedtype == nil {
return nil, makeError(&err)
}
defer C.free(unsafe.Pointer(schedtype))
- if nparams == 0 {
+ if cnparams == 0 {
return &DomainSchedulerParameters{
Type: C.GoString(schedtype),
}, nil
}
- cparams := make([]C.virTypedParameter, nparams)
- ret := C.virDomainGetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret := C.virDomainGetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, &err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -3756,26 +3756,26 @@ func (d *Domain) GetSchedulerParametersFlags(flags
DomainModificationImpact) (*D
params := &DomainSchedulerParameters{}
info := getDomainSchedulerParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
+ schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err)
if schedtype == nil {
return nil, makeError(&err)
}
defer C.free(unsafe.Pointer(schedtype))
- if nparams == 0 {
+ if cnparams == 0 {
return &DomainSchedulerParameters{
Type: C.GoString(schedtype),
}, nil
}
- cparams := make([]C.virTypedParameter, nparams)
- ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags),
&err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
_, gerr := typedParamsUnpack(cparams, info)
if gerr != nil {
@@ -3789,31 +3789,31 @@ func (d *Domain) GetSchedulerParametersFlags(flags
DomainModificationImpact) (*D
func (d *Domain) SetSchedulerParameters(params *DomainSchedulerParameters) error {
info := getDomainSchedulerParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
+ schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err)
if schedtype == nil {
return makeError(&err)
}
defer C.free(unsafe.Pointer(schedtype))
- if nparams == 0 {
+ if cnparams == 0 {
return nil
}
- cparams := make([]C.virTypedParameter, nparams)
- ret := C.virDomainGetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret := C.virDomainGetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, &err)
+ ret = C.virDomainSetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, &err)
if ret == -1 {
return makeError(&err)
}
@@ -3825,31 +3825,31 @@ func (d *Domain) SetSchedulerParameters(params
*DomainSchedulerParameters) error
func (d *Domain) SetSchedulerParametersFlags(params *DomainSchedulerParameters, flags
DomainModificationImpact) error {
info := getDomainSchedulerParametersFieldInfo(params)
- var nparams C.int
+ var cnparams C.int
var err C.virError
- schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err)
+ schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err)
if schedtype == nil {
return makeError(&err)
}
defer C.free(unsafe.Pointer(schedtype))
- if nparams == 0 {
+ if cnparams == 0 {
return nil
}
- cparams := make([]C.virTypedParameter, nparams)
- ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err)
+ cparams := make([]C.virTypedParameter, cnparams)
+ ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
if ret == -1 {
return makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
nparams)
+ defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
gerr := typedParamsPack(cparams, info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags),
&err)
+ ret = C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -4635,16 +4635,16 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*DomainGuestVcpus,
error) {
info := getDomainGuestVcpusParametersFieldInfo(vcpus, &VcpusStr, &OnlineStr,
&OfflinableStr)
var cparams C.virTypedParameterPtr
- var nparams C.uint
+ var cnparams C.uint
var err C.virError
- ret := C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &nparams, C.uint(flags),
&err)
+ ret := C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsFree(cparams, C.int(nparams))
+ defer C.virTypedParamsFree(cparams, C.int(cnparams))
- _, gerr := typedParamsUnpackLen(cparams, C.int(nparams), info)
+ _, gerr := typedParamsUnpackLen(cparams, C.int(cnparams), info)
if gerr != nil {
return nil, gerr
}
@@ -4851,17 +4851,17 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32)
(*DomainLaunchSecurityParam
info := getDomainLaunchSecurityFieldInfo(params)
var cparams *C.virTypedParameter
- var nparams C.int
+ var cnparams C.int
var err C.virError
- ret := C.virDomainGetLaunchSecurityInfoWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags),
&err)
+ ret := C.virDomainGetLaunchSecurityInfoWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsFree(cparams, nparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
- _, gerr := typedParamsUnpackLen(cparams, nparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/domain_events.go b/domain_events.go
index b4bff7b..7e72313 100644
--- a/domain_events.go
+++ b/domain_events.go
@@ -758,12 +758,12 @@ func countPinInfo(cparams C.virTypedParameterPtr, nparams C.int)
(int, int) {
return maxvcpus + 1, maxiothreads + 1
}
-func domainEventTunableGetPin(params C.virTypedParameterPtr, nparams C.int)
*DomainEventTunableCpuPin {
+func domainEventTunableGetPin(params C.virTypedParameterPtr, cnparams C.int)
*DomainEventTunableCpuPin {
var pin domainEventTunablePinTemp
- numvcpus, numiothreads := countPinInfo(params, nparams)
+ numvcpus, numiothreads := countPinInfo(params, cnparams)
pinInfo := getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin)
- num, err := typedParamsUnpackLen(params, nparams, pinInfo)
+ num, err := typedParamsUnpackLen(params, cnparams, pinInfo)
if num == 0 || err != nil {
return nil
}
@@ -806,13 +806,13 @@ func domainEventTunableGetPin(params C.virTypedParameterPtr, nparams
C.int) *Dom
}
//export domainEventTunableCallback
-func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, params
C.virTypedParameterPtr, nparams C.int, goCallbackId int) {
+func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, params
C.virTypedParameterPtr, cnparams C.int, goCallbackId int) {
domain := &Domain{ptr: d}
connection := &Connect{ptr: c}
eventDetails := &DomainEventTunable{}
- pin := domainEventTunableGetPin(params, nparams)
+ pin := domainEventTunableGetPin(params, cnparams)
if pin != nil {
eventDetails.CpuPin = pin
}
@@ -820,7 +820,7 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr,
params C.vi
var sched DomainSchedulerParameters
schedInfo := getDomainTuneSchedulerParametersFieldInfo(&sched)
- num, _ := typedParamsUnpackLen(params, nparams, schedInfo)
+ num, _ := typedParamsUnpackLen(params, cnparams, schedInfo)
if num > 0 {
eventDetails.CpuSched = &sched
}
@@ -831,12 +831,12 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr,
params C.vi
s: &eventDetails.BlkdevDisk,
},
}
- typedParamsUnpackLen(params, nparams, blknameInfo)
+ typedParamsUnpackLen(params, cnparams, blknameInfo)
var blktune DomainBlockIoTuneParameters
blktuneInfo := getTuneBlockIoTuneParametersFieldInfo(&blktune)
- num, _ = typedParamsUnpackLen(params, nparams, blktuneInfo)
+ num, _ = typedParamsUnpackLen(params, cnparams, blktuneInfo)
if num > 0 {
eventDetails.BlkdevTune = &blktune
}
@@ -903,14 +903,14 @@ func domainEventMigrationIterationCallback(c C.virConnectPtr, d
C.virDomainPtr,
}
//export domainEventJobCompletedCallback
-func domainEventJobCompletedCallback(c C.virConnectPtr, d C.virDomainPtr, params
C.virTypedParameterPtr, nparams C.int, goCallbackId int) {
+func domainEventJobCompletedCallback(c C.virConnectPtr, d C.virDomainPtr, params
C.virTypedParameterPtr, cnparams C.int, goCallbackId int) {
domain := &Domain{ptr: d}
connection := &Connect{ptr: c}
eventDetails := &DomainEventJobCompleted{}
info := getDomainJobInfoFieldInfo(&eventDetails.Info)
- typedParamsUnpackLen(params, nparams, info)
+ typedParamsUnpackLen(params, cnparams, info)
callbackFunc := getCallbackId(goCallbackId)
callback, ok := callbackFunc.(DomainEventJobCompletedCallback)
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 6/8] Simplify setting of typed parameters
There is no need to get currently known parameters from libvirt before
setting new typed parameters.
Indeed this behaviour actually causes problems because it means when
setting parameters we will explicitly set all known parameters, instead
of only the parameters with changed (non-default) values.
Fixes github bug #21
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
connect.go | 23 ++-----
domain.go | 182 +++++++++++--------------------------------------
typedparams.go | 73 --------------------
3 files changed, 44 insertions(+), 234 deletions(-)
diff --git a/connect.go b/connect.go
index 11a6a8c..632b7a6 100644
--- a/connect.go
+++ b/connect.go
@@ -1995,28 +1995,15 @@ func (c *Connect) GetSecurityModel() (*NodeSecurityModel, error)
{
func (c *Connect) SetMemoryParameters(params *NodeMemoryParameters, flags uint32) error
{
info := getMemoryParameterFieldInfo(params)
- var cnparams C.int
-
- var err C.virError
- ret := C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virNodeGetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virNodeSetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virNodeSetMemoryParametersWrapper(c.ptr, cparams, cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
diff --git a/domain.go b/domain.go
index 6c40f10..c851bf6 100644
--- a/domain.go
+++ b/domain.go
@@ -1288,30 +1288,18 @@ func (d *Domain) GetInterfaceParameters(device string, flags
DomainModificationI
func (d *Domain) SetInterfaceParameters(device string, params *DomainInterfaceParameters,
flags DomainModificationImpact) error {
info := getInterfaceParameterFieldInfo(params)
- var cnparams C.int
-
cdevice := C.CString(device)
defer C.free(unsafe.Pointer(cdevice))
- var err C.virError
- ret := C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &cnparams, 0,
&err)
- if ret == -1 {
- return makeError(&err)
- }
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, cparams, cnparams,
C.uint(flags), &err)
if ret == -1 {
return makeError(&err)
}
@@ -2636,28 +2624,15 @@ func (d *Domain) GetBlkioParameters(flags
DomainModificationImpact) (*DomainBlki
func (d *Domain) SetBlkioParameters(params *DomainBlkioParameters, flags
DomainModificationImpact) error {
info := getBlkioParametersFieldInfo(params)
- var cnparams C.int
-
- var err C.virError
- ret := C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virDomainSetBlkioParametersWrapper(d.ptr, cparams, cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -2831,28 +2806,15 @@ func (d *Domain) SetBlockIoTune(disk string, params
*DomainBlockIoTuneParameters
info := getBlockIoTuneParametersFieldInfo(params)
- var cnparams C.int
-
- var err C.virError
- ret := C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, cparams, cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3314,28 +3276,15 @@ func (d *Domain) GetMemoryParameters(flags
DomainModificationImpact) (*DomainMem
func (d *Domain) SetMemoryParameters(params *DomainMemoryParameters, flags
DomainModificationImpact) error {
info := getDomainMemoryParametersFieldInfo(params)
- var cnparams C.int
-
- var err C.virError
- ret := C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virDomainSetMemoryParametersWrapper(d.ptr, cparams, cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3395,28 +3344,15 @@ func (d *Domain) GetNumaParameters(flags DomainModificationImpact)
(*DomainNumaP
func (d *Domain) SetNumaParameters(params *DomainNumaParameters, flags
DomainModificationImpact) error {
info := getDomainNumaParametersFieldInfo(params)
- var cnparams C.int
-
- var err C.virError
- ret := C.virDomainGetNumaParametersWrapper(d.ptr, nil, &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
-
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virDomainSetNumaParametersWrapper(d.ptr, cparams, cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3601,22 +3537,14 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEvents, flags
DomainModificatio
info := getDomainPerfEventsFieldInfo(params)
- var cparams *C.virTypedParameter
- var cnparams C.int
- var err C.virError
- ret := C.virDomainGetPerfEventsWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
- if ret == -1 {
- return makeError(&err)
- }
-
- defer C.virTypedParamsFree(cparams, cnparams)
-
- gerr := typedParamsPackLen(cparams, int(cnparams), info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
+ defer C.virTypedParamsFree(cparams, cnparams)
- ret = C.virDomainSetPerfEventsWrapper(d.ptr, cparams, cnparams, C.uint(flags),
&err)
+ var err C.virError
+ ret := C.virDomainSetPerfEventsWrapper(d.ptr, cparams, cnparams, C.uint(flags),
&err)
if ret == -1 {
return makeError(&err)
}
@@ -3789,31 +3717,15 @@ func (d *Domain) GetSchedulerParametersFlags(flags
DomainModificationImpact) (*D
func (d *Domain) SetSchedulerParameters(params *DomainSchedulerParameters) error {
info := getDomainSchedulerParametersFieldInfo(params)
- var cnparams C.int
- var err C.virError
- schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err)
- if schedtype == nil {
- return makeError(&err)
- }
-
- defer C.free(unsafe.Pointer(schedtype))
- if cnparams == 0 {
- return nil
- }
-
- cparams := make([]C.virTypedParameter, cnparams)
- ret := C.virDomainGetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, &err)
- if ret == -1 {
- return makeError(&err)
- }
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, &err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virDomainSetSchedulerParametersWrapper(d.ptr, cparams, cnparams, &err)
if ret == -1 {
return makeError(&err)
}
@@ -3825,31 +3737,15 @@ func (d *Domain) SetSchedulerParameters(params
*DomainSchedulerParameters) error
func (d *Domain) SetSchedulerParametersFlags(params *DomainSchedulerParameters, flags
DomainModificationImpact) error {
info := getDomainSchedulerParametersFieldInfo(params)
- var cnparams C.int
- var err C.virError
- schedtype := C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err)
- if schedtype == nil {
- return makeError(&err)
- }
-
- defer C.free(unsafe.Pointer(schedtype))
- if cnparams == 0 {
- return nil
- }
-
- cparams := make([]C.virTypedParameter, cnparams)
- ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err)
- if ret == -1 {
- return makeError(&err)
- }
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- gerr := typedParamsPack(cparams, info)
+ cparams, cnparams, gerr := typedParamsPackNew(info)
if gerr != nil {
return gerr
}
- ret = C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags),
&err)
+ defer C.virTypedParamsFree(cparams, cnparams)
+
+ var err C.virError
+ ret := C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, cparams, cnparams,
C.uint(flags), &err)
if ret == -1 {
return makeError(&err)
}
diff --git a/typedparams.go b/typedparams.go
index bda785f..ee531cc 100644
--- a/typedparams.go
+++ b/typedparams.go
@@ -135,79 +135,6 @@ func typedParamsUnpack(cparams []C.virTypedParameter, infomap
map[string]typedPa
return typedParamsUnpackLen(&cparams[0], C.int(len(cparams)), infomap)
}
-func typedParamsPackLen(cparams *C.virTypedParameter, nparams int, infomap
map[string]typedParamsFieldInfo) error {
- stringOffsets := make(map[string]uint)
-
- for i := 0; i < nparams; i++ {
- var cparam *C.virTypedParameter
- cparam = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) +
unsafe.Sizeof(*cparam)*uintptr(i)))
- name := C.GoString((*C.char)(unsafe.Pointer(&cparam.field)))
- info, ok := infomap[name]
- if !ok {
- // Ignore unknown keys so that we don't break if
- // run against a newer libvirt that returns more
- // parameters than we currently have code to
- // consume
- continue
- }
- if !*info.set {
- continue
- }
- switch cparam._type {
- case C.VIR_TYPED_PARAM_INT:
- if info.i == nil {
- return fmt.Errorf("field %s expects an int", name)
- }
- *(*C.int)(unsafe.Pointer(&cparam.value)) = C.int(*info.i)
- case C.VIR_TYPED_PARAM_UINT:
- if info.ui == nil {
- return fmt.Errorf("field %s expects a uint", name)
- }
- *(*C.uint)(unsafe.Pointer(&cparam.value)) = C.uint(*info.ui)
- case C.VIR_TYPED_PARAM_LLONG:
- if info.l == nil {
- return fmt.Errorf("field %s expects an int64", name)
- }
- *(*C.longlong)(unsafe.Pointer(&cparam.value)) = C.longlong(*info.l)
- case C.VIR_TYPED_PARAM_ULLONG:
- if info.ul == nil {
- return fmt.Errorf("field %s expects a uint64", name)
- }
- *(*C.ulonglong)(unsafe.Pointer(&cparam.value)) = C.ulonglong(*info.ul)
- case C.VIR_TYPED_PARAM_DOUBLE:
- if info.d == nil {
- return fmt.Errorf("field %s expects a float64", name)
- }
- *(*C.double)(unsafe.Pointer(&cparam.value)) = C.double(*info.d)
- case C.VIR_TYPED_PARAM_BOOLEAN:
- if info.b == nil {
- return fmt.Errorf("field %s expects a bool", name)
- }
- if *info.b {
- *(*C.char)(unsafe.Pointer(&cparam.value)) = 1
- } else {
- *(*C.char)(unsafe.Pointer(&cparam.value)) = 0
- }
- case C.VIR_TYPED_PARAM_STRING:
- if info.s != nil {
- *(**C.char)(unsafe.Pointer(&cparam.value)) = C.CString(*info.s)
- } else if info.sl != nil {
- count := stringOffsets[name]
- *(**C.char)(unsafe.Pointer(&cparam.value)) = C.CString((*info.sl)[count])
- stringOffsets[name] = count + 1
- } else {
- return fmt.Errorf("field %s expects a string", name)
- }
- }
- }
-
- return nil
-}
-
-func typedParamsPack(cparams []C.virTypedParameter, infomap
map[string]typedParamsFieldInfo) error {
- return typedParamsPackLen(&cparams[0], len(cparams), infomap)
-}
-
func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*C.virTypedParameter,
C.int, error) {
var cparams C.virTypedParameterPtr
var nparams C.int
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 7/8] Switch remaining typed parameter code to use C allocs
Bring remaining typed parameter code in line with previous patches
by switching to C allocs instead of passing Go memory to C.
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
connect.go | 9 ++---
domain.go | 102 +++++++++++++++++++++++--------------------------
typedparams.go | 11 +++++-
3 files changed, 61 insertions(+), 61 deletions(-)
diff --git a/connect.go b/connect.go
index 632b7a6..f627e7d 100644
--- a/connect.go
+++ b/connect.go
@@ -1905,15 +1905,14 @@ func (c *Connect) GetMemoryParameters(flags uint32)
(*NodeMemoryParameters, erro
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virNodeGetMemoryParametersWrapper(c.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret = C.virNodeGetMemoryParametersWrapper(c.ptr, cparams, &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/domain.go b/domain.go
index c851bf6..bee779f 100644
--- a/domain.go
+++ b/domain.go
@@ -1173,29 +1173,29 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags
uint32) ([]DomainCP
if ret == -1 {
return []DomainCPUStats{}, makeError(&err)
}
- cnparams := uint(ret)
+ cnparams := C.int(ret)
- var cparams []C.virTypedParameter
- var nallocparams uint
+ var cnallocparams C.int
if startCpu == -1 {
- nallocparams = cnparams
+ cnallocparams = cnparams
} else {
- nallocparams = cnparams * nCpus
+ cnallocparams = cnparams * C.int(nCpus)
}
- cparams = make([]C.virTypedParameter, nallocparams)
- ret = C.virDomainGetCPUStatsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), C.uint(cnparams),
C.int(startCpu), C.uint(nCpus), C.uint(flags), &err)
+ cparams := typedParamsNew(cnallocparams)
+ defer C.virTypedParamsFree(cparams, cnallocparams)
+ ret = C.virDomainGetCPUStatsWrapper(d.ptr, cparams, C.uint(cnparams), C.int(startCpu),
C.uint(nCpus), C.uint(flags), &err)
if ret == -1 {
return []DomainCPUStats{}, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
C.int(nallocparams))
-
stats := make([]DomainCPUStats, nCpus)
for i := 0; i < int(nCpus); i++ {
- offset := i * int(cnparams)
+ coffset := C.int(i) * cnparams
info := getCPUStatsFieldInfo(&stats[i])
- cparamscpu := cparams[offset : offset+int(ret)]
- _, gerr := typedParamsUnpack(cparamscpu, info)
+ var cparamscpu *C.virTypedParameter
+ cparamscpu = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) +
+ (unsafe.Sizeof(*cparams) * uintptr(coffset))))
+ _, gerr := typedParamsUnpackLen(cparamscpu, cnparams, info)
if gerr != nil {
return []DomainCPUStats{}, gerr
}
@@ -1268,15 +1268,14 @@ func (d *Domain) GetInterfaceParameters(device string, flags
DomainModificationI
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret = C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -1659,15 +1658,14 @@ func (d *Domain) BlockStatsFlags(disk string, flags uint32)
(*DomainBlockStats,
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret = C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -2604,15 +2602,14 @@ func (d *Domain) GetBlkioParameters(flags
DomainModificationImpact) (*DomainBlki
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetBlkioParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret = C.virDomainGetBlkioParametersWrapper(d.ptr, cparams, &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -2783,15 +2780,14 @@ func (d *Domain) GetBlockIoTune(disk string, flags
DomainModificationImpact) (*D
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret = C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3156,11 +3152,11 @@ func getDomainJobInfoFieldInfo(params *DomainJobInfo)
map[string]typedParamsFiel
// See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobStats
func (d *Domain) GetJobStats(flags DomainGetJobStatsFlags) (*DomainJobInfo, error) {
- var cparams *C.virTypedParameter
+ var cparams C.virTypedParameterPtr
var cnparams C.int
var jobtype C.int
var err C.virError
- ret := C.virDomainGetJobStatsWrapper(d.ptr, &jobtype,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
+ ret := C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, &cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
@@ -3256,15 +3252,14 @@ func (d *Domain) GetMemoryParameters(flags
DomainModificationImpact) (*DomainMem
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetMemoryParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret = C.virDomainGetMemoryParametersWrapper(d.ptr, cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3324,15 +3319,14 @@ func (d *Domain) GetNumaParameters(flags DomainModificationImpact)
(*DomainNumaP
return nil, makeError(&err)
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret = C.virDomainGetNumaParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret = C.virDomainGetNumaParametersWrapper(d.ptr, cparams, &cnparams, C.uint(flags),
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
-
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3511,10 +3505,10 @@ func (d *Domain) GetPerfEvents(flags DomainModificationImpact)
(*DomainPerfEvent
params := &DomainPerfEvents{}
info := getDomainPerfEventsFieldInfo(params)
- var cparams *C.virTypedParameter
+ var cparams C.virTypedParameterPtr
var cnparams C.int
var err C.virError
- ret := C.virDomainGetPerfEventsWrapper(d.ptr,
(*C.virTypedParameterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags),
&err)
+ ret := C.virDomainGetPerfEventsWrapper(d.ptr, &cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
@@ -3664,14 +3658,14 @@ func (d *Domain) GetSchedulerParameters()
(*DomainSchedulerParameters, error) {
}, nil
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret := C.virDomainGetSchedulerParametersWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, &err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret := C.virDomainGetSchedulerParametersWrapper(d.ptr, cparams, &cnparams,
&err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3698,14 +3692,14 @@ func (d *Domain) GetSchedulerParametersFlags(flags
DomainModificationImpact) (*D
}, nil
}
- cparams := make([]C.virTypedParameter, cnparams)
- ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr,
(*C.virTypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags),
&err)
+ cparams := typedParamsNew(cnparams)
+ defer C.virTypedParamsFree(cparams, cnparams)
+ ret := C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, cparams, &cnparams,
C.uint(flags), &err)
if ret == -1 {
return nil, makeError(&err)
}
- defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparams[0])),
cnparams)
- _, gerr := typedParamsUnpack(cparams, info)
+ _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/typedparams.go b/typedparams.go
index ee531cc..0a4c175 100644
--- a/typedparams.go
+++ b/typedparams.go
@@ -131,8 +131,15 @@ func typedParamsUnpackLen(cparams *C.virTypedParameter, cnparams
C.int, infomap
return count, nil
}
-func typedParamsUnpack(cparams []C.virTypedParameter, infomap
map[string]typedParamsFieldInfo) (uint, error) {
- return typedParamsUnpackLen(&cparams[0], C.int(len(cparams)), infomap)
+func typedParamsNew(nparams C.int) *C.virTypedParameter {
+ var cparams *C.virTypedParameter
+ memlen := C.size_t(unsafe.Sizeof(*cparams) * uintptr(nparams))
+ cparams = (*C.virTypedParameter)(C.malloc(memlen))
+ if cparams == nil {
+ C.abort()
+ }
+ C.memset(unsafe.Pointer(cparams), 0, memlen)
+ return cparams
}
func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*C.virTypedParameter,
C.int, error) {
--
2.20.1
7:17 a.m.
New subject: [libvirt] [go PATCH 8/8] Rename typedParamsUnpackLen to typedParamsUnpack
Now we only have one variant of this method it can loose the suffix
Signed-off-by: Daniel P. Berrangé <berrange(a)redhat.com>
---
connect.go | 20 ++++++++++----------
domain.go | 26 +++++++++++++-------------
domain_events.go | 10 +++++-----
typedparams.go | 2 +-
typedparams_test.go | 2 +-
5 files changed, 30 insertions(+), 30 deletions(-)
diff --git a/connect.go b/connect.go
index f627e7d..f77d10d 100644
--- a/connect.go
+++ b/connect.go
@@ -1912,7 +1912,7 @@ func (c *Connect) GetMemoryParameters(flags uint32)
(*NodeMemoryParameters, erro
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -2797,7 +2797,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
state := &DomainStatsState{}
stateInfo := getDomainStatsStateFieldInfo(state)
- count, gerr := typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, stateInfo)
+ count, gerr := typedParamsUnpack(cdomstats.params, cdomstats.nparams, stateInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2808,7 +2808,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
cpu := &DomainStatsCPU{}
cpuInfo := getDomainStatsCPUFieldInfo(cpu)
- count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, cpuInfo)
+ count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, cpuInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2819,7 +2819,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
balloon := &DomainStatsBalloon{}
balloonInfo := getDomainStatsBalloonFieldInfo(balloon)
- count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, balloonInfo)
+ count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, balloonInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2830,7 +2830,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
perf := &DomainStatsPerf{}
perfInfo := getDomainStatsPerfFieldInfo(perf)
- count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, perfInfo)
+ count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, perfInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2841,7 +2841,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
lengths := domainStatsLengths{}
lengthsInfo := getDomainStatsLengthsFieldInfo(&lengths)
- count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, lengthsInfo)
+ count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, lengthsInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2857,7 +2857,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
vcpu := DomainStatsVcpu{}
vcpuInfo := getDomainStatsVcpuFieldInfo(j, &vcpu)
- count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, vcpuInfo)
+ count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, vcpuInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2875,7 +2875,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
block := DomainStatsBlock{}
blockInfo := getDomainStatsBlockFieldInfo(j, &block)
- count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, blockInfo)
+ count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, blockInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2891,7 +2891,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, statsTypes
DomainStatsTypes,
net := DomainStatsNet{}
netInfo := getDomainStatsNetFieldInfo(j, &net)
- count, gerr = typedParamsUnpackLen(cdomstats.params, cdomstats.nparams, netInfo)
+ count, gerr = typedParamsUnpack(cdomstats.params, cdomstats.nparams, netInfo)
if gerr != nil {
return []DomainStats{}, gerr
}
@@ -2963,7 +2963,7 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSEVParameters,
error) {
defer C.virTypedParamsFree(cparams, cnparams)
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/domain.go b/domain.go
index bee779f..98dd290 100644
--- a/domain.go
+++ b/domain.go
@@ -1195,7 +1195,7 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags uint32)
([]DomainCP
var cparamscpu *C.virTypedParameter
cparamscpu = (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(cparams)) +
(unsafe.Sizeof(*cparams) * uintptr(coffset))))
- _, gerr := typedParamsUnpackLen(cparamscpu, cnparams, info)
+ _, gerr := typedParamsUnpack(cparamscpu, cnparams, info)
if gerr != nil {
return []DomainCPUStats{}, gerr
}
@@ -1275,7 +1275,7 @@ func (d *Domain) GetInterfaceParameters(device string, flags
DomainModificationI
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -1665,7 +1665,7 @@ func (d *Domain) BlockStatsFlags(disk string, flags uint32)
(*DomainBlockStats,
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -2609,7 +2609,7 @@ func (d *Domain) GetBlkioParameters(flags DomainModificationImpact)
(*DomainBlki
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -2787,7 +2787,7 @@ func (d *Domain) GetBlockIoTune(disk string, flags
DomainModificationImpact) (*D
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3165,7 +3165,7 @@ func (d *Domain) GetJobStats(flags DomainGetJobStatsFlags)
(*DomainJobInfo, erro
params := DomainJobInfo{}
info := getDomainJobInfoFieldInfo(¶ms)
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3259,7 +3259,7 @@ func (d *Domain) GetMemoryParameters(flags DomainModificationImpact)
(*DomainMem
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3326,7 +3326,7 @@ func (d *Domain) GetNumaParameters(flags DomainModificationImpact)
(*DomainNumaP
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3515,7 +3515,7 @@ func (d *Domain) GetPerfEvents(flags DomainModificationImpact)
(*DomainPerfEvent
defer C.virTypedParamsFree(cparams, cnparams)
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3665,7 +3665,7 @@ func (d *Domain) GetSchedulerParameters()
(*DomainSchedulerParameters, error) {
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -3699,7 +3699,7 @@ func (d *Domain) GetSchedulerParametersFlags(flags
DomainModificationImpact) (*D
return nil, makeError(&err)
}
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
@@ -4534,7 +4534,7 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*DomainGuestVcpus,
error) {
defer C.virTypedParamsFree(cparams, C.int(cnparams))
- _, gerr := typedParamsUnpackLen(cparams, C.int(cnparams), info)
+ _, gerr := typedParamsUnpack(cparams, C.int(cnparams), info)
if gerr != nil {
return nil, gerr
}
@@ -4751,7 +4751,7 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32)
(*DomainLaunchSecurityParam
defer C.virTypedParamsFree(cparams, cnparams)
- _, gerr := typedParamsUnpackLen(cparams, cnparams, info)
+ _, gerr := typedParamsUnpack(cparams, cnparams, info)
if gerr != nil {
return nil, gerr
}
diff --git a/domain_events.go b/domain_events.go
index 7e72313..2aff8e8 100644
--- a/domain_events.go
+++ b/domain_events.go
@@ -763,7 +763,7 @@ func domainEventTunableGetPin(params C.virTypedParameterPtr, cnparams
C.int) *Do
numvcpus, numiothreads := countPinInfo(params, cnparams)
pinInfo := getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin)
- num, err := typedParamsUnpackLen(params, cnparams, pinInfo)
+ num, err := typedParamsUnpack(params, cnparams, pinInfo)
if num == 0 || err != nil {
return nil
}
@@ -820,7 +820,7 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr,
params C.vi
var sched DomainSchedulerParameters
schedInfo := getDomainTuneSchedulerParametersFieldInfo(&sched)
- num, _ := typedParamsUnpackLen(params, cnparams, schedInfo)
+ num, _ := typedParamsUnpack(params, cnparams, schedInfo)
if num > 0 {
eventDetails.CpuSched = &sched
}
@@ -831,12 +831,12 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr,
params C.vi
s: &eventDetails.BlkdevDisk,
},
}
- typedParamsUnpackLen(params, cnparams, blknameInfo)
+ typedParamsUnpack(params, cnparams, blknameInfo)
var blktune DomainBlockIoTuneParameters
blktuneInfo := getTuneBlockIoTuneParametersFieldInfo(&blktune)
- num, _ = typedParamsUnpackLen(params, cnparams, blktuneInfo)
+ num, _ = typedParamsUnpack(params, cnparams, blktuneInfo)
if num > 0 {
eventDetails.BlkdevTune = &blktune
}
@@ -910,7 +910,7 @@ func domainEventJobCompletedCallback(c C.virConnectPtr, d
C.virDomainPtr, params
eventDetails := &DomainEventJobCompleted{}
info := getDomainJobInfoFieldInfo(&eventDetails.Info)
- typedParamsUnpackLen(params, cnparams, info)
+ typedParamsUnpack(params, cnparams, info)
callbackFunc := getCallbackId(goCallbackId)
callback, ok := callbackFunc.(DomainEventJobCompletedCallback)
diff --git a/typedparams.go b/typedparams.go
index 0a4c175..ccceee1 100644
--- a/typedparams.go
+++ b/typedparams.go
@@ -53,7 +53,7 @@ type typedParamsFieldInfo struct {
sl *[]string
}
-func typedParamsUnpackLen(cparams *C.virTypedParameter, cnparams C.int, infomap
map[string]typedParamsFieldInfo) (uint, error) {
+func typedParamsUnpack(cparams *C.virTypedParameter, cnparams C.int, infomap
map[string]typedParamsFieldInfo) (uint, error) {
count := uint(0)
for name, value := range infomap {
var err C.virError
diff --git a/typedparams_test.go b/typedparams_test.go
index dca65b2..7720bcd 100644
--- a/typedparams_test.go
+++ b/typedparams_test.go
@@ -86,7 +86,7 @@ func TestPackUnpack(t *testing.T) {
t.Fatal(err)
}
- nout, err := typedParamsUnpackLen(params, nparams, infoout)
+ nout, err := typedParamsUnpack(params, nparams, infoout)
if err != nil {
t.Fatal(err)
}
--
2.20.1
7:16 a.m.
On Thu, Jan 24, 2019 at 01:16:59PM +0000, Daniel P. Berrangé wrote:
Go 1.12 breaks our current typed parameter handling as it appears to
be
deciding some various are no longer live & free'ing them. Mixing go
allocated memory with C API calls often trips with this kind of thing.
This series thus changes the code to use C allocated memory for typed
parameter arrays and use the libvirt APIs where possible.
I'm not sure if anyone on list feels like reviewing this Go code or not.
Most of the time I've just pushed Go changes directly, but I figure putting
it out for review might help people spread the knowledge of the Go
bindings
Been a week so I presume no one cares abuot review & I'll push this
Regards,
Daniel
--
|: https://berrange.com -o- https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org -o- https://fstop138.berrange.com :|
|: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|
2152
days inactive
2159
days old
9 comments
1 participants
participants (1)
-
Daniel P. Berrangé