rebase: use go-ceph v0.3.0

v0.3.0 adds support for rbd.FeatureSet that can be used to parse the
features of an RBD image. This will be used in the followup commit that
adds rbdVolume.getImageInfo().

Signed-off-by: Niels de Vos <ndevos@redhat.com>

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

@@ -0,0 +1,135 @@
+package rbd
+
+/*
+#cgo LDFLAGS: -lrbd
+#undef _GNU_SOURCE
+#include <errno.h>
+#include <stdlib.h>
+#include <rbd/librbd.h>
+
+extern int callDiffIterateCallback(uint64_t ofs, size_t len, int exists, int index);
+
+// cgo is having trouble converting the callback from the librbd header
+// to a unsafe.Pointer. This shim exists solely to help it along.
+static inline int wrap_rbd_diff_iterate2(
+			rbd_image_t image,
+			const char *fromsnapname,
+			uint64_t ofs, uint64_t len,
+			uint8_t include_parent, uint8_t whole_object,
+			void *cb,
+			uintptr_t arg) {
+	return rbd_diff_iterate2(image, fromsnapname, ofs, len, include_parent, whole_object, cb, (void*)arg);
+}
+*/
+import "C"
+
+import (
+	"unsafe"
+
+	"github.com/ceph/go-ceph/internal/callbacks"
+)
+
+var diffIterateCallbacks = callbacks.New()
+
+// DiffIncludeParent values control if the difference should include the parent
+// image.
+type DiffIncludeParent uint8
+
+// DiffWholeObject values control if the diff extents should cover the whole
+// object.
+type DiffWholeObject uint8
+
+// DiffIterateCallback defines the function signature needed for the
+// DiffIterate callback.
+//
+// The function will be called with the arguments: offset, length, exists, and
+// data. The offset and length correspond to the changed region of the image.
+// The exists value is set to zero if the region is known to be zeros,
+// otherwise it is set to 1. The data value is the extra data parameter that
+// was set on the DiffIterateConfig and is meant to be used for passing
+// arbitrary user-defined items to the callback function.
+//
+// The callback can trigger the iteration to terminate early by returning
+// a non-zero error code.
+type DiffIterateCallback func(uint64, uint64, int, interface{}) int
+
+// DiffIterateConfig is used to define the parameters of a DiffIterate call.
+// Callback, Offset, and Length should always be specified when passed to
+// DiffIterate. The other values are optional.
+type DiffIterateConfig struct {
+	SnapName      string
+	Offset        uint64
+	Length        uint64
+	IncludeParent DiffIncludeParent
+	WholeObject   DiffWholeObject
+	Callback      DiffIterateCallback
+	Data          interface{}
+}
+
+const (
+	// ExcludeParent will exclude the parent from the diff.
+	ExcludeParent = DiffIncludeParent(0)
+	// IncludeParent will include the parent in the diff.
+	IncludeParent = DiffIncludeParent(1)
+
+	// DisableWholeObject will not use the whole object in the diff.
+	DisableWholeObject = DiffWholeObject(0)
+	// EnableWholeObject will use the whole object in the diff.
+	EnableWholeObject = DiffWholeObject(1)
+)
+
+// DiffIterate calls a callback on changed extents of an image.
+//
+// Calling DiffIterate will cause the callback specified in the
+// DiffIterateConfig to be called as many times as there are changed
+// regions in the image (controlled by the parameters as passed to librbd).
+//
+// See the documentation of DiffIterateCallback for a description of the
+// arguments to the callback and the return behavior.
+//
+// Implements:
+//  int rbd_diff_iterate2(rbd_image_t image,
+//                        const char *fromsnapname,
+//                        uint64_t ofs, uint64_t len,
+//                        uint8_t include_parent, uint8_t whole_object,
+//                        int (*cb)(uint64_t, size_t, int, void *),
+//                        void *arg);
+func (image *Image) DiffIterate(config DiffIterateConfig) error {
+	if err := image.validate(imageIsOpen); err != nil {
+		return err
+	}
+	if config.Callback == nil {
+		return RBDError(C.EINVAL)
+	}
+
+	var cSnapName *C.char
+	if config.SnapName != NoSnapshot {
+		cSnapName = C.CString(config.SnapName)
+		defer C.free(unsafe.Pointer(cSnapName))
+	}
+
+	cbIndex := diffIterateCallbacks.Add(config)
+	defer diffIterateCallbacks.Remove(cbIndex)
+
+	ret := C.wrap_rbd_diff_iterate2(
+		image.image,
+		cSnapName,
+		C.uint64_t(config.Offset),
+		C.uint64_t(config.Length),
+		C.uint8_t(config.IncludeParent),
+		C.uint8_t(config.WholeObject),
+		C.callDiffIterateCallback,
+		C.uintptr_t(cbIndex))
+
+	return getError(ret)
+}
+
+//export diffIterateCallback
+func diffIterateCallback(
+	offset C.uint64_t, length C.size_t, exists, index C.int) C.int {
+
+	v := diffIterateCallbacks.Lookup(int(index))
+	config := v.(DiffIterateConfig)
+	return C.int(config.Callback(
+		uint64(offset), uint64(length), int(exists), config.Data))
+}