From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 1548335843428732.9060085473043; Thu, 24 Jan 2019 05:17:23 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id E00767EBAD; Thu, 24 Jan 2019 13:17:18 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 940852635A; Thu, 24 Jan 2019 13:17:17 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 04D1C180339D; Thu, 24 Jan 2019 13:17:14 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHDLX016776 for ; Thu, 24 Jan 2019 08:17:13 -0500 Received: by smtp.corp.redhat.com (Postfix) id 62B7A2635A; Thu, 24 Jan 2019 13:17:13 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id 86C1226332; Thu, 24 Jan 2019 13:17:12 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:00 +0000 Message-Id: <20190124131707.17976-2-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 1/8] Fix GetGuestVcpus to actually return some data X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.27]); Thu, 24 Jan 2019 13:17:19 +0000 (UTC) Signed-off-by: Daniel P. Berrang=C3=A9 --- 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 } =20 type DomainGuestVcpus struct { - Vcpus []bool - Online []bool - Offlinable []bool + VcpusSet bool + Vcpus []bool + OnlineSet bool + Online []bool + OfflinableSet bool + Offlinable []bool } =20 -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]typedParamsFieldIn= fo { 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) (*Domain= GuestVcpus, error) { return nil, makeNotImplementedError("virDomainGetGuestVcpus") } =20 - var VcpusSet, OnlineSet, OfflinableSet bool + vcpus :=3D &DomainGuestVcpus{} var VcpusStr, OnlineStr, OfflinableStr string - info :=3D getDomainGuestVcpusParametersFieldInfo(&VcpusSet, &VcpusStr, &O= nlineSet, &OnlineStr, &OfflinableSet, &OfflinableStr) + info :=3D getDomainGuestVcpusParametersFieldInfo(vcpus, &VcpusStr, &Onlin= eStr, &OfflinableStr) =20 var cparams C.virTypedParameterPtr var nparams C.uint @@ -4626,7 +4629,29 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*Domai= nGuestVcpus, error) { return nil, gerr } =20 - return &DomainGuestVcpus{}, nil + if vcpus.VcpusSet { + mask, gerr :=3D parseCPUString(VcpusStr) + if gerr !=3D nil { + return nil, gerr + } + vcpus.Vcpus =3D mask + } + if vcpus.OnlineSet { + mask, gerr :=3D parseCPUString(OnlineStr) + if gerr !=3D nil { + return nil, gerr + } + vcpus.Online =3D mask + } + if vcpus.OfflinableSet { + mask, gerr :=3D parseCPUString(OfflinableStr) + if gerr !=3D nil { + return nil, gerr + } + vcpus.Offlinable =3D mask + } + + return vcpus, nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SetGuestVcpus --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 1548335857993655.0280284238456; Thu, 24 Jan 2019 05:17:37 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id CDD01796E5; Thu, 24 Jan 2019 13:17:35 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 8F945605C5; Thu, 24 Jan 2019 13:17:35 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 32A713F606; Thu, 24 Jan 2019 13:17:35 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHEHd016783 for ; Thu, 24 Jan 2019 08:17:14 -0500 Received: by smtp.corp.redhat.com (Postfix) id 8D9652635A; Thu, 24 Jan 2019 13:17:14 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id C607326E63; Thu, 24 Jan 2019 13:17:13 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:01 +0000 Message-Id: <20190124131707.17976-3-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 2/8] Add missing error reporting when setting typed parameters X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.25]); Thu, 24 Jan 2019 13:17:36 +0000 (UTC) Signed-off-by: Daniel P. Berrang=C3=A9 --- 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 *NodeMem= oryParameters, flags uint32 } =20 ret =3D C.virNodeSetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 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 } =20 ret =3D C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } @@ -2658,6 +2661,9 @@ func (d *Domain) SetBlkioParameters(params *DomainBlk= ioParameters, flags DomainM } =20 ret =3D C.virDomainSetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } @@ -2850,6 +2856,9 @@ func (d *Domain) SetBlockIoTune(disk string, params *= DomainBlockIoTuneParameters } =20 ret =3D C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } @@ -3330,6 +3339,9 @@ func (d *Domain) SetMemoryParameters(params *DomainMe= moryParameters, flags Domai } =20 ret =3D C.virDomainSetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } @@ -3408,6 +3420,9 @@ func (d *Domain) SetNumaParameters(params *DomainNuma= Parameters, flags DomainMod } =20 ret =3D C.virDomainSetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } @@ -3605,6 +3620,9 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEven= ts, flags DomainModificatio } =20 ret =3D C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(f= lags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } @@ -3799,6 +3817,9 @@ func (d *Domain) SetSchedulerParameters(params *Domai= nSchedulerParameters) error } =20 ret =3D C.virDomainSetSchedulerParametersWrapper(d.ptr, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), nparams, &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } @@ -3832,6 +3853,9 @@ func (d *Domain) SetSchedulerParametersFlags(params *= DomainSchedulerParameters, } =20 ret =3D C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTyped= Parameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + if ret =3D=3D -1 { + return makeError(&err) + } =20 return nil } --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 1548335862696654.2447434863496; Thu, 24 Jan 2019 05:17:42 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 3B868C09942B; Thu, 24 Jan 2019 13:17:40 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 04047BA9E; Thu, 24 Jan 2019 13:17:40 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 9F8DD18033A3; Thu, 24 Jan 2019 13:17:39 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHF7F016793 for ; Thu, 24 Jan 2019 08:17:15 -0500 Received: by smtp.corp.redhat.com (Postfix) id C3F1426DFC; Thu, 24 Jan 2019 13:17:15 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id E908326332; Thu, 24 Jan 2019 13:17:14 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:02 +0000 Message-Id: <20190124131707.17976-4-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 3/8] Change typedParamsPackNew to use a C allocated array X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.31]); Thu, 24 Jan 2019 13:17:41 +0000 (UTC) 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=C3=A9 --- 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 str= ing, params *DomainBlockCopyP =20 info :=3D getBlockCopyParameterFieldInfo(params) =20 - cparams, gerr :=3D typedParamsPackNew(info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } - nparams :=3D len(*cparams) =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cpar= ams)[0])), C.int(nparams)) + defer C.virTypedParamsFree(cparams, cnparams) =20 var err C.virError - ret :=3D C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml, (*C.virTyped= Parameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.uint(flags), = &err) + ret :=3D C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml, cparams, cnp= arams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -2375,16 +2374,15 @@ func getMigrateParameterFieldInfo(params *DomainMig= rateParameters) map[string]ty func (d *Domain) Migrate3(dconn *Connect, params *DomainMigrateParameters,= flags DomainMigrateFlags) (*Domain, error) { =20 info :=3D getMigrateParameterFieldInfo(params) - cparams, gerr :=3D typedParamsPackNew(info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return nil, gerr } - nparams :=3D len(*cparams) =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cpar= ams)[0])), C.int(nparams)) + defer C.virTypedParamsFree(cparams, cnparams) =20 var err C.virError - ret :=3D C.virDomainMigrate3Wrapper(d.ptr, dconn.ptr, (*C.virTypedParamet= er)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags), &err) + ret :=3D C.virDomainMigrate3Wrapper(d.ptr, dconn.ptr, cparams, C.uint(cnp= arams), C.uint(flags), &err) if ret =3D=3D nil { return nil, makeError(&err) } @@ -2455,16 +2453,15 @@ func (d *Domain) MigrateToURI3(dconnuri string, par= ams *DomainMigrateParameters, } =20 info :=3D getMigrateParameterFieldInfo(params) - cparams, gerr :=3D typedParamsPackNew(info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } - nparams :=3D len(*cparams) =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cpar= ams)[0])), C.int(nparams)) + defer C.virTypedParamsFree(cparams, cnparams) =20 var err C.virError - ret :=3D C.virDomainMigrateToURI3Wrapper(d.ptr, cdconnuri, (*C.virTypedPa= rameter)(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags), &= err) + ret :=3D C.virDomainMigrateToURI3Wrapper(d.ptr, cdconnuri, cparams, C.uin= t(cnparams), C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -4272,16 +4269,15 @@ func (d *Domain) SetIOThreadParams(iothreadid uint,= params *DomainSetIOThreadPar } info :=3D getSetIOThreadParamsFieldInfo(params) =20 - cparams, gerr :=3D typedParamsPackNew(info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } - nparams :=3D len(*cparams) =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&(*cpar= ams)[0])), C.int(nparams)) + defer C.virTypedParamsFree(cparams, cnparams) =20 var err C.virError - ret :=3D C.virDomainSetIOThreadParamsWrapper(d.ptr, C.uint(iothreadid), (= *C.virTypedParameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.ui= nt(flags), &err) + ret :=3D C.virDomainSetIOThreadParamsWrapper(d.ptr, C.uint(iothreadid), c= params, cnparams, C.uint(flags), &err) if ret =3D=3D -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 #include #include +#include "typedparams_wrapper.h" */ import "C" =20 @@ -197,66 +198,70 @@ func typedParamsPack(cparams []C.virTypedParameter, i= nfomap map[string]typedPara return typedParamsPackLen(&cparams[0], len(cparams), infomap) } =20 -func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*[]C.vir= TypedParameter, error) { - nparams :=3D 0 - for _, value :=3D range infomap { - if !*value.set { - continue - } +func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*C.virTy= pedParameter, C.int, error) { + var cparams C.virTypedParameterPtr + var nparams C.int + var maxparams C.int =20 - if value.sl !=3D nil { - nparams +=3D len(*value.sl) - } else { - nparams++ - } - } + defer C.virTypedParamsFree(cparams, nparams) =20 - cparams :=3D make([]C.virTypedParameter, nparams) - nparams =3D 0 - for key, value :=3D range infomap { + for name, value :=3D range infomap { if !*value.set { continue } =20 - cfield :=3D C.CString(key) - defer C.free(unsafe.Pointer(cfield)) - clen :=3D len(key) + 1 - if clen > C.VIR_TYPED_PARAM_FIELD_LENGTH { - clen =3D C.VIR_TYPED_PARAM_FIELD_LENGTH - } + cname :=3D C.CString(name) + defer C.free(unsafe.Pointer(cname)) if value.sl !=3D 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 :=3D 0; i < len(*value.sl); i++ { - cparam :=3D &cparams[nparams] - cparam._type =3D C.VIR_TYPED_PARAM_STRING - C.memcpy(unsafe.Pointer(&cparam.field[0]), unsafe.Pointer(cfield), C.s= ize_t(clen)) - nparams++ + cvalue :=3D C.CString((*value.sl)[i]) + defer C.free(unsafe.Pointer(cvalue)) + var err C.virError + ret :=3D C.virTypedParamsAddStringWrapper(&cparams, &nparams, &maxpara= ms, cname, cvalue, &err) + if ret < 0 { + return nil, 0, makeError(&err) + } } } else { - cparam :=3D &cparams[nparams] + var err C.virError + var ret C.int if value.i !=3D nil { - cparam._type =3D C.VIR_TYPED_PARAM_INT + ret =3D C.virTypedParamsAddIntWrapper(&cparams, &nparams, &maxparams, = cname, C.int(*value.i), &err) } else if value.ui !=3D nil { - cparam._type =3D C.VIR_TYPED_PARAM_UINT + ret =3D C.virTypedParamsAddUIntWrapper(&cparams, &nparams, &maxparams,= cname, C.uint(*value.ui), &err) } else if value.l !=3D nil { - cparam._type =3D C.VIR_TYPED_PARAM_LLONG + ret =3D C.virTypedParamsAddLLongWrapper(&cparams, &nparams, &maxparams= , cname, C.longlong(*value.l), &err) } else if value.ul !=3D nil { - cparam._type =3D C.VIR_TYPED_PARAM_ULLONG + ret =3D C.virTypedParamsAddULLongWrapper(&cparams, &nparams, &maxparam= s, cname, C.ulonglong(*value.ul), &err) } else if value.b !=3D nil { - cparam._type =3D C.VIR_TYPED_PARAM_BOOLEAN + v :=3D 0 + if *value.b { + v =3D 1 + } + ret =3D C.virTypedParamsAddBooleanWrapper(&cparams, &nparams, &maxpara= ms, cname, C.int(v), &err) } else if value.d !=3D nil { - cparam._type =3D C.VIR_TYPED_PARAM_DOUBLE + ret =3D C.virTypedParamsAddDoubleWrapper(&cparams, &nparams, &maxparam= s, cname, C.double(*value.i), &err) } else if value.s !=3D nil { - cparam._type =3D C.VIR_TYPED_PARAM_STRING + cvalue :=3D C.CString(*value.s) + defer C.free(unsafe.Pointer(cvalue)) + ret =3D C.virTypedParamsAddStringWrapper(&cparams, &nparams, &maxparam= s, 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.si= ze_t(clen)) - nparams++ } } =20 - err :=3D typedParamsPack(cparams, infomap) - if err !=3D 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, } =20 - params, err :=3D typedParamsPackNew(infoin) + params, nparams, err :=3D typedParamsPackNew(infoin) if err !=3D nil { + lverr, ok :=3D err.(Error) + if ok && lverr.Code =3D=3D ERR_NO_SUPPORT { + return + } t.Fatal(err) } =20 - nout, err :=3D typedParamsUnpack(*params, infoout) + nout, err :=3D typedParamsUnpackLen(params, int(nparams), infoout) if err !=3D 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"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included= in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS= OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL= THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING= FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS = IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +package libvirt + +/* +#cgo pkg-config: libvirt +#include +#include "typedparams_wrapper.h" + +int +virTypedParamsAddIntWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + int value, + virErrorPtr err) +{ + int ret =3D virTypedParamsAddInt(params, nparams, maxparams, name, val= ue); + 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 =3D virTypedParamsAddUInt(params, nparams, maxparams, name, va= lue); + 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 =3D virTypedParamsAddLLong(params, nparams, maxparams, name, v= alue); + 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 =3D 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 =3D 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 =3D 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 =3D 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"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included= in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS= OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL= THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING= FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS = IN + * THE SOFTWARE. + * + * Copyright (C) 2019 Red Hat, Inc. + * + */ + +#ifndef LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ +#define LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ + +#include +#include + +int +virTypedParamsAddIntWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + int value, + virErrorPtr err); +int +virTypedParamsAddUIntWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + unsigned int value, + virErrorPtr err); +int +virTypedParamsAddLLongWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + long long value, + virErrorPtr err); +int +virTypedParamsAddULLongWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + unsigned long long value, + virErrorPtr err); +int +virTypedParamsAddDoubleWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + double value, + virErrorPtr err); +int +virTypedParamsAddBooleanWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + int value, + virErrorPtr err); +int +virTypedParamsAddStringWrapper(virTypedParameterPtr *params, + int *nparams, + int *maxparams, + const char *name, + const char *value, + virErrorPtr err); + +#endif /* LIBVIRT_GO_TYPEDPARAMS_WRAPPER_H__ */ --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 1548335843509580.1779941724941; Thu, 24 Jan 2019 05:17:23 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 937DAC059B85; Thu, 24 Jan 2019 13:17:20 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 538DD1001F5E; Thu, 24 Jan 2019 13:17:20 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id F00BD180339F; Thu, 24 Jan 2019 13:17:19 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHHN1016801 for ; Thu, 24 Jan 2019 08:17:17 -0500 Received: by smtp.corp.redhat.com (Postfix) id A6B2C26E63; Thu, 24 Jan 2019 13:17:17 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id 39C9326332; Thu, 24 Jan 2019 13:17:15 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:03 +0000 Message-Id: <20190124131707.17976-5-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 4/8] Switch typedParamsUnpackLen to use accessor methods X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Thu, 24 Jan 2019 13:17:21 +0000 (UTC) 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=C3=A9 --- 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, s= tatsTypes DomainStatsTypes, state :=3D &DomainStatsState{} stateInfo :=3D getDomainStatsStateFieldInfo(state) =20 - count, gerr :=3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.np= arams), stateInfo) + count, gerr :=3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparam= s, stateInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2822,7 +2822,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, cpu :=3D &DomainStatsCPU{} cpuInfo :=3D getDomainStatsCPUFieldInfo(cpu) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.npa= rams), cpuInfo) + count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , cpuInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2833,7 +2833,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, balloon :=3D &DomainStatsBalloon{} balloonInfo :=3D getDomainStatsBalloonFieldInfo(balloon) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.npa= rams), balloonInfo) + count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , balloonInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2844,7 +2844,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, perf :=3D &DomainStatsPerf{} perfInfo :=3D getDomainStatsPerfFieldInfo(perf) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.npa= rams), perfInfo) + count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , perfInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2855,7 +2855,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, lengths :=3D domainStatsLengths{} lengthsInfo :=3D getDomainStatsLengthsFieldInfo(&lengths) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.npa= rams), lengthsInfo) + count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , lengthsInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2871,7 +2871,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, vcpu :=3D DomainStatsVcpu{} vcpuInfo :=3D getDomainStatsVcpuFieldInfo(j, &vcpu) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.n= params), vcpuInfo) + count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.npara= ms, vcpuInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2889,7 +2889,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, block :=3D DomainStatsBlock{} blockInfo :=3D getDomainStatsBlockFieldInfo(j, &block) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.n= params), blockInfo) + count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.npara= ms, blockInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2905,7 +2905,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, net :=3D DomainStatsNet{} netInfo :=3D getDomainStatsNetFieldInfo(j, &net) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, int(cdomstats.n= params), netInfo) + count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.npara= ms, netInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2977,7 +2977,7 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSEVP= arameters, error) { =20 defer C.virTypedParamsFree(cparams, nparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) if gerr !=3D 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 DomainGetJobStatsF= lags) (*DomainJobInfo, erro params :=3D DomainJobInfo{} info :=3D getDomainJobInfoFieldInfo(¶ms) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) if gerr !=3D nil { return nil, gerr } @@ -3585,7 +3585,7 @@ func (d *Domain) GetPerfEvents(flags DomainModificati= onImpact) (*DomainPerfEvent =20 defer C.virTypedParamsFree(cparams, nparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) if gerr !=3D nil { return nil, gerr } @@ -4644,7 +4644,7 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*Domain= GuestVcpus, error) { =20 defer C.virTypedParamsFree(cparams, C.int(nparams)) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr :=3D typedParamsUnpackLen(cparams, C.int(nparams), info) if gerr !=3D nil { return nil, gerr } @@ -4861,7 +4861,7 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32) = (*DomainLaunchSecurityParam =20 defer C.virTypedParamsFree(cparams, nparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) if gerr !=3D 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.virTypedParamete= rPtr, nparams C.int) *Dom numvcpus, numiothreads :=3D countPinInfo(params, nparams) pinInfo :=3D getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin) =20 - num, err :=3D typedParamsUnpackLen(params, int(nparams), pinInfo) + num, err :=3D typedParamsUnpackLen(params, nparams, pinInfo) if num =3D=3D 0 || err !=3D nil { return nil } @@ -820,7 +820,7 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.= virDomainPtr, params C.vi var sched DomainSchedulerParameters schedInfo :=3D getDomainTuneSchedulerParametersFieldInfo(&sched) =20 - num, _ :=3D typedParamsUnpackLen(params, int(nparams), schedInfo) + num, _ :=3D typedParamsUnpackLen(params, nparams, schedInfo) if num > 0 { eventDetails.CpuSched =3D &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) =20 var blktune DomainBlockIoTuneParameters blktuneInfo :=3D getTuneBlockIoTuneParametersFieldInfo(&blktune) =20 - num, _ =3D typedParamsUnpackLen(params, int(nparams), blktuneInfo) + num, _ =3D typedParamsUnpackLen(params, nparams, blktuneInfo) if num > 0 { eventDetails.BlkdevTune =3D &blktune } @@ -910,7 +910,7 @@ func domainEventJobCompletedCallback(c C.virConnectPtr,= d C.virDomainPtr, params eventDetails :=3D &DomainEventJobCompleted{} info :=3D getDomainJobInfoFieldInfo(&eventDetails.Info) =20 - typedParamsUnpackLen(params, int(nparams), info) + typedParamsUnpackLen(params, nparams, info) =20 callbackFunc :=3D getCallbackId(goCallbackId) callback, ok :=3D 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 } =20 -func typedParamsUnpackLen(cparams *C.virTypedParameter, nparams int, infom= ap map[string]typedParamsFieldInfo) (uint, error) { +func typedParamsUnpackLen(cparams *C.virTypedParameter, cnparams C.int, in= fomap map[string]typedParamsFieldInfo) (uint, error) { count :=3D uint(0) - for i :=3D 0; i < nparams; i++ { - var cparam *C.virTypedParameter - cparam =3D (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(= cparams)) + unsafe.Sizeof(*cparam)*uintptr(i))) - name :=3D C.GoString((*C.char)(unsafe.Pointer(&cparam.field))) - info, ok :=3D 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 =3D=3D nil { - return 0, fmt.Errorf("field %s expects an int", name) - } - *info.i =3D int(*(*C.int)(unsafe.Pointer(&cparam.value))) - *info.set =3D true - case C.VIR_TYPED_PARAM_UINT: - if info.ui =3D=3D nil { - return 0, fmt.Errorf("field %s expects a uint", name) - } - *info.ui =3D uint(*(*C.uint)(unsafe.Pointer(&cparam.value))) - *info.set =3D true - case C.VIR_TYPED_PARAM_LLONG: - if info.l =3D=3D nil { - return 0, fmt.Errorf("field %s expects an int64", name) - } - *info.l =3D int64(*(*C.longlong)(unsafe.Pointer(&cparam.value))) - *info.set =3D true - case C.VIR_TYPED_PARAM_ULLONG: - if info.ul =3D=3D nil { - return 0, fmt.Errorf("field %s expects a uint64", name) - } - *info.ul =3D uint64(*(*C.ulonglong)(unsafe.Pointer(&cparam.value))) - *info.set =3D true - case C.VIR_TYPED_PARAM_DOUBLE: - if info.d =3D=3D nil { - return 0, fmt.Errorf("field %s expects a float64", name) + for name, value :=3D range infomap { + var err C.virError + var ret C.int + cname :=3D C.CString(name) + defer C.free(unsafe.Pointer(cname)) + if value.sl !=3D nil { + for i :=3D 0; i < int(cnparams); i++ { + var cparam *C.virTypedParameter + cparam =3D (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointe= r(cparams)) + + (unsafe.Sizeof(*cparam) * uintptr(i)))) + var cs *C.char + ret =3D C.virTypedParamsGetStringWrapper(cparam, 1, cname, &cs, &err) + if ret =3D=3D 1 { + *value.sl =3D append(*value.sl, C.GoString(cs)) + *value.set =3D true + count++ + } } - *info.d =3D float64(*(*C.double)(unsafe.Pointer(&cparam.value))) - *info.set =3D true - case C.VIR_TYPED_PARAM_BOOLEAN: - if info.b =3D=3D nil { - return 0, fmt.Errorf("field %s expects a bool", name) + } else { + if value.i !=3D nil { + var ci C.int + ret =3D C.virTypedParamsGetIntWrapper(cparams, cnparams, cname, &ci, &= err) + if ret =3D=3D 1 { + *value.i =3D int(ci) + } + } else if value.ui !=3D nil { + var cui C.uint + ret =3D C.virTypedParamsGetUIntWrapper(cparams, cnparams, cname, &cui,= &err) + if ret =3D=3D 1 { + *value.ui =3D uint(cui) + } + } else if value.l !=3D nil { + var cl C.longlong + ret =3D C.virTypedParamsGetLLongWrapper(cparams, cnparams, cname, &cl,= &err) + if ret =3D=3D 1 { + *value.l =3D int64(cl) + } + } else if value.ul !=3D nil { + var cul C.ulonglong + ret =3D C.virTypedParamsGetULLongWrapper(cparams, cnparams, cname, &cu= l, &err) + if ret =3D=3D 1 { + *value.ul =3D uint64(cul) + } + } else if value.d !=3D nil { + var cd C.double + ret =3D C.virTypedParamsGetDoubleWrapper(cparams, cnparams, cname, &cd= , &err) + if ret =3D=3D 1 { + *value.d =3D float64(cd) + } + } else if value.b !=3D nil { + var cb C.int + ret =3D C.virTypedParamsGetBooleanWrapper(cparams, cnparams, cname, &c= b, &err) + if ret =3D=3D 1 { + if cb =3D=3D 1 { + *value.b =3D true + } else { + *value.b =3D false + } + } + } else if value.s !=3D nil { + var cs *C.char + ret =3D C.virTypedParamsGetStringWrapper(cparams, cnparams, cname, &cs= , &err) + if ret =3D=3D 1 { + *value.s =3D C.GoString(cs) + } } - *info.b =3D *(*C.char)(unsafe.Pointer(&cparam.value)) =3D=3D 1 - *info.set =3D true - case C.VIR_TYPED_PARAM_STRING: - if info.s !=3D nil { - *info.s =3D C.GoString(*(**C.char)(unsafe.Pointer(&cparam.value))) - *info.set =3D true - } else if info.sl !=3D nil { - *info.sl =3D append(*info.sl, C.GoString(*(**C.char)(unsafe.Pointer(&c= param.value)))) - *info.set =3D true - } else { - return 0, fmt.Errorf("field %s expects a string/string list", name) + if ret =3D=3D 1 { + *value.set =3D true + count++ } } - count++ } =20 return count, nil } =20 func typedParamsUnpack(cparams []C.virTypedParameter, infomap map[string]t= ypedParamsFieldInfo) (uint, error) { - return typedParamsUnpackLen(&cparams[0], len(cparams), infomap) + return typedParamsUnpackLen(&cparams[0], C.int(len(cparams)), infomap) } =20 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) } =20 - nout, err :=3D typedParamsUnpackLen(params, int(nparams), infoout) + nout, err :=3D typedParamsUnpackLen(params, nparams, infoout) if err !=3D 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; } =20 + +int +virTypedParamsGetIntWrapper(virTypedParameterPtr params, + int nparams, + const char *name, + int *value, + virErrorPtr err) +{ + int ret =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 =3D 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 *par= ams, const char *value, virErrorPtr err); =20 +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__ */ --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 15483358595341001.6838697852974; Thu, 24 Jan 2019 05:17:39 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 17E0DC07456A; Thu, 24 Jan 2019 13:17:37 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 3910D1F8; Thu, 24 Jan 2019 13:17:35 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id E19B33F605; Thu, 24 Jan 2019 13:17:34 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHL2w016822 for ; Thu, 24 Jan 2019 08:17:21 -0500 Received: by smtp.corp.redhat.com (Postfix) id 3254326332; Thu, 24 Jan 2019 13:17:21 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id 077F826E69; Thu, 24 Jan 2019 13:17:17 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:04 +0000 Message-Id: <20190124131707.17976-6-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 5/8] Use 'cnparams' for virTypedParameters array length variables X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Thu, 24 Jan 2019 13:17:37 +0000 (UTC) Signed-off-by: Daniel P. Berrang=C3=A9 --- 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 { =20 // See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetC= PUStats func (c *Connect) GetCPUStats(cpuNum int, flags uint32) (*NodeCPUStats, er= ror) { - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), nil, &nparams,= C.uint(0), &err) + ret :=3D C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), nil, &cnparams= , C.uint(0), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - params :=3D make([]C.virNodeCPUStats, nparams) - ret =3D C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), (*C.virNodeCPUS= tats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags), &err) + params :=3D make([]C.virNodeCPUStats, cnparams) + ret =3D C.virNodeGetCPUStatsWrapper(c.ptr, C.int(cpuNum), (*C.virNodeCPUS= tats)(unsafe.Pointer(¶ms[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 stats :=3D &NodeCPUStats{} - for i :=3D 0; i < int(nparams); i++ { + for i :=3D 0; i < int(cnparams); i++ { param :=3D params[i] field :=3D C.GoString((*C.char)(unsafe.Pointer(¶m.field))) switch field { @@ -1897,21 +1897,21 @@ func (c *Connect) GetMemoryParameters(flags uint32)= (*NodeMemoryParameters, erro params :=3D &NodeMemoryParameters{} info :=3D getMemoryParameterFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, C.uint= (0), &err) + ret :=3D C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &cnparams, C.uin= t(0), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -1934,22 +1934,22 @@ type NodeMemoryStats struct { =20 // See also https://libvirt.org/html/libvirt-libvirt-host.html#virNodeGetM= emoryStats func (c *Connect) GetMemoryStats(cellNum int, flags uint32) (*NodeMemorySt= ats, error) { - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), nil, &npar= ams, 0, &err) + ret :=3D C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), nil, &cnpa= rams, 0, &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - params :=3D make([]C.virNodeMemoryStats, nparams) - ret =3D C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), (*C.virNode= MemoryStats)(unsafe.Pointer(¶ms[0])), &nparams, C.uint(flags), &err) + params :=3D make([]C.virNodeMemoryStats, cnparams) + ret =3D C.virNodeGetMemoryStatsWrapper(c.ptr, C.int(cellNum), (*C.virNode= MemoryStats)(unsafe.Pointer(¶ms[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 stats :=3D &NodeMemoryStats{} - for i :=3D 0; i < int(nparams); i++ { + for i :=3D 0; i < int(cnparams); i++ { param :=3D params[i] field :=3D C.GoString((*C.char)(unsafe.Pointer(¶m.field))) switch field { @@ -1995,28 +1995,28 @@ func (c *Connect) GetSecurityModel() (*NodeSecurity= Model, error) { func (c *Connect) SetMemoryParameters(params *NodeMemoryParameters, flags = uint32) error { info :=3D getMemoryParameterFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &nparams, 0, &er= r) + ret :=3D C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &cnparams, 0, &e= rr) if ret =3D=3D -1 { return makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virNodeSetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + ret =3D C.virNodeSetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -2967,17 +2967,17 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSE= VParameters, error) { info :=3D getNodeSEVFieldInfo(params) =20 var cparams *C.virTypedParameter - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virNodeGetSEVInfoWrapper(c.ptr, (*C.virTypedParameterPtr)(unsa= fe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret :=3D C.virNodeGetSEVInfoWrapper(c.ptr, (*C.virTypedParameterPtr)(unsa= fe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D 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 ui= nt, flags uint32) ([]DomainCP if ret =3D=3D -1 { return []DomainCPUStats{}, makeError(&err) } - nparams :=3D uint(ret) + cnparams :=3D uint(ret) =20 var cparams []C.virTypedParameter var nallocparams uint if startCpu =3D=3D -1 { - nallocparams =3D nparams + nallocparams =3D cnparams } else { - nallocparams =3D nparams * nCpus + nallocparams =3D cnparams * nCpus } cparams =3D make([]C.virTypedParameter, nallocparams) - ret =3D C.virDomainGetCPUStatsWrapper(d.ptr, (*C.virTypedParameter)(unsaf= e.Pointer(&cparams[0])), C.uint(nparams), C.int(startCpu), C.uint(nCpus), C= .uint(flags), &err) + ret =3D C.virDomainGetCPUStatsWrapper(d.ptr, (*C.virTypedParameter)(unsaf= e.Pointer(&cparams[0])), C.uint(cnparams), C.int(startCpu), C.uint(nCpus), = C.uint(flags), &err) if ret =3D=3D -1 { return []DomainCPUStats{}, makeError(&err) } @@ -1192,7 +1192,7 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint= , flags uint32) ([]DomainCP =20 stats :=3D make([]DomainCPUStats, nCpus) for i :=3D 0; i < int(nCpus); i++ { - offset :=3D i * int(nparams) + offset :=3D i * int(cnparams) info :=3D getCPUStatsFieldInfo(&stats[i]) cparamscpu :=3D cparams[offset : offset+int(ret)] _, gerr :=3D typedParamsUnpack(cparamscpu, info) @@ -1258,23 +1258,23 @@ func (d *Domain) GetInterfaceParameters(device stri= ng, flags DomainModificationI params :=3D &DomainInterfaceParameters{} info :=3D getInterfaceParameterFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 cdevice :=3D C.CString(device) defer C.free(unsafe.Pointer(cdevice)) var err C.virError - ret :=3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &n= params, C.uint(0), &err) + ret :=3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &c= nparams, C.uint(0), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -1288,30 +1288,30 @@ func (d *Domain) GetInterfaceParameters(device stri= ng, flags DomainModificationI func (d *Domain) SetInterfaceParameters(device string, params *DomainInter= faceParameters, flags DomainModificationImpact) error { info :=3D getInterfaceParameterFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 cdevice :=3D C.CString(device) defer C.free(unsafe.Pointer(cdevice)) var err C.virError - ret :=3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &n= params, 0, &err) + ret :=3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &c= nparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + ret =3D C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -1661,23 +1661,23 @@ func (d *Domain) BlockStatsFlags(disk string, flags= uint32) (*DomainBlockStats, params :=3D &DomainBlockStats{} info :=3D getBlockStatsFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 cdisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) var err C.virError - ret :=3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &nparams, C= .uint(0), &err) + ret :=3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &cnparams, = C.uint(0), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -2609,20 +2609,20 @@ func (d *Domain) GetBlkioParameters(flags DomainMod= ificationImpact) (*DomainBlki params :=3D &DomainBlkioParameters{} info :=3D getBlkioParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - ret :=3D C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &e= rr) + ret :=3D C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &cnparams, 0, &= err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -2636,28 +2636,28 @@ func (d *Domain) GetBlkioParameters(flags DomainMod= ificationImpact) (*DomainBlki func (d *Domain) SetBlkioParameters(params *DomainBlkioParameters, flags D= omainModificationImpact) error { info :=3D getBlkioParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &e= rr) + ret :=3D C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &cnparams, 0, &= err) if ret =3D=3D -1 { return makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + ret =3D C.virDomainSetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -2801,20 +2801,20 @@ func (d *Domain) GetBlockIoTune(disk string, flags = DomainModificationImpact) (*D params :=3D &DomainBlockIoTuneParameters{} info :=3D getBlockIoTuneParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - ret :=3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0,= &err) + ret :=3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &cnparams, 0= , &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -2831,28 +2831,28 @@ func (d *Domain) SetBlockIoTune(disk string, params= *DomainBlockIoTuneParameters =20 info :=3D getBlockIoTuneParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0,= &err) + ret :=3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &cnparams, 0= , &err) if ret =3D=3D -1 { return makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + ret =3D C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3195,19 +3195,19 @@ func getDomainJobInfoFieldInfo(params *DomainJobInf= o) map[string]typedParamsFiel // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetJobStats 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 :=3D C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret :=3D C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) =20 params :=3D DomainJobInfo{} info :=3D getDomainJobInfoFieldInfo(¶ms) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3287,20 +3287,20 @@ func (d *Domain) GetMemoryParameters(flags DomainMo= dificationImpact) (*DomainMem params :=3D &DomainMemoryParameters{} info :=3D getDomainMemoryParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - ret :=3D C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &= err) + ret :=3D C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &cnparams, 0, = &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -3314,28 +3314,28 @@ func (d *Domain) GetMemoryParameters(flags DomainMo= dificationImpact) (*DomainMem func (d *Domain) SetMemoryParameters(params *DomainMemoryParameters, flags= DomainModificationImpact) error { info :=3D getDomainMemoryParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &= err) + ret :=3D C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &cnparams, 0, = &err) if ret =3D=3D -1 { return makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + ret =3D C.virDomainSetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3368,20 +3368,20 @@ func (d *Domain) GetNumaParameters(flags DomainModi= ficationImpact) (*DomainNumaP params :=3D &DomainNumaParameters{} info :=3D getDomainNumaParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - ret :=3D C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &er= r) + ret :=3D C.virDomainGetNumaParametersWrapper(d.ptr, nil, &cnparams, 0, &e= rr) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -3395,28 +3395,28 @@ func (d *Domain) GetNumaParameters(flags DomainModi= ficationImpact) (*DomainNumaP func (d *Domain) SetNumaParameters(params *DomainNumaParameters, flags Dom= ainModificationImpact) error { info :=3D getDomainNumaParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &er= r) + ret :=3D C.virDomainGetNumaParametersWrapper(d.ptr, nil, &cnparams, 0, &e= rr) if ret =3D=3D -1 { return makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + ret =3D C.virDomainSetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3576,16 +3576,16 @@ func (d *Domain) GetPerfEvents(flags DomainModifica= tionImpact) (*DomainPerfEvent info :=3D getDomainPerfEventsFieldInfo(params) =20 var cparams *C.virTypedParameter - var nparams C.int + var cnparams C.int var err C.virError - ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3602,21 +3602,21 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEv= ents, flags DomainModificatio info :=3D getDomainPerfEventsFieldInfo(params) =20 var cparams *C.virTypedParameter - var nparams C.int + var cnparams C.int var err C.virError - ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } =20 - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) =20 - gerr :=3D typedParamsPackLen(cparams, int(nparams), info) + gerr :=3D typedParamsPackLen(cparams, int(cnparams), info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(f= lags), &err) + ret =3D C.virDomainSetPerfEventsWrapper(d.ptr, cparams, cnparams, C.uint(= flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3722,26 +3722,26 @@ func (d *Domain) GetSchedulerParameters() (*DomainS= chedulerParameters, error) { params :=3D &DomainSchedulerParameters{} info :=3D getDomainSchedulerParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) if schedtype =3D=3D nil { return nil, makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) - if nparams =3D=3D 0 { + if cnparams =3D=3D 0 { return &DomainSchedulerParameters{ Type: C.GoString(schedtype), }, nil } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &nparams, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &cnparams, &err) if ret =3D=3D -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -3756,26 +3756,26 @@ func (d *Domain) GetSchedulerParametersFlags(flags = DomainModificationImpact) (*D params :=3D &DomainSchedulerParameters{} info :=3D getDomainSchedulerParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) if schedtype =3D=3D nil { return nil, makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) - if nparams =3D=3D 0 { + if cnparams =3D=3D 0 { return &DomainSchedulerParameters{ Type: C.GoString(schedtype), }, nil } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 _, gerr :=3D typedParamsUnpack(cparams, info) if gerr !=3D nil { @@ -3789,31 +3789,31 @@ func (d *Domain) GetSchedulerParametersFlags(flags = DomainModificationImpact) (*D func (d *Domain) SetSchedulerParameters(params *DomainSchedulerParameters)= error { info :=3D getDomainSchedulerParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) if schedtype =3D=3D nil { return makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) - if nparams =3D=3D 0 { + if cnparams =3D=3D 0 { return nil } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &nparams, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &cnparams, &err) if ret =3D=3D -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetSchedulerParametersWrapper(d.ptr, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), nparams, &err) + ret =3D C.virDomainSetSchedulerParametersWrapper(d.ptr, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), cnparams, &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3825,31 +3825,31 @@ func (d *Domain) SetSchedulerParameters(params *Dom= ainSchedulerParameters) error func (d *Domain) SetSchedulerParametersFlags(params *DomainSchedulerParame= ters, flags DomainModificationImpact) error { info :=3D getDomainSchedulerParametersFieldInfo(params) =20 - var nparams C.int + var cnparams C.int var err C.virError - schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) if schedtype =3D=3D nil { return makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) - if nparams =3D=3D 0 { + if cnparams =3D=3D 0 { return nil } =20 - cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) + cparams :=3D make([]C.virTypedParameter, cnparams) + ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) if ret =3D=3D -1 { return makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) + defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 gerr :=3D typedParamsPack(cparams, info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTyped= Parameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) + ret =3D C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTyped= Parameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -4635,16 +4635,16 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*Doma= inGuestVcpus, error) { info :=3D getDomainGuestVcpusParametersFieldInfo(vcpus, &VcpusStr, &Onlin= eStr, &OfflinableStr) =20 var cparams C.virTypedParameterPtr - var nparams C.uint + var cnparams C.uint var err C.virError - ret :=3D C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &nparams, C.uin= t(flags), &err) + ret :=3D C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &cnparams, C.ui= nt(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsFree(cparams, C.int(nparams)) + defer C.virTypedParamsFree(cparams, C.int(cnparams)) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, C.int(nparams), info) + _, gerr :=3D typedParamsUnpackLen(cparams, C.int(cnparams), info) if gerr !=3D nil { return nil, gerr } @@ -4851,17 +4851,17 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32= ) (*DomainLaunchSecurityParam info :=3D getDomainLaunchSecurityFieldInfo(params) =20 var cparams *C.virTypedParameter - var nparams C.int + var cnparams C.int =20 var err C.virError - ret :=3D C.virDomainGetLaunchSecurityInfoWrapper(d.ptr, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) + ret :=3D C.virDomainGetLaunchSecurityInfoWrapper(d.ptr, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsFree(cparams, nparams) + defer C.virTypedParamsFree(cparams, cnparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, nparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D 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, npa= rams C.int) (int, int) { return maxvcpus + 1, maxiothreads + 1 } =20 -func domainEventTunableGetPin(params C.virTypedParameterPtr, nparams C.int= ) *DomainEventTunableCpuPin { +func domainEventTunableGetPin(params C.virTypedParameterPtr, cnparams C.in= t) *DomainEventTunableCpuPin { var pin domainEventTunablePinTemp - numvcpus, numiothreads :=3D countPinInfo(params, nparams) + numvcpus, numiothreads :=3D countPinInfo(params, cnparams) pinInfo :=3D getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin) =20 - num, err :=3D typedParamsUnpackLen(params, nparams, pinInfo) + num, err :=3D typedParamsUnpackLen(params, cnparams, pinInfo) if num =3D=3D 0 || err !=3D nil { return nil } @@ -806,13 +806,13 @@ func domainEventTunableGetPin(params C.virTypedParame= terPtr, nparams C.int) *Dom } =20 //export domainEventTunableCallback -func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, param= s C.virTypedParameterPtr, nparams C.int, goCallbackId int) { +func domainEventTunableCallback(c C.virConnectPtr, d C.virDomainPtr, param= s C.virTypedParameterPtr, cnparams C.int, goCallbackId int) { domain :=3D &Domain{ptr: d} connection :=3D &Connect{ptr: c} =20 eventDetails :=3D &DomainEventTunable{} =20 - pin :=3D domainEventTunableGetPin(params, nparams) + pin :=3D domainEventTunableGetPin(params, cnparams) if pin !=3D nil { eventDetails.CpuPin =3D pin } @@ -820,7 +820,7 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.= virDomainPtr, params C.vi var sched DomainSchedulerParameters schedInfo :=3D getDomainTuneSchedulerParametersFieldInfo(&sched) =20 - num, _ :=3D typedParamsUnpackLen(params, nparams, schedInfo) + num, _ :=3D typedParamsUnpackLen(params, cnparams, schedInfo) if num > 0 { eventDetails.CpuSched =3D &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) =20 var blktune DomainBlockIoTuneParameters blktuneInfo :=3D getTuneBlockIoTuneParametersFieldInfo(&blktune) =20 - num, _ =3D typedParamsUnpackLen(params, nparams, blktuneInfo) + num, _ =3D typedParamsUnpackLen(params, cnparams, blktuneInfo) if num > 0 { eventDetails.BlkdevTune =3D &blktune } @@ -903,14 +903,14 @@ func domainEventMigrationIterationCallback(c C.virCon= nectPtr, d C.virDomainPtr, } =20 //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 :=3D &Domain{ptr: d} connection :=3D &Connect{ptr: c} =20 eventDetails :=3D &DomainEventJobCompleted{} info :=3D getDomainJobInfoFieldInfo(&eventDetails.Info) =20 - typedParamsUnpackLen(params, nparams, info) + typedParamsUnpackLen(params, cnparams, info) =20 callbackFunc :=3D getCallbackId(goCallbackId) callback, ok :=3D callbackFunc.(DomainEventJobCompletedCallback) --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 1548335867778974.8959165569571; Thu, 24 Jan 2019 05:17:47 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 09583A7FF2; Thu, 24 Jan 2019 13:17:45 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id BA4025D6A9; Thu, 24 Jan 2019 13:17:44 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 7335618033A6; Thu, 24 Jan 2019 13:17:44 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHMdQ016836 for ; Thu, 24 Jan 2019 08:17:22 -0500 Received: by smtp.corp.redhat.com (Postfix) id E9DE826DFC; Thu, 24 Jan 2019 13:17:22 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id A189126332; Thu, 24 Jan 2019 13:17:21 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:05 +0000 Message-Id: <20190124131707.17976-7-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 6/8] Simplify setting of typed parameters X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.28]); Thu, 24 Jan 2019 13:17:45 +0000 (UTC) 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=C3=A9 --- 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() (*NodeSecurity= Model, error) { func (c *Connect) SetMemoryParameters(params *NodeMemoryParameters, flags = uint32) error { info :=3D getMemoryParameterFieldInfo(params) =20 - var cnparams C.int - - var err C.virError - ret :=3D C.virNodeGetMemoryParametersWrapper(c.ptr, nil, &cnparams, 0, &e= rr) - if ret =3D=3D -1 { - return makeError(&err) - } - - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D 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 :=3D C.virNodeSetMemoryParametersWrapper(c.ptr, cparams, cnparams, C.= uint(flags), &err) if ret =3D=3D -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 stri= ng, flags DomainModificationI func (d *Domain) SetInterfaceParameters(device string, params *DomainInter= faceParameters, flags DomainModificationImpact) error { info :=3D getInterfaceParameterFieldInfo(params) =20 - var cnparams C.int - cdevice :=3D C.CString(device) defer C.free(unsafe.Pointer(cdevice)) - var err C.virError - ret :=3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &c= nparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret :=3D C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, cparams= , cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -2636,28 +2624,15 @@ func (d *Domain) GetBlkioParameters(flags DomainMod= ificationImpact) (*DomainBlki func (d *Domain) SetBlkioParameters(params *DomainBlkioParameters, flags D= omainModificationImpact) error { info :=3D getBlkioParametersFieldInfo(params) =20 - var cnparams C.int - - var err C.virError - ret :=3D C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &cnparams, 0, &= err) - if ret =3D=3D -1 { - return makeError(&err) - } - - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D 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 :=3D C.virDomainSetBlkioParametersWrapper(d.ptr, cparams, cnparams, C= .uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -2831,28 +2806,15 @@ func (d *Domain) SetBlockIoTune(disk string, params= *DomainBlockIoTuneParameters =20 info :=3D getBlockIoTuneParametersFieldInfo(params) =20 - var cnparams C.int - - var err C.virError - ret :=3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &cnparams, 0= , &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret :=3D C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, cparams, cnparams= , C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3314,28 +3276,15 @@ func (d *Domain) GetMemoryParameters(flags DomainMo= dificationImpact) (*DomainMem func (d *Domain) SetMemoryParameters(params *DomainMemoryParameters, flags= DomainModificationImpact) error { info :=3D getDomainMemoryParametersFieldInfo(params) =20 - var cnparams C.int - - var err C.virError - ret :=3D C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &cnparams, 0, = &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret :=3D C.virDomainSetMemoryParametersWrapper(d.ptr, cparams, cnparams, = C.uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3395,28 +3344,15 @@ func (d *Domain) GetNumaParameters(flags DomainModi= ficationImpact) (*DomainNumaP func (d *Domain) SetNumaParameters(params *DomainNumaParameters, flags Dom= ainModificationImpact) error { info :=3D getDomainNumaParametersFieldInfo(params) =20 - var cnparams C.int - - var err C.virError - ret :=3D C.virDomainGetNumaParametersWrapper(d.ptr, nil, &cnparams, 0, &e= rr) - if ret =3D=3D -1 { - return makeError(&err) - } - - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D 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 :=3D C.virDomainSetNumaParametersWrapper(d.ptr, cparams, cnparams, C.= uint(flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3601,22 +3537,14 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEv= ents, flags DomainModificatio =20 info :=3D getDomainPerfEventsFieldInfo(params) =20 - var cparams *C.virTypedParameter - var cnparams C.int - var err C.virError - ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) - if ret =3D=3D -1 { - return makeError(&err) - } - - defer C.virTypedParamsFree(cparams, cnparams) - - gerr :=3D typedParamsPackLen(cparams, int(cnparams), info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } + defer C.virTypedParamsFree(cparams, cnparams) =20 - ret =3D C.virDomainSetPerfEventsWrapper(d.ptr, cparams, cnparams, C.uint(= flags), &err) + var err C.virError + ret :=3D C.virDomainSetPerfEventsWrapper(d.ptr, cparams, cnparams, C.uint= (flags), &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3789,31 +3717,15 @@ func (d *Domain) GetSchedulerParametersFlags(flags = DomainModificationImpact) (*D func (d *Domain) SetSchedulerParameters(params *DomainSchedulerParameters)= error { info :=3D getDomainSchedulerParametersFieldInfo(params) =20 - var cnparams C.int - var err C.virError - schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) - if schedtype =3D=3D nil { - return makeError(&err) - } - - defer C.free(unsafe.Pointer(schedtype)) - if cnparams =3D=3D 0 { - return nil - } - - cparams :=3D make([]C.virTypedParameter, cnparams) - ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &cnparams, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetSchedulerParametersWrapper(d.ptr, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), cnparams, &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret :=3D C.virDomainSetSchedulerParametersWrapper(d.ptr, cparams, cnparam= s, &err) if ret =3D=3D -1 { return makeError(&err) } @@ -3825,31 +3737,15 @@ func (d *Domain) SetSchedulerParameters(params *Dom= ainSchedulerParameters) error func (d *Domain) SetSchedulerParametersFlags(params *DomainSchedulerParame= ters, flags DomainModificationImpact) error { info :=3D getDomainSchedulerParametersFieldInfo(params) =20 - var cnparams C.int - var err C.virError - schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &cnparams, &err) - if schedtype =3D=3D nil { - return makeError(&err) - } - - defer C.free(unsafe.Pointer(schedtype)) - if cnparams =3D=3D 0 { - return nil - } - - cparams :=3D make([]C.virTypedParameter, cnparams) - ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &cnparams, 0, &err) - if ret =3D=3D -1 { - return makeError(&err) - } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - gerr :=3D typedParamsPack(cparams, info) + cparams, cnparams, gerr :=3D typedParamsPackNew(info) if gerr !=3D nil { return gerr } =20 - ret =3D C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTyped= Parameter)(unsafe.Pointer(&cparams[0])), cnparams, C.uint(flags), &err) + defer C.virTypedParamsFree(cparams, cnparams) + + var err C.virError + ret :=3D C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, cparams, cn= params, C.uint(flags), &err) if ret =3D=3D -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) } =20 -func typedParamsPackLen(cparams *C.virTypedParameter, nparams int, infomap= map[string]typedParamsFieldInfo) error { - stringOffsets :=3D make(map[string]uint) - - for i :=3D 0; i < nparams; i++ { - var cparam *C.virTypedParameter - cparam =3D (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Pointer(= cparams)) + unsafe.Sizeof(*cparam)*uintptr(i))) - name :=3D C.GoString((*C.char)(unsafe.Pointer(&cparam.field))) - info, ok :=3D 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 =3D=3D nil { - return fmt.Errorf("field %s expects an int", name) - } - *(*C.int)(unsafe.Pointer(&cparam.value)) =3D C.int(*info.i) - case C.VIR_TYPED_PARAM_UINT: - if info.ui =3D=3D nil { - return fmt.Errorf("field %s expects a uint", name) - } - *(*C.uint)(unsafe.Pointer(&cparam.value)) =3D C.uint(*info.ui) - case C.VIR_TYPED_PARAM_LLONG: - if info.l =3D=3D nil { - return fmt.Errorf("field %s expects an int64", name) - } - *(*C.longlong)(unsafe.Pointer(&cparam.value)) =3D C.longlong(*info.l) - case C.VIR_TYPED_PARAM_ULLONG: - if info.ul =3D=3D nil { - return fmt.Errorf("field %s expects a uint64", name) - } - *(*C.ulonglong)(unsafe.Pointer(&cparam.value)) =3D C.ulonglong(*info.ul) - case C.VIR_TYPED_PARAM_DOUBLE: - if info.d =3D=3D nil { - return fmt.Errorf("field %s expects a float64", name) - } - *(*C.double)(unsafe.Pointer(&cparam.value)) =3D C.double(*info.d) - case C.VIR_TYPED_PARAM_BOOLEAN: - if info.b =3D=3D nil { - return fmt.Errorf("field %s expects a bool", name) - } - if *info.b { - *(*C.char)(unsafe.Pointer(&cparam.value)) =3D 1 - } else { - *(*C.char)(unsafe.Pointer(&cparam.value)) =3D 0 - } - case C.VIR_TYPED_PARAM_STRING: - if info.s !=3D nil { - *(**C.char)(unsafe.Pointer(&cparam.value)) =3D C.CString(*info.s) - } else if info.sl !=3D nil { - count :=3D stringOffsets[name] - *(**C.char)(unsafe.Pointer(&cparam.value)) =3D C.CString((*info.sl)[co= unt]) - stringOffsets[name] =3D count + 1 - } else { - return fmt.Errorf("field %s expects a string", name) - } - } - } - - return nil -} - -func typedParamsPack(cparams []C.virTypedParameter, infomap map[string]typ= edParamsFieldInfo) error { - return typedParamsPackLen(&cparams[0], len(cparams), infomap) -} - func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*C.virTy= pedParameter, C.int, error) { var cparams C.virTypedParameterPtr var nparams C.int --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 1548335872450917.1095062628451; Thu, 24 Jan 2019 05:17:52 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 764738E675; Thu, 24 Jan 2019 13:17:50 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 36C986D089; Thu, 24 Jan 2019 13:17:50 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id A8D893F605; Thu, 24 Jan 2019 13:17:49 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHOcO016853 for ; Thu, 24 Jan 2019 08:17:24 -0500 Received: by smtp.corp.redhat.com (Postfix) id 562012635A; Thu, 24 Jan 2019 13:17:24 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id 4FACF26E63; Thu, 24 Jan 2019 13:17:23 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:06 +0000 Message-Id: <20190124131707.17976-8-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 7/8] Switch remaining typed parameter code to use C allocs X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.25]); Thu, 24 Jan 2019 13:17:51 +0000 (UTC) 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=C3=A9 --- 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) } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virNodeGetMemoryParametersWrapper(c.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret =3D C.virNodeGetMemoryParametersWrapper(c.ptr, cparams, &cnparams, C.= uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D 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 ui= nt, flags uint32) ([]DomainCP if ret =3D=3D -1 { return []DomainCPUStats{}, makeError(&err) } - cnparams :=3D uint(ret) + cnparams :=3D C.int(ret) =20 - var cparams []C.virTypedParameter - var nallocparams uint + var cnallocparams C.int if startCpu =3D=3D -1 { - nallocparams =3D cnparams + cnallocparams =3D cnparams } else { - nallocparams =3D cnparams * nCpus + cnallocparams =3D cnparams * C.int(nCpus) } - cparams =3D make([]C.virTypedParameter, nallocparams) - ret =3D C.virDomainGetCPUStatsWrapper(d.ptr, (*C.virTypedParameter)(unsaf= e.Pointer(&cparams[0])), C.uint(cnparams), C.int(startCpu), C.uint(nCpus), = C.uint(flags), &err) + cparams :=3D typedParamsNew(cnallocparams) + defer C.virTypedParamsFree(cparams, cnallocparams) + ret =3D C.virDomainGetCPUStatsWrapper(d.ptr, cparams, C.uint(cnparams), C= .int(startCpu), C.uint(nCpus), C.uint(flags), &err) if ret =3D=3D -1 { return []DomainCPUStats{}, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), C.int(nallocparams)) - stats :=3D make([]DomainCPUStats, nCpus) for i :=3D 0; i < int(nCpus); i++ { - offset :=3D i * int(cnparams) + coffset :=3D C.int(i) * cnparams info :=3D getCPUStatsFieldInfo(&stats[i]) - cparamscpu :=3D cparams[offset : offset+int(ret)] - _, gerr :=3D typedParamsUnpack(cparamscpu, info) + var cparamscpu *C.virTypedParameter + cparamscpu =3D (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Poin= ter(cparams)) + + (unsafe.Sizeof(*cparams) * uintptr(coffset)))) + _, gerr :=3D typedParamsUnpackLen(cparamscpu, cnparams, info) if gerr !=3D nil { return []DomainCPUStats{}, gerr } @@ -1268,15 +1268,14 @@ func (d *Domain) GetInterfaceParameters(device stri= ng, flags DomainModificationI return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, cparams,= &cnparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -1659,15 +1658,14 @@ func (d *Domain) BlockStatsFlags(disk string, flags= uint32) (*DomainBlockStats, return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret =3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, cparams, &cnparam= s, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -2604,15 +2602,14 @@ func (d *Domain) GetBlkioParameters(flags DomainMod= ificationImpact) (*DomainBlki return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, cparams, &cnparams, C= .uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -2783,15 +2780,14 @@ func (d *Domain) GetBlockIoTune(disk string, flags = DomainModificationImpact) (*D return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, cparams, &cnparams= , C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3156,11 +3152,11 @@ func getDomainJobInfoFieldInfo(params *DomainJobInf= o) map[string]typedParamsFiel =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetJobStats 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 :=3D C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) + ret :=3D C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, &cparams, &cnpara= ms, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } @@ -3256,15 +3252,14 @@ func (d *Domain) GetMemoryParameters(flags DomainMo= dificationImpact) (*DomainMem return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, cparams, &cnparams, = C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3324,15 +3319,14 @@ func (d *Domain) GetNumaParameters(flags DomainModi= ficationImpact) (*DomainNumaP return nil, makeError(&err) } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, cparams, &cnparams, C.= uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } =20 - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) - - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3511,10 +3505,10 @@ func (d *Domain) GetPerfEvents(flags DomainModifica= tionImpact) (*DomainPerfEvent params :=3D &DomainPerfEvents{} info :=3D getDomainPerfEventsFieldInfo(params) =20 - var cparams *C.virTypedParameter + var cparams C.virTypedParameterPtr var cnparams C.int var err C.virError - ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &cnparams, C.uint(flags), &err) + ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, &cparams, &cnparams, C.ui= nt(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } @@ -3664,14 +3658,14 @@ func (d *Domain) GetSchedulerParameters() (*DomainS= chedulerParameters, error) { }, nil } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &cnparams, &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, cparams, &cnpara= ms, &err) if ret =3D=3D -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3698,14 +3692,14 @@ func (d *Domain) GetSchedulerParametersFlags(flags = DomainModificationImpact) (*D }, nil } =20 - cparams :=3D make([]C.virTypedParameter, cnparams) - ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &cnparams, C.uint(flags), &err) + cparams :=3D typedParamsNew(cnparams) + defer C.virTypedParamsFree(cparams, cnparams) + ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, cparams, &c= nparams, C.uint(flags), &err) if ret =3D=3D -1 { return nil, makeError(&err) } - defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), cnparams) =20 - _, gerr :=3D typedParamsUnpack(cparams, info) + _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) if gerr !=3D 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 } =20 -func typedParamsUnpack(cparams []C.virTypedParameter, infomap map[string]t= ypedParamsFieldInfo) (uint, error) { - return typedParamsUnpackLen(&cparams[0], C.int(len(cparams)), infomap) +func typedParamsNew(nparams C.int) *C.virTypedParameter { + var cparams *C.virTypedParameter + memlen :=3D C.size_t(unsafe.Sizeof(*cparams) * uintptr(nparams)) + cparams =3D (*C.virTypedParameter)(C.malloc(memlen)) + if cparams =3D=3D nil { + C.abort() + } + C.memset(unsafe.Pointer(cparams), 0, memlen) + return cparams } =20 func typedParamsPackNew(infomap map[string]typedParamsFieldInfo) (*C.virTy= pedParameter, C.int, error) { --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list From nobody Mon May 6 08:20:12 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; envelope-from=libvir-list-bounces@redhat.com; helo=mx1.redhat.com; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=libvir-list-bounces@redhat.com; dmarc=pass(p=none dis=none) header.from=redhat.com Return-Path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by mx.zohomail.com with SMTPS id 1548335861716406.80878427574453; Thu, 24 Jan 2019 05:17:41 -0800 (PST) Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id A4D1A9D789; Thu, 24 Jan 2019 13:17:39 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 6B22B5D75E; Thu, 24 Jan 2019 13:17:39 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 1997018033A1; Thu, 24 Jan 2019 13:17:39 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id x0ODHPG4016861 for ; Thu, 24 Jan 2019 08:17:25 -0500 Received: by smtp.corp.redhat.com (Postfix) id B09C726DFC; Thu, 24 Jan 2019 13:17:25 +0000 (UTC) Received: from localhost.localdomain.com (ovpn-112-61.ams2.redhat.com [10.36.112.61]) by smtp.corp.redhat.com (Postfix) with ESMTP id B385D26332; Thu, 24 Jan 2019 13:17:24 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Thu, 24 Jan 2019 13:17:07 +0000 Message-Id: <20190124131707.17976-9-berrange@redhat.com> In-Reply-To: <20190124131707.17976-1-berrange@redhat.com> References: <20190124131707.17976-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 8/8] Rename typedParamsUnpackLen to typedParamsUnpack X-BeenThere: libvir-list@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: Development discussions about the libvirt library & tools List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: libvir-list-bounces@redhat.com Errors-To: libvir-list-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.28]); Thu, 24 Jan 2019 13:17:40 +0000 (UTC) Now we only have one variant of this method it can loose the suffix Signed-off-by: Daniel P. Berrang=C3=A9 --- 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) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -2797,7 +2797,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, state :=3D &DomainStatsState{} stateInfo :=3D getDomainStatsStateFieldInfo(state) =20 - count, gerr :=3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparam= s, stateInfo) + count, gerr :=3D typedParamsUnpack(cdomstats.params, cdomstats.nparams, = stateInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2808,7 +2808,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, cpu :=3D &DomainStatsCPU{} cpuInfo :=3D getDomainStatsCPUFieldInfo(cpu) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , cpuInfo) + count, gerr =3D typedParamsUnpack(cdomstats.params, cdomstats.nparams, c= puInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2819,7 +2819,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, balloon :=3D &DomainStatsBalloon{} balloonInfo :=3D getDomainStatsBalloonFieldInfo(balloon) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , balloonInfo) + count, gerr =3D typedParamsUnpack(cdomstats.params, cdomstats.nparams, b= alloonInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2830,7 +2830,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, perf :=3D &DomainStatsPerf{} perfInfo :=3D getDomainStatsPerfFieldInfo(perf) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , perfInfo) + count, gerr =3D typedParamsUnpack(cdomstats.params, cdomstats.nparams, p= erfInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2841,7 +2841,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, lengths :=3D domainStatsLengths{} lengthsInfo :=3D getDomainStatsLengthsFieldInfo(&lengths) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.nparams= , lengthsInfo) + count, gerr =3D typedParamsUnpack(cdomstats.params, cdomstats.nparams, l= engthsInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2857,7 +2857,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, vcpu :=3D DomainStatsVcpu{} vcpuInfo :=3D getDomainStatsVcpuFieldInfo(j, &vcpu) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.npara= ms, vcpuInfo) + count, gerr =3D typedParamsUnpack(cdomstats.params, cdomstats.nparams,= vcpuInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2875,7 +2875,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, block :=3D DomainStatsBlock{} blockInfo :=3D getDomainStatsBlockFieldInfo(j, &block) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.npara= ms, blockInfo) + count, gerr =3D typedParamsUnpack(cdomstats.params, cdomstats.nparams,= blockInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2891,7 +2891,7 @@ func (c *Connect) GetAllDomainStats(doms []*Domain, s= tatsTypes DomainStatsTypes, net :=3D DomainStatsNet{} netInfo :=3D getDomainStatsNetFieldInfo(j, &net) =20 - count, gerr =3D typedParamsUnpackLen(cdomstats.params, cdomstats.npara= ms, netInfo) + count, gerr =3D typedParamsUnpack(cdomstats.params, cdomstats.nparams,= netInfo) if gerr !=3D nil { return []DomainStats{}, gerr } @@ -2963,7 +2963,7 @@ func (c *Connect) GetSEVInfo(flags uint32) (*NodeSEVP= arameters, error) { =20 defer C.virTypedParamsFree(cparams, cnparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D 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 =3D (*C.virTypedParameter)(unsafe.Pointer(uintptr(unsafe.Poin= ter(cparams)) + (unsafe.Sizeof(*cparams) * uintptr(coffset)))) - _, gerr :=3D typedParamsUnpackLen(cparamscpu, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparamscpu, cnparams, info) if gerr !=3D nil { return []DomainCPUStats{}, gerr } @@ -1275,7 +1275,7 @@ func (d *Domain) GetInterfaceParameters(device string= , flags DomainModificationI return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -1665,7 +1665,7 @@ func (d *Domain) BlockStatsFlags(disk string, flags u= int32) (*DomainBlockStats, return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -2609,7 +2609,7 @@ func (d *Domain) GetBlkioParameters(flags DomainModif= icationImpact) (*DomainBlki return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -2787,7 +2787,7 @@ func (d *Domain) GetBlockIoTune(disk string, flags Do= mainModificationImpact) (*D return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3165,7 +3165,7 @@ func (d *Domain) GetJobStats(flags DomainGetJobStatsF= lags) (*DomainJobInfo, erro params :=3D DomainJobInfo{} info :=3D getDomainJobInfoFieldInfo(¶ms) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3259,7 +3259,7 @@ func (d *Domain) GetMemoryParameters(flags DomainModi= ficationImpact) (*DomainMem return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3326,7 +3326,7 @@ func (d *Domain) GetNumaParameters(flags DomainModifi= cationImpact) (*DomainNumaP return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3515,7 +3515,7 @@ func (d *Domain) GetPerfEvents(flags DomainModificati= onImpact) (*DomainPerfEvent =20 defer C.virTypedParamsFree(cparams, cnparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3665,7 +3665,7 @@ func (d *Domain) GetSchedulerParameters() (*DomainSch= edulerParameters, error) { return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -3699,7 +3699,7 @@ func (d *Domain) GetSchedulerParametersFlags(flags Do= mainModificationImpact) (*D return nil, makeError(&err) } =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D nil { return nil, gerr } @@ -4534,7 +4534,7 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*Domain= GuestVcpus, error) { =20 defer C.virTypedParamsFree(cparams, C.int(cnparams)) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, C.int(cnparams), info) + _, gerr :=3D typedParamsUnpack(cparams, C.int(cnparams), info) if gerr !=3D nil { return nil, gerr } @@ -4751,7 +4751,7 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32) = (*DomainLaunchSecurityParam =20 defer C.virTypedParamsFree(cparams, cnparams) =20 - _, gerr :=3D typedParamsUnpackLen(cparams, cnparams, info) + _, gerr :=3D typedParamsUnpack(cparams, cnparams, info) if gerr !=3D 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.virTypedParamete= rPtr, cnparams C.int) *Do numvcpus, numiothreads :=3D countPinInfo(params, cnparams) pinInfo :=3D getDomainPinTempFieldInfo(numvcpus, numiothreads, &pin) =20 - num, err :=3D typedParamsUnpackLen(params, cnparams, pinInfo) + num, err :=3D typedParamsUnpack(params, cnparams, pinInfo) if num =3D=3D 0 || err !=3D nil { return nil } @@ -820,7 +820,7 @@ func domainEventTunableCallback(c C.virConnectPtr, d C.= virDomainPtr, params C.vi var sched DomainSchedulerParameters schedInfo :=3D getDomainTuneSchedulerParametersFieldInfo(&sched) =20 - num, _ :=3D typedParamsUnpackLen(params, cnparams, schedInfo) + num, _ :=3D typedParamsUnpack(params, cnparams, schedInfo) if num > 0 { eventDetails.CpuSched =3D &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) =20 var blktune DomainBlockIoTuneParameters blktuneInfo :=3D getTuneBlockIoTuneParametersFieldInfo(&blktune) =20 - num, _ =3D typedParamsUnpackLen(params, cnparams, blktuneInfo) + num, _ =3D typedParamsUnpack(params, cnparams, blktuneInfo) if num > 0 { eventDetails.BlkdevTune =3D &blktune } @@ -910,7 +910,7 @@ func domainEventJobCompletedCallback(c C.virConnectPtr,= d C.virDomainPtr, params eventDetails :=3D &DomainEventJobCompleted{} info :=3D getDomainJobInfoFieldInfo(&eventDetails.Info) =20 - typedParamsUnpackLen(params, cnparams, info) + typedParamsUnpack(params, cnparams, info) =20 callbackFunc :=3D getCallbackId(goCallbackId) callback, ok :=3D 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 } =20 -func typedParamsUnpackLen(cparams *C.virTypedParameter, cnparams C.int, in= fomap map[string]typedParamsFieldInfo) (uint, error) { +func typedParamsUnpack(cparams *C.virTypedParameter, cnparams C.int, infom= ap map[string]typedParamsFieldInfo) (uint, error) { count :=3D uint(0) for name, value :=3D 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) } =20 - nout, err :=3D typedParamsUnpackLen(params, nparams, infoout) + nout, err :=3D typedParamsUnpack(params, nparams, infoout) if err !=3D nil { t.Fatal(err) } --=20 2.20.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list