From c7c7e5a75cddffb76f85f8313cd351d61a3db5b5 Mon Sep 17 00:00:00 2001 From: Victor Denisov Date: Mon, 26 Sep 2016 20:18:55 -0700 Subject: [PATCH] librbd: Add group snapshot operations Signed-off-by: Victor Denisov --- src/cls/rbd/cls_rbd_types.cc | 2 +- src/cls/rbd/cls_rbd_types.h | 2 +- src/include/rbd/librbd.h | 41 +- src/include/rbd/librbd.hpp | 25 + src/include/rbd_types.h | 2 + src/librbd/ImageCtx.cc | 13 +- src/librbd/ImageCtx.h | 2 + src/librbd/api/Group.cc | 878 ++++++++++++++++++++++++++----- src/librbd/api/Group.h | 13 + src/librbd/librbd.cc | 148 +++++- src/pybind/rbd/rbd.pyx | 383 +++++++++++++- src/test/cli/rbd/help.t | 57 +- src/test/cls_rbd/test_cls_rbd.cc | 30 +- src/test/librbd/test_Groups.cc | 33 ++ src/test/pybind/test_rbd.py | 126 ++++- src/tracing/librbd.tp | 100 ++++ 16 files changed, 1694 insertions(+), 161 deletions(-) diff --git a/src/cls/rbd/cls_rbd_types.cc b/src/cls/rbd/cls_rbd_types.cc index 50af65ebbd490..fcd31863565be 100644 --- a/src/cls/rbd/cls_rbd_types.cc +++ b/src/cls/rbd/cls_rbd_types.cc @@ -517,7 +517,7 @@ void GroupSnapshot::dump(Formatter *f) const { } void GroupSnapshot::generate_test_instances(std::list &o) { - o.push_back(new GroupSnapshot("10152ae8944a", "groupsnapshot1", GROUP_SNAPSHOT_STATE_PENDING)); + o.push_back(new GroupSnapshot("10152ae8944a", "groupsnapshot1", GROUP_SNAPSHOT_STATE_INCOMPLETE)); o.push_back(new GroupSnapshot("1018643c9869", "groupsnapshot2", GROUP_SNAPSHOT_STATE_COMPLETE)); } void TrashImageSpec::encode(bufferlist& bl) const { diff --git a/src/cls/rbd/cls_rbd_types.h b/src/cls/rbd/cls_rbd_types.h index 51c653b81b95d..10ffa592f0d66 100644 --- a/src/cls/rbd/cls_rbd_types.h +++ b/src/cls/rbd/cls_rbd_types.h @@ -339,7 +339,7 @@ WRITE_CLASS_ENCODER(SnapshotNamespaceOnDisk); SnapshotNamespaceType get_namespace_type(const SnapshotNamespace& snapshot_namespace); enum GroupSnapshotState { - GROUP_SNAPSHOT_STATE_PENDING = 0, + GROUP_SNAPSHOT_STATE_INCOMPLETE = 0, GROUP_SNAPSHOT_STATE_COMPLETE = 1, }; diff --git a/src/include/rbd/librbd.h b/src/include/rbd/librbd.h index 1d673f78e1c35..ba8ea29b7d707 100644 --- a/src/include/rbd/librbd.h +++ b/src/include/rbd/librbd.h @@ -169,6 +169,22 @@ typedef struct { int64_t pool; } rbd_group_spec_t; +typedef enum { + GROUP_SNAP_STATE_PENDING, + GROUP_SNAP_STATE_COMPLETE +} rbd_group_snap_state_t; + +typedef struct { + char *name; + rbd_group_snap_state_t state; +} rbd_group_snap_spec_t; + +typedef enum { + SNAP_NAMESPACE_TYPE_USER = 0, + SNAP_NAMESPACE_TYPE_GROUP = 1, + SNAP_NAMESPACE_TYPE_UNKNOWN = -1, +} rbd_snap_namespace_type_t; + typedef enum { RBD_LOCK_MODE_EXCLUSIVE = 0, RBD_LOCK_MODE_SHARED = 1, @@ -917,12 +933,25 @@ CEPH_RBD_API int rbd_image_get_group(rados_ioctx_t image_p, const char *image_name, rbd_group_spec_t *group_spec); CEPH_RBD_API void rbd_group_spec_cleanup(rbd_group_spec_t *group_spec); -CEPH_RBD_API void rbd_group_image_status_cleanup( - rbd_group_image_status_t *image - ); -CEPH_RBD_API void rbd_group_image_status_list_cleanup( - rbd_group_image_status_t *images, - size_t len); +CEPH_RBD_API void rbd_group_image_status_cleanup(rbd_group_image_status_t *image); +CEPH_RBD_API void rbd_group_image_status_list_cleanup(rbd_group_image_status_t *images, + size_t len); +CEPH_RBD_API int rbd_group_snap_create(rados_ioctx_t group_p, + const char *group_name, + const char *snap_name); +CEPH_RBD_API int rbd_group_snap_remove(rados_ioctx_t group_p, + const char *group_name, + const char *snap_name); +CEPH_RBD_API int rbd_group_snap_list(rados_ioctx_t group_p, + const char *group_name, + rbd_group_snap_spec_t *snaps, + size_t *snaps_size); +CEPH_RBD_API void rbd_group_snap_list_cleanup(rbd_group_snap_spec_t *snaps, + size_t len); +CEPH_RBD_API int rbd_snap_get_namespace_type(rbd_image_t image, + uint64_t snap_id, + rbd_snap_namespace_type_t *namespace_type); + #ifdef __cplusplus } #endif diff --git a/src/include/rbd/librbd.hpp b/src/include/rbd/librbd.hpp index eb73387ca521a..b814a23e980d7 100644 --- a/src/include/rbd/librbd.hpp +++ b/src/include/rbd/librbd.hpp @@ -34,6 +34,14 @@ namespace librbd { typedef void *completion_t; typedef void (*callback_t)(completion_t cb, void *arg); + typedef struct { + int64_t group_pool; + std::string group_name; + std::string group_snap_name; + } group_snap_t; + + typedef rbd_snap_namespace_type_t snap_namespace_type_t; + typedef struct { uint64_t id; uint64_t size; @@ -84,6 +92,13 @@ namespace librbd { int64_t pool; } group_spec_t; + typedef rbd_group_snap_state_t group_snap_state_t; + + typedef struct { + std::string name; + group_snap_state_t state; + } group_snap_spec_t; + typedef rbd_image_info_t image_info_t; class CEPH_RBD_API ProgressContext @@ -212,6 +227,13 @@ public: int group_image_list(IoCtx& io_ctx, const char *group_name, std::vector *images); + int group_snap_create(IoCtx& io_ctx, const char *group_name, + const char *snap_name); + int group_snap_remove(IoCtx& io_ctx, const char *group_name, + const char *snap_name); + int group_snap_list(IoCtx& group_ioctx, const char *group_name, + std::vector *snaps); + private: /* We don't allow assignment or copying */ RBD(const RBD& rhs); @@ -356,6 +378,9 @@ public: int snap_get_limit(uint64_t *limit); int snap_set_limit(uint64_t limit); int snap_get_timestamp(uint64_t snap_id, struct timespec *timestamp); + int snap_get_namespace_type(uint64_t snap_id, + snap_namespace_type_t *namespace_type); + int snap_get_group(uint64_t snap_id, group_snap_t *group_snap); /* I/O */ ssize_t read(uint64_t ofs, size_t len, ceph::bufferlist& bl); diff --git a/src/include/rbd_types.h b/src/include/rbd_types.h index 939d4d3489098..df3f248000955 100644 --- a/src/include/rbd_types.h +++ b/src/include/rbd_types.h @@ -101,6 +101,8 @@ #define RBD_HEADER_SIGNATURE "RBD" #define RBD_HEADER_VERSION "001.005" +#define RBD_GROUP_INVALID_POOL (-1) + #define RBD_GROUP_HEADER_PREFIX "rbd_group_header." #define RBD_GROUP_DIRECTORY "rbd_group_directory" diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc index 90abc4f530320..5124f4a1eb211 100644 --- a/src/librbd/ImageCtx.cc +++ b/src/librbd/ImageCtx.cc @@ -476,6 +476,17 @@ struct C_InvalidateCache : public Context { return CEPH_NOSNAP; } + snap_t ImageCtx::get_snap_id_from_namespace(cls::rbd::SnapshotNamespace in_snap_namespace) const + { + assert(snap_lock.is_locked()); + map, snap_t>::const_iterator it = + snap_ids.lower_bound({in_snap_namespace, ""}); + if (it != snap_ids.end()) { + return it->second; + } + return CEPH_NOSNAP; + } + const SnapInfo* ImageCtx::get_snap_info(snap_t in_snap_id) const { assert(snap_lock.is_locked()); @@ -483,7 +494,7 @@ struct C_InvalidateCache : public Context { snap_info.find(in_snap_id); if (it != snap_info.end()) return &it->second; - return NULL; + return nullptr; } int ImageCtx::get_snap_name(snap_t in_snap_id, diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h index 41635fd4cb5ee..aee48bb981cc7 100644 --- a/src/librbd/ImageCtx.h +++ b/src/librbd/ImageCtx.h @@ -243,6 +243,8 @@ namespace librbd { void snap_unset(); librados::snap_t get_snap_id(cls::rbd::SnapshotNamespace in_snap_namespace, std::string in_snap_name) const; + librados::snap_t get_snap_id_from_namespace( + cls::rbd::SnapshotNamespace in_snap_namespace) const; const SnapInfo* get_snap_info(librados::snap_t in_snap_id) const; int get_snap_name(librados::snap_t in_snap_id, std::string *out_snap_name) const; diff --git a/src/librbd/api/Group.cc b/src/librbd/api/Group.cc index 090a98074c052..bdd0205592ac2 100644 --- a/src/librbd/api/Group.cc +++ b/src/librbd/api/Group.cc @@ -1,9 +1,13 @@ // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- // vim: ts=8 sw=2 smarttab -#include "librbd/api/Group.h" #include "common/errno.h" + +#include "librbd/ExclusiveLock.h" +#include "librbd/api/Group.h" +#include "librbd/ImageCtx.h" #include "librbd/ImageState.h" +#include "librbd/Operations.h" #include "librbd/Utils.h" #include "librbd/io/AioCompletion.h" @@ -23,23 +27,362 @@ using librados::snap_t; using librados::IoCtx; using librados::Rados; + namespace librbd { namespace api { -// Consistency groups functions +namespace { -template -int Group::create(librados::IoCtx& io_ctx, const char *group_name) +string generate_uuid(librados::IoCtx& io_ctx) { - CephContext *cct = (CephContext *)io_ctx.cct(); - Rados rados(io_ctx); uint64_t bid = rados.get_instance_id(); uint32_t extra = rand() % 0xFFFFFFFF; ostringstream bid_ss; bid_ss << std::hex << bid << std::hex << extra; - string id = bid_ss.str(); + return bid_ss.str(); +} + +int group_snap_list(librados::IoCtx& group_ioctx, const char *group_name, + std::vector *cls_snaps) +{ + CephContext *cct = (CephContext *)group_ioctx.cct(); + librados::Rados rados(group_ioctx); + + string group_id; + vector ind_snap_names; + + int r = cls_client::dir_get_id(&group_ioctx, RBD_GROUP_DIRECTORY, + group_name, &group_id); + if (r < 0) { + lderr(cct) << "error reading consistency group id object: " + << cpp_strerror(r) + << dendl; + return r; + } + string group_header_oid = util::group_header_name(group_id); + + const int max_read = 1024; + cls::rbd::GroupSnapshot snap_last; + + for (;;) { + vector snaps_page; + + r = cls_client::group_snap_list(&group_ioctx, group_header_oid, + snap_last, max_read, &snaps_page); + + if (r < 0) { + lderr(cct) << "error reading snap list from consistency group: " + << cpp_strerror(-r) << dendl; + return r; + } + cls_snaps->insert(cls_snaps->end(), snaps_page.begin(), snaps_page.end()); + if (snaps_page.size() < max_read) { + break; + } + snap_last = *snaps_page.rbegin(); + } + + return 0; +} + +std::string calc_ind_image_snap_name(uint64_t pool_id, + std::string group_id, + std::string snap_id) +{ + std::stringstream ind_snap_name_stream; + ind_snap_name_stream << std::setw(16) << std::setfill('0') << std::hex << + pool_id << + "_" << group_id << + "_" << snap_id; + return ind_snap_name_stream.str(); +} + +int group_image_list(librados::IoCtx& group_ioctx, const char *group_name, + std::vector *image_ids) +{ + CephContext *cct = (CephContext *)group_ioctx.cct(); + + string group_id; + + int r = cls_client::dir_get_id(&group_ioctx, RBD_GROUP_DIRECTORY, + group_name, &group_id); + if (r < 0) { + lderr(cct) << "error reading consistency group id object: " + << cpp_strerror(r) + << dendl; + return r; + } + string group_header_oid = util::group_header_name(group_id); + + ldout(cct, 20) << "listing images in group name " + << group_name << " group id " << group_header_oid << dendl; + image_ids->clear(); + + const int max_read = 1024; + cls::rbd::GroupImageSpec start_last; + do { + std::vector image_ids_page; + + r = cls_client::group_image_list(&group_ioctx, group_header_oid, + start_last, max_read, &image_ids_page); + + if (r < 0) { + lderr(cct) << "error reading image list from consistency group: " + << cpp_strerror(-r) << dendl; + return r; + } + image_ids->insert(image_ids->end(), + image_ids_page.begin(), image_ids_page.end()); + + if (image_ids_page.size() > 0) + start_last = image_ids_page.rbegin()->spec; + + r = image_ids_page.size(); + } while (r == max_read); + + return 0; +} + +int group_image_remove(librados::IoCtx& group_ioctx, string group_id, + librados::IoCtx& image_ioctx, string image_id) +{ + CephContext *cct = (CephContext *)group_ioctx.cct(); + + string group_header_oid = util::group_header_name(group_id); + + string image_header_oid = util::header_name(image_id); + + ldout(cct, 20) << "removing image " << image_id + << " image id " << image_header_oid << dendl; + + cls::rbd::GroupSpec group_spec(group_id, group_ioctx.get_id()); + + cls::rbd::GroupImageStatus incomplete_st(image_id, image_ioctx.get_id(), + cls::rbd::GROUP_IMAGE_LINK_STATE_INCOMPLETE); + + cls::rbd::GroupImageSpec spec(image_id, image_ioctx.get_id()); + + int r = cls_client::group_image_set(&group_ioctx, group_header_oid, + incomplete_st); + + if (r < 0) { + lderr(cct) << "couldn't put image into removing state: " + << cpp_strerror(-r) << dendl; + return r; + } + + r = cls_client::image_remove_group(&image_ioctx, image_header_oid, + group_spec); + if ((r < 0) && (r != -ENOENT)) { + lderr(cct) << "couldn't remove group reference from image" + << cpp_strerror(-r) << dendl; + return r; + } + + r = cls_client::group_image_remove(&group_ioctx, group_header_oid, spec); + if (r < 0) { + lderr(cct) << "couldn't remove image from group" + << cpp_strerror(-r) << dendl; + return r; + } + + return 0; +} + +int group_snap_remove_by_record(librados::IoCtx& group_ioctx, + const cls::rbd::GroupSnapshot& group_snap, + const std::string& group_id, + const std::string& group_header_oid) { + + CephContext *cct = (CephContext *)group_ioctx.cct(); + librados::Rados rados(group_ioctx); + std::vector on_finishes; + int r, ret_code; + + std::vector io_ctxs; + std::vector ictxs; + + std::string image_snap_name; + + cls::rbd::SnapshotNamespace ne; + + ldout(cct, 20) << "Removing snapshots" << dendl; + int snap_count = group_snap.snaps.size(); + + for (int i = 0; i < snap_count; ++i) { + librbd::IoCtx image_io_ctx; + r = rados.ioctx_create2(group_snap.snaps[i].pool, image_io_ctx); + if (r < 0) { + ldout(cct, 1) << "Failed to create io context for image" << dendl; + } + + librbd::ImageCtx* image_ctx = new ImageCtx("", group_snap.snaps[i].image_id, + nullptr, image_io_ctx, false); + + C_SaferCond* on_finish = new C_SaferCond; + + image_ctx->state->open(false, on_finish); + + ictxs.push_back(image_ctx); + on_finishes.push_back(on_finish); + } + + ret_code = 0; + for (int i = 0; i < snap_count; ++i) { + r = on_finishes[i]->wait(); + delete on_finishes[i]; + if (r < 0) { + delete ictxs[i]; + ictxs[i] = nullptr; + ret_code = r; + } + } + if (ret_code != 0) { + goto finish; + } + + ne = cls::rbd::GroupSnapshotNamespace(group_ioctx.get_id(), + group_id, + group_snap.id); + + ldout(cct, 20) << "Opened participating images. " << + "Deleting snapshots themselves." << dendl; + + for (int i = 0; i < snap_count; ++i) { + ImageCtx *ictx = ictxs[i]; + ldout(cct, 20) << "Removing individual snapshot with name: " << + image_snap_name << dendl; + on_finishes[i] = new C_SaferCond; + + std::string snap_name; + ictx->snap_lock.get_read(); + snap_t snap_id = ictx->get_snap_id_from_namespace(ne); + r = ictx->get_snap_name(snap_id, &snap_name); + ictx->snap_lock.put_read(); + if (r >= 0) { + ictx->operations->snap_remove(ne, snap_name.c_str(), on_finishes[i]); + } + // We are ok to ignore missing image snapshots. The snapshot could have been inconsistent in the first place. + } + + for (int i = 0; i < snap_count; ++i) { + r = on_finishes[i]->wait(); + delete on_finishes[i]; + if (r < 0 && r != -ENOENT) { // if previous attempts to remove this snapshot failed then the image's snapshot may not exist + lderr(cct) << "Failed deleting image snapshot. Ret code: " << r << dendl; + ret_code = r; + } + } + + if (ret_code != 0) { + goto finish; + } + + ldout(cct, 20) << "Removed images snapshots removing snapshot record." << + dendl; + + r = cls_client::group_snap_remove(&group_ioctx, group_header_oid, + group_snap.id); + if (r < 0) { + ret_code = r; + goto finish; + } + +finish: + for (int i = 0; i < snap_count; ++i) { + if (ictxs[i] != nullptr) { + ictxs[i]->state->close(); + } + } + return ret_code; +} + +class GetGroupVisitor : public boost::static_visitor { +public: + librados::IoCtx *image_ioctx; + group_snap_t group_snap; + + explicit GetGroupVisitor(librados::IoCtx *_image_ioctx) : image_ioctx(_image_ioctx) {}; + + template + inline int operator()(const T&) const { + // ignore other than GroupSnapshotNamespace types. + return -1; + } + + inline int operator()(const cls::rbd::GroupSnapshotNamespace& snap_namespace) { + librados::Rados rados(*image_ioctx); + IoCtx group_ioctx; + int r = rados.ioctx_create2(snap_namespace.group_pool, group_ioctx); + if (r < 0) { + return r; + } + + cls::rbd::GroupSnapshot group_snapshot; + + std::string group_name; + r = cls_client::dir_get_name(&group_ioctx, RBD_GROUP_DIRECTORY, + snap_namespace.group_id, &group_name); + if (r < 0) { + return r; + } + + string group_header_oid = util::group_header_name(snap_namespace.group_id); + + r = cls_client::group_snap_get_by_id(&group_ioctx, + group_header_oid, + snap_namespace.group_snapshot_id, + &group_snapshot); + if (r < 0) { + return r; + } + + group_snap.group_pool = group_ioctx.get_id(); + group_snap.group_name = group_name; + group_snap.group_snap_name = group_snapshot.name; + + return 0; + } +}; + +} // anonymous namespace + +template +int Group::image_remove_by_id(librados::IoCtx& group_ioctx, + const char *group_name, + librados::IoCtx& image_ioctx, + const char *image_id) +{ + CephContext *cct = (CephContext *)group_ioctx.cct(); + ldout(cct, 20) << "io_ctx=" << &group_ioctx + << " group name " << group_name << " image " + << &image_ioctx << " id " << image_id << dendl; + + string group_id; + + int r = cls_client::dir_get_id(&group_ioctx, RBD_GROUP_DIRECTORY, group_name, + &group_id); + if (r < 0) { + lderr(cct) << "error reading consistency group id object: " + << cpp_strerror(r) + << dendl; + return r; + } + + ldout(cct, 20) << "removing image from group name " << group_name + << " group id " << group_id << dendl; + + return group_image_remove(group_ioctx, group_id, image_ioctx, string(image_id)); +} + +template +int Group::create(librados::IoCtx& io_ctx, const char *group_name) +{ + CephContext *cct = (CephContext *)io_ctx.cct(); + + string id = generate_uuid(io_ctx); ldout(cct, 2) << "adding consistency group to directory..." << dendl; @@ -53,9 +396,9 @@ int Group::create(librados::IoCtx& io_ctx, const char *group_name) } string header_oid = util::group_header_name(id); - r = cls_client::group_create(&io_ctx, header_oid); + r = io_ctx.create(header_oid, true); if (r < 0) { - lderr(cct) << "error writing header: " << cpp_strerror(r) << dendl; + lderr(cct) << "error creating group header: " << cpp_strerror(r) << dendl; goto err_remove_from_dir; } @@ -77,34 +420,49 @@ template int Group::remove(librados::IoCtx& io_ctx, const char *group_name) { CephContext *cct((CephContext *)io_ctx.cct()); - ldout(cct, 20) << "io_ctx=" << &io_ctx << " " << group_name << dendl; + ldout(cct, 20) << "group_remove " << &io_ctx << " " << group_name << dendl; + + std::string group_id; + int r = cls_client::dir_get_id(&io_ctx, RBD_GROUP_DIRECTORY, + std::string(group_name), &group_id); + if (r < 0 && r != -ENOENT) { + lderr(cct) << "error getting id of group" << dendl; + return r; + } + string group_header_oid = util::group_header_name(group_id); + + std::vector snaps; + r = group_snap_list(io_ctx, group_name, &snaps); + + for (auto &snap : snaps) { + r = group_snap_remove_by_record(io_ctx, snap, group_id, group_header_oid); + if (r < 0) { + return r; + } + } - std::vector images; - int r = image_list(io_ctx, group_name, &images); + std::vector images; + r = group_image_list(io_ctx, group_name, &images); if (r < 0 && r != -ENOENT) { lderr(cct) << "error listing group images" << dendl; return r; } - for (auto i : images) { + for (auto image : images) { librados::Rados rados(io_ctx); IoCtx image_ioctx; - rados.ioctx_create2(i.pool, image_ioctx); - r = image_remove(io_ctx, group_name, image_ioctx, i.name.c_str()); + r = rados.ioctx_create2(image.spec.pool_id, image_ioctx); + if (r < 0) { + lderr(cct) << "error creating image_ioctx" << dendl; + return r; + } + r = group_image_remove(io_ctx, group_id, image_ioctx, image.spec.image_id); if (r < 0 && r != -ENOENT) { lderr(cct) << "error removing image from a group" << dendl; return r; } } - std::string group_id; - r = cls_client::dir_get_id(&io_ctx, RBD_GROUP_DIRECTORY, - std::string(group_name), &group_id); - if (r < 0 && r != -ENOENT) { - lderr(cct) << "error getting id of group" << dendl; - return r; - } - string header_oid = util::group_header_name(group_id); r = io_ctx.remove(header_oid); @@ -113,8 +471,8 @@ int Group::remove(librados::IoCtx& io_ctx, const char *group_name) return r; } - r = cls_client::group_dir_remove(&io_ctx, RBD_GROUP_DIRECTORY, group_name, - group_id); + r = cls_client::group_dir_remove(&io_ctx, RBD_GROUP_DIRECTORY, + group_name, group_id); if (r < 0 && r != -ENOENT) { lderr(cct) << "error removing group from directory" << dendl; return r; @@ -136,6 +494,9 @@ int Group::list(IoCtx& io_ctx, vector *names) map groups; r = cls_client::group_dir_list(&io_ctx, RBD_GROUP_DIRECTORY, last_read, max_read, &groups); + if (r == -ENOENT) { + return 0; // Ignore missing rbd group directory. It means we don't have any groups yet. + } if (r < 0) { if (r != -ENOENT) { lderr(cct) << "error listing group in directory: " @@ -159,7 +520,7 @@ int Group::list(IoCtx& io_ctx, vector *names) template int Group::image_add(librados::IoCtx& group_ioctx, const char *group_name, - librados::IoCtx& image_ioctx, const char *image_name) + librados::IoCtx& image_ioctx, const char *image_name) { CephContext *cct = (CephContext *)group_ioctx.cct(); ldout(cct, 20) << "io_ctx=" << &group_ioctx @@ -236,98 +597,347 @@ int Group::image_remove(librados::IoCtx& group_ioctx, const char *group_name, { CephContext *cct = (CephContext *)group_ioctx.cct(); ldout(cct, 20) << "io_ctx=" << &group_ioctx - << " group name " << group_name << " image " - << &image_ioctx << " name " << image_name << dendl; + << " group name " << group_name << " image " + << &image_ioctx << " name " << image_name << dendl; + + string group_id; + + int r = cls_client::dir_get_id(&group_ioctx, RBD_GROUP_DIRECTORY, group_name, + &group_id); + if (r < 0) { + lderr(cct) << "error reading consistency group id object: " + << cpp_strerror(r) + << dendl; + return r; + } + + ldout(cct, 20) << "removing image from group name " << group_name + << " group id " << group_id << dendl; string image_id; - int r = cls_client::dir_get_id(&image_ioctx, RBD_DIRECTORY, image_name, - &image_id); + r = cls_client::dir_get_id(&image_ioctx, RBD_DIRECTORY, image_name, + &image_id); if (r < 0) { lderr(cct) << "error reading image id object: " - << cpp_strerror(-r) << dendl; + << cpp_strerror(-r) << dendl; return r; } - return Group::image_remove_by_id(group_ioctx, group_name, image_ioctx, - image_id.c_str()); + r = group_image_remove(group_ioctx, group_id, image_ioctx, image_id); + + return r; } template -int Group::image_remove_by_id(librados::IoCtx& group_ioctx, - const char *group_name, - librados::IoCtx& image_ioctx, - const char *image_id) +int Group::image_list(librados::IoCtx& group_ioctx, + const char *group_name, + std::vector* images) +{ + CephContext *cct = (CephContext *)group_ioctx.cct(); + ldout(cct, 20) << "io_ctx=" << &group_ioctx + << " group name " << group_name << dendl; + + std::vector image_ids; + + group_image_list(group_ioctx, group_name, &image_ids); + + for (auto image_id : image_ids) { + librados::Rados rados(group_ioctx); + IoCtx ioctx; + int r = rados.ioctx_create2(image_id.spec.pool_id, ioctx); + if (r < 0) { + return r; + } + std::string image_name; + r = cls_client::dir_get_name(&ioctx, RBD_DIRECTORY, + image_id.spec.image_id, &image_name); + if (r < 0) { + return r; + } + + images->push_back( + group_image_status_t { + image_name, + ioctx.get_id(), + static_cast(image_id.state)}); + } + + return 0; +} + +template +int Group::image_get_group(I *ictx, group_spec_t *group_spec) +{ + int r = ictx->state->refresh_if_required(); + if (r < 0) + return r; + + if (-1 != ictx->group_spec.pool_id) { + librados::Rados rados(ictx->md_ctx); + IoCtx ioctx; + r = rados.ioctx_create2(ictx->group_spec.pool_id, ioctx); + if (r < 0) + return r; + + std::string group_name; + r = cls_client::dir_get_name(&ioctx, RBD_GROUP_DIRECTORY, + ictx->group_spec.group_id, &group_name); + if (r < 0) + return r; + group_spec->pool = ioctx.get_id(); + group_spec->name = group_name; + } else { + group_spec->pool = RBD_GROUP_INVALID_POOL; + group_spec->name = ""; + } + + return 0; +} + +template +int Group::snap_create(librados::IoCtx& group_ioctx, + const char *group_name, const char *snap_name) { CephContext *cct = (CephContext *)group_ioctx.cct(); - ldout(cct, 20) << "group_remove_image_by_id " << &group_ioctx - << " group name " << group_name << " image " - << &image_ioctx << " id " << image_id << dendl; + librados::Rados rados(group_ioctx); string group_id; + cls::rbd::GroupSnapshot group_snap; + vector image_snaps; + std::string ind_snap_name; - int r = cls_client::dir_get_id(&group_ioctx, RBD_GROUP_DIRECTORY, group_name, - &group_id); + std::vector io_ctxs; + std::vector ictxs; + std::vector on_finishes; + + cls::rbd::SnapshotNamespace ne; + + int r = cls_client::dir_get_id(&group_ioctx, RBD_GROUP_DIRECTORY, + group_name, &group_id); if (r < 0) { lderr(cct) << "error reading consistency group id object: " << cpp_strerror(r) << dendl; return r; } + + std::vector images; + r = group_image_list(group_ioctx, group_name, &images); + if (r < 0) { + return r; + } + int image_count = images.size(); + + ldout(cct, 20) << "Found " << image_count << " images in group" << dendl; + + image_snaps = vector(image_count, + cls::rbd::ImageSnapshotSpec()); + + for (int i = 0; i < image_count; ++i) { + image_snaps[i].pool = images[i].spec.pool_id; + image_snaps[i].image_id = images[i].spec.image_id; + } + string group_header_oid = util::group_header_name(group_id); - ldout(cct, 20) << "adding image to group name " << group_name - << " group id " << group_header_oid << dendl; + group_snap.id = generate_uuid(group_ioctx); + group_snap.name = string(snap_name); + group_snap.state = cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE; + group_snap.snaps = image_snaps; - string image_header_oid = util::header_name(image_id); + r = cls_client::group_snap_add(&group_ioctx, group_header_oid, group_snap); + if (r == -EEXIST) { + lderr(cct) << "snapshot with this name already exists: " + << cpp_strerror(r) + << dendl; + } + int ret_code = 0; + if (r < 0) { + ret_code = r; + goto finish; + } - ldout(cct, 20) << "removing " << " image id " << image_header_oid << dendl; + for (auto image: images) { + librbd::IoCtx* image_io_ctx = new librbd::IoCtx; - cls::rbd::GroupSpec group_spec(group_id, group_ioctx.get_id()); + r = rados.ioctx_create2(image.spec.pool_id, *image_io_ctx); + if (r < 0) { + ldout(cct, 1) << "Failed to create io context for image" << dendl; + } - cls::rbd::GroupImageStatus incomplete_st( - image_id, image_ioctx.get_id(), - cls::rbd::GROUP_IMAGE_LINK_STATE_INCOMPLETE); + ldout(cct, 20) << "Openning image with id" << image.spec.image_id << dendl; - cls::rbd::GroupImageSpec spec(image_id, image_ioctx.get_id()); + librbd::ImageCtx* image_ctx = new ImageCtx("", image.spec.image_id.c_str(), + nullptr, *image_io_ctx, false); - r = cls_client::group_image_set(&group_ioctx, group_header_oid, - incomplete_st); + C_SaferCond* on_finish = new C_SaferCond; + + image_ctx->state->open(false, on_finish); + + ictxs.push_back(image_ctx); + on_finishes.push_back(on_finish); + } + ldout(cct, 20) << "Issued open request waiting for the completion" << dendl; + ret_code = 0; + for (int i = 0; i < image_count; ++i) { + + ldout(cct, 20) << "Waiting for completion on on_finish: " << + on_finishes[i] << dendl; + + r = on_finishes[i]->wait(); + delete on_finishes[i]; + if (r < 0) { + delete ictxs[i]; + ictxs[i] = nullptr; + ret_code = r; + } + } + if (ret_code != 0) { + goto remove_record; + } + ldout(cct, 20) << "Requesting exclusive locks for images" << dendl; + + for (auto ictx: ictxs) { + RWLock::RLocker owner_lock(ictx->owner_lock); + if (ictx->exclusive_lock != nullptr) { + ictx->exclusive_lock->block_requests(-EBUSY); + } + } + for (int i = 0; i < image_count; ++i) { + ImageCtx *ictx = ictxs[i]; + RWLock::RLocker owner_lock(ictx->owner_lock); + + on_finishes[i] = new C_SaferCond; + if (ictx->exclusive_lock != nullptr) { + ictx->exclusive_lock->acquire_lock(on_finishes[i]); + } + } + ret_code = 0; + for (int i = 0; i < image_count; ++i) { + r = 0; + ImageCtx *ictx = ictxs[i]; + if (ictx->exclusive_lock != nullptr) { + r = on_finishes[i]->wait(); + } + delete on_finishes[i]; + if (r < 0) { + ret_code = r; + } + } + if (ret_code != 0) { + goto remove_record; + } + + ind_snap_name = calc_ind_image_snap_name(group_ioctx.get_id(), group_id, + group_snap.id); + ne = cls::rbd::GroupSnapshotNamespace(group_ioctx.get_id(), group_id, + group_snap.id); + + for (int i = 0; i < image_count; ++i) { + ImageCtx *ictx = ictxs[i]; + + C_SaferCond* on_finish = new C_SaferCond; + + ictx->operations->snap_create(ne, ind_snap_name.c_str(), on_finish); + + on_finishes[i] = on_finish; + } + + ret_code = 0; + for (int i = 0; i < image_count; ++i) { + r = on_finishes[i]->wait(); + delete on_finishes[i]; + if (r < 0) { + ret_code = r; + } else { + ImageCtx *ictx = ictxs[i]; + ictx->snap_lock.get_read(); + snap_t snap_id = ictx->get_snap_id_from_namespace(ne); + ictx->snap_lock.put_read(); + if (snap_id == CEPH_NOSNAP) { + ldout(cct, 20) << + "Couldn't find supposedly created snapshot with namespace: " << + ne << dendl; + ret_code = -ENOENT; + } else { + image_snaps[i].snap_id = snapid_t(snap_id); + image_snaps[i].pool = ictx->data_ctx.get_id(); + image_snaps[i].image_id = ictx->id; + } + } + } + if (ret_code != 0) { + goto remove_image_snaps; + } + + group_snap.snaps = image_snaps; + group_snap.state = cls::rbd::GROUP_SNAPSHOT_STATE_COMPLETE; + + r = cls_client::group_snap_update(&group_ioctx, group_header_oid, group_snap); if (r < 0) { - lderr(cct) << "couldn't put image into removing state: " - << cpp_strerror(-r) << dendl; - return r; + ret_code = r; + goto remove_image_snaps; } - r = cls_client::image_remove_group(&image_ioctx, image_header_oid, - group_spec); - if ((r < 0) && (r != -ENOENT)) { - lderr(cct) << "couldn't remove group reference from image" - << cpp_strerror(-r) << dendl; - return r; + goto finish; + +remove_image_snaps: + + for (int i = 0; i < image_count; ++i) { + ImageCtx *ictx = ictxs[i]; + ldout(cct, 20) << "Removing individual snapshot with name: " << + ind_snap_name << dendl; + + on_finishes[i] = new C_SaferCond; + std::string snap_name; + ictx->snap_lock.get_read(); + snap_t snap_id = ictx->get_snap_id_from_namespace(ne); + r = ictx->get_snap_name(snap_id, &snap_name); + ictx->snap_lock.put_read(); + if (r >= 0) { + ictx->operations->snap_remove(ne, snap_name.c_str(), on_finishes[i]); + } + // Ignore missing image snapshots. The whole snapshot could have been inconsistent. } - r = cls_client::group_image_remove(&group_ioctx, group_header_oid, spec); + for (int i = 0, n = on_finishes.size(); i < n; ++i) { + r = on_finishes[i]->wait(); + delete on_finishes[i]; + if (r < 0 && r != -ENOENT) { // if previous attempts to remove this snapshot failed then the image's snapshot may not exist + lderr(cct) << "Failed cleaning up image snapshot. Ret code: " << r << dendl; + // just report error, but don't abort the process + } + } + +remove_record: + r = cls_client::group_snap_remove(&group_ioctx, group_header_oid, + group_snap.id); if (r < 0) { - lderr(cct) << "couldn't remove image from group" - << cpp_strerror(-r) << dendl; - return r; + lderr(cct) << "error while cleaning up group snapshot" << dendl; + // we ignore return value in clean up } - return 0; +finish: + for (int i = 0, n = ictxs.size(); i < n; ++i) { + if (ictxs[i] != nullptr) { + ictxs[i]->state->close(); + } + } + return ret_code; } template -int Group::image_list(librados::IoCtx& group_ioctx, - const char *group_name, - std::vector *images) +int Group::snap_remove(librados::IoCtx& group_ioctx, const char *group_name, + const char *snap_name) { CephContext *cct = (CephContext *)group_ioctx.cct(); - ldout(cct, 20) << "io_ctx=" << &group_ioctx - << " group name " << group_name << dendl; + librados::Rados rados(group_ioctx); - string group_id; + std::vector snaps; + std::vector on_finishes; + string group_id; int r = cls_client::dir_get_id(&group_ioctx, RBD_GROUP_DIRECTORY, group_name, &group_id); if (r < 0) { @@ -338,81 +948,85 @@ int Group::image_list(librados::IoCtx& group_ioctx, } string group_header_oid = util::group_header_name(group_id); - ldout(cct, 20) << "listing images in group name " - << group_name << " group id " << group_header_oid << dendl; - - std::vector image_ids; - - const int max_read = 1024; - do { - std::vector image_ids_page; - cls::rbd::GroupImageSpec start_last; - - r = cls_client::group_image_list(&group_ioctx, group_header_oid, - start_last, max_read, &image_ids_page); - - if (r < 0) { - lderr(cct) << "error reading image list from consistency group: " - << cpp_strerror(-r) << dendl; - return r; + r = group_snap_list(group_ioctx, group_name, &snaps); + if (r < 0) { + return r; + } + cls::rbd::GroupSnapshot *group_snap = nullptr; + for (auto &snap : snaps) { + if (snap.name == string(snap_name)) { + group_snap = &snap; + break; } - image_ids.insert(image_ids.end(), - image_ids_page.begin(), image_ids_page.end()); + } + if (group_snap == nullptr) { + return -ENOENT; + } - if (image_ids_page.size() > 0) - start_last = image_ids_page.rbegin()->spec; + r = group_snap_remove_by_record(group_ioctx, *group_snap, group_id, + group_header_oid); - r = image_ids_page.size(); - } while (r == max_read); + return r; +} - for (auto i : image_ids) { - librados::Rados rados(group_ioctx); - IoCtx ioctx; - rados.ioctx_create2(i.spec.pool_id, ioctx); - std::string image_name; - r = cls_client::dir_get_name(&ioctx, RBD_DIRECTORY, - i.spec.image_id, &image_name); - if (r < 0) { - return r; - } +template +int Group::snap_list(librados::IoCtx& group_ioctx, const char *group_name, + std::vector *snaps) +{ + std::vector cls_snaps; - images->push_back( - group_image_status_t { - image_name, - i.spec.pool_id, - static_cast(i.state)}); + int r = group_snap_list(group_ioctx, group_name, &cls_snaps); + if (r < 0) { + return r; } + for (auto snap : cls_snaps) { + snaps->push_back( + group_snap_spec_t { + snap.name, + static_cast(snap.state)}); + + } return 0; } template -int Group::image_get_group(I *ictx, group_spec_t *group_spec) -{ - int r = ictx->state->refresh_if_required(); - if (r < 0) - return r; - - if (-1 != ictx->group_spec.pool_id) { - librados::Rados rados(ictx->md_ctx); - IoCtx ioctx; - rados.ioctx_create2(ictx->group_spec.pool_id, ioctx); +int Group::snap_get_group(I *ictx, + uint64_t snap_id, + group_snap_t *group_snap) { + const SnapInfo *snap_info; + { + RWLock::RLocker l(ictx->snap_lock); + snap_info = ictx->get_snap_info(snap_id); + if (snap_info) { + GetGroupVisitor ggv = GetGroupVisitor(&ictx->data_ctx); + int r = boost::apply_visitor(ggv, snap_info->snap_namespace); + if (r < 0) { + return r; + } + *group_snap = ggv.group_snap; + } + } + return 0; +} - std::string group_name; - r = cls_client::dir_get_name(&ioctx, RBD_GROUP_DIRECTORY, - ictx->group_spec.group_id, &group_name); - if (r < 0) - return r; - group_spec->pool = ictx->group_spec.pool_id; - group_spec->name = group_name; - } else { - group_spec->pool = -1; - group_spec->name = ""; +template +int Group::snap_get_namespace_type(I *ictx, + uint64_t snap_id, + snap_namespace_type_t *namespace_type) { + const SnapInfo *snap_info; + { + RWLock::RLocker l(ictx->snap_lock); + snap_info = ictx->get_snap_info(snap_id); + if (snap_info) { + *namespace_type = static_cast( + get_namespace_type(snap_info->snap_namespace)); + } } - return 0; } + } // namespace api } // namespace librbd diff --git a/src/librbd/api/Group.h b/src/librbd/api/Group.h index bcc772ffe7379..6c17b29582e2f 100644 --- a/src/librbd/api/Group.h +++ b/src/librbd/api/Group.h @@ -36,6 +36,19 @@ struct Group { static int image_get_group(ImageCtxT *ictx, group_spec_t *group_spec); + static int snap_create(librados::IoCtx& group_ioctx, + const char *group_name, const char *snap_name); + static int snap_remove(librados::IoCtx& group_ioctx, + const char *group_name, const char *snap_name); + static int snap_list(librados::IoCtx& group_ioctx, const char *group_name, + std::vector *snaps); + static int snap_get_group(ImageCtxT *ictx, + uint64_t snap_id, + group_snap_t *group_snap); + + static int snap_get_namespace_type(ImageCtxT *ictx, + uint64_t snap_id, + snap_namespace_type_t *namespace_type); }; } // namespace api diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc index f13c236cb9606..ebdf6d62452f4 100644 --- a/src/librbd/librbd.cc +++ b/src/librbd/librbd.cc @@ -167,6 +167,12 @@ void group_spec_cpp_to_c(const librbd::group_spec_t &cpp_spec, c_spec->pool = cpp_spec.pool; } +void group_snap_spec_cpp_to_c(const librbd::group_snap_spec_t &cpp_spec, + rbd_group_snap_spec_t *c_spec) { + c_spec->name = strdup(cpp_spec.name.c_str()); + c_spec->state = cpp_spec.state; +} + void mirror_image_info_cpp_to_c(const librbd::mirror_image_info_t &cpp_info, rbd_mirror_image_info_t *c_info) { c_info->global_id = strdup(cpp_info.global_id.c_str()); @@ -764,6 +770,37 @@ namespace librbd { return r; } + int RBD::group_snap_create(IoCtx& group_ioctx, const char *group_name, + const char *snap_name) { + TracepointProvider::initialize(get_cct(group_ioctx)); + tracepoint(librbd, group_snap_create_enter, group_ioctx.get_pool_name().c_str(), + group_ioctx.get_id(), group_name, snap_name); + int r = librbd::api::Group<>::snap_create(group_ioctx, group_name, snap_name); + tracepoint(librbd, group_snap_create_exit, r); + return r; + } + + int RBD::group_snap_remove(IoCtx& group_ioctx, const char *group_name, + const char *snap_name) { + TracepointProvider::initialize(get_cct(group_ioctx)); + tracepoint(librbd, group_snap_remove_enter, group_ioctx.get_pool_name().c_str(), + group_ioctx.get_id(), group_name, snap_name); + int r = librbd::api::Group<>::snap_remove(group_ioctx, group_name, snap_name); + tracepoint(librbd, group_snap_remove_exit, r); + return r; + } + + int RBD::group_snap_list(IoCtx& group_ioctx, const char *group_name, + std::vector *snaps) + { + TracepointProvider::initialize(get_cct(group_ioctx)); + tracepoint(librbd, group_snap_list_enter, group_ioctx.get_pool_name().c_str(), + group_ioctx.get_id(), group_name); + int r = librbd::api::Group<>::snap_list(group_ioctx, group_name, snaps); + tracepoint(librbd, group_snap_list_exit, r); + return r; + } + RBD::AioCompletion::AioCompletion(void *cb_arg, callback_t complete_cb) { @@ -1523,6 +1560,24 @@ namespace librbd { return r; } + int Image::snap_get_namespace_type(uint64_t snap_id, + snap_namespace_type_t *namespace_type) { + ImageCtx *ictx = (ImageCtx *)ctx; + tracepoint(librbd, snap_get_namespace_type_enter, ictx, ictx->name.c_str()); + int r = librbd::api::Group<>::snap_get_namespace_type(ictx, snap_id, namespace_type); + tracepoint(librbd, snap_get_namespace_type_exit, r); + return r; + } + + int Image::snap_get_group(uint64_t snap_id, + group_snap_t *group_snap) { + ImageCtx *ictx = (ImageCtx *)ctx; + tracepoint(librbd, snap_get_group_enter, ictx, ictx->name.c_str()); + int r = librbd::api::Group<>::snap_get_group(ictx, snap_id, group_snap); + tracepoint(librbd, snap_get_group_exit, r); + return r; + } + int Image::snap_set_limit(uint64_t limit) { ImageCtx *ictx = (ImageCtx *)ctx; @@ -4331,7 +4386,8 @@ extern "C" int rbd_group_list(rados_ioctx_t p, char *names, size_t *size) io_ctx.get_id()); vector cpp_names; - int r = librbd::list(io_ctx, cpp_names); + int r = librbd::api::Group<>::list(io_ctx, &cpp_names); + if (r < 0) { tracepoint(librbd, group_list_exit, r); return r; @@ -4458,6 +4514,7 @@ extern "C" int rbd_group_image_list(rados_ioctx_t group_p, } if (*image_size < cpp_images.size()) { + *image_size = cpp_images.size(); tracepoint(librbd, group_image_list_exit, -ERANGE); return -ERANGE; } @@ -4466,6 +4523,7 @@ extern "C" int rbd_group_image_list(rados_ioctx_t group_p, group_image_status_cpp_to_c(cpp_images[i], &images[i]); } + r = cpp_images.size(); tracepoint(librbd, group_image_list_exit, r); return r; } @@ -4510,6 +4568,94 @@ extern "C" void rbd_group_image_status_list_cleanup( } } +extern "C" int rbd_group_snap_create(rados_ioctx_t group_p, const char *group_name, + const char *snap_name) +{ + librados::IoCtx group_ioctx; + librados::IoCtx::from_rados_ioctx_t(group_p, group_ioctx); + + TracepointProvider::initialize(get_cct(group_ioctx)); + tracepoint(librbd, group_snap_create_enter, group_ioctx.get_pool_name().c_str(), + group_ioctx.get_id(), group_name, snap_name); + + int r = librbd::api::Group<>::snap_create(group_ioctx, group_name, snap_name); + + tracepoint(librbd, group_snap_create_exit, r); + + return r; +} + +extern "C" int rbd_group_snap_remove(rados_ioctx_t group_p, const char *group_name, + const char *snap_name) +{ + librados::IoCtx group_ioctx; + librados::IoCtx::from_rados_ioctx_t(group_p, group_ioctx); + + TracepointProvider::initialize(get_cct(group_ioctx)); + tracepoint(librbd, group_snap_remove_enter, group_ioctx.get_pool_name().c_str(), + group_ioctx.get_id(), group_name, snap_name); + + int r = librbd::api::Group<>::snap_remove(group_ioctx, group_name, snap_name); + + tracepoint(librbd, group_snap_remove_exit, r); + + return r; +} + +extern "C" int rbd_group_snap_list(rados_ioctx_t group_p, const char *group_name, + rbd_group_snap_spec_t *snaps, size_t *snaps_size) +{ + librados::IoCtx group_ioctx; + librados::IoCtx::from_rados_ioctx_t(group_p, group_ioctx); + + TracepointProvider::initialize(get_cct(group_ioctx)); + tracepoint(librbd, group_snap_list_enter, group_ioctx.get_pool_name().c_str(), + group_ioctx.get_id(), group_name); + + std::vector cpp_snaps; + int r = librbd::api::Group<>::snap_list(group_ioctx, group_name, &cpp_snaps); + + if (r == -ENOENT) { + tracepoint(librbd, group_snap_list_exit, 0); + return 0; + } + + if (r < 0) { + tracepoint(librbd, group_snap_list_exit, r); + return r; + } + + if (*snaps_size < cpp_snaps.size()) { + *snaps_size = cpp_snaps.size(); + tracepoint(librbd, group_snap_list_exit, -ERANGE); + return -ERANGE; + } + + for (size_t i = 0; i < cpp_snaps.size(); ++i) { + group_snap_spec_cpp_to_c(cpp_snaps[i], &snaps[i]); + } + + *snaps_size = cpp_snaps.size(); + tracepoint(librbd, group_snap_list_exit, 0); + return 0; +} + +extern "C" void rbd_group_snap_list_cleanup(rbd_group_snap_spec_t *snaps, + size_t len) { + for (size_t i = 0; i < len; ++i) { + free(snaps[i].name); + } +} + +extern "C" int rbd_snap_get_namespace_type(rbd_image_t image, + uint64_t snap_id, + rbd_snap_namespace_type_t *namespace_type) { + librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; + tracepoint(librbd, snap_get_namespace_type_enter, ictx, ictx->name.c_str()); + int r = librbd::api::Group<>::snap_get_namespace_type(ictx, snap_id, namespace_type); + tracepoint(librbd, snap_get_namespace_type_exit, r); + return r; +} extern "C" int rbd_watchers_list(rbd_image_t image, rbd_image_watcher_t *watchers, size_t *max_watchers) { diff --git a/src/pybind/rbd/rbd.pyx b/src/pybind/rbd/rbd.pyx index 6470b78af2a1e..16c9b50ba91ca 100644 --- a/src/pybind/rbd/rbd.pyx +++ b/src/pybind/rbd/rbd.pyx @@ -139,6 +139,11 @@ cdef extern from "rbd/librbd.h" nogil: time_t last_update bint up + ctypedef enum rbd_snap_namespace_type_t: + _SNAP_NAMESPACE_TYPE_USER "SNAP_NAMESPACE_TYPE_USER" + _SNAP_NAMESPACE_TYPE_GROUP "SNAP_NAMESPACE_TYPE_GROUP" + _SNAP_NAMESPACE_TYPE_UNKNOWN "SNAP_NAMESPACE_TYPE_UNKNOWN" + ctypedef enum rbd_lock_mode_t: _RBD_LOCK_MODE_EXCLUSIVE "RBD_LOCK_MODE_EXCLUSIVE" _RBD_LOCK_MODE_SHARED "RBD_LOCK_MODE_SHARED" @@ -159,6 +164,26 @@ cdef extern from "rbd/librbd.h" nogil: int64_t id uint64_t cookie + ctypedef struct rbd_group_image_spec_t: + char *name + uint64_t pool + + ctypedef enum rbd_group_image_state_t: + _GROUP_IMAGE_STATE_ATTACHED "GROUP_IMAGE_STATE_ATTACHED" + _GROUP_IMAGE_STATE_INCOMPLETE "GROUP_IMAGE_STATE_INCOMPLETE" + + ctypedef struct rbd_group_image_status_t: + rbd_group_image_spec_t spec + rbd_group_image_state_t state + + ctypedef enum rbd_group_snap_state_t: + _GROUP_SNAP_STATE_PENDING "GROUP_SNAP_STATE_PENDING" + _GROUP_SNAP_STATE_COMPLETE "GROUP_SNAP_STATE_COMPLETE" + + ctypedef struct rbd_group_snap_spec_t: + char *name + rbd_group_snap_state_t state + ctypedef void (*rbd_callback_t)(rbd_completion_t cb, void *arg) ctypedef int (*librbd_progress_fn_t)(uint64_t offset, uint64_t total, void* ptr) @@ -359,6 +384,39 @@ cdef extern from "rbd/librbd.h" nogil: int rbd_metadata_list(rbd_image_t image, const char *start, uint64_t max, char *keys, size_t *key_len, char *values, size_t *vals_len) + int rbd_group_create(rados_ioctx_t p, const char *name) + int rbd_group_remove(rados_ioctx_t p, const char *name) + int rbd_group_list(rados_ioctx_t p, char *names, size_t *size) + int rbd_group_image_add(rados_ioctx_t group_p, const char *group_name, + rados_ioctx_t image_p, const char *image_name) + int rbd_group_image_remove(rados_ioctx_t group_p, const char *group_name, + rados_ioctx_t image_p, const char *image_name) + + int rbd_group_image_list(rados_ioctx_t group_p, + const char *group_name, + rbd_group_image_status_t *images, + size_t *image_size) + + void rbd_group_image_status_list_cleanup(rbd_group_image_status_t *images, + size_t len) + + int rbd_group_snap_create(rados_ioctx_t group_p, const char *group_name, + const char *snap_name) + + int rbd_group_snap_remove(rados_ioctx_t group_p, const char *group_name, + const char *snap_name) + + int rbd_group_snap_list(rados_ioctx_t group_p, + const char *group_name, + rbd_group_snap_spec_t *snaps, + size_t *snaps_size) + + void rbd_group_snap_list_cleanup(rbd_group_snap_spec_t *snaps, + size_t len) + + int rbd_snap_get_namespace_type(rbd_image_t image, + uint64_t snap_id, + rbd_snap_namespace_type_t *namespace_type) int rbd_watchers_list(rbd_image_t image, rbd_image_watcher_t *watchers, size_t *max_watchers) @@ -434,10 +492,15 @@ class PermissionError(OSError): class ImageNotFound(OSError): pass +class ObjectNotFound(Error): + pass class ImageExists(OSError): pass +class ObjectExists(Error): + pass + class IOError(OSError): pass @@ -507,7 +570,24 @@ cdef errno_to_exception = { errno.EDQUOT : DiskQuotaExceeded, } -cdef make_ex(ret, msg): +cdef group_errno_to_exception = { + errno.EPERM : PermissionError, + errno.ENOENT : ObjectNotFound, + errno.EIO : IOError, + errno.ENOSPC : NoSpace, + errno.EEXIST : ObjectExists, + errno.EINVAL : InvalidArgument, + errno.EROFS : ReadOnlyImage, + errno.EBUSY : ImageBusy, + errno.ENOTEMPTY : ImageHasSnapshots, + errno.ENOSYS : FunctionNotSupported, + errno.EDOM : ArgumentOutOfRange, + errno.ESHUTDOWN : ConnectionShutdown, + errno.ETIMEDOUT : Timeout, + errno.EDQUOT : DiskQuotaExceeded, +} + +cdef make_ex(ret, msg, exception_map=errno_to_exception): """ Translate a librbd return code into an exception. @@ -1213,6 +1293,77 @@ class RBD(object): free(states) free(counts) + def group_create(self, ioctx, name): + """ + Create a consistency group. + + :param ioctx: determines which RADOS pool is used + :type ioctx: :class:`rados.Ioctx` + :param name: the name of the consistency group + :type name: str + :raises: :class:`ObjectExists` + :raises: :class:`InvalidArgument` + :raises: :class:`FunctionNotSupported` + """ + name = cstr(name, 'name') + cdef: + char *_name = name + rados_ioctx_t _ioctx = convert_ioctx(ioctx) + with nogil: + ret = rbd_group_create(_ioctx, _name) + if ret != 0: + raise make_ex(ret, 'error creating group %s' % name, group_errno_to_exception) + + def group_remove(self, ioctx, name): + """ + Delete an RBD group. This may take a long time, since it does + not return until every image in the consistency group has been removed + from the group. + + :param ioctx: determines which RADOS pool the group is in + :type ioctx: :class:`rados.Ioctx` + :param name: the name of the group to remove + :type name: str + :raises: :class:`ObjectNotFound` + :raises: :class:`InvalidArgument` + :raises: :class:`FunctionNotSupported` + """ + name = cstr(name, 'name') + cdef: + rados_ioctx_t _ioctx = convert_ioctx(ioctx) + char *_name = name + with nogil: + ret = rbd_group_remove(_ioctx, _name) + if ret != 0: + raise make_ex(ret, 'error removing group', group_errno_to_exception) + + def group_list(self, ioctx): + """ + List groups. + + :param ioctx: determines which RADOS pool is read + :type ioctx: :class:`rados.Ioctx` + :returns: list -- a list of groups names + :raises: :class:`FunctionNotSupported` + """ + cdef: + rados_ioctx_t _ioctx = convert_ioctx(ioctx) + size_t size = 512 + char *c_names = NULL + try: + while True: + c_names = realloc_chk(c_names, size) + with nogil: + ret = rbd_group_list(_ioctx, c_names, &size) + if ret >= 0: + break + elif ret != -errno.ERANGE: + raise make_ex(ret, 'error listing groups', group_errno_to_exception) + return [decode_cstr(name) for name in c_names[:ret].split(b'\0') + if name] + finally: + free(c_names) + cdef class MirrorPeerIterator(object): """ Iterator over mirror peer info for a pool. @@ -1361,6 +1512,127 @@ cdef int diff_iterate_cb(uint64_t offset, size_t length, int write, void *cb) \ return 0 return ret +cdef class Group(object): + """ + This class represents an RBD consistency group. It is used to interact with + snapshots and images members. + """ + + cdef object name + cdef char *_name + cdef object ioctx + + cdef rados_ioctx_t _ioctx + + def __init__(self, ioctx, name): + name = cstr(name, 'name') + self.name = name + + self._ioctx = convert_ioctx(ioctx) + self._name = name + + def add_image(self, image_ioctx, image_name): + """ + Add an image to a group. + + :param image_ioctx: determines which RADOS pool the image belongs to. + :type ioctx: :class:`rados.Ioctx` + :param name: the name of the image to remove + :type name: str + + :raises: :class:`ObjectNotFound` + :raises: :class:`ObjectExists` + :raises: :class:`InvalidArgument` + :raises: :class:`FunctionNotSupported` + """ + image_name = cstr(image_name, 'image_name') + cdef: + rados_ioctx_t _image_ioctx = convert_ioctx(image_ioctx) + char *_image_name = image_name + with nogil: + ret = rbd_group_image_add(self._ioctx, self._name, _image_ioctx, _image_name) + if ret != 0: + raise make_ex(ret, 'error adding image to group', group_errno_to_exception) + + def remove_image(self, image_ioctx, image_name): + """ + Remove an image to a group. + + :param image_ioctx: determines which RADOS pool the image belongs to. + :type ioctx: :class:`rados.Ioctx` + :param name: the name of the image to remove + :type name: str + + :raises: :class:`ObjectNotFound` + :raises: :class:`ObjectExists` + :raises: :class:`InvalidArgument` + :raises: :class:`FunctionNotSupported` + """ + image_name = cstr(image_name, 'image_name') + cdef: + rados_ioctx_t _image_ioctx = convert_ioctx(image_ioctx) + char *_image_name = image_name + with nogil: + ret = rbd_group_image_remove(self._ioctx, self._name, _image_ioctx, _image_name) + if ret != 0: + raise make_ex(ret, 'error removing image from group', group_errno_to_exception) + + + def list_images(self): + """ + Iterate over the images of a group. + + :returns: :class:`GroupImageIterator` + """ + return GroupImageIterator(self) + + def create_snap(self, snap_name): + """ + Create a snapshot for the group. + + :param snap_name: the name of the snapshot to create + :type name: str + + :raises: :class:`ObjectNotFound` + :raises: :class:`ObjectExists` + :raises: :class:`InvalidArgument` + :raises: :class:`FunctionNotSupported` + """ + snap_name = cstr(snap_name, 'snap_name') + cdef: + char *_snap_name = snap_name + with nogil: + ret = rbd_group_snap_create(self._ioctx, self._name, _snap_name) + if ret != 0: + raise make_ex(ret, 'error creating group snapshot', group_errno_to_exception) + + def remove_snap(self, snap_name): + """ + Remove a snapshot from the group. + + :param snap_name: the name of the snapshot to remove + :type name: str + + :raises: :class:`ObjectNotFound` + :raises: :class:`ObjectExists` + :raises: :class:`InvalidArgument` + :raises: :class:`FunctionNotSupported` + """ + snap_name = cstr(snap_name, 'snap_name') + cdef: + char *_snap_name = snap_name + with nogil: + ret = rbd_group_snap_remove(self._ioctx, self._name, _snap_name) + if ret != 0: + raise make_ex(ret, 'error removing group snapshot', group_errno_to_exception) + + def list_snaps(self): + """ + Iterate over the images of a group. + + :returns: :class:`GroupSnapIterator` + """ + return GroupSnapIterator(self) cdef class Image(object): """ @@ -2850,7 +3122,6 @@ written." % (self.name, ret, length)) """ return MetadataIterator(self) - def watchers_list(self): """ List image watchers. @@ -2859,6 +3130,20 @@ written." % (self.name, ret, length)) """ return WatcherIterator(self) + def snap_get_namespace_type(self, snap_id): + """ + Get the snapshot namespace type. + :param snap_id: the snapshot id of a snap shot + """ + cdef: + rbd_snap_namespace_type_t namespace_type + uint64_t _snap_id = snap_id + with nogil: + ret = rbd_snap_get_namespace_type(self.image, _snap_id, &namespace_type) + if ret != 0: + raise make_ex(ret, 'error getting snapshot namespace type for image: %s, snap_id: %d' % (self.name, snap_id)) + + return namespace_type cdef class LockOwnerIterator(object): """ @@ -3178,3 +3463,97 @@ cdef class WatcherIterator(object): if self.watchers: rbd_watchers_list_cleanup(self.watchers, self.num_watchers) free(self.watchers) + +cdef class GroupImageIterator(object): + """ + Iterator over image info for a group. + + Yields a dictionary containing information about an image. + + Keys are: + + * ``name`` (str) - name of the image + + * ``pool`` (int) - name of the pool this image belongs to + + * ``state`` (int) - state of the image + """ + + cdef rbd_group_image_status_t *images + cdef size_t num_images + cdef object group + + def __init__(self, Group group): + self.group = group + self.images = NULL + self.num_images = 10 + while True: + self.images = realloc_chk(self.images, + self.num_images * + sizeof(rbd_group_image_status_t)) + with nogil: + ret = rbd_group_image_list(group._ioctx, group._name, self.images, &self.num_images) + + if ret >= 0: + self.num_images = ret + break + elif ret != -errno.ERANGE: + raise make_ex(ret, 'error listing images for group %s' % (group.name,), group_errno_to_exception) + + def __iter__(self): + for i in range(self.num_images): + yield { + 'name' : decode_cstr(self.images[i].spec.name), + 'pool' : self.images[i].spec.pool, + 'state' : self.images[i].state, + } + + def __dealloc__(self): + if self.images: + rbd_group_image_status_list_cleanup(self.images, self.num_images) + free(self.images) + +cdef class GroupSnapIterator(object): + """ + Iterator over snaps specs for a group. + + Yields a dictionary containing information about a snapshot. + + Keys are: + + * ``name`` (str) - name of the snapshot + + * ``state`` (int) - state of the snapshot + """ + + cdef rbd_group_snap_spec_t *snaps + cdef size_t num_snaps + cdef object group + + def __init__(self, Group group): + self.group = group + self.snaps = NULL + self.num_snaps = 10 + while True: + self.snaps = realloc_chk(self.snaps, + self.num_snaps * + sizeof(rbd_group_snap_spec_t)) + with nogil: + ret = rbd_group_snap_list(group._ioctx, group._name, self.snaps, &self.num_snaps) + + if ret == 0: + break + elif ret != -errno.ERANGE: + raise make_ex(ret, 'error listing snapshots for group %s' % (group.name,), group_errno_to_exception) + + def __iter__(self): + for i in range(self.num_snaps): + yield { + 'name' : decode_cstr(self.snaps[i].name), + 'state' : self.snaps[i].state, + } + + def __dealloc__(self): + if self.snaps: + rbd_group_snap_list_cleanup(self.snaps, self.num_snaps) + free(self.snaps) diff --git a/src/test/cli/rbd/help.t b/src/test/cli/rbd/help.t index b41d56c0e39ff..de528f0e0cc42 100644 --- a/src/test/cli/rbd/help.t +++ b/src/test/cli/rbd/help.t @@ -30,6 +30,9 @@ Skip test on FreeBSD as it generates different output there. group image remove Remove an image from a consistency group. group list (group ls) List rbd consistency groups. group remove (group rm) Delete a consistency group. + group snap create Make a snapshot of a group. + group snap list List snapshots of a consistency group. + group snap remove Remove a snapshot from a group. image-meta get Image metadata get the value associated with the key. image-meta list (image-meta ls) Image metadata list keys with values. @@ -540,6 +543,57 @@ Skip test on FreeBSD as it generates different output there. -p [ --pool ] arg pool name --group arg group name + rbd help group snap create + usage: rbd group snap create [--pool ] [--group ] [--snap ] + + + Make a snapshot of a group. + + Positional arguments + group specification + (example: [/]) + snapshot name + (example: ) + + Optional arguments + -p [ --pool ] arg pool name + --group arg group name + --snap arg snapshot name + + rbd help group snap list + usage: rbd group snap list [--format ] [--pretty-format] + [--pool ] [--group ] + + + List snapshots of a consistency group. + + Positional arguments + group specification + (example: [/]) + + Optional arguments + --format arg output format (plain, json, or xml) [default: plain] + --pretty-format pretty formatting (json and xml) + -p [ --pool ] arg pool name + --group arg group name + + rbd help group snap remove + usage: rbd group snap remove [--pool ] [--group ] [--snap ] + + + Remove a snapshot from a group. + + Positional arguments + group specification + (example: [/]) + snapshot name + (example: ) + + Optional arguments + -p [ --pool ] arg pool name + --group arg group name + --snap arg snapshot name + rbd help image-meta get usage: rbd image-meta get [--pool ] [--image ] @@ -1343,7 +1397,7 @@ Skip test on FreeBSD as it generates different output there. rbd help snap list usage: rbd snap list [--pool ] [--image ] [--image-id ] - [--format ] [--pretty-format] + [--format ] [--pretty-format] [--all] Dump list of image snapshots. @@ -1358,6 +1412,7 @@ Skip test on FreeBSD as it generates different output there. --image-id arg image id --format arg output format (plain, json, or xml) [default: plain] --pretty-format pretty formatting (json and xml) + -a [ --all ] list snapshots from all namespaces rbd help snap protect usage: rbd snap protect [--pool ] [--image ] [--snap ] diff --git a/src/test/cls_rbd/test_cls_rbd.cc b/src/test/cls_rbd/test_cls_rbd.cc index ead403c12adce..3217c9d9dc1e5 100644 --- a/src/test/cls_rbd/test_cls_rbd.cc +++ b/src/test/cls_rbd/test_cls_rbd.cc @@ -2233,7 +2233,7 @@ TEST_F(TestClsRbd, group_snap_add_empty_name) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id, "", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EINVAL, group_snap_add(&ioctx, group_id, snap)); } @@ -2247,7 +2247,7 @@ TEST_F(TestClsRbd, group_snap_add_empty_id) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {"", "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {"", "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EINVAL, group_snap_add(&ioctx, group_id, snap)); } @@ -2261,10 +2261,10 @@ TEST_F(TestClsRbd, group_snap_add_duplicate_id) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); - cls::rbd::GroupSnapshot snap1 = {snap_id, "snap_name1", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap1 = {snap_id, "snap_name1", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EEXIST, group_snap_add(&ioctx, group_id, snap1)); } @@ -2278,11 +2278,11 @@ TEST_F(TestClsRbd, group_snap_add_duplicate_name) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id1 = "snap_id1"; - cls::rbd::GroupSnapshot snap = {snap_id1, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id1, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); string snap_id2 = "snap_id2"; - cls::rbd::GroupSnapshot snap1 = {snap_id2, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap1 = {snap_id2, "snap_name", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(-EEXIST, group_snap_add(&ioctx, group_id, snap1)); } @@ -2296,7 +2296,7 @@ TEST_F(TestClsRbd, group_snap_add) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); set keys; @@ -2319,11 +2319,11 @@ TEST_F(TestClsRbd, group_snap_list) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id1 = "snap_id1"; - cls::rbd::GroupSnapshot snap1 = {snap_id1, "test_snapshot1", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap1 = {snap_id1, "test_snapshot1", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap1)); string snap_id2 = "snap_id2"; - cls::rbd::GroupSnapshot snap2 = {snap_id2, "test_snapshot2", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap2 = {snap_id2, "test_snapshot2", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap2)); std::vector snapshots; @@ -2353,7 +2353,7 @@ TEST_F(TestClsRbd, group_snap_list_max_return) { string snap_id = "snap_id" + hexify(i); cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot" + hexify(i), - cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); } @@ -2386,7 +2386,7 @@ TEST_F(TestClsRbd, group_snap_update) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); snap.state = cls::rbd::GROUP_SNAPSHOT_STATE_COMPLETE; @@ -2410,7 +2410,7 @@ TEST_F(TestClsRbd, group_snap_update_empty_name) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); snap.name = ""; @@ -2429,7 +2429,7 @@ TEST_F(TestClsRbd, group_snap_update_empty_id) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); snap.id = ""; @@ -2449,7 +2449,7 @@ TEST_F(TestClsRbd, group_snap_remove) { ASSERT_EQ(0, ioctx.create(group_id, true)); string snap_id = "snap_id"; - cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); set keys; @@ -2483,7 +2483,7 @@ TEST_F(TestClsRbd, group_snap_get_by_id) { string snap_id = "snap_id"; cls::rbd::GroupSnapshot snap = {snap_id, "test_snapshot", - cls::rbd::GROUP_SNAPSHOT_STATE_PENDING}; + cls::rbd::GROUP_SNAPSHOT_STATE_INCOMPLETE}; ASSERT_EQ(0, group_snap_add(&ioctx, group_id, snap)); cls::rbd::GroupSnapshot received_snap; diff --git a/src/test/librbd/test_Groups.cc b/src/test/librbd/test_Groups.cc index 39f30959abb52..947966511c755 100644 --- a/src/test/librbd/test_Groups.cc +++ b/src/test/librbd/test_Groups.cc @@ -89,3 +89,36 @@ TEST_F(TestLibCG, add_image) ASSERT_EQ(0, rbd.group_image_list(ioctx, group_name, &images)); ASSERT_EQ(0U, images.size()); } + +TEST_F(TestLibCG, add_snapshot) +{ + librados::IoCtx ioctx; + ASSERT_EQ(0, _rados.ioctx_create(_pool_name.c_str(), ioctx)); + + const char *group_name = "snap_consistency_group"; + const char *image_name = "snap_image"; + const char *snap_name = "snap_snapshot"; + + librbd::RBD rbd; + ASSERT_EQ(0, rbd.group_create(ioctx, group_name)); + + int order = 14; + ASSERT_EQ(0, rbd.create2(ioctx, image_name, 65535, + RBD_FEATURE_LAYERING, &order)); // Specified features make image of new format. + + ASSERT_EQ(0, rbd.group_image_add(ioctx, group_name, ioctx, image_name)); + + ASSERT_EQ(0, rbd.group_snap_create(ioctx, group_name, snap_name)); + + std::vector snaps; + ASSERT_EQ(0, rbd.group_snap_list(ioctx, group_name, &snaps)); + ASSERT_EQ(1U, snaps.size()); + + ASSERT_EQ(snap_name, snaps[0].name); + + ASSERT_EQ(0, rbd.group_snap_remove(ioctx, group_name, snap_name)); + + snaps.clear(); + ASSERT_EQ(0, rbd.group_snap_list(ioctx, group_name, &snaps)); + ASSERT_EQ(0U, snaps.size()); +} diff --git a/src/test/pybind/test_rbd.py b/src/test/pybind/test_rbd.py index 0ee0c8e3c117c..af4e73158558e 100644 --- a/src/test/pybind/test_rbd.py +++ b/src/test/pybind/test_rbd.py @@ -12,7 +12,7 @@ from rados import (Rados, LIBRADOS_OP_FLAG_FADVISE_DONTNEED, LIBRADOS_OP_FLAG_FADVISE_NOCACHE, LIBRADOS_OP_FLAG_FADVISE_RANDOM) -from rbd import (RBD, Image, ImageNotFound, InvalidArgument, ImageExists, +from rbd import (RBD, Group, Image, ImageNotFound, InvalidArgument, ImageExists, ImageBusy, ImageHasSnapshots, ReadOnlyImage, FunctionNotSupported, ArgumentOutOfRange, DiskQuotaExceeded, ConnectionShutdown, PermissionError, @@ -27,7 +27,11 @@ rados = None ioctx = None features = None image_idx = 0 +group_idx = 0 +snap_idx = 0 image_name = None +group_name = None +snap_name = None pool_idx = 0 pool_name = None IMG_SIZE = 8 << 20 # 8 MiB @@ -65,6 +69,16 @@ def get_temp_image_name(): image_idx += 1 return "image" + str(image_idx) +def get_temp_group_name(): + global group_idx + group_idx += 1 + return "group" + str(group_idx) + +def get_temp_snap_name(): + global snap_idx + snap_idx += 1 + return "snap" + str(snap_idx) + def create_image(): global image_name image_name = get_temp_image_name() @@ -78,6 +92,15 @@ def remove_image(): if image_name is not None: RBD().remove(ioctx, image_name) +def create_group(): + global group_name + group_name = get_temp_group_name() + RBD().group_create(ioctx, group_name) + +def remove_group(): + if group_name is not None: + RBD().group_remove(ioctx, group_name) + def require_new_format(): def wrapper(fn): def _require_new_format(*args, **kwargs): @@ -1658,3 +1681,104 @@ class TestTrash(object): RBD().trash_move(ioctx, image_name, 1000) RBD().trash_restore(ioctx, image_id, image_name) remove_image() + +def test_create_group(): + create_group() + remove_group() + +def test_list_groups_empty(): + eq([], RBD().group_list(ioctx)) + +@with_setup(create_group, remove_group) +def test_list_groups(): + eq([group_name], RBD().group_list(ioctx)) + +@with_setup(create_group) +def test_list_groups_after_removed(): + remove_group() + eq([], RBD().group_list(ioctx)) + +class TestConsistencyGroups(object): + + def setUp(self): + global snap_name + self.rbd = RBD() + create_image() + self.image = Image(ioctx, image_name) + create_group() + snap_name = get_temp_snap_name() + self.group = Group(ioctx, group_name) + + def tearDown(self): + remove_group() + self.image = None + remove_image() + + def test_group_image_add(self): + self.group.add_image(ioctx, image_name) + + def test_group_image_list_empty(self): + eq([], list(self.group.list_images())) + + def test_group_image_list(self): + eq([], list(self.group.list_images())) + self.group.add_image(ioctx, image_name) + eq([image_name], [img['name'] for img in self.group.list_images()]) + + def test_group_image_15_images(self): + eq([], list(self.group.list_images())) + names = [] + for x in range(0, 20): + names.append(image_name) + self.group.add_image(ioctx, image_name) + create_image() + names.sort() + answer = [img['name'] for img in self.group.list_images()] + answer.sort() + eq(names, answer) + + def test_group_image_remove(self): + eq([], list(self.group.list_images())) + self.group.add_image(ioctx, image_name) + eq([image_name], [img['name'] for img in self.group.list_images()]) + self.group.remove_image(ioctx, image_name) + eq([], list(self.group.list_images())) + + def test_group_snap(self): + global snap_name + eq([], list(self.group.list_snaps())) + """ + self.group.create_snap(snap_name) + eq([snap_name], [snap['name'] for snap in self.group.list_snaps()]) + self.group.remove_snap(snap_name) + eq([], list(self.group.list_snaps())) + """ + + def test_group_snap_list_15(self): + global snap_name + eq([], list(self.group.list_snaps())) + snap_names = [] + for x in range(0, 20): + snap_names.append(snap_name) + self.group.create_snap(snap_name) + snap_name = get_temp_snap_name() + + snap_names.sort() + answer = [snap['name'] for snap in self.group.list_snaps()] + answer.sort() + eq(snap_names, answer) + + def test_group_snap_namespace(self): + global snap_name + eq([], list(self.group.list_snaps())) + self.group.add_image(ioctx, image_name) + self.group.create_snap(snap_name) + eq(1, len([snap['name'] for snap in self.image.list_snaps()])) + self.group.remove_image(ioctx, image_name) + self.group.remove_snap(snap_name) + eq([], list(self.group.list_snaps())) + +@with_setup(create_image, remove_image) +def test_rename(): + rbd = RBD() + image_name2 = get_temp_image_name() diff --git a/src/tracing/librbd.tp b/src/tracing/librbd.tp index 3a57e17dbf62f..5413f324bd6b1 100644 --- a/src/tracing/librbd.tp +++ b/src/tracing/librbd.tp @@ -2417,6 +2417,42 @@ TRACEPOINT_EVENT(librbd, update_unwatch_exit, ) ) +TRACEPOINT_EVENT(librbd, snap_get_namespace_type_enter, + TP_ARGS( + void*, imagectx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_namespace_type_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_group_enter, + TP_ARGS( + void*, imagectx, + const char*, name), + TP_FIELDS( + ctf_integer_hex(void*, imagectx, imagectx) + ctf_string(name, name) + ) +) + +TRACEPOINT_EVENT(librbd, snap_get_group_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + TRACEPOINT_EVENT(librbd, group_image_add_enter, TP_ARGS( const char*, pool_name, @@ -2531,6 +2567,70 @@ TRACEPOINT_EVENT(librbd, image_get_group_exit, ) ) +TRACEPOINT_EVENT(librbd, group_snap_create_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, snap_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(snap_name, snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_create_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_remove_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name, + const char*, snap_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ctf_string(snap_name, snap_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_remove_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_list_enter, + TP_ARGS( + const char*, pool_name, + int64_t, id, + const char*, group_name), + TP_FIELDS( + ctf_string(pool_name, pool_name) + ctf_integer(int64_t, id, id) + ctf_string(group_name, group_name) + ) +) + +TRACEPOINT_EVENT(librbd, group_snap_list_exit, + TP_ARGS( + int, retval), + TP_FIELDS( + ctf_integer(int, retval, retval) + ) +) + TRACEPOINT_EVENT(librbd, list_watchers_enter, TP_ARGS( void*, imagectx, -- 2.39.5