From nobody Sun Feb 8 05:41:06 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 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