From de85e007e7926f56d0a83126ee2e3f01a9184b82 Mon Sep 17 00:00:00 2001 From: Victor Denisov Date: Mon, 30 Jan 2017 14:04:13 -0800 Subject: [PATCH] librbd: Add snapshot namespace to snapshot-name index in ImageCtx The essence of this huge change is to have two keys for indexing snap ids in ImageCtx. It used to be a map of (snap_name -> snap_id) now it's (snap_namespace, snap_name) -> snap_id. Therefore now snapshots can have the same name if they are in different namespaces. All the remaining changes are a consequece of this change of ImageCtx.snap_ids field. The only exception is: we assume that you can't rename snapshots from GroupSnapshotNamespaces. So rename operation always assumes UserSnapshotNamespace. Signed-off-by: Victor Denisov --- src/cls/rbd/cls_rbd_types.h | 18 ++ src/librbd/ImageCtx.cc | 27 +-- src/librbd/ImageCtx.h | 17 +- src/librbd/ImageState.cc | 7 +- src/librbd/ImageState.h | 8 +- src/librbd/ImageWatcher.cc | 36 ++-- src/librbd/ImageWatcher.h | 16 +- src/librbd/Operations.cc | 116 +++++++------ src/librbd/Operations.h | 46 ++++-- src/librbd/WatchNotifyTypes.cc | 25 +-- src/librbd/WatchNotifyTypes.h | 29 ++-- src/librbd/api/DiffIterate.cc | 13 +- src/librbd/api/DiffIterate.h | 17 +- src/librbd/image/OpenRequest.cc | 2 +- src/librbd/image/RefreshParentRequest.cc | 19 ++- src/librbd/image/RefreshRequest.cc | 8 +- src/librbd/image/SetSnapRequest.cc | 10 +- src/librbd/image/SetSnapRequest.h | 10 +- src/librbd/internal.cc | 36 ++-- src/librbd/internal.h | 9 +- src/librbd/journal/Replay.cc | 18 +- src/librbd/journal/Types.cc | 46 ++++-- src/librbd/journal/Types.h | 61 ++++--- src/librbd/librbd.cc | 48 +++--- src/librbd/mirror/DisableRequest.cc | 11 +- src/librbd/mirror/DisableRequest.h | 3 +- src/librbd/operation/SnapshotCreateRequest.cc | 11 +- src/librbd/operation/SnapshotCreateRequest.h | 6 +- .../operation/SnapshotProtectRequest.cc | 7 +- src/librbd/operation/SnapshotProtectRequest.h | 6 +- src/librbd/operation/SnapshotRemoveRequest.cc | 7 +- src/librbd/operation/SnapshotRemoveRequest.h | 7 +- .../operation/SnapshotRollbackRequest.cc | 7 +- .../operation/SnapshotRollbackRequest.h | 7 +- .../operation/SnapshotUnprotectRequest.cc | 9 +- .../operation/SnapshotUnprotectRequest.h | 6 +- .../librbd/image/test_mock_RefreshRequest.cc | 14 +- src/test/librbd/journal/test_Replay.cc | 101 +++++++----- src/test/librbd/journal/test_mock_Replay.cc | 156 +++++++++++++----- .../librbd/mirror/test_mock_DisableRequest.cc | 16 +- src/test/librbd/mock/MockImageCtx.h | 16 +- src/test/librbd/mock/MockImageState.h | 4 +- src/test/librbd/mock/MockOperations.h | 23 ++- .../object_map/test_mock_InvalidateRequest.cc | 4 +- .../object_map/test_mock_ResizeRequest.cc | 4 +- .../test_mock_SnapshotCreateRequest.cc | 3 +- .../object_map/test_mock_UpdateRequest.cc | 4 +- .../test_mock_SnapshotCreateRequest.cc | 26 +-- .../test_mock_SnapshotProtectRequest.cc | 12 +- .../test_mock_SnapshotRemoveRequest.cc | 23 ++- .../test_mock_SnapshotRollbackRequest.cc | 3 +- .../test_mock_SnapshotUnprotectRequest.cc | 14 +- src/test/librbd/test_ImageWatcher.cc | 20 ++- src/test/librbd/test_fixture.cc | 7 +- src/test/librbd/test_internal.cc | 69 +++++--- src/test/librbd/test_mirroring.cc | 2 +- .../test_mock_CreateImageRequest.cc | 11 +- .../test_mock_EventPreprocessor.cc | 4 +- .../image_sync/test_mock_ImageCopyRequest.cc | 49 ++++-- .../image_sync/test_mock_ObjectCopyRequest.cc | 22 ++- .../test_mock_SnapshotCopyRequest.cc | 126 ++++++++++---- .../test_mock_SnapshotCreateRequest.cc | 5 +- .../test_mock_SyncPointCreateRequest.cc | 5 +- .../test_mock_SyncPointPruneRequest.cc | 68 ++++++-- src/test/rbd_mirror/test_ImageDeleter.cc | 14 +- src/test/rbd_mirror/test_ImageReplayer.cc | 29 ++-- src/test/rbd_mirror/test_ImageSync.cc | 8 +- src/test/rbd_mirror/test_PoolWatcher.cc | 7 +- src/test/rbd_mirror/test_fixture.cc | 10 +- src/test/rbd_mirror/test_mock_ImageSync.cc | 17 +- src/tools/rbd_mirror/ImageDeleter.cc | 6 +- src/tools/rbd_mirror/ImageSync.cc | 3 +- .../image_replayer/CreateImageRequest.cc | 4 +- .../image_replayer/EventPreprocessor.cc | 5 +- .../rbd_mirror/image_sync/ImageCopyRequest.cc | 5 +- .../image_sync/SnapshotCopyRequest.cc | 21 ++- .../image_sync/SnapshotCreateRequest.cc | 7 +- .../image_sync/SyncPointCreateRequest.cc | 2 +- .../image_sync/SyncPointPruneRequest.cc | 7 +- 79 files changed, 1079 insertions(+), 606 deletions(-) diff --git a/src/cls/rbd/cls_rbd_types.h b/src/cls/rbd/cls_rbd_types.h index d2a48a2d0c1..50145420830 100644 --- a/src/cls/rbd/cls_rbd_types.h +++ b/src/cls/rbd/cls_rbd_types.h @@ -237,6 +237,10 @@ struct UserSnapshotNamespace { return true; } + inline bool operator<(const UserSnapshotNamespace& usn) const { + return false; + } + }; std::ostream& operator<<(std::ostream& os, const UserSnapshotNamespace& ns); @@ -267,6 +271,16 @@ struct GroupSnapshotNamespace { snapshot_id == gsn.snapshot_id; } + inline bool operator<(const GroupSnapshotNamespace& gsn) const { + if (group_pool < gsn.group_pool) { + return true; + } else if (group_id < gsn.group_id) { + return true; + } else { + return snapshot_id < gsn.snapshot_id; + } + } + }; std::ostream& operator<<(std::ostream& os, const GroupSnapshotNamespace& ns); @@ -282,6 +296,10 @@ struct UnknownSnapshotNamespace { inline bool operator==(const UnknownSnapshotNamespace& gsn) const { return true; } + + inline bool operator<(const UnknownSnapshotNamespace& usn) const { + return false; + } }; std::ostream& operator<<(std::ostream& os, const UnknownSnapshotNamespace& ns); diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc index 0fe40b5166b..9ea00a1bcfb 100644 --- a/src/librbd/ImageCtx.cc +++ b/src/librbd/ImageCtx.cc @@ -412,12 +412,14 @@ struct C_InvalidateCache : public Context { return flags; } - int ImageCtx::snap_set(string in_snap_name) + int ImageCtx::snap_set(cls::rbd::SnapshotNamespace in_snap_namespace, + string in_snap_name) { assert(snap_lock.is_wlocked()); - snap_t in_snap_id = get_snap_id(in_snap_name); + snap_t in_snap_id = get_snap_id(in_snap_namespace, in_snap_name); if (in_snap_id != CEPH_NOSNAP) { snap_id = in_snap_id; + snap_namespace = in_snap_namespace; snap_name = in_snap_name; snap_exists = true; data_ctx.snap_set_read(snap_id); @@ -430,16 +432,17 @@ struct C_InvalidateCache : public Context { { assert(snap_lock.is_wlocked()); snap_id = CEPH_NOSNAP; + snap_namespace = {}; snap_name = ""; snap_exists = true; data_ctx.snap_set_read(snap_id); } - snap_t ImageCtx::get_snap_id(string in_snap_name) const + snap_t ImageCtx::get_snap_id(cls::rbd::SnapshotNamespace in_snap_namespace, + string in_snap_name) const { assert(snap_lock.is_locked()); - map::const_iterator it = - snap_ids.find(in_snap_name); + auto it = snap_ids.find({in_snap_namespace, in_snap_name}); if (it != snap_ids.end()) return it->second; return CEPH_NOSNAP; @@ -548,8 +551,8 @@ struct C_InvalidateCache : public Context { return -ENOENT; } - void ImageCtx::add_snap(string in_snap_name, - cls::rbd::SnapshotNamespace in_snap_namespace, + void ImageCtx::add_snap(cls::rbd::SnapshotNamespace in_snap_namespace, + string in_snap_name, snap_t id, uint64_t in_size, const ParentInfo &parent, uint8_t protection_status, uint64_t flags, utime_t timestamp) @@ -558,16 +561,18 @@ struct C_InvalidateCache : public Context { snaps.push_back(id); SnapInfo info(in_snap_name, in_snap_namespace, in_size, parent, protection_status, flags, timestamp); - snap_info.insert(pair(id, info)); - snap_ids.insert(pair(in_snap_name, id)); + snap_info.insert({id, info}); + snap_ids.insert({{in_snap_namespace, in_snap_name}, id}); } - void ImageCtx::rm_snap(string in_snap_name, snap_t id) + void ImageCtx::rm_snap(cls::rbd::SnapshotNamespace in_snap_namespace, + string in_snap_name, + snap_t id) { assert(snap_lock.is_wlocked()); snaps.erase(std::remove(snaps.begin(), snaps.end(), id), snaps.end()); snap_info.erase(id); - snap_ids.erase(in_snap_name); + snap_ids.erase({in_snap_namespace, in_snap_name}); } uint64_t ImageCtx::get_image_size(snap_t in_snap_id) const diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h index e264fbb5759..b85974224a8 100644 --- a/src/librbd/ImageCtx.h +++ b/src/librbd/ImageCtx.h @@ -68,7 +68,7 @@ namespace librbd { std::vector snaps; // this mirrors snapc.snaps, but is in // a format librados can understand std::map snap_info; - std::map snap_ids; + std::map, librados::snap_t> snap_ids; uint64_t snap_id; bool snap_exists; // false if our snap_id was deleted // whether the image was opened read-only. cannot be changed after opening @@ -81,6 +81,7 @@ namespace librbd { std::string lock_tag; std::string name; + cls::rbd::SnapshotNamespace snap_namespace; std::string snap_name; IoCtx data_ctx, md_ctx; ImageWatcher *image_watcher; @@ -227,9 +228,11 @@ namespace librbd { void perf_stop(); void set_read_flag(unsigned flag); int get_read_flags(librados::snap_t snap_id); - int snap_set(std::string in_snap_name); + int snap_set(cls::rbd::SnapshotNamespace in_snap_namespace, + std::string in_snap_name); void snap_unset(); - librados::snap_t get_snap_id(std::string in_snap_name) const; + librados::snap_t get_snap_id(cls::rbd::SnapshotNamespace in_snap_namespace, + std::string in_snap_name) 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; @@ -249,12 +252,14 @@ namespace librbd { uint64_t get_stripe_count() const; uint64_t get_stripe_period() const; - void add_snap(std::string in_snap_name, - cls::rbd::SnapshotNamespace in_snap_namespace, + void add_snap(cls::rbd::SnapshotNamespace in_snap_namespace, + std::string in_snap_name, librados::snap_t id, uint64_t in_size, const ParentInfo &parent, uint8_t protection_status, uint64_t flags, utime_t timestamp); - void rm_snap(std::string in_snap_name, librados::snap_t id); + void rm_snap(cls::rbd::SnapshotNamespace in_snap_namespace, + std::string in_snap_name, + librados::snap_t id); uint64_t get_image_size(librados::snap_t in_snap_id) const; uint64_t get_object_count(librados::snap_t in_snap_id) const; bool test_features(uint64_t test_features) const; diff --git a/src/librbd/ImageState.cc b/src/librbd/ImageState.cc index 71a3fdec3da..ba4151a0005 100644 --- a/src/librbd/ImageState.cc +++ b/src/librbd/ImageState.cc @@ -381,11 +381,14 @@ ImageState::find_pending_refresh() const { } template -void ImageState::snap_set(const std::string &snap_name, Context *on_finish) { +void ImageState::snap_set(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, + Context *on_finish) { CephContext *cct = m_image_ctx->cct; ldout(cct, 20) << __func__ << ": snap_name=" << snap_name << dendl; Action action(ACTION_TYPE_SET_SNAP); + action.snap_namespace = snap_namespace; action.snap_name = snap_name; m_lock.Lock(); @@ -694,7 +697,7 @@ void ImageState::send_set_snap_unlock() { *m_image_ctx, create_context_callback< ImageState, &ImageState::handle_set_snap>(this)); image::SetSnapRequest *req = image::SetSnapRequest::create( - *m_image_ctx, action_contexts.first.snap_name, ctx); + *m_image_ctx, action_contexts.first.snap_namespace, action_contexts.first.snap_name, ctx); m_lock.Unlock(); req->send(); diff --git a/src/librbd/ImageState.h b/src/librbd/ImageState.h index 73433ba8fc8..2f4d3e33d13 100644 --- a/src/librbd/ImageState.h +++ b/src/librbd/ImageState.h @@ -9,6 +9,7 @@ #include #include #include +#include "cls/rbd/cls_rbd_types.h" class Context; class RWLock; @@ -39,7 +40,9 @@ public: int refresh_if_required(); void refresh(Context *on_finish); - void snap_set(const std::string &snap_name, Context *on_finish); + void snap_set(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, + Context *on_finish); void prepare_lock(Context *on_ready); void handle_prepare_lock_complete(); @@ -72,6 +75,7 @@ private: struct Action { ActionType action_type; uint64_t refresh_seq = 0; + cls::rbd::SnapshotNamespace snap_namespace; std::string snap_name; Context *on_ready = nullptr; @@ -85,7 +89,7 @@ private: case ACTION_TYPE_REFRESH: return (refresh_seq == action.refresh_seq); case ACTION_TYPE_SET_SNAP: - return snap_name == action.snap_name; + return (snap_name == action.snap_name) && (snap_namespace == action.snap_namespace); case ACTION_TYPE_LOCK: return false; default: diff --git a/src/librbd/ImageWatcher.cc b/src/librbd/ImageWatcher.cc index af2a0ba8727..8219201d1d5 100644 --- a/src/librbd/ImageWatcher.cc +++ b/src/librbd/ImageWatcher.cc @@ -150,20 +150,20 @@ void ImageWatcher::notify_resize(uint64_t request_id, uint64_t size, } template -void ImageWatcher::notify_snap_create(const std::string &snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace, +void ImageWatcher::notify_snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock && !m_image_ctx.exclusive_lock->is_lock_owner()); - notify_lock_owner(SnapCreatePayload(snap_name, snap_namespace), on_finish); + notify_lock_owner(SnapCreatePayload(snap_namespace, snap_name), on_finish); } template void ImageWatcher::notify_snap_rename(const snapid_t &src_snap_id, const std::string &dst_snap_name, - Context *on_finish) { + Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock && !m_image_ctx.exclusive_lock->is_lock_owner()); @@ -172,33 +172,36 @@ void ImageWatcher::notify_snap_rename(const snapid_t &src_snap_id, } template -void ImageWatcher::notify_snap_remove(const std::string &snap_name, +void ImageWatcher::notify_snap_remove(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock && !m_image_ctx.exclusive_lock->is_lock_owner()); - notify_lock_owner(SnapRemovePayload(snap_name), on_finish); + notify_lock_owner(SnapRemovePayload(snap_namespace, snap_name), on_finish); } template -void ImageWatcher::notify_snap_protect(const std::string &snap_name, +void ImageWatcher::notify_snap_protect(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock && !m_image_ctx.exclusive_lock->is_lock_owner()); - notify_lock_owner(SnapProtectPayload(snap_name), on_finish); + notify_lock_owner(SnapProtectPayload(snap_namespace, snap_name), on_finish); } template -void ImageWatcher::notify_snap_unprotect(const std::string &snap_name, +void ImageWatcher::notify_snap_unprotect(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); assert(m_image_ctx.exclusive_lock && !m_image_ctx.exclusive_lock->is_lock_owner()); - notify_lock_owner(SnapUnprotectPayload(snap_name), on_finish); + notify_lock_owner(SnapUnprotectPayload(snap_namespace, snap_name), on_finish); } template @@ -700,8 +703,8 @@ bool ImageWatcher::handle_payload(const SnapCreatePayload &payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_create request: " << payload.snap_name << dendl; - m_image_ctx.operations->execute_snap_create(payload.snap_name, - payload.snap_namespace, + m_image_ctx.operations->execute_snap_create(payload.snap_namespace, + payload.snap_name, new C_ResponseMessage(ack_ctx), 0, false); return false; @@ -744,7 +747,8 @@ bool ImageWatcher::handle_payload(const SnapRemovePayload &payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_remove request: " << payload.snap_name << dendl; - m_image_ctx.operations->execute_snap_remove(payload.snap_name, + m_image_ctx.operations->execute_snap_remove(payload.snap_namespace, + payload.snap_name, new C_ResponseMessage(ack_ctx)); return false; } else if (r < 0) { @@ -764,7 +768,8 @@ bool ImageWatcher::handle_payload(const SnapProtectPayload& payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_protect request: " << payload.snap_name << dendl; - m_image_ctx.operations->execute_snap_protect(payload.snap_name, + m_image_ctx.operations->execute_snap_protect(payload.snap_namespace, + payload.snap_name, new C_ResponseMessage(ack_ctx)); return false; } else if (r < 0) { @@ -784,7 +789,8 @@ bool ImageWatcher::handle_payload(const SnapUnprotectPayload& payload, ldout(m_image_ctx.cct, 10) << this << " remote snap_unprotect request: " << payload.snap_name << dendl; - m_image_ctx.operations->execute_snap_unprotect(payload.snap_name, + m_image_ctx.operations->execute_snap_unprotect(payload.snap_namespace, + payload.snap_name, new C_ResponseMessage(ack_ctx)); return false; } else if (r < 0) { diff --git a/src/librbd/ImageWatcher.h b/src/librbd/ImageWatcher.h index 14b5a6dc96d..9e899eb7885 100644 --- a/src/librbd/ImageWatcher.h +++ b/src/librbd/ImageWatcher.h @@ -40,15 +40,21 @@ public: Context *on_finish); void notify_resize(uint64_t request_id, uint64_t size, bool allow_shrink, ProgressContext &prog_ctx, Context *on_finish); - void notify_snap_create(const std::string &snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace, + void notify_snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish); void notify_snap_rename(const snapid_t &src_snap_id, const std::string &dst_snap_name, Context *on_finish); - void notify_snap_remove(const std::string &snap_name, Context *on_finish); - void notify_snap_protect(const std::string &snap_name, Context *on_finish); - void notify_snap_unprotect(const std::string &snap_name, Context *on_finish); + void notify_snap_remove(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, + Context *on_finish); + void notify_snap_protect(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, + Context *on_finish); + void notify_snap_unprotect(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, + Context *on_finish); void notify_rebuild_object_map(uint64_t request_id, ProgressContext &prog_ctx, Context *on_finish); void notify_rename(const std::string &image_name, Context *on_finish); diff --git a/src/librbd/Operations.cc b/src/librbd/Operations.cc index 3bfb2da29ae..c70ff6f9111 100644 --- a/src/librbd/Operations.cc +++ b/src/librbd/Operations.cc @@ -664,8 +664,8 @@ void Operations::execute_resize(uint64_t size, bool allow_shrink, ProgressCon } template -int Operations::snap_create(const char *snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace) { +int Operations::snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const char *snap_name) { if (m_image_ctx.read_only) { return -EROFS; } @@ -676,7 +676,7 @@ int Operations::snap_create(const char *snap_name, } C_SaferCond ctx; - snap_create(snap_name, snap_namespace, &ctx); + snap_create(snap_namespace, snap_name, &ctx); r = ctx.wait(); if (r < 0) { @@ -688,8 +688,8 @@ int Operations::snap_create(const char *snap_name, } template -void Operations::snap_create(const char *snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace, +void Operations::snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const char *snap_name, Context *on_finish) { CephContext *cct = m_image_ctx.cct; ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name @@ -701,7 +701,7 @@ void Operations::snap_create(const char *snap_name, } m_image_ctx.snap_lock.get_read(); - if (m_image_ctx.get_snap_id(snap_name) != CEPH_NOSNAP) { + if (m_image_ctx.get_snap_id(snap_namespace, snap_name) != CEPH_NOSNAP) { m_image_ctx.snap_lock.put_read(); on_finish->complete(-EEXIST); return; @@ -710,17 +710,17 @@ void Operations::snap_create(const char *snap_name, C_InvokeAsyncRequest *req = new C_InvokeAsyncRequest( m_image_ctx, "snap_create", true, - boost::bind(&Operations::execute_snap_create, this, snap_name, - snap_namespace, _1, 0, false), + boost::bind(&Operations::execute_snap_create, this, snap_namespace, snap_name, + _1, 0, false), boost::bind(&ImageWatcher::notify_snap_create, m_image_ctx.image_watcher, - snap_name, snap_namespace, _1), + snap_namespace, snap_name, _1), {-EEXIST}, on_finish); req->send(); } template -void Operations::execute_snap_create(const std::string &snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace, +void Operations::execute_snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish, uint64_t journal_op_tid, bool skip_object_map) { @@ -733,7 +733,7 @@ void Operations::execute_snap_create(const std::string &snap_name, << dendl; m_image_ctx.snap_lock.get_read(); - if (m_image_ctx.get_snap_id(snap_name) != CEPH_NOSNAP) { + if (m_image_ctx.get_snap_id(snap_namespace, snap_name) != CEPH_NOSNAP) { m_image_ctx.snap_lock.put_read(); on_finish->complete(-EEXIST); return; @@ -742,13 +742,14 @@ void Operations::execute_snap_create(const std::string &snap_name, operation::SnapshotCreateRequest *req = new operation::SnapshotCreateRequest( - m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_name, - snap_namespace, journal_op_tid, skip_object_map); + m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), + snap_namespace, snap_name, journal_op_tid, skip_object_map); req->send(); } template -int Operations::snap_rollback(const char *snap_name, +int Operations::snap_rollback(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name, ProgressContext& prog_ctx) { CephContext *cct = m_image_ctx.cct; ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name @@ -770,7 +771,7 @@ int Operations::snap_rollback(const char *snap_name, return -EROFS; } - uint64_t snap_id = m_image_ctx.get_snap_id(snap_name); + uint64_t snap_id = m_image_ctx.get_snap_id(snap_namespace, snap_name); if (snap_id == CEPH_NOSNAP) { lderr(cct) << "No such snapshot found." << dendl; return -ENOENT; @@ -787,7 +788,7 @@ int Operations::snap_rollback(const char *snap_name, } C_SaferCond cond_ctx; - execute_snap_rollback(snap_name, prog_ctx, &cond_ctx); + execute_snap_rollback(snap_namespace, snap_name, prog_ctx, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { return r; @@ -798,7 +799,8 @@ int Operations::snap_rollback(const char *snap_name, } template -void Operations::execute_snap_rollback(const std::string &snap_name, +void Operations::execute_snap_rollback(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, ProgressContext& prog_ctx, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); @@ -807,7 +809,7 @@ void Operations::execute_snap_rollback(const std::string &snap_name, << dendl; m_image_ctx.snap_lock.get_read(); - uint64_t snap_id = m_image_ctx.get_snap_id(snap_name); + uint64_t snap_id = m_image_ctx.get_snap_id(snap_namespace, snap_name); if (snap_id == CEPH_NOSNAP) { lderr(cct) << "No such snapshot found." << dendl; m_image_ctx.snap_lock.put_read(); @@ -821,13 +823,14 @@ void Operations::execute_snap_rollback(const std::string &snap_name, // async mode used for journal replay operation::SnapshotRollbackRequest *request = new operation::SnapshotRollbackRequest( - m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_name, + m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_namespace, snap_name, snap_id, new_size, prog_ctx); request->send(); } template -int Operations::snap_remove(const char *snap_name) { +int Operations::snap_remove(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name) { if (m_image_ctx.read_only) { return -EROFS; } @@ -838,7 +841,7 @@ int Operations::snap_remove(const char *snap_name) { } C_SaferCond ctx; - snap_remove(snap_name, &ctx); + snap_remove(snap_namespace, snap_name, &ctx); r = ctx.wait(); if (r < 0) { @@ -850,7 +853,9 @@ int Operations::snap_remove(const char *snap_name) { } template -void Operations::snap_remove(const char *snap_name, Context *on_finish) { +void Operations::snap_remove(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name, + Context *on_finish) { CephContext *cct = m_image_ctx.cct; ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name << dendl; @@ -862,7 +867,7 @@ void Operations::snap_remove(const char *snap_name, Context *on_finish) { // quickly filter out duplicate ops m_image_ctx.snap_lock.get_read(); - if (m_image_ctx.get_snap_id(snap_name) == CEPH_NOSNAP) { + if (m_image_ctx.get_snap_id(snap_namespace, snap_name) == CEPH_NOSNAP) { m_image_ctx.snap_lock.put_read(); on_finish->complete(-ENOENT); return; @@ -875,19 +880,20 @@ void Operations::snap_remove(const char *snap_name, Context *on_finish) { if (proxy_op) { C_InvokeAsyncRequest *req = new C_InvokeAsyncRequest( m_image_ctx, "snap_remove", true, - boost::bind(&Operations::execute_snap_remove, this, snap_name, _1), + boost::bind(&Operations::execute_snap_remove, this, snap_namespace, snap_name, _1), boost::bind(&ImageWatcher::notify_snap_remove, m_image_ctx.image_watcher, - snap_name, _1), + snap_namespace, snap_name, _1), {-ENOENT}, on_finish); req->send(); } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); - execute_snap_remove(snap_name, on_finish); + execute_snap_remove(snap_namespace, snap_name, on_finish); } } template -void Operations::execute_snap_remove(const std::string &snap_name, +void Operations::execute_snap_remove(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); { @@ -902,7 +908,7 @@ void Operations::execute_snap_remove(const std::string &snap_name, << dendl; m_image_ctx.snap_lock.get_read(); - uint64_t snap_id = m_image_ctx.get_snap_id(snap_name); + uint64_t snap_id = m_image_ctx.get_snap_id(snap_namespace, snap_name); if (snap_id == CEPH_NOSNAP) { lderr(m_image_ctx.cct) << "No such snapshot found." << dendl; m_image_ctx.snap_lock.put_read(); @@ -926,8 +932,8 @@ void Operations::execute_snap_remove(const std::string &snap_name, operation::SnapshotRemoveRequest *req = new operation::SnapshotRemoveRequest( - m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_name, - snap_id); + m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), + snap_namespace, snap_name, snap_id); req->send(); } @@ -949,11 +955,11 @@ int Operations::snap_rename(const char *srcname, const char *dstname) { { RWLock::RLocker l(m_image_ctx.snap_lock); - snap_id = m_image_ctx.get_snap_id(srcname); + snap_id = m_image_ctx.get_snap_id(cls::rbd::UserSnapshotNamespace(), srcname); if (snap_id == CEPH_NOSNAP) { return -ENOENT; } - if (m_image_ctx.get_snap_id(dstname) != CEPH_NOSNAP) { + if (m_image_ctx.get_snap_id(cls::rbd::UserSnapshotNamespace(), dstname) != CEPH_NOSNAP) { return -EEXIST; } } @@ -994,7 +1000,9 @@ void Operations::execute_snap_rename(const uint64_t src_snap_id, } m_image_ctx.snap_lock.get_read(); - if (m_image_ctx.get_snap_id(dest_snap_name) != CEPH_NOSNAP) { + if (m_image_ctx.get_snap_id(cls::rbd::UserSnapshotNamespace(), + dest_snap_name) != CEPH_NOSNAP) { + // Renaming is supported for snapshots from user namespace only. m_image_ctx.snap_lock.put_read(); on_finish->complete(-EEXIST); return; @@ -1014,7 +1022,8 @@ void Operations::execute_snap_rename(const uint64_t src_snap_id, } template -int Operations::snap_protect(const char *snap_name) { +int Operations::snap_protect(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name) { CephContext *cct = m_image_ctx.cct; ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name << dendl; @@ -1036,7 +1045,7 @@ int Operations::snap_protect(const char *snap_name) { { RWLock::RLocker snap_locker(m_image_ctx.snap_lock); bool is_protected; - r = m_image_ctx.is_snap_protected(m_image_ctx.get_snap_id(snap_name), + r = m_image_ctx.is_snap_protected(m_image_ctx.get_snap_id(snap_namespace, snap_name), &is_protected); if (r < 0) { return r; @@ -1050,17 +1059,17 @@ int Operations::snap_protect(const char *snap_name) { if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { r = invoke_async_request("snap_protect", true, boost::bind(&Operations::execute_snap_protect, - this, snap_name, _1), + this, snap_namespace, snap_name, _1), boost::bind(&ImageWatcher::notify_snap_protect, - m_image_ctx.image_watcher, snap_name, - _1)); + m_image_ctx.image_watcher, + snap_namespace, snap_name, _1)); if (r < 0 && r != -EBUSY) { return r; } } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); C_SaferCond cond_ctx; - execute_snap_protect(snap_name, &cond_ctx); + execute_snap_protect(snap_namespace, snap_name, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { @@ -1071,7 +1080,8 @@ int Operations::snap_protect(const char *snap_name) { } template -void Operations::execute_snap_protect(const std::string &snap_name, +void Operations::execute_snap_protect(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { @@ -1081,7 +1091,7 @@ void Operations::execute_snap_protect(const std::string &snap_name, m_image_ctx.snap_lock.get_read(); bool is_protected; - int r = m_image_ctx.is_snap_protected(m_image_ctx.get_snap_id(snap_name), + int r = m_image_ctx.is_snap_protected(m_image_ctx.get_snap_id(snap_namespace, snap_name), &is_protected); if (r < 0) { m_image_ctx.snap_lock.put_read(); @@ -1100,12 +1110,13 @@ void Operations::execute_snap_protect(const std::string &snap_name, operation::SnapshotProtectRequest *request = new operation::SnapshotProtectRequest( - m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_name); + m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_namespace, snap_name); request->send(); } template -int Operations::snap_unprotect(const char *snap_name) { +int Operations::snap_unprotect(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name) { CephContext *cct = m_image_ctx.cct; ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name << dendl; @@ -1122,7 +1133,7 @@ int Operations::snap_unprotect(const char *snap_name) { { RWLock::RLocker snap_locker(m_image_ctx.snap_lock); bool is_unprotected; - r = m_image_ctx.is_snap_unprotected(m_image_ctx.get_snap_id(snap_name), + r = m_image_ctx.is_snap_unprotected(m_image_ctx.get_snap_id(snap_namespace, snap_name), &is_unprotected); if (r < 0) { return r; @@ -1136,17 +1147,17 @@ int Operations::snap_unprotect(const char *snap_name) { if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { r = invoke_async_request("snap_unprotect", true, boost::bind(&Operations::execute_snap_unprotect, - this, snap_name, _1), + this, snap_namespace, snap_name, _1), boost::bind(&ImageWatcher::notify_snap_unprotect, - m_image_ctx.image_watcher, snap_name, - _1)); + m_image_ctx.image_watcher, + snap_namespace, snap_name, _1)); if (r < 0 && r != -EINVAL) { return r; } } else { RWLock::RLocker owner_lock(m_image_ctx.owner_lock); C_SaferCond cond_ctx; - execute_snap_unprotect(snap_name, &cond_ctx); + execute_snap_unprotect(snap_namespace, snap_name, &cond_ctx); r = cond_ctx.wait(); if (r < 0) { @@ -1157,7 +1168,8 @@ int Operations::snap_unprotect(const char *snap_name) { } template -void Operations::execute_snap_unprotect(const std::string &snap_name, +void Operations::execute_snap_unprotect(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, Context *on_finish) { assert(m_image_ctx.owner_lock.is_locked()); if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) { @@ -1167,7 +1179,7 @@ void Operations::execute_snap_unprotect(const std::string &snap_name, m_image_ctx.snap_lock.get_read(); bool is_unprotected; - int r = m_image_ctx.is_snap_unprotected(m_image_ctx.get_snap_id(snap_name), + int r = m_image_ctx.is_snap_unprotected(m_image_ctx.get_snap_id(snap_namespace, snap_name), &is_unprotected); if (r < 0) { m_image_ctx.snap_lock.put_read(); @@ -1186,7 +1198,7 @@ void Operations::execute_snap_unprotect(const std::string &snap_name, operation::SnapshotUnprotectRequest *request = new operation::SnapshotUnprotectRequest( - m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_name); + m_image_ctx, new C_NotifyUpdate(m_image_ctx, on_finish), snap_namespace, snap_name); request->send(); } diff --git a/src/librbd/Operations.h b/src/librbd/Operations.h index 673b61cc228..3ffac5c733f 100644 --- a/src/librbd/Operations.h +++ b/src/librbd/Operations.h @@ -44,34 +44,48 @@ public: void execute_resize(uint64_t size, bool allow_shrink, ProgressContext &prog_ctx, Context *on_finish, uint64_t journal_op_tid); - int snap_create(const char *snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace); - void snap_create(const char *snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace, + int snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const char *snap_name); + void snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const char *snap_name, Context *on_finish); - void execute_snap_create(const std::string &snap_name, - const cls::rbd::SnapshotNamespace &snap_namespace, + void execute_snap_create(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish, uint64_t journal_op_tid, bool skip_object_map); - int snap_rollback(const char *snap_name, ProgressContext& prog_ctx); - void execute_snap_rollback(const std::string &snap_name, + int snap_rollback(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name, + ProgressContext& prog_ctx); + void execute_snap_rollback(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, ProgressContext& prog_ctx, Context *on_finish); - int snap_remove(const char *snap_name); - void snap_remove(const char *snap_name, Context *on_finish); - void execute_snap_remove(const std::string &snap_name, Context *on_finish); + int snap_remove(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name); + void snap_remove(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name, + Context *on_finish); + void execute_snap_remove(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, + Context *on_finish); int snap_rename(const char *srcname, const char *dstname); void execute_snap_rename(const uint64_t src_snap_id, const std::string &dest_snap_name, Context *on_finish); - int snap_protect(const char *snap_name); - void execute_snap_protect(const std::string &snap_name, Context *on_finish); - - int snap_unprotect(const char *snap_name); - void execute_snap_unprotect(const std::string &snap_name, Context *on_finish); + int snap_protect(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name); + void execute_snap_protect(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, + Context *on_finish); + + int snap_unprotect(const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name); + void execute_snap_unprotect(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, + Context *on_finish); int snap_set_limit(uint64_t limit); void execute_snap_set_limit(uint64_t limit, Context *on_finish); diff --git a/src/librbd/WatchNotifyTypes.cc b/src/librbd/WatchNotifyTypes.cc index 395bfe88602..bef0b612f22 100644 --- a/src/librbd/WatchNotifyTypes.cc +++ b/src/librbd/WatchNotifyTypes.cc @@ -202,24 +202,31 @@ void ResizePayload::dump(Formatter *f) const { void SnapPayloadBase::encode(bufferlist &bl) const { ::encode(snap_name, bl); + ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl); } void SnapPayloadBase::decode(__u8 version, bufferlist::iterator &iter) { ::decode(snap_name, iter); + if (version >= 6) { + cls::rbd::SnapshotNamespaceOnDisk sn; + ::decode(sn, iter); + snap_namespace = sn.snapshot_namespace; + } } void SnapPayloadBase::dump(Formatter *f) const { f->dump_string("snap_name", snap_name); + cls::rbd::SnapshotNamespaceOnDisk sn(snap_namespace); + sn.dump(f); } void SnapCreatePayload::encode(bufferlist &bl) const { SnapPayloadBase::encode(bl); - ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl); } void SnapCreatePayload::decode(__u8 version, bufferlist::iterator &iter) { SnapPayloadBase::decode(version, iter); - if (version >= 5) { + if (version == 5) { cls::rbd::SnapshotNamespaceOnDisk sn; ::decode(sn, iter); snap_namespace = sn.snapshot_namespace; @@ -228,8 +235,6 @@ void SnapCreatePayload::decode(__u8 version, bufferlist::iterator &iter) { void SnapCreatePayload::dump(Formatter *f) const { SnapPayloadBase::dump(f); - cls::rbd::SnapshotNamespaceOnDisk sn(snap_namespace); - sn.dump(f); } void SnapRenamePayload::encode(bufferlist &bl) const { @@ -289,7 +294,7 @@ bool NotifyMessage::check_for_refresh() const { } void NotifyMessage::encode(bufferlist& bl) const { - ENCODE_START(5, 1, bl); + ENCODE_START(6, 1, bl); boost::apply_visitor(watcher::EncodePayloadVisitor(bl), payload); ENCODE_FINISH(bl); } @@ -372,11 +377,11 @@ void NotifyMessage::generate_test_instances(std::list &o) { o.push_back(new NotifyMessage(AsyncCompletePayload(AsyncRequestId(ClientId(0, 1), 2), 3))); o.push_back(new NotifyMessage(FlattenPayload(AsyncRequestId(ClientId(0, 1), 2)))); o.push_back(new NotifyMessage(ResizePayload(123, true, AsyncRequestId(ClientId(0, 1), 2)))); - o.push_back(new NotifyMessage(SnapCreatePayload("foo", - cls::rbd::UserSnapshotNamespace()))); - o.push_back(new NotifyMessage(SnapRemovePayload("foo"))); - o.push_back(new NotifyMessage(SnapProtectPayload("foo"))); - o.push_back(new NotifyMessage(SnapUnprotectPayload("foo"))); + o.push_back(new NotifyMessage(SnapCreatePayload(cls::rbd::UserSnapshotNamespace(), + "foo"))); + o.push_back(new NotifyMessage(SnapRemovePayload(cls::rbd::UserSnapshotNamespace(), "foo"))); + o.push_back(new NotifyMessage(SnapProtectPayload(cls::rbd::UserSnapshotNamespace(), "foo"))); + o.push_back(new NotifyMessage(SnapUnprotectPayload(cls::rbd::UserSnapshotNamespace(), "foo"))); o.push_back(new NotifyMessage(RebuildObjectMapPayload(AsyncRequestId(ClientId(0, 1), 2)))); o.push_back(new NotifyMessage(RenamePayload("foo"))); o.push_back(new NotifyMessage(UpdateFeaturesPayload(1, true))); diff --git a/src/librbd/WatchNotifyTypes.h b/src/librbd/WatchNotifyTypes.h index 403a9388e3c..439ae8c4151 100644 --- a/src/librbd/WatchNotifyTypes.h +++ b/src/librbd/WatchNotifyTypes.h @@ -218,6 +218,7 @@ struct SnapPayloadBase { public: static const bool CHECK_FOR_REFRESH = true; + cls::rbd::SnapshotNamespace snap_namespace; std::string snap_name; void encode(bufferlist &bl) const; @@ -226,17 +227,18 @@ public: protected: SnapPayloadBase() {} - SnapPayloadBase(const std::string &name) : snap_name(name) {} + SnapPayloadBase(const cls::rbd::SnapshotNamespace& _snap_namespace, + const std::string &name) + : snap_namespace(_snap_namespace), snap_name(name) {} }; struct SnapCreatePayload : public SnapPayloadBase { static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_CREATE; SnapCreatePayload() {} - SnapCreatePayload(const std::string &name, - const cls::rbd::SnapshotNamespace &_snap_namespace) : SnapPayloadBase(name), snap_namespace(_snap_namespace) {} - - cls::rbd::SnapshotNamespace snap_namespace; + SnapCreatePayload(const cls::rbd::SnapshotNamespace &_snap_namespace, + const std::string &name) + : SnapPayloadBase(_snap_namespace, name) {} void encode(bufferlist &bl) const; void decode(__u8 version, bufferlist::iterator &iter); @@ -247,8 +249,9 @@ struct SnapRenamePayload : public SnapPayloadBase { static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_RENAME; SnapRenamePayload() {} - SnapRenamePayload(const uint64_t &src_snap_id, const std::string &dst_name) - : SnapPayloadBase(dst_name), snap_id(src_snap_id) {} + SnapRenamePayload(const uint64_t &src_snap_id, + const std::string &dst_name) + : SnapPayloadBase(cls::rbd::UserSnapshotNamespace(), dst_name), snap_id(src_snap_id) {} uint64_t snap_id; @@ -261,21 +264,27 @@ struct SnapRemovePayload : public SnapPayloadBase { static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_REMOVE; SnapRemovePayload() {} - SnapRemovePayload(const std::string &name) : SnapPayloadBase(name) {} + SnapRemovePayload(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &name) + : SnapPayloadBase(snap_namespace, name) {} }; struct SnapProtectPayload : public SnapPayloadBase { static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_PROTECT; SnapProtectPayload() {} - SnapProtectPayload(const std::string &name) : SnapPayloadBase(name) {} + SnapProtectPayload(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &name) + : SnapPayloadBase(snap_namespace, name) {} }; struct SnapUnprotectPayload : public SnapPayloadBase { static const NotifyOp NOTIFY_OP = NOTIFY_OP_SNAP_UNPROTECT; SnapUnprotectPayload() {} - SnapUnprotectPayload(const std::string &name) : SnapPayloadBase(name) {} + SnapUnprotectPayload(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &name) + : SnapPayloadBase(snap_namespace, name) {} }; struct RebuildObjectMapPayload : public AsyncRequestPayloadBase { diff --git a/src/librbd/api/DiffIterate.cc b/src/librbd/api/DiffIterate.cc index 28b3b83eefd..04b8ba450e1 100644 --- a/src/librbd/api/DiffIterate.cc +++ b/src/librbd/api/DiffIterate.cc @@ -218,7 +218,9 @@ int simple_diff_cb(uint64_t off, size_t len, int exists, void *arg) { } // anonymous namespace template -int DiffIterate::diff_iterate(I *ictx, const char *fromsnapname, +int DiffIterate::diff_iterate(I *ictx, + const cls::rbd::SnapshotNamespace& from_snap_namespace, + const char *fromsnapname, uint64_t off, uint64_t len, bool include_parent, bool whole_object, int (*cb)(uint64_t, size_t, int, void *), @@ -245,8 +247,8 @@ int DiffIterate::diff_iterate(I *ictx, const char *fromsnapname, return r; } - DiffIterate command(*ictx, fromsnapname, off, len, include_parent, - whole_object, cb, arg); + DiffIterate command(*ictx, from_snap_namespace, fromsnapname, off, len, + include_parent, whole_object, cb, arg); r = command.execute(); return r; } @@ -265,7 +267,7 @@ int DiffIterate::execute() { RWLock::RLocker snap_locker(m_image_ctx.snap_lock); head_ctx.dup(m_image_ctx.data_ctx); if (m_from_snap_name) { - from_snap_id = m_image_ctx.get_snap_id(m_from_snap_name); + from_snap_id = m_image_ctx.get_snap_id(m_from_snap_namespace, m_from_snap_name); from_size = m_image_ctx.get_image_size(from_snap_id); } end_snap_id = m_image_ctx.snap_id; @@ -317,7 +319,8 @@ int DiffIterate::execute() { r = 0; if (m_image_ctx.parent && overlap > 0) { ldout(cct, 10) << " first getting parent diff" << dendl; - DiffIterate diff_parent(*m_image_ctx.parent, NULL, 0, overlap, + DiffIterate diff_parent(*m_image_ctx.parent, {}, + nullptr, 0, overlap, m_include_parent, m_whole_object, &simple_diff_cb, &diff_context.parent_diff); diff --git a/src/librbd/api/DiffIterate.h b/src/librbd/api/DiffIterate.h index 7790dcd6a87..e6074d9cb3d 100644 --- a/src/librbd/api/DiffIterate.h +++ b/src/librbd/api/DiffIterate.h @@ -6,6 +6,7 @@ #include "include/int_types.h" #include "common/bit_vector.hpp" +#include "cls/rbd/cls_rbd_types.h" namespace librbd { @@ -18,7 +19,9 @@ class DiffIterate { public: typedef int (*Callback)(uint64_t, size_t, int, void *); - static int diff_iterate(ImageCtxT *ictx, const char *fromsnapname, + static int diff_iterate(ImageCtxT *ictx, + const cls::rbd::SnapshotNamespace& from_snap_namespace, + const char *fromsnapname, uint64_t off, uint64_t len, bool include_parent, bool whole_object, int (*cb)(uint64_t, size_t, int, void *), @@ -26,6 +29,7 @@ public: private: ImageCtxT &m_image_ctx; + cls::rbd::SnapshotNamespace m_from_snap_namespace; const char* m_from_snap_name; uint64_t m_offset; uint64_t m_length; @@ -34,10 +38,13 @@ private: Callback m_callback; void *m_callback_arg; - DiffIterate(ImageCtxT &image_ctx, const char *from_snap_name, uint64_t off, - uint64_t len, bool include_parent, bool whole_object, - Callback callback, void *callback_arg) - : m_image_ctx(image_ctx), m_from_snap_name(from_snap_name), m_offset(off), + DiffIterate(ImageCtxT &image_ctx, + const cls::rbd::SnapshotNamespace& from_snap_namespace, + const char *from_snap_name, uint64_t off, uint64_t len, + bool include_parent, bool whole_object, Callback callback, + void *callback_arg) + : m_image_ctx(image_ctx), m_from_snap_namespace(from_snap_namespace), + m_from_snap_name(from_snap_name), m_offset(off), m_length(len), m_include_parent(include_parent), m_whole_object(whole_object), m_callback(callback), m_callback_arg(callback_arg) diff --git a/src/librbd/image/OpenRequest.cc b/src/librbd/image/OpenRequest.cc index d17d7606279..f448466eab4 100644 --- a/src/librbd/image/OpenRequest.cc +++ b/src/librbd/image/OpenRequest.cc @@ -458,7 +458,7 @@ Context *OpenRequest::send_set_snap(int *result) { using klass = OpenRequest; SetSnapRequest *req = SetSnapRequest::create( - *m_image_ctx, m_image_ctx->snap_name, + *m_image_ctx, m_image_ctx->snap_namespace, m_image_ctx->snap_name, create_context_callback(this)); req->send(); return nullptr; diff --git a/src/librbd/image/RefreshParentRequest.cc b/src/librbd/image/RefreshParentRequest.cc index 31d079b2259..3245ff11158 100644 --- a/src/librbd/image/RefreshParentRequest.cc +++ b/src/librbd/image/RefreshParentRequest.cc @@ -152,24 +152,25 @@ void RefreshParentRequest::send_set_parent_snap() { CephContext *cct = m_child_image_ctx.cct; ldout(cct, 10) << this << " " << __func__ << dendl; - int r; + cls::rbd::SnapshotNamespace snap_namespace; std::string snap_name; { RWLock::RLocker snap_locker(m_parent_image_ctx->snap_lock); - r = m_parent_image_ctx->get_snap_name(m_parent_md.spec.snap_id, &snap_name); - } - - if (r < 0) { - lderr(cct) << "failed to located snapshot: " << cpp_strerror(r) << dendl; - send_complete(r); - return; + const SnapInfo *info = m_parent_image_ctx->get_snap_info(m_parent_md.spec.snap_id); + if (!info) { + lderr(cct) << "failed to locate snapshot: Snapshot with this id not found" << dendl; + send_complete(-ENOENT); + return; + } + snap_namespace = info->snap_namespace; + snap_name = info->name; } using klass = RefreshParentRequest; Context *ctx = create_context_callback< klass, &klass::handle_set_parent_snap, false>(this); SetSnapRequest *req = SetSnapRequest::create( - *m_parent_image_ctx, snap_name, ctx); + *m_parent_image_ctx, snap_namespace, snap_name, ctx); req->send(); } diff --git a/src/librbd/image/RefreshRequest.cc b/src/librbd/image/RefreshRequest.cc index 86691b5baa7..7397b681a71 100644 --- a/src/librbd/image/RefreshRequest.cc +++ b/src/librbd/image/RefreshRequest.cc @@ -1049,13 +1049,15 @@ void RefreshRequest::apply() { parent = m_snap_parents[i]; } - m_image_ctx.add_snap(m_snap_names[i], m_snap_namespaces[i], m_snapc.snaps[i].val, - m_snap_sizes[i], parent, protection_status, flags, m_snap_timestamps[i]); + m_image_ctx.add_snap(m_snap_namespaces[i], m_snap_names[i], + m_snapc.snaps[i].val, m_snap_sizes[i], parent, + protection_status, flags, m_snap_timestamps[i]); } m_image_ctx.snapc = m_snapc; if (m_image_ctx.snap_id != CEPH_NOSNAP && - m_image_ctx.get_snap_id(m_image_ctx.snap_name) != m_image_ctx.snap_id) { + m_image_ctx.get_snap_id(m_image_ctx.snap_namespace, + m_image_ctx.snap_name) != m_image_ctx.snap_id) { lderr(cct) << "tried to read from a snapshot that no longer exists: " << m_image_ctx.snap_name << dendl; m_image_ctx.snap_exists = false; diff --git a/src/librbd/image/SetSnapRequest.cc b/src/librbd/image/SetSnapRequest.cc index 495c3adcfb3..ae7776c87c0 100644 --- a/src/librbd/image/SetSnapRequest.cc +++ b/src/librbd/image/SetSnapRequest.cc @@ -21,9 +21,11 @@ namespace image { using util::create_context_callback; template -SetSnapRequest::SetSnapRequest(I &image_ctx, const std::string &snap_name, +SetSnapRequest::SetSnapRequest(I &image_ctx, const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, Context *on_finish) - : m_image_ctx(image_ctx), m_snap_name(snap_name), m_on_finish(on_finish), + : m_image_ctx(image_ctx), m_snap_namespace(snap_namespace), + m_snap_name(snap_name), m_on_finish(on_finish), m_snap_id(CEPH_NOSNAP), m_exclusive_lock(nullptr), m_object_map(nullptr), m_refresh_parent(nullptr), m_writes_blocked(false) { } @@ -121,7 +123,7 @@ Context *SetSnapRequest::handle_block_writes(int *result) { { RWLock::RLocker snap_locker(m_image_ctx.snap_lock); - m_snap_id = m_image_ctx.get_snap_id(m_snap_name); + m_snap_id = m_image_ctx.get_snap_id(m_snap_namespace, m_snap_name); if (m_snap_id == CEPH_NOSNAP) { ldout(cct, 5) << "failed to locate snapshot '" << m_snap_name << "'" << dendl; @@ -328,7 +330,7 @@ int SetSnapRequest::apply() { RWLock::WLocker parent_locker(m_image_ctx.parent_lock); if (m_snap_id != CEPH_NOSNAP) { assert(m_image_ctx.exclusive_lock == nullptr); - int r = m_image_ctx.snap_set(m_snap_name); + int r = m_image_ctx.snap_set(m_snap_namespace, m_snap_name); if (r < 0) { return r; } diff --git a/src/librbd/image/SetSnapRequest.h b/src/librbd/image/SetSnapRequest.h index b64fa68afa0..f6f5da06860 100644 --- a/src/librbd/image/SetSnapRequest.h +++ b/src/librbd/image/SetSnapRequest.h @@ -4,6 +4,7 @@ #ifndef CEPH_LIBRBD_IMAGE_SNAP_SET_REQUEST_H #define CEPH_LIBRBD_IMAGE_SNAP_SET_REQUEST_H +#include "cls/rbd/cls_rbd_client.h" #include class Context; @@ -22,9 +23,10 @@ template class SetSnapRequest { public: static SetSnapRequest *create(ImageCtxT &image_ctx, - const std::string &snap_name, + const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, Context *on_finish) { - return new SetSnapRequest(image_ctx, snap_name, on_finish); + return new SetSnapRequest(image_ctx, snap_namespace, snap_name, on_finish); } ~SetSnapRequest(); @@ -75,10 +77,12 @@ private: * @endverbatim */ - SetSnapRequest(ImageCtxT &image_ctx, const std::string &snap_name, + SetSnapRequest(ImageCtxT &image_ctx, const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, Context *on_finish); ImageCtxT &m_image_ctx; + cls::rbd::SnapshotNamespace m_snap_namespace; std::string m_snap_name; Context *m_on_finish; diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc index 3432ae71c45..75b7afa6d0d 100644 --- a/src/librbd/internal.cc +++ b/src/librbd/internal.cc @@ -555,7 +555,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { ldout(cct, 20) << "children flatten " << ictx->name << dendl; RWLock::RLocker l(ictx->snap_lock); - snap_t snap_id = ictx->get_snap_id(snap_name); + snap_t snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), snap_name); ParentSpec parent_spec(ictx->md_ctx.get_id(), ictx->id, snap_id); map< pair, set > image_info; @@ -674,17 +674,15 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { int r = ictx->state->refresh_if_required(); if (r < 0) return r; - RWLock::RLocker l(ictx->snap_lock); - snap_t snap_id = ictx->get_snap_id(snap_name); + snap_t snap_id = ictx->get_snap_id(*snap_namespace, snap_name); if (snap_id == CEPH_NOSNAP) return -ENOENT; r = ictx->get_snap_namespace(snap_id, snap_namespace); return r; } - int snap_is_protected(ImageCtx *ictx, const char *snap_name, - bool *is_protected) + int snap_is_protected(ImageCtx *ictx, const char *snap_name, bool *is_protected) { ldout(ictx->cct, 20) << "snap_is_protected " << ictx << " " << snap_name << dendl; @@ -694,7 +692,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { return r; RWLock::RLocker l(ictx->snap_lock); - snap_t snap_id = ictx->get_snap_id(snap_name); + snap_t snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), snap_name); if (snap_id == CEPH_NOSNAP) return -ENOENT; bool is_unprotected; @@ -1503,7 +1501,8 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { return 0; } - int snap_exists(ImageCtx *ictx, const char *snap_name, bool *exists) + int snap_exists(ImageCtx *ictx, const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name, bool *exists) { ldout(ictx->cct, 20) << "snap_exists " << ictx << " " << snap_name << dendl; @@ -1512,25 +1511,17 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { return r; RWLock::RLocker l(ictx->snap_lock); - *exists = ictx->get_snap_id(snap_name) != CEPH_NOSNAP; + *exists = ictx->get_snap_id(snap_namespace, snap_name) != CEPH_NOSNAP; return 0; } - int snap_remove(ImageCtx *ictx, const char *snap_name, uint32_t flags, ProgressContext& pctx) + int snap_remove(ImageCtx *ictx, const char *snap_name, uint32_t flags, + ProgressContext& pctx) { ldout(ictx->cct, 20) << "snap_remove " << ictx << " " << snap_name << " flags: " << flags << dendl; int r = 0; - cls::rbd::SnapshotNamespace snap_namespace; - r = get_snap_namespace(ictx, snap_name, &snap_namespace); - if (r < 0) { - return r; - } - if (boost::get(&snap_namespace) == nullptr) { - return -EINVAL; - } - r = ictx->state->refresh_if_required(); if (r < 0) return r; @@ -1549,7 +1540,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { } if (is_protected && flags & RBD_SNAP_REMOVE_UNPROTECT) { - r = ictx->operations->snap_unprotect(snap_name); + r = ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), snap_name); if (r < 0) { lderr(ictx->cct) << "failed to unprotect snapshot: " << snap_name << dendl; return r; @@ -1566,7 +1557,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { } C_SaferCond ctx; - ictx->operations->snap_remove(snap_name, &ctx); + ictx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), snap_name, &ctx); r = ctx.wait(); return r; @@ -1774,7 +1765,8 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { return r; } - int snap_set(ImageCtx *ictx, const char *snap_name) + int snap_set(ImageCtx *ictx, const cls::rbd::SnapshotNamespace &snap_namespace, + const char *snap_name) { ldout(ictx->cct, 20) << "snap_set " << ictx << " snap = " << (snap_name ? snap_name : "NULL") << dendl; @@ -1785,7 +1777,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) { C_SaferCond ctx; std::string name(snap_name == nullptr ? "" : snap_name); - ictx->state->snap_set(name, &ctx); + ictx->state->snap_set(snap_namespace, name, &ctx); int r = ctx.wait(); if (r < 0) { diff --git a/src/librbd/internal.h b/src/librbd/internal.h index 65bb5a40eab..f96e05f432f 100644 --- a/src/librbd/internal.h +++ b/src/librbd/internal.h @@ -93,7 +93,8 @@ namespace librbd { void image_options_clear(rbd_image_options_t opts); bool image_options_is_empty(rbd_image_options_t opts); - int snap_set(ImageCtx *ictx, const char *snap_name); + int snap_set(ImageCtx *ictx, const cls::rbd::SnapshotNamespace &snap_namespace, + const char *snap_name); int list(librados::IoCtx& io_ctx, std::vector& names); int list_children(ImageCtx *ictx, @@ -140,14 +141,12 @@ namespace librbd { const std::string &image_id, ProgressContext& prog_ctx, bool force=false); int snap_list(ImageCtx *ictx, std::vector& snaps); - int snap_exists(ImageCtx *ictx, const char *snap_name, bool *exists); + int snap_exists(ImageCtx *ictx, const cls::rbd::SnapshotNamespace& snap_namespace, + const char *snap_name, bool *exists); int snap_get_limit(ImageCtx *ictx, uint64_t *limit); int snap_set_limit(ImageCtx *ictx, uint64_t limit); int snap_get_timestamp(ImageCtx *ictx, uint64_t snap_id, struct timespec *timestamp); int snap_remove(ImageCtx *ictx, const char *snap_name, uint32_t flags, ProgressContext& pctx); - int get_snap_namespace(ImageCtx *ictx, - const char *snap_name, - cls::rbd::SnapshotNamespace *snap_namespace); int snap_is_protected(ImageCtx *ictx, const char *snap_name, bool *is_protected); int copy(ImageCtx *ictx, IoCtx& dest_md_ctx, const char *destname, diff --git a/src/librbd/journal/Replay.cc b/src/librbd/journal/Replay.cc index c3e91081656..481f7510c53 100644 --- a/src/librbd/journal/Replay.cc +++ b/src/librbd/journal/Replay.cc @@ -38,35 +38,39 @@ struct ExecuteOp : public Context { } void execute(const journal::SnapCreateEvent &_) { - image_ctx.operations->execute_snap_create(event.snap_name, - event.snap_namespace, + image_ctx.operations->execute_snap_create(event.snap_namespace, + event.snap_name, on_op_complete, event.op_tid, false); } void execute(const journal::SnapRemoveEvent &_) { - image_ctx.operations->execute_snap_remove(event.snap_name, + image_ctx.operations->execute_snap_remove(event.snap_namespace, + event.snap_name, on_op_complete); } void execute(const journal::SnapRenameEvent &_) { image_ctx.operations->execute_snap_rename(event.snap_id, - event.snap_name, + event.dst_snap_name, on_op_complete); } void execute(const journal::SnapProtectEvent &_) { - image_ctx.operations->execute_snap_protect(event.snap_name, + image_ctx.operations->execute_snap_protect(event.snap_namespace, + event.snap_name, on_op_complete); } void execute(const journal::SnapUnprotectEvent &_) { - image_ctx.operations->execute_snap_unprotect(event.snap_name, + image_ctx.operations->execute_snap_unprotect(event.snap_namespace, + event.snap_name, on_op_complete); } void execute(const journal::SnapRollbackEvent &_) { - image_ctx.operations->execute_snap_rollback(event.snap_name, + image_ctx.operations->execute_snap_rollback(event.snap_namespace, + event.snap_name, no_op_progress_callback, on_op_complete); } diff --git a/src/librbd/journal/Types.cc b/src/librbd/journal/Types.cc index cef0dbfd130..249bc9122d2 100644 --- a/src/librbd/journal/Types.cc +++ b/src/librbd/journal/Types.cc @@ -168,26 +168,32 @@ void OpFinishEvent::dump(Formatter *f) const { void SnapEventBase::encode(bufferlist& bl) const { OpEventBase::encode(bl); ::encode(snap_name, bl); + ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl); } void SnapEventBase::decode(__u8 version, bufferlist::iterator& it) { OpEventBase::decode(version, it); ::decode(snap_name, it); + if (version >= 6) { + cls::rbd::SnapshotNamespaceOnDisk sn; + ::decode(sn, it); + snap_namespace = sn.snapshot_namespace; + } } void SnapEventBase::dump(Formatter *f) const { OpEventBase::dump(f); f->dump_string("snap_name", snap_name); + cls::rbd::SnapshotNamespaceOnDisk(snap_namespace).dump(f); } void SnapCreateEvent::encode(bufferlist &bl) const { SnapEventBase::encode(bl); - ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl); } void SnapCreateEvent::decode(__u8 version, bufferlist::iterator& it) { SnapEventBase::decode(version, it); - if (version >= 3) { + if (3 <= version && version < 6) { cls::rbd::SnapshotNamespaceOnDisk sn; ::decode(sn, it); snap_namespace = sn.snapshot_namespace; @@ -196,7 +202,6 @@ void SnapCreateEvent::decode(__u8 version, bufferlist::iterator& it) { void SnapCreateEvent::dump(Formatter *f) const { SnapEventBase::dump(f); - cls::rbd::SnapshotNamespaceOnDisk(snap_namespace).dump(f); } void SnapLimitEvent::encode(bufferlist &bl) const { @@ -215,13 +220,15 @@ void SnapLimitEvent::dump(Formatter *f) const { } void SnapRenameEvent::encode(bufferlist& bl) const { - SnapEventBase::encode(bl); + OpEventBase::encode(bl); + ::encode(dst_snap_name, bl); ::encode(snap_id, bl); ::encode(src_snap_name, bl); } void SnapRenameEvent::decode(__u8 version, bufferlist::iterator& it) { - SnapEventBase::decode(version, it); + OpEventBase::decode(version, it); + ::decode(dst_snap_name, it); ::decode(snap_id, it); if (version >= 2) { ::decode(src_snap_name, it); @@ -229,10 +236,10 @@ void SnapRenameEvent::decode(__u8 version, bufferlist::iterator& it) { } void SnapRenameEvent::dump(Formatter *f) const { - SnapEventBase::dump(f); + OpEventBase::dump(f); f->dump_unsigned("src_snap_id", snap_id); f->dump_string("src_snap_name", src_snap_name); - f->dump_string("dest_snap_name", snap_name); + f->dump_string("dest_snap_name", dst_snap_name); } void RenameEvent::encode(bufferlist& bl) const { @@ -340,7 +347,7 @@ EventType EventEntry::get_event_type() const { } void EventEntry::encode(bufferlist& bl) const { - ENCODE_START(5, 1, bl); + ENCODE_START(6, 1, bl); boost::apply_visitor(EncodeVisitor(bl), event); ENCODE_FINISH(bl); encode_metadata(bl); @@ -451,25 +458,23 @@ void EventEntry::generate_test_instances(std::list &o) { o.push_back(new EventEntry(OpFinishEvent(123, -1), utime_t(1, 1))); o.push_back(new EventEntry(SnapCreateEvent(), utime_t(1, 1))); - o.push_back(new EventEntry(SnapCreateEvent(234, "snap", - cls::rbd::UserSnapshotNamespace()), - utime_t(1, 1))); + o.push_back(new EventEntry(SnapCreateEvent(234, cls::rbd::UserSnapshotNamespace(), "snap"), utime_t(1, 1))); o.push_back(new EventEntry(SnapRemoveEvent())); - o.push_back(new EventEntry(SnapRemoveEvent(345, "snap"), utime_t(1, 1))); + o.push_back(new EventEntry(SnapRemoveEvent(345, cls::rbd::UserSnapshotNamespace(), "snap"), utime_t(1, 1))); o.push_back(new EventEntry(SnapRenameEvent())); o.push_back(new EventEntry(SnapRenameEvent(456, 1, "src snap", "dest snap"), utime_t(1, 1))); o.push_back(new EventEntry(SnapProtectEvent())); - o.push_back(new EventEntry(SnapProtectEvent(567, "snap"), utime_t(1, 1))); + o.push_back(new EventEntry(SnapProtectEvent(567, cls::rbd::UserSnapshotNamespace(), "snap"), utime_t(1, 1))); o.push_back(new EventEntry(SnapUnprotectEvent())); - o.push_back(new EventEntry(SnapUnprotectEvent(678, "snap"), utime_t(1, 1))); + o.push_back(new EventEntry(SnapUnprotectEvent(678, cls::rbd::UserSnapshotNamespace(), "snap"), utime_t(1, 1))); o.push_back(new EventEntry(SnapRollbackEvent())); - o.push_back(new EventEntry(SnapRollbackEvent(789, "snap"), utime_t(1, 1))); + o.push_back(new EventEntry(SnapRollbackEvent(789, cls::rbd::UserSnapshotNamespace(), "snap"), utime_t(1, 1))); o.push_back(new EventEntry(RenameEvent())); o.push_back(new EventEntry(RenameEvent(890, "image name"), utime_t(1, 1))); @@ -512,12 +517,18 @@ void MirrorPeerSyncPoint::encode(bufferlist& bl) const { ::encode(snap_name, bl); ::encode(from_snap_name, bl); ::encode(object_number, bl); + ::encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl); } void MirrorPeerSyncPoint::decode(__u8 version, bufferlist::iterator& it) { ::decode(snap_name, it); ::decode(from_snap_name, it); ::decode(object_number, it); + if (version >= 2) { + cls::rbd::SnapshotNamespaceOnDisk sn; + ::decode(sn, it); + snap_namespace = sn.snapshot_namespace; + } } void MirrorPeerSyncPoint::dump(Formatter *f) const { @@ -526,6 +537,7 @@ void MirrorPeerSyncPoint::dump(Formatter *f) const { if (object_number) { f->dump_unsigned("object_number", *object_number); } + cls::rbd::SnapshotNamespaceOnDisk(snap_namespace).dump(f); } void MirrorPeerClientMeta::encode(bufferlist& bl) const { @@ -603,7 +615,7 @@ ClientMetaType ClientData::get_client_meta_type() const { } void ClientData::encode(bufferlist& bl) const { - ENCODE_START(1, 1, bl); + ENCODE_START(2, 1, bl); boost::apply_visitor(EncodeVisitor(bl), client_meta); ENCODE_FINISH(bl); } @@ -643,7 +655,7 @@ void ClientData::generate_test_instances(std::list &o) { o.push_back(new ClientData(ImageClientMeta(123))); o.push_back(new ClientData(MirrorPeerClientMeta())); o.push_back(new ClientData(MirrorPeerClientMeta("image_id", - {{"snap 2", "snap 1", 123}}, + {{{}, "snap 2", "snap 1", 123}}, {{1, 2}, {3, 4}}))); o.push_back(new ClientData(CliClientMeta())); } diff --git a/src/librbd/journal/Types.h b/src/librbd/journal/Types.h index e80d82586f4..9c8057bd36a 100644 --- a/src/librbd/journal/Types.h +++ b/src/librbd/journal/Types.h @@ -140,13 +140,17 @@ struct OpFinishEvent : public OpEventBase { }; struct SnapEventBase : public OpEventBase { + cls::rbd::SnapshotNamespace snap_namespace; std::string snap_name; protected: SnapEventBase() { } - SnapEventBase(uint64_t op_tid, const std::string &_snap_name) - : OpEventBase(op_tid), snap_name(_snap_name) { + SnapEventBase(uint64_t op_tid, const cls::rbd::SnapshotNamespace& _snap_namespace, + const std::string &_snap_name) + : OpEventBase(op_tid), + snap_namespace(_snap_namespace), + snap_name(_snap_name) { } void encode(bufferlist& bl) const; @@ -156,12 +160,12 @@ protected: struct SnapCreateEvent : public SnapEventBase { static const EventType TYPE = EVENT_TYPE_SNAP_CREATE; - cls::rbd::SnapshotNamespace snap_namespace; SnapCreateEvent() { } - SnapCreateEvent(uint64_t op_tid, const std::string &snap_name, const cls::rbd::SnapshotNamespace &_snap_namespace) - : SnapEventBase(op_tid, snap_name), snap_namespace(_snap_namespace) { + SnapCreateEvent(uint64_t op_tid, const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name) + : SnapEventBase(op_tid, snap_namespace, snap_name) { } void encode(bufferlist& bl) const; @@ -174,8 +178,9 @@ struct SnapRemoveEvent : public SnapEventBase { SnapRemoveEvent() { } - SnapRemoveEvent(uint64_t op_tid, const std::string &snap_name) - : SnapEventBase(op_tid, snap_name) { + SnapRemoveEvent(uint64_t op_tid, const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name) + : SnapEventBase(op_tid, snap_namespace, snap_name) { } using SnapEventBase::encode; @@ -183,19 +188,22 @@ struct SnapRemoveEvent : public SnapEventBase { using SnapEventBase::dump; }; -struct SnapRenameEvent : public SnapEventBase { +struct SnapRenameEvent : public OpEventBase{ static const EventType TYPE = EVENT_TYPE_SNAP_RENAME; uint64_t snap_id; std::string src_snap_name; + std::string dst_snap_name; SnapRenameEvent() : snap_id(CEPH_NOSNAP) { } SnapRenameEvent(uint64_t op_tid, uint64_t src_snap_id, const std::string &src_snap_name, const std::string &dest_snap_name) - : SnapEventBase(op_tid, dest_snap_name), snap_id(src_snap_id), - src_snap_name(src_snap_name) { + : OpEventBase(op_tid), + snap_id(src_snap_id), + src_snap_name(src_snap_name), + dst_snap_name(dest_snap_name) { } void encode(bufferlist& bl) const; @@ -208,8 +216,9 @@ struct SnapProtectEvent : public SnapEventBase { SnapProtectEvent() { } - SnapProtectEvent(uint64_t op_tid, const std::string &snap_name) - : SnapEventBase(op_tid, snap_name) { + SnapProtectEvent(uint64_t op_tid, const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name) + : SnapEventBase(op_tid, snap_namespace, snap_name) { } using SnapEventBase::encode; @@ -222,8 +231,9 @@ struct SnapUnprotectEvent : public SnapEventBase { SnapUnprotectEvent() { } - SnapUnprotectEvent(uint64_t op_tid, const std::string &snap_name) - : SnapEventBase(op_tid, snap_name) { + SnapUnprotectEvent(uint64_t op_tid, const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name) + : SnapEventBase(op_tid, snap_namespace, snap_name) { } using SnapEventBase::encode; @@ -251,8 +261,9 @@ struct SnapRollbackEvent : public SnapEventBase { SnapRollbackEvent() { } - SnapRollbackEvent(uint64_t op_tid, const std::string &snap_name) - : SnapEventBase(op_tid, snap_name) { + SnapRollbackEvent(uint64_t op_tid, const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name) + : SnapEventBase(op_tid, snap_namespace, snap_name) { } using SnapEventBase::encode; @@ -449,27 +460,31 @@ struct ImageClientMeta { struct MirrorPeerSyncPoint { typedef boost::optional ObjectNumber; + cls::rbd::SnapshotNamespace snap_namespace; std::string snap_name; std::string from_snap_name; ObjectNumber object_number; - MirrorPeerSyncPoint() : MirrorPeerSyncPoint("", "", boost::none) { + MirrorPeerSyncPoint() : MirrorPeerSyncPoint({}, "", "", boost::none) { } - MirrorPeerSyncPoint(const std::string &snap_name, + MirrorPeerSyncPoint(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, const ObjectNumber &object_number) - : MirrorPeerSyncPoint(snap_name, "", object_number) { + : MirrorPeerSyncPoint(snap_namespace, snap_name, "", object_number) { } - MirrorPeerSyncPoint(const std::string &snap_name, + MirrorPeerSyncPoint(const cls::rbd::SnapshotNamespace& snap_namespace, + const std::string &snap_name, const std::string &from_snap_name, const ObjectNumber &object_number) - : snap_name(snap_name), from_snap_name(from_snap_name), - object_number(object_number) { + : snap_namespace(snap_namespace), snap_name(snap_name), + from_snap_name(from_snap_name), object_number(object_number) { } inline bool operator==(const MirrorPeerSyncPoint &sync) const { return (snap_name == sync.snap_name && from_snap_name == sync.from_snap_name && - object_number == sync.object_number); + object_number == sync.object_number && + snap_namespace == sync.snap_namespace); } void encode(bufferlist& bl) const; diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc index 92704f65138..8e379aca3b6 100644 --- a/src/librbd/librbd.cc +++ b/src/librbd/librbd.cc @@ -1105,8 +1105,8 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, snap_create_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = ictx->operations->snap_create(snap_name, - cls::rbd::UserSnapshotNamespace()); + int r = ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name); tracepoint(librbd, snap_create_exit, r); return r; } @@ -1135,7 +1135,7 @@ namespace librbd { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); librbd::NoOpProgressContext prog_ctx; - int r = ictx->operations->snap_rollback(snap_name, prog_ctx); + int r = ictx->operations->snap_rollback(cls::rbd::UserSnapshotNamespace(), snap_name, prog_ctx); tracepoint(librbd, snap_rollback_exit, r); return r; } @@ -1154,7 +1154,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = ictx->operations->snap_rollback(snap_name, prog_ctx); + int r = ictx->operations->snap_rollback(cls::rbd::UserSnapshotNamespace(), snap_name, prog_ctx); tracepoint(librbd, snap_rollback_exit, r); return r; } @@ -1163,7 +1163,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, snap_protect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = ictx->operations->snap_protect(snap_name); + int r = ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), snap_name); tracepoint(librbd, snap_protect_exit, r); return r; } @@ -1172,7 +1172,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, snap_unprotect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = ictx->operations->snap_unprotect(snap_name); + int r = ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), snap_name); tracepoint(librbd, snap_unprotect_exit, r); return r; } @@ -1212,7 +1212,7 @@ namespace librbd { tracepoint(librbd, snap_exists_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); bool exists; - int r = librbd::snap_exists(ictx, snap_name, &exists); + int r = librbd::snap_exists(ictx, cls::rbd::UserSnapshotNamespace(), snap_name, &exists); tracepoint(librbd, snap_exists_exit, r, exists); if (r < 0) { // lie to caller since we don't know the real answer yet. @@ -1227,7 +1227,7 @@ namespace librbd { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, snap_exists_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = librbd::snap_exists(ictx, snap_name, exists); + int r = librbd::snap_exists(ictx, cls::rbd::UserSnapshotNamespace(), snap_name, exists); tracepoint(librbd, snap_exists_exit, r, *exists); return r; } @@ -1264,7 +1264,7 @@ namespace librbd { { ImageCtx *ictx = (ImageCtx *)ctx; tracepoint(librbd, snap_set_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = librbd::snap_set(ictx, snap_name); + int r = librbd::snap_set(ictx, cls::rbd::UserSnapshotNamespace(), snap_name); tracepoint(librbd, snap_set_exit, r); return r; } @@ -1325,7 +1325,9 @@ namespace librbd { tracepoint(librbd, diff_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, fromsnapname, ofs, len, true, false); - int r = librbd::api::DiffIterate<>::diff_iterate(ictx, fromsnapname, ofs, + int r = librbd::api::DiffIterate<>::diff_iterate(ictx, + cls::rbd::UserSnapshotNamespace(), + fromsnapname, ofs, len, true, false, cb, arg); tracepoint(librbd, diff_iterate_exit, r); return r; @@ -1339,7 +1341,9 @@ namespace librbd { tracepoint(librbd, diff_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, fromsnapname, ofs, len, include_parent, whole_object); - int r = librbd::api::DiffIterate<>::diff_iterate(ictx, fromsnapname, ofs, + int r = librbd::api::DiffIterate<>::diff_iterate(ictx, + cls::rbd::UserSnapshotNamespace(), + fromsnapname, ofs, len, include_parent, whole_object, cb, arg); tracepoint(librbd, diff_iterate_exit, r); @@ -2573,8 +2577,8 @@ extern "C" int rbd_snap_create(rbd_image_t image, const char *snap_name) { librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, snap_create_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = ictx->operations->snap_create(snap_name, - cls::rbd::UserSnapshotNamespace()); + int r = ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name); tracepoint(librbd, snap_create_exit, r); return r; } @@ -2614,7 +2618,7 @@ extern "C" int rbd_snap_rollback(rbd_image_t image, const char *snap_name) librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); librbd::NoOpProgressContext prog_ctx; - int r = ictx->operations->snap_rollback(snap_name, prog_ctx); + int r = ictx->operations->snap_rollback(cls::rbd::UserSnapshotNamespace(), snap_name, prog_ctx); tracepoint(librbd, snap_rollback_exit, r); return r; } @@ -2627,7 +2631,7 @@ extern "C" int rbd_snap_rollback_with_progress(rbd_image_t image, librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, snap_rollback_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); librbd::CProgressContext prog_ctx(cb, cbdata); - int r = ictx->operations->snap_rollback(snap_name, prog_ctx); + int r = ictx->operations->snap_rollback(cls::rbd::UserSnapshotNamespace(), snap_name, prog_ctx); tracepoint(librbd, snap_rollback_exit, r); return r; } @@ -2696,7 +2700,7 @@ extern "C" int rbd_snap_protect(rbd_image_t image, const char *snap_name) { librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, snap_protect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = ictx->operations->snap_protect(snap_name); + int r = ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), snap_name); tracepoint(librbd, snap_protect_exit, r); return r; } @@ -2705,7 +2709,7 @@ extern "C" int rbd_snap_unprotect(rbd_image_t image, const char *snap_name) { librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, snap_unprotect_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = ictx->operations->snap_unprotect(snap_name); + int r = ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), snap_name); tracepoint(librbd, snap_unprotect_exit, r); return r; } @@ -2757,7 +2761,7 @@ extern "C" int rbd_snap_set(rbd_image_t image, const char *snap_name) { librbd::ImageCtx *ictx = (librbd::ImageCtx *)image; tracepoint(librbd, snap_set_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, snap_name); - int r = librbd::snap_set(ictx, snap_name); + int r = librbd::snap_set(ictx, cls::rbd::UserSnapshotNamespace(), snap_name); tracepoint(librbd, snap_set_exit, r); return r; } @@ -2978,7 +2982,9 @@ extern "C" int rbd_diff_iterate(rbd_image_t image, tracepoint(librbd, diff_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, fromsnapname, ofs, len, true, false); - int r = librbd::api::DiffIterate<>::diff_iterate(ictx, fromsnapname, ofs, len, + int r = librbd::api::DiffIterate<>::diff_iterate(ictx, + cls::rbd::UserSnapshotNamespace(), + fromsnapname, ofs, len, true, false, cb, arg); tracepoint(librbd, diff_iterate_exit, r); return r; @@ -2994,7 +3000,9 @@ extern "C" int rbd_diff_iterate2(rbd_image_t image, const char *fromsnapname, tracepoint(librbd, diff_iterate_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, fromsnapname, ofs, len, include_parent != 0, whole_object != 0); - int r = librbd::api::DiffIterate<>::diff_iterate(ictx, fromsnapname, ofs, len, + int r = librbd::api::DiffIterate<>::diff_iterate(ictx, + cls::rbd::UserSnapshotNamespace(), + fromsnapname, ofs, len, include_parent, whole_object, cb, arg); tracepoint(librbd, diff_iterate_exit, r); diff --git a/src/librbd/mirror/DisableRequest.cc b/src/librbd/mirror/DisableRequest.cc index 48a6326088e..bcbff06a452 100644 --- a/src/librbd/mirror/DisableRequest.cc +++ b/src/librbd/mirror/DisableRequest.cc @@ -273,7 +273,7 @@ Context *DisableRequest::handle_get_clients(int *result) { boost::get(client_data.client_meta); for (const auto& sync : client_meta.sync_points) { - send_remove_snap(client.id, sync.snap_name); + send_remove_snap(client.id, sync.snap_namespace, sync.snap_name); } if (m_current_ops[client.id] == 0) { @@ -299,7 +299,8 @@ Context *DisableRequest::handle_get_clients(int *result) { template void DisableRequest::send_remove_snap(const std::string &client_id, - const std::string &snap_name) { + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name) { CephContext *cct = m_image_ctx->cct; ldout(cct, 10) << this << " " << __func__ << ": client_id=" << client_id << ", snap_name=" << snap_name << dendl; @@ -311,9 +312,11 @@ void DisableRequest::send_remove_snap(const std::string &client_id, Context *ctx = create_context_callback( &DisableRequest::handle_remove_snap, client_id); - ctx = new FunctionContext([this, snap_name, ctx](int r) { + ctx = new FunctionContext([this, snap_namespace, snap_name, ctx](int r) { RWLock::WLocker owner_locker(m_image_ctx->owner_lock); - m_image_ctx->operations->execute_snap_remove(snap_name.c_str(), ctx); + m_image_ctx->operations->execute_snap_remove(snap_namespace, + snap_name.c_str(), + ctx); }); m_image_ctx->op_work_queue->queue(ctx, 0); diff --git a/src/librbd/mirror/DisableRequest.h b/src/librbd/mirror/DisableRequest.h index 99cf04af904..1a3b122339c 100644 --- a/src/librbd/mirror/DisableRequest.h +++ b/src/librbd/mirror/DisableRequest.h @@ -113,7 +113,8 @@ private: Context *handle_get_clients(int *result); void send_remove_snap(const std::string &client_id, - const std::string &snap_name); + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name); Context *handle_remove_snap(int *result, const std::string &client_id); void send_unregister_client(const std::string &client_id); diff --git a/src/librbd/operation/SnapshotCreateRequest.cc b/src/librbd/operation/SnapshotCreateRequest.cc index bc0dffe2123..d332d870c15 100644 --- a/src/librbd/operation/SnapshotCreateRequest.cc +++ b/src/librbd/operation/SnapshotCreateRequest.cc @@ -25,12 +25,12 @@ using util::create_rados_callback; template SnapshotCreateRequest::SnapshotCreateRequest(I &image_ctx, Context *on_finish, - const std::string &snap_name, const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, uint64_t journal_op_tid, bool skip_object_map) - : Request(image_ctx, on_finish, journal_op_tid), m_snap_name(snap_name), - m_snap_namespace(snap_namespace), + : Request(image_ctx, on_finish, journal_op_tid), + m_snap_namespace(snap_namespace), m_snap_name(snap_name), m_skip_object_map(skip_object_map), m_ret_val(0), m_snap_id(CEPH_NOSNAP) { } @@ -295,8 +295,9 @@ void SnapshotCreateRequest::update_snap_context() { // immediately add a reference to the new snapshot utime_t snap_time = ceph_clock_now(); - image_ctx.add_snap(m_snap_name, m_snap_namespace, m_snap_id, m_size, m_parent_info, - RBD_PROTECTION_STATUS_UNPROTECTED, 0, snap_time); + image_ctx.add_snap(m_snap_namespace, m_snap_name, m_snap_id, m_size, + m_parent_info, RBD_PROTECTION_STATUS_UNPROTECTED, + 0, snap_time); // immediately start using the new snap context if we // own the exclusive lock diff --git a/src/librbd/operation/SnapshotCreateRequest.h b/src/librbd/operation/SnapshotCreateRequest.h index b0f5f06428a..571916000f2 100644 --- a/src/librbd/operation/SnapshotCreateRequest.h +++ b/src/librbd/operation/SnapshotCreateRequest.h @@ -60,8 +60,8 @@ public: * (if enabled) and bubble the originating error code back to the client. */ SnapshotCreateRequest(ImageCtxT &image_ctx, Context *on_finish, - const std::string &snap_name, const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, uint64_t journal_op_tid, bool skip_object_map); @@ -74,12 +74,12 @@ protected: return true; } journal::Event create_event(uint64_t op_tid) const override { - return journal::SnapCreateEvent(op_tid, m_snap_name, m_snap_namespace); + return journal::SnapCreateEvent(op_tid, m_snap_namespace, m_snap_name); } private: - std::string m_snap_name; cls::rbd::SnapshotNamespace m_snap_namespace; + std::string m_snap_name; bool m_skip_object_map; int m_ret_val; diff --git a/src/librbd/operation/SnapshotProtectRequest.cc b/src/librbd/operation/SnapshotProtectRequest.cc index 409d9983c40..199432196ef 100644 --- a/src/librbd/operation/SnapshotProtectRequest.cc +++ b/src/librbd/operation/SnapshotProtectRequest.cc @@ -31,8 +31,9 @@ std::ostream& operator<<(std::ostream& os, template SnapshotProtectRequest::SnapshotProtectRequest(I &image_ctx, Context *on_finish, - const std::string &snap_name) - : Request(image_ctx, on_finish), m_snap_name(snap_name) { + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name) + : Request(image_ctx, on_finish), m_snap_namespace(snap_namespace), m_snap_name(snap_name) { } template @@ -85,7 +86,7 @@ int SnapshotProtectRequest::verify_and_send_protect_snap() { return -ENOSYS; } - uint64_t snap_id = image_ctx.get_snap_id(m_snap_name); + uint64_t snap_id = image_ctx.get_snap_id(m_snap_namespace, m_snap_name); if (snap_id == CEPH_NOSNAP) { return -ENOENT; } diff --git a/src/librbd/operation/SnapshotProtectRequest.h b/src/librbd/operation/SnapshotProtectRequest.h index 764da65da0c..bef80229af6 100644 --- a/src/librbd/operation/SnapshotProtectRequest.h +++ b/src/librbd/operation/SnapshotProtectRequest.h @@ -39,17 +39,19 @@ public: }; SnapshotProtectRequest(ImageCtxT &image_ctx, Context *on_finish, - const std::string &snap_name); + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name); protected: void send_op() override; bool should_complete(int r) override; journal::Event create_event(uint64_t op_tid) const override { - return journal::SnapProtectEvent(op_tid, m_snap_name); + return journal::SnapProtectEvent(op_tid, m_snap_namespace, m_snap_name); } private: + cls::rbd::SnapshotNamespace m_snap_namespace; std::string m_snap_name; State m_state; diff --git a/src/librbd/operation/SnapshotRemoveRequest.cc b/src/librbd/operation/SnapshotRemoveRequest.cc index 70bbf60e3d9..4cbfc03b0d4 100644 --- a/src/librbd/operation/SnapshotRemoveRequest.cc +++ b/src/librbd/operation/SnapshotRemoveRequest.cc @@ -48,10 +48,11 @@ std::ostream& operator<<(std::ostream& os, template SnapshotRemoveRequest::SnapshotRemoveRequest(I &image_ctx, Context *on_finish, + const cls::rbd::SnapshotNamespace &snap_namespace, const std::string &snap_name, uint64_t snap_id) - : Request(image_ctx, on_finish), m_snap_name(snap_name), - m_snap_id(snap_id) { + : Request(image_ctx, on_finish), m_snap_namespace(snap_namespace), + m_snap_name(snap_name), m_snap_id(snap_id) { } template @@ -214,7 +215,7 @@ void SnapshotRemoveRequest::remove_snap_context() { ldout(cct, 5) << this << " " << __func__ << dendl; RWLock::WLocker snap_locker(image_ctx.snap_lock); - image_ctx.rm_snap(m_snap_name, m_snap_id); + image_ctx.rm_snap(m_snap_namespace, m_snap_name, m_snap_id); } template diff --git a/src/librbd/operation/SnapshotRemoveRequest.h b/src/librbd/operation/SnapshotRemoveRequest.h index a3f1d0ed62b..0f4331ee255 100644 --- a/src/librbd/operation/SnapshotRemoveRequest.h +++ b/src/librbd/operation/SnapshotRemoveRequest.h @@ -57,17 +57,20 @@ public: }; SnapshotRemoveRequest(ImageCtxT &image_ctx, Context *on_finish, - const std::string &snap_name, uint64_t snap_id); + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, + uint64_t snap_id); protected: void send_op() override; bool should_complete(int r) override; journal::Event create_event(uint64_t op_tid) const override { - return journal::SnapRemoveEvent(op_tid, m_snap_name); + return journal::SnapRemoveEvent(op_tid, m_snap_namespace, m_snap_name); } private: + cls::rbd::SnapshotNamespace m_snap_namespace; std::string m_snap_name; uint64_t m_snap_id; State m_state; diff --git a/src/librbd/operation/SnapshotRollbackRequest.cc b/src/librbd/operation/SnapshotRollbackRequest.cc index 27af771ea9a..2dcffbc0189 100644 --- a/src/librbd/operation/SnapshotRollbackRequest.cc +++ b/src/librbd/operation/SnapshotRollbackRequest.cc @@ -64,13 +64,14 @@ private: template SnapshotRollbackRequest::SnapshotRollbackRequest(I &image_ctx, Context *on_finish, + const cls::rbd::SnapshotNamespace &snap_namespace, const std::string &snap_name, uint64_t snap_id, uint64_t snap_size, ProgressContext &prog_ctx) - : Request(image_ctx, on_finish), m_snap_name(snap_name), - m_snap_id(snap_id), m_snap_size(snap_size), m_prog_ctx(prog_ctx), - m_object_map(nullptr) { + : Request(image_ctx, on_finish), m_snap_namespace(snap_namespace), + m_snap_name(snap_name), m_snap_id(snap_id), + m_snap_size(snap_size), m_prog_ctx(prog_ctx), m_object_map(nullptr) { } template diff --git a/src/librbd/operation/SnapshotRollbackRequest.h b/src/librbd/operation/SnapshotRollbackRequest.h index 5d1cb69e85c..a32a84dc27b 100644 --- a/src/librbd/operation/SnapshotRollbackRequest.h +++ b/src/librbd/operation/SnapshotRollbackRequest.h @@ -57,7 +57,9 @@ public: */ SnapshotRollbackRequest(ImageCtxT &image_ctx, Context *on_finish, - const std::string &snap_name, uint64_t snap_id, + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, + uint64_t snap_id, uint64_t snap_size, ProgressContext &prog_ctx); ~SnapshotRollbackRequest() override; @@ -68,10 +70,11 @@ protected: } journal::Event create_event(uint64_t op_tid) const override { - return journal::SnapRollbackEvent(op_tid, m_snap_name); + return journal::SnapRollbackEvent(op_tid, m_snap_namespace, m_snap_name); } private: + cls::rbd::SnapshotNamespace m_snap_namespace; std::string m_snap_name; uint64_t m_snap_id; uint64_t m_snap_size; diff --git a/src/librbd/operation/SnapshotUnprotectRequest.cc b/src/librbd/operation/SnapshotUnprotectRequest.cc index 944b7b9e18b..369d8e283a1 100644 --- a/src/librbd/operation/SnapshotUnprotectRequest.cc +++ b/src/librbd/operation/SnapshotUnprotectRequest.cc @@ -152,9 +152,10 @@ private: template SnapshotUnprotectRequest::SnapshotUnprotectRequest(I &image_ctx, Context *on_finish, - const std::string &snap_name) - : Request(image_ctx, on_finish), m_snap_name(snap_name), m_ret_val(0), - m_snap_id(CEPH_NOSNAP) { + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name) + : Request(image_ctx, on_finish), m_snap_namespace(snap_namespace), + m_snap_name(snap_name), m_ret_val(0), m_snap_id(CEPH_NOSNAP) { } template @@ -319,7 +320,7 @@ int SnapshotUnprotectRequest::verify_and_send_unprotect_snap_start() { return -ENOSYS; } - m_snap_id = image_ctx.get_snap_id(m_snap_name); + m_snap_id = image_ctx.get_snap_id(m_snap_namespace, m_snap_name); if (m_snap_id == CEPH_NOSNAP) { return -ENOENT; } diff --git a/src/librbd/operation/SnapshotUnprotectRequest.h b/src/librbd/operation/SnapshotUnprotectRequest.h index 7930592f57e..19cc6d32b77 100644 --- a/src/librbd/operation/SnapshotUnprotectRequest.h +++ b/src/librbd/operation/SnapshotUnprotectRequest.h @@ -50,7 +50,8 @@ public: }; SnapshotUnprotectRequest(ImageCtxT &image_ctx, Context *on_finish, - const std::string &snap_name); + const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name); protected: void send_op() override; @@ -64,10 +65,11 @@ protected: } journal::Event create_event(uint64_t op_tid) const override { - return journal::SnapUnprotectEvent(op_tid, m_snap_name); + return journal::SnapUnprotectEvent(op_tid, m_snap_namespace, m_snap_name); } private: + cls::rbd::SnapshotNamespace m_snap_namespace; std::string m_snap_name; State m_state; diff --git a/src/test/librbd/image/test_mock_RefreshRequest.cc b/src/test/librbd/image/test_mock_RefreshRequest.cc index d5454785fd4..858e98e197c 100644 --- a/src/test/librbd/image/test_mock_RefreshRequest.cc +++ b/src/test/librbd/image/test_mock_RefreshRequest.cc @@ -224,7 +224,7 @@ public: void expect_add_snap(MockRefreshImageCtx &mock_image_ctx, const std::string &snap_name, uint64_t snap_id) { - EXPECT_CALL(mock_image_ctx, add_snap(snap_name, _, snap_id, _, _, _, _, _)); + EXPECT_CALL(mock_image_ctx, add_snap(_, snap_name, snap_id, _, _, _, _, _)); } void expect_init_exclusive_lock(MockRefreshImageCtx &mock_image_ctx, @@ -324,8 +324,10 @@ public: } void expect_get_snap_id(MockRefreshImageCtx &mock_image_ctx, - const std::string &snap_name, uint64_t snap_id) { - EXPECT_CALL(mock_image_ctx, get_snap_id(snap_name)).WillOnce(Return(snap_id)); + const std::string &snap_name, + uint64_t snap_id) { + EXPECT_CALL(mock_image_ctx, + get_snap_id(_, snap_name)).WillOnce(Return(snap_id)); } void expect_block_writes(MockImageCtx &mock_image_ctx, int r) { @@ -456,7 +458,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessSetSnapshotV2) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, snap_create(*ictx, "snap")); - ASSERT_EQ(0, librbd::snap_set(ictx, "snap")); + ASSERT_EQ(0, librbd::snap_set(ictx, cls::rbd::UserSnapshotNamespace(), "snap")); MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; @@ -503,7 +505,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessChild) { librbd::NoOpProgressContext no_op; ASSERT_EQ(0, librbd::remove(m_ioctx, clone_name, "", no_op)); - ASSERT_EQ(0, ictx->operations->snap_unprotect("snap")); + ASSERT_EQ(0, ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), "snap")); }; int order = ictx->order; @@ -554,7 +556,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessChildDontOpenParent) { librbd::NoOpProgressContext no_op; ASSERT_EQ(0, librbd::remove(m_ioctx, clone_name, "", no_op)); - ASSERT_EQ(0, ictx->operations->snap_unprotect("snap")); + ASSERT_EQ(0, ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), "snap")); }; int order = ictx->order; diff --git a/src/test/librbd/journal/test_Replay.cc b/src/test/librbd/journal/test_Replay.cc index abdbbf99aa9..7c735695b8e 100644 --- a/src/test/librbd/journal/test_Replay.cc +++ b/src/test/librbd/journal/test_Replay.cc @@ -309,8 +309,8 @@ TEST_F(TestJournalReplay, SnapCreate) { get_journal_commit_position(ictx, &initial_tag, &initial_entry); // inject snapshot ops into journal - inject_into_journal(ictx, librbd::journal::SnapCreateEvent(1, "snap", - cls::rbd::UserSnapshotNamespace())); + inject_into_journal(ictx, librbd::journal::SnapCreateEvent(1, cls::rbd::UserSnapshotNamespace(), + "snap")); inject_into_journal(ictx, librbd::journal::OpFinishEvent(1, 0)); close_image(ictx); @@ -326,12 +326,13 @@ TEST_F(TestJournalReplay, SnapCreate) { { RWLock::RLocker snap_locker(ictx->snap_lock); - ASSERT_NE(CEPH_NOSNAP, ictx->get_snap_id("snap")); + ASSERT_NE(CEPH_NOSNAP, ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), + "snap")); } // verify lock ordering constraints - ASSERT_EQ(0, ictx->operations->snap_create("snap2", - cls::rbd::UserSnapshotNamespace())); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap2")); } TEST_F(TestJournalReplay, SnapProtect) { @@ -342,8 +343,8 @@ TEST_F(TestJournalReplay, SnapProtect) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, when_acquired_lock(ictx)); - ASSERT_EQ(0, ictx->operations->snap_create("snap", - cls::rbd::UserSnapshotNamespace())); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap")); // get current commit position int64_t initial_tag; @@ -351,7 +352,10 @@ TEST_F(TestJournalReplay, SnapProtect) { get_journal_commit_position(ictx, &initial_tag, &initial_entry); // inject snapshot ops into journal - inject_into_journal(ictx, librbd::journal::SnapProtectEvent(1, "snap")); + inject_into_journal(ictx, + librbd::journal::SnapProtectEvent(1, + cls::rbd::UserSnapshotNamespace(), + "snap")); inject_into_journal(ictx, librbd::journal::OpFinishEvent(1, 0)); close_image(ictx); @@ -370,9 +374,10 @@ TEST_F(TestJournalReplay, SnapProtect) { ASSERT_TRUE(is_protected); // verify lock ordering constraints - ASSERT_EQ(0, ictx->operations->snap_create("snap2", - cls::rbd::UserSnapshotNamespace())); - ASSERT_EQ(0, ictx->operations->snap_protect("snap2")); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap2")); + ASSERT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap2")); } TEST_F(TestJournalReplay, SnapUnprotect) { @@ -383,15 +388,16 @@ TEST_F(TestJournalReplay, SnapUnprotect) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, when_acquired_lock(ictx)); - ASSERT_EQ(0, ictx->operations->snap_create("snap", - cls::rbd::UserSnapshotNamespace())); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap")); uint64_t snap_id; { RWLock::RLocker snap_locker(ictx->snap_lock); - snap_id = ictx->get_snap_id("snap"); + snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap"); ASSERT_NE(CEPH_NOSNAP, snap_id); } - ASSERT_EQ(0, ictx->operations->snap_protect("snap")); + ASSERT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap")); // get current commit position int64_t initial_tag; @@ -399,7 +405,10 @@ TEST_F(TestJournalReplay, SnapUnprotect) { get_journal_commit_position(ictx, &initial_tag, &initial_entry); // inject snapshot ops into journal - inject_into_journal(ictx, librbd::journal::SnapUnprotectEvent(1, "snap")); + inject_into_journal(ictx, + librbd::journal::SnapUnprotectEvent(1, + cls::rbd::UserSnapshotNamespace(), + "snap")); inject_into_journal(ictx, librbd::journal::OpFinishEvent(1, 0)); close_image(ictx); @@ -418,10 +427,12 @@ TEST_F(TestJournalReplay, SnapUnprotect) { ASSERT_FALSE(is_protected); // verify lock ordering constraints - ASSERT_EQ(0, ictx->operations->snap_create("snap2", - cls::rbd::UserSnapshotNamespace())); - ASSERT_EQ(0, ictx->operations->snap_protect("snap2")); - ASSERT_EQ(0, ictx->operations->snap_unprotect("snap2")); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap2")); + ASSERT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap2")); + ASSERT_EQ(0, ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), + "snap2")); } TEST_F(TestJournalReplay, SnapRename) { @@ -432,12 +443,12 @@ TEST_F(TestJournalReplay, SnapRename) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, when_acquired_lock(ictx)); - ASSERT_EQ(0, ictx->operations->snap_create("snap", - cls::rbd::UserSnapshotNamespace())); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap")); uint64_t snap_id; { RWLock::RLocker snap_locker(ictx->snap_lock); - snap_id = ictx->get_snap_id("snap"); + snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap"); ASSERT_NE(CEPH_NOSNAP, snap_id); } @@ -465,7 +476,7 @@ TEST_F(TestJournalReplay, SnapRename) { { RWLock::RLocker snap_locker(ictx->snap_lock); - snap_id = ictx->get_snap_id("snap2"); + snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap2"); ASSERT_NE(CEPH_NOSNAP, snap_id); } @@ -481,8 +492,8 @@ TEST_F(TestJournalReplay, SnapRollback) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, when_acquired_lock(ictx)); - ASSERT_EQ(0, ictx->operations->snap_create("snap", - cls::rbd::UserSnapshotNamespace())); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap")); // get current commit position int64_t initial_tag; @@ -490,7 +501,10 @@ TEST_F(TestJournalReplay, SnapRollback) { get_journal_commit_position(ictx, &initial_tag, &initial_entry); // inject snapshot ops into journal - inject_into_journal(ictx, librbd::journal::SnapRollbackEvent(1, "snap")); + inject_into_journal(ictx, + librbd::journal::SnapRollbackEvent(1, + cls::rbd::UserSnapshotNamespace(), + "snap")); inject_into_journal(ictx, librbd::journal::OpFinishEvent(1, 0)); close_image(ictx); @@ -506,7 +520,9 @@ TEST_F(TestJournalReplay, SnapRollback) { // verify lock ordering constraints librbd::NoOpProgressContext no_op_progress; - ASSERT_EQ(0, ictx->operations->snap_rollback("snap", no_op_progress)); + ASSERT_EQ(0, ictx->operations->snap_rollback(cls::rbd::UserSnapshotNamespace(), + "snap", + no_op_progress)); } TEST_F(TestJournalReplay, SnapRemove) { @@ -517,8 +533,8 @@ TEST_F(TestJournalReplay, SnapRemove) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, when_acquired_lock(ictx)); - ASSERT_EQ(0, ictx->operations->snap_create("snap", - cls::rbd::UserSnapshotNamespace())); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap")); // get current commit position int64_t initial_tag; @@ -526,7 +542,10 @@ TEST_F(TestJournalReplay, SnapRemove) { get_journal_commit_position(ictx, &initial_tag, &initial_entry); // inject snapshot ops into journal - inject_into_journal(ictx, librbd::journal::SnapRemoveEvent(1, "snap")); + inject_into_journal(ictx, + librbd::journal::SnapRemoveEvent(1, + cls::rbd::UserSnapshotNamespace(), + "snap")); inject_into_journal(ictx, librbd::journal::OpFinishEvent(1, 0)); close_image(ictx); @@ -542,14 +561,16 @@ TEST_F(TestJournalReplay, SnapRemove) { { RWLock::RLocker snap_locker(ictx->snap_lock); - uint64_t snap_id = ictx->get_snap_id("snap"); + uint64_t snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), + "snap"); ASSERT_EQ(CEPH_NOSNAP, snap_id); } // verify lock ordering constraints - ASSERT_EQ(0, ictx->operations->snap_create("snap", - cls::rbd::UserSnapshotNamespace())); - ASSERT_EQ(0, ictx->operations->snap_remove("snap")); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap")); + ASSERT_EQ(0, ictx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), + "snap")); } TEST_F(TestJournalReplay, Rename) { @@ -624,9 +645,10 @@ TEST_F(TestJournalReplay, Flatten) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - ASSERT_EQ(0, ictx->operations->snap_create("snap", - cls::rbd::UserSnapshotNamespace())); - ASSERT_EQ(0, ictx->operations->snap_protect("snap")); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap")); + ASSERT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap")); std::string clone_name = get_temp_image_name(); int order = ictx->order; @@ -656,7 +678,8 @@ TEST_F(TestJournalReplay, Flatten) { get_journal_commit_position(ictx2, ¤t_tag, ¤t_entry); ASSERT_EQ(initial_tag + 1, current_tag); ASSERT_EQ(1, current_entry); - ASSERT_EQ(0, ictx->operations->snap_unprotect("snap")); + ASSERT_EQ(0, ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), + "snap")); // verify lock ordering constraints librbd::NoOpProgressContext no_op; diff --git a/src/test/librbd/journal/test_mock_Replay.cc b/src/test/librbd/journal/test_mock_Replay.cc index 62fc57e178e..aade74c1205 100644 --- a/src/test/librbd/journal/test_mock_Replay.cc +++ b/src/test/librbd/journal/test_mock_Replay.cc @@ -183,7 +183,7 @@ public: void expect_snap_create(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name, uint64_t op_tid) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_create(StrEq(snap_name), _, _, + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_create(_, StrEq(snap_name), _, op_tid, false)) .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); @@ -191,8 +191,8 @@ public: void expect_snap_remove(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(StrEq(snap_name), _)) - .WillOnce(DoAll(SaveArg<1>(on_finish), + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(_, StrEq(snap_name), _)) + .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } @@ -206,22 +206,22 @@ public: void expect_snap_protect(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_protect(StrEq(snap_name), _)) - .WillOnce(DoAll(SaveArg<1>(on_finish), + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_protect(_, StrEq(snap_name), _)) + .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_snap_unprotect(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_unprotect(StrEq(snap_name), _)) - .WillOnce(DoAll(SaveArg<1>(on_finish), + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_unprotect(_, StrEq(snap_name), _)) + .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } void expect_snap_rollback(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_rollback(StrEq(snap_name), _, _)) - .WillOnce(DoAll(SaveArg<2>(on_finish), + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_rollback(_, StrEq(snap_name), _, _)) + .WillOnce(DoAll(SaveArg<3>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } @@ -582,8 +582,12 @@ TEST_F(TestMockJournalReplay, OpFinishError) { InSequence seq; C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapRemoveEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapRemoveEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -613,9 +617,12 @@ TEST_F(TestMockJournalReplay, BlockedOpFinishError) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapCreateEvent(123, "snap", - cls::rbd::UserSnapshotNamespace())}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapCreateEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); C_SaferCond on_resume; when_replay_op_ready(mock_journal_replay, 123, &on_resume); @@ -654,15 +661,22 @@ TEST_F(TestMockJournalReplay, MissingOpFinishEvent) { C_SaferCond on_snap_remove_ready; C_SaferCond on_snap_remove_safe; - when_process(mock_journal_replay, EventEntry{SnapRemoveEvent(122, "snap")}, - &on_snap_remove_ready, &on_snap_remove_safe); + when_process(mock_journal_replay, + EventEntry{SnapRemoveEvent(122, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_snap_remove_ready, + &on_snap_remove_safe); ASSERT_EQ(0, on_snap_remove_ready.wait()); C_SaferCond on_snap_create_ready; C_SaferCond on_snap_create_safe; - when_process(mock_journal_replay, EventEntry{SnapCreateEvent(123, "snap", - cls::rbd::UserSnapshotNamespace())}, - &on_snap_create_ready, &on_snap_create_safe); + when_process(mock_journal_replay, + EventEntry{SnapCreateEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_snap_create_ready, + &on_snap_create_safe); C_SaferCond on_shut_down; mock_journal_replay.shut_down(false, &on_shut_down); @@ -696,14 +710,22 @@ TEST_F(TestMockJournalReplay, MissingOpFinishEventCancelOps) { C_SaferCond on_snap_remove_ready; C_SaferCond on_snap_remove_safe; - when_process(mock_journal_replay, EventEntry{SnapRemoveEvent(122, "snap")}, - &on_snap_remove_ready, &on_snap_remove_safe); + when_process(mock_journal_replay, + EventEntry{SnapRemoveEvent(122, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_snap_remove_ready, + &on_snap_remove_safe); ASSERT_EQ(0, on_snap_remove_ready.wait()); C_SaferCond on_snap_create_ready; C_SaferCond on_snap_create_safe; - when_process(mock_journal_replay, EventEntry{SnapCreateEvent(123, "snap", cls::rbd::UserSnapshotNamespace())}, - &on_snap_create_ready, &on_snap_create_safe); + when_process(mock_journal_replay, + EventEntry{SnapCreateEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_snap_create_ready, + &on_snap_create_safe); C_SaferCond on_resume; when_replay_op_ready(mock_journal_replay, 123, &on_resume); @@ -755,8 +777,12 @@ TEST_F(TestMockJournalReplay, OpEventError) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapRemoveEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapRemoveEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -787,8 +813,12 @@ TEST_F(TestMockJournalReplay, SnapCreateEvent) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapCreateEvent(123, "snap", cls::rbd::UserSnapshotNamespace())}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapCreateEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); C_SaferCond on_resume; when_replay_op_ready(mock_journal_replay, 123, &on_resume); @@ -824,8 +854,12 @@ TEST_F(TestMockJournalReplay, SnapCreateEventExists) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapCreateEvent(123, "snap", cls::rbd::UserSnapshotNamespace())}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapCreateEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); wait_for_op_invoked(&on_finish, -EEXIST); ASSERT_EQ(0, on_start_ready.wait()); @@ -857,8 +891,12 @@ TEST_F(TestMockJournalReplay, SnapRemoveEvent) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapRemoveEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapRemoveEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -889,8 +927,12 @@ TEST_F(TestMockJournalReplay, SnapRemoveEventDNE) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapRemoveEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapRemoveEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -987,8 +1029,12 @@ TEST_F(TestMockJournalReplay, SnapProtectEvent) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapProtectEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapProtectEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -1019,8 +1065,12 @@ TEST_F(TestMockJournalReplay, SnapProtectEventBusy) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapProtectEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapProtectEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -1051,8 +1101,12 @@ TEST_F(TestMockJournalReplay, SnapUnprotectEvent) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapUnprotectEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapUnprotectEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -1079,8 +1133,12 @@ TEST_F(TestMockJournalReplay, SnapUnprotectOpFinishBusy) { InSequence seq; C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapUnprotectEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapUnprotectEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); // aborts the snap unprotect op if image had children @@ -1111,8 +1169,12 @@ TEST_F(TestMockJournalReplay, SnapUnprotectEventInvalid) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapUnprotectEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapUnprotectEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; @@ -1143,8 +1205,12 @@ TEST_F(TestMockJournalReplay, SnapRollbackEvent) { C_SaferCond on_start_ready; C_SaferCond on_start_safe; - when_process(mock_journal_replay, EventEntry{SnapRollbackEvent(123, "snap")}, - &on_start_ready, &on_start_safe); + when_process(mock_journal_replay, + EventEntry{SnapRollbackEvent(123, + cls::rbd::UserSnapshotNamespace(), + "snap")}, + &on_start_ready, + &on_start_safe); ASSERT_EQ(0, on_start_ready.wait()); C_SaferCond on_finish_ready; diff --git a/src/test/librbd/mirror/test_mock_DisableRequest.cc b/src/test/librbd/mirror/test_mock_DisableRequest.cc index 1ab8c93e639..6334e9b4f13 100644 --- a/src/test/librbd/mirror/test_mock_DisableRequest.cc +++ b/src/test/librbd/mirror/test_mock_DisableRequest.cc @@ -192,8 +192,8 @@ public: void expect_snap_remove(MockTestImageCtx &mock_image_ctx, const std::string &snap_name, int r) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(StrEq(snap_name), _)) - .WillOnce(WithArg<1>(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue))); + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(_, StrEq(snap_name), _)) + .WillOnce(WithArg<2>(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue))); } template @@ -233,8 +233,8 @@ TEST_F(TestMockMirrorDisableRequest, Success) { {"", encode(journal::ClientData{journal::ImageClientMeta{}})}, {"peer 1", encode(journal::ClientData{journal::MirrorPeerClientMeta{}})}, {"peer 2", encode(journal::ClientData{journal::MirrorPeerClientMeta{ - "remote image id", {{"snap 1", boost::optional(0)}, - {"snap 2", boost::optional(0)}}} + "remote image id", {{cls::rbd::UserSnapshotNamespace(), "snap 1", boost::optional(0)}, + {cls::rbd::UserSnapshotNamespace(), "snap 2", boost::optional(0)}}} })} }, 0); expect_journal_client_unregister(mock_image_ctx, "peer 1", 0); @@ -493,8 +493,8 @@ TEST_F(TestMockMirrorDisableRequest, SnapRemoveError) { {"", encode(journal::ClientData{journal::ImageClientMeta{}})}, {"peer 1", encode(journal::ClientData{journal::MirrorPeerClientMeta{}})}, {"peer 2", encode(journal::ClientData{journal::MirrorPeerClientMeta{ - "remote image id", {{"snap 1", boost::optional(0)}, - {"snap 2", boost::optional(0)}}} + "remote image id", {{cls::rbd::UserSnapshotNamespace(), "snap 1", boost::optional(0)}, + {cls::rbd::UserSnapshotNamespace(), "snap 2", boost::optional(0)}}} })} }, 0); expect_journal_client_unregister(mock_image_ctx, "peer 1", 0); @@ -533,8 +533,8 @@ TEST_F(TestMockMirrorDisableRequest, JournalClientUnregisterError) { {"", encode(journal::ClientData{journal::ImageClientMeta{}})}, {"peer 1", encode(journal::ClientData{journal::MirrorPeerClientMeta{}})}, {"peer 2", encode(journal::ClientData{journal::MirrorPeerClientMeta{ - "remote image id", {{"snap 1", boost::optional(0)}, - {"snap 2", boost::optional(0)}}} + "remote image id", {{cls::rbd::UserSnapshotNamespace(), "snap 1", boost::optional(0)}, + {cls::rbd::UserSnapshotNamespace(), "snap 2", boost::optional(0)}}} })} }, 0); expect_journal_client_unregister(mock_image_ctx, "peer 1", -EINVAL); diff --git a/src/test/librbd/mock/MockImageCtx.h b/src/test/librbd/mock/MockImageCtx.h index 61ca316515c..e7147a2cfe6 100644 --- a/src/test/librbd/mock/MockImageCtx.h +++ b/src/test/librbd/mock/MockImageCtx.h @@ -42,6 +42,7 @@ struct MockImageCtx { : image_ctx(&image_ctx), cct(image_ctx.cct), perfcounter(image_ctx.perfcounter), + snap_namespace(image_ctx.snap_namespace), snap_name(image_ctx.snap_name), snap_id(image_ctx.snap_id), snap_exists(image_ctx.snap_exists), @@ -142,7 +143,9 @@ struct MockImageCtx { MOCK_CONST_METHOD0(get_current_size, uint64_t()); MOCK_CONST_METHOD1(get_image_size, uint64_t(librados::snap_t)); MOCK_CONST_METHOD1(get_object_count, uint64_t(librados::snap_t)); - MOCK_CONST_METHOD1(get_snap_id, librados::snap_t(std::string in_snap_name)); + MOCK_CONST_METHOD2(get_snap_id, + librados::snap_t(cls::rbd::SnapshotNamespace snap_namespace, + std::string in_snap_name)); MOCK_CONST_METHOD1(get_snap_info, const SnapInfo*(librados::snap_t)); MOCK_CONST_METHOD2(get_snap_namespace, int(librados::snap_t, cls::rbd::SnapshotNamespace *out_snap_namespace)); @@ -154,12 +157,14 @@ struct MockImageCtx { MOCK_CONST_METHOD2(is_snap_unprotected, int(librados::snap_t in_snap_id, bool *is_unprotected)); - MOCK_METHOD8(add_snap, void(std::string in_snap_name, - cls::rbd::SnapshotNamespace in_snap_namespace, + MOCK_METHOD8(add_snap, void(cls::rbd::SnapshotNamespace in_snap_namespace, + std::string in_snap_name, librados::snap_t id, uint64_t in_size, const ParentInfo &parent, uint8_t protection_status, uint64_t flags, utime_t timestamp)); - MOCK_METHOD2(rm_snap, void(std::string in_snap_name, librados::snap_t id)); + MOCK_METHOD3(rm_snap, void(cls::rbd::SnapshotNamespace in_snap_namespace, + std::string in_snap_name, + librados::snap_t id)); MOCK_METHOD0(user_flushed, void()); MOCK_METHOD1(flush, void(Context *)); @@ -196,6 +201,7 @@ struct MockImageCtx { CephContext *cct; PerfCounters *perfcounter; + cls::rbd::SnapshotNamespace snap_namespace; std::string snap_name; uint64_t snap_id; bool snap_exists; @@ -203,7 +209,7 @@ struct MockImageCtx { ::SnapContext snapc; std::vector snaps; std::map snap_info; - std::map snap_ids; + std::map, librados::snap_t> snap_ids; ObjectCacher *object_cacher; ObjectCacher::ObjectSet *object_set; diff --git a/src/test/librbd/mock/MockImageState.h b/src/test/librbd/mock/MockImageState.h index afea67af877..2ec53adafc0 100644 --- a/src/test/librbd/mock/MockImageState.h +++ b/src/test/librbd/mock/MockImageState.h @@ -6,6 +6,8 @@ #include +#include "cls/rbd/cls_rbd_types.h" + class Context; namespace librbd { @@ -19,7 +21,7 @@ struct MockImageState { MOCK_METHOD0(close, int()); MOCK_METHOD1(close, void(Context*)); - MOCK_METHOD2(snap_set, void(const std::string &, Context*)); + MOCK_METHOD3(snap_set, void(const cls::rbd::SnapshotNamespace &, const std::string &, Context*)); MOCK_METHOD1(prepare_lock, void(Context*)); MOCK_METHOD0(handle_prepare_lock_complete, void()); diff --git a/src/test/librbd/mock/MockOperations.h b/src/test/librbd/mock/MockOperations.h index 3c536d98fce..49876d197c5 100644 --- a/src/test/librbd/mock/MockOperations.h +++ b/src/test/librbd/mock/MockOperations.h @@ -25,27 +25,32 @@ struct MockOperations { ProgressContext &prog_ctx, Context *on_finish, uint64_t journal_op_tid)); - MOCK_METHOD3(snap_create, void(const std::string &snap_name, - const cls::rbd::SnapshotNamespace &snapshot_namespace, + MOCK_METHOD3(snap_create, void(const cls::rbd::SnapshotNamespace &snapshot_namespace, + const std::string &snap_name, Context *on_finish)); - MOCK_METHOD5(execute_snap_create, void(const std::string &snap_name, - const cls::rbd::SnapshotNamespace &snapshot_namespace, + MOCK_METHOD5(execute_snap_create, void(const cls::rbd::SnapshotNamespace &snapshot_namespace, + const std::string &snap_name, Context *on_finish, uint64_t journal_op_tid, bool skip_object_map)); - MOCK_METHOD2(snap_remove, void(const std::string &snap_name, + MOCK_METHOD3(snap_remove, void(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish)); - MOCK_METHOD2(execute_snap_remove, void(const std::string &snap_name, + MOCK_METHOD3(execute_snap_remove, void(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish)); MOCK_METHOD3(execute_snap_rename, void(uint64_t src_snap_id, const std::string &snap_name, Context *on_finish)); - MOCK_METHOD3(execute_snap_rollback, void(const std::string &snap_name, + MOCK_METHOD4(execute_snap_rollback, void(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, ProgressContext &prog_ctx, Context *on_finish)); - MOCK_METHOD2(execute_snap_protect, void(const std::string &snap_name, + MOCK_METHOD3(execute_snap_protect, void(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish)); - MOCK_METHOD2(execute_snap_unprotect, void(const std::string &snap_name, + MOCK_METHOD3(execute_snap_unprotect, void(const cls::rbd::SnapshotNamespace &snap_namespace, + const std::string &snap_name, Context *on_finish)); MOCK_METHOD2(execute_snap_set_limit, void(uint64_t limit, Context *on_finish)); diff --git a/src/test/librbd/object_map/test_mock_InvalidateRequest.cc b/src/test/librbd/object_map/test_mock_InvalidateRequest.cc index e85357a4451..275d0de8053 100644 --- a/src/test/librbd/object_map/test_mock_InvalidateRequest.cc +++ b/src/test/librbd/object_map/test_mock_InvalidateRequest.cc @@ -76,7 +76,9 @@ TEST_F(TestMockObjectMapInvalidateRequest, UpdatesSnapOnDiskFlag) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, snap_create(*ictx, "snap1")); - ASSERT_EQ(0, librbd::snap_set(ictx, "snap1")); + ASSERT_EQ(0, librbd::snap_set(ictx, + cls::rbd::UserSnapshotNamespace(), + "snap1")); C_SaferCond cond_ctx; AsyncRequest<> *request = new InvalidateRequest<>(*ictx, ictx->snap_id, false, diff --git a/src/test/librbd/object_map/test_mock_ResizeRequest.cc b/src/test/librbd/object_map/test_mock_ResizeRequest.cc index 479d24662b7..de5aa8af67a 100644 --- a/src/test/librbd/object_map/test_mock_ResizeRequest.cc +++ b/src/test/librbd/object_map/test_mock_ResizeRequest.cc @@ -98,7 +98,9 @@ TEST_F(TestMockObjectMapResizeRequest, UpdateSnapOnDisk) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, snap_create(*ictx, "snap1")); - ASSERT_EQ(0, librbd::snap_set(ictx, "snap1")); + ASSERT_EQ(0, librbd::snap_set(ictx, + cls::rbd::UserSnapshotNamespace(), + "snap1")); uint64_t snap_id = ictx->snap_id; expect_resize(ictx, snap_id, 0); diff --git a/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc b/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc index 7280aef4da8..6aa8d142796 100644 --- a/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc +++ b/src/test/librbd/object_map/test_mock_SnapshotCreateRequest.cc @@ -25,8 +25,7 @@ public: void inject_snap_info(librbd::ImageCtx *ictx, uint64_t snap_id) { RWLock::WLocker snap_locker(ictx->snap_lock); RWLock::RLocker parent_locker(ictx->parent_lock); - ictx->add_snap("snap name", - cls::rbd::UserSnapshotNamespace(), snap_id, + ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "snap name", snap_id, ictx->size, ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED, 0, utime_t()); } diff --git a/src/test/librbd/object_map/test_mock_UpdateRequest.cc b/src/test/librbd/object_map/test_mock_UpdateRequest.cc index 6e677410cec..ea40404d39b 100644 --- a/src/test/librbd/object_map/test_mock_UpdateRequest.cc +++ b/src/test/librbd/object_map/test_mock_UpdateRequest.cc @@ -117,7 +117,9 @@ TEST_F(TestMockObjectMapUpdateRequest, UpdateSnapOnDisk) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, snap_create(*ictx, "snap1")); - ASSERT_EQ(0, librbd::snap_set(ictx, "snap1")); + ASSERT_EQ(0, librbd::snap_set(ictx, + cls::rbd::UserSnapshotNamespace(), + "snap1")); uint64_t snap_id = ictx->snap_id; expect_update(ictx, snap_id, 0); diff --git a/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc b/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc index 3fce272a6bd..845c36fde88 100644 --- a/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc +++ b/src/test/librbd/operation/test_mock_SnapshotCreateRequest.cc @@ -89,7 +89,7 @@ public: // state machine checks to ensure a refresh hasn't already added the snap EXPECT_CALL(mock_image_ctx, get_snap_info(_)) .WillOnce(Return(static_cast(NULL))); - EXPECT_CALL(mock_image_ctx, add_snap("snap1", _, _, _, _, _, _, _)); + EXPECT_CALL(mock_image_ctx, add_snap(_, "snap1", _, _, _, _, _, _)); } void expect_unblock_writes(MockImageCtx &mock_image_ctx) { @@ -132,8 +132,8 @@ TEST_F(TestMockOperationSnapshotCreateRequest, Success) { C_SaferCond cond_ctx; MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest( - mock_image_ctx, &cond_ctx, "snap1", - cls::rbd::UserSnapshotNamespace(), 0, false); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), + "snap1", 0, false); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -162,8 +162,8 @@ TEST_F(TestMockOperationSnapshotCreateRequest, AllocateSnapIdError) { C_SaferCond cond_ctx; MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest( - mock_image_ctx, &cond_ctx, "snap1", - cls::rbd::UserSnapshotNamespace(), 0, false); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), + "snap1", 0, false); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -201,8 +201,8 @@ TEST_F(TestMockOperationSnapshotCreateRequest, CreateSnapStale) { C_SaferCond cond_ctx; MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest( - mock_image_ctx, &cond_ctx, "snap1", - cls::rbd::UserSnapshotNamespace(), 0, false); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), + "snap1", 0, false); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -232,8 +232,8 @@ TEST_F(TestMockOperationSnapshotCreateRequest, CreateSnapError) { C_SaferCond cond_ctx; MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest( - mock_image_ctx, &cond_ctx, "snap1", - cls::rbd::UserSnapshotNamespace(), 0, false); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), + "snap1", 0, false); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -263,8 +263,8 @@ TEST_F(TestMockOperationSnapshotCreateRequest, ReleaseSnapIdError) { C_SaferCond cond_ctx; MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest( - mock_image_ctx, &cond_ctx, "snap1", - cls::rbd::UserSnapshotNamespace(), 0, false); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), + "snap1", 0, false); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -300,8 +300,8 @@ TEST_F(TestMockOperationSnapshotCreateRequest, SkipObjectMap) { C_SaferCond cond_ctx; MockSnapshotCreateRequest *req = new MockSnapshotCreateRequest( - mock_image_ctx, &cond_ctx, "snap1", - cls::rbd::UserSnapshotNamespace(), 0, true); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), + "snap1", 0, true); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); diff --git a/src/test/librbd/operation/test_mock_SnapshotProtectRequest.cc b/src/test/librbd/operation/test_mock_SnapshotProtectRequest.cc index 23f27ed2d66..c583f03a91f 100644 --- a/src/test/librbd/operation/test_mock_SnapshotProtectRequest.cc +++ b/src/test/librbd/operation/test_mock_SnapshotProtectRequest.cc @@ -31,7 +31,7 @@ public: typedef SnapshotProtectRequest MockSnapshotProtectRequest; void expect_get_snap_id(MockImageCtx &mock_image_ctx, uint64_t snap_id) { - EXPECT_CALL(mock_image_ctx, get_snap_id(_)) + EXPECT_CALL(mock_image_ctx, get_snap_id(_, _)) .WillOnce(Return(snap_id)); } @@ -76,7 +76,7 @@ TEST_F(TestMockOperationSnapshotProtectRequest, Success) { C_SaferCond cond_ctx; MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -101,7 +101,7 @@ TEST_F(TestMockOperationSnapshotProtectRequest, GetSnapIdMissing) { C_SaferCond cond_ctx; MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -127,7 +127,7 @@ TEST_F(TestMockOperationSnapshotProtectRequest, IsSnapProtectedError) { C_SaferCond cond_ctx; MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -153,7 +153,7 @@ TEST_F(TestMockOperationSnapshotProtectRequest, SnapAlreadyProtected) { C_SaferCond cond_ctx; MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -180,7 +180,7 @@ TEST_F(TestMockOperationSnapshotProtectRequest, SetProtectionStateError) { C_SaferCond cond_ctx; MockSnapshotProtectRequest *req = new MockSnapshotProtectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); diff --git a/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc b/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc index 3209859dd98..3f5fe186865 100644 --- a/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc +++ b/src/test/librbd/operation/test_mock_SnapshotRemoveRequest.cc @@ -106,7 +106,7 @@ public: } void expect_rm_snap(MockImageCtx &mock_image_ctx) { - EXPECT_CALL(mock_image_ctx, rm_snap(_, _)).Times(1); + EXPECT_CALL(mock_image_ctx, rm_snap(_, _, _)).Times(1); } void expect_release_snap_id(MockImageCtx &mock_image_ctx) { @@ -148,7 +148,8 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, Success) { C_SaferCond cond_ctx; MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest( - mock_image_ctx, &cond_ctx, "snap1", snap_id); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1", + snap_id); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -201,7 +202,8 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, FlattenedCloneRemovesChild) { C_SaferCond cond_ctx; MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest( - mock_image_ctx, &cond_ctx, "snap1", snap_id); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1", + snap_id); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -232,7 +234,8 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, ObjectMapSnapRemoveError) { C_SaferCond cond_ctx; MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest( - mock_image_ctx, &cond_ctx, "snap1", snap_id); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1", + snap_id); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -262,7 +265,8 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, RemoveChildParentError) { C_SaferCond cond_ctx; MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest( - mock_image_ctx, &cond_ctx, "snap1", snap_id); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1", + snap_id); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -311,7 +315,8 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, RemoveChildError) { C_SaferCond cond_ctx; MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest( - mock_image_ctx, &cond_ctx, "snap1", snap_id); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1", + snap_id); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -348,7 +353,8 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, RemoveSnapError) { C_SaferCond cond_ctx; MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest( - mock_image_ctx, &cond_ctx, "snap1", snap_id); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1", + snap_id); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -379,7 +385,8 @@ TEST_F(TestMockOperationSnapshotRemoveRequest, MissingSnap) { C_SaferCond cond_ctx; MockSnapshotRemoveRequest *req = new MockSnapshotRemoveRequest( - mock_image_ctx, &cond_ctx, "snap1", snap_id); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1", + snap_id); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); diff --git a/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc b/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc index a65206c42b9..1f8b4addf05 100644 --- a/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc +++ b/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc @@ -176,7 +176,8 @@ public: C_SaferCond cond_ctx; librbd::NoOpProgressContext prog_ctx; MockSnapshotRollbackRequest *req = new MockSnapshotRollbackRequest( - mock_image_ctx, &cond_ctx, snap_name, snap_id, snap_size, prog_ctx); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), snap_name, + snap_id, snap_size, prog_ctx); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); diff --git a/src/test/librbd/operation/test_mock_SnapshotUnprotectRequest.cc b/src/test/librbd/operation/test_mock_SnapshotUnprotectRequest.cc index 5e74a67a303..e1b4d69f93d 100644 --- a/src/test/librbd/operation/test_mock_SnapshotUnprotectRequest.cc +++ b/src/test/librbd/operation/test_mock_SnapshotUnprotectRequest.cc @@ -34,7 +34,7 @@ public: typedef SnapshotUnprotectRequest MockSnapshotUnprotectRequest; void expect_get_snap_id(MockImageCtx &mock_image_ctx, uint64_t snap_id) { - EXPECT_CALL(mock_image_ctx, get_snap_id(_)) + EXPECT_CALL(mock_image_ctx, get_snap_id(_, _)) .WillOnce(Return(snap_id)); } @@ -126,7 +126,7 @@ TEST_F(TestMockOperationSnapshotUnprotectRequest, Success) { C_SaferCond cond_ctx; MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -151,7 +151,7 @@ TEST_F(TestMockOperationSnapshotUnprotectRequest, GetSnapIdMissing) { C_SaferCond cond_ctx; MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -177,7 +177,7 @@ TEST_F(TestMockOperationSnapshotUnprotectRequest, IsSnapUnprotectedError) { C_SaferCond cond_ctx; MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -203,7 +203,7 @@ TEST_F(TestMockOperationSnapshotUnprotectRequest, SnapAlreadyUnprotected) { C_SaferCond cond_ctx; MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -232,7 +232,7 @@ TEST_F(TestMockOperationSnapshotUnprotectRequest, SetProtectionStatusError) { C_SaferCond cond_ctx; MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); @@ -265,7 +265,7 @@ TEST_F(TestMockOperationSnapshotUnprotectRequest, ChildrenExist) { C_SaferCond cond_ctx; MockSnapshotUnprotectRequest *req = new MockSnapshotUnprotectRequest( - mock_image_ctx, &cond_ctx, "snap1"); + mock_image_ctx, &cond_ctx, cls::rbd::UserSnapshotNamespace(), "snap1"); { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); req->send(); diff --git a/src/test/librbd/test_ImageWatcher.cc b/src/test/librbd/test_ImageWatcher.cc index 24d420898ad..6232154fa37 100644 --- a/src/test/librbd/test_ImageWatcher.cc +++ b/src/test/librbd/test_ImageWatcher.cc @@ -430,8 +430,8 @@ TEST_F(TestImageWatcher, NotifySnapCreate) { RWLock::RLocker l(ictx->owner_lock); C_SaferCond notify_ctx; - ictx->image_watcher->notify_snap_create("snap", - cls::rbd::UserSnapshotNamespace(), ¬ify_ctx); + ictx->image_watcher->notify_snap_create(cls::rbd::UserSnapshotNamespace(), + "snap", ¬ify_ctx); ASSERT_EQ(0, notify_ctx.wait()); NotifyOps expected_notify_ops; @@ -453,8 +453,8 @@ TEST_F(TestImageWatcher, NotifySnapCreateError) { RWLock::RLocker l(ictx->owner_lock); C_SaferCond notify_ctx; - ictx->image_watcher->notify_snap_create("snap", - cls::rbd::UserSnapshotNamespace(), ¬ify_ctx); + ictx->image_watcher->notify_snap_create(cls::rbd::UserSnapshotNamespace(), + "snap", ¬ify_ctx); ASSERT_EQ(-EEXIST, notify_ctx.wait()); NotifyOps expected_notify_ops; @@ -520,7 +520,9 @@ TEST_F(TestImageWatcher, NotifySnapRemove) { RWLock::RLocker l(ictx->owner_lock); C_SaferCond notify_ctx; - ictx->image_watcher->notify_snap_remove("snap", ¬ify_ctx); + ictx->image_watcher->notify_snap_remove(cls::rbd::UserSnapshotNamespace(), + "snap", + ¬ify_ctx); ASSERT_EQ(0, notify_ctx.wait()); NotifyOps expected_notify_ops; @@ -542,7 +544,9 @@ TEST_F(TestImageWatcher, NotifySnapProtect) { RWLock::RLocker l(ictx->owner_lock); C_SaferCond notify_ctx; - ictx->image_watcher->notify_snap_protect("snap", ¬ify_ctx); + ictx->image_watcher->notify_snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap", + ¬ify_ctx); ASSERT_EQ(0, notify_ctx.wait()); NotifyOps expected_notify_ops; @@ -564,7 +568,9 @@ TEST_F(TestImageWatcher, NotifySnapUnprotect) { RWLock::RLocker l(ictx->owner_lock); C_SaferCond notify_ctx; - ictx->image_watcher->notify_snap_unprotect("snap", ¬ify_ctx); + ictx->image_watcher->notify_snap_unprotect(cls::rbd::UserSnapshotNamespace(), + "snap", + ¬ify_ctx); ASSERT_EQ(0, notify_ctx.wait()); NotifyOps expected_notify_ops; diff --git a/src/test/librbd/test_fixture.cc b/src/test/librbd/test_fixture.cc index 73a66f43083..139c9987575 100644 --- a/src/test/librbd/test_fixture.cc +++ b/src/test/librbd/test_fixture.cc @@ -83,13 +83,14 @@ int TestFixture::open_image(const std::string &image_name, int TestFixture::snap_create(librbd::ImageCtx &ictx, const std::string &snap_name) { - return ictx.operations->snap_create(snap_name.c_str(), - cls::rbd::UserSnapshotNamespace()); + return ictx.operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str()); } int TestFixture::snap_protect(librbd::ImageCtx &ictx, const std::string &snap_name) { - return ictx.operations->snap_protect(snap_name.c_str()); + return ictx.operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str()); } int TestFixture::flatten(librbd::ImageCtx &ictx, diff --git a/src/test/librbd/test_internal.cc b/src/test/librbd/test_internal.cc index ed247a3a225..5b4f1d68162 100644 --- a/src/test/librbd/test_internal.cc +++ b/src/test/librbd/test_internal.cc @@ -37,9 +37,13 @@ public: librbd::ImageCtx *ictx; EXPECT_EQ(0, open_image(m_image_name, &ictx)); if (iter->second) { - EXPECT_EQ(0, ictx->operations->snap_unprotect(iter->first.c_str())); + EXPECT_EQ(0, + ictx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), + iter->first.c_str())); } - EXPECT_EQ(0, ictx->operations->snap_remove(iter->first.c_str())); + EXPECT_EQ(0, + ictx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), + iter->first.c_str())); } TestFixture::TearDown(); @@ -59,7 +63,7 @@ public: m_snaps.push_back(std::make_pair(snap_name, snap_protect)); if (snap_protect) { - r = ictx->operations->snap_protect(snap_name); + r = ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), snap_name); if (r < 0) { return r; } @@ -189,7 +193,9 @@ TEST_F(TestInternal, SnapCreateLocksImage) { ASSERT_EQ(0, snap_create(*ictx, "snap1")); BOOST_SCOPE_EXIT( (ictx) ) { - ASSERT_EQ(0, ictx->operations->snap_remove("snap1")); + ASSERT_EQ(0, + ictx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), + "snap1")); } BOOST_SCOPE_EXIT_END; bool is_owner; @@ -216,7 +222,9 @@ TEST_F(TestInternal, SnapRollbackLocksImage) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); librbd::NoOpProgressContext no_op; - ASSERT_EQ(0, ictx->operations->snap_rollback("snap1", no_op)); + ASSERT_EQ(0, ictx->operations->snap_rollback(cls::rbd::UserSnapshotNamespace(), + "snap1", + no_op)); bool is_owner; ASSERT_EQ(0, librbd::is_exclusive_lock_owner(ictx, &is_owner)); @@ -234,7 +242,10 @@ TEST_F(TestInternal, SnapRollbackFailsToLockImage) { ASSERT_EQ(0, lock_image(*ictx, LOCK_EXCLUSIVE, "manually locked")); librbd::NoOpProgressContext no_op; - ASSERT_EQ(-EROFS, ictx->operations->snap_rollback("snap1", no_op)); + ASSERT_EQ(-EROFS, + ictx->operations->snap_rollback(cls::rbd::UserSnapshotNamespace(), + "snap1", + no_op)); } TEST_F(TestInternal, SnapSetReleasesLock) { @@ -244,7 +255,7 @@ TEST_F(TestInternal, SnapSetReleasesLock) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - ASSERT_EQ(0, librbd::snap_set(ictx, "snap1")); + ASSERT_EQ(0, librbd::snap_set(ictx, cls::rbd::UserSnapshotNamespace(), "snap1")); bool is_owner; ASSERT_EQ(0, librbd::is_exclusive_lock_owner(ictx, &is_owner)); @@ -548,7 +559,9 @@ TEST_F(TestInternal, SnapshotCopyup) ASSERT_EQ(256, ictx->io_work_queue->write(0, bl.length(), bufferlist{bl}, 0)); ASSERT_EQ(0, snap_create(*ictx, "snap1")); - ASSERT_EQ(0, ictx->operations->snap_protect("snap1")); + ASSERT_EQ(0, + ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap1")); uint64_t features; ASSERT_EQ(0, librbd::get_features(ictx, &features)); @@ -593,7 +606,9 @@ TEST_F(TestInternal, SnapshotCopyup) for (std::list::iterator it = snaps.begin(); it != snaps.end(); ++it) { const char *snap_name = it->empty() ? NULL : it->c_str(); - ASSERT_EQ(0, librbd::snap_set(ictx2, snap_name)); + ASSERT_EQ(0, librbd::snap_set(ictx2, + cls::rbd::UserSnapshotNamespace(), + snap_name)); ASSERT_EQ(256, ictx2->io_work_queue->read(0, 256, @@ -654,7 +669,9 @@ TEST_F(TestInternal, ResizeCopyup) } ASSERT_EQ(0, snap_create(*ictx, "snap1")); - ASSERT_EQ(0, ictx->operations->snap_protect("snap1")); + ASSERT_EQ(0, + ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap1")); std::string clone_name = get_temp_image_name(); ASSERT_EQ(0, librbd::clone(m_ioctx, m_image_name.c_str(), "snap1", m_ioctx, @@ -674,7 +691,9 @@ TEST_F(TestInternal, ResizeCopyup) true, no_op)); ASSERT_EQ(0, ictx2->operations->resize(m_image_size - (2 << order) - 32, true, no_op)); - ASSERT_EQ(0, librbd::snap_set(ictx2, "snap1")); + ASSERT_EQ(0, librbd::snap_set(ictx2, + cls::rbd::UserSnapshotNamespace(), + "snap1")); { // hide the parent from the snapshot @@ -719,7 +738,9 @@ TEST_F(TestInternal, DiscardCopyup) } ASSERT_EQ(0, snap_create(*ictx, "snap1")); - ASSERT_EQ(0, ictx->operations->snap_protect("snap1")); + ASSERT_EQ(0, + ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap1")); std::string clone_name = get_temp_image_name(); ASSERT_EQ(0, librbd::clone(m_ioctx, m_image_name.c_str(), "snap1", m_ioctx, @@ -736,7 +757,9 @@ TEST_F(TestInternal, DiscardCopyup) ASSERT_EQ(static_cast(m_image_size - 64), ictx2->io_work_queue->discard(32, m_image_size - 64, false)); - ASSERT_EQ(0, librbd::snap_set(ictx2, "snap1")); + ASSERT_EQ(0, librbd::snap_set(ictx2, + cls::rbd::UserSnapshotNamespace(), + "snap1")); { // hide the parent from the snapshot @@ -872,7 +895,8 @@ TEST_F(TestInternal, WriteFullCopyup) { librbd::ImageCtx *ictx2 = NULL; BOOST_SCOPE_EXIT( (&m_ioctx) (clone_name) (parent) (&ictx2) ) { if (ictx2 != NULL) { - ictx2->operations->snap_remove("snap1"); + ictx2->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), + "snap1"); parent->close_image(ictx2); } @@ -881,8 +905,8 @@ TEST_F(TestInternal, WriteFullCopyup) { } BOOST_SCOPE_EXIT_END; ASSERT_EQ(0, open_image(clone_name, &ictx2)); - ASSERT_EQ(0, ictx2->operations->snap_create("snap1", - cls::rbd::UserSnapshotNamespace())); + ASSERT_EQ(0, ictx2->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap1")); bufferlist write_full_bl; write_full_bl.append(std::string(1 << ictx2->order, '2')); @@ -902,7 +926,9 @@ TEST_F(TestInternal, WriteFullCopyup) { librbd::io::ReadResult{read_result}, 0)); ASSERT_TRUE(write_full_bl.contents_equal(read_bl)); - ASSERT_EQ(0, librbd::snap_set(ictx2, "snap1")); + ASSERT_EQ(0, librbd::snap_set(ictx2, + cls::rbd::UserSnapshotNamespace(), + "snap1")); ASSERT_EQ(read_bl.length(), ictx2->io_work_queue->read(0, read_bl.length(), librbd::io::ReadResult{read_result}, 0)); @@ -956,7 +982,9 @@ TEST_F(TestInternal, DiffIterateCloneOverwrite) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(clone_name, &ictx)); ASSERT_EQ(0, snap_create(*ictx, "one")); - ASSERT_EQ(0, ictx->operations->snap_protect("one")); + ASSERT_EQ(0, + ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "one")); // Simulate a client that doesn't support deep flatten (old librbd / krbd) // which will copy up the full object from the parent @@ -967,9 +995,10 @@ TEST_F(TestInternal, DiffIterateCloneOverwrite) { ASSERT_EQ(0, io_ctx.write(oid, bl, 4096, 4096)); interval_set diff; - ASSERT_EQ(0, librbd::snap_set(ictx, "one")); + ASSERT_EQ(0, librbd::snap_set(ictx, cls::rbd::UserSnapshotNamespace(), "one")); ASSERT_EQ(0, librbd::api::DiffIterate<>::diff_iterate( - ictx, nullptr, 0, size, true, false, iterate_cb, (void *)&diff)); + ictx, cls::rbd::UserSnapshotNamespace(), nullptr, 0, size, true, false, + iterate_cb, (void *)&diff)); ASSERT_EQ(one, diff); } diff --git a/src/test/librbd/test_mirroring.cc b/src/test/librbd/test_mirroring.cc index ec81ae4705a..837ef2b88fa 100644 --- a/src/test/librbd/test_mirroring.cc +++ b/src/test/librbd/test_mirroring.cc @@ -270,7 +270,7 @@ public: ASSERT_EQ(0, get_image_id(image, &image_id)); librbd::journal::MirrorPeerClientMeta peer_client_meta( - "remote-image-id", {{"sync-point-snap", boost::none}}, {}); + "remote-image-id", {{{}, "sync-point-snap", boost::none}}, {}); librbd::journal::ClientData client_data(peer_client_meta); journal::Journaler journaler(io_ctx, image_id, "peer-client", {}); diff --git a/src/test/rbd_mirror/image_replayer/test_mock_CreateImageRequest.cc b/src/test/rbd_mirror/image_replayer/test_mock_CreateImageRequest.cc index 455362d30d1..3ee1f67984e 100644 --- a/src/test/rbd_mirror/image_replayer/test_mock_CreateImageRequest.cc +++ b/src/test/rbd_mirror/image_replayer/test_mock_CreateImageRequest.cc @@ -218,9 +218,10 @@ public: "", "", m_remote_io_ctx, false); ictx->state->open(false); - EXPECT_EQ(0, ictx->operations->snap_create(snap_name.c_str(), - cls::rbd::UserSnapshotNamespace())); - EXPECT_EQ(0, ictx->operations->snap_protect(snap_name.c_str())); + EXPECT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str())); + EXPECT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str())); ictx->state->close(); } @@ -289,8 +290,8 @@ public: void expect_snap_set(librbd::MockTestImageCtx &mock_image_ctx, const std::string &snap_name, int r) { - EXPECT_CALL(*mock_image_ctx.state, snap_set(StrEq(snap_name), _)) - .WillOnce(WithArg<1>(Invoke([this, r](Context *on_finish) { + EXPECT_CALL(*mock_image_ctx.state, snap_set(_, StrEq(snap_name), _)) + .WillOnce(WithArg<2>(Invoke([this, r](Context *on_finish) { m_threads->work_queue->queue(on_finish, r); }))); } diff --git a/src/test/rbd_mirror/image_replayer/test_mock_EventPreprocessor.cc b/src/test/rbd_mirror/image_replayer/test_mock_EventPreprocessor.cc index 9929f2ad586..d7bbce2d5a5 100644 --- a/src/test/rbd_mirror/image_replayer/test_mock_EventPreprocessor.cc +++ b/src/test/rbd_mirror/image_replayer/test_mock_EventPreprocessor.cc @@ -144,7 +144,7 @@ TEST_F(TestMockImageReplayerEventPreprocessor, PreprocessSnapRename) { expect_image_refresh(mock_local_image_ctx, 0); expect_update_client(mock_remote_journaler, 0); - mock_local_image_ctx.snap_ids = {{"snap", 6}}; + mock_local_image_ctx.snap_ids = {{{cls::rbd::UserSnapshotNamespace(), "snap"}, 6}}; mock_local_image_ctx.snap_info = { {6, librbd::SnapInfo{"snap", cls::rbd::UserSnapshotNamespace(), 0U, {}, 0U, 0U, utime_t()}}}; MockEventPreprocessor event_preprocessor(mock_local_image_ctx, @@ -244,7 +244,7 @@ TEST_F(TestMockImageReplayerEventPreprocessor, PreprocessClientUpdateError) { expect_image_refresh(mock_local_image_ctx, 0); expect_update_client(mock_remote_journaler, -EINVAL); - mock_local_image_ctx.snap_ids = {{"snap", 6}}; + mock_local_image_ctx.snap_ids = {{{cls::rbd::UserSnapshotNamespace(), "snap"}, 6}}; mock_local_image_ctx.snap_info = { {6, librbd::SnapInfo{"snap", cls::rbd::UserSnapshotNamespace(), 0U, {}, 0U, 0U, utime_t()}}}; MockEventPreprocessor event_preprocessor(mock_local_image_ctx, diff --git a/src/test/rbd_mirror/image_sync/test_mock_ImageCopyRequest.cc b/src/test/rbd_mirror/image_sync/test_mock_ImageCopyRequest.cc index a36f0bb10f2..81c0ea931b1 100644 --- a/src/test/rbd_mirror/image_sync/test_mock_ImageCopyRequest.cc +++ b/src/test/rbd_mirror/image_sync/test_mock_ImageCopyRequest.cc @@ -107,10 +107,11 @@ public: } void expect_get_snap_id(librbd::MockTestImageCtx &mock_image_ctx) { - EXPECT_CALL(mock_image_ctx, get_snap_id(_)) - .WillRepeatedly(Invoke([&mock_image_ctx](std::string snap_name) { + EXPECT_CALL(mock_image_ctx, get_snap_id(_, _)) + .WillRepeatedly(Invoke([&mock_image_ctx](cls::rbd::SnapshotNamespace snap_namespace, + std::string snap_name) { assert(mock_image_ctx.image_ctx->snap_lock.is_locked()); - return mock_image_ctx.image_ctx->get_snap_id(snap_name); + return mock_image_ctx.image_ctx->get_snap_id(snap_namespace, snap_name); })); } @@ -206,7 +207,9 @@ public: TEST_F(TestMockImageSyncImageCopyRequest, SimpleImage) { ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -237,7 +240,9 @@ TEST_F(TestMockImageSyncImageCopyRequest, SimpleImage) { TEST_F(TestMockImageSyncImageCopyRequest, Throttled) { ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none}}; std::string update_sync_age;; ASSERT_EQ(0, _rados->conf_get("rbd_mirror_sync_point_update_age", update_sync_age)); @@ -313,7 +318,8 @@ TEST_F(TestMockImageSyncImageCopyRequest, SnapshotSubset) { ASSERT_EQ(0, create_snap("snap1")); ASSERT_EQ(0, create_snap("snap2")); ASSERT_EQ(0, create_snap("snap3")); - m_client_meta.sync_points = {{"snap3", "snap2", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), + "snap3", "snap2", boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -350,8 +356,8 @@ TEST_F(TestMockImageSyncImageCopyRequest, SnapshotSubset) { TEST_F(TestMockImageSyncImageCopyRequest, RestartCatchup) { ASSERT_EQ(0, create_snap("snap1")); ASSERT_EQ(0, create_snap("snap2")); - m_client_meta.sync_points = {{"snap1", boost::none}, - {"snap2", "snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}, + {cls::rbd::UserSnapshotNamespace(), "snap2", "snap1", boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -383,7 +389,9 @@ TEST_F(TestMockImageSyncImageCopyRequest, RestartCatchup) { TEST_F(TestMockImageSyncImageCopyRequest, RestartPartialSync) { ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"snap1", librbd::journal::MirrorPeerSyncPoint::ObjectNumber{0U}}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), + "snap1", + librbd::journal::MirrorPeerSyncPoint::ObjectNumber{0U}}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -420,7 +428,7 @@ TEST_F(TestMockImageSyncImageCopyRequest, Cancel) { } BOOST_SCOPE_EXIT_END; ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -466,7 +474,7 @@ TEST_F(TestMockImageSyncImageCopyRequest, Cancel_Inflight_Sync) { } BOOST_SCOPE_EXIT_END; ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -514,7 +522,7 @@ TEST_F(TestMockImageSyncImageCopyRequest, Cancel_Inflight_Sync) { TEST_F(TestMockImageSyncImageCopyRequest, Cancel1) { ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -545,7 +553,7 @@ TEST_F(TestMockImageSyncImageCopyRequest, Cancel1) { TEST_F(TestMockImageSyncImageCopyRequest, MissingSnap) { ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"missing-snap", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "missing-snap", boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -565,7 +573,10 @@ TEST_F(TestMockImageSyncImageCopyRequest, MissingSnap) { TEST_F(TestMockImageSyncImageCopyRequest, MissingFromSnap) { ASSERT_EQ(0, create_snap("snap1")); - m_client_meta.sync_points = {{"snap1", "missing-snap", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), + "snap1", + "missing-snap", + boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -587,7 +598,10 @@ TEST_F(TestMockImageSyncImageCopyRequest, EmptySnapMap) { ASSERT_EQ(0, create_snap("snap1")); ASSERT_EQ(0, create_snap("snap2")); m_client_meta.snap_seqs = {{0, 0}}; - m_client_meta.sync_points = {{"snap2", "snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", + boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -609,7 +623,10 @@ TEST_F(TestMockImageSyncImageCopyRequest, EmptySnapSeqs) { ASSERT_EQ(0, create_snap("snap1")); ASSERT_EQ(0, create_snap("snap2")); m_client_meta.snap_seqs = {}; - m_client_meta.sync_points = {{"snap2", "snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", + boost::none}}; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); diff --git a/src/test/rbd_mirror/image_sync/test_mock_ObjectCopyRequest.cc b/src/test/rbd_mirror/image_sync/test_mock_ObjectCopyRequest.cc index 57b38b8bab1..bfebabdc97a 100644 --- a/src/test/rbd_mirror/image_sync/test_mock_ObjectCopyRequest.cc +++ b/src/test/rbd_mirror/image_sync/test_mock_ObjectCopyRequest.cc @@ -250,13 +250,15 @@ public: librados::snap_t snap_id) { auto it = std::find_if(image_ctx->snap_ids.begin(), image_ctx->snap_ids.end(), - [snap_id](const std::pair &pair) { + [snap_id](const std::pair, + librados::snap_t> &pair) { return (pair.second == snap_id); }); if (it == image_ctx->snap_ids.end()) { return ""; } - return it->first; + return it->first.second; } int compare_objects() { @@ -280,12 +282,16 @@ public: std::cout << "comparing '" << snap_name << " (" << remote_snap_id << " to " << local_snap_id << ")" << std::endl; - r = librbd::snap_set(m_remote_image_ctx, snap_name.c_str()); + r = librbd::snap_set(m_remote_image_ctx, + cls::rbd::UserSnapshotNamespace(), + snap_name.c_str()); if (r < 0) { return r; } - r = librbd::snap_set(m_local_image_ctx, snap_name.c_str()); + r = librbd::snap_set(m_local_image_ctx, + cls::rbd::UserSnapshotNamespace(), + snap_name.c_str()); if (r < 0) { return r; } @@ -311,11 +317,15 @@ public: } } - r = librbd::snap_set(m_remote_image_ctx, nullptr); + r = librbd::snap_set(m_remote_image_ctx, + cls::rbd::UserSnapshotNamespace(), + nullptr); if (r < 0) { return r; } - r = librbd::snap_set(m_local_image_ctx, nullptr); + r = librbd::snap_set(m_local_image_ctx, + cls::rbd::UserSnapshotNamespace(), + nullptr); if (r < 0) { return r; } diff --git a/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc b/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc index 4b2b7df258b..0d019e5ce09 100644 --- a/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc +++ b/src/test/rbd_mirror/image_sync/test_mock_SnapshotCopyRequest.cc @@ -105,6 +105,13 @@ public: ASSERT_EQ(0, open_image(m_local_io_ctx, m_image_name, &m_local_image_ctx)); } + void expect_get_snap_namespace(librbd::MockTestImageCtx &mock_image_ctx, + uint64_t snap_id) { + EXPECT_CALL(mock_image_ctx, get_snap_namespace(snap_id, _)) + .WillOnce(DoAll(SetArgPointee<1>(cls::rbd::UserSnapshotNamespace()), + Return(0))); + } + void expect_snap_create(librbd::MockTestImageCtx &mock_image_ctx, MockSnapshotCreateRequest &mock_snapshot_create_request, const std::string &snap_name, uint64_t snap_id, int r) { @@ -119,24 +126,24 @@ public: void expect_snap_remove(librbd::MockTestImageCtx &mock_image_ctx, const std::string &snap_name, int r) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(StrEq(snap_name), _)) - .WillOnce(WithArg<1>(Invoke([this, r](Context *ctx) { + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_remove(_, StrEq(snap_name), _)) + .WillOnce(WithArg<2>(Invoke([this, r](Context *ctx) { m_threads->work_queue->queue(ctx, r); }))); } void expect_snap_protect(librbd::MockTestImageCtx &mock_image_ctx, const std::string &snap_name, int r) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_protect(StrEq(snap_name), _)) - .WillOnce(WithArg<1>(Invoke([this, r](Context *ctx) { + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_protect(_, StrEq(snap_name), _)) + .WillOnce(WithArg<2>(Invoke([this, r](Context *ctx) { m_threads->work_queue->queue(ctx, r); }))); } void expect_snap_unprotect(librbd::MockTestImageCtx &mock_image_ctx, const std::string &snap_name, int r) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_unprotect(StrEq(snap_name), _)) - .WillOnce(WithArg<1>(Invoke([this, r](Context *ctx) { + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_unprotect(_, StrEq(snap_name), _)) + .WillOnce(WithArg<2>(Invoke([this, r](Context *ctx) { m_threads->work_queue->queue(ctx, r); }))); } @@ -162,7 +169,8 @@ public: static void inject_snap(librbd::MockTestImageCtx &mock_image_ctx, uint64_t snap_id, const std::string &snap_name) { - mock_image_ctx.snap_ids[snap_name] = snap_id; + mock_image_ctx.snap_ids[{cls::rbd::UserSnapshotNamespace(), + snap_name}] = snap_id; } MockSnapshotCopyRequest *create_request(librbd::MockTestImageCtx &mock_remote_image_ctx, @@ -177,14 +185,15 @@ public: int create_snap(librbd::ImageCtx *image_ctx, const std::string &snap_name, bool protect = false) { - int r = image_ctx->operations->snap_create(snap_name.c_str(), - cls::rbd::UserSnapshotNamespace()); + int r = image_ctx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str()); if (r < 0) { return r; } if (protect) { - r = image_ctx->operations->snap_protect(snap_name.c_str()); + r = image_ctx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str()); if (r < 0) { return r; } @@ -271,8 +280,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapCreate) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1")); ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap2")); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; - uint64_t remote_snap_id2 = m_remote_image_ctx->snap_ids["snap2"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t remote_snap_id2 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap2"}]; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -280,7 +291,9 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapCreate) { journal::MockJournaler mock_journaler; InSequence seq; + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_create(mock_local_image_ctx, mock_snapshot_create_request, "snap1", 12, 0); + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id2); expect_snap_create(mock_local_image_ctx, mock_snapshot_create_request, "snap2", 14, 0); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, false, 0); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id2, false, 0); @@ -305,7 +318,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapCreateError) { MockSnapshotCreateRequest mock_snapshot_create_request; journal::MockJournaler mock_journaler; + uint64_t remote_snap_id1 = mock_remote_image_ctx.snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; InSequence seq; + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_create(mock_local_image_ctx, mock_snapshot_create_request, "snap1", 12, -EINVAL); C_SaferCond ctx; @@ -324,6 +340,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapCreateCancel) { MockSnapshotCreateRequest mock_snapshot_create_request; journal::MockJournaler mock_journaler; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); + C_SaferCond ctx; MockSnapshotCopyRequest *request = create_request(mock_remote_image_ctx, mock_local_image_ctx, @@ -345,7 +365,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapRemoveAndCreate) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1")); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1")); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -354,8 +377,11 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapRemoveAndCreate) { InSequence seq; expect_snap_is_unprotected(mock_local_image_ctx, - m_local_image_ctx->snap_ids["snap1"], true, 0); + m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}], true, 0); + expect_get_snap_namespace(mock_local_image_ctx, local_snap_id1); expect_snap_remove(mock_local_image_ctx, "snap1", 0); + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_create(mock_local_image_ctx, mock_snapshot_create_request, "snap1", 12, 0); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, false, 0); expect_update_client(mock_journaler, 0); @@ -378,9 +404,13 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapRemoveError) { librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); journal::MockJournaler mock_journaler; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; InSequence seq; expect_snap_is_unprotected(mock_local_image_ctx, - m_local_image_ctx->snap_ids["snap1"], true, 0); + m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}], true, 0); + expect_get_snap_namespace(mock_local_image_ctx, local_snap_id1); expect_snap_remove(mock_local_image_ctx, "snap1", -EINVAL); C_SaferCond ctx; @@ -395,8 +425,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotect) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; - uint64_t local_snap_id1 = m_local_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; m_client_meta.snap_seqs[remote_snap_id1] = local_snap_id1; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -407,6 +439,8 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotect) { expect_snap_is_unprotected(mock_local_image_ctx, local_snap_id1, false, 0); expect_snap_is_unprotected(mock_remote_image_ctx, remote_snap_id1, true, 0); expect_snap_unprotect(mock_local_image_ctx, "snap1", 0); + expect_get_snap_namespace(mock_local_image_ctx, local_snap_id1); + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, false, 0); expect_update_client(mock_journaler, 0); @@ -425,8 +459,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotectError) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; - uint64_t local_snap_id1 = m_local_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; m_client_meta.snap_seqs[remote_snap_id1] = local_snap_id1; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -450,8 +486,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotectCancel) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; - uint64_t local_snap_id1 = m_local_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; m_client_meta.snap_seqs[remote_snap_id1] = local_snap_id1; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -466,11 +504,11 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotectCancel) { expect_snap_is_unprotected(mock_local_image_ctx, local_snap_id1, false, 0); expect_snap_is_unprotected(mock_remote_image_ctx, remote_snap_id1, true, 0); EXPECT_CALL(*mock_local_image_ctx.operations, - execute_snap_unprotect(StrEq("snap1"), _)) + execute_snap_unprotect(_, StrEq("snap1"), _)) .WillOnce(DoAll(InvokeWithoutArgs([request]() { request->cancel(); }), - WithArg<1>(Invoke([this](Context *ctx) { + WithArg<2>(Invoke([this](Context *ctx) { m_threads->work_queue->queue(ctx, 0); })))); @@ -482,7 +520,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotectRemove) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -491,9 +532,12 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotectRemove) { InSequence seq; expect_snap_is_unprotected(mock_local_image_ctx, - m_local_image_ctx->snap_ids["snap1"], false, 0); + m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}], false, 0); expect_snap_unprotect(mock_local_image_ctx, "snap1", 0); + expect_get_snap_namespace(mock_local_image_ctx, local_snap_id1); expect_snap_remove(mock_local_image_ctx, "snap1", 0); + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_create(mock_local_image_ctx, mock_snapshot_create_request, "snap1", 12, 0); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, false, 0); expect_update_client(mock_journaler, 0); @@ -512,7 +556,8 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapUnprotectRemove) { TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapCreateProtect) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); librbd::MockTestImageCtx mock_local_image_ctx(*m_local_image_ctx); @@ -520,6 +565,7 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapCreateProtect) { journal::MockJournaler mock_journaler; InSequence seq; + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_create(mock_local_image_ctx, mock_snapshot_create_request, "snap1", 12, 0); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, true, 0); expect_snap_is_protected(mock_local_image_ctx, 12, false, 0); @@ -541,8 +587,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapProtect) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; - uint64_t local_snap_id1 = m_local_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; m_client_meta.snap_seqs[remote_snap_id1] = local_snap_id1; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -551,6 +599,8 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapProtect) { InSequence seq; expect_snap_is_unprotected(mock_local_image_ctx, local_snap_id1, true, 0); + expect_get_snap_namespace(mock_local_image_ctx, local_snap_id1); + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, true, 0); expect_snap_is_protected(mock_local_image_ctx, local_snap_id1, false, 0); expect_snap_protect(mock_local_image_ctx, "snap1", 0); @@ -571,8 +621,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapProtectError) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; - uint64_t local_snap_id1 = m_local_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; m_client_meta.snap_seqs[remote_snap_id1] = local_snap_id1; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -581,6 +633,8 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapProtectError) { InSequence seq; expect_snap_is_unprotected(mock_local_image_ctx, local_snap_id1, true, 0); + expect_get_snap_namespace(mock_local_image_ctx, local_snap_id1); + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, true, 0); expect_snap_is_protected(mock_local_image_ctx, local_snap_id1, false, 0); expect_snap_protect(mock_local_image_ctx, "snap1", -EINVAL); @@ -597,8 +651,10 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapProtectCancel) { ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap1", true)); ASSERT_EQ(0, create_snap(m_local_image_ctx, "snap1", true)); - uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids["snap1"]; - uint64_t local_snap_id1 = m_local_image_ctx->snap_ids["snap1"]; + uint64_t remote_snap_id1 = m_remote_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; + uint64_t local_snap_id1 = m_local_image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}]; m_client_meta.snap_seqs[remote_snap_id1] = local_snap_id1; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -611,14 +667,16 @@ TEST_F(TestMockImageSyncSnapshotCopyRequest, SnapProtectCancel) { mock_journaler, &ctx); InSequence seq; expect_snap_is_unprotected(mock_local_image_ctx, local_snap_id1, true, 0); + expect_get_snap_namespace(mock_local_image_ctx, local_snap_id1); + expect_get_snap_namespace(mock_remote_image_ctx, remote_snap_id1); expect_snap_is_protected(mock_remote_image_ctx, remote_snap_id1, true, 0); expect_snap_is_protected(mock_local_image_ctx, local_snap_id1, false, 0); EXPECT_CALL(*mock_local_image_ctx.operations, - execute_snap_protect(StrEq("snap1"), _)) + execute_snap_protect(_, StrEq("snap1"), _)) .WillOnce(DoAll(InvokeWithoutArgs([request]() { request->cancel(); }), - WithArg<1>(Invoke([this](Context *ctx) { + WithArg<2>(Invoke([this](Context *ctx) { m_threads->work_queue->queue(ctx, 0); })))); diff --git a/src/test/rbd_mirror/image_sync/test_mock_SnapshotCreateRequest.cc b/src/test/rbd_mirror/image_sync/test_mock_SnapshotCreateRequest.cc index 236bfe4e617..91893abe2b5 100644 --- a/src/test/rbd_mirror/image_sync/test_mock_SnapshotCreateRequest.cc +++ b/src/test/rbd_mirror/image_sync/test_mock_SnapshotCreateRequest.cc @@ -80,7 +80,7 @@ public: void expect_snap_create(librbd::MockTestImageCtx &mock_image_ctx, const std::string &snap_name, uint64_t snap_id, int r) { - EXPECT_CALL(*mock_image_ctx.operations, execute_snap_create(StrEq(snap_name), _, _, 0, true)) + EXPECT_CALL(*mock_image_ctx.operations, execute_snap_create(_, StrEq(snap_name), _, 0, true)) .WillOnce(DoAll(InvokeWithoutArgs([&mock_image_ctx, snap_id, snap_name]() { inject_snap(mock_image_ctx, snap_id, snap_name); }), @@ -100,7 +100,8 @@ public: static void inject_snap(librbd::MockTestImageCtx &mock_image_ctx, uint64_t snap_id, const std::string &snap_name) { - mock_image_ctx.snap_ids[snap_name] = snap_id; + mock_image_ctx.snap_ids[{cls::rbd::UserSnapshotNamespace(), + snap_name}] = snap_id; } MockSnapshotCreateRequest *create_request(librbd::MockTestImageCtx &mock_local_image_ctx, diff --git a/src/test/rbd_mirror/image_sync/test_mock_SyncPointCreateRequest.cc b/src/test/rbd_mirror/image_sync/test_mock_SyncPointCreateRequest.cc index c9c3316bfa5..1414d333597 100644 --- a/src/test/rbd_mirror/image_sync/test_mock_SyncPointCreateRequest.cc +++ b/src/test/rbd_mirror/image_sync/test_mock_SyncPointCreateRequest.cc @@ -102,7 +102,10 @@ TEST_F(TestMockImageSyncSyncPointCreateRequest, Success) { } TEST_F(TestMockImageSyncSyncPointCreateRequest, ResyncSuccess) { - m_client_meta.sync_points.emplace_front("start snap", "", boost::none); + m_client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "start snap", + "", + boost::none); auto sync_point = m_client_meta.sync_points.front(); librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); diff --git a/src/test/rbd_mirror/image_sync/test_mock_SyncPointPruneRequest.cc b/src/test/rbd_mirror/image_sync/test_mock_SyncPointPruneRequest.cc index 4bec0f94e49..f02645b045b 100644 --- a/src/test/rbd_mirror/image_sync/test_mock_SyncPointPruneRequest.cc +++ b/src/test/rbd_mirror/image_sync/test_mock_SyncPointPruneRequest.cc @@ -65,7 +65,7 @@ public: void expect_get_snap_id(librbd::MockTestImageCtx &mock_remote_image_ctx, const std::string &snap_name, uint64_t snap_id) { - EXPECT_CALL(mock_remote_image_ctx, get_snap_id(StrEq(snap_name))) + EXPECT_CALL(mock_remote_image_ctx, get_snap_id(_, StrEq(snap_name))) .WillOnce(Return(snap_id)); } @@ -76,8 +76,8 @@ public: void expect_snap_remove(librbd::MockTestImageCtx &mock_remote_image_ctx, const std::string &snap_name, int r) { - EXPECT_CALL(*mock_remote_image_ctx.operations, snap_remove(StrEq(snap_name), _)) - .WillOnce(WithArg<1>(CompleteContext(r))); + EXPECT_CALL(*mock_remote_image_ctx.operations, snap_remove(_, StrEq(snap_name), _)) + .WillOnce(WithArg<2>(CompleteContext(r))); } MockSyncPointPruneRequest *create_request(librbd::MockTestImageCtx &mock_remote_image_ctx, @@ -93,7 +93,9 @@ public: TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncInProgressSuccess) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -114,8 +116,12 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncInProgressSuccess) { TEST_F(TestMockImageSyncSyncPointPruneRequest, RestartedSyncInProgressSuccess) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap2", "snap1", boost::none); - client_meta.sync_points.emplace_front("snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -139,8 +145,13 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, RestartedSyncInProgressSuccess) { TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncInProgressMissingSnapSuccess) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap2", "snap1", boost::none); - client_meta.sync_points.emplace_front("snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", + boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -165,7 +176,10 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncInProgressMissingSnapSuccess) TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncInProgressUnexpectedFromSnapSuccess) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap2", "snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -190,7 +204,9 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncInProgressUnexpectedFromSnapS TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncCompleteSuccess) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); m_client_meta = client_meta; ASSERT_EQ(librbd::journal::MIRROR_PEER_STATE_SYNCING, m_client_meta.state); @@ -213,8 +229,13 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, SyncCompleteSuccess) { TEST_F(TestMockImageSyncSyncPointPruneRequest, RestartedSyncCompleteSuccess) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap2", "snap1", boost::none); - client_meta.sync_points.emplace_front("snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", + boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -235,8 +256,14 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, RestartedSyncCompleteSuccess) { TEST_F(TestMockImageSyncSyncPointPruneRequest, RestartedCatchUpSyncCompleteSuccess) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap3", "snap2", boost::none); - client_meta.sync_points.emplace_front("snap2", "snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap3", + "snap2", + boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -258,7 +285,9 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, RestartedCatchUpSyncCompleteSucce TEST_F(TestMockImageSyncSyncPointPruneRequest, SnapshotDNE) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); @@ -279,8 +308,13 @@ TEST_F(TestMockImageSyncSyncPointPruneRequest, SnapshotDNE) { TEST_F(TestMockImageSyncSyncPointPruneRequest, ClientUpdateError) { librbd::journal::MirrorPeerClientMeta client_meta; - client_meta.sync_points.emplace_front("snap2", "snap1", boost::none); - client_meta.sync_points.emplace_front("snap1", boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap2", + "snap1", + boost::none); + client_meta.sync_points.emplace_front(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); m_client_meta = client_meta; librbd::MockTestImageCtx mock_remote_image_ctx(*m_remote_image_ctx); diff --git a/src/test/rbd_mirror/test_ImageDeleter.cc b/src/test/rbd_mirror/test_ImageDeleter.cc index 1059e20b7c2..606bec8d378 100644 --- a/src/test/rbd_mirror/test_ImageDeleter.cc +++ b/src/test/rbd_mirror/test_ImageDeleter.cc @@ -152,11 +152,12 @@ public: EXPECT_EQ(0, ictx->state->open(false)); promote_image(ictx); - EXPECT_EQ(0, ictx->operations->snap_create(snap_name.c_str(), - cls::rbd::UserSnapshotNamespace())); + EXPECT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str())); if (protect) { - EXPECT_EQ(0, ictx->operations->snap_protect(snap_name.c_str())); + EXPECT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str())); } demote_image(ictx); @@ -169,9 +170,10 @@ public: EXPECT_EQ(0, ictx->state->open(false)); promote_image(ictx); - EXPECT_EQ(0, ictx->operations->snap_create("snap1", - cls::rbd::UserSnapshotNamespace())); - EXPECT_EQ(0, ictx->operations->snap_protect("snap1")); + EXPECT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "snap1")); + EXPECT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "snap1")); int order = 20; EXPECT_EQ(0, librbd::clone(m_local_io_ctx, ictx->name.c_str(), "snap1", m_local_io_ctx, "clone1", ictx->features, diff --git a/src/test/rbd_mirror/test_ImageReplayer.cc b/src/test/rbd_mirror/test_ImageReplayer.cc index 35139384149..b4869a7f5a7 100644 --- a/src/test/rbd_mirror/test_ImageReplayer.cc +++ b/src/test/rbd_mirror/test_ImageReplayer.cc @@ -800,12 +800,14 @@ TEST_F(TestImageReplayer, MultipleReplayFailures_SingleEpoch) { librbd::ImageCtx *ictx; open_image(m_local_ioctx, m_image_name, false, &ictx); ictx->features &= ~RBD_FEATURE_JOURNALING; - ASSERT_EQ(0, ictx->operations->snap_create("foo", - cls::rbd::UserSnapshotNamespace())); - ASSERT_EQ(0, ictx->operations->snap_protect("foo")); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "foo")); + ASSERT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "foo")); ASSERT_EQ(0, librbd::cls_client::add_child(&ictx->md_ctx, RBD_CHILDREN, {ictx->md_ctx.get_id(), - ictx->id, ictx->snap_ids["foo"]}, + ictx->id, + ictx->snap_ids[{cls::rbd::UserSnapshotNamespace(), "foo"}]}, "dummy child id")); close_image(ictx); @@ -821,7 +823,9 @@ TEST_F(TestImageReplayer, MultipleReplayFailures_SingleEpoch) { ictx->journal->append_op_event( i, librbd::journal::EventEntry{ - librbd::journal::SnapUnprotectEvent{i, "foo"}}, + librbd::journal::SnapUnprotectEvent{i, + cls::rbd::UserSnapshotNamespace(), + "foo"}}, &append_ctx); ASSERT_EQ(0, append_ctx.wait()); @@ -848,12 +852,15 @@ TEST_F(TestImageReplayer, MultipleReplayFailures_MultiEpoch) { librbd::ImageCtx *ictx; open_image(m_local_ioctx, m_image_name, false, &ictx); ictx->features &= ~RBD_FEATURE_JOURNALING; - ASSERT_EQ(0, ictx->operations->snap_create("foo", - cls::rbd::UserSnapshotNamespace())); - ASSERT_EQ(0, ictx->operations->snap_protect("foo")); + ASSERT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + "foo")); + ASSERT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + "foo")); ASSERT_EQ(0, librbd::cls_client::add_child(&ictx->md_ctx, RBD_CHILDREN, {ictx->md_ctx.get_id(), - ictx->id, ictx->snap_ids["foo"]}, + ictx->id, + ictx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + "foo"}]}, "dummy child id")); close_image(ictx); @@ -869,7 +876,9 @@ TEST_F(TestImageReplayer, MultipleReplayFailures_MultiEpoch) { ictx->journal->append_op_event( 1U, librbd::journal::EventEntry{ - librbd::journal::SnapUnprotectEvent{1U, "foo"}}, + librbd::journal::SnapUnprotectEvent{1U, + cls::rbd::UserSnapshotNamespace(), + "foo"}}, &append_ctx); ASSERT_EQ(0, append_ctx.wait()); diff --git a/src/test/rbd_mirror/test_ImageSync.cc b/src/test/rbd_mirror/test_ImageSync.cc index 8947ddbc075..cd50af8ded5 100644 --- a/src/test/rbd_mirror/test_ImageSync.cc +++ b/src/test/rbd_mirror/test_ImageSync.cc @@ -264,7 +264,9 @@ TEST_F(TestImageSync, SnapshotStress) { uint64_t remote_size; { C_SaferCond ctx; - m_remote_image_ctx->state->snap_set(snap_name, &ctx); + m_remote_image_ctx->state->snap_set(cls::rbd::UserSnapshotNamespace(), + snap_name, + &ctx); ASSERT_EQ(0, ctx.wait()); RWLock::RLocker remote_snap_locker(m_remote_image_ctx->snap_lock); @@ -275,7 +277,9 @@ TEST_F(TestImageSync, SnapshotStress) { uint64_t local_size; { C_SaferCond ctx; - m_local_image_ctx->state->snap_set(snap_name, &ctx); + m_local_image_ctx->state->snap_set(cls::rbd::UserSnapshotNamespace(), + snap_name, + &ctx); ASSERT_EQ(0, ctx.wait()); RWLock::RLocker snap_locker(m_local_image_ctx->snap_lock); diff --git a/src/test/rbd_mirror/test_PoolWatcher.cc b/src/test/rbd_mirror/test_PoolWatcher.cc index bbc9bb123e0..d5ab58a9f84 100644 --- a/src/test/rbd_mirror/test_PoolWatcher.cc +++ b/src/test/rbd_mirror/test_PoolWatcher.cc @@ -133,9 +133,10 @@ TestPoolWatcher() : m_lock("TestPoolWatcherLock"), librbd::ImageCtx *ictx = new librbd::ImageCtx(parent_image_name.c_str(), "", "", pioctx, false); ictx->state->open(false); - EXPECT_EQ(0, ictx->operations->snap_create(snap_name.c_str(), - cls::rbd::UserSnapshotNamespace())); - EXPECT_EQ(0, ictx->operations->snap_protect(snap_name.c_str())); + EXPECT_EQ(0, ictx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str())); + EXPECT_EQ(0, ictx->operations->snap_protect(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str())); ictx->state->close(); } diff --git a/src/test/rbd_mirror/test_fixture.cc b/src/test/rbd_mirror/test_fixture.cc index 0d6fc4d5a9b..45aad51b65a 100644 --- a/src/test/rbd_mirror/test_fixture.cc +++ b/src/test/rbd_mirror/test_fixture.cc @@ -95,8 +95,8 @@ int TestFixture::open_image(librados::IoCtx &io_ctx, int TestFixture::create_snap(librbd::ImageCtx *image_ctx, const char* snap_name, librados::snap_t *snap_id) { - int r = image_ctx->operations->snap_create(snap_name, - cls::rbd::UserSnapshotNamespace()); + int r = image_ctx->operations->snap_create(cls::rbd::UserSnapshotNamespace(), + snap_name); if (r < 0) { return r; } @@ -106,12 +106,14 @@ int TestFixture::create_snap(librbd::ImageCtx *image_ctx, const char* snap_name, return r; } - if (image_ctx->snap_ids.count(snap_name) == 0) { + if (image_ctx->snap_ids.count({cls::rbd::UserSnapshotNamespace(), + snap_name}) == 0) { return -ENOENT; } if (snap_id != nullptr) { - *snap_id = image_ctx->snap_ids[snap_name]; + *snap_id = image_ctx->snap_ids[{cls::rbd::UserSnapshotNamespace(), + snap_name}]; } return 0; } diff --git a/src/test/rbd_mirror/test_mock_ImageSync.cc b/src/test/rbd_mirror/test_mock_ImageSync.cc index 921525d735e..676615d870c 100644 --- a/src/test/rbd_mirror/test_mock_ImageSync.cc +++ b/src/test/rbd_mirror/test_mock_ImageSync.cc @@ -197,8 +197,11 @@ public: EXPECT_CALL(mock_sync_point_create_request, send()) .WillOnce(Invoke([this, &mock_local_image_ctx, &mock_sync_point_create_request, r]() { if (r == 0) { - mock_local_image_ctx.snap_ids["snap1"] = 123; - m_client_meta.sync_points.emplace_back("snap1", boost::none); + mock_local_image_ctx.snap_ids[{cls::rbd::UserSnapshotNamespace(), + "snap1"}] = 123; + m_client_meta.sync_points.emplace_back(cls::rbd::UserSnapshotNamespace(), + "snap1", + boost::none); } m_threads->work_queue->queue(mock_sync_point_create_request.on_finish, r); })); @@ -313,10 +316,10 @@ TEST_F(TestMockImageSync, RestartSync) { MockSyncPointCreateRequest mock_sync_point_create_request; MockSyncPointPruneRequest mock_sync_point_prune_request; - m_client_meta.sync_points = {{"snap1", boost::none}, - {"snap2", "snap1", boost::none}}; - mock_local_image_ctx.snap_ids["snap1"] = 123; - mock_local_image_ctx.snap_ids["snap2"] = 234; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}, + {cls::rbd::UserSnapshotNamespace(), "snap2", "snap1", boost::none}}; + mock_local_image_ctx.snap_ids[{cls::rbd::UserSnapshotNamespace(), "snap1"}] = 123; + mock_local_image_ctx.snap_ids[{cls::rbd::UserSnapshotNamespace(), "snap2"}] = 234; librbd::MockObjectMap *mock_object_map = new librbd::MockObjectMap(); mock_local_image_ctx.object_map = mock_object_map; @@ -348,7 +351,7 @@ TEST_F(TestMockImageSync, CancelImageCopy) { MockSyncPointCreateRequest mock_sync_point_create_request; MockSyncPointPruneRequest mock_sync_point_prune_request; - m_client_meta.sync_points = {{"snap1", boost::none}}; + m_client_meta.sync_points = {{cls::rbd::UserSnapshotNamespace(), "snap1", boost::none}}; InSequence seq; expect_prune_sync_point(mock_sync_point_prune_request, false, 0); diff --git a/src/tools/rbd_mirror/ImageDeleter.cc b/src/tools/rbd_mirror/ImageDeleter.cc index 1c10147d688..00c4c3952f2 100644 --- a/src/tools/rbd_mirror/ImageDeleter.cc +++ b/src/tools/rbd_mirror/ImageDeleter.cc @@ -375,7 +375,8 @@ bool ImageDeleter::process_image_delete() { dout(20) << "snapshot " << imgctx->name << "@" << snap.name << " is protected, issuing unprotect command" << dendl; - r = imgctx->operations->snap_unprotect(snap.name.c_str()); + r = imgctx->operations->snap_unprotect(cls::rbd::UserSnapshotNamespace(), + snap.name.c_str()); if (r == -EBUSY) { // there are still clones of snapshots of this image, therefore send // the delete request to the end of the queue @@ -396,7 +397,8 @@ bool ImageDeleter::process_image_delete() { } } - r = imgctx->operations->snap_remove(snap.name.c_str()); + r = imgctx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), + snap.name.c_str()); if (r < 0) { derr << "error removing snapshot " << imgctx->name << "@" << snap.name << ": " << cpp_strerror(r) << dendl; diff --git a/src/tools/rbd_mirror/ImageSync.cc b/src/tools/rbd_mirror/ImageSync.cc index e19ed563794..9c898fdbb62 100644 --- a/src/tools/rbd_mirror/ImageSync.cc +++ b/src/tools/rbd_mirror/ImageSync.cc @@ -257,7 +257,8 @@ void ImageSync::send_copy_object_map() { assert(!m_client_meta->sync_points.empty()); librbd::journal::MirrorPeerSyncPoint &sync_point = m_client_meta->sync_points.front(); - auto snap_id_it = m_local_image_ctx->snap_ids.find(sync_point.snap_name); + auto snap_id_it = m_local_image_ctx->snap_ids.find({cls::rbd::UserSnapshotNamespace(), + sync_point.snap_name}); assert(snap_id_it != m_local_image_ctx->snap_ids.end()); librados::snap_t snap_id = snap_id_it->second; diff --git a/src/tools/rbd_mirror/image_replayer/CreateImageRequest.cc b/src/tools/rbd_mirror/image_replayer/CreateImageRequest.cc index c204354c393..2f113e6f995 100644 --- a/src/tools/rbd_mirror/image_replayer/CreateImageRequest.cc +++ b/src/tools/rbd_mirror/image_replayer/CreateImageRequest.cc @@ -260,7 +260,9 @@ void CreateImageRequest::set_local_parent_snap() { Context *ctx = create_context_callback< CreateImageRequest, &CreateImageRequest::handle_set_local_parent_snap>(this); - m_local_parent_image_ctx->state->snap_set(m_parent_snap_name, ctx); + m_local_parent_image_ctx->state->snap_set(cls::rbd::UserSnapshotNamespace(), + m_parent_snap_name, + ctx); } template diff --git a/src/tools/rbd_mirror/image_replayer/EventPreprocessor.cc b/src/tools/rbd_mirror/image_replayer/EventPreprocessor.cc index 5aaf352e863..443c0c209f3 100644 --- a/src/tools/rbd_mirror/image_replayer/EventPreprocessor.cc +++ b/src/tools/rbd_mirror/image_replayer/EventPreprocessor.cc @@ -107,7 +107,7 @@ int EventPreprocessor::preprocess_snap_rename( dout(20) << ": " << "remote_snap_id=" << event.snap_id << ", " << "src_snap_name=" << event.src_snap_name << ", " - << "dest_snap_name=" << event.snap_name << dendl; + << "dest_snap_name=" << event.dst_snap_name << dendl; auto snap_seq_it = m_snap_seqs.find(event.snap_id); if (snap_seq_it != m_snap_seqs.end()) { @@ -117,7 +117,8 @@ int EventPreprocessor::preprocess_snap_rename( return 0; } - auto snap_id_it = m_local_image_ctx.snap_ids.find(event.src_snap_name); + auto snap_id_it = m_local_image_ctx.snap_ids.find({cls::rbd::UserSnapshotNamespace(), + event.src_snap_name}); if (snap_id_it == m_local_image_ctx.snap_ids.end()) { dout(20) << ": cannot map remote snapshot '" << event.src_snap_name << "' " << "to local snapshot" << dendl; diff --git a/src/tools/rbd_mirror/image_sync/ImageCopyRequest.cc b/src/tools/rbd_mirror/image_sync/ImageCopyRequest.cc index 66f7542e612..dbc2560acd0 100644 --- a/src/tools/rbd_mirror/image_sync/ImageCopyRequest.cc +++ b/src/tools/rbd_mirror/image_sync/ImageCopyRequest.cc @@ -364,7 +364,8 @@ int ImageCopyRequest::compute_snap_map() { librados::snap_t snap_id_end; { RWLock::RLocker snap_locker(m_remote_image_ctx->snap_lock); - snap_id_end = m_remote_image_ctx->get_snap_id(m_sync_point->snap_name); + snap_id_end = m_remote_image_ctx->get_snap_id( + cls::rbd::UserSnapshotNamespace(), m_sync_point->snap_name); if (snap_id_end == CEPH_NOSNAP) { derr << ": failed to locate snapshot: " << m_sync_point->snap_name << dendl; @@ -373,7 +374,7 @@ int ImageCopyRequest::compute_snap_map() { if (!m_sync_point->from_snap_name.empty()) { snap_id_start = m_remote_image_ctx->get_snap_id( - m_sync_point->from_snap_name); + cls::rbd::UserSnapshotNamespace(), m_sync_point->from_snap_name); if (snap_id_start == CEPH_NOSNAP) { derr << ": failed to locate from snapshot: " << m_sync_point->from_snap_name << dendl; diff --git a/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc b/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc index 8e9827e4d65..25967b9e339 100644 --- a/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc +++ b/src/tools/rbd_mirror/image_sync/SnapshotCopyRequest.cc @@ -27,11 +27,14 @@ const std::string &get_snapshot_name(I *image_ctx, librados::snap_t snap_id) { auto snap_it = std::find_if(image_ctx->snap_ids.begin(), image_ctx->snap_ids.end(), [snap_id]( - const std::pair &pair) { + const std::pair< + std::pair, + librados::snap_t> &pair) { return pair.second == snap_id; }); assert(snap_it != image_ctx->snap_ids.end()); - return snap_it->first; + return snap_it->first.second; } } // anonymous namespace @@ -170,7 +173,8 @@ void SnapshotCopyRequest::send_snap_unprotect() { SnapshotCopyRequest, &SnapshotCopyRequest::handle_snap_unprotect>( this); RWLock::RLocker owner_locker(m_local_image_ctx->owner_lock); - m_local_image_ctx->operations->execute_snap_unprotect(m_snap_name.c_str(), + m_local_image_ctx->operations->execute_snap_unprotect(cls::rbd::UserSnapshotNamespace(), + m_snap_name.c_str(), ctx); } @@ -247,7 +251,9 @@ void SnapshotCopyRequest::send_snap_remove() { SnapshotCopyRequest, &SnapshotCopyRequest::handle_snap_remove>( this); RWLock::RLocker owner_locker(m_local_image_ctx->owner_lock); - m_local_image_ctx->operations->execute_snap_remove(m_snap_name.c_str(), ctx); + m_local_image_ctx->operations->execute_snap_remove(cls::rbd::UserSnapshotNamespace(), + m_snap_name.c_str(), + ctx); } template @@ -362,7 +368,8 @@ void SnapshotCopyRequest::handle_snap_create(int r) { assert(m_prev_snap_id != CEPH_NOSNAP); - auto snap_it = m_local_image_ctx->snap_ids.find(m_snap_name); + auto snap_it = m_local_image_ctx->snap_ids.find({cls::rbd::UserSnapshotNamespace(), + m_snap_name}); assert(snap_it != m_local_image_ctx->snap_ids.end()); librados::snap_t local_snap_id = snap_it->second; @@ -442,7 +449,9 @@ void SnapshotCopyRequest::send_snap_protect() { SnapshotCopyRequest, &SnapshotCopyRequest::handle_snap_protect>( this); RWLock::RLocker owner_locker(m_local_image_ctx->owner_lock); - m_local_image_ctx->operations->execute_snap_protect(m_snap_name.c_str(), ctx); + m_local_image_ctx->operations->execute_snap_protect(cls::rbd::UserSnapshotNamespace(), + m_snap_name.c_str(), + ctx); } template diff --git a/src/tools/rbd_mirror/image_sync/SnapshotCreateRequest.cc b/src/tools/rbd_mirror/image_sync/SnapshotCreateRequest.cc index 78317e2dda8..e5cb9eda008 100644 --- a/src/tools/rbd_mirror/image_sync/SnapshotCreateRequest.cc +++ b/src/tools/rbd_mirror/image_sync/SnapshotCreateRequest.cc @@ -190,8 +190,8 @@ void SnapshotCreateRequest::send_snap_create() { SnapshotCreateRequest, &SnapshotCreateRequest::handle_snap_create>( this); RWLock::RLocker owner_locker(m_local_image_ctx->owner_lock); - m_local_image_ctx->operations->execute_snap_create(m_snap_name.c_str(), - m_snap_namespace, + m_local_image_ctx->operations->execute_snap_create(m_snap_namespace, + m_snap_name.c_str(), ctx, 0U, true); } @@ -218,7 +218,8 @@ void SnapshotCreateRequest::send_create_object_map() { } m_local_image_ctx->snap_lock.get_read(); - auto snap_it = m_local_image_ctx->snap_ids.find(m_snap_name); + auto snap_it = m_local_image_ctx->snap_ids.find({cls::rbd::UserSnapshotNamespace(), + m_snap_name}); if (snap_it == m_local_image_ctx->snap_ids.end()) { derr << ": failed to locate snap: " << m_snap_name << dendl; m_local_image_ctx->snap_lock.put_read(); diff --git a/src/tools/rbd_mirror/image_sync/SyncPointCreateRequest.cc b/src/tools/rbd_mirror/image_sync/SyncPointCreateRequest.cc index 5fd0e948572..5323d7d2b8e 100644 --- a/src/tools/rbd_mirror/image_sync/SyncPointCreateRequest.cc +++ b/src/tools/rbd_mirror/image_sync/SyncPointCreateRequest.cc @@ -123,7 +123,7 @@ void SyncPointCreateRequest::send_create_snap() { SyncPointCreateRequest, &SyncPointCreateRequest::handle_create_snap>( this); m_remote_image_ctx->operations->snap_create( - sync_point.snap_name.c_str(), cls::rbd::UserSnapshotNamespace(), ctx); + cls::rbd::UserSnapshotNamespace(), sync_point.snap_name.c_str(), ctx); } template diff --git a/src/tools/rbd_mirror/image_sync/SyncPointPruneRequest.cc b/src/tools/rbd_mirror/image_sync/SyncPointPruneRequest.cc index 9e21bf79075..a9d9445a0f4 100644 --- a/src/tools/rbd_mirror/image_sync/SyncPointPruneRequest.cc +++ b/src/tools/rbd_mirror/image_sync/SyncPointPruneRequest.cc @@ -62,7 +62,8 @@ void SyncPointPruneRequest::send() { it != m_client_meta_copy.sync_points.rend(); ++it) { MirrorPeerSyncPoint &sync_point = *it; if (&sync_point == &m_client_meta_copy.sync_points.front()) { - if (m_remote_image_ctx->get_snap_id(sync_point.snap_name) == + if (m_remote_image_ctx->get_snap_id( + cls::rbd::UserSnapshotNamespace(), sync_point.snap_name) == CEPH_NOSNAP) { derr << ": failed to locate sync point snapshot: " << sync_point.snap_name << dendl; @@ -109,7 +110,9 @@ void SyncPointPruneRequest::send_remove_snap() { Context *ctx = create_context_callback< SyncPointPruneRequest, &SyncPointPruneRequest::handle_remove_snap>( this); - m_remote_image_ctx->operations->snap_remove(snap_name.c_str(), ctx); + m_remote_image_ctx->operations->snap_remove(cls::rbd::UserSnapshotNamespace(), + snap_name.c_str(), + ctx); } template -- 2.39.5