return true;
}
+ inline bool operator<(const UserSnapshotNamespace& usn) const {
+ return false;
+ }
+
};
std::ostream& operator<<(std::ostream& os, const UserSnapshotNamespace& ns);
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);
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);
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);
{
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<string, snap_t>::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;
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)
snaps.push_back(id);
SnapInfo info(in_snap_name, in_snap_namespace,
in_size, parent, protection_status, flags, timestamp);
- snap_info.insert(pair<snap_t, SnapInfo>(id, info));
- snap_ids.insert(pair<string, snap_t>(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
std::vector<librados::snap_t> snaps; // this mirrors snapc.snaps, but is in
// a format librados can understand
std::map<librados::snap_t, SnapInfo> snap_info;
- std::map<std::string, librados::snap_t> snap_ids;
+ std::map<std::pair<cls::rbd::SnapshotNamespace, std::string>, 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
std::string lock_tag;
std::string name;
+ cls::rbd::SnapshotNamespace snap_namespace;
std::string snap_name;
IoCtx data_ctx, md_ctx;
ImageWatcher<ImageCtx> *image_watcher;
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;
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;
}
template <typename I>
-void ImageState<I>::snap_set(const std::string &snap_name, Context *on_finish) {
+void ImageState<I>::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();
*m_image_ctx, create_context_callback<
ImageState<I>, &ImageState<I>::handle_set_snap>(this));
image::SetSnapRequest<I> *req = image::SetSnapRequest<I>::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();
#include <list>
#include <string>
#include <utility>
+#include "cls/rbd/cls_rbd_types.h"
class Context;
class RWLock;
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();
struct Action {
ActionType action_type;
uint64_t refresh_seq = 0;
+ cls::rbd::SnapshotNamespace snap_namespace;
std::string snap_name;
Context *on_ready = nullptr;
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:
}
template <typename I>
-void ImageWatcher<I>::notify_snap_create(const std::string &snap_name,
- const cls::rbd::SnapshotNamespace &snap_namespace,
+void ImageWatcher<I>::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 <typename I>
void ImageWatcher<I>::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());
}
template <typename I>
-void ImageWatcher<I>::notify_snap_remove(const std::string &snap_name,
+void ImageWatcher<I>::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 <typename I>
-void ImageWatcher<I>::notify_snap_protect(const std::string &snap_name,
+void ImageWatcher<I>::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 <typename I>
-void ImageWatcher<I>::notify_snap_unprotect(const std::string &snap_name,
+void ImageWatcher<I>::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 <typename I>
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;
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) {
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) {
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) {
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);
}
template <typename I>
-int Operations<I>::snap_create(const char *snap_name,
- const cls::rbd::SnapshotNamespace &snap_namespace) {
+int Operations<I>::snap_create(const cls::rbd::SnapshotNamespace &snap_namespace,
+ const char *snap_name) {
if (m_image_ctx.read_only) {
return -EROFS;
}
}
C_SaferCond ctx;
- snap_create(snap_name, snap_namespace, &ctx);
+ snap_create(snap_namespace, snap_name, &ctx);
r = ctx.wait();
if (r < 0) {
}
template <typename I>
-void Operations<I>::snap_create(const char *snap_name,
- const cls::rbd::SnapshotNamespace &snap_namespace,
+void Operations<I>::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
}
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;
C_InvokeAsyncRequest<I> *req = new C_InvokeAsyncRequest<I>(
m_image_ctx, "snap_create", true,
- boost::bind(&Operations<I>::execute_snap_create, this, snap_name,
- snap_namespace, _1, 0, false),
+ boost::bind(&Operations<I>::execute_snap_create, this, snap_namespace, snap_name,
+ _1, 0, false),
boost::bind(&ImageWatcher<I>::notify_snap_create, m_image_ctx.image_watcher,
- snap_name, snap_namespace, _1),
+ snap_namespace, snap_name, _1),
{-EEXIST}, on_finish);
req->send();
}
template <typename I>
-void Operations<I>::execute_snap_create(const std::string &snap_name,
- const cls::rbd::SnapshotNamespace &snap_namespace,
+void Operations<I>::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) {
<< 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;
operation::SnapshotCreateRequest<I> *req =
new operation::SnapshotCreateRequest<I>(
- m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_name,
- snap_namespace, journal_op_tid, skip_object_map);
+ m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish),
+ snap_namespace, snap_name, journal_op_tid, skip_object_map);
req->send();
}
template <typename I>
-int Operations<I>::snap_rollback(const char *snap_name,
+int Operations<I>::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
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;
}
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;
}
template <typename I>
-void Operations<I>::execute_snap_rollback(const std::string &snap_name,
+void Operations<I>::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());
<< 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();
// async mode used for journal replay
operation::SnapshotRollbackRequest<I> *request =
new operation::SnapshotRollbackRequest<I>(
- m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_name,
+ m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_namespace, snap_name,
snap_id, new_size, prog_ctx);
request->send();
}
template <typename I>
-int Operations<I>::snap_remove(const char *snap_name) {
+int Operations<I>::snap_remove(const cls::rbd::SnapshotNamespace& snap_namespace,
+ const char *snap_name) {
if (m_image_ctx.read_only) {
return -EROFS;
}
}
C_SaferCond ctx;
- snap_remove(snap_name, &ctx);
+ snap_remove(snap_namespace, snap_name, &ctx);
r = ctx.wait();
if (r < 0) {
}
template <typename I>
-void Operations<I>::snap_remove(const char *snap_name, Context *on_finish) {
+void Operations<I>::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;
// 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;
if (proxy_op) {
C_InvokeAsyncRequest<I> *req = new C_InvokeAsyncRequest<I>(
m_image_ctx, "snap_remove", true,
- boost::bind(&Operations<I>::execute_snap_remove, this, snap_name, _1),
+ boost::bind(&Operations<I>::execute_snap_remove, this, snap_namespace, snap_name, _1),
boost::bind(&ImageWatcher<I>::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 <typename I>
-void Operations<I>::execute_snap_remove(const std::string &snap_name,
+void Operations<I>::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());
{
<< 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();
operation::SnapshotRemoveRequest<I> *req =
new operation::SnapshotRemoveRequest<I>(
- m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_name,
- snap_id);
+ m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish),
+ snap_namespace, snap_name, snap_id);
req->send();
}
{
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;
}
}
}
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;
}
template <typename I>
-int Operations<I>::snap_protect(const char *snap_name) {
+int Operations<I>::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;
{
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;
if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) {
r = invoke_async_request("snap_protect", true,
boost::bind(&Operations<I>::execute_snap_protect,
- this, snap_name, _1),
+ this, snap_namespace, snap_name, _1),
boost::bind(&ImageWatcher<I>::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) {
}
template <typename I>
-void Operations<I>::execute_snap_protect(const std::string &snap_name,
+void Operations<I>::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)) {
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();
operation::SnapshotProtectRequest<I> *request =
new operation::SnapshotProtectRequest<I>(
- m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_name);
+ m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_namespace, snap_name);
request->send();
}
template <typename I>
-int Operations<I>::snap_unprotect(const char *snap_name) {
+int Operations<I>::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;
{
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;
if (m_image_ctx.test_features(RBD_FEATURE_JOURNALING)) {
r = invoke_async_request("snap_unprotect", true,
boost::bind(&Operations<I>::execute_snap_unprotect,
- this, snap_name, _1),
+ this, snap_namespace, snap_name, _1),
boost::bind(&ImageWatcher<I>::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) {
}
template <typename I>
-void Operations<I>::execute_snap_unprotect(const std::string &snap_name,
+void Operations<I>::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)) {
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();
operation::SnapshotUnprotectRequest<I> *request =
new operation::SnapshotUnprotectRequest<I>(
- m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_name);
+ m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), snap_namespace, snap_name);
request->send();
}
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);
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;
void SnapCreatePayload::dump(Formatter *f) const {
SnapPayloadBase::dump(f);
- cls::rbd::SnapshotNamespaceOnDisk sn(snap_namespace);
- sn.dump(f);
}
void SnapRenamePayload::encode(bufferlist &bl) 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);
}
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)));
public:
static const bool CHECK_FOR_REFRESH = true;
+ cls::rbd::SnapshotNamespace snap_namespace;
std::string snap_name;
void encode(bufferlist &bl) const;
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);
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;
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 {
} // anonymous namespace
template <typename I>
-int DiffIterate<I>::diff_iterate(I *ictx, const char *fromsnapname,
+int DiffIterate<I>::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 *),
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;
}
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;
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);
#include "include/int_types.h"
#include "common/bit_vector.hpp"
+#include "cls/rbd/cls_rbd_types.h"
namespace librbd {
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 *),
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;
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)
using klass = OpenRequest<I>;
SetSnapRequest<I> *req = SetSnapRequest<I>::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<klass, &klass::handle_set_snap>(this));
req->send();
return nullptr;
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<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_set_parent_snap, false>(this);
SetSnapRequest<I> *req = SetSnapRequest<I>::create(
- *m_parent_image_ctx, snap_name, ctx);
+ *m_parent_image_ctx, snap_namespace, snap_name, ctx);
req->send();
}
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;
using util::create_context_callback;
template <typename I>
-SetSnapRequest<I>::SetSnapRequest(I &image_ctx, const std::string &snap_name,
+SetSnapRequest<I>::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) {
}
{
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;
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;
}
#ifndef CEPH_LIBRBD_IMAGE_SNAP_SET_REQUEST_H
#define CEPH_LIBRBD_IMAGE_SNAP_SET_REQUEST_H
+#include "cls/rbd/cls_rbd_client.h"
#include <string>
class Context;
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();
* @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;
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<int64_t, string>, set<string> > image_info;
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;
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;
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;
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<cls::rbd::UserSnapshotNamespace>(&snap_namespace) == nullptr) {
- return -EINVAL;
- }
-
r = ictx->state->refresh_if_required();
if (r < 0)
return r;
}
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;
}
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;
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;
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) {
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<std::string>& names);
int list_children(ImageCtx *ictx,
const std::string &image_id, ProgressContext& prog_ctx,
bool force=false);
int snap_list(ImageCtx *ictx, std::vector<snap_info_t>& 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,
}
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);
}
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;
void SnapCreateEvent::dump(Formatter *f) const {
SnapEventBase::dump(f);
- cls::rbd::SnapshotNamespaceOnDisk(snap_namespace).dump(f);
}
void SnapLimitEvent::encode(bufferlist &bl) 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);
}
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 {
}
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);
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)));
::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 {
if (object_number) {
f->dump_unsigned("object_number", *object_number);
}
+ cls::rbd::SnapshotNamespaceOnDisk(snap_namespace).dump(f);
}
void MirrorPeerClientMeta::encode(bufferlist& bl) 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);
}
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()));
}
};
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;
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;
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;
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;
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;
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;
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;
struct MirrorPeerSyncPoint {
typedef boost::optional<uint64_t> 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;
{
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;
}
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;
}
{
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;
}
{
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;
}
{
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;
}
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.
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;
}
{
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;
}
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;
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);
{
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;
}
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;
}
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;
}
{
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;
}
{
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;
}
{
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;
}
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;
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);
boost::get<journal::MirrorPeerClientMeta>(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) {
template <typename I>
void DisableRequest<I>::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;
Context *ctx = create_context_callback(
&DisableRequest<I>::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);
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);
template <typename I>
SnapshotCreateRequest<I>::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<I>(image_ctx, on_finish, journal_op_tid), m_snap_name(snap_name),
- m_snap_namespace(snap_namespace),
+ : Request<I>(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) {
}
// 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
* (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);
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;
template <typename I>
SnapshotProtectRequest<I>::SnapshotProtectRequest(I &image_ctx,
Context *on_finish,
- const std::string &snap_name)
- : Request<I>(image_ctx, on_finish), m_snap_name(snap_name) {
+ const cls::rbd::SnapshotNamespace &snap_namespace,
+ const std::string &snap_name)
+ : Request<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace), m_snap_name(snap_name) {
}
template <typename I>
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;
}
};
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;
template <typename I>
SnapshotRemoveRequest<I>::SnapshotRemoveRequest(I &image_ctx,
Context *on_finish,
+ const cls::rbd::SnapshotNamespace &snap_namespace,
const std::string &snap_name,
uint64_t snap_id)
- : Request<I>(image_ctx, on_finish), m_snap_name(snap_name),
- m_snap_id(snap_id) {
+ : Request<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace),
+ m_snap_name(snap_name), m_snap_id(snap_id) {
}
template <typename I>
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 <typename I>
};
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;
template <typename I>
SnapshotRollbackRequest<I>::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<I>(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<I>(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 <typename I>
*/
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;
}
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;
template <typename I>
SnapshotUnprotectRequest<I>::SnapshotUnprotectRequest(I &image_ctx,
Context *on_finish,
- const std::string &snap_name)
- : Request<I>(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<I>(image_ctx, on_finish), m_snap_namespace(snap_namespace),
+ m_snap_name(snap_name), m_ret_val(0), m_snap_id(CEPH_NOSNAP) {
}
template <typename I>
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;
}
};
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;
}
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;
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,
}
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) {
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;
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;
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;
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);
{
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) {
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;
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);
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) {
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;
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);
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) {
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);
}
{
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);
}
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;
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);
// 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) {
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;
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);
{
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) {
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;
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;
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)));
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)));
}
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)));
}
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;
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);
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);
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);
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;
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);
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());
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;
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;
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;
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;
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;
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
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;
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;
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 <typename T>
{"", 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<uint64_t>(0)},
- {"snap 2", boost::optional<uint64_t>(0)}}}
+ "remote image id", {{cls::rbd::UserSnapshotNamespace(), "snap 1", boost::optional<uint64_t>(0)},
+ {cls::rbd::UserSnapshotNamespace(), "snap 2", boost::optional<uint64_t>(0)}}}
})}
}, 0);
expect_journal_client_unregister(mock_image_ctx, "peer 1", 0);
{"", 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<uint64_t>(0)},
- {"snap 2", boost::optional<uint64_t>(0)}}}
+ "remote image id", {{cls::rbd::UserSnapshotNamespace(), "snap 1", boost::optional<uint64_t>(0)},
+ {cls::rbd::UserSnapshotNamespace(), "snap 2", boost::optional<uint64_t>(0)}}}
})}
}, 0);
expect_journal_client_unregister(mock_image_ctx, "peer 1", 0);
{"", 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<uint64_t>(0)},
- {"snap 2", boost::optional<uint64_t>(0)}}}
+ "remote image id", {{cls::rbd::UserSnapshotNamespace(), "snap 1", boost::optional<uint64_t>(0)},
+ {cls::rbd::UserSnapshotNamespace(), "snap 2", boost::optional<uint64_t>(0)}}}
})}
}, 0);
expect_journal_client_unregister(mock_image_ctx, "peer 1", -EINVAL);
: 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),
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));
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 *));
CephContext *cct;
PerfCounters *perfcounter;
+ cls::rbd::SnapshotNamespace snap_namespace;
std::string snap_name;
uint64_t snap_id;
bool snap_exists;
::SnapContext snapc;
std::vector<librados::snap_t> snaps;
std::map<librados::snap_t, SnapInfo> snap_info;
- std::map<std::string, librados::snap_t> snap_ids;
+ std::map<std::pair<cls::rbd::SnapshotNamespace, std::string>, librados::snap_t> snap_ids;
ObjectCacher *object_cacher;
ObjectCacher::ObjectSet *object_set;
#include <gmock/gmock.h>
+#include "cls/rbd/cls_rbd_types.h"
+
class Context;
namespace librbd {
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());
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));
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,
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);
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());
}
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);
// 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<const librbd::SnapInfo*>(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) {
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();
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();
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();
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();
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();
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();
typedef SnapshotProtectRequest<MockImageCtx> 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));
}
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();
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();
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();
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();
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();
}
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) {
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();
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();
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();
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();
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();
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();
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();
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();
typedef SnapshotUnprotectRequest<MockImageCtx> 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));
}
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();
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();
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();
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();
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();
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();
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;
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;
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;
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;
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;
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,
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();
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;
}
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;
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));
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) {
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));
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));
for (std::list<std::string>::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,
}
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,
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
}
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,
ASSERT_EQ(static_cast<int>(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
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);
}
} 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'));
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));
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
ASSERT_EQ(0, io_ctx.write(oid, bl, 4096, 4096));
interval_set<uint64_t> 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);
}
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", {});
"", "", 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();
}
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);
})));
}
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,
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,
}
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);
}));
}
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);
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));
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);
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);
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);
} 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);
} 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);
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);
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);
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);
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);
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);
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<std::string, librados::snap_t> &pair) {
+ [snap_id](const std::pair<std::pair<cls::rbd::SnapshotNamespace,
+ std::string>,
+ 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() {
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;
}
}
}
- 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;
}
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) {
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);
})));
}
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,
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;
}
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);
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);
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;
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,
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);
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);
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;
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);
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);
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);
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);
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);
}))));
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
}))));
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);
}),
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,
}
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);
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));
}
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,
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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,
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);
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());
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);
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());
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);
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);
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();
}
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;
}
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;
}
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);
}));
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;
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);
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
}
}
- 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;
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;
Context *ctx = create_context_callback<
CreateImageRequest<I>,
&CreateImageRequest<I>::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 <typename I>
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()) {
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;
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;
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;
auto snap_it = std::find_if(image_ctx->snap_ids.begin(),
image_ctx->snap_ids.end(),
[snap_id](
- const std::pair<std::string, librados::snap_t> &pair) {
+ const std::pair<
+ std::pair<cls::rbd::SnapshotNamespace,
+ std::string>,
+ 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
SnapshotCopyRequest<I>, &SnapshotCopyRequest<I>::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);
}
SnapshotCopyRequest<I>, &SnapshotCopyRequest<I>::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 <typename I>
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;
SnapshotCopyRequest<I>, &SnapshotCopyRequest<I>::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 <typename I>
SnapshotCreateRequest<I>, &SnapshotCreateRequest<I>::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);
}
}
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();
SyncPointCreateRequest<I>, &SyncPointCreateRequest<I>::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 <typename I>
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;
Context *ctx = create_context_callback<
SyncPointPruneRequest<I>, &SyncPointPruneRequest<I>::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 <typename I>
projects / ceph.git / commitdiff