//! Low level bindings for Ceph's RBD interface.
//! Please see [Ceph librbd](http://docs.ceph.com/docs/master/rbd/librbdpy/#module-rbd) for more
//! information. Those are the python docs but the parameters should be the same.
#![allow(non_camel_case_types)]
extern crate libc;
extern crate librados_sys;
use self::libc::{int64_t, size_t, ssize_t, uint8_t, uint64_t};
use self::librados_sys::rados_ioctx_t;
pub type rbd_snap_t = *mut ::std::os::raw::c_void;
pub type rbd_image_t = *mut ::std::os::raw::c_void;
pub type librbd_progress_fn_t =
::std::option::Option<unsafe extern "C" fn(offset: uint64_t,
total: uint64_t,
ptr:
*mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int>;
#[repr(C)]
#[derive(Copy)]
pub struct rbd_snap_info_t{
/// Numeric identifier of the snapshot
pub id: uint64_t,
/// Size of the image at the time of snapshot (in bytes)
pub size: uint64_t,
/// Name of the snapshot
pub name: *const ::std::os::raw::c_char,
}
impl ::std::clone::Clone for rbd_snap_info_t {
fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for rbd_snap_info_t {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct rbd_image_info_t {
/// The size of the image in bytes
pub size: uint64_t,
/// The size of each object that comprises the image
pub obj_size: uint64_t,
/// The number of objects in the image
pub num_objs: uint64_t,
/// log_2(object_size)
pub order: ::std::os::raw::c_int,
/// The prefix of the RADOS objects used to store the image
pub block_name_prefix: [::std::os::raw::c_char; 24usize],
/// deprecated
pub parent_pool: int64_t,
/// deprecated
pub parent_name: [::std::os::raw::c_char; 96usize],
}
impl ::std::clone::Clone for rbd_image_info_t {
fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for rbd_image_info_t {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type rbd_completion_t = *mut ::std::os::raw::c_void;
pub type rbd_callback_t =
::std::option::Option<unsafe extern "C" fn(cb: rbd_completion_t,
arg:
*mut ::std::os::raw::c_void)>;
#[link(name = "rbd")]
extern "C" {
/// Get the version number of the librbd C library.
pub fn rbd_version(major: *mut ::std::os::raw::c_int,
minor: *mut ::std::os::raw::c_int,
extra: *mut ::std::os::raw::c_int);
/// List image names.
pub fn rbd_list(io: rados_ioctx_t, names: *mut ::std::os::raw::c_char,
size: *mut size_t) -> ::std::os::raw::c_int;
pub fn rbd_create(io: rados_ioctx_t, name: *const ::std::os::raw::c_char,
size: uint64_t, order: *mut ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
pub fn rbd_create2(io: rados_ioctx_t, name: *const ::std::os::raw::c_char,
size: uint64_t, features: uint64_t,
order: *mut ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
/// create new rbd image
///
/// The stripe_unit must be a factor of the object size (1 << order).
/// The stripe_count can be one (no intra-object striping) or greater
/// than one. The RBD_FEATURE_STRIPINGV2 must be specified if the
/// stripe_unit != the object size and the stripe_count is != 1.
///
/// # Arguments
/// * `io` ioctx
/// * `name` image name
/// * `size` image size in bytes
/// * `features` initial feature bits
/// * `order` object/block size, as a power of two (object size == 1 << order)
/// * `stripe_unit` stripe unit size, in bytes.
/// * `stripe_count` number of objects to stripe over before looping
/// @return 0 on success, or negative error code
pub fn rbd_create3(io: rados_ioctx_t, name: *const ::std::os::raw::c_char,
size: uint64_t, features: uint64_t,
order: *mut ::std::os::raw::c_int,
stripe_unit: uint64_t, stripe_count: uint64_t)
-> ::std::os::raw::c_int;
/// Clone a parent rbd snapshot into a COW sparse child.
pub fn rbd_clone(p_ioctx: rados_ioctx_t,
p_name: *const ::std::os::raw::c_char,
p_snapname: *const ::std::os::raw::c_char,
c_ioctx: rados_ioctx_t,
c_name: *const ::std::os::raw::c_char,
features: uint64_t, c_order: *mut ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
/// Clone a parent rbd snapshot into a COW sparse child.
pub fn rbd_clone2(p_ioctx: rados_ioctx_t,
p_name: *const ::std::os::raw::c_char,
p_snapname: *const ::std::os::raw::c_char,
c_ioctx: rados_ioctx_t,
c_name: *const ::std::os::raw::c_char,
features: uint64_t, c_order: *mut ::std::os::raw::c_int,
stripe_unit: uint64_t,
stripe_count: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
/// Delete an RBD image. This may take a long time, since it does not return until every
/// object that comprises the image has been deleted. Note that all snapshots must be deleted
/// before the image can be removed.
pub fn rbd_remove(io: rados_ioctx_t, name: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_remove_with_progress(io: rados_ioctx_t,
name: *const ::std::os::raw::c_char,
cb: librbd_progress_fn_t,
cbdata: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
/// Rename an RBD image.
pub fn rbd_rename(src_io_ctx: rados_ioctx_t,
srcname: *const ::std::os::raw::c_char,
destname: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_open(io: rados_ioctx_t, name: *const ::std::os::raw::c_char,
image: *mut rbd_image_t,
snap_name: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
/// Open an image in read-only mode.
///
/// This is intended for use by clients that cannot write to a block
/// device due to cephx restrictions. There will be no watch
/// established on the header object, since a watch is a write. This
/// means the metadata reported about this image (parents, snapshots,
/// size, etc.) may become stale. This should not be used for
/// long-running operations, unless you can be sure that one of these
/// properties changing is safe.
///
/// Attempting to write to a read-only image will return -EROFS.
///
/// # Arguments
/// * `io` ioctx to determine the pool the image is in
/// * `name` image name
/// * `image` where to store newly opened image handle
/// * `snap_name` name of snapshot to open at, or NULL for no snapshot
/// @returns 0 on success, negative error code on failure
pub fn rbd_open_read_only(io: rados_ioctx_t,
name: *const ::std::os::raw::c_char,
image: *mut rbd_image_t,
snap_name: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_close(image: rbd_image_t) -> ::std::os::raw::c_int;
/// Change the size of the image.
pub fn rbd_resize(image: rbd_image_t, size: uint64_t)
-> ::std::os::raw::c_int;
pub fn rbd_resize_with_progress(image: rbd_image_t, size: uint64_t,
cb: librbd_progress_fn_t,
cbdata: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
/// Get information about the image. Currently parent pool and parent name are always -1 and ‘’.
pub fn rbd_stat(image: rbd_image_t, info: *mut rbd_image_info_t,
infosize: size_t) -> ::std::os::raw::c_int;
pub fn rbd_get_old_format(image: rbd_image_t, old: *mut uint8_t)
-> ::std::os::raw::c_int;
pub fn rbd_get_size(image: rbd_image_t, size: *mut uint64_t)
-> ::std::os::raw::c_int;
pub fn rbd_get_features(image: rbd_image_t, features: *mut uint64_t)
-> ::std::os::raw::c_int;
pub fn rbd_get_stripe_unit(image: rbd_image_t, stripe_unit: *mut uint64_t)
-> ::std::os::raw::c_int;
pub fn rbd_get_stripe_count(image: rbd_image_t,
stripe_count: *mut uint64_t)
-> ::std::os::raw::c_int;
pub fn rbd_get_overlap(image: rbd_image_t, overlap: *mut uint64_t)
-> ::std::os::raw::c_int;
pub fn rbd_get_parent_info(image: rbd_image_t,
parent_poolname: *mut ::std::os::raw::c_char,
ppoolnamelen: size_t,
parent_name: *mut ::std::os::raw::c_char,
pnamelen: size_t,
parent_snapname: *mut ::std::os::raw::c_char,
psnapnamelen: size_t) -> ::std::os::raw::c_int;
pub fn rbd_copy(image: rbd_image_t, dest_io_ctx: rados_ioctx_t,
destname: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_copy2(src: rbd_image_t, dest: rbd_image_t)
-> ::std::os::raw::c_int;
pub fn rbd_copy_with_progress(image: rbd_image_t, dest_p: rados_ioctx_t,
destname: *const ::std::os::raw::c_char,
cb: librbd_progress_fn_t,
cbdata: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
pub fn rbd_copy_with_progress2(src: rbd_image_t, dest: rbd_image_t,
cb: librbd_progress_fn_t,
cbdata: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
pub fn rbd_snap_list(image: rbd_image_t, snaps: *mut rbd_snap_info_t,
max_snaps: *mut ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
pub fn rbd_snap_list_end(snaps: *mut rbd_snap_info_t);
pub fn rbd_snap_create(image: rbd_image_t,
snapname: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_snap_remove(image: rbd_image_t,
snapname: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_snap_rollback(image: rbd_image_t,
snapname: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_snap_rollback_with_progress(image: rbd_image_t,
snapname:
*const ::std::os::raw::c_char,
cb: librbd_progress_fn_t,
cbdata:
*mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
/// Prevent a snapshot from being deleted until it is unprotected.
pub fn rbd_snap_protect(image: rbd_image_t,
snap_name: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
/// Allow a snaphshot to be deleted
pub fn rbd_snap_unprotect(image: rbd_image_t,
snap_name: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
/// Determine whether a snapshot is protected.
pub fn rbd_snap_is_protected(image: rbd_image_t,
snap_name: *const ::std::os::raw::c_char,
is_protected: *mut ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
pub fn rbd_snap_set(image: rbd_image_t,
snapname: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_flatten(image: rbd_image_t) -> ::std::os::raw::c_int;
/// List all images that are cloned from the image at the
/// snapshot that is set via rbd_snap_set().
///
/// This iterates over all pools, so it should be run by a user with
/// read access to all of them. pools_len and images_len are filled in
/// with the number of bytes put into the pools and images buffers.
/// If the provided buffers are too short, the required lengths are
/// still filled in, but the data is not and -ERANGE is returned.
/// Otherwise, the buffers are filled with the pool and image names
/// of the children, with a '\0' after each.
/// # Arguments
/// * `image` which image (and implicitly snapshot) to list clones of
/// * `pools` buffer in which to store pool names
/// * `pools_len` number of bytes in pools buffer
/// * `images` buffer in which to store image names
/// * `images_len` number of bytes in images buffer
/// @returns number of children on success, negative error code on failure
/// @returns -ERANGE if either buffer is too short
pub fn rbd_list_children(image: rbd_image_t,
pools: *mut ::std::os::raw::c_char,
pools_len: *mut size_t,
images: *mut ::std::os::raw::c_char,
images_len: *mut size_t) -> ssize_t;
/// List clients that have locked the image and information about the lock.
///
/// The number of bytes required in each buffer is put in the
/// corresponding size out parameter. If any of the provided buffers
/// are too short, -ERANGE is returned after these sizes are filled in.
/// # Arguments
/// * `image` which image (and implicitly snapshot) to list lockers of
/// * `exclusive` where to store whether the lock is exclusive (1) or shared (0)
/// * `tag` where to store the tag associated with the image
/// * `tag_len` number of bytes in tag buffer
/// * `clients` buffer in which locker clients are stored, separated by '\0'
/// * `clients_len` number of bytes in the clients buffer
/// * `cookies` buffer in which locker cookies are stored, separated by '\0'
/// * `cookies_len` number of bytes in the cookies buffer
/// * `addrs` buffer in which locker addresses are stored, separated by '\0'
/// * `addrs_len` number of bytes in the clients buffer
/// @returns number of lockers on success, negative error code on failure
/// @returns -ERANGE if any of the buffers are too short
pub fn rbd_list_lockers(image: rbd_image_t,
exclusive: *mut ::std::os::raw::c_int,
tag: *mut ::std::os::raw::c_char,
tag_len: *mut size_t,
clients: *mut ::std::os::raw::c_char,
clients_len: *mut size_t,
cookies: *mut ::std::os::raw::c_char,
cookies_len: *mut size_t,
addrs: *mut ::std::os::raw::c_char,
addrs_len: *mut size_t) -> ssize_t;
/// Take an exclusive lock on the image.
/// # Arguments
/// * `image` the image to lock
/// * `cookie` user-defined identifier for this instance of the lock
/// @returns 0 on success, negative error code on failure
/// @returns -EBUSY if the lock is already held by another (client, cookie) pair
/// @returns -EEXIST if the lock is already held by the same (client, cookie) pair
pub fn rbd_lock_exclusive(image: rbd_image_t,
cookie: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
/// Take a shared lock on the image.
///
/// Other clients may also take a shared lock, as lock as they use the
/// same tag.
///
/// # Arguments
/// * `image` the image to lock
/// * `cookie` user-defined identifier for this instance of the lock
/// * `tag` user-defined identifier for this shared use of the lock
/// @returns 0 on success, negative error code on failure
/// @returns -EBUSY if the lock is already held by another (client, cookie) pair
/// @returns -EEXIST if the lock is already held by the same (client, cookie) pair
pub fn rbd_lock_shared(image: rbd_image_t,
cookie: *const ::std::os::raw::c_char,
tag: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
/// Release a shared or exclusive lock on the image.
///
/// # Arguments
/// * `image` the image to unlock
/// * `cookie` user-defined identifier for the instance of the lock
/// @returns 0 on success, negative error code on failure
/// @returns -ENOENT if the lock is not held by the specified (client, cookie) pair
pub fn rbd_unlock(image: rbd_image_t,
cookie: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
/// Release a shared or exclusive lock that was taken by the specified client.
///
/// # Arguments
/// * `image` the image to unlock
/// * `client` the entity holding the lock (as given by rbd_list_lockers())
/// * `cookie` user-defined identifier for the instance of the lock to break
///
/// @returns 0 on success, negative error code on failure
/// @returns -ENOENT if the lock is not held by the specified (client, cookie) pair
pub fn rbd_break_lock(image: rbd_image_t,
client: *const ::std::os::raw::c_char,
cookie: *const ::std::os::raw::c_char)
-> ::std::os::raw::c_int;
pub fn rbd_read(image: rbd_image_t, ofs: uint64_t, len: size_t,
buf: *mut ::std::os::raw::c_char) -> ssize_t;
/// iterate read over an image
/// Reads each region of the image and calls the callback. If the
/// buffer pointer passed to the callback is NULL, the given extent is
/// defined to be zeros (a hole). Normally the granularity for the
/// callback is the image stripe size.
/// # Arguments
/// * `image` image to read
/// * `ofs` offset to start from
/// * `len` bytes of source image to cover
/// * `cb` callback for each region
/// @returns 0 success, error otherwise
pub fn rbd_read_iterate2(image: rbd_image_t, ofs: uint64_t, len: uint64_t,
cb:
::std::option::Option<unsafe extern "C" fn(arg1:
uint64_t,
arg2:
size_t,
arg3:
*const ::std::os::raw::c_char,
arg4:
*mut ::std::os::raw::c_void)
->
::std::os::raw::c_int>,
arg: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
/// get difference between two versions of an image
///
/// This will return the differences between two versions of an image
/// via a callback, which gets the offset and length and a flag
/// indicating whether the extent exists (1), or is known/defined to
/// be zeros (a hole, 0). If the source snapshot name is NULL, we
/// interpret that as the beginning of time and return all allocated
/// regions of the image. The end version is whatever is currently
/// selected for the image handle (either a snapshot or the writeable
/// head).
/// # Arguments
/// * `fromsnapname` start snapshot name, or NULL
/// * `ofs` start offset
/// * `len` len in bytes of region to report on
/// * `cb` callback to call for each allocated region
/// * `arg` argument to pass to the callback
/// @returns 0 on success, or negative error code on error
pub fn rbd_diff_iterate(image: rbd_image_t,
fromsnapname: *const ::std::os::raw::c_char,
ofs: uint64_t, len: uint64_t,
cb:
::std::option::Option<unsafe extern "C" fn(arg1:
uint64_t,
arg2:
size_t,
arg3:
::std::os::raw::c_int,
arg4:
*mut ::std::os::raw::c_void)
->
::std::os::raw::c_int>,
arg: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
pub fn rbd_write(image: rbd_image_t, ofs: uint64_t, len: size_t,
buf: *const ::std::os::raw::c_char) -> ssize_t;
/// Trim the range from the image. It will be logically filled with zeroes.
/// # Arguments
/// * `image` the image to trim a range from
/// * `ofs` offset to start from
/// * `len` bytes of image to trim
pub fn rbd_discard(image: rbd_image_t, ofs: uint64_t, len: uint64_t)
-> ::std::os::raw::c_int;
pub fn rbd_aio_write(image: rbd_image_t, off: uint64_t, len: size_t,
buf: *const ::std::os::raw::c_char,
c: rbd_completion_t) -> ::std::os::raw::c_int;
pub fn rbd_aio_read(image: rbd_image_t, off: uint64_t, len: size_t,
buf: *mut ::std::os::raw::c_char, c: rbd_completion_t)
-> ::std::os::raw::c_int;
pub fn rbd_aio_discard(image: rbd_image_t, off: uint64_t, len: uint64_t,
c: rbd_completion_t) -> ::std::os::raw::c_int;
pub fn rbd_aio_create_completion(cb_arg: *mut ::std::os::raw::c_void,
complete_cb: rbd_callback_t,
c: *mut rbd_completion_t)
-> ::std::os::raw::c_int;
pub fn rbd_aio_is_complete(c: rbd_completion_t) -> ::std::os::raw::c_int;
pub fn rbd_aio_wait_for_complete(c: rbd_completion_t)
-> ::std::os::raw::c_int;
pub fn rbd_aio_get_return_value(c: rbd_completion_t) -> ssize_t;
pub fn rbd_aio_release(c: rbd_completion_t);
/// Start a flush if caching is enabled. Get a callback when
/// the currently pending writes are on disk.
/// # Arguments
/// * `image` the image to flush writes to
/// * `c` what to call when flushing is complete
/// @returns 0 on success, negative error code on failure
pub fn rbd_flush(image: rbd_image_t) -> ::std::os::raw::c_int;
pub fn rbd_aio_flush(image: rbd_image_t, c: rbd_completion_t)
-> ::std::os::raw::c_int;
/// Drop any cached data for an image
///
/// # Arguments
/// * `image` the image to invalidate cached data for
/// @returns 0 on success, negative error code on failure
pub fn rbd_invalidate_cache(image: rbd_image_t) -> ::std::os::raw::c_int;
}