From nobody Sun Feb 8 14:10:16 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 1531747521539394.2704166565901; Mon, 16 Jul 2018 06:25:21 -0700 (PDT) Received: from smtp.corp.redhat.com (int-mx10.intmail.prod.int.phx2.redhat.com [10.5.11.25]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 28438307CF35; Mon, 16 Jul 2018 13:25:20 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id D6B582010CA0; Mon, 16 Jul 2018 13:25:19 +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 7B6F81853DA3; Mon, 16 Jul 2018 13:25:19 +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 w6GDOmlI028154 for ; Mon, 16 Jul 2018 09:24:48 -0400 Received: by smtp.corp.redhat.com (Postfix) id AAC312027047; Mon, 16 Jul 2018 13:24:48 +0000 (UTC) Received: from t460.redhat.com (unknown [10.33.36.75]) by smtp.corp.redhat.com (Postfix) with ESMTP id D48972026D65; Mon, 16 Jul 2018 13:24:47 +0000 (UTC) From: =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= To: libvir-list@redhat.com Date: Mon, 16 Jul 2018 14:24:07 +0100 Message-Id: <20180716132423.10354-22-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 21/37] storage pool: 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.25 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.44]); Mon, 16 Jul 2018 13:25:20 +0000 (UTC) X-ZohoMail: RSF_0 Z_629925259 SPT_0 Create wrapper functions for each storage pool 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 --- storage_pool.go | 117 +++++++++------ storage_pool_wrapper.go | 309 ++++++++++++++++++++++++++++++++++++++++ storage_pool_wrapper.h | 117 +++++++++++++++ 3 files changed, 496 insertions(+), 47 deletions(-) diff --git a/storage_pool.go b/storage_pool.go index a2d1462..9bfcc79 100644 --- a/storage_pool.go +++ b/storage_pool.go @@ -105,54 +105,60 @@ type StoragePoolInfo struct { =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolBuild func (p *StoragePool) Build(flags StoragePoolBuildFlags) error { - result :=3D C.virStoragePoolBuild(p.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virStoragePoolBuildWrapper(p.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-storage.html#virStora= gePoolCreate func (p *StoragePool) Create(flags StoragePoolCreateFlags) error { - result :=3D C.virStoragePoolCreate(p.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virStoragePoolCreateWrapper(p.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-storage.html#virStora= gePoolDelete func (p *StoragePool) Delete(flags StoragePoolDeleteFlags) error { - result :=3D C.virStoragePoolDelete(p.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virStoragePoolDeleteWrapper(p.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-storage.html#virStora= gePoolDestroy func (p *StoragePool) Destroy() error { - result :=3D C.virStoragePoolDestroy(p.ptr) + var err C.virError + result :=3D C.virStoragePoolDestroyWrapper(p.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolFree func (p *StoragePool) Free() error { - ret :=3D C.virStoragePoolFree(p.ptr) + var err C.virError + ret :=3D C.virStoragePoolFreeWrapper(p.ptr, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolRef func (c *StoragePool) Ref() error { - ret :=3D C.virStoragePoolRef(c.ptr) + var err C.virError + ret :=3D C.virStoragePoolRefWrapper(c.ptr, &err) if ret =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -160,9 +166,10 @@ func (c *StoragePool) Ref() error { // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolGetAutostart func (p *StoragePool) GetAutostart() (bool, error) { var out C.int - result :=3D C.virStoragePoolGetAutostart(p.ptr, (*C.int)(unsafe.Pointer(&= out))) + var err C.virError + result :=3D C.virStoragePoolGetAutostartWrapper(p.ptr, (*C.int)(unsafe.Po= inter(&out)), &err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } switch out { case 1: @@ -175,9 +182,10 @@ func (p *StoragePool) GetAutostart() (bool, error) { // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolGetInfo func (p *StoragePool) GetInfo() (*StoragePoolInfo, error) { var cinfo C.virStoragePoolInfo - result :=3D C.virStoragePoolGetInfo(p.ptr, &cinfo) + var err C.virError + result :=3D C.virStoragePoolGetInfoWrapper(p.ptr, &cinfo, &err) if result =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } return &StoragePoolInfo{ State: StoragePoolState(cinfo.state), @@ -189,9 +197,10 @@ func (p *StoragePool) GetInfo() (*StoragePoolInfo, err= or) { =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolGetName func (p *StoragePool) GetName() (string, error) { - name :=3D C.virStoragePoolGetName(p.ptr) + var err C.virError + name :=3D C.virStoragePoolGetNameWrapper(p.ptr, &err) if name =3D=3D nil { - return "", GetLastError() + return "", makeError(&err) } return C.GoString(name), nil } @@ -200,9 +209,10 @@ func (p *StoragePool) GetName() (string, error) { func (p *StoragePool) GetUUID() ([]byte, error) { var cUuid [C.VIR_UUID_BUFLEN](byte) cuidPtr :=3D unsafe.Pointer(&cUuid) - result :=3D C.virStoragePoolGetUUID(p.ptr, (*C.uchar)(cuidPtr)) + var err C.virError + result :=3D C.virStoragePoolGetUUIDWrapper(p.ptr, (*C.uchar)(cuidPtr), &e= rr) if result !=3D 0 { - return []byte{}, GetLastError() + return []byte{}, makeError(&err) } return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil } @@ -211,18 +221,20 @@ func (p *StoragePool) GetUUID() ([]byte, error) { func (p *StoragePool) GetUUIDString() (string, error) { var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) cuidPtr :=3D unsafe.Pointer(&cUuid) - result :=3D C.virStoragePoolGetUUIDString(p.ptr, (*C.char)(cuidPtr)) + var err C.virError + result :=3D C.virStoragePoolGetUUIDStringWrapper(p.ptr, (*C.char)(cuidPtr= ), &err) if result !=3D 0 { - return "", GetLastError() + return "", makeError(&err) } return C.GoString((*C.char)(cuidPtr)), nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolGetXMLDesc func (p *StoragePool) GetXMLDesc(flags StorageXMLFlags) (string, error) { - result :=3D C.virStoragePoolGetXMLDesc(p.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virStoragePoolGetXMLDescWrapper(p.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)) @@ -231,9 +243,10 @@ func (p *StoragePool) GetXMLDesc(flags StorageXMLFlags= ) (string, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolIsActive func (p *StoragePool) IsActive() (bool, error) { - result :=3D C.virStoragePoolIsActive(p.ptr) + var err C.virError + result :=3D C.virStoragePoolIsActiveWrapper(p.ptr, &err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } if result =3D=3D 1 { return true, nil @@ -243,9 +256,10 @@ func (p *StoragePool) IsActive() (bool, error) { =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolIsPersistent func (p *StoragePool) IsPersistent() (bool, error) { - result :=3D C.virStoragePoolIsPersistent(p.ptr) + var err C.virError + result :=3D C.virStoragePoolIsPersistentWrapper(p.ptr, &err) if result =3D=3D -1 { - return false, GetLastError() + return false, makeError(&err) } if result =3D=3D 1 { return true, nil @@ -262,27 +276,30 @@ func (p *StoragePool) SetAutostart(autostart bool) er= ror { default: cAutostart =3D 0 } - result :=3D C.virStoragePoolSetAutostart(p.ptr, cAutostart) + var err C.virError + result :=3D C.virStoragePoolSetAutostartWrapper(p.ptr, cAutostart, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolRefresh func (p *StoragePool) Refresh(flags uint32) error { - result :=3D C.virStoragePoolRefresh(p.ptr, C.uint(flags)) + var err C.virError + result :=3D C.virStoragePoolRefreshWrapper(p.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-storage.html#virStora= gePoolUndefine func (p *StoragePool) Undefine() error { - result :=3D C.virStoragePoolUndefine(p.ptr) + var err C.virError + result :=3D C.virStoragePoolUndefineWrapper(p.ptr, &err) if result =3D=3D -1 { - return GetLastError() + return makeError(&err) } return nil } @@ -291,9 +308,10 @@ func (p *StoragePool) Undefine() error { func (p *StoragePool) StorageVolCreateXML(xmlConfig string, flags StorageV= olCreateFlags) (*StorageVol, error) { cXml :=3D C.CString(string(xmlConfig)) defer C.free(unsafe.Pointer(cXml)) - ptr :=3D C.virStorageVolCreateXML(p.ptr, cXml, C.uint(flags)) + var err C.virError + ptr :=3D C.virStorageVolCreateXMLWrapper(p.ptr, cXml, C.uint(flags), &err) if ptr =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } return &StorageVol{ptr: ptr}, nil } @@ -302,9 +320,10 @@ func (p *StoragePool) StorageVolCreateXML(xmlConfig st= ring, flags StorageVolCrea func (p *StoragePool) StorageVolCreateXMLFrom(xmlConfig string, clonevol *= StorageVol, flags StorageVolCreateFlags) (*StorageVol, error) { cXml :=3D C.CString(string(xmlConfig)) defer C.free(unsafe.Pointer(cXml)) - ptr :=3D C.virStorageVolCreateXMLFrom(p.ptr, cXml, clonevol.ptr, C.uint(f= lags)) + var err C.virError + ptr :=3D C.virStorageVolCreateXMLFromWrapper(p.ptr, cXml, clonevol.ptr, C= .uint(flags), &err) if ptr =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } return &StorageVol{ptr: ptr}, nil } @@ -313,18 +332,20 @@ func (p *StoragePool) StorageVolCreateXMLFrom(xmlConf= ig string, clonevol *Storag func (p *StoragePool) LookupStorageVolByName(name string) (*StorageVol, er= ror) { cName :=3D C.CString(name) defer C.free(unsafe.Pointer(cName)) - ptr :=3D C.virStorageVolLookupByName(p.ptr, cName) + var err C.virError + ptr :=3D C.virStorageVolLookupByNameWrapper(p.ptr, cName, &err) if ptr =3D=3D nil { - return nil, GetLastError() + return nil, makeError(&err) } return &StorageVol{ptr: ptr}, nil } =20 // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolNumOfVolumes func (p *StoragePool) NumOfStorageVolumes() (int, error) { - result :=3D int(C.virStoragePoolNumOfVolumes(p.ptr)) + var err C.virError + result :=3D int(C.virStoragePoolNumOfVolumesWrapper(p.ptr, &err)) if result =3D=3D -1 { - return 0, GetLastError() + return 0, makeError(&err) } return result, nil } @@ -334,12 +355,13 @@ func (p *StoragePool) ListStorageVolumes() ([]string,= error) { const maxVols =3D 1024 var names [maxVols](*C.char) namesPtr :=3D unsafe.Pointer(&names) - numStorageVols :=3D C.virStoragePoolListVolumes( + var err C.virError + numStorageVols :=3D C.virStoragePoolListVolumesWrapper( p.ptr, (**C.char)(namesPtr), - maxVols) + maxVols, &err) if numStorageVols =3D=3D -1 { - return nil, GetLastError() + return nil, makeError(&err) } goNames :=3D make([]string, numStorageVols) for k :=3D 0; k < int(numStorageVols); k++ { @@ -352,9 +374,10 @@ func (p *StoragePool) ListStorageVolumes() ([]string, = error) { // See also https://libvirt.org/html/libvirt-libvirt-storage.html#virStora= gePoolListAllVolumes func (p *StoragePool) ListAllStorageVolumes(flags uint32) ([]StorageVol, e= rror) { var cList *C.virStorageVolPtr - numVols :=3D C.virStoragePoolListAllVolumes(p.ptr, (**C.virStorageVolPtr)= (&cList), C.uint(flags)) + var err C.virError + numVols :=3D C.virStoragePoolListAllVolumesWrapper(p.ptr, (**C.virStorage= VolPtr)(&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)), diff --git a/storage_pool_wrapper.go b/storage_pool_wrapper.go index cd3c1bc..8534f7c 100644 --- a/storage_pool_wrapper.go +++ b/storage_pool_wrapper.go @@ -30,5 +30,314 @@ package libvirt #include #include "storage_pool_wrapper.h" =20 +int +virStoragePoolBuildWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virStoragePoolBuild(pool, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolCreateWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virStoragePoolCreate(pool, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolDeleteWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virStoragePoolDelete(pool, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolDestroyWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + int ret =3D virStoragePoolDestroy(pool); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolFreeWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + int ret =3D virStoragePoolFree(pool); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolGetAutostartWrapper(virStoragePoolPtr pool, + int *autostart, + virErrorPtr err) +{ + int ret =3D virStoragePoolGetAutostart(pool, autostart); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +virConnectPtr +virStoragePoolGetConnectWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + virConnectPtr ret =3D virStoragePoolGetConnect(pool); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolGetInfoWrapper(virStoragePoolPtr pool, + virStoragePoolInfoPtr info, + virErrorPtr err) +{ + int ret =3D virStoragePoolGetInfo(pool, info); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +const char * +virStoragePoolGetNameWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + const char * ret =3D virStoragePoolGetName(pool); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolGetUUIDWrapper(virStoragePoolPtr pool, + unsigned char *uuid, + virErrorPtr err) +{ + int ret =3D virStoragePoolGetUUID(pool, uuid); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolGetUUIDStringWrapper(virStoragePoolPtr pool, + char *buf, + virErrorPtr err) +{ + int ret =3D virStoragePoolGetUUIDString(pool, buf); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +char * +virStoragePoolGetXMLDescWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err) +{ + char * ret =3D virStoragePoolGetXMLDesc(pool, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolIsActiveWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + int ret =3D virStoragePoolIsActive(pool); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolIsPersistentWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + int ret =3D virStoragePoolIsPersistent(pool); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolListAllVolumesWrapper(virStoragePoolPtr pool, + virStorageVolPtr **vols, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virStoragePoolListAllVolumes(pool, vols, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolListVolumesWrapper(virStoragePoolPtr pool, + char ** const names, + int maxnames, + virErrorPtr err) +{ + int ret =3D virStoragePoolListVolumes(pool, names, maxnames); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolNumOfVolumesWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + int ret =3D virStoragePoolNumOfVolumes(pool); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolRefWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + int ret =3D virStoragePoolRef(pool); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolRefreshWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err) +{ + int ret =3D virStoragePoolRefresh(pool, flags); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolSetAutostartWrapper(virStoragePoolPtr pool, + int autostart, + virErrorPtr err) +{ + int ret =3D virStoragePoolSetAutostart(pool, autostart); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +int +virStoragePoolUndefineWrapper(virStoragePoolPtr pool, + virErrorPtr err) +{ + int ret =3D virStoragePoolUndefine(pool); + if (ret < 0) { + virCopyLastError(err); + } + return ret; +} + + +virStorageVolPtr +virStorageVolCreateXMLWrapper(virStoragePoolPtr pool, + const char *xmlDesc, + unsigned int flags, + virErrorPtr err) +{ + virStorageVolPtr ret =3D virStorageVolCreateXML(pool, xmlDesc, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +virStorageVolPtr +virStorageVolCreateXMLFromWrapper(virStoragePoolPtr pool, + const char *xmlDesc, + virStorageVolPtr clonevol, + unsigned int flags, + virErrorPtr err) +{ + virStorageVolPtr ret =3D virStorageVolCreateXMLFrom(pool, xmlDesc, clo= nevol, flags); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + +virStorageVolPtr +virStorageVolLookupByNameWrapper(virStoragePoolPtr pool, + const char *name, + virErrorPtr err) +{ + virStorageVolPtr ret =3D virStorageVolLookupByName(pool, name); + if (!ret) { + virCopyLastError(err); + } + return ret; +} + + + */ import "C" diff --git a/storage_pool_wrapper.h b/storage_pool_wrapper.h index 3e2f60f..acd121b 100644 --- a/storage_pool_wrapper.h +++ b/storage_pool_wrapper.h @@ -30,4 +30,121 @@ #include #include "storage_pool_compat.h" =20 +int +virStoragePoolBuildWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err); + +int +virStoragePoolCreateWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err); + +int +virStoragePoolDeleteWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err); + +int +virStoragePoolDestroyWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolFreeWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolGetAutostartWrapper(virStoragePoolPtr pool, + int *autostart, + virErrorPtr err); + +virConnectPtr +virStoragePoolGetConnectWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolGetInfoWrapper(virStoragePoolPtr pool, + virStoragePoolInfoPtr info, + virErrorPtr err); + +const char * +virStoragePoolGetNameWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolGetUUIDWrapper(virStoragePoolPtr pool, + unsigned char *uuid, + virErrorPtr err); + +int +virStoragePoolGetUUIDStringWrapper(virStoragePoolPtr pool, + char *buf, + virErrorPtr err); + +char * +virStoragePoolGetXMLDescWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err); + +int +virStoragePoolIsActiveWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolIsPersistentWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolListAllVolumesWrapper(virStoragePoolPtr pool, + virStorageVolPtr **vols, + unsigned int flags, + virErrorPtr err); + +int +virStoragePoolListVolumesWrapper(virStoragePoolPtr pool, + char **const names, + int maxnames, + virErrorPtr err); + +int +virStoragePoolNumOfVolumesWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolRefWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +int +virStoragePoolRefreshWrapper(virStoragePoolPtr pool, + unsigned int flags, + virErrorPtr err); + +int +virStoragePoolSetAutostartWrapper(virStoragePoolPtr pool, + int autostart, + virErrorPtr err); + +int +virStoragePoolUndefineWrapper(virStoragePoolPtr pool, + virErrorPtr err); + +virStorageVolPtr +virStorageVolCreateXMLWrapper(virStoragePoolPtr pool, + const char *xmlDesc, + unsigned int flags, + virErrorPtr err); + +virStorageVolPtr +virStorageVolCreateXMLFromWrapper(virStoragePoolPtr pool, + const char *xmlDesc, + virStorageVolPtr clonevol, + unsigned int flags, + virErrorPtr err); + +virStorageVolPtr +virStorageVolLookupByNameWrapper(virStoragePoolPtr pool, + const char *name, + virErrorPtr err); + + #endif /* LIBVIRT_GO_STORAGE_POOL_WRAPPER_H__ */ --=20 2.17.1 -- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list