From nobody Sun Feb 8 05:40:52 2026 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