rebase: Make use of latest go ceph library

The go-ceph version 0.4.0 is available now which got some important
library changes required for ceph csi project.

Signed-off-by: Humble Chirammal <hchiramm@redhat.com>

vendor/github.com/ceph/go-ceph/rbd/errors.go

@@ -37,26 +37,47 @@ func getError(err C.int) error {
 	return nil
 }
 
+// getErrorIfNegative converts a ceph return code to error if negative.
+// This is useful for functions that return a usable positive value on
+// success but a negative error number on error.
+func getErrorIfNegative(ret C.int) error {
+	if ret >= 0 {
+		return nil
+	}
+	return getError(ret)
+}
+
 // Public go errors:
 
 var (
 	// ErrNoIOContext may be returned if an api call requires an IOContext and
 	// it is not provided.
-	ErrNoIOContext = errors.New("RBD image does not have an IOContext")
+	ErrNoIOContext = errors.New("IOContext is missing")
 	// ErrNoName may be returned if an api call requires a name and it is
 	// not provided.
 	ErrNoName = errors.New("RBD image does not have a name")
-	// ErrSnapshotNoName may be returned if an aip call requires a snapshot
+	// ErrSnapshotNoName may be returned if an api call requires a snapshot
 	// name and it is not provided.
 	ErrSnapshotNoName = errors.New("RBD snapshot does not have a name")
-	// ErrImageNotOpen may be returnened if an api call requires an open image handle and one is not provided.
+	// ErrImageNotOpen may be returned if an api call requires an open image handle and one is not provided.
 	ErrImageNotOpen = errors.New("RBD image not open")
+	// ErrImageIsOpen may be returned if an api call requires a closed image handle and one is not provided.
+	ErrImageIsOpen = errors.New("RBD image is open")
 	// ErrNotFound may be returned from an api call when the requested item is
 	// missing.
 	ErrNotFound = errors.New("RBD image not found")
+	// ErrNoNamespaceName maye be returned if an api call requires a namespace
+	// name and it is not provided.
+	ErrNoNamespaceName = errors.New("Namespace value is missing")
 
 	// revive:disable:exported for compatibility with old versions
 	RbdErrorImageNotOpen = ErrImageNotOpen
 	RbdErrorNotFound     = ErrNotFound
 	// revive:enable:exported
 )
+
+// Private errors:
+
+const (
+	errRange = RBDError(-C.ERANGE)
+)

vendor/github.com/ceph/go-ceph/rbd/features.go

@@ -102,7 +102,7 @@ const (
 	// revive:enable:exported
 )
 
-// FeatureSet is a combination of the bit value for multiple featurs.
+// FeatureSet is a combination of the bit value for multiple features.
 type FeatureSet uint64
 
 var (

vendor/github.com/ceph/go-ceph/rbd/namespace_nautilus.go

@@ -0,0 +1,111 @@
+// +build !luminous,!mimic
+//
+// Ceph Nautilus is the first release that includes rbd_namespace_create(),
+// rbd_namespace_remove(), rbd_namespace_exists() and rbd_namespace_list().
+
+package rbd
+
+// #cgo LDFLAGS: -lrbd
+// #include <rados/librados.h>
+// #include <rbd/librbd.h>
+// #include <stdlib.h>
+// #include <errno.h>
+import "C"
+
+import (
+	"bytes"
+	"unsafe"
+
+	"github.com/ceph/go-ceph/internal/retry"
+	"github.com/ceph/go-ceph/rados"
+)
+
+// NamespaceCreate creates the namespace for a given Rados IOContext.
+//
+// Implements:
+//  int rbd_namespace_create(rados_ioctx_t io, const char *namespace_name);
+func NamespaceCreate(ioctx *rados.IOContext, namespaceName string) error {
+	if ioctx == nil {
+		return ErrNoIOContext
+	}
+	if namespaceName == "" {
+		return ErrNoNamespaceName
+	}
+	cNamespaceName := C.CString(namespaceName)
+	defer C.free(unsafe.Pointer(cNamespaceName))
+
+	ret := C.rbd_namespace_create(cephIoctx(ioctx), cNamespaceName)
+	return getError(ret)
+}
+
+// NamespaceRemove removes a given namespace.
+//
+// Implements:
+//  int rbd_namespace_remove(rados_ioctx_t io, const char *namespace_name);
+func NamespaceRemove(ioctx *rados.IOContext, namespaceName string) error {
+	if ioctx == nil {
+		return ErrNoIOContext
+	}
+	if namespaceName == "" {
+		return ErrNoNamespaceName
+	}
+	cNamespaceName := C.CString(namespaceName)
+	defer C.free(unsafe.Pointer(cNamespaceName))
+
+	ret := C.rbd_namespace_remove(cephIoctx(ioctx), cNamespaceName)
+	return getError(ret)
+}
+
+// NamespaceExists checks whether a given namespace exists or not.
+//
+// Implements:
+//  int rbd_namespace_exists(rados_ioctx_t io, const char *namespace_name, bool *exists);
+func NamespaceExists(ioctx *rados.IOContext, namespaceName string) (bool, error) {
+	if ioctx == nil {
+		return false, ErrNoIOContext
+	}
+	if namespaceName == "" {
+		return false, ErrNoNamespaceName
+	}
+	cNamespaceName := C.CString(namespaceName)
+	defer C.free(unsafe.Pointer(cNamespaceName))
+
+	var exists C.bool
+	ret := C.rbd_namespace_exists(cephIoctx(ioctx), cNamespaceName, &exists)
+	return bool(exists), getErrorIfNegative(ret)
+}
+
+// NamespaceList returns a slice containing the names of existing rbd namespaces.
+//
+// Implements:
+//  int rbd_namespace_list(rados_ioctx_t io, char *namespace_names, size_t *size);
+func NamespaceList(ioctx *rados.IOContext) (names []string, err error) {
+	if ioctx == nil {
+		return nil, ErrNoIOContext
+	}
+	var (
+		buf   []byte
+		cSize C.size_t
+	)
+	retry.WithSizes(4096, 262144, func(size int) retry.Hint {
+		cSize = C.size_t(size)
+		buf = make([]byte, cSize)
+		ret := C.rbd_namespace_list(cephIoctx(ioctx),
+			(*C.char)(unsafe.Pointer(&buf[0])),
+			&cSize)
+		err = getErrorIfNegative(ret)
+		return retry.Size(int(cSize)).If(err == errRange)
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	tmpList := bytes.Split(buf[:cSize-1], []byte{0})
+	for _, s := range tmpList {
+		if len(s) > 0 {
+			name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
+			names = append(names, name)
+		}
+	}
+	return names, nil
+}

vendor/github.com/ceph/go-ceph/rbd/options.go

@@ -69,9 +69,6 @@ const (
 	RbdImageOptionFeaturesClear = ImageOptionFeaturesClear
 	// RbdImageOptionDataPool deprecated alias for ImageOptionDataPool
 	RbdImageOptionDataPool = ImageOptionDataPool
-
-	// introduced with Ceph Mimic
-	//RbdImageOptionFlatten = C.RBD_IMAGE_OPTION_FLATTEN
 )
 
 // ImageOptions represents a group of configurable image options.

vendor/github.com/ceph/go-ceph/rbd/options_mimic.go

@@ -0,0 +1,12 @@
+// +build !luminous
+
+package rbd
+
+// #include <rbd/librbd.h>
+import "C"
+
+const (
+	// ImageOptionFlatten is the representation of RBD_IMAGE_OPTION_FLATTEN
+	// from librbd
+	ImageOptionFlatten = C.RBD_IMAGE_OPTION_FLATTEN
+)

vendor/github.com/ceph/go-ceph/rbd/options_nautilus.go

@@ -0,0 +1,12 @@
+// +build !luminous,!mimic
+
+package rbd
+
+// #include <rbd/librbd.h>
+import "C"
+
+const (
+	// ImageOptionCloneFormat is the representation of
+	// RBD_IMAGE_OPTION_CLONE_FORMAT from librbd
+	ImageOptionCloneFormat = C.RBD_IMAGE_OPTION_CLONE_FORMAT
+)

vendor/github.com/ceph/go-ceph/rbd/options_octopus.go

@@ -0,0 +1,12 @@
+// +build !luminous,!mimic,!nautilus
+
+package rbd
+
+// #include <rbd/librbd.h>
+import "C"
+
+const (
+	// ImageOptionMirrorImageMode is the representation of
+	// RBD_IMAGE_OPTION_MIRROR_IMAGE_MODE from librbd
+	ImageOptionMirrorImageMode = C.RBD_IMAGE_OPTION_MIRROR_IMAGE_MODE
+)

vendor/github.com/ceph/go-ceph/rbd/pool_nautilus.go

@@ -0,0 +1,86 @@
+// +build !luminous,!mimic
+//
+// Ceph Nautilus is the first release that includes rbd_pool_metadata_get(),
+// rbd_pool_metadata_set() and rbd_pool_metadata_remove().
+
+package rbd
+
+// #cgo LDFLAGS: -lrbd
+// #include <rados/librados.h>
+// #include <rbd/librbd.h>
+// #include <stdlib.h>
+import "C"
+
+import (
+	"unsafe"
+
+	"github.com/ceph/go-ceph/internal/retry"
+	"github.com/ceph/go-ceph/rados"
+)
+
+// GetPoolMetadata returns pool metadata associated with the given key.
+//
+// Implements:
+//  int rbd_pool_metadata_get(rados_ioctx_t io_ctx, const char *key, char *value, size_t *val_len);
+func GetPoolMetadata(ioctx *rados.IOContext, key string) (string, error) {
+	if ioctx == nil {
+		return "", ErrNoIOContext
+	}
+
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+
+	var (
+		buf []byte
+		err error
+	)
+	retry.WithSizes(4096, 262144, func(size int) retry.Hint {
+		cSize := C.size_t(size)
+		buf = make([]byte, cSize)
+		ret := C.rbd_pool_metadata_get(cephIoctx(ioctx),
+			cKey,
+			(*C.char)(unsafe.Pointer(&buf[0])),
+			&cSize)
+		err = getError(ret)
+		return retry.Size(int(cSize)).If(err == errRange)
+	})
+
+	if err != nil {
+		return "", err
+	}
+	return C.GoString((*C.char)(unsafe.Pointer(&buf[0]))), nil
+}
+
+// SetPoolMetadata updates the pool metadata string associated with the given key.
+//
+// Implements:
+//  int rbd_pool_metadata_set(rados_ioctx_t io_ctx, const char *key, const char *value);
+func SetPoolMetadata(ioctx *rados.IOContext, key, value string) error {
+	if ioctx == nil {
+		return ErrNoIOContext
+	}
+
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+	cValue := C.CString(value)
+	defer C.free(unsafe.Pointer(cValue))
+
+	ret := C.rbd_pool_metadata_set(cephIoctx(ioctx), cKey, cValue)
+	return getError(ret)
+}
+
+// RemovePoolMetadata removes the pool metadata value for a given pool metadata key.
+//
+// Implements:
+//  int rbd_pool_metadata_remove(rados_ioctx_t io_ctx, const char *key)
+func RemovePoolMetadata(ioctx *rados.IOContext, key string) error {
+	if ioctx == nil {
+		return ErrNoIOContext
+	}
+
+	cKey := C.CString(key)
+	defer C.free(unsafe.Pointer(cKey))
+
+	ret := C.rbd_pool_metadata_remove(cephIoctx(ioctx), cKey)
+	return getError(ret)
+}

vendor/github.com/ceph/go-ceph/rbd/rbd.go

@@ -17,6 +17,7 @@ import (
 	"time"
 	"unsafe"
 
+	"github.com/ceph/go-ceph/internal/retry"
 	"github.com/ceph/go-ceph/rados"
 )
 
@@ -37,6 +38,7 @@ const (
 	imageNeedsName uint32 = 1 << iota
 	imageNeedsIOContext
 	imageIsOpen
+	imageIsNotOpen
 	snapshotNeedsName
 
 	// NoSnapshot indicates that no snapshot name is in use (see OpenImage)
@@ -120,6 +122,8 @@ func (image *Image) validate(req uint32) error {
 		return ErrNoIOContext
 	} else if hasBit(req, imageIsOpen) && image.image == nil {
 		return ErrImageNotOpen
+	} else if hasBit(req, imageIsNotOpen) && image.image != nil {
+		return ErrImageIsOpen
 	}
 
 	return nil
@@ -277,7 +281,7 @@ func (image *Image) Clone(snapname string, c_ioctx *rados.IOContext, c_name stri
 // Implements:
 //  int rbd_remove(rados_ioctx_t io, const char *name);
 func (image *Image) Remove() error {
-	if err := image.validate(imageNeedsIOContext | imageNeedsName); err != nil {
+	if err := image.validate(imageNeedsIOContext | imageNeedsName | imageIsNotOpen); err != nil {
 		return err
 	}
 	return RemoveImage(image.ioctx, image.name)
@@ -873,22 +877,24 @@ func (image *Image) GetMetadata(key string) (string, error) {
 	c_key := C.CString(key)
 	defer C.free(unsafe.Pointer(c_key))
 
-	var c_vallen C.size_t
-	ret := C.rbd_metadata_get(image.image, c_key, nil, (*C.size_t)(&c_vallen))
-	// get size of value
-	// ret -34 because we pass nil as value pointer
-	if ret != 0 && ret != -C.ERANGE {
-		return "", RBDError(ret)
+	var (
+		buf []byte
+		err error
+	)
+	retry.WithSizes(4096, 262144, func(size int) retry.Hint {
+		csize := C.size_t(size)
+		buf = make([]byte, csize)
+		// rbd_metadata_get is a bit quirky and *does not* update the size
+		// value if the size passed in >= the needed size.
+		ret := C.rbd_metadata_get(
+			image.image, c_key, (*C.char)(unsafe.Pointer(&buf[0])), &csize)
+		err = getError(ret)
+		return retry.Size(int(csize)).If(err == errRange)
+	})
+	if err != nil {
+		return "", err
 	}
-
-	// make a bytes array with a good size
-	value := make([]byte, c_vallen-1)
-	ret = C.rbd_metadata_get(image.image, c_key, (*C.char)(unsafe.Pointer(&value[0])), (*C.size_t)(&c_vallen))
-	if ret < 0 {
-		return "", RBDError(ret)
-	}
-
-	return string(value), nil
+	return C.GoString((*C.char)(unsafe.Pointer(&buf[0]))), nil
 }
 
 // SetMetadata updates the metadata string associated with the given key.
@@ -941,42 +947,50 @@ func (image *Image) GetId() (string, error) {
 	if err := image.validate(imageIsOpen); err != nil {
 		return "", err
 	}
-	size := C.size_t(1024)
-	buf := make([]byte, size)
-	for {
+	var (
+		err error
+		buf []byte
+	)
+	retry.WithSizes(1, 8192, func(size int) retry.Hint {
+		buf = make([]byte, size)
 		ret := C.rbd_get_id(
 			image.image,
 			(*C.char)(unsafe.Pointer(&buf[0])),
-			size)
-		if ret == -C.ERANGE && size <= 8192 {
-			size *= 2
-			buf = make([]byte, size)
-		} else if ret < 0 {
-			return "", getError(ret)
-		}
-		id := C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
-		return id, nil
+			C.size_t(size))
+		err = getErrorIfNegative(ret)
+		return retry.DoubleSize.If(err == errRange)
+	})
+	if err != nil {
+		return "", err
 	}
+	id := C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
+	return id, nil
+
 }
 
 // GetTrashList returns a slice of TrashInfo structs, containing information about all RBD images
 // currently residing in the trash.
 func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
-	var num_entries C.size_t
-
-	// Call rbd_trash_list with nil pointer to get number of trash entries.
-	if C.rbd_trash_list(cephIoctx(ioctx), nil, &num_entries); num_entries == 0 {
-		return nil, nil
+	var (
+		err     error
+		count   C.size_t
+		entries []C.rbd_trash_image_info_t
+	)
+	retry.WithSizes(32, 1024, func(size int) retry.Hint {
+		count = C.size_t(size)
+		entries = make([]C.rbd_trash_image_info_t, count)
+		ret := C.rbd_trash_list(cephIoctx(ioctx), &entries[0], &count)
+		err = getErrorIfNegative(ret)
+		return retry.Size(int(count)).If(err == errRange)
+	})
+	if err != nil {
+		return nil, err
 	}
+	// Free rbd_trash_image_info_t pointers
+	defer C.rbd_trash_list_cleanup(&entries[0], count)
 
-	c_entries := make([]C.rbd_trash_image_info_t, num_entries)
-	trashList := make([]TrashInfo, num_entries)
-
-	if ret := C.rbd_trash_list(cephIoctx(ioctx), &c_entries[0], &num_entries); ret < 0 {
-		return nil, RBDError(ret)
-	}
-
-	for i, ti := range c_entries {
+	trashList := make([]TrashInfo, count)
+	for i, ti := range entries[:count] {
 		trashList[i] = TrashInfo{
 			Id:               C.GoString(ti.id),
 			Name:             C.GoString(ti.name),
@@ -984,10 +998,6 @@ func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
 			DefermentEndTime: time.Unix(int64(ti.deferment_end_time), 0),
 		}
 	}
-
-	// Free rbd_trash_image_info_t pointers
-	C.rbd_trash_list_cleanup(&c_entries[0], num_entries)
-
 	return trashList, nil
 }
 
@@ -1018,6 +1028,13 @@ func TrashRestore(ioctx *rados.IOContext, id, name string) error {
 //  int rbd_open(rados_ioctx_t io, const char *name,
 //               rbd_image_t *image, const char *snap_name);
 func OpenImage(ioctx *rados.IOContext, name, snapName string) (*Image, error) {
+	if ioctx == nil {
+		return nil, ErrNoIOContext
+	}
+	if name == "" {
+		return nil, ErrNoName
+	}
+
 	cName := C.CString(name)
 	defer C.free(unsafe.Pointer(cName))
 
@@ -1054,6 +1071,13 @@ func OpenImage(ioctx *rados.IOContext, name, snapName string) (*Image, error) {
 //  int rbd_open_read_only(rados_ioctx_t io, const char *name,
 //                         rbd_image_t *image, const char *snap_name);
 func OpenImageReadOnly(ioctx *rados.IOContext, name, snapName string) (*Image, error) {
+	if ioctx == nil {
+		return nil, ErrNoIOContext
+	}
+	if name == "" {
+		return nil, ErrNoName
+	}
+
 	cName := C.CString(name)
 	defer C.free(unsafe.Pointer(cName))
 
@@ -1091,6 +1115,13 @@ func OpenImageReadOnly(ioctx *rados.IOContext, name, snapName string) (*Image, e
 //  int rbd_open_by_id(rados_ioctx_t io, const char *id,
 //                     rbd_image_t *image, const char *snap_name);
 func OpenImageById(ioctx *rados.IOContext, id, snapName string) (*Image, error) {
+	if ioctx == nil {
+		return nil, ErrNoIOContext
+	}
+	if id == "" {
+		return nil, ErrNoName
+	}
+
 	cid := C.CString(id)
 	defer C.free(unsafe.Pointer(cid))
 
@@ -1128,6 +1159,13 @@ func OpenImageById(ioctx *rados.IOContext, id, snapName string) (*Image, error)
 //  int rbd_open_by_id_read_only(rados_ioctx_t io, const char *id,
 //                               rbd_image_t *image, const char *snap_name);
 func OpenImageByIdReadOnly(ioctx *rados.IOContext, id, snapName string) (*Image, error) {
+	if ioctx == nil {
+		return nil, ErrNoIOContext
+	}
+	if id == "" {
+		return nil, ErrNoName
+	}
+
 	cid := C.CString(id)
 	defer C.free(unsafe.Pointer(cid))
 
@@ -1160,7 +1198,12 @@ func OpenImageByIdReadOnly(ioctx *rados.IOContext, id, snapName string) (*Image,
 //  int rbd_create4(rados_ioctx_t io, const char *name, uint64_t size,
 //                 rbd_image_options_t opts);
 func CreateImage(ioctx *rados.IOContext, name string, size uint64, rio *ImageOptions) error {
-
+	if ioctx == nil {
+		return ErrNoIOContext
+	}
+	if name == "" {
+		return ErrNoName
+	}
 	if rio == nil {
 		return RBDError(C.EINVAL)
 	}
@@ -1178,6 +1221,13 @@ func CreateImage(ioctx *rados.IOContext, name string, size uint64, rio *ImageOpt
 // Implements:
 //  int rbd_remove(rados_ioctx_t io, const char *name);
 func RemoveImage(ioctx *rados.IOContext, name string) error {
+	if ioctx == nil {
+		return ErrNoIOContext
+	}
+	if name == "" {
+		return ErrNoName
+	}
+
 	c_name := C.CString(name)
 	defer C.free(unsafe.Pointer(c_name))
 	return getError(C.rbd_remove(cephIoctx(ioctx), c_name))

vendor/github.com/ceph/go-ceph/rbd/rbd_mimic.go

@@ -15,29 +15,34 @@ import (
 	"bytes"
 	"unsafe"
 
+	"github.com/ceph/go-ceph/internal/retry"
 	"github.com/ceph/go-ceph/rados"
 )
 
 // GetImageNames returns the list of current RBD images.
 func GetImageNames(ioctx *rados.IOContext) (names []string, err error) {
-	buf := make([]byte, 4096)
-	for {
-		size := C.size_t(len(buf))
+	var (
+		buf   []byte
+		csize C.size_t
+	)
+	// from 4KiB to 32KiB
+	retry.WithSizes(4096, 1<<15, func(size int) retry.Hint {
+		csize = C.size_t(size)
+		buf = make([]byte, csize)
 		ret := C.rbd_list(cephIoctx(ioctx),
-			(*C.char)(unsafe.Pointer(&buf[0])), &size)
-		if ret == -C.ERANGE {
-			buf = make([]byte, size)
-			continue
-		} else if ret < 0 {
-			return nil, RBDError(ret)
-		}
-		tmp := bytes.Split(buf[:size-1], []byte{0})
-		for _, s := range tmp {
-			if len(s) > 0 {
-				name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
-				names = append(names, name)
-			}
-		}
-		return names, nil
+			(*C.char)(unsafe.Pointer(&buf[0])), &csize)
+		err = getErrorIfNegative(ret)
+		return retry.Size(int(csize)).If(err == errRange)
+	})
+	if err != nil {
+		return nil, err
 	}
+	tmp := bytes.Split(buf[:csize-1], []byte{0})
+	for _, s := range tmp {
+		if len(s) > 0 {
+			name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
+			names = append(names, name)
+		}
+	}
+	return names, nil
 }

vendor/github.com/ceph/go-ceph/rbd/rbd_nautilus.go

@@ -11,34 +11,36 @@ package rbd
 import "C"
 
 import (
-	"fmt"
 	"unsafe"
 
+	"github.com/ceph/go-ceph/internal/retry"
 	"github.com/ceph/go-ceph/rados"
 )
 
 // GetImageNames returns the list of current RBD images.
 func GetImageNames(ioctx *rados.IOContext) ([]string, error) {
-	size := C.size_t(0)
-	ret := C.rbd_list2(cephIoctx(ioctx), nil, &size)
-	if ret < 0 && ret != -C.ERANGE {
-		return nil, RBDError(ret)
-	} else if ret > 0 {
-		return nil, fmt.Errorf("rbd_list2() returned %d names, expected 0", ret)
-	} else if ret == 0 && size == 0 {
-		return nil, nil
-	}
-
-	// expected: ret == -ERANGE, size contains number of image names
-	images := make([]C.rbd_image_spec_t, size)
-	ret = C.rbd_list2(cephIoctx(ioctx), (*C.rbd_image_spec_t)(unsafe.Pointer(&images[0])), &size)
-	if ret < 0 {
-		return nil, RBDError(ret)
+	var (
+		err    error
+		images []C.rbd_image_spec_t
+		size   C.size_t
+	)
+	retry.WithSizes(32, 4096, func(s int) retry.Hint {
+		size = C.size_t(s)
+		images = make([]C.rbd_image_spec_t, size)
+		ret := C.rbd_list2(
+			cephIoctx(ioctx),
+			(*C.rbd_image_spec_t)(unsafe.Pointer(&images[0])),
+			&size)
+		err = getErrorIfNegative(ret)
+		return retry.Size(int(size)).If(err == errRange)
+	})
+	if err != nil {
+		return nil, err
 	}
 	defer C.rbd_image_spec_list_cleanup((*C.rbd_image_spec_t)(unsafe.Pointer(&images[0])), size)
 
 	names := make([]string, size)
-	for i, image := range images {
+	for i, image := range images[:size] {
 		names[i] = C.GoString(image.name)
 	}
 	return names, nil

vendor/github.com/ceph/go-ceph/rbd/snapshot_nautilus.go

@@ -11,8 +11,9 @@ package rbd
 import "C"
 
 import (
-	"fmt"
 	"unsafe"
+
+	"github.com/ceph/go-ceph/internal/retry"
 )
 
 // GetParentInfo looks for the parent of the image and stores the pool, name
@@ -76,27 +77,28 @@ func (image *Image) ListChildren() (pools []string, images []string, err error)
 		return nil, nil, err
 	}
 
-	size := C.size_t(0)
-	ret := C.rbd_list_children3(image.image, nil, &size)
-	if ret < 0 && ret != -C.ERANGE {
-		return nil, nil, RBDError(ret)
-	} else if ret > 0 {
-		return nil, nil, fmt.Errorf("rbd_list_children3() returned %d, expected 0", ret)
-	} else if ret == 0 && size == 0 {
-		return nil, nil, nil
+	var (
+		csize    C.size_t
+		children []C.rbd_linked_image_spec_t
+	)
+	retry.WithSizes(16, 4096, func(size int) retry.Hint {
+		csize = C.size_t(size)
+		children = make([]C.rbd_linked_image_spec_t, csize)
+		ret := C.rbd_list_children3(
+			image.image,
+			(*C.rbd_linked_image_spec_t)(unsafe.Pointer(&children[0])),
+			&csize)
+		err = getErrorIfNegative(ret)
+		return retry.Size(int(csize)).If(err == errRange)
+	})
+	if err != nil {
+		return nil, nil, err
 	}
+	defer C.rbd_linked_image_spec_list_cleanup((*C.rbd_linked_image_spec_t)(unsafe.Pointer(&children[0])), csize)
 
-	// expected: ret == -ERANGE, size contains number of image names
-	children := make([]C.rbd_linked_image_spec_t, size)
-	ret = C.rbd_list_children3(image.image, (*C.rbd_linked_image_spec_t)(unsafe.Pointer(&children[0])), &size)
-	if ret < 0 {
-		return nil, nil, RBDError(ret)
-	}
-	defer C.rbd_linked_image_spec_list_cleanup((*C.rbd_linked_image_spec_t)(unsafe.Pointer(&children[0])), size)
-
-	pools = make([]string, size)
-	images = make([]string, size)
-	for i, child := range children {
+	pools = make([]string, csize)
+	images = make([]string, csize)
+	for i, child := range children[:csize] {
 		pools[i] = C.GoString(child.pool_name)
 		images[i] = C.GoString(child.image_name)
 	}

vendor/github.com/ceph/go-ceph/rbd/watchers_mimic.go

@@ -9,6 +9,10 @@ package rbd
 // #include <rbd/librbd.h>
 import "C"
 
+import (
+	"github.com/ceph/go-ceph/internal/retry"
+)
+
 // ImageWatcher is a representation of the rbd_image_watcher_t from librbd.h
 type ImageWatcher struct {
 	Addr   string
@@ -30,28 +34,28 @@ func (image *Image) ListWatchers() ([]ImageWatcher, error) {
 		return nil, err
 	}
 
-	count := C.ulong(0)
-	ret := C.rbd_watchers_list(image.image, nil, &count)
-	if ret != 0 && ret != -C.ERANGE {
-		return nil, getError(ret)
-	}
-	if ret == 0 && count == 0 {
-		return nil, nil
-	}
-
-	watchers := make([]C.rbd_image_watcher_t, count)
-	ret = C.rbd_watchers_list(image.image, &watchers[0], &count)
-	if ret != 0 && ret != -C.ERANGE {
-		return nil, getError(ret)
+	var (
+		err      error
+		count    C.size_t
+		watchers []C.rbd_image_watcher_t
+	)
+	retry.WithSizes(16, 4096, func(size int) retry.Hint {
+		count = C.size_t(size)
+		watchers = make([]C.rbd_image_watcher_t, count)
+		ret := C.rbd_watchers_list(image.image, &watchers[0], &count)
+		err = getErrorIfNegative(ret)
+		return retry.Size(int(count)).If(err == errRange)
+	})
+	if err != nil {
+		return nil, err
 	}
 	defer C.rbd_watchers_list_cleanup(&watchers[0], count)
 
-	imageWatchers := make([]ImageWatcher, len(watchers))
-	for i, watcher := range watchers {
+	imageWatchers := make([]ImageWatcher, count)
+	for i, watcher := range watchers[:count] {
 		imageWatchers[i].Addr = C.GoString(watcher.addr)
 		imageWatchers[i].Id = int64(watcher.id)
 		imageWatchers[i].Cookie = uint64(watcher.cookie)
 	}
-
 	return imageWatchers, nil
 }