From nobody Sun Feb 8 21:27:10 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 1531747539026464.1520614301163; Mon, 16 Jul 2018 06:25:39 -0700 (PDT) Received: from smtp.corp.redhat.com (int-mx12.intmail.prod.int.phx2.redhat.com [10.5.11.27]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 17EAF368E7; Mon, 16 Jul 2018 13:25: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 D72E3CA5EF; Mon, 16 Jul 2018 13:25:36 +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 81D643F7CC; Mon, 16 Jul 2018 13:25:36 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id w6GDP3Kg028333 for ; Mon, 16 Jul 2018 09:25:03 -0400 Received: by smtp.corp.redhat.com (Postfix) id 1E41D2026D76; Mon, 16 Jul 2018 13:25:03 +0000 (UTC) Received: from t460.redhat.com (unknown [10.33.36.75]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5DEFD2026D65; Mon, 16 Jul 2018 13:25:01 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Mon, 16 Jul 2018 14:24:17 +0100 Message-Id: <20180716132423.10354-32-berrange@redhat.com> In-Reply-To: <20180716132423.10354-1-berrange@redhat.com> References: <20180716132423.10354-1-berrange@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.78 on 10.11.54.4 X-loop: libvir-list@redhat.com Subject: [libvirt] [go PATCH 31/37] domain: fix error reporting thread safety 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.27 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.30]); Mon, 16 Jul 2018 13:25:37 +0000 (UTC) X-ZohoMail: RSF_0 Z_629925259 SPT_0 Create wrapper functions for each domain C API that accepts a virErrorPtr parameter. This avoids accessing a thread local from a goroutine which may race with other goroutines doing native API calls in the same OS thread. Signed-off-by: Daniel P. Berrang=C3=A9 --- domain.go | 1017 +++++++++++--------- domain_wrapper.go | 2335 +++++++++++++++++++++++++++++++++++++++++---- domain_wrapper.h | 942 ++++++++++++++++-- 3 files changed, 3587 insertions(+), 707 deletions(-) diff --git a/domain.go b/domain.go index fad2a41..302cdb8 100644 --- a/domain.go +++ b/domain.go @@ -30,6 +30,7 @@ package libvirt #cgo pkg-config: libvirt #include #include "domain_wrapper.h" +#include "connect_wrapper.h" */ import "C" =20 @@ -858,36 +859,40 @@ type DomainVcpuInfo struct { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Free func (d *Domain) Free() error { - ret :=3D C.virDomainFree(d.ptr) + var err C.virError + ret :=3D C.virDomainFreeWrapper(d.ptr, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Ref func (c *Domain) Ref() error { - ret :=3D C.virDomainRef(c.ptr) + var err C.virError + ret :=3D C.virDomainRefWrapper(c.ptr, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Create func (d *Domain) Create() error { - result :=3D C.virDomainCreate(d.ptr) + var err C.virError + result :=3D C.virDomainCreateWrapper(d.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= CreateWithFlags func (d *Domain) CreateWithFlags(flags DomainCreateFlags) error { - result :=3D C.virDomainCreateWithFlags(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainCreateWithFlagsWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -898,45 +903,50 @@ func (d *Domain) CreateWithFiles(files []os.File, fla= gs DomainCreateFlags) error for i :=3D 0; i < len(files); i++ { cfiles[i] =3D C.int(files[i].Fd()) } - result :=3D C.virDomainCreateWithFiles(d.ptr, C.uint(len(files)), &cfiles= [0], C.uint(flags)) + var err C.virError + result :=3D C.virDomainCreateWithFilesWrapper(d.ptr, C.uint(len(files)), = &cfiles[0], C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Destroy func (d *Domain) Destroy() error { - result :=3D C.virDomainDestroy(d.ptr) + var err C.virError + result :=3D C.virDomainDestroyWrapper(d.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Shutdown func (d *Domain) Shutdown() error { - result :=3D C.virDomainShutdown(d.ptr) + var err C.virError + result :=3D C.virDomainShutdownWrapper(d.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Reboot func (d *Domain) Reboot(flags DomainRebootFlagValues) error { - result :=3D C.virDomainReboot(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainRebootWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= IsActive func (d *Domain) IsActive() (bool, error) { - result :=3D C.virDomainIsActive(d.ptr) + var err C.virError + result :=3D C.virDomainIsActiveWrapper(d.ptr, &err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } if result =3D=3D 1 { return true, nil @@ -946,9 +956,10 @@ func (d *Domain) IsActive() (bool, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= IsPersistent func (d *Domain) IsPersistent() (bool, error) { - result :=3D C.virDomainIsPersistent(d.ptr) + var err C.virError + result :=3D C.virDomainIsPersistentWrapper(d.ptr, &err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } if result =3D=3D 1 { return true, nil @@ -958,9 +969,10 @@ func (d *Domain) IsPersistent() (bool, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= IsUpdated func (d *Domain) IsUpdated() (bool, error) { - result :=3D C.virDomainIsUpdated(d.ptr) + var err C.virError + result :=3D C.virDomainIsUpdatedWrapper(d.ptr, &err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } if result =3D=3D 1 { return true, nil @@ -977,9 +989,10 @@ func (d *Domain) SetAutostart(autostart bool) error { default: cAutostart =3D 0 } - result :=3D C.virDomainSetAutostart(d.ptr, cAutostart) + var err C.virError + result :=3D C.virDomainSetAutostartWrapper(d.ptr, cAutostart, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -987,9 +1000,10 @@ func (d *Domain) SetAutostart(autostart bool) error { // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetAutostart func (d *Domain) GetAutostart() (bool, error) { var out C.int - result :=3D C.virDomainGetAutostart(d.ptr, (*C.int)(unsafe.Pointer(&out))) + var err C.virError + result :=3D C.virDomainGetAutostartWrapper(d.ptr, (*C.int)(unsafe.Pointer= (&out)), &err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } switch out { case 1: @@ -1004,9 +1018,10 @@ func (d *Domain) GetBlockInfo(disk string, flag uint= ) (*DomainBlockInfo, error) var cinfo C.virDomainBlockInfo cDisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cDisk)) - result :=3D C.virDomainGetBlockInfo(d.ptr, cDisk, &cinfo, C.uint(flag)) + var err C.virError + result :=3D C.virDomainGetBlockInfoWrapper(d.ptr, cDisk, &cinfo, C.uint(f= lag), &err) if result =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &DomainBlockInfo{ @@ -1018,9 +1033,10 @@ func (d *Domain) GetBlockInfo(disk string, flag uint= ) (*DomainBlockInfo, error) =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetName func (d *Domain) GetName() (string, error) { - name :=3D C.virDomainGetName(d.ptr) + var err C.virError + name :=3D C.virDomainGetNameWrapper(d.ptr, &err) if name =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) } return C.GoString(name), nil } @@ -1029,21 +1045,23 @@ func (d *Domain) GetName() (string, error) { func (d *Domain) GetState() (DomainState, int, error) { var cState C.int var cReason C.int - result :=3D C.virDomainGetState(d.ptr, + var err C.virError + result :=3D C.virDomainGetStateWrapper(d.ptr, (*C.int)(unsafe.Pointer(&cState)), (*C.int)(unsafe.Pointer(&cReason)), - 0) + 0, &err) if int(result) =3D=3D -1 { - return 0, 0, GetLastError() + return 0, 0, makeError(&err) } return DomainState(cState), int(cReason), nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetID func (d *Domain) GetID() (uint, error) { - id :=3D uint(C.virDomainGetID(d.ptr)) + var err C.virError + id :=3D uint(C.virDomainGetIDWrapper(d.ptr, &err)) if id =3D=3D ^uint(0) { - return id, GetLastError() + return id, makeError(&err) } return id, nil } @@ -1052,9 +1070,10 @@ func (d *Domain) GetID() (uint, error) { func (d *Domain) GetUUID() ([]byte, error) { var cUuid [C.VIR_UUID_BUFLEN](byte) cuidPtr :=3D unsafe.Pointer(&cUuid) - result :=3D C.virDomainGetUUID(d.ptr, (*C.uchar)(cuidPtr)) + var err C.virError + result :=3D C.virDomainGetUUIDWrapper(d.ptr, (*C.uchar)(cuidPtr), &err) if result !=3D 0 { - return []byte{}, GetLastError() + return []byte{}, makeError(&err) } return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil } @@ -1063,9 +1082,10 @@ func (d *Domain) GetUUID() ([]byte, error) { func (d *Domain) GetUUIDString() (string, error) { var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) cuidPtr :=3D unsafe.Pointer(&cUuid) - result :=3D C.virDomainGetUUIDString(d.ptr, (*C.char)(cuidPtr)) + var err C.virError + result :=3D C.virDomainGetUUIDStringWrapper(d.ptr, (*C.char)(cuidPtr), &e= rr) if result !=3D 0 { - return "", GetLastError() + return "", makeError(&err) } return C.GoString((*C.char)(cuidPtr)), nil } @@ -1073,9 +1093,10 @@ func (d *Domain) GetUUIDString() (string, error) { // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetInfo func (d *Domain) GetInfo() (*DomainInfo, error) { var cinfo C.virDomainInfo - result :=3D C.virDomainGetInfo(d.ptr, &cinfo) + var err C.virError + result :=3D C.virDomainGetInfoWrapper(d.ptr, &cinfo, &err) if result =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } return &DomainInfo{ State: DomainState(cinfo.state), @@ -1088,9 +1109,10 @@ func (d *Domain) GetInfo() (*DomainInfo, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetXMLDesc func (d *Domain) GetXMLDesc(flags DomainXMLFlags) (string, error) { - result :=3D C.virDomainGetXMLDesc(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainGetXMLDescWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) } xml :=3D C.GoString(result) C.free(unsafe.Pointer(result)) @@ -1131,21 +1153,22 @@ func getCPUStatsFieldInfo(params *DomainCPUStats) m= ap[string]typedParamsFieldInf =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetCPUStats func (d *Domain) GetCPUStats(startCpu int, nCpus uint, flags uint32) ([]Do= mainCPUStats, error) { + var err C.virError if nCpus =3D=3D 0 { if startCpu =3D=3D -1 { nCpus =3D 1 } else { - ret :=3D C.virDomainGetCPUStats(d.ptr, nil, 0, 0, 0, 0) + ret :=3D C.virDomainGetCPUStatsWrapper(d.ptr, nil, 0, 0, 0, 0, &err) if ret =3D=3D -1 { - return []DomainCPUStats{}, GetLastError() + return []DomainCPUStats{}, makeError(&err) } nCpus =3D uint(ret) } } =20 - ret :=3D C.virDomainGetCPUStats(d.ptr, nil, 0, C.int(startCpu), C.uint(nC= pus), 0) + ret :=3D C.virDomainGetCPUStatsWrapper(d.ptr, nil, 0, C.int(startCpu), C.= uint(nCpus), 0, &err) if ret =3D=3D -1 { - return []DomainCPUStats{}, GetLastError() + return []DomainCPUStats{}, makeError(&err) } nparams :=3D uint(ret) =20 @@ -1157,9 +1180,9 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint= , flags uint32) ([]DomainCP nallocparams =3D nparams * nCpus } cparams =3D make([]C.virTypedParameter, nallocparams) - ret =3D C.virDomainGetCPUStats(d.ptr, (*C.virTypedParameter)(unsafe.Point= er(&cparams[0])), C.uint(nparams), C.int(startCpu), C.uint(nCpus), C.uint(f= lags)) + 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) if ret =3D=3D -1 { - return []DomainCPUStats{}, GetLastError() + return []DomainCPUStats{}, makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), C.int(nallocparams)) @@ -1169,9 +1192,9 @@ func (d *Domain) GetCPUStats(startCpu int, nCpus uint= , flags uint32) ([]DomainCP offset :=3D i * int(nparams) info :=3D getCPUStatsFieldInfo(&stats[i]) cparamscpu :=3D cparams[offset : offset+int(ret)] - _, err :=3D typedParamsUnpack(cparamscpu, info) - if err !=3D nil { - return []DomainCPUStats{}, err + _, gerr :=3D typedParamsUnpack(cparamscpu, info) + if gerr !=3D nil { + return []DomainCPUStats{}, gerr } } return stats, nil @@ -1236,22 +1259,23 @@ func (d *Domain) GetInterfaceParameters(device stri= ng, flags DomainModificationI =20 cdevice :=3D C.CString(device) defer C.free(unsafe.Pointer(cdevice)) - ret :=3D C.virDomainGetInterfaceParameters(d.ptr, cdevice, nil, &nparams,= C.uint(0)) + var err C.virError + ret :=3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &n= params, C.uint(0), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetInterfaceParameters(d.ptr, cdevice, (*C.virTypedPar= ameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags)) + ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -1265,25 +1289,26 @@ func (d *Domain) SetInterfaceParameters(device stri= ng, params *DomainInterfacePa =20 cdevice :=3D C.CString(device) defer C.free(unsafe.Pointer(cdevice)) - ret :=3D C.virDomainGetInterfaceParameters(d.ptr, cdevice, nil, &nparams,= 0) + var err C.virError + ret :=3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, nil, &n= params, 0, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetInterfaceParameters(d.ptr, cdevice, (*C.virTypedPar= ameter)(unsafe.Pointer(&cparams[0])), &nparams, 0) + ret =3D C.virDomainGetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - err :=3D typedParamsPack(cparams, info) - if err !=3D nil { - return err + gerr :=3D typedParamsPack(cparams, info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetInterfaceParameters(d.ptr, cdevice, (*C.virTypedPar= ameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags)) + ret =3D C.virDomainSetInterfaceParametersWrapper(d.ptr, cdevice, (*C.virT= ypedParameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) =20 return nil } @@ -1296,9 +1321,10 @@ func (d *Domain) GetMetadata(tipus DomainMetadataTyp= e, uri string, flags DomainM defer C.free(unsafe.Pointer(cUri)) } =20 - result :=3D C.virDomainGetMetadata(d.ptr, C.int(tipus), cUri, C.uint(flag= s)) + var err C.virError + result :=3D C.virDomainGetMetadataWrapper(d.ptr, C.int(tipus), cUri, C.ui= nt(flags), &err) if result =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) =20 } defer C.free(unsafe.Pointer(result)) @@ -1324,126 +1350,140 @@ func (d *Domain) SetMetadata(metaDataType DomainM= etadataType, metaDataCont, uriK cUri =3D C.CString(uri) defer C.free(unsafe.Pointer(cUri)) } - result :=3D C.virDomainSetMetadata(d.ptr, C.int(metaDataType), cMetaDataC= ont, cUriKey, cUri, C.uint(flags)) + var err C.virError + result :=3D C.virDomainSetMetadataWrapper(d.ptr, C.int(metaDataType), cMe= taDataCont, cUriKey, cUri, C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Undefine func (d *Domain) Undefine() error { - result :=3D C.virDomainUndefine(d.ptr) + var err C.virError + result :=3D C.virDomainUndefineWrapper(d.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= UndefineFlags func (d *Domain) UndefineFlags(flags DomainUndefineFlagsValues) error { - result :=3D C.virDomainUndefineFlags(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainUndefineFlagsWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SetMaxMemory func (d *Domain) SetMaxMemory(memory uint) error { - result :=3D C.virDomainSetMaxMemory(d.ptr, C.ulong(memory)) + var err C.virError + result :=3D C.virDomainSetMaxMemoryWrapper(d.ptr, C.ulong(memory), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SetMemory func (d *Domain) SetMemory(memory uint64) error { - result :=3D C.virDomainSetMemory(d.ptr, C.ulong(memory)) + var err C.virError + result :=3D C.virDomainSetMemoryWrapper(d.ptr, C.ulong(memory), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SetMemoryFlags func (d *Domain) SetMemoryFlags(memory uint64, flags DomainMemoryModFlags)= error { - result :=3D C.virDomainSetMemoryFlags(d.ptr, C.ulong(memory), C.uint(flag= s)) + var err C.virError + result :=3D C.virDomainSetMemoryFlagsWrapper(d.ptr, C.ulong(memory), C.ui= nt(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SetMemoryStatsPeriod func (d *Domain) SetMemoryStatsPeriod(period int, flags DomainMemoryModFla= gs) error { - result :=3D C.virDomainSetMemoryStatsPeriod(d.ptr, C.int(period), C.uint(= flags)) + var err C.virError + result :=3D C.virDomainSetMemoryStatsPeriodWrapper(d.ptr, C.int(period), = C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SetVcpus func (d *Domain) SetVcpus(vcpu uint) error { - result :=3D C.virDomainSetVcpus(d.ptr, C.uint(vcpu)) + var err C.virError + result :=3D C.virDomainSetVcpusWrapper(d.ptr, C.uint(vcpu), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SetVcpusFlags func (d *Domain) SetVcpusFlags(vcpu uint, flags DomainVcpuFlags) error { - result :=3D C.virDomainSetVcpusFlags(d.ptr, C.uint(vcpu), C.uint(flags)) + var err C.virError + result :=3D C.virDomainSetVcpusFlagsWrapper(d.ptr, C.uint(vcpu), C.uint(f= lags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Suspend func (d *Domain) Suspend() error { - result :=3D C.virDomainSuspend(d.ptr) + var err C.virError + result :=3D C.virDomainSuspendWrapper(d.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Resume func (d *Domain) Resume() error { - result :=3D C.virDomainResume(d.ptr) + var err C.virError + result :=3D C.virDomainResumeWrapper(d.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= AbortJob func (d *Domain) AbortJob() error { - result :=3D C.virDomainAbortJob(d.ptr) + var err C.virError + result :=3D C.virDomainAbortJobWrapper(d.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= DestroyFlags func (d *Domain) DestroyFlags(flags DomainDestroyFlags) error { - result :=3D C.virDomainDestroyFlags(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainDestroyFlagsWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= ShutdownFlags func (d *Domain) ShutdownFlags(flags DomainShutdownFlags) error { - result :=3D C.virDomainShutdownFlags(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainShutdownFlagsWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -1452,9 +1492,10 @@ func (d *Domain) ShutdownFlags(flags DomainShutdownF= lags) error { func (d *Domain) AttachDevice(xml string) error { cXml :=3D C.CString(xml) defer C.free(unsafe.Pointer(cXml)) - result :=3D C.virDomainAttachDevice(d.ptr, cXml) + var err C.virError + result :=3D C.virDomainAttachDeviceWrapper(d.ptr, cXml, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -1463,9 +1504,10 @@ func (d *Domain) AttachDevice(xml string) error { func (d *Domain) AttachDeviceFlags(xml string, flags DomainDeviceModifyFla= gs) error { cXml :=3D C.CString(xml) defer C.free(unsafe.Pointer(cXml)) - result :=3D C.virDomainAttachDeviceFlags(d.ptr, cXml, C.uint(flags)) + var err C.virError + result :=3D C.virDomainAttachDeviceFlagsWrapper(d.ptr, cXml, C.uint(flags= ), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -1474,9 +1516,10 @@ func (d *Domain) AttachDeviceFlags(xml string, flags= DomainDeviceModifyFlags) er func (d *Domain) DetachDevice(xml string) error { cXml :=3D C.CString(xml) defer C.free(unsafe.Pointer(cXml)) - result :=3D C.virDomainDetachDevice(d.ptr, cXml) + var err C.virError + result :=3D C.virDomainDetachDeviceWrapper(d.ptr, cXml, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -1485,9 +1528,10 @@ func (d *Domain) DetachDevice(xml string) error { func (d *Domain) DetachDeviceFlags(xml string, flags DomainDeviceModifyFla= gs) error { cXml :=3D C.CString(xml) defer C.free(unsafe.Pointer(cXml)) - result :=3D C.virDomainDetachDeviceFlags(d.ptr, cXml, C.uint(flags)) + var err C.virError + result :=3D C.virDomainDetachDeviceFlagsWrapper(d.ptr, cXml, C.uint(flags= ), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -1500,9 +1544,10 @@ func (d *Domain) DetachDeviceAlias(alias string, fla= gs DomainDeviceModifyFlags) =20 cAlias :=3D C.CString(alias) defer C.free(unsafe.Pointer(cAlias)) - result :=3D C.virDomainDetachDeviceAliasWrapper(d.ptr, cAlias, C.uint(fla= gs)) + var err C.virError + result :=3D C.virDomainDetachDeviceAliasWrapper(d.ptr, cAlias, C.uint(fla= gs), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -1511,18 +1556,20 @@ func (d *Domain) DetachDeviceAlias(alias string, fl= ags DomainDeviceModifyFlags) func (d *Domain) UpdateDeviceFlags(xml string, flags DomainDeviceModifyFla= gs) error { cXml :=3D C.CString(xml) defer C.free(unsafe.Pointer(cXml)) - result :=3D C.virDomainUpdateDeviceFlags(d.ptr, cXml, C.uint(flags)) + var err C.virError + result :=3D C.virDomainUpdateDeviceFlagsWrapper(d.ptr, cXml, C.uint(flags= ), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Screenshot func (d *Domain) Screenshot(stream *Stream, screen, flags uint32) (string,= error) { - cType :=3D C.virDomainScreenshot(d.ptr, stream.ptr, C.uint(screen), C.uin= t(flags)) + var err C.virError + cType :=3D C.virDomainScreenshotWrapper(d.ptr, stream.ptr, C.uint(screen)= , C.uint(flags), &err) if cType =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) } defer C.free(unsafe.Pointer(cType)) =20 @@ -1532,9 +1579,10 @@ func (d *Domain) Screenshot(stream *Stream, screen, = flags uint32) (string, error =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SendKey func (d *Domain) SendKey(codeset, holdtime uint, keycodes []uint, flags ui= nt32) error { - result :=3D C.virDomainSendKey(d.ptr, C.uint(codeset), C.uint(holdtime), = (*C.uint)(unsafe.Pointer(&keycodes[0])), C.int(len(keycodes)), C.uint(flags= )) + var err C.virError + result :=3D C.virDomainSendKeyWrapper(d.ptr, C.uint(codeset), C.uint(hold= time), (*C.uint)(unsafe.Pointer(&keycodes[0])), C.int(len(keycodes)), C.uin= t(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -1611,22 +1659,23 @@ func (d *Domain) BlockStatsFlags(disk string, flags= uint32) (*DomainBlockStats, =20 cdisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) - ret :=3D C.virDomainBlockStatsFlags(d.ptr, cdisk, nil, &nparams, C.uint(0= )) + var err C.virError + ret :=3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, nil, &nparams, C= .uint(0), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainBlockStatsFlags(d.ptr, cdisk, (*C.virTypedParameter)(u= nsafe.Pointer(&cparams[0])), &nparams, C.uint(flags)) + ret =3D C.virDomainBlockStatsFlagsWrapper(d.ptr, cdisk, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -1642,10 +1691,11 @@ func (d *Domain) BlockStats(path string) (*DomainBl= ockStats, error) { cStats :=3D (C.virDomainBlockStatsPtr)(C.malloc(size)) defer C.free(unsafe.Pointer(cStats)) =20 - result :=3D C.virDomainBlockStats(d.ptr, cPath, (C.virDomainBlockStatsPtr= )(cStats), size) + var err C.virError + result :=3D C.virDomainBlockStatsWrapper(d.ptr, cPath, (C.virDomainBlockS= tatsPtr)(cStats), size, &err) =20 if result !=3D 0 { - return nil, GetLastError() + return nil, makeError(&err) } return &DomainBlockStats{ WrReqSet: true, @@ -1688,10 +1738,11 @@ func (d *Domain) InterfaceStats(path string) (*Doma= inInterfaceStats, error) { cStats :=3D (C.virDomainInterfaceStatsPtr)(C.malloc(size)) defer C.free(unsafe.Pointer(cStats)) =20 - result :=3D C.virDomainInterfaceStats(d.ptr, cPath, (C.virDomainInterface= StatsPtr)(cStats), size) + var err C.virError + result :=3D C.virDomainInterfaceStatsWrapper(d.ptr, cPath, (C.virDomainIn= terfaceStatsPtr)(cStats), size, &err) =20 if result !=3D 0 { - return nil, GetLastError() + return nil, makeError(&err) } return &DomainInterfaceStats{ RxBytesSet: true, @@ -1717,12 +1768,13 @@ func (d *Domain) InterfaceStats(path string) (*Doma= inInterfaceStats, error) { func (d *Domain) MemoryStats(nrStats uint32, flags uint32) ([]DomainMemory= Stat, error) { ptr :=3D make([]C.virDomainMemoryStatStruct, nrStats) =20 - result :=3D C.virDomainMemoryStats( + var err C.virError + result :=3D C.virDomainMemoryStatsWrapper( d.ptr, (C.virDomainMemoryStatPtr)(unsafe.Pointer(&ptr[0])), - C.uint(nrStats), C.uint(flags)) + C.uint(nrStats), C.uint(flags), &err) =20 if result =3D=3D -1 { - return []DomainMemoryStat{}, GetLastError() + return []DomainMemoryStat{}, makeError(&err) } =20 out :=3D make([]DomainMemoryStat, 0) @@ -1741,14 +1793,15 @@ func (d *Domain) MemoryStats(nrStats uint32, flags = uint32) ([]DomainMemoryStat, // acquire a reference on the returned Connect, which must // be released by calling Close() func (d *Domain) DomainGetConnect() (*Connect, error) { - ptr :=3D C.virDomainGetConnect(d.ptr) + var err C.virError + ptr :=3D C.virDomainGetConnectWrapper(d.ptr, &err) if ptr =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } =20 - ret :=3D C.virConnectRef(ptr) + ret :=3D C.virConnectRefWrapper(ptr, &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &Connect{ptr: ptr}, nil @@ -1757,15 +1810,16 @@ func (d *Domain) DomainGetConnect() (*Connect, erro= r) { // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetVcpus func (d *Domain) GetVcpus() ([]DomainVcpuInfo, error) { var cnodeinfo C.virNodeInfo - ret :=3D C.virNodeGetInfo(C.virDomainGetConnect(d.ptr), &cnodeinfo) + var err C.virError + ret :=3D C.virNodeGetInfoWrapper(C.virDomainGetConnect(d.ptr), &cnodeinfo= , &err) if ret =3D=3D -1 { - return []DomainVcpuInfo{}, GetLastError() + return []DomainVcpuInfo{}, makeError(&err) } =20 var cdominfo C.virDomainInfo - ret =3D C.virDomainGetInfo(d.ptr, &cdominfo) + ret =3D C.virDomainGetInfoWrapper(d.ptr, &cdominfo, &err) if ret =3D=3D -1 { - return []DomainVcpuInfo{}, GetLastError() + return []DomainVcpuInfo{}, makeError(&err) } =20 nvcpus :=3D int(cdominfo.nrVirtCpu) @@ -1774,9 +1828,9 @@ func (d *Domain) GetVcpus() ([]DomainVcpuInfo, error)= { ccpumaps :=3D make([]C.uchar, maplen*nvcpus) cinfo :=3D make([]C.virVcpuInfo, nvcpus) =20 - ret =3D C.virDomainGetVcpus(d.ptr, &cinfo[0], C.int(nvcpus), &ccpumaps[0]= , C.int(maplen)) + ret =3D C.virDomainGetVcpusWrapper(d.ptr, &cinfo[0], C.int(nvcpus), &ccpu= maps[0], C.int(maplen), &err) if ret =3D=3D -1 { - return []DomainVcpuInfo{}, GetLastError() + return []DomainVcpuInfo{}, makeError(&err) } =20 info :=3D make([]DomainVcpuInfo, int(ret)) @@ -1803,9 +1857,10 @@ func (d *Domain) GetVcpus() ([]DomainVcpuInfo, error= ) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetVcpusFlags func (d *Domain) GetVcpusFlags(flags DomainVcpuFlags) (int32, error) { - result :=3D C.virDomainGetVcpusFlags(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainGetVcpusFlagsWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D -1 { - return 0, GetLastError() + return 0, makeError(&err) } return int32(result), nil } @@ -1822,10 +1877,11 @@ func (d *Domain) PinVcpu(vcpu uint, cpuMap []bool) = error { } } =20 - result :=3D C.virDomainPinVcpu(d.ptr, C.uint(vcpu), &ccpumap[0], C.int(ma= plen)) + var err C.virError + result :=3D C.virDomainPinVcpuWrapper(d.ptr, C.uint(vcpu), &ccpumap[0], C= .int(maplen), &err) =20 if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -1843,10 +1899,11 @@ func (d *Domain) PinVcpuFlags(vcpu uint, cpuMap []b= ool, flags DomainModification } } =20 - result :=3D C.virDomainPinVcpuFlags(d.ptr, C.uint(vcpu), &ccpumap[0], C.i= nt(maplen), C.uint(flags)) + var err C.virError + result :=3D C.virDomainPinVcpuFlagsWrapper(d.ptr, C.uint(vcpu), &ccpumap[= 0], C.int(maplen), C.uint(flags), &err) =20 if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -1871,9 +1928,10 @@ func (d *Domain) ListAllInterfaceAddresses(src Domai= nInterfaceAddressesSource) ( } =20 var cList *C.virDomainInterfacePtr - numIfaces :=3D int(C.virDomainInterfaceAddressesWrapper(d.ptr, (**C.virDo= mainInterfacePtr)(&cList), C.uint(src), 0)) + var err C.virError + numIfaces :=3D int(C.virDomainInterfaceAddressesWrapper(d.ptr, (**C.virDo= mainInterfacePtr)(&cList), C.uint(src), 0, &err)) if numIfaces =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 ifaces :=3D make([]DomainInterface, numIfaces) @@ -1906,9 +1964,10 @@ func (d *Domain) ListAllInterfaceAddresses(src Domai= nInterfaceAddressesSource) ( =20 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#= virDomainSnapshotCurrent func (d *Domain) SnapshotCurrent(flags uint32) (*DomainSnapshot, error) { - result :=3D C.virDomainSnapshotCurrent(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainSnapshotCurrentWrapper(d.ptr, C.uint(flags), &err) if result =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } return &DomainSnapshot{ptr: result}, nil =20 @@ -1916,9 +1975,10 @@ func (d *Domain) SnapshotCurrent(flags uint32) (*Dom= ainSnapshot, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#= virDomainSnapshotNum func (d *Domain) SnapshotNum(flags DomainSnapshotListFlags) (int, error) { - result :=3D int(C.virDomainSnapshotNum(d.ptr, C.uint(flags))) + var err C.virError + result :=3D int(C.virDomainSnapshotNumWrapper(d.ptr, C.uint(flags), &err)) if result =3D=3D -1 { - return 0, GetLastError() + return 0, makeError(&err) } return result, nil } @@ -1927,9 +1987,10 @@ func (d *Domain) SnapshotNum(flags DomainSnapshotLis= tFlags) (int, error) { func (d *Domain) SnapshotLookupByName(name string, flags uint32) (*DomainS= napshot, error) { cName :=3D C.CString(name) defer C.free(unsafe.Pointer(cName)) - ptr :=3D C.virDomainSnapshotLookupByName(d.ptr, cName, C.uint(flags)) + var err C.virError + ptr :=3D C.virDomainSnapshotLookupByNameWrapper(d.ptr, cName, C.uint(flag= s), &err) if ptr =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } return &DomainSnapshot{ptr: ptr}, nil } @@ -1939,12 +2000,13 @@ func (d *Domain) SnapshotListNames(flags DomainSnap= shotListFlags) ([]string, err const maxNames =3D 1024 var names [maxNames](*C.char) namesPtr :=3D unsafe.Pointer(&names) - numNames :=3D C.virDomainSnapshotListNames( + var err C.virError + numNames :=3D C.virDomainSnapshotListNamesWrapper( d.ptr, (**C.char)(namesPtr), - maxNames, C.uint(flags)) + maxNames, C.uint(flags), &err) if numNames =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } goNames :=3D make([]string, numNames) for k :=3D 0; k < int(numNames); k++ { @@ -1957,9 +2019,10 @@ func (d *Domain) SnapshotListNames(flags DomainSnaps= hotListFlags) ([]string, err // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#= virDomainListAllSnapshots func (d *Domain) ListAllSnapshots(flags DomainSnapshotListFlags) ([]Domain= Snapshot, error) { var cList *C.virDomainSnapshotPtr - numVols :=3D C.virDomainListAllSnapshots(d.ptr, (**C.virDomainSnapshotPtr= )(&cList), C.uint(flags)) + var err C.virError + numVols :=3D C.virDomainListAllSnapshotsWrapper(d.ptr, (**C.virDomainSnap= shotPtr)(&cList), C.uint(flags), &err) if numVols =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } hdr :=3D reflect.SliceHeader{ Data: uintptr(unsafe.Pointer(cList)), @@ -1989,9 +2052,10 @@ func (d *Domain) BlockCommit(disk string, base strin= g, top string, bandwidth uin ctop =3D C.CString(top) defer C.free(unsafe.Pointer(ctop)) } - ret :=3D C.virDomainBlockCommit(d.ptr, cdisk, cbase, ctop, C.ulong(bandwi= dth), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainBlockCommitWrapper(d.ptr, cdisk, cbase, ctop, C.ulong= (bandwidth), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -2034,17 +2098,18 @@ func (d *Domain) BlockCopy(disk string, destxml str= ing, params *DomainBlockCopyP =20 info :=3D getBlockCopyParameterFieldInfo(params) =20 - cparams, err :=3D typedParamsPackNew(info) - if err !=3D nil { - return err + cparams, 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)) =20 - ret :=3D C.virDomainBlockCopyWrapper(d.ptr, cdisk, cdestxml, (*C.virTyped= Parameter)(unsafe.Pointer(&(*cparams)[0])), C.int(nparams), C.uint(flags)) + 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) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2054,9 +2119,10 @@ func (d *Domain) BlockCopy(disk string, destxml stri= ng, params *DomainBlockCopyP func (d *Domain) BlockJobAbort(disk string, flags DomainBlockJobAbortFlags= ) error { cdisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) - ret :=3D C.virDomainBlockJobAbort(d.ptr, cdisk, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainBlockJobAbortWrapper(d.ptr, cdisk, C.uint(flags), &er= r) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -2065,9 +2131,10 @@ func (d *Domain) BlockJobAbort(disk string, flags Do= mainBlockJobAbortFlags) erro func (d *Domain) BlockJobSetSpeed(disk string, bandwidth uint64, flags Dom= ainBlockJobSetSpeedFlags) error { cdisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) - ret :=3D C.virDomainBlockJobSetSpeed(d.ptr, cdisk, C.ulong(bandwidth), C.= uint(flags)) + var err C.virError + ret :=3D C.virDomainBlockJobSetSpeedWrapper(d.ptr, cdisk, C.ulong(bandwid= th), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -2076,9 +2143,10 @@ func (d *Domain) BlockJobSetSpeed(disk string, bandw= idth uint64, flags DomainBlo func (d *Domain) BlockPull(disk string, bandwidth uint64, flags DomainBloc= kPullFlags) error { cdisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) - ret :=3D C.virDomainBlockPull(d.ptr, cdisk, C.ulong(bandwidth), C.uint(fl= ags)) + var err C.virError + ret :=3D C.virDomainBlockPullWrapper(d.ptr, cdisk, C.ulong(bandwidth), C.= uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -2092,9 +2160,10 @@ func (d *Domain) BlockRebase(disk string, base strin= g, bandwidth uint64, flags D cbase :=3D C.CString(base) defer C.free(unsafe.Pointer(cbase)) } - ret :=3D C.virDomainBlockRebase(d.ptr, cdisk, cbase, C.ulong(bandwidth), = C.uint(flags)) + var err C.virError + ret :=3D C.virDomainBlockRebaseWrapper(d.ptr, cdisk, cbase, C.ulong(bandw= idth), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -2103,9 +2172,10 @@ func (d *Domain) BlockRebase(disk string, base strin= g, bandwidth uint64, flags D func (d *Domain) BlockResize(disk string, size uint64, flags DomainBlockRe= sizeFlags) error { cdisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) - ret :=3D C.virDomainBlockResize(d.ptr, cdisk, C.ulonglong(size), C.uint(f= lags)) + var err C.virError + ret :=3D C.virDomainBlockResizeWrapper(d.ptr, cdisk, C.ulonglong(size), C= .uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -2115,10 +2185,11 @@ func (d *Domain) BlockPeek(disk string, offset uint= 64, size uint64, flags uint32 cdisk :=3D C.CString(disk) defer C.free(unsafe.Pointer(cdisk)) data :=3D make([]byte, size) - ret :=3D C.virDomainBlockPeek(d.ptr, cdisk, C.ulonglong(offset), C.size_t= (size), - unsafe.Pointer(&data[0]), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainBlockPeekWrapper(d.ptr, cdisk, C.ulonglong(offset), C= .size_t(size), + unsafe.Pointer(&data[0]), C.uint(flags), &err) if ret =3D=3D -1 { - return []byte{}, GetLastError() + return []byte{}, makeError(&err) } =20 return data, nil @@ -2127,10 +2198,11 @@ func (d *Domain) BlockPeek(disk string, offset uint= 64, size uint64, flags uint32 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= MemoryPeek func (d *Domain) MemoryPeek(start uint64, size uint64, flags DomainMemoryF= lags) ([]byte, error) { data :=3D make([]byte, size) - ret :=3D C.virDomainMemoryPeek(d.ptr, C.ulonglong(start), C.size_t(size), - unsafe.Pointer(&data[0]), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainMemoryPeekWrapper(d.ptr, C.ulonglong(start), C.size_t= (size), + unsafe.Pointer(&data[0]), C.uint(flags), &err) if ret =3D=3D -1 { - return []byte{}, GetLastError() + return []byte{}, makeError(&err) } =20 return data, nil @@ -2149,9 +2221,10 @@ func (d *Domain) Migrate(dconn *Connect, flags Domai= nMigrateFlags, dname string, defer C.free(unsafe.Pointer(curi)) } =20 - ret :=3D C.virDomainMigrate(d.ptr, dconn.ptr, C.ulong(flags), cdname, cur= i, C.ulong(bandwidth)) + var err C.virError + ret :=3D C.virDomainMigrateWrapper(d.ptr, dconn.ptr, C.ulong(flags), cdna= me, curi, C.ulong(bandwidth), &err) if ret =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &Domain{ @@ -2177,9 +2250,10 @@ func (d *Domain) Migrate2(dconn *Connect, dxml strin= g, flags DomainMigrateFlags, defer C.free(unsafe.Pointer(curi)) } =20 - ret :=3D C.virDomainMigrate2(d.ptr, dconn.ptr, cdxml, C.ulong(flags), cdn= ame, curi, C.ulong(bandwidth)) + var err C.virError + ret :=3D C.virDomainMigrate2Wrapper(d.ptr, dconn.ptr, cdxml, C.ulong(flag= s), cdname, curi, C.ulong(bandwidth), &err) if ret =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &Domain{ @@ -2295,17 +2369,18 @@ 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, err :=3D typedParamsPackNew(info) - if err !=3D nil { - return nil, err + cparams, 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)) =20 - ret :=3D C.virDomainMigrate3(d.ptr, dconn.ptr, (*C.virTypedParameter)(uns= afe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags)) + 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) if ret =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &Domain{ @@ -2324,9 +2399,10 @@ func (d *Domain) MigrateToURI(duri string, flags Dom= ainMigrateFlags, dname strin defer C.free(unsafe.Pointer(cdname)) } =20 - ret :=3D C.virDomainMigrateToURI(d.ptr, cduri, C.ulong(flags), cdname, C.= ulong(bandwidth)) + var err C.virError + ret :=3D C.virDomainMigrateToURIWrapper(d.ptr, cduri, C.ulong(flags), cdn= ame, C.ulong(bandwidth), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2355,9 +2431,10 @@ func (d *Domain) MigrateToURI2(dconnuri string, migu= ri string, dxml string, flag defer C.free(unsafe.Pointer(cdname)) } =20 - ret :=3D C.virDomainMigrateToURI2(d.ptr, cdconnuri, cmiguri, cdxml, C.ulo= ng(flags), cdname, C.ulong(bandwidth)) + var err C.virError + ret :=3D C.virDomainMigrateToURI2Wrapper(d.ptr, cdconnuri, cmiguri, cdxml= , C.ulong(flags), cdname, C.ulong(bandwidth), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2372,17 +2449,18 @@ func (d *Domain) MigrateToURI3(dconnuri string, par= ams *DomainMigrateParameters, } =20 info :=3D getMigrateParameterFieldInfo(params) - cparams, err :=3D typedParamsPackNew(info) - if err !=3D nil { - return err + cparams, 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)) =20 - ret :=3D C.virDomainMigrateToURI3(d.ptr, cdconnuri, (*C.virTypedParameter= )(unsafe.Pointer(&(*cparams)[0])), C.uint(nparams), C.uint(flags)) + 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) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2392,9 +2470,10 @@ func (d *Domain) MigrateToURI3(dconnuri string, para= ms *DomainMigrateParameters, func (d *Domain) MigrateGetCompressionCache(flags uint32) (uint64, error) { var cacheSize C.ulonglong =20 - ret :=3D C.virDomainMigrateGetCompressionCache(d.ptr, &cacheSize, C.uint(= flags)) + var err C.virError + ret :=3D C.virDomainMigrateGetCompressionCacheWrapper(d.ptr, &cacheSize, = C.uint(flags), &err) if ret =3D=3D -1 { - return 0, GetLastError() + return 0, makeError(&err) } =20 return uint64(cacheSize), nil @@ -2402,9 +2481,10 @@ func (d *Domain) MigrateGetCompressionCache(flags ui= nt32) (uint64, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= MigrateSetCompressionCache func (d *Domain) MigrateSetCompressionCache(size uint64, flags uint32) err= or { - ret :=3D C.virDomainMigrateSetCompressionCache(d.ptr, C.ulonglong(size), = C.uint(flags)) + var err C.virError + ret :=3D C.virDomainMigrateSetCompressionCacheWrapper(d.ptr, C.ulonglong(= size), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2414,9 +2494,10 @@ func (d *Domain) MigrateSetCompressionCache(size uin= t64, flags uint32) error { func (d *Domain) MigrateGetMaxSpeed(flags uint32) (uint64, error) { var maxSpeed C.ulong =20 - ret :=3D C.virDomainMigrateGetMaxSpeed(d.ptr, &maxSpeed, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainMigrateGetMaxSpeedWrapper(d.ptr, &maxSpeed, C.uint(fl= ags), &err) if ret =3D=3D -1 { - return 0, GetLastError() + return 0, makeError(&err) } =20 return uint64(maxSpeed), nil @@ -2424,9 +2505,10 @@ func (d *Domain) MigrateGetMaxSpeed(flags uint32) (u= int64, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= MigrateSetMaxSpeed func (d *Domain) MigrateSetMaxSpeed(speed uint64, flags uint32) error { - ret :=3D C.virDomainMigrateSetMaxSpeed(d.ptr, C.ulong(speed), C.uint(flag= s)) + var err C.virError + ret :=3D C.virDomainMigrateSetMaxSpeedWrapper(d.ptr, C.ulong(speed), C.ui= nt(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2434,9 +2516,10 @@ func (d *Domain) MigrateSetMaxSpeed(speed uint64, fl= ags uint32) error { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= MigrateSetMaxDowntime func (d *Domain) MigrateSetMaxDowntime(downtime uint64, flags uint32) erro= r { - ret :=3D C.virDomainMigrateSetMaxDowntime(d.ptr, C.ulonglong(downtime), C= .uint(flags)) + var err C.virError + ret :=3D C.virDomainMigrateSetMaxDowntimeWrapper(d.ptr, C.ulonglong(downt= ime), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2450,9 +2533,10 @@ func (d *Domain) MigrateGetMaxDowntime(flags uint32)= (uint64, error) { return 0, GetNotImplementedError("virDomainMigrateGetMaxDowntime") } =20 - ret :=3D C.virDomainMigrateGetMaxDowntimeWrapper(d.ptr, &downtimeLen, C.u= int(flags)) + var err C.virError + ret :=3D C.virDomainMigrateGetMaxDowntimeWrapper(d.ptr, &downtimeLen, C.u= int(flags), &err) if ret =3D=3D -1 { - return 0, GetLastError() + return 0, makeError(&err) } =20 return uint64(downtimeLen), nil @@ -2464,9 +2548,10 @@ func (d *Domain) MigrateStartPostCopy(flags uint32) = error { return GetNotImplementedError("virDomainMigrateStartPostCopy") } =20 - ret :=3D C.virDomainMigrateStartPostCopyWrapper(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainMigrateStartPostCopyWrapper(d.ptr, C.uint(flags), &er= r) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -2522,22 +2607,23 @@ func (d *Domain) GetBlkioParameters(flags DomainMod= ificationImpact) (*DomainBlki info :=3D getBlkioParametersFieldInfo(params) =20 var nparams C.int - ret :=3D C.virDomainGetBlkioParameters(d.ptr, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &e= rr) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlkioParameters(d.ptr, (*C.virTypedParameter)(unsaf= e.Pointer(&cparams[0])), &nparams, C.uint(flags)) + ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -2549,25 +2635,26 @@ func (d *Domain) SetBlkioParameters(params *DomainB= lkioParameters, flags DomainM =20 var nparams C.int =20 - ret :=3D C.virDomainGetBlkioParameters(d.ptr, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetBlkioParametersWrapper(d.ptr, nil, &nparams, 0, &e= rr) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlkioParameters(d.ptr, (*C.virTypedParameter)(unsaf= e.Pointer(&cparams[0])), &nparams, 0) + ret =3D C.virDomainGetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - err :=3D typedParamsPack(cparams, info) - if err !=3D nil { - return err + gerr :=3D typedParamsPack(cparams, info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetBlkioParameters(d.ptr, (*C.virTypedParameter)(unsaf= e.Pointer(&cparams[0])), nparams, C.uint(flags)) + ret =3D C.virDomainSetBlkioParametersWrapper(d.ptr, (*C.virTypedParameter= )(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) =20 return nil } @@ -2709,22 +2796,23 @@ func (d *Domain) GetBlockIoTune(disk string, flags = DomainModificationImpact) (*D info :=3D getBlockIoTuneParametersFieldInfo(params) =20 var nparams C.int - ret :=3D C.virDomainGetBlockIoTune(d.ptr, cdisk, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0,= &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlockIoTune(d.ptr, cdisk, (*C.virTypedParameter)(un= safe.Pointer(&cparams[0])), &nparams, C.uint(flags)) + ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -2739,25 +2827,26 @@ func (d *Domain) SetBlockIoTune(disk string, params= *DomainBlockIoTuneParameters =20 var nparams C.int =20 - ret :=3D C.virDomainGetBlockIoTune(d.ptr, cdisk, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, nil, &nparams, 0,= &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetBlockIoTune(d.ptr, cdisk, (*C.virTypedParameter)(un= safe.Pointer(&cparams[0])), &nparams, 0) + ret =3D C.virDomainGetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - err :=3D typedParamsPack(cparams, info) - if err !=3D nil { - return err + gerr :=3D typedParamsPack(cparams, info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetBlockIoTune(d.ptr, cdisk, (*C.virTypedParameter)(un= safe.Pointer(&cparams[0])), nparams, C.uint(flags)) + ret =3D C.virDomainSetBlockIoTuneWrapper(d.ptr, cdisk, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) =20 return nil } @@ -2776,10 +2865,11 @@ func (d *Domain) GetBlockJobInfo(disk string, flags= DomainBlockJobInfoFlags) (*D =20 var cinfo C.virDomainBlockJobInfo =20 - ret :=3D C.virDomainGetBlockJobInfo(d.ptr, cdisk, &cinfo, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetBlockJobInfoWrapper(d.ptr, cdisk, &cinfo, C.uint(f= lags), &err) =20 if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &DomainBlockJobInfo{ @@ -2801,9 +2891,10 @@ func (d *Domain) GetControlInfo(flags uint32) (*Doma= inControlInfo, error) { =20 var cinfo C.virDomainControlInfo =20 - ret :=3D C.virDomainGetControlInfo(d.ptr, &cinfo, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetControlInfoWrapper(d.ptr, &cinfo, C.uint(flags), &= err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &DomainControlInfo{ @@ -2820,17 +2911,18 @@ type DomainDiskError struct { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetDiskErrors func (d *Domain) GetDiskErrors(flags uint32) ([]DomainDiskError, error) { - ret :=3D C.virDomainGetDiskErrors(d.ptr, nil, 0, 0) + var err C.virError + ret :=3D C.virDomainGetDiskErrorsWrapper(d.ptr, nil, 0, 0, &err) if ret =3D=3D -1 { - return []DomainDiskError{}, GetLastError() + return []DomainDiskError{}, makeError(&err) } =20 maxerrors :=3D ret cerrors :=3D make([]C.virDomainDiskError, maxerrors) =20 - ret =3D C.virDomainGetDiskErrors(d.ptr, (*C.virDomainDiskError)(unsafe.Po= inter(&cerrors[0])), C.uint(maxerrors), C.uint(flags)) + ret =3D C.virDomainGetDiskErrorsWrapper(d.ptr, (*C.virDomainDiskError)(un= safe.Pointer(&cerrors[0])), C.uint(maxerrors), C.uint(flags), &err) if ret =3D=3D -1 { - return []DomainDiskError{}, GetLastError() + return []DomainDiskError{}, makeError(&err) } =20 errors :=3D make([]DomainDiskError, maxerrors) @@ -2848,9 +2940,10 @@ func (d *Domain) GetDiskErrors(flags uint32) ([]Doma= inDiskError, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetHostname func (d *Domain) GetHostname(flags uint32) (string, error) { - ret :=3D C.virDomainGetHostname(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetHostnameWrapper(d.ptr, C.uint(flags), &err) if ret =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) } =20 defer C.free(unsafe.Pointer(ret)) @@ -2926,9 +3019,10 @@ type DomainJobInfo struct { func (d *Domain) GetJobInfo() (*DomainJobInfo, error) { var cinfo C.virDomainJobInfo =20 - ret :=3D C.virDomainGetJobInfo(d.ptr, &cinfo) + var err C.virError + ret :=3D C.virDomainGetJobInfoWrapper(d.ptr, &cinfo, &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &DomainJobInfo{ @@ -3088,18 +3182,19 @@ func (d *Domain) GetJobStats(flags DomainGetJobStat= sFlags) (*DomainJobInfo, erro var cparams *C.virTypedParameter var nparams C.int var jobtype C.int - ret :=3D C.virDomainGetJobStats(d.ptr, &jobtype, (*C.virTypedParameterPtr= )(unsafe.Pointer(&cparams)), &nparams, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetJobStatsWrapper(d.ptr, &jobtype, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } defer C.virTypedParamsFree(cparams, nparams) =20 params :=3D DomainJobInfo{} info :=3D getDomainJobInfoFieldInfo(¶ms) =20 - _, err :=3D typedParamsUnpackLen(cparams, int(nparams), info) - if err !=3D nil { - return nil, GetLastError() + _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + if gerr !=3D nil { + return nil, gerr } =20 return ¶ms, nil @@ -3107,9 +3202,10 @@ func (d *Domain) GetJobStats(flags DomainGetJobStats= Flags) (*DomainJobInfo, erro =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetMaxMemory func (d *Domain) GetMaxMemory() (uint64, error) { - ret :=3D C.virDomainGetMaxMemory(d.ptr) + var err C.virError + ret :=3D C.virDomainGetMaxMemoryWrapper(d.ptr, &err) if ret =3D=3D 0 { - return 0, GetLastError() + return 0, makeError(&err) } =20 return uint64(ret), nil @@ -3117,9 +3213,10 @@ func (d *Domain) GetMaxMemory() (uint64, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetMaxVcpus func (d *Domain) GetMaxVcpus() (uint, error) { - ret :=3D C.virDomainGetMaxVcpus(d.ptr) + var err C.virError + ret :=3D C.virDomainGetMaxVcpusWrapper(d.ptr, &err) if ret =3D=3D -1 { - return 0, GetLastError() + return 0, makeError(&err) } =20 return uint(ret), nil @@ -3127,9 +3224,10 @@ func (d *Domain) GetMaxVcpus() (uint, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetOSType func (d *Domain) GetOSType() (string, error) { - ret :=3D C.virDomainGetOSType(d.ptr) + var err C.virError + ret :=3D C.virDomainGetOSTypeWrapper(d.ptr, &err) if ret =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) } =20 defer C.free(unsafe.Pointer(ret)) @@ -3175,22 +3273,23 @@ func (d *Domain) GetMemoryParameters(flags DomainMo= dificationImpact) (*DomainMem info :=3D getDomainMemoryParametersFieldInfo(params) =20 var nparams C.int - ret :=3D C.virDomainGetMemoryParameters(d.ptr, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &= err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetMemoryParameters(d.ptr, (*C.virTypedParameter)(unsa= fe.Pointer(&cparams[0])), &nparams, C.uint(flags)) + ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -3202,25 +3301,26 @@ func (d *Domain) SetMemoryParameters(params *Domain= MemoryParameters, flags Domai =20 var nparams C.int =20 - ret :=3D C.virDomainGetMemoryParameters(d.ptr, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetMemoryParametersWrapper(d.ptr, nil, &nparams, 0, &= err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetMemoryParameters(d.ptr, (*C.virTypedParameter)(unsa= fe.Pointer(&cparams[0])), &nparams, 0) + ret =3D C.virDomainGetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - err :=3D typedParamsPack(cparams, info) - if err !=3D nil { - return err + gerr :=3D typedParamsPack(cparams, info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetMemoryParameters(d.ptr, (*C.virTypedParameter)(unsa= fe.Pointer(&cparams[0])), nparams, C.uint(flags)) + ret =3D C.virDomainSetMemoryParametersWrapper(d.ptr, (*C.virTypedParamete= r)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) =20 return nil } @@ -3251,22 +3351,23 @@ func (d *Domain) GetNumaParameters(flags DomainModi= ficationImpact) (*DomainNumaP info :=3D getDomainNumaParametersFieldInfo(params) =20 var nparams C.int - ret :=3D C.virDomainGetNumaParameters(d.ptr, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &er= r) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetNumaParameters(d.ptr, (*C.virTypedParameter)(unsafe= .Pointer(&cparams[0])), &nparams, C.uint(flags)) + ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -3278,25 +3379,26 @@ func (d *Domain) SetNumaParameters(params *DomainNu= maParameters, flags DomainMod =20 var nparams C.int =20 - ret :=3D C.virDomainGetNumaParameters(d.ptr, nil, &nparams, 0) + var err C.virError + ret :=3D C.virDomainGetNumaParametersWrapper(d.ptr, nil, &nparams, 0, &er= r) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret =3D C.virDomainGetNumaParameters(d.ptr, (*C.virTypedParameter)(unsafe= .Pointer(&cparams[0])), &nparams, 0) + ret =3D C.virDomainGetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), &nparams, 0, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - err :=3D typedParamsPack(cparams, info) - if err !=3D nil { - return err + gerr :=3D typedParamsPack(cparams, info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetNumaParameters(d.ptr, (*C.virTypedParameter)(unsafe= .Pointer(&cparams[0])), nparams, C.uint(flags)) + ret =3D C.virDomainSetNumaParametersWrapper(d.ptr, (*C.virTypedParameter)= (unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) =20 return nil } @@ -3454,16 +3556,17 @@ func (d *Domain) GetPerfEvents(flags DomainModifica= tionImpact) (*DomainPerfEvent =20 var cparams *C.virTypedParameter var nparams C.int - ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &nparams, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsFree(cparams, nparams) =20 - _, err :=3D typedParamsUnpackLen(cparams, int(nparams), info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -3479,19 +3582,20 @@ func (d *Domain) SetPerfEvents(params *DomainPerfEv= ents, flags DomainModificatio =20 var cparams *C.virTypedParameter var nparams C.int - ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &nparams, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetPerfEventsWrapper(d.ptr, (*C.virTypedParameterPtr)= (unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 defer C.virTypedParamsFree(cparams, nparams) =20 - err :=3D typedParamsPackLen(cparams, int(nparams), info) - if err !=3D nil { - return err + gerr :=3D typedParamsPackLen(cparams, int(nparams), info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(f= lags)) + ret =3D C.virDomainSetPerfEventsWrapper(d.ptr, cparams, nparams, C.uint(f= lags), &err) =20 return nil } @@ -3595,9 +3699,10 @@ func (d *Domain) GetSchedulerParameters() (*DomainSc= hedulerParameters, error) { info :=3D getDomainSchedulerParametersFieldInfo(params) =20 var nparams C.int - schedtype :=3D C.virDomainGetSchedulerType(d.ptr, &nparams) + var err C.virError + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) if schedtype =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) @@ -3608,15 +3713,15 @@ func (d *Domain) GetSchedulerParameters() (*DomainS= chedulerParameters, error) { } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParameters(d.ptr, (*C.virTypedParameter)(= unsafe.Pointer(&cparams[0])), &nparams) + ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &nparams, &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -3628,9 +3733,10 @@ func (d *Domain) GetSchedulerParametersFlags(flags D= omainModificationImpact) (*D info :=3D getDomainSchedulerParametersFieldInfo(params) =20 var nparams C.int - schedtype :=3D C.virDomainGetSchedulerType(d.ptr, &nparams) + var err C.virError + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) if schedtype =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) @@ -3641,15 +3747,15 @@ func (d *Domain) GetSchedulerParametersFlags(flags = DomainModificationImpact) (*D } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParametersFlags(d.ptr, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags)) + ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - _, err :=3D typedParamsUnpack(cparams, info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpack(cparams, info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil @@ -3660,9 +3766,10 @@ func (d *Domain) SetSchedulerParameters(params *Doma= inSchedulerParameters) error info :=3D getDomainSchedulerParametersFieldInfo(params) =20 var nparams C.int - schedtype :=3D C.virDomainGetSchedulerType(d.ptr, &nparams) + var err C.virError + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) if schedtype =3D=3D nil { - return GetLastError() + return makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) @@ -3671,18 +3778,18 @@ func (d *Domain) SetSchedulerParameters(params *Dom= ainSchedulerParameters) error } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParameters(d.ptr, (*C.virTypedParameter)(= unsafe.Pointer(&cparams[0])), &nparams) + ret :=3D C.virDomainGetSchedulerParametersWrapper(d.ptr, (*C.virTypedPara= meter)(unsafe.Pointer(&cparams[0])), &nparams, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - err :=3D typedParamsPack(cparams, info) - if err !=3D nil { - return err + gerr :=3D typedParamsPack(cparams, info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetSchedulerParameters(d.ptr, (*C.virTypedParameter)(u= nsafe.Pointer(&cparams[0])), nparams) + ret =3D C.virDomainSetSchedulerParametersWrapper(d.ptr, (*C.virTypedParam= eter)(unsafe.Pointer(&cparams[0])), nparams, &err) =20 return nil } @@ -3692,9 +3799,10 @@ func (d *Domain) SetSchedulerParametersFlags(params = *DomainSchedulerParameters, info :=3D getDomainSchedulerParametersFieldInfo(params) =20 var nparams C.int - schedtype :=3D C.virDomainGetSchedulerType(d.ptr, &nparams) + var err C.virError + schedtype :=3D C.virDomainGetSchedulerTypeWrapper(d.ptr, &nparams, &err) if schedtype =3D=3D nil { - return GetLastError() + return makeError(&err) } =20 defer C.free(unsafe.Pointer(schedtype)) @@ -3703,18 +3811,18 @@ func (d *Domain) SetSchedulerParametersFlags(params= *DomainSchedulerParameters, } =20 cparams :=3D make([]C.virTypedParameter, nparams) - ret :=3D C.virDomainGetSchedulerParametersFlags(d.ptr, (*C.virTypedParame= ter)(unsafe.Pointer(&cparams[0])), &nparams, 0) + ret :=3D C.virDomainGetSchedulerParametersFlagsWrapper(d.ptr, (*C.virType= dParameter)(unsafe.Pointer(&cparams[0])), &nparams, 0, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } defer C.virTypedParamsClear((*C.virTypedParameter)(unsafe.Pointer(&cparam= s[0])), nparams) =20 - err :=3D typedParamsPack(cparams, info) - if err !=3D nil { - return err + gerr :=3D typedParamsPack(cparams, info) + if gerr !=3D nil { + return gerr } =20 - ret =3D C.virDomainSetSchedulerParametersFlags(d.ptr, (*C.virTypedParamet= er)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags)) + ret =3D C.virDomainSetSchedulerParametersFlagsWrapper(d.ptr, (*C.virTyped= Parameter)(unsafe.Pointer(&cparams[0])), nparams, C.uint(flags), &err) =20 return nil } @@ -3728,9 +3836,10 @@ type SecurityLabel struct { func (d *Domain) GetSecurityLabel() (*SecurityLabel, error) { var clabel C.virSecurityLabel =20 - ret :=3D C.virDomainGetSecurityLabel(d.ptr, &clabel) + var err C.virError + ret :=3D C.virDomainGetSecurityLabelWrapper(d.ptr, &clabel, &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 return &SecurityLabel{ @@ -3743,9 +3852,10 @@ func (d *Domain) GetSecurityLabel() (*SecurityLabel,= error) { func (d *Domain) GetSecurityLabelList() ([]SecurityLabel, error) { var clabels *C.virSecurityLabel =20 - ret :=3D C.virDomainGetSecurityLabelList(d.ptr, (*C.virSecurityLabelPtr)(= unsafe.Pointer(&clabels))) + var err C.virError + ret :=3D C.virDomainGetSecurityLabelListWrapper(d.ptr, (*C.virSecurityLab= elPtr)(unsafe.Pointer(&clabels)), &err) if ret =3D=3D -1 { - return []SecurityLabel{}, GetLastError() + return []SecurityLabel{}, makeError(&err) } =20 labels :=3D make([]SecurityLabel, ret) @@ -3768,9 +3878,10 @@ func (d *Domain) GetTime(flags uint32) (int64, uint,= error) { } var secs C.longlong var nsecs C.uint - ret :=3D C.virDomainGetTimeWrapper(d.ptr, &secs, &nsecs, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetTimeWrapper(d.ptr, &secs, &nsecs, C.uint(flags), &= err) if ret =3D=3D -1 { - return 0, 0, GetLastError() + return 0, 0, makeError(&err) } =20 return int64(secs), uint(nsecs), nil @@ -3782,9 +3893,10 @@ func (d *Domain) SetTime(secs int64, nsecs uint, fla= gs DomainSetTimeFlags) error return GetNotImplementedError("virDomainSetTime") } =20 - ret :=3D C.virDomainSetTimeWrapper(d.ptr, C.longlong(secs), C.uint(nsecs)= , C.uint(flags)) + var err C.virError + ret :=3D C.virDomainSetTimeWrapper(d.ptr, C.longlong(secs), C.uint(nsecs)= , C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3801,9 +3913,10 @@ func (d *Domain) SetUserPassword(user string, passwo= rd string, flags DomainSetUs defer C.free(unsafe.Pointer(cuser)) defer C.free(unsafe.Pointer(cpassword)) =20 - ret :=3D C.virDomainSetUserPasswordWrapper(d.ptr, cuser, cpassword, C.uin= t(flags)) + var err C.virError + ret :=3D C.virDomainSetUserPasswordWrapper(d.ptr, cuser, cpassword, C.uin= t(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3811,9 +3924,10 @@ func (d *Domain) SetUserPassword(user string, passwo= rd string, flags DomainSetUs =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= ManagedSave func (d *Domain) ManagedSave(flags DomainSaveRestoreFlags) error { - ret :=3D C.virDomainManagedSave(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainManagedSaveWrapper(d.ptr, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3821,9 +3935,10 @@ func (d *Domain) ManagedSave(flags DomainSaveRestore= Flags) error { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= HasManagedSaveImage func (d *Domain) HasManagedSaveImage(flags uint32) (bool, error) { - result :=3D C.virDomainHasManagedSaveImage(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainHasManagedSaveImageWrapper(d.ptr, C.uint(flags), &= err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } if result =3D=3D 1 { return true, nil @@ -3833,9 +3948,10 @@ func (d *Domain) HasManagedSaveImage(flags uint32) (= bool, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= ManagedSaveRemove func (d *Domain) ManagedSaveRemove(flags uint32) error { - ret :=3D C.virDomainManagedSaveRemove(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainManagedSaveRemoveWrapper(d.ptr, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3848,9 +3964,10 @@ func (d *Domain) Rename(name string, flags uint32) e= rror { } cname :=3D C.CString(name) defer C.free(unsafe.Pointer(cname)) - ret :=3D C.virDomainRenameWrapper(d.ptr, cname, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainRenameWrapper(d.ptr, cname, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3858,9 +3975,10 @@ func (d *Domain) Rename(name string, flags uint32) e= rror { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= Reset func (d *Domain) Reset(flags uint32) error { - ret :=3D C.virDomainReset(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainResetWrapper(d.ptr, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3868,9 +3986,10 @@ func (d *Domain) Reset(flags uint32) error { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= SendProcessSignal func (d *Domain) SendProcessSignal(pid int64, signum DomainProcessSignal, = flags uint32) error { - ret :=3D C.virDomainSendProcessSignal(d.ptr, C.longlong(pid), C.uint(sign= um), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainSendProcessSignalWrapper(d.ptr, C.longlong(pid), C.ui= nt(signum), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3878,9 +3997,10 @@ func (d *Domain) SendProcessSignal(pid int64, signum= DomainProcessSignal, flags =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= InjectNMI func (d *Domain) InjectNMI(flags uint32) error { - ret :=3D C.virDomainInjectNMI(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainInjectNMIWrapper(d.ptr, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3891,9 +4011,10 @@ func (d *Domain) CoreDump(to string, flags DomainCor= eDumpFlags) error { cto :=3D C.CString(to) defer C.free(unsafe.Pointer(cto)) =20 - ret :=3D C.virDomainCoreDump(d.ptr, cto, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainCoreDumpWrapper(d.ptr, cto, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3907,9 +4028,10 @@ func (d *Domain) CoreDumpWithFormat(to string, forma= t DomainCoreDumpFormat, flag cto :=3D C.CString(to) defer C.free(unsafe.Pointer(cto)) =20 - ret :=3D C.virDomainCoreDumpWithFormatWrapper(d.ptr, cto, C.uint(format),= C.uint(flags)) + var err C.virError + ret :=3D C.virDomainCoreDumpWithFormatWrapper(d.ptr, cto, C.uint(format),= C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3917,9 +4039,10 @@ func (d *Domain) CoreDumpWithFormat(to string, forma= t DomainCoreDumpFormat, flag =20 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#= virDomainHasCurrentSnapshot func (d *Domain) HasCurrentSnapshot(flags uint32) (bool, error) { - result :=3D C.virDomainHasCurrentSnapshot(d.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virDomainHasCurrentSnapshotWrapper(d.ptr, C.uint(flags), &e= rr) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } if result =3D=3D 1 { return true, nil @@ -3940,9 +4063,10 @@ func (d *Domain) FSFreeze(mounts []string, flags uin= t32) error { } =20 nmounts :=3D len(mounts) - ret :=3D C.virDomainFSFreezeWrapper(d.ptr, (**C.char)(unsafe.Pointer(&cmo= unts[0])), C.uint(nmounts), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainFSFreezeWrapper(d.ptr, (**C.char)(unsafe.Pointer(&cmo= unts[0])), C.uint(nmounts), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3961,9 +4085,10 @@ func (d *Domain) FSThaw(mounts []string, flags uint3= 2) error { } =20 nmounts :=3D len(mounts) - ret :=3D C.virDomainFSThawWrapper(d.ptr, (**C.char)(unsafe.Pointer(&cmoun= ts[0])), C.uint(nmounts), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainFSThawWrapper(d.ptr, (**C.char)(unsafe.Pointer(&cmoun= ts[0])), C.uint(nmounts), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3977,9 +4102,10 @@ func (d *Domain) FSTrim(mount string, minimum uint64= , flags uint32) error { defer C.free(unsafe.Pointer(cmount)) } =20 - ret :=3D C.virDomainFSTrim(d.ptr, cmount, C.ulonglong(minimum), C.uint(fl= ags)) + var err C.virError + ret :=3D C.virDomainFSTrimWrapper(d.ptr, cmount, C.ulonglong(minimum), C.= uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -3999,9 +4125,10 @@ func (d *Domain) GetFSInfo(flags uint32) ([]DomainFS= Info, error) { } var cfsinfolist **C.virDomainFSInfo =20 - ret :=3D C.virDomainGetFSInfoWrapper(d.ptr, (**C.virDomainFSInfoPtr)(unsa= fe.Pointer(&cfsinfolist)), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetFSInfoWrapper(d.ptr, (**C.virDomainFSInfoPtr)(unsa= fe.Pointer(&cfsinfolist)), C.uint(flags), &err) if ret =3D=3D -1 { - return []DomainFSInfo{}, GetLastError() + return []DomainFSInfo{}, makeError(&err) } =20 fsinfo :=3D make([]DomainFSInfo, int(ret)) @@ -4030,9 +4157,10 @@ func (d *Domain) GetFSInfo(flags uint32) ([]DomainFS= Info, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= PMSuspendForDuration func (d *Domain) PMSuspendForDuration(target NodeSuspendTarget, duration u= int64, flags uint32) error { - ret :=3D C.virDomainPMSuspendForDuration(d.ptr, C.uint(target), C.ulonglo= ng(duration), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainPMSuspendForDurationWrapper(d.ptr, C.uint(target), C.= ulonglong(duration), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4040,9 +4168,10 @@ func (d *Domain) PMSuspendForDuration(target NodeSus= pendTarget, duration uint64, =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= PMWakeup func (d *Domain) PMWakeup(flags uint32) error { - ret :=3D C.virDomainPMWakeup(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainPMWakeupWrapper(d.ptr, C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4053,9 +4182,10 @@ func (d *Domain) AddIOThread(id uint, flags DomainMo= dificationImpact) error { if C.LIBVIR_VERSION_NUMBER < 1002015 { return GetNotImplementedError("virDomainAddIOThread") } - ret :=3D C.virDomainAddIOThreadWrapper(d.ptr, C.uint(id), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainAddIOThreadWrapper(d.ptr, C.uint(id), C.uint(flags), = &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4066,9 +4196,10 @@ func (d *Domain) DelIOThread(id uint, flags DomainMo= dificationImpact) error { if C.LIBVIR_VERSION_NUMBER < 1002015 { return GetNotImplementedError("virDomainDelIOThread") } - ret :=3D C.virDomainDelIOThreadWrapper(d.ptr, C.uint(id), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainDelIOThreadWrapper(d.ptr, C.uint(id), C.uint(flags), = &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4077,17 +4208,18 @@ func (d *Domain) DelIOThread(id uint, flags DomainM= odificationImpact) error { // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetEmulatorPinInfo func (d *Domain) GetEmulatorPinInfo(flags DomainModificationImpact) ([]boo= l, error) { var cnodeinfo C.virNodeInfo - ret :=3D C.virNodeGetInfo(C.virDomainGetConnect(d.ptr), &cnodeinfo) + var err C.virError + ret :=3D C.virNodeGetInfoWrapper(C.virDomainGetConnect(d.ptr), &cnodeinfo= , &err) if ret =3D=3D -1 { - return []bool{}, GetLastError() + return []bool{}, makeError(&err) } =20 ncpus :=3D cnodeinfo.nodes * cnodeinfo.sockets * cnodeinfo.cores * cnodei= nfo.threads maplen :=3D int((ncpus + 7) / 8) ccpumaps :=3D make([]C.uchar, maplen) - ret =3D C.virDomainGetEmulatorPinInfo(d.ptr, &ccpumaps[0], C.int(maplen),= C.uint(flags)) + ret =3D C.virDomainGetEmulatorPinInfoWrapper(d.ptr, &ccpumaps[0], C.int(m= aplen), C.uint(flags), &err) if ret =3D=3D -1 { - return []bool{}, GetLastError() + return []bool{}, makeError(&err) } =20 cpumaps :=3D make([]bool, ncpus) @@ -4112,9 +4244,10 @@ func (d *Domain) GetIOThreadInfo(flags DomainModific= ationImpact) ([]DomainIOThre } var cinfolist **C.virDomainIOThreadInfo =20 - ret :=3D C.virDomainGetIOThreadInfoWrapper(d.ptr, (**C.virDomainIOThreadI= nfoPtr)(unsafe.Pointer(&cinfolist)), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetIOThreadInfoWrapper(d.ptr, (**C.virDomainIOThreadI= nfoPtr)(unsafe.Pointer(&cinfolist)), C.uint(flags), &err) if ret =3D=3D -1 { - return []DomainIOThreadInfo{}, GetLastError() + return []DomainIOThreadInfo{}, makeError(&err) } =20 info :=3D make([]DomainIOThreadInfo, int(ret)) @@ -4147,15 +4280,16 @@ func (d *Domain) GetIOThreadInfo(flags DomainModifi= cationImpact) ([]DomainIOThre // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= GetVcpuPinInfo func (d *Domain) GetVcpuPinInfo(flags DomainModificationImpact) ([][]bool,= error) { var cnodeinfo C.virNodeInfo - ret :=3D C.virNodeGetInfo(C.virDomainGetConnect(d.ptr), &cnodeinfo) + var err C.virError + ret :=3D C.virNodeGetInfoWrapper(C.virDomainGetConnect(d.ptr), &cnodeinfo= , &err) if ret =3D=3D -1 { - return [][]bool{}, GetLastError() + return [][]bool{}, makeError(&err) } =20 var cdominfo C.virDomainInfo - ret =3D C.virDomainGetInfo(d.ptr, &cdominfo) + ret =3D C.virDomainGetInfoWrapper(d.ptr, &cdominfo, &err) if ret =3D=3D -1 { - return [][]bool{}, GetLastError() + return [][]bool{}, makeError(&err) } =20 nvcpus :=3D int(cdominfo.nrVirtCpu) @@ -4163,9 +4297,9 @@ func (d *Domain) GetVcpuPinInfo(flags DomainModificat= ionImpact) ([][]bool, error maplen :=3D ((npcpus + 7) / 8) ccpumaps :=3D make([]C.uchar, maplen*nvcpus) =20 - ret =3D C.virDomainGetVcpuPinInfo(d.ptr, C.int(nvcpus), &ccpumaps[0], C.i= nt(maplen), C.uint(flags)) + ret =3D C.virDomainGetVcpuPinInfoWrapper(d.ptr, C.int(nvcpus), &ccpumaps[= 0], C.int(maplen), C.uint(flags), &err) if ret =3D=3D -1 { - return [][]bool{}, GetLastError() + return [][]bool{}, makeError(&err) } =20 cpumaps :=3D make([][]bool, nvcpus) @@ -4198,9 +4332,10 @@ func (d *Domain) PinEmulator(cpumap []bool, flags Do= mainModificationImpact) erro } } =20 - ret :=3D C.virDomainPinEmulator(d.ptr, &ccpumaps[0], C.int(maplen), C.uin= t(flags)) + var err C.virError + ret :=3D C.virDomainPinEmulatorWrapper(d.ptr, &ccpumaps[0], C.int(maplen)= , C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4223,9 +4358,10 @@ func (d *Domain) PinIOThread(iothreadid uint, cpumap= []bool, flags DomainModific } } =20 - ret :=3D C.virDomainPinIOThreadWrapper(d.ptr, C.uint(iothreadid), &ccpuma= ps[0], C.int(maplen), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainPinIOThreadWrapper(d.ptr, C.uint(iothreadid), &ccpuma= ps[0], C.int(maplen), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4236,9 +4372,10 @@ func (d *Domain) OpenChannel(name string, stream *St= ream, flags DomainChannelFla cname :=3D C.CString(name) defer C.free(unsafe.Pointer(cname)) =20 - ret :=3D C.virDomainOpenChannel(d.ptr, cname, stream.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainOpenChannelWrapper(d.ptr, cname, stream.ptr, C.uint(f= lags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4252,9 +4389,10 @@ func (d *Domain) OpenConsole(devname string, stream = *Stream, flags DomainConsole defer C.free(unsafe.Pointer(cdevname)) } =20 - ret :=3D C.virDomainOpenConsole(d.ptr, cdevname, stream.ptr, C.uint(flags= )) + var err C.virError + ret :=3D C.virDomainOpenConsoleWrapper(d.ptr, cdevname, stream.ptr, C.uin= t(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4262,9 +4400,10 @@ func (d *Domain) OpenConsole(devname string, stream = *Stream, flags DomainConsole =20 // See also https://libvirt.org/html/libvirt-libvirt-domain.html#virDomain= OpenGraphics func (d *Domain) OpenGraphics(idx uint, file os.File, flags DomainOpenGrap= hicsFlags) error { - ret :=3D C.virDomainOpenGraphics(d.ptr, C.uint(idx), C.int(file.Fd()), C.= uint(flags)) + var err C.virError + ret :=3D C.virDomainOpenGraphicsWrapper(d.ptr, C.uint(idx), C.int(file.Fd= ()), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4275,9 +4414,10 @@ func (d *Domain) OpenGraphicsFD(idx uint, flags Doma= inOpenGraphicsFlags) (*os.Fi if C.LIBVIR_VERSION_NUMBER < 1002008 { return nil, GetNotImplementedError("virDomainOpenGraphicsFD") } - ret :=3D C.virDomainOpenGraphicsFDWrapper(d.ptr, C.uint(idx), C.uint(flag= s)) + var err C.virError + ret :=3D C.virDomainOpenGraphicsFDWrapper(d.ptr, C.uint(idx), C.uint(flag= s), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 return os.NewFile(uintptr(ret), "graphics"), nil @@ -4287,9 +4427,10 @@ func (d *Domain) OpenGraphicsFD(idx uint, flags Doma= inOpenGraphicsFlags) (*os.Fi func (d *Domain) CreateSnapshotXML(xml string, flags DomainSnapshotCreateF= lags) (*DomainSnapshot, error) { cXml :=3D C.CString(xml) defer C.free(unsafe.Pointer(cXml)) - result :=3D C.virDomainSnapshotCreateXML(d.ptr, cXml, C.uint(flags)) + var err C.virError + result :=3D C.virDomainSnapshotCreateXMLWrapper(d.ptr, cXml, C.uint(flags= ), &err) if result =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } return &DomainSnapshot{ptr: result}, nil } @@ -4298,9 +4439,10 @@ func (d *Domain) CreateSnapshotXML(xml string, flags= DomainSnapshotCreateFlags) func (d *Domain) Save(destFile string) error { cPath :=3D C.CString(destFile) defer C.free(unsafe.Pointer(cPath)) - result :=3D C.virDomainSave(d.ptr, cPath) + var err C.virError + result :=3D C.virDomainSaveWrapper(d.ptr, cPath, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -4311,9 +4453,10 @@ func (d *Domain) SaveFlags(destFile string, destXml = string, flags DomainSaveRest cDestXml :=3D C.CString(destXml) defer C.free(unsafe.Pointer(cDestXml)) defer C.free(unsafe.Pointer(cDestFile)) - result :=3D C.virDomainSaveFlags(d.ptr, cDestFile, cDestXml, C.uint(flags= )) + var err C.virError + result :=3D C.virDomainSaveFlagsWrapper(d.ptr, cDestFile, cDestXml, C.uin= t(flags), &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -4410,16 +4553,17 @@ func (d *Domain) GetGuestVcpus(flags uint32) (*Doma= inGuestVcpus, error) { =20 var cparams C.virTypedParameterPtr var nparams C.uint - ret :=3D C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &nparams, C.uin= t(flags)) + var err C.virError + ret :=3D C.virDomainGetGuestVcpusWrapper(d.ptr, &cparams, &nparams, C.uin= t(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsFree(cparams, C.int(nparams)) =20 - _, err :=3D typedParamsUnpackLen(cparams, int(nparams), info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + if gerr !=3D nil { + return nil, gerr } =20 return &DomainGuestVcpus{}, nil @@ -4450,9 +4594,10 @@ func (d *Domain) SetGuestVcpus(cpus []bool, state bo= ol, flags uint32) error { } ccpumap :=3D C.CString(cpumap) defer C.free(unsafe.Pointer(ccpumap)) - ret :=3D C.virDomainSetGuestVcpusWrapper(d.ptr, ccpumap, cstate, C.uint(f= lags)) + var err C.virError + ret :=3D C.virDomainSetGuestVcpusWrapper(d.ptr, ccpumap, cstate, C.uint(f= lags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4483,9 +4628,10 @@ func (d *Domain) SetVcpu(cpus []bool, state bool, fl= ags uint32) error { } ccpumap :=3D C.CString(cpumap) defer C.free(unsafe.Pointer(ccpumap)) - ret :=3D C.virDomainSetVcpuWrapper(d.ptr, ccpumap, cstate, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainSetVcpuWrapper(d.ptr, ccpumap, cstate, C.uint(flags),= &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4499,9 +4645,10 @@ func (d *Domain) SetBlockThreshold(dev string, thres= hold uint64, flags uint32) e =20 cdev :=3D C.CString(dev) defer C.free(unsafe.Pointer(cdev)) - ret :=3D C.virDomainSetBlockThresholdWrapper(d.ptr, cdev, C.ulonglong(thr= eshold), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainSetBlockThresholdWrapper(d.ptr, cdev, C.ulonglong(thr= eshold), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4515,9 +4662,10 @@ func (d *Domain) ManagedSaveDefineXML(xml string, fl= ags uint32) error { =20 cxml :=3D C.CString(xml) defer C.free(unsafe.Pointer(cxml)) - ret :=3D C.virDomainManagedSaveDefineXMLWrapper(d.ptr, cxml, C.uint(flags= )) + var err C.virError + ret :=3D C.virDomainManagedSaveDefineXMLWrapper(d.ptr, cxml, C.uint(flags= ), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4529,9 +4677,10 @@ func (d *Domain) ManagedSaveGetXMLDesc(flags uint32)= (string, error) { return "", GetNotImplementedError("virDomainManagedSaveGetXMLDesc") } =20 - ret :=3D C.virDomainManagedSaveGetXMLDescWrapper(d.ptr, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainManagedSaveGetXMLDescWrapper(d.ptr, C.uint(flags), &e= rr) if ret =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) } =20 xml :=3D C.GoString(ret) @@ -4564,9 +4713,10 @@ func (d *Domain) SetLifecycleAction(lifecycleType ui= nt32, action uint32, flags u return GetNotImplementedError("virDomainSetLifecycleAction") } =20 - ret :=3D C.virDomainSetLifecycleActionWrapper(d.ptr, C.uint(lifecycleType= ), C.uint(action), C.uint(flags)) + var err C.virError + ret :=3D C.virDomainSetLifecycleActionWrapper(d.ptr, C.uint(lifecycleType= ), C.uint(action), C.uint(flags), &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } =20 return nil @@ -4598,16 +4748,17 @@ func (d *Domain) GetLaunchSecurityInfo(flags uint32= ) (*DomainLaunchSecurityParam var cparams *C.virTypedParameter var nparams C.int =20 - ret :=3D C.virDomainGetLaunchSecurityInfoWrapper(d.ptr, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags)) + var err C.virError + ret :=3D C.virDomainGetLaunchSecurityInfoWrapper(d.ptr, (*C.virTypedParam= eterPtr)(unsafe.Pointer(&cparams)), &nparams, C.uint(flags), &err) if ret =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } =20 defer C.virTypedParamsFree(cparams, nparams) =20 - _, err :=3D typedParamsUnpackLen(cparams, int(nparams), info) - if err !=3D nil { - return nil, err + _, gerr :=3D typedParamsUnpackLen(cparams, int(nparams), info) + if gerr !=3D nil { + return nil, gerr } =20 return params, nil diff --git a/domain_wrapper.go b/domain_wrapper.go index 1596ae5..b42dd42 100644 --- a/domain_wrapper.go +++ b/domain_wrapper.go @@ -31,353 +31,2300 @@ package libvirt #include #include "domain_wrapper.h" =20 -int virDomainCoreDumpWithFormatWrapper(virDomainPtr domain, - const char *to, - unsigned int dumpformat, - unsigned int flags) +int +virDomainAbortJobWrapper(virDomainPtr domain, + virErrorPtr err) +{ + int ret =3D virDomainAbortJob(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainAddIOThreadWrapper(virDomainPtr domain, + unsigned int iothread_id, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002015 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainAddIOThread(domain, iothread_id, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainAttachDeviceWrapper(virDomainPtr domain, + const char *xml, + virErrorPtr err) +{ + int ret =3D virDomainAttachDevice(domain, xml); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainAttachDeviceFlagsWrapper(virDomainPtr domain, + const char *xml, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainAttachDeviceFlags(domain, xml, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockCommitWrapper(virDomainPtr dom, + const char *disk, + const char *base, + const char *top, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockCommit(dom, disk, base, top, bandwidth, flag= s); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockCopyWrapper(virDomainPtr dom, + const char *disk, + const char *destxml, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002008 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainBlockCopy(dom, disk, destxml, params, nparams, fl= ags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainBlockJobAbortWrapper(virDomainPtr dom, + const char *disk, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockJobAbort(dom, disk, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockJobSetSpeedWrapper(virDomainPtr dom, + const char *disk, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockJobSetSpeed(dom, disk, bandwidth, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockPeekWrapper(virDomainPtr dom, + const char *disk, + unsigned long long offset, + size_t size, + void *buffer, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockPeek(dom, disk, offset, size, buffer, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockPullWrapper(virDomainPtr dom, + const char *disk, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockPull(dom, disk, bandwidth, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockRebaseWrapper(virDomainPtr dom, + const char *disk, + const char *base, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockRebase(dom, disk, base, bandwidth, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockResizeWrapper(virDomainPtr dom, + const char *disk, + unsigned long long size, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockResize(dom, disk, size, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockStatsWrapper(virDomainPtr dom, + const char *disk, + virDomainBlockStatsPtr stats, + size_t size, + virErrorPtr err) +{ + int ret =3D virDomainBlockStats(dom, disk, stats, size); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainBlockStatsFlagsWrapper(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainBlockStatsFlags(dom, disk, params, nparams, flags= ); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainCoreDumpWrapper(virDomainPtr domain, + const char *to, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainCoreDump(domain, to, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainCoreDumpWithFormatWrapper(virDomainPtr domain, + const char *to, + unsigned int dumpformat, + unsigned int flags, + virErrorPtr err) { #if LIBVIR_VERSION_NUMBER < 1002003 assert(0); // Caller should have checked version #else - return virDomainCoreDumpWithFormat(domain, to, dumpformat, flags); + int ret =3D virDomainCoreDumpWithFormat(domain, to, dumpformat, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainCreateWrapper(virDomainPtr domain, + virErrorPtr err) +{ + int ret =3D virDomainCreate(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainCreateWithFilesWrapper(virDomainPtr domain, + unsigned int nfiles, + int *files, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainCreateWithFiles(domain, nfiles, files, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainCreateWithFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainCreateWithFlags(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainDelIOThreadWrapper(virDomainPtr domain, + unsigned int iothread_id, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002015 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainDelIOThread(domain, iothread_id, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainDestroyWrapper(virDomainPtr domain, + virErrorPtr err) +{ + int ret =3D virDomainDestroy(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainDestroyFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainDestroyFlags(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainDetachDeviceWrapper(virDomainPtr domain, + const char *xml, + virErrorPtr err) +{ + int ret =3D virDomainDetachDevice(domain, xml); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainDetachDeviceAliasWrapper(virDomainPtr domain, + const char *alias, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 4004000 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainDetachDeviceAlias(domain, alias, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainDetachDeviceFlagsWrapper(virDomainPtr domain, + const char *xml, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainDetachDeviceFlags(domain, xml, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainFSFreezeWrapper(virDomainPtr dom, + const char **mountpoints, + unsigned int nmountpoints, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002005 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainFSFreeze(dom, mountpoints, nmountpoints, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +void +virDomainFSInfoFreeWrapper(virDomainFSInfoPtr info) +{ +#if LIBVIR_VERSION_NUMBER < 1002011 + assert(0); // Caller should have checked version +#else + virDomainFSInfoFree(info); +#endif +} + + +int +virDomainFSThawWrapper(virDomainPtr dom, + const char **mountpoints, + unsigned int nmountpoints, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002005 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainFSThaw(dom, mountpoints, nmountpoints, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainFSTrimWrapper(virDomainPtr dom, + const char *mountPoint, + unsigned long long minimum, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainFSTrim(dom, mountPoint, minimum, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainFreeWrapper(virDomainPtr domain, + virErrorPtr err) +{ + int ret =3D virDomainFree(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetAutostartWrapper(virDomainPtr domain, + int *autostart, + virErrorPtr err) +{ + int ret =3D virDomainGetAutostart(domain, autostart); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetBlkioParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetBlkioParameters(domain, params, nparams, flags= ); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetBlockInfoWrapper(virDomainPtr domain, + const char *disk, + virDomainBlockInfoPtr info, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetBlockInfo(domain, disk, info, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetBlockIoTuneWrapper(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetBlockIoTune(dom, disk, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetBlockJobInfoWrapper(virDomainPtr dom, + const char *disk, + virDomainBlockJobInfoPtr info, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetBlockJobInfo(dom, disk, info, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetCPUStatsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + unsigned int nparams, + int start_cpu, + unsigned int ncpus, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetCPUStats(domain, params, nparams, start_cpu, n= cpus, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +virConnectPtr +virDomainGetConnectWrapper(virDomainPtr dom, + virErrorPtr err) +{ + virConnectPtr ret =3D virDomainGetConnect(dom); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetControlInfoWrapper(virDomainPtr domain, + virDomainControlInfoPtr info, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetControlInfo(domain, info, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetDiskErrorsWrapper(virDomainPtr dom, + virDomainDiskErrorPtr errors, + unsigned int maxerrors, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetDiskErrors(dom, errors, maxerrors, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetEmulatorPinInfoWrapper(virDomainPtr domain, + unsigned char *cpumap, + int maplen, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetEmulatorPinInfo(domain, cpumap, maplen, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetFSInfoWrapper(virDomainPtr dom, + virDomainFSInfoPtr **info, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002011 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainGetFSInfo(dom, info, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainGetGuestVcpusWrapper(virDomainPtr domain, + virTypedParameterPtr *params, + unsigned int *nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 2000000 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainGetGuestVcpus(domain, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +char * +virDomainGetHostnameWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + char * ret =3D virDomainGetHostname(domain, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +unsigned int +virDomainGetIDWrapper(virDomainPtr domain, + virErrorPtr err) +{ + unsigned int ret =3D virDomainGetID(domain); + if (ret =3D=3D (unsigned int)-1) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetIOThreadInfoWrapper(virDomainPtr dom, + virDomainIOThreadInfoPtr **info, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002014 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainGetIOThreadInfo(dom, info, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainGetInfoWrapper(virDomainPtr domain, + virDomainInfoPtr info, + virErrorPtr err) +{ + int ret =3D virDomainGetInfo(domain, info); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetInterfaceParametersWrapper(virDomainPtr domain, + const char *device, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetInterfaceParameters(domain, device, params, np= arams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetJobInfoWrapper(virDomainPtr domain, + virDomainJobInfoPtr info, + virErrorPtr err) +{ + int ret =3D virDomainGetJobInfo(domain, info); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetJobStatsWrapper(virDomainPtr domain, + int *type, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetJobStats(domain, type, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetLaunchSecurityInfoWrapper(virDomainPtr domain, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 4005000 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainGetLaunchSecurityInfo(domain, params, nparams, fl= ags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +unsigned long +virDomainGetMaxMemoryWrapper(virDomainPtr domain, + virErrorPtr err) +{ + unsigned long ret =3D virDomainGetMaxMemory(domain); + if (ret =3D=3D 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetMaxVcpusWrapper(virDomainPtr domain, + virErrorPtr err) +{ + int ret =3D virDomainGetMaxVcpus(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetMemoryParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetMemoryParameters(domain, params, nparams, flag= s); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +char * +virDomainGetMetadataWrapper(virDomainPtr domain, + int type, + const char *uri, + unsigned int flags, + virErrorPtr err) +{ + char * ret =3D virDomainGetMetadata(domain, type, uri, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +const char * +virDomainGetNameWrapper(virDomainPtr domain, + virErrorPtr err) +{ + const char * ret =3D virDomainGetName(domain); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetNumaParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetNumaParameters(domain, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +char * +virDomainGetOSTypeWrapper(virDomainPtr domain, + virErrorPtr err) +{ + char * ret =3D virDomainGetOSType(domain); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetPerfEventsWrapper(virDomainPtr domain, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1003003 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainGetPerfEvents(domain, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainGetSchedulerParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + virErrorPtr err) +{ + int ret =3D virDomainGetSchedulerParameters(domain, params, nparams); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetSchedulerParametersFlagsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetSchedulerParametersFlags(domain, params, npara= ms, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +char * +virDomainGetSchedulerTypeWrapper(virDomainPtr domain, + int *nparams, + virErrorPtr err) +{ + char * ret =3D virDomainGetSchedulerType(domain, nparams); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetSecurityLabelWrapper(virDomainPtr domain, + virSecurityLabelPtr seclabel, + virErrorPtr err) +{ + int ret =3D virDomainGetSecurityLabel(domain, seclabel); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetSecurityLabelListWrapper(virDomainPtr domain, + virSecurityLabelPtr *seclabels, + virErrorPtr err) +{ + int ret =3D virDomainGetSecurityLabelList(domain, seclabels); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetStateWrapper(virDomainPtr domain, + int *state, + int *reason, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetState(domain, state, reason, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetTimeWrapper(virDomainPtr dom, + long long *seconds, + unsigned int *nseconds, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002005 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainGetTime(dom, seconds, nseconds, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +#endif +} + + +int +virDomainGetUUIDWrapper(virDomainPtr domain, + unsigned char *uuid, + virErrorPtr err) +{ + int ret =3D virDomainGetUUID(domain, uuid); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetUUIDStringWrapper(virDomainPtr domain, + char *buf, + virErrorPtr err) +{ + int ret =3D virDomainGetUUIDString(domain, buf); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetVcpuPinInfoWrapper(virDomainPtr domain, + int ncpumaps, + unsigned char *cpumaps, + int maplen, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetVcpuPinInfo(domain, ncpumaps, cpumaps, maplen,= flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetVcpusWrapper(virDomainPtr domain, + virVcpuInfoPtr info, + int maxinfo, + unsigned char *cpumaps, + int maplen, + virErrorPtr err) +{ + int ret =3D virDomainGetVcpus(domain, info, maxinfo, cpumaps, maplen); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainGetVcpusFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainGetVcpusFlags(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +char * +virDomainGetXMLDescWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + char * ret =3D virDomainGetXMLDesc(domain, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainHasCurrentSnapshotWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainHasCurrentSnapshot(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainHasManagedSaveImageWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainHasManagedSaveImage(dom, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainInjectNMIWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainInjectNMI(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainInterfaceAddressesWrapper(virDomainPtr dom, + virDomainInterfacePtr **ifaces, + unsigned int source, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002014 + assert(0); // Caller should have checked version +#else + int ret =3D virDomainInterfaceAddresses(dom, ifaces, source, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainGetTimeWrapper(virDomainPtr dom, - long long *seconds, - unsigned int *nseconds, - unsigned int flags) +void +virDomainInterfaceFreeWrapper(virDomainInterfacePtr iface) +{ +#if LIBVIR_VERSION_NUMBER < 1002014 + assert(0); // Caller should have checked version +#else + virDomainInterfaceFree(iface); +#endif +} + + +int +virDomainInterfaceStatsWrapper(virDomainPtr dom, + const char *device, + virDomainInterfaceStatsPtr stats, + size_t size, + virErrorPtr err) +{ + int ret =3D virDomainInterfaceStats(dom, device, stats, size); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +void +virDomainIOThreadInfoFreeWrapper(virDomainIOThreadInfoPtr info) +{ +#if LIBVIR_VERSION_NUMBER < 1002014 + assert(0); // Caller should have checked version +#else + virDomainIOThreadInfoFree(info); +#endif +} + + +int +virDomainIsActiveWrapper(virDomainPtr dom, + virErrorPtr err) +{ + int ret =3D virDomainIsActive(dom); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainIsPersistentWrapper(virDomainPtr dom, + virErrorPtr err) +{ + int ret =3D virDomainIsPersistent(dom); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainIsUpdatedWrapper(virDomainPtr dom, + virErrorPtr err) +{ + int ret =3D virDomainIsUpdated(dom); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainListAllSnapshotsWrapper(virDomainPtr domain, + virDomainSnapshotPtr **snaps, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainListAllSnapshots(domain, snaps, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainManagedSaveWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainManagedSave(dom, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainManagedSaveDefineXMLWrapper(virDomainPtr domain, + const char *dxml, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002005 +#if LIBVIR_VERSION_NUMBER < 3007000 assert(0); // Caller should have checked version #else - return virDomainGetTime(dom, seconds, nseconds, flags); + int ret =3D virDomainManagedSaveDefineXML(domain, dxml, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 -int virDomainSetTimeWrapper(virDomainPtr dom, - long long seconds, - unsigned int nseconds, - unsigned int flags) + +char * +virDomainManagedSaveGetXMLDescWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002005 +#if LIBVIR_VERSION_NUMBER < 3007000 assert(0); // Caller should have checked version #else - return virDomainSetTime(dom, seconds, nseconds, flags); + char * ret =3D virDomainManagedSaveGetXMLDesc(domain, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; #endif } =20 -int virDomainFSFreezeWrapper(virDomainPtr dom, - const char **mountpoints, - unsigned int nmountpoints, - unsigned int flags) + +int +virDomainManagedSaveRemoveWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002005 - assert(0); // Caller should have checked version -#else - return virDomainFSFreeze(dom, mountpoints, nmountpoints, flags); -#endif + int ret =3D virDomainManagedSaveRemove(dom, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainFSThawWrapper(virDomainPtr dom, - const char **mountpoints, - unsigned int nmountpoints, - unsigned int flags) + +int +virDomainMemoryPeekWrapper(virDomainPtr dom, + unsigned long long start, + size_t size, + void *buffer, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002005 + int ret =3D virDomainMemoryPeek(dom, start, size, buffer, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMemoryStatsWrapper(virDomainPtr dom, + virDomainMemoryStatPtr stats, + unsigned int nr_stats, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainMemoryStats(dom, stats, nr_stats, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +virDomainPtr +virDomainMigrateWrapper(virDomainPtr domain, + virConnectPtr dconn, + unsigned long flags, + const char *dname, + const char *uri, + unsigned long bandwidth, + virErrorPtr err) +{ + virDomainPtr ret =3D virDomainMigrate(domain, dconn, flags, dname, uri= , bandwidth); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +virDomainPtr +virDomainMigrate2Wrapper(virDomainPtr domain, + virConnectPtr dconn, + const char *dxml, + unsigned long flags, + const char *dname, + const char *uri, + unsigned long bandwidth, + virErrorPtr err) +{ + virDomainPtr ret =3D virDomainMigrate2(domain, dconn, dxml, flags, dna= me, uri, bandwidth); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +virDomainPtr +virDomainMigrate3Wrapper(virDomainPtr domain, + virConnectPtr dconn, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags, + virErrorPtr err) +{ + virDomainPtr ret =3D virDomainMigrate3(domain, dconn, params, nparams,= flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateGetCompressionCacheWrapper(virDomainPtr domain, + unsigned long long *cacheSize, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainMigrateGetCompressionCache(domain, cacheSize, fla= gs); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateGetMaxDowntimeWrapper(virDomainPtr domain, + unsigned long long *downtime, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 3007000 assert(0); // Caller should have checked version #else - return virDomainFSThaw(dom, mountpoints, nmountpoints, flags); + int ret =3D virDomainMigrateGetMaxDowntime(domain, downtime, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 -int virDomainBlockCopyWrapper(virDomainPtr dom, const char *disk, - const char *destxml, - virTypedParameterPtr params, - int nparams, - unsigned int flags) + +int +virDomainMigrateGetMaxSpeedWrapper(virDomainPtr domain, + unsigned long *bandwidth, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002008 + int ret =3D virDomainMigrateGetMaxSpeed(domain, bandwidth, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateSetCompressionCacheWrapper(virDomainPtr domain, + unsigned long long cacheSize, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainMigrateSetCompressionCache(domain, cacheSize, fla= gs); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateSetMaxDowntimeWrapper(virDomainPtr domain, + unsigned long long downtime, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainMigrateSetMaxDowntime(domain, downtime, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateSetMaxSpeedWrapper(virDomainPtr domain, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainMigrateSetMaxSpeed(domain, bandwidth, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateStartPostCopyWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1003003 assert(0); // Caller should have checked version #else - return virDomainBlockCopy(dom, disk, destxml, params, nparams, flags); + int ret =3D virDomainMigrateStartPostCopy(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 -int virDomainOpenGraphicsFDWrapper(virDomainPtr dom, - unsigned int idx, - unsigned int flags) + +int +virDomainMigrateToURIWrapper(virDomainPtr domain, + const char *duri, + unsigned long flags, + const char *dname, + unsigned long bandwidth, + virErrorPtr err) +{ + int ret =3D virDomainMigrateToURI(domain, duri, flags, dname, bandwidt= h); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateToURI2Wrapper(virDomainPtr domain, + const char *dconnuri, + const char *miguri, + const char *dxml, + unsigned long flags, + const char *dname, + unsigned long bandwidth, + virErrorPtr err) +{ + int ret =3D virDomainMigrateToURI2(domain, dconnuri, miguri, dxml, fla= gs, dname, bandwidth); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainMigrateToURI3Wrapper(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainMigrateToURI3(domain, dconnuri, params, nparams, = flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainOpenChannelWrapper(virDomainPtr dom, + const char *name, + virStreamPtr st, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainOpenChannel(dom, name, st, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainOpenConsoleWrapper(virDomainPtr dom, + const char *dev_name, + virStreamPtr st, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainOpenConsole(dom, dev_name, st, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainOpenGraphicsWrapper(virDomainPtr dom, + unsigned int idx, + int fd, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainOpenGraphics(dom, idx, fd, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainOpenGraphicsFDWrapper(virDomainPtr dom, + unsigned int idx, + unsigned int flags, + virErrorPtr err) { #if LIBVIR_VERSION_NUMBER < 1002008 assert(0); // Caller should have checked version #else - return virDomainOpenGraphicsFD(dom, idx, flags); + int ret =3D virDomainOpenGraphicsFD(dom, idx, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 -void virDomainFSInfoFreeWrapper(virDomainFSInfoPtr info) + +int +virDomainPMSuspendForDurationWrapper(virDomainPtr dom, + unsigned int target, + unsigned long long duration, + unsigned int flags, + virErrorPtr err) { + int ret =3D virDomainPMSuspendForDuration(dom, target, duration, flags= ); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainGetFSInfoWrapper(virDomainPtr dom, - virDomainFSInfoPtr **info, - unsigned int flags) + +int +virDomainPMWakeupWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002011 - assert(0); // Caller should have checked version -#else - return virDomainGetFSInfo(dom, info, flags); -#endif + int ret =3D virDomainPMWakeup(dom, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainPinEmulatorWrapper(virDomainPtr domain, + unsigned char *cpumap, + int maplen, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainPinEmulator(domain, cpumap, maplen, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainInterfaceAddressesWrapper(virDomainPtr dom, - virDomainInterfacePtr **ifaces, - unsigned int source, - unsigned int flags) + +int +virDomainPinIOThreadWrapper(virDomainPtr domain, + unsigned int iothread_id, + unsigned char *cpumap, + int maplen, + unsigned int flags, + virErrorPtr err) { #if LIBVIR_VERSION_NUMBER < 1002014 assert(0); // Caller should have checked version #else - return virDomainInterfaceAddresses(dom, ifaces, source, flags); + int ret =3D virDomainPinIOThread(domain, iothread_id, cpumap, maplen, = flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 -void virDomainInterfaceFreeWrapper(virDomainInterfacePtr iface) + +int +virDomainPinVcpuWrapper(virDomainPtr domain, + unsigned int vcpu, + unsigned char *cpumap, + int maplen, + virErrorPtr err) { + int ret =3D virDomainPinVcpu(domain, vcpu, cpumap, maplen); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -void virDomainIOThreadInfoFreeWrapper(virDomainIOThreadInfoPtr info) + +int +virDomainPinVcpuFlagsWrapper(virDomainPtr domain, + unsigned int vcpu, + unsigned char *cpumap, + int maplen, + unsigned int flags, + virErrorPtr err) { + int ret =3D virDomainPinVcpuFlags(domain, vcpu, cpumap, maplen, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainGetIOThreadInfoWrapper(virDomainPtr domain, - virDomainIOThreadInfoPtr **info, - unsigned int flags) + +int +virDomainRebootWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002014 - assert(0); // Caller should have checked version -#else - return virDomainGetIOThreadInfo(domain, info, flags); -#endif + int ret =3D virDomainReboot(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } -int virDomainPinIOThreadWrapper(virDomainPtr domain, - unsigned int iothread_id, - unsigned char *cpumap, - int maplen, - unsigned int flags) + + +int +virDomainRefWrapper(virDomainPtr domain, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002014 - assert(0); // Caller should have checked version -#else - return virDomainPinIOThread(domain, iothread_id, cpumap, maplen, flags= ); -#endif + int ret =3D virDomainRef(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainAddIOThreadWrapper(virDomainPtr domain, - unsigned int iothread_id, - unsigned int flags) + +int +virDomainRenameWrapper(virDomainPtr dom, + const char *new_name, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002015 +#if LIBVIR_VERSION_NUMBER < 1002019 assert(0); // Caller should have checked version #else - return virDomainAddIOThread(domain, iothread_id, flags); + int ret =3D virDomainRename(dom, new_name, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainDelIOThreadWrapper(virDomainPtr domain, - unsigned int iothread_id, - unsigned int flags) +int +virDomainResetWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002015 - assert(0); // Caller should have checked version -#else - return virDomainDelIOThread(domain, iothread_id, flags); -#endif + int ret =3D virDomainReset(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 =20 -int virDomainSetUserPasswordWrapper(virDomainPtr dom, - const char *user, - const char *password, - unsigned int flags) +int +virDomainResumeWrapper(virDomainPtr domain, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002016 - assert(0); // Caller should have checked version -#else - return virDomainSetUserPassword(dom, user, password, flags); -#endif + int ret =3D virDomainResume(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 =20 -int virDomainRenameWrapper(virDomainPtr dom, - const char *new_name, - unsigned int flags) +int +virDomainSaveWrapper(virDomainPtr domain, + const char *to, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1002019 + int ret =3D virDomainSave(domain, to); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSaveFlagsWrapper(virDomainPtr domain, + const char *to, + const char *dxml, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSaveFlags(domain, to, dxml, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +char * +virDomainScreenshotWrapper(virDomainPtr domain, + virStreamPtr stream, + unsigned int screen, + unsigned int flags, + virErrorPtr err) +{ + char * ret =3D virDomainScreenshot(domain, stream, screen, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSendKeyWrapper(virDomainPtr domain, + unsigned int codeset, + unsigned int holdtime, + unsigned int *keycodes, + int nkeycodes, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSendKey(domain, codeset, holdtime, keycodes, nkey= codes, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSendProcessSignalWrapper(virDomainPtr domain, + long long pid_value, + unsigned int signum, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSendProcessSignal(domain, pid_value, signum, flag= s); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetAutostartWrapper(virDomainPtr domain, + int autostart, + virErrorPtr err) +{ + int ret =3D virDomainSetAutostart(domain, autostart); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetBlkioParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetBlkioParameters(domain, params, nparams, flags= ); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetBlockIoTuneWrapper(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetBlockIoTune(dom, disk, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetBlockThresholdWrapper(virDomainPtr domain, + const char *dev, + unsigned long long threshold, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 3002000 assert(0); // Caller should have checked version #else - return virDomainRename(dom, new_name, flags); + int ret =3D virDomainSetBlockThreshold(domain, dev, threshold, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainGetPerfEventsWrapper(virDomainPtr dom, - virTypedParameterPtr *params, - int *nparams, - unsigned int flags) +int +virDomainSetGuestVcpusWrapper(virDomainPtr domain, + const char *cpumap, + int state, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1003003 +#if LIBVIR_VERSION_NUMBER < 2000000 assert(0); // Caller should have checked version #else - return virDomainGetPerfEvents(dom, params, nparams, flags); + int ret =3D virDomainSetGuestVcpus(domain, cpumap, state, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainSetPerfEventsWrapper(virDomainPtr dom, - virTypedParameterPtr params, - int nparams, - unsigned int flags) +int +virDomainSetInterfaceParametersWrapper(virDomainPtr domain, + const char *device, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 1003003 + int ret =3D virDomainSetInterfaceParameters(domain, device, params, np= arams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetLifecycleActionWrapper(virDomainPtr domain, + unsigned int type, + unsigned int action, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 3009000 assert(0); // Caller should have checked version #else - return virDomainSetPerfEvents(dom, params, nparams, flags); + int ret =3D virDomainSetLifecycleAction(domain, type, action, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainMigrateStartPostCopyWrapper(virDomainPtr domain, - unsigned int flags) +int +virDomainSetMaxMemoryWrapper(virDomainPtr domain, + unsigned long memory, + virErrorPtr err) +{ + int ret =3D virDomainSetMaxMemory(domain, memory); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetMemoryWrapper(virDomainPtr domain, + unsigned long memory, + virErrorPtr err) +{ + int ret =3D virDomainSetMemory(domain, memory); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetMemoryFlagsWrapper(virDomainPtr domain, + unsigned long memory, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetMemoryFlags(domain, memory, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetMemoryParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetMemoryParameters(domain, params, nparams, flag= s); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetMemoryStatsPeriodWrapper(virDomainPtr domain, + int period, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetMemoryStatsPeriod(domain, period, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetMetadataWrapper(virDomainPtr domain, + int type, + const char *metadata, + const char *key, + const char *uri, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetMetadata(domain, type, metadata, key, uri, fla= gs); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetNumaParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetNumaParameters(domain, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetPerfEventsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) { #if LIBVIR_VERSION_NUMBER < 1003003 assert(0); // Caller should have checked version #else - return virDomainMigrateStartPostCopy(domain, flags); + int ret =3D virDomainSetPerfEvents(domain, params, nparams, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainGetGuestVcpusWrapper(virDomainPtr domain, - virTypedParameterPtr *params, - unsigned int *nparams, - unsigned int flags) +int +virDomainSetSchedulerParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 2000000 + int ret =3D virDomainSetSchedulerParameters(domain, params, nparams); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetSchedulerParametersFlagsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSetSchedulerParametersFlags(domain, params, npara= ms, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSetTimeWrapper(virDomainPtr dom, + long long seconds, + unsigned int nseconds, + unsigned int flags, + virErrorPtr err) +{ +#if LIBVIR_VERSION_NUMBER < 1002005 assert(0); // Caller should have checked version #else - return virDomainGetGuestVcpus(domain, params, nparams, flags); + int ret =3D virDomainSetTime(dom, seconds, nseconds, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainSetGuestVcpusWrapper(virDomainPtr domain, - const char *cpumap, - int state, - unsigned int flags) +int +virDomainSetUserPasswordWrapper(virDomainPtr dom, + const char *user, + const char *password, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 2000000 +#if LIBVIR_VERSION_NUMBER < 1002016 assert(0); // Caller should have checked version #else - return virDomainSetGuestVcpus(domain, cpumap, state, flags); + int ret =3D virDomainSetUserPassword(dom, user, password, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 -int virDomainSetVcpuWrapper(virDomainPtr domain, - const char *cpumap, - int state, - unsigned int flags) + +int +virDomainSetVcpuWrapper(virDomainPtr domain, + const char *vcpumap, + int state, + unsigned int flags, + virErrorPtr err) { #if LIBVIR_VERSION_NUMBER < 3001000 assert(0); // Caller should have checked version #else - return virDomainSetVcpu(domain, cpumap, state, flags); + int ret =3D virDomainSetVcpu(domain, vcpumap, state, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; #endif } =20 =20 -int virDomainSetBlockThresholdWrapper(virDomainPtr domain, - const char *dev, - unsigned long long threshold, - unsigned int flags) +int +virDomainSetVcpusWrapper(virDomainPtr domain, + unsigned int nvcpus, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 3002000 - assert(0); // Caller should have checked version -#else - return virDomainSetBlockThreshold(domain, dev, threshold, flags); -#endif + int ret =3D virDomainSetVcpus(domain, nvcpus); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainMigrateGetMaxDowntimeWrapper(virDomainPtr domain, - unsigned long long *downtime, - unsigned int flags) + +int +virDomainSetVcpusFlagsWrapper(virDomainPtr domain, + unsigned int nvcpus, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 3007000 - assert(0); // Caller should have checked version -#else - return virDomainMigrateGetMaxDowntime(domain, downtime, flags); -#endif + int ret =3D virDomainSetVcpusFlags(domain, nvcpus, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 =20 -char *virDomainManagedSaveGetXMLDescWrapper(virDomainPtr domain, - unsigned int flags) +int +virDomainShutdownWrapper(virDomainPtr domain, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 3007000 - assert(0); // Caller should have checked version -#else - return virDomainManagedSaveGetXMLDesc(domain, flags); -#endif + int ret =3D virDomainShutdown(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 =20 -int virDomainManagedSaveDefineXMLWrapper(virDomainPtr domain, - const char *dxml, - unsigned int flags) +int +virDomainShutdownFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 3007000 - assert(0); // Caller should have checked version -#else - return virDomainManagedSaveDefineXML(domain, dxml, flags); -#endif + int ret =3D virDomainShutdownFlags(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainSetLifecycleActionWrapper(virDomainPtr domain, - unsigned int type, - unsigned int action, - unsigned int flags) + +virDomainSnapshotPtr +virDomainSnapshotCreateXMLWrapper(virDomainPtr domain, + const char *xmlDesc, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 3009000 - assert(0); // Caller should have checked version -#else - return virDomainSetLifecycleAction(domain, type, action, flags); -#endif + virDomainSnapshotPtr ret =3D virDomainSnapshotCreateXML(domain, xmlDes= c, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainDetachDeviceAliasWrapper(virDomainPtr domain, - const char *alias, - unsigned int flags) + +virDomainSnapshotPtr +virDomainSnapshotCurrentWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 4004000 - assert(0); // Caller should have checked version -#else - return virDomainDetachDeviceAlias(domain, alias, flags); -#endif + virDomainSnapshotPtr ret =3D virDomainSnapshotCurrent(domain, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; } =20 -int virDomainGetLaunchSecurityInfoWrapper(virDomainPtr domain, - virTypedParameterPtr *params, - int *nparams, - unsigned int flags) + +int +virDomainSnapshotListNamesWrapper(virDomainPtr domain, + char **names, + int nameslen, + unsigned int flags, + virErrorPtr err) { -#if LIBVIR_VERSION_NUMBER < 4005000 - assert(0); // Caller should have checked version -#else - return virDomainGetLaunchSecurityInfo(domain, params, nparams, flags); -#endif + int ret =3D virDomainSnapshotListNames(domain, names, nameslen, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +virDomainSnapshotPtr +virDomainSnapshotLookupByNameWrapper(virDomainPtr domain, + const char *name, + unsigned int flags, + virErrorPtr err) +{ + virDomainSnapshotPtr ret =3D virDomainSnapshotLookupByName(domain, nam= e, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSnapshotNumWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainSnapshotNum(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainSuspendWrapper(virDomainPtr domain, + virErrorPtr err) +{ + int ret =3D virDomainSuspend(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainUndefineWrapper(virDomainPtr domain, + virErrorPtr err) +{ + int ret =3D virDomainUndefine(domain); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainUndefineFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainUndefineFlags(domain, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virDomainUpdateDeviceFlagsWrapper(virDomainPtr domain, + const char *xml, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virDomainUpdateDeviceFlags(domain, xml, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; } =20 + */ import "C" diff --git a/domain_wrapper.h b/domain_wrapper.h index c344565..7bd8282 100644 --- a/domain_wrapper.h +++ b/domain_wrapper.h @@ -31,174 +31,956 @@ #include #include "domain_compat.h" =20 +int +virDomainAbortJobWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainAddIOThreadWrapper(virDomainPtr domain, + unsigned int iothread_id, + unsigned int flags, + virErrorPtr err); + +int +virDomainAttachDeviceWrapper(virDomainPtr domain, + const char *xml, + virErrorPtr err); + +int +virDomainAttachDeviceFlagsWrapper(virDomainPtr domain, + const char *xml, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockCommitWrapper(virDomainPtr dom, + const char *disk, + const char *base, + const char *top, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockCopyWrapper(virDomainPtr dom, + const char *disk, + const char *destxml, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockJobAbortWrapper(virDomainPtr dom, + const char *disk, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockJobSetSpeedWrapper(virDomainPtr dom, + const char *disk, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockPeekWrapper(virDomainPtr dom, + const char *disk, + unsigned long long offset, + size_t size, + void *buffer, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockPullWrapper(virDomainPtr dom, + const char *disk, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockRebaseWrapper(virDomainPtr dom, + const char *disk, + const char *base, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockResizeWrapper(virDomainPtr dom, + const char *disk, + unsigned long long size, + unsigned int flags, + virErrorPtr err); + +int +virDomainBlockStatsWrapper(virDomainPtr dom, + const char *disk, + virDomainBlockStatsPtr stats, + size_t size, + virErrorPtr err); + +int +virDomainBlockStatsFlagsWrapper(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainCoreDumpWrapper(virDomainPtr domain, + const char *to, + unsigned int flags, + virErrorPtr err); + int virDomainCoreDumpWithFormatWrapper(virDomainPtr domain, const char *to, unsigned int dumpformat, - unsigned int flags); + unsigned int flags, + virErrorPtr err); =20 +int +virDomainCreateWrapper(virDomainPtr domain, + virErrorPtr err); =20 int -virDomainGetTimeWrapper(virDomainPtr dom, - long long *seconds, - unsigned int *nseconds, - unsigned int flags); +virDomainCreateWithFilesWrapper(virDomainPtr domain, + unsigned int nfiles, + int *files, + unsigned int flags, + virErrorPtr err); =20 int -virDomainSetTimeWrapper(virDomainPtr dom, - long long seconds, - unsigned int nseconds, - unsigned int flags); +virDomainCreateWithFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainDelIOThreadWrapper(virDomainPtr domain, + unsigned int iothread_id, + unsigned int flags, + virErrorPtr err); + +int +virDomainDestroyWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainDestroyFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainDetachDeviceWrapper(virDomainPtr domain, + const char *xml, + virErrorPtr err); + +int +virDomainDetachDeviceAliasWrapper(virDomainPtr domain, + const char *alias, + unsigned int flags, + virErrorPtr err); + +int +virDomainDetachDeviceFlagsWrapper(virDomainPtr domain, + const char *xml, + unsigned int flags, + virErrorPtr err); =20 int virDomainFSFreezeWrapper(virDomainPtr dom, const char **mountpoints, unsigned int nmountpoints, - unsigned int flags); + unsigned int flags, + virErrorPtr err); + +void +virDomainFSInfoFreeWrapper(virDomainFSInfoPtr info); =20 int virDomainFSThawWrapper(virDomainPtr dom, const char **mountpoints, unsigned int nmountpoints, - unsigned int flags); + unsigned int flags, + virErrorPtr err); =20 +int +virDomainFSTrimWrapper(virDomainPtr dom, + const char *mountPoint, + unsigned long long minimum, + unsigned int flags, + virErrorPtr err); =20 int -virDomainBlockCopyWrapper(virDomainPtr dom, - const char *disk, - const char *destxml, - virTypedParameterPtr params, - int nparams, - unsigned int flags); +virDomainFreeWrapper(virDomainPtr domain, + virErrorPtr err); =20 int -virDomainOpenGraphicsFDWrapper(virDomainPtr dom, - unsigned int idx, - unsigned int flags); +virDomainGetAutostartWrapper(virDomainPtr domain, + int *autostart, + virErrorPtr err); =20 +int +virDomainGetBlkioParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err); =20 -void -virDomainFSInfoFreeWrapper(virDomainFSInfoPtr info); +int +virDomainGetBlockInfoWrapper(virDomainPtr domain, + const char *disk, + virDomainBlockInfoPtr info, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetBlockIoTuneWrapper(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetBlockJobInfoWrapper(virDomainPtr dom, + const char *disk, + virDomainBlockJobInfoPtr info, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetCPUStatsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + unsigned int nparams, + int start_cpu, + unsigned int ncpus, + unsigned int flags, + virErrorPtr err); + +virConnectPtr +virDomainGetConnectWrapper(virDomainPtr dom, + virErrorPtr err); + +int +virDomainGetControlInfoWrapper(virDomainPtr domain, + virDomainControlInfoPtr info, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetDiskErrorsWrapper(virDomainPtr dom, + virDomainDiskErrorPtr errors, + unsigned int maxerrors, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetEmulatorPinInfoWrapper(virDomainPtr domain, + unsigned char *cpumap, + int maplen, + unsigned int flags, + virErrorPtr err); =20 int virDomainGetFSInfoWrapper(virDomainPtr dom, virDomainFSInfoPtr **info, - unsigned int flags); + unsigned int flags, + virErrorPtr err); + +int +virDomainGetGuestVcpusWrapper(virDomainPtr domain, + virTypedParameterPtr *params, + unsigned int *nparams, + unsigned int flags, + virErrorPtr err); + +char * +virDomainGetHostnameWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +unsigned int +virDomainGetIDWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainGetIOThreadInfoWrapper(virDomainPtr dom, + virDomainIOThreadInfoPtr **info, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetInfoWrapper(virDomainPtr domain, + virDomainInfoPtr info, + virErrorPtr err); + +int +virDomainGetInterfaceParametersWrapper(virDomainPtr domain, + const char *device, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetJobInfoWrapper(virDomainPtr domain, + virDomainJobInfoPtr info, + virErrorPtr err); + +int +virDomainGetJobStatsWrapper(virDomainPtr domain, + int *type, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetLaunchSecurityInfoWrapper(virDomainPtr domain, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +unsigned long +virDomainGetMaxMemoryWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainGetMaxVcpusWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainGetMemoryParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +char * +virDomainGetMetadataWrapper(virDomainPtr domain, + int type, + const char *uri, + unsigned int flags, + virErrorPtr err); + +const char * +virDomainGetNameWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainGetNumaParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +char * +virDomainGetOSTypeWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainGetPerfEventsWrapper(virDomainPtr domain, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetSchedulerParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + virErrorPtr err); + +int +virDomainGetSchedulerParametersFlagsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int *nparams, + unsigned int flags, + virErrorPtr err); + +char * +virDomainGetSchedulerTypeWrapper(virDomainPtr domain, + int *nparams, + virErrorPtr err); =20 +int +virDomainGetSecurityLabelWrapper(virDomainPtr domain, + virSecurityLabelPtr seclabel, + virErrorPtr err); + +int +virDomainGetSecurityLabelListWrapper(virDomainPtr domain, + virSecurityLabelPtr *seclabels, + virErrorPtr err); + +int +virDomainGetStateWrapper(virDomainPtr domain, + int *state, + int *reason, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetTimeWrapper(virDomainPtr dom, + long long *seconds, + unsigned int *nseconds, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetUUIDWrapper(virDomainPtr domain, + unsigned char *uuid, + virErrorPtr err); + +int +virDomainGetUUIDStringWrapper(virDomainPtr domain, + char *buf, + virErrorPtr err); + +int +virDomainGetVcpuPinInfoWrapper(virDomainPtr domain, + int ncpumaps, + unsigned char *cpumaps, + int maplen, + unsigned int flags, + virErrorPtr err); + +int +virDomainGetVcpusWrapper(virDomainPtr domain, + virVcpuInfoPtr info, + int maxinfo, + unsigned char *cpumaps, + int maplen, + virErrorPtr err); + +int +virDomainGetVcpusFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +char * +virDomainGetXMLDescWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainHasCurrentSnapshotWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainHasManagedSaveImageWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err); + +int +virDomainInjectNMIWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); =20 int virDomainInterfaceAddressesWrapper(virDomainPtr dom, virDomainInterfacePtr **ifaces, unsigned int source, - unsigned int flags); + unsigned int flags, + virErrorPtr err); =20 void virDomainInterfaceFreeWrapper(virDomainInterfacePtr iface); =20 +int +virDomainInterfaceStatsWrapper(virDomainPtr dom, + const char *device, + virDomainInterfaceStatsPtr stats, + size_t size, + virErrorPtr err); + void virDomainIOThreadInfoFreeWrapper(virDomainIOThreadInfoPtr info); =20 int -virDomainGetIOThreadInfoWrapper(virDomainPtr domain, - virDomainIOThreadInfoPtr **info, - unsigned int flags); +virDomainIsActiveWrapper(virDomainPtr dom, + virErrorPtr err); + +int +virDomainIsPersistentWrapper(virDomainPtr dom, + virErrorPtr err); + +int +virDomainIsUpdatedWrapper(virDomainPtr dom, + virErrorPtr err); + +int +virDomainListAllSnapshotsWrapper(virDomainPtr domain, + virDomainSnapshotPtr **snaps, + unsigned int flags, + virErrorPtr err); + +int +virDomainManagedSaveWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err); + +int +virDomainManagedSaveDefineXMLWrapper(virDomainPtr domain, + const char *dxml, + unsigned int flags, + virErrorPtr err); + +char * +virDomainManagedSaveGetXMLDescWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainManagedSaveRemoveWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err); + +int +virDomainMemoryPeekWrapper(virDomainPtr dom, + unsigned long long start, + size_t size, + void *buffer, + unsigned int flags, + virErrorPtr err); + +int +virDomainMemoryStatsWrapper(virDomainPtr dom, + virDomainMemoryStatPtr stats, + unsigned int nr_stats, + unsigned int flags, + virErrorPtr err); + +virDomainPtr +virDomainMigrateWrapper(virDomainPtr domain, + virConnectPtr dconn, + unsigned long flags, + const char *dname, + const char *uri, + unsigned long bandwidth, + virErrorPtr err); + +virDomainPtr +virDomainMigrate2Wrapper(virDomainPtr domain, + virConnectPtr dconn, + const char *dxml, + unsigned long flags, + const char *dname, + const char *uri, + unsigned long bandwidth, + virErrorPtr err); + +virDomainPtr +virDomainMigrate3Wrapper(virDomainPtr domain, + virConnectPtr dconn, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateGetCompressionCacheWrapper(virDomainPtr domain, + unsigned long long *cacheSize, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateGetMaxDowntimeWrapper(virDomainPtr domain, + unsigned long long *downtime, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateGetMaxSpeedWrapper(virDomainPtr domain, + unsigned long *bandwidth, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateSetCompressionCacheWrapper(virDomainPtr domain, + unsigned long long cacheSize, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateSetMaxDowntimeWrapper(virDomainPtr domain, + unsigned long long downtime, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateSetMaxSpeedWrapper(virDomainPtr domain, + unsigned long bandwidth, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateStartPostCopyWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainMigrateToURIWrapper(virDomainPtr domain, + const char *duri, + unsigned long flags, + const char *dname, + unsigned long bandwidth, + virErrorPtr err); + +int +virDomainMigrateToURI2Wrapper(virDomainPtr domain, + const char *dconnuri, + const char *miguri, + const char *dxml, + unsigned long flags, + const char *dname, + unsigned long bandwidth, + virErrorPtr err); + +int +virDomainMigrateToURI3Wrapper(virDomainPtr domain, + const char *dconnuri, + virTypedParameterPtr params, + unsigned int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainOpenChannelWrapper(virDomainPtr dom, + const char *name, + virStreamPtr st, + unsigned int flags, + virErrorPtr err); + +int +virDomainOpenConsoleWrapper(virDomainPtr dom, + const char *dev_name, + virStreamPtr st, + unsigned int flags, + virErrorPtr err); + +int +virDomainOpenGraphicsWrapper(virDomainPtr dom, + unsigned int idx, + int fd, + unsigned int flags, + virErrorPtr err); + +int +virDomainOpenGraphicsFDWrapper(virDomainPtr dom, + unsigned int idx, + unsigned int flags, + virErrorPtr err); + +int +virDomainPMSuspendForDurationWrapper(virDomainPtr dom, + unsigned int target, + unsigned long long duration, + unsigned int flags, + virErrorPtr err); + +int +virDomainPMWakeupWrapper(virDomainPtr dom, + unsigned int flags, + virErrorPtr err); + +int +virDomainPinEmulatorWrapper(virDomainPtr domain, + unsigned char *cpumap, + int maplen, + unsigned int flags, + virErrorPtr err); + int virDomainPinIOThreadWrapper(virDomainPtr domain, unsigned int iothread_id, unsigned char *cpumap, int maplen, - unsigned int flags); + unsigned int flags, + virErrorPtr err); =20 int -virDomainAddIOThreadWrapper(virDomainPtr domain, - unsigned int iothread_id, - unsigned int flags); +virDomainPinVcpuWrapper(virDomainPtr domain, + unsigned int vcpu, + unsigned char *cpumap, + int maplen, + virErrorPtr err); =20 int -virDomainDelIOThreadWrapper(virDomainPtr domain, - unsigned int iothread_id, - unsigned int flags); +virDomainPinVcpuFlagsWrapper(virDomainPtr domain, + unsigned int vcpu, + unsigned char *cpumap, + int maplen, + unsigned int flags, + virErrorPtr err); =20 int -virDomainSetUserPasswordWrapper(virDomainPtr dom, - const char *user, - const char *password, - unsigned int flags); +virDomainRebootWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainRefWrapper(virDomainPtr domain, + virErrorPtr err); =20 int virDomainRenameWrapper(virDomainPtr dom, const char *new_name, - unsigned int flags); + unsigned int flags, + virErrorPtr err); =20 int -virDomainGetPerfEventsWrapper(virDomainPtr dom, - virTypedParameterPtr *params, - int *nparams, - unsigned int flags); +virDomainResetWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); =20 int -virDomainSetPerfEventsWrapper(virDomainPtr dom, - virTypedParameterPtr params, - int nparams, - unsigned int flags); +virDomainResumeWrapper(virDomainPtr domain, + virErrorPtr err); =20 int -virDomainMigrateStartPostCopyWrapper(virDomainPtr domain, - unsigned int flags); +virDomainSaveWrapper(virDomainPtr domain, + const char *to, + virErrorPtr err); =20 int -virDomainGetGuestVcpusWrapper(virDomainPtr domain, - virTypedParameterPtr *params, - unsigned int *nparams, - unsigned int flags); +virDomainSaveFlagsWrapper(virDomainPtr domain, + const char *to, + const char *dxml, + unsigned int flags, + virErrorPtr err); + +char * +virDomainScreenshotWrapper(virDomainPtr domain, + virStreamPtr stream, + unsigned int screen, + unsigned int flags, + virErrorPtr err); =20 int -virDomainSetGuestVcpusWrapper(virDomainPtr domain, - const char *cpumap, - int state, - unsigned int flags); +virDomainSendKeyWrapper(virDomainPtr domain, + unsigned int codeset, + unsigned int holdtime, + unsigned int *keycodes, + int nkeycodes, + unsigned int flags, + virErrorPtr err); =20 int -virDomainSetVcpuWrapper(virDomainPtr domain, - const char *cpumap, - int state, - unsigned int flags); +virDomainSendProcessSignalWrapper(virDomainPtr domain, + long long pid_value, + unsigned int signum, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetAutostartWrapper(virDomainPtr domain, + int autostart, + virErrorPtr err); + +int +virDomainSetBlkioParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetBlockIoTuneWrapper(virDomainPtr dom, + const char *disk, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); =20 int virDomainSetBlockThresholdWrapper(virDomainPtr domain, const char *dev, unsigned long long threshold, - unsigned int flags); + unsigned int flags, + virErrorPtr err); =20 int -virDomainMigrateGetMaxDowntimeWrapper(virDomainPtr domain, - unsigned long long *downtime, - unsigned int flags); - -char * -virDomainManagedSaveGetXMLDescWrapper(virDomainPtr domain, - unsigned int flags); +virDomainSetGuestVcpusWrapper(virDomainPtr domain, + const char *cpumap, + int state, + unsigned int flags, + virErrorPtr err); =20 int -virDomainManagedSaveDefineXMLWrapper(virDomainPtr domain, - const char *dxml, - unsigned int flags); +virDomainSetInterfaceParametersWrapper(virDomainPtr domain, + const char *device, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); =20 int virDomainSetLifecycleActionWrapper(virDomainPtr domain, unsigned int type, unsigned int action, - unsigned int flags); + unsigned int flags, + virErrorPtr err); =20 int -virDomainDetachDeviceAliasWrapper(virDomainPtr domain, - const char *alias, - unsigned int flags); +virDomainSetMaxMemoryWrapper(virDomainPtr domain, + unsigned long memory, + virErrorPtr err); =20 int -virDomainGetLaunchSecurityInfoWrapper(virDomainPtr domain, - virTypedParameterPtr *params, - int *nparams, - unsigned int flags); +virDomainSetMemoryWrapper(virDomainPtr domain, + unsigned long memory, + virErrorPtr err); + +int +virDomainSetMemoryFlagsWrapper(virDomainPtr domain, + unsigned long memory, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetMemoryParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetMemoryStatsPeriodWrapper(virDomainPtr domain, + int period, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetMetadataWrapper(virDomainPtr domain, + int type, + const char *metadata, + const char *key, + const char *uri, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetNumaParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetPerfEventsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetSchedulerParametersWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + virErrorPtr err); + +int +virDomainSetSchedulerParametersFlagsWrapper(virDomainPtr domain, + virTypedParameterPtr params, + int nparams, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetTimeWrapper(virDomainPtr dom, + long long seconds, + unsigned int nseconds, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetUserPasswordWrapper(virDomainPtr dom, + const char *user, + const char *password, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetVcpuWrapper(virDomainPtr domain, + const char *vcpumap, + int state, + unsigned int flags, + virErrorPtr err); + +int +virDomainSetVcpusWrapper(virDomainPtr domain, + unsigned int nvcpus, + virErrorPtr err); + +int +virDomainSetVcpusFlagsWrapper(virDomainPtr domain, + unsigned int nvcpus, + unsigned int flags, + virErrorPtr err); + +int +virDomainShutdownWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainShutdownFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +virDomainSnapshotPtr +virDomainSnapshotCreateXMLWrapper(virDomainPtr domain, + const char *xmlDesc, + unsigned int flags, + virErrorPtr err); + +virDomainSnapshotPtr +virDomainSnapshotCurrentWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainSnapshotListNamesWrapper(virDomainPtr domain, + char **names, + int nameslen, + unsigned int flags, + virErrorPtr err); + +virDomainSnapshotPtr +virDomainSnapshotLookupByNameWrapper(virDomainPtr domain, + const char *name, + unsigned int flags, + virErrorPtr err); + +int +virDomainSnapshotNumWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainSuspendWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainUndefineWrapper(virDomainPtr domain, + virErrorPtr err); + +int +virDomainUndefineFlagsWrapper(virDomainPtr domain, + unsigned int flags, + virErrorPtr err); + +int +virDomainUpdateDeviceFlagsWrapper(virDomainPtr domain, + const char *xml, + unsigned int flags, + virErrorPtr err); + =20 #endif /* LIBVIRT_GO_DOMAIN_WRAPPER_H__ */ --=20 2.17.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list