[libvirt] [go PATCH 0/8] Refactor the way typed parameters are handled
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
Signed-off-by: Daniel P. Berrangé <berrange@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
Signed-off-by: Daniel P. Berrangé <berrange@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
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@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
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@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
Signed-off-by: Daniel P. Berrangé <berrange@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
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@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
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@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
Now we only have one variant of this method it can loose the suffix Signed-off-by: Daniel P. Berrangé <berrange@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
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 :|
participants (1)
-
Daniel P. Berrangé