template <typename I>
void DeepCopyRequest<I>::send_copy_object_map() {
m_dst_image_ctx->owner_lock.get_read();
- m_dst_image_ctx->snap_lock.get_read();
+ m_dst_image_ctx->image_lock.get_read();
if (!m_dst_image_ctx->test_features(RBD_FEATURE_OBJECT_MAP,
- m_dst_image_ctx->snap_lock)) {
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock)) {
+ m_dst_image_ctx->image_lock.put_read();
m_dst_image_ctx->owner_lock.put_read();
send_copy_metadata();
return;
}
if (m_snap_id_end == CEPH_NOSNAP) {
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
m_dst_image_ctx->owner_lock.put_read();
send_refresh_object_map();
return;
}
if (finish_op_ctx == nullptr) {
lderr(m_cct) << "lost exclusive lock" << dendl;
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
m_dst_image_ctx->owner_lock.put_read();
finish(r);
return;
ceph_assert(m_snap_seqs->count(m_snap_id_end) > 0);
librados::snap_t copy_snap_id = (*m_snap_seqs)[m_snap_id_end];
m_dst_image_ctx->object_map->rollback(copy_snap_id, ctx);
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
m_dst_image_ctx->owner_lock.put_read();
}
}
{
- RWLock::WLocker snap_locker(m_dst_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_dst_image_ctx->image_lock);
RWLock::WLocker object_map_locker(m_dst_image_ctx->object_map_lock);
std::swap(m_dst_image_ctx->object_map, m_object_map);
}
template <typename I>
int DeepCopyRequest<I>::validate_copy_points() {
- RWLock::RLocker snap_locker(m_src_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_src_image_ctx->image_lock);
if (m_snap_id_start != 0 &&
m_src_image_ctx->snap_info.find(m_snap_id_start) ==
journal(NULL),
owner_lock(util::unique_lock_name("librbd::ImageCtx::owner_lock", this)),
md_lock(util::unique_lock_name("librbd::ImageCtx::md_lock", this)),
- snap_lock(util::unique_lock_name("librbd::ImageCtx::snap_lock", this)),
- timestamp_lock(util::unique_lock_name("librbd::ImageCtx::timestamp_lock", this)),
+ image_lock(util::unique_lock_name("librbd::ImageCtx::image_lock", this)),
parent_lock(util::unique_lock_name("librbd::ImageCtx::parent_lock", this)),
object_map_lock(util::unique_lock_name("librbd::ImageCtx::object_map_lock", this)),
+ timestamp_lock(util::unique_lock_name("librbd::ImageCtx::timestamp_lock", this)),
async_ops_lock(util::unique_lock_name("librbd::ImageCtx::async_ops_lock", this)),
copyup_list_lock(util::unique_lock_name("librbd::ImageCtx::copyup_list_lock", this)),
completed_reqs_lock(util::unique_lock_name("librbd::ImageCtx::completed_reqs_lock", this)),
}
int ImageCtx::snap_set(uint64_t in_snap_id) {
- ceph_assert(snap_lock.is_wlocked());
+ ceph_assert(image_lock.is_wlocked());
auto it = snap_info.find(in_snap_id);
if (in_snap_id != CEPH_NOSNAP && it != snap_info.end()) {
snap_id = in_snap_id;
void ImageCtx::snap_unset()
{
- ceph_assert(snap_lock.is_wlocked());
+ ceph_assert(image_lock.is_wlocked());
snap_id = CEPH_NOSNAP;
snap_namespace = {};
snap_name = "";
snap_t ImageCtx::get_snap_id(const cls::rbd::SnapshotNamespace& in_snap_namespace,
const string& in_snap_name) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
auto it = snap_ids.find({in_snap_namespace, in_snap_name});
if (it != snap_ids.end()) {
return it->second;
const SnapInfo* ImageCtx::get_snap_info(snap_t in_snap_id) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
map<snap_t, SnapInfo>::const_iterator it =
snap_info.find(in_snap_id);
if (it != snap_info.end())
int ImageCtx::get_snap_name(snap_t in_snap_id,
string *out_snap_name) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
const SnapInfo *info = get_snap_info(in_snap_id);
if (info) {
*out_snap_name = info->name;
int ImageCtx::get_snap_namespace(snap_t in_snap_id,
cls::rbd::SnapshotNamespace *out_snap_namespace) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
const SnapInfo *info = get_snap_info(in_snap_id);
if (info) {
*out_snap_namespace = info->snap_namespace;
uint64_t ImageCtx::get_current_size() const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
return size;
}
int ImageCtx::is_snap_protected(snap_t in_snap_id,
bool *is_protected) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
const SnapInfo *info = get_snap_info(in_snap_id);
if (info) {
*is_protected =
int ImageCtx::is_snap_unprotected(snap_t in_snap_id,
bool *is_unprotected) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
const SnapInfo *info = get_snap_info(in_snap_id);
if (info) {
*is_unprotected =
uint8_t protection_status, uint64_t flags,
utime_t timestamp)
{
- ceph_assert(snap_lock.is_wlocked());
+ ceph_assert(image_lock.is_wlocked());
snaps.push_back(id);
SnapInfo info(in_snap_name, in_snap_namespace,
in_size, parent, protection_status, flags, timestamp);
string in_snap_name,
snap_t id)
{
- ceph_assert(snap_lock.is_wlocked());
+ ceph_assert(image_lock.is_wlocked());
snaps.erase(std::remove(snaps.begin(), snaps.end(), id), snaps.end());
snap_info.erase(id);
snap_ids.erase({in_snap_namespace, in_snap_name});
uint64_t ImageCtx::get_image_size(snap_t in_snap_id) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
if (in_snap_id == CEPH_NOSNAP) {
if (!resize_reqs.empty() &&
resize_reqs.front()->shrinking()) {
}
uint64_t ImageCtx::get_object_count(snap_t in_snap_id) const {
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
uint64_t image_size = get_image_size(in_snap_id);
return Striper::get_num_objects(layout, image_size);
}
bool ImageCtx::test_features(uint64_t features) const
{
- RWLock::RLocker l(snap_lock);
- return test_features(features, snap_lock);
+ RWLock::RLocker l(image_lock);
+ return test_features(features, image_lock);
}
bool ImageCtx::test_features(uint64_t in_features,
- const RWLock &in_snap_lock) const
+ const RWLock &in_image_lock) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
return ((features & in_features) == in_features);
}
bool ImageCtx::test_op_features(uint64_t in_op_features) const
{
- RWLock::RLocker snap_locker(snap_lock);
- return test_op_features(in_op_features, snap_lock);
+ RWLock::RLocker image_locker(image_lock);
+ return test_op_features(in_op_features, image_lock);
}
bool ImageCtx::test_op_features(uint64_t in_op_features,
- const RWLock &in_snap_lock) const
+ const RWLock &in_image_lock) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
return ((op_features & in_op_features) == in_op_features);
}
int ImageCtx::get_flags(librados::snap_t _snap_id, uint64_t *_flags) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
if (_snap_id == CEPH_NOSNAP) {
*_flags = flags;
return 0;
int ImageCtx::test_flags(librados::snap_t in_snap_id,
uint64_t flags, bool *flags_set) const
{
- RWLock::RLocker l(snap_lock);
- return test_flags(in_snap_id, flags, snap_lock, flags_set);
+ RWLock::RLocker l(image_lock);
+ return test_flags(in_snap_id, flags, image_lock, flags_set);
}
int ImageCtx::test_flags(librados::snap_t in_snap_id,
- uint64_t flags, const RWLock &in_snap_lock,
+ uint64_t flags, const RWLock &in_image_lock,
bool *flags_set) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
uint64_t snap_flags;
int r = get_flags(in_snap_id, &snap_flags);
if (r < 0) {
int ImageCtx::update_flags(snap_t in_snap_id, uint64_t flag, bool enabled)
{
- ceph_assert(snap_lock.is_wlocked());
+ ceph_assert(image_lock.is_wlocked());
uint64_t *_flags;
if (in_snap_id == CEPH_NOSNAP) {
_flags = &flags;
const ParentImageInfo* ImageCtx::get_parent_info(snap_t in_snap_id) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
ceph_assert(parent_lock.is_locked());
if (in_snap_id == CEPH_NOSNAP)
return &parent_md;
int ImageCtx::get_parent_overlap(snap_t in_snap_id, uint64_t *overlap) const
{
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
const auto info = get_parent_info(in_snap_id);
if (info) {
*overlap = info->overlap;
void ImageCtx::set_image_name(const std::string &image_name) {
// update the name so rename can be invoked repeatedly
RWLock::RLocker owner_locker(owner_lock);
- RWLock::WLocker snap_locker(snap_lock);
+ RWLock::WLocker image_locker(image_lock);
name = image_name;
if (old_format) {
header_oid = util::old_header_name(image_name);
}
journal::Policy *ImageCtx::get_journal_policy() const {
- ceph_assert(snap_lock.is_locked());
+ ceph_assert(image_lock.is_locked());
ceph_assert(journal_policy != nullptr);
return journal_policy;
}
void ImageCtx::set_journal_policy(journal::Policy *policy) {
- ceph_assert(snap_lock.is_wlocked());
+ ceph_assert(image_lock.is_wlocked());
ceph_assert(policy != nullptr);
delete journal_policy;
journal_policy = policy;
/**
* Lock ordering:
*
- * owner_lock, md_lock, snap_lock, parent_lock,
+ * owner_lock, md_lock, image_lock, parent_lock,
* object_map_lock, async_op_lock, timestamp_lock
*/
RWLock owner_lock; // protects exclusive lock leadership updates
// exclusive_locked
// lock_tag
// lockers
- RWLock snap_lock; // protects snapshot-related member variables,
- // features (and associated helper classes), and flags
- RWLock timestamp_lock;
+ RWLock image_lock; // protects snapshot-related member variables,
+ // features (and associated helper classes), and flags
RWLock parent_lock; // protects parent_md and parent
RWLock object_map_lock; // protects object map updates and object_map itself
+
+ RWLock timestamp_lock; // protects (create/access/modify)_timestamp
Mutex async_ops_lock; // protects async_ops and async_requests
Mutex copyup_list_lock; // protects copyup_waiting_list
Mutex completed_reqs_lock; // protects completed_reqs
uint64_t get_object_count(librados::snap_t in_snap_id) const;
bool test_features(uint64_t test_features) const;
bool test_features(uint64_t test_features,
- const RWLock &in_snap_lock) const;
+ const RWLock &in_image_lock) const;
bool test_op_features(uint64_t op_features) const;
bool test_op_features(uint64_t op_features,
- const RWLock &in_snap_lock) const;
+ const RWLock &in_image_lock) const;
int get_flags(librados::snap_t in_snap_id, uint64_t *flags) const;
int test_flags(librados::snap_t in_snap_id,
uint64_t test_flags, bool *flags_set) const;
int test_flags(librados::snap_t in_snap_id,
- uint64_t test_flags, const RWLock &in_snap_lock,
+ uint64_t test_flags, const RWLock &in_image_lock,
bool *flags_set) const;
int update_flags(librados::snap_t in_snap_id, uint64_t flag, bool enabled);
template <typename I>
void ImageWatcher<I>::notify_request_lock() {
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
// ExclusiveLock state machine can be dynamically disabled or
// race with task cancel
template <typename I>
void ImageWatcher<I>::handle_request_lock(int r) {
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
// ExclusiveLock state machine cannot transition -- but can be
// dynamically disabled
template <typename I>
bool Journal<I>::is_journal_supported(I &image_ctx) {
- ceph_assert(image_ctx.snap_lock.is_locked());
+ ceph_assert(image_ctx.image_lock.is_locked());
return ((image_ctx.features & RBD_FEATURE_JOURNALING) &&
!image_ctx.read_only && image_ctx.snap_id == CEPH_NOSNAP);
}
template <typename I>
bool Journal<I>::is_journal_appending() const {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
Mutex::Locker locker(m_lock);
return (m_state == STATE_READY &&
!m_image_ctx.get_journal_policy()->append_disabled());
template <typename I>
bool ObjectMap<I>::object_may_exist(uint64_t object_no) const
{
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
// Fall back to default logic if object map is disabled or invalid
if (!m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP,
- m_image_ctx.snap_lock)) {
+ m_image_ctx.image_lock)) {
return true;
}
bool flags_set;
int r = m_image_ctx.test_flags(m_image_ctx.snap_id,
RBD_FLAG_OBJECT_MAP_INVALID,
- m_image_ctx.snap_lock, &flags_set);
+ m_image_ctx.image_lock, &flags_set);
if (r < 0 || flags_set) {
return true;
}
template <typename I>
bool ObjectMap<I>::object_may_not_exist(uint64_t object_no) const
{
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
// Fall back to default logic if object map is disabled or invalid
if (!m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP,
- m_image_ctx.snap_lock)) {
+ m_image_ctx.image_lock)) {
return true;
}
bool flags_set;
int r = m_image_ctx.test_flags(m_image_ctx.snap_id,
RBD_FLAG_OBJECT_MAP_INVALID,
- m_image_ctx.snap_lock, &flags_set);
+ m_image_ctx.image_lock, &flags_set);
if (r < 0 || flags_set) {
return true;
}
template <typename I>
bool ObjectMap<I>::set_object_map(ceph::BitVector<2> &target_object_map) {
ceph_assert(m_image_ctx.owner_lock.is_locked());
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert(m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP,
- m_image_ctx.snap_lock));
+ m_image_ctx.image_lock));
RWLock::RLocker object_map_locker(m_image_ctx.object_map_lock);
m_object_map = target_object_map;
return true;
template <typename I>
void ObjectMap<I>::rollback(uint64_t snap_id, Context *on_finish) {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert(m_image_ctx.object_map_lock.is_wlocked());
object_map::SnapshotRollbackRequest *req =
template <typename I>
void ObjectMap<I>::snapshot_add(uint64_t snap_id, Context *on_finish) {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert((m_image_ctx.features & RBD_FEATURE_OBJECT_MAP) != 0);
ceph_assert(snap_id != CEPH_NOSNAP);
template <typename I>
void ObjectMap<I>::snapshot_remove(uint64_t snap_id, Context *on_finish) {
- ceph_assert(m_image_ctx.snap_lock.is_wlocked());
+ ceph_assert(m_image_ctx.image_lock.is_wlocked());
ceph_assert((m_image_ctx.features & RBD_FEATURE_OBJECT_MAP) != 0);
ceph_assert(snap_id != CEPH_NOSNAP);
template <typename I>
void ObjectMap<I>::aio_save(Context *on_finish) {
ceph_assert(m_image_ctx.owner_lock.is_locked());
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert(m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP,
- m_image_ctx.snap_lock));
+ m_image_ctx.image_lock));
RWLock::RLocker object_map_locker(m_image_ctx.object_map_lock);
librados::ObjectWriteOperation op;
void ObjectMap<I>::aio_resize(uint64_t new_size, uint8_t default_object_state,
Context *on_finish) {
ceph_assert(m_image_ctx.owner_lock.is_locked());
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert(m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP,
- m_image_ctx.snap_lock));
+ m_image_ctx.image_lock));
ceph_assert(m_image_ctx.image_watcher != NULL);
ceph_assert(m_image_ctx.exclusive_lock == nullptr ||
m_image_ctx.exclusive_lock->is_lock_owner());
CephContext *cct = m_image_ctx.cct;
ldout(cct, 20) << dendl;
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert(m_image_ctx.object_map_lock.is_wlocked());
BlockGuardCell *cell;
m_update_guard->release(cell, &block_ops);
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
RWLock::WLocker object_map_locker(m_image_ctx.object_map_lock);
for (auto &op : block_ops) {
detained_aio_update(std::move(op));
const boost::optional<uint8_t> ¤t_state,
const ZTracer::Trace &parent_trace,
bool ignore_enoent, Context *on_finish) {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert((m_image_ctx.features & RBD_FEATURE_OBJECT_MAP) != 0);
ceph_assert(m_image_ctx.image_watcher != nullptr);
ceph_assert(m_image_ctx.exclusive_lock == nullptr ||
// context can complete before owner_lock is unlocked
RWLock &owner_lock(image_ctx.owner_lock);
owner_lock.get_read();
- image_ctx.snap_lock.get_read();
+ image_ctx.image_lock.get_read();
if (image_ctx.read_only ||
(!permit_snapshot && image_ctx.snap_id != CEPH_NOSNAP)) {
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
owner_lock.put_read();
complete(-EROFS);
return;
}
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
if (image_ctx.exclusive_lock == nullptr) {
send_local_request();
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
m_image_ctx.parent_lock.get_read();
// can't flatten a non-clone
if (m_image_ctx.parent_md.spec.pool_id == -1) {
lderr(cct) << "image has no parent" << dendl;
m_image_ctx.parent_lock.put_read();
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EINVAL);
return;
}
if (m_image_ctx.snap_id != CEPH_NOSNAP) {
lderr(cct) << "snapshots cannot be flattened" << dendl;
m_image_ctx.parent_lock.put_read();
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EROFS);
return;
}
overlap);
m_image_ctx.parent_lock.put_read();
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
operation::FlattenRequest<I> *req = new operation::FlattenRequest<I>(
m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), overlap_objects,
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
if (m_image_ctx.name == dest_name) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EEXIST);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": dest_name=" << dest_name
int Operations<I>::resize(uint64_t size, bool allow_shrink, ProgressContext& prog_ctx) {
CephContext *cct = m_image_ctx.cct;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
ldout(cct, 5) << this << " " << __func__ << ": "
<< "size=" << m_image_ctx.size << ", "
<< "new_size=" << size << dendl;
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
int r = m_image_ctx.state->refresh_if_required();
if (r < 0) {
m_image_ctx.exclusive_lock->is_lock_owner());
CephContext *cct = m_image_ctx.cct;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
ldout(cct, 5) << this << " " << __func__ << ": "
<< "size=" << m_image_ctx.size << ", "
<< "new_size=" << size << dendl;
if (m_image_ctx.snap_id != CEPH_NOSNAP || m_image_ctx.read_only ||
m_image_ctx.operations_disabled) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EROFS);
return;
} else if (m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP,
- m_image_ctx.snap_lock) &&
+ m_image_ctx.image_lock) &&
!ObjectMap<>::is_compatible(m_image_ctx.layout, size)) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EINVAL);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
operation::ResizeRequest<I> *req = new operation::ResizeRequest<I>(
m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), size, allow_shrink,
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
if (m_image_ctx.get_snap_id(snap_namespace, snap_name) != CEPH_NOSNAP) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EEXIST);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
C_InvokeAsyncRequest<I> *req = new C_InvokeAsyncRequest<I>(
m_image_ctx, "snap_create", true,
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
if (m_image_ctx.get_snap_id(snap_namespace, snap_name) != CEPH_NOSNAP) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EEXIST);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
operation::SnapshotCreateRequest<I> *req =
new operation::SnapshotCreateRequest<I>(
{
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
{
- // need to drop snap_lock before invalidating cache
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ // need to drop image_lock before invalidating cache
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
if (!m_image_ctx.snap_exists) {
return -ENOENT;
}
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
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();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-ENOENT);
return;
}
uint64_t new_size = m_image_ctx.get_image_size(snap_id);
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
// async mode used for journal replay
operation::SnapshotRollbackRequest<I> *request =
}
// quickly filter out duplicate ops
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
if (m_image_ctx.get_snap_id(snap_namespace, snap_name) == CEPH_NOSNAP) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-ENOENT);
return;
}
bool proxy_op = ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0 ||
(m_image_ctx.features & RBD_FEATURE_JOURNALING) != 0);
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
if (proxy_op) {
C_InvokeAsyncRequest<I> *req = new C_InvokeAsyncRequest<I>(
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
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();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-ENOENT);
return;
}
bool is_protected;
int r = m_image_ctx.is_snap_protected(snap_id, &is_protected);
if (r < 0) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(r);
return;
} else if (is_protected) {
lderr(m_image_ctx.cct) << "snapshot is protected" << dendl;
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EBUSY);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
operation::SnapshotRemoveRequest<I> *req =
new operation::SnapshotRemoveRequest<I>(
return r;
{
- RWLock::RLocker l(m_image_ctx.snap_lock);
+ RWLock::RLocker l(m_image_ctx.image_lock);
snap_id = m_image_ctx.get_snap_id(cls::rbd::UserSnapshotNamespace(), srcname);
if (snap_id == CEPH_NOSNAP) {
return -ENOENT;
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
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();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EEXIST);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": "
}
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
bool is_protected;
r = m_image_ctx.is_snap_protected(m_image_ctx.get_snap_id(snap_namespace, snap_name),
&is_protected);
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
bool is_protected;
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();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(r);
return;
} else if (is_protected) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EBUSY);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name
}
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
bool is_unprotected;
r = m_image_ctx.is_snap_unprotected(m_image_ctx.get_snap_id(snap_namespace, snap_name),
&is_unprotected);
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
bool is_unprotected;
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();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(r);
return;
} else if (is_unprotected) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EINVAL);
return;
}
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << ": snap_name=" << snap_name
return -EINVAL;
}
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
if (enabled && (features & m_image_ctx.features) != 0) {
lderr(cct) << "one or more requested features are already enabled"
<< dendl;
// when acquiring the exclusive lock in case the journal is corrupt
bool disabling_journal = false;
if (!enabled && ((features & RBD_FEATURE_JOURNALING) != 0)) {
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
m_image_ctx.set_journal_policy(new journal::DisabledPolicy());
disabling_journal = true;
}
BOOST_SCOPE_EXIT_ALL( (this)(disabling_journal) ) {
if (disabling_journal) {
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
m_image_ctx.set_journal_policy(
new journal::StandardPolicy<I>(&m_image_ctx));
}
return;
}
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
m_image_ctx.parent_lock.get_read();
if (m_image_ctx.migration_info.empty()) {
lderr(cct) << "image has no migrating parent" << dendl;
m_image_ctx.parent_lock.put_read();
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EINVAL);
return;
}
if (m_image_ctx.snap_id != CEPH_NOSNAP) {
lderr(cct) << "snapshots cannot be migrated" << dendl;
m_image_ctx.parent_lock.put_read();
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
on_finish->complete(-EROFS);
return;
}
m_image_ctx.parent_lock.put_read();
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
operation::MigrateRequest<I> *req = new operation::MigrateRequest<I>(
m_image_ctx, new C_NotifyUpdate<I>(m_image_ctx, on_finish), prog_ctx);
return r;
}
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
r = clip_io(ictx, off, &len);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
if (r < 0) {
return r;
}
uint64_t end_size;
{
RWLock::RLocker md_locker(m_image_ctx.md_lock);
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_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_namespace, m_from_snap_name);
bool fast_diff_enabled = false;
BitVector<2> object_diff_state;
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
if (m_whole_object && (m_image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0) {
r = diff_object_map(from_snap_id, end_snap_id, &object_diff_state);
if (r < 0) {
DiffContext diff_context(m_image_ctx, m_callback, m_callback_arg,
m_whole_object, from_snap_id, end_snap_id);
if (m_include_parent && from_snap_id == 0) {
- RWLock::RLocker l(m_image_ctx.snap_lock);
+ RWLock::RLocker l(m_image_ctx.image_lock);
RWLock::RLocker l2(m_image_ctx.parent_lock);
uint64_t overlap = 0;
m_image_ctx.get_parent_overlap(m_image_ctx.snap_id, &overlap);
template <typename I>
int DiffIterate<I>::diff_object_map(uint64_t from_snap_id, uint64_t to_snap_id,
BitVector<2>* object_diff_state) {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
CephContext* cct = m_image_ctx.cct;
bool diff_from_start = (from_snap_id == 0);
template <typename I>
snap_t get_group_snap_id(I* ictx,
const cls::rbd::SnapshotNamespace& in_snap_namespace) {
- ceph_assert(ictx->snap_lock.is_locked());
+ ceph_assert(ictx->image_lock.is_locked());
auto it = ictx->snap_ids.lower_bound({in_snap_namespace, ""});
if (it != ictx->snap_ids.end() && it->first.first == in_snap_namespace) {
return it->second;
on_finishes[i] = new C_SaferCond;
std::string snap_name;
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
snap_t snap_id = get_group_snap_id(ictx, ne);
r = ictx->get_snap_name(snap_id, &snap_name);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
if (r >= 0) {
ldout(cct, 20) << "removing individual snapshot from image " << ictx->name
RWLock::RLocker owner_locker(ictx->owner_lock);
std::string snap_name;
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
snap_t snap_id = get_group_snap_id(ictx, ne);
r = ictx->get_snap_name(snap_id, &snap_name);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
if (r >= 0) {
ldout(cct, 20) << "rolling back to individual snapshot for image " << ictx->name
ret_code = r;
} else {
ImageCtx *ictx = ictxs[i];
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
snap_t snap_id = get_group_snap_id(ictx, ne);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
if (snap_id == CEPH_NOSNAP) {
ldout(cct, 20) << "Couldn't find created snapshot with namespace: "
<< ne << dendl;
on_finishes[i] = new C_SaferCond;
std::string snap_name;
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
snap_t snap_id = get_group_snap_id(ictx, ne);
r = ictx->get_snap_name(snap_id, &snap_name);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
if (r >= 0) {
ictx->operations->snap_remove(ne, snap_name.c_str(), on_finishes[i]);
} else {
return r;
}
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
*op_features = ictx->op_features;
return 0;
}
return r;
}
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::RLocker parent_locker(ictx->parent_lock);
bool release_parent_locks = false;
BOOST_SCOPE_EXIT_ALL(ictx, &release_parent_locks) {
if (release_parent_locks) {
ictx->parent->parent_lock.put_read();
- ictx->parent->snap_lock.put_read();
+ ictx->parent->image_lock.put_read();
}
};
auto parent = ictx->parent;
if (!ictx->migration_info.empty() && ictx->parent != nullptr) {
release_parent_locks = true;
- ictx->parent->snap_lock.get_read();
+ ictx->parent->image_lock.get_read();
ictx->parent->parent_lock.get_read();
parent = ictx->parent->parent;
parent_image->pool_name = parent->md_ctx.get_pool_name();
parent_image->pool_namespace = parent->md_ctx.get_namespace();
- RWLock::RLocker parent_snap_locker(parent->snap_lock);
+ RWLock::RLocker parent_image_locker(parent->image_lock);
parent_snap->id = parent->snap_id;
parent_snap->namespace_type = RBD_SNAP_NAMESPACE_TYPE_USER;
if (parent->snap_id != CEPH_NOSNAP) {
int Image<I>::list_descendants(
I *ictx, const std::optional<size_t> &max_level,
std::vector<librbd::linked_image_spec_t> *images) {
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
std::vector<librados::snap_t> snap_ids;
if (ictx->snap_id != CEPH_NOSNAP) {
snap_ids.push_back(ictx->snap_id);
ldout(cct, 20) << "ictx=" << ictx << dendl;
// no children for non-layered or old format image
- if (!ictx->test_features(RBD_FEATURE_LAYERING, ictx->snap_lock)) {
+ if (!ictx->test_features(RBD_FEATURE_LAYERING, ictx->image_lock)) {
return 0;
}
uint64_t features;
uint64_t src_size;
{
- RWLock::RLocker snap_locker(src->snap_lock);
+ RWLock::RLocker image_locker(src->image_lock);
if (!src->migration_info.empty()) {
lderr(cct) << "cannot deep copy migrating image" << dendl;
if (flatten > 0) {
parent_spec.pool_id = -1;
} else {
- RWLock::RLocker snap_locker(src->snap_lock);
+ RWLock::RLocker image_locker(src->image_lock);
RWLock::RLocker parent_locker(src->parent_lock);
// use oldest snapshot or HEAD for parent spec
librados::snap_t snap_id_start = 0;
librados::snap_t snap_id_end;
{
- RWLock::RLocker snap_locker(src->snap_lock);
+ RWLock::RLocker image_locker(src->image_lock);
snap_id_end = src->snap_id;
}
uint64_t snap_id = CEPH_NOSNAP;
std::string name(snap_name == nullptr ? "" : snap_name);
if (!name.empty()) {
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace{},
snap_name);
if (snap_id == CEPH_NOSNAP) {
uint64_t features;
{
- RWLock::RLocker snap_locker(image_ctx->snap_lock);
+ RWLock::RLocker image_locker(image_ctx->image_lock);
features = image_ctx->features;
}
opts.get(RBD_IMAGE_OPTION_FEATURES, &features);
}
for (auto &snap : snaps) {
- RWLock::RLocker snap_locker(m_src_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_src_image_ctx->image_lock);
cls::rbd::ParentImageSpec parent_spec{m_src_image_ctx->md_ctx.get_id(),
m_src_image_ctx->md_ctx.get_namespace(),
m_src_image_ctx->id, snap.id};
uint64_t size;
cls::rbd::ParentImageSpec parent_spec;
{
- RWLock::RLocker snap_locker(m_src_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_src_image_ctx->image_lock);
RWLock::RLocker parent_locker(m_src_image_ctx->parent_lock);
size = m_src_image_ctx->size;
// Also collect the list of the children currently attached to the
// source, so we could make a proper decision later about relinking.
- RWLock::RLocker src_snap_locker(to_image_ctx->snap_lock);
+ RWLock::RLocker src_image_locker(to_image_ctx->image_lock);
cls::rbd::ParentImageSpec src_parent_spec{to_image_ctx->md_ctx.get_id(),
to_image_ctx->md_ctx.get_namespace(),
to_image_ctx->id, snap.id};
return r;
}
- RWLock::RLocker snap_locker(from_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(from_image_ctx->image_lock);
snap.id = from_image_ctx->get_snap_id(cls::rbd::UserSnapshotNamespace(),
snap.name);
if (snap.id == CEPH_NOSNAP) {
std::vector<librbd::linked_image_spec_t> child_images;
{
- RWLock::RLocker snap_locker(from_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(from_image_ctx->image_lock);
cls::rbd::ParentImageSpec parent_spec{from_image_ctx->md_ctx.get_id(),
from_image_ctx->md_ctx.get_namespace(),
from_image_ctx->id, snap.id};
librados::snap_t to_snap_id;
{
- RWLock::RLocker snap_locker(to_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(to_image_ctx->image_lock);
to_snap_id = to_image_ctx->get_snap_id(cls::rbd::UserSnapshotNamespace(),
from_snap.name);
if (to_snap_id == CEPH_NOSNAP) {
cls::rbd::ParentImageSpec parent_spec;
uint64_t parent_overlap;
{
- RWLock::RLocker snap_locker(child_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(child_image_ctx->image_lock);
RWLock::RLocker parent_locker(child_image_ctx->parent_lock);
// use oldest snapshot or HEAD for parent spec
};
{
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
map<librados::snap_t, SnapInfo> snap_info = ictx->snap_info;
for (auto &info : snap_info) {
cls::rbd::ParentImageSpec parent_spec{ictx->md_ctx.get_id(),
return r;
}
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
auto snap_info = ictx->get_snap_info(snap_id);
if (snap_info == nullptr) {
return -ENOENT;
return r;
}
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
auto snap_info = ictx->get_snap_info(snap_id);
if (snap_info == nullptr) {
return -ENOENT;
return r;
}
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
auto snap_info = ictx->get_snap_info(snap_id);
if (snap_info == nullptr) {
return -ENOENT;
cls::rbd::SnapshotNamespace snapshot_namespace;
std::string snapshot_name;
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
auto it = ictx->snap_info.find(snap_id);
if (it == ictx->snap_info.end()) {
return -ENOENT;
if (r == 0) {
if (ictx->test_features(RBD_FEATURE_JOURNALING)) {
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
ictx->set_journal_policy(new journal::DisabledPolicy());
}
}
ictx->owner_lock.put_read();
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
if (!ictx->migration_info.empty()) {
lderr(cct) << "cannot move migrating image to trash" << dendl;
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
ictx->state->close();
return -EBUSY;
}
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
r = disable_mirroring<I>(ictx);
if (r < 0) {
on_dispatched = util::create_async_context_callback(*m_image_ctx,
on_dispatched);
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
auto rd = m_object_cacher->prepare_read(snap_id, read_data, op_flags);
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
ObjectExtent extent(oid, object_no, object_off, object_len, 0);
extent.oloc.pool = m_image_ctx->data_ctx.get_id();
on_dispatched = util::create_async_context_callback(*m_image_ctx,
on_dispatched);
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
ObjectCacher::OSDWrite *wr = m_object_cacher->prepare_write(
snapc, data, ceph::real_time::min(), op_flags, *journal_tid);
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
ObjectExtent extent(oid, 0, object_off, data.length(), 0);
extent.oloc.pool = m_image_ctx->data_ctx.get_id();
uint64_t read_len,
snapid_t snapid)
{
- m_ictx->snap_lock.get_read();
+ m_ictx->image_lock.get_read();
librados::snap_t snap_id = m_ictx->snap_id;
m_ictx->parent_lock.get_read();
uint64_t overlap = 0;
m_ictx->get_parent_overlap(snap_id, &overlap);
m_ictx->parent_lock.put_read();
- m_ictx->snap_lock.put_read();
+ m_ictx->image_lock.put_read();
uint64_t object_no = oid_to_object_no(oid.name, m_ictx->object_prefix);
uint64_t size;
{
- RWLock::RLocker snap_locker(m_src_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_src_image_ctx->image_lock);
size = m_src_image_ctx->get_image_size(CEPH_NOSNAP);
for (auto snap_id : m_src_image_ctx->snaps) {
size = std::max(size, m_src_image_ctx->get_image_size(snap_id));
template <typename I>
void ObjectCopyRequest<I>::send_read_from_parent() {
- m_src_image_ctx->snap_lock.get_read();
+ m_src_image_ctx->image_lock.get_read();
m_src_image_ctx->parent_lock.get_read();
io::Extents image_extents;
compute_read_from_parent_ops(&image_extents);
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
if (image_extents.empty()) {
m_src_image_ctx->parent_lock.put_read();
}
m_dst_image_ctx->owner_lock.get_read();
- m_dst_image_ctx->snap_lock.get_read();
+ m_dst_image_ctx->image_lock.get_read();
if (m_dst_image_ctx->object_map == nullptr) {
// possible that exclusive lock was lost in background
lderr(m_cct) << "object map is not initialized" << dendl;
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
m_dst_image_ctx->owner_lock.put_read();
finish(-EINVAL);
return;
auto finish_op_ctx = start_lock_op(m_dst_image_ctx->owner_lock, &r);
if (finish_op_ctx == nullptr) {
lderr(m_cct) << "lost exclusive lock" << dendl;
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
m_dst_image_ctx->owner_lock.put_read();
finish(r);
return;
// NOTE: state machine might complete before we reach here
dst_image_ctx->object_map_lock.put_write();
- dst_image_ctx->snap_lock.put_read();
+ dst_image_ctx->image_lock.put_read();
dst_image_ctx->owner_lock.put_read();
if (!sent) {
ceph_assert(dst_snap_id == CEPH_NOSNAP);
template <typename I>
void ObjectCopyRequest<I>::compute_read_from_parent_ops(
io::Extents *parent_image_extents) {
- assert(m_src_image_ctx->snap_lock.is_locked());
+ assert(m_src_image_ctx->image_lock.is_locked());
assert(m_src_image_ctx->parent_lock.is_locked());
m_read_ops = {};
}
if (hide_parent) {
- RWLock::RLocker snap_locker(m_dst_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_dst_image_ctx->image_lock);
RWLock::RLocker parent_locker(m_dst_image_ctx->parent_lock);
uint64_t parent_overlap = 0;
int r = m_dst_image_ctx->get_parent_overlap(dst_snap_seq, &parent_overlap);
template <typename I>
void ObjectCopyRequest<I>::compute_dst_object_may_exist() {
- RWLock::RLocker snap_locker(m_dst_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_dst_image_ctx->image_lock);
auto snap_ids = m_dst_image_ctx->snaps;
snap_ids.push_back(CEPH_NOSNAP);
template <typename I>
void SetHeadRequest<I>::send_set_size() {
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
if (m_image_ctx->size == m_size) {
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
send_detach_parent();
return;
}
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
ldout(m_cct, 20) << dendl;
{
// adjust in-memory image size now that it's updated on disk
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
if (m_image_ctx->size > m_size) {
RWLock::WLocker parent_locker(m_image_ctx->parent_lock);
if (m_image_ctx->parent_md.spec.pool_id != -1 &&
for (; snap_id_it != m_dst_snap_ids.end(); ++snap_id_it) {
librados::snap_t dst_snap_id = *snap_id_it;
- m_dst_image_ctx->snap_lock.get_read();
+ m_dst_image_ctx->image_lock.get_read();
bool dst_unprotected;
int r = m_dst_image_ctx->is_snap_unprotected(dst_snap_id, &dst_unprotected);
if (r < 0) {
lderr(m_cct) << "failed to retrieve destination snap unprotect status: "
<< cpp_strerror(r) << dendl;
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
finish(r);
return;
}
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
if (dst_unprotected) {
// snap is already unprotected -- check next snap
});
if (snap_seq_it != m_snap_seqs.end()) {
- m_src_image_ctx->snap_lock.get_read();
+ m_src_image_ctx->image_lock.get_read();
bool src_unprotected;
r = m_src_image_ctx->is_snap_unprotected(snap_seq_it->first,
&src_unprotected);
if (r < 0) {
lderr(m_cct) << "failed to retrieve source snap unprotect status: "
<< cpp_strerror(r) << dendl;
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
finish(r);
return;
}
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
if (src_unprotected) {
// source is unprotected -- unprotect destination snap
{
// avoid the need to refresh to delete the newly unprotected snapshot
- RWLock::RLocker snap_locker(m_dst_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_dst_image_ctx->image_lock);
auto snap_info_it = m_dst_image_ctx->snap_info.find(m_prev_snap_id);
if (snap_info_it != m_dst_image_ctx->snap_info.end()) {
snap_info_it->second.protection_status =
librados::snap_t dst_snap_id = *snap_id_it;
cls::rbd::SnapshotNamespace snap_namespace;
- m_dst_image_ctx->snap_lock.get_read();
+ m_dst_image_ctx->image_lock.get_read();
int r = m_dst_image_ctx->get_snap_namespace(dst_snap_id, &snap_namespace);
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
if (r < 0) {
lderr(m_cct) << "failed to retrieve destination snap namespace: "
<< m_snap_name << dendl;
librados::snap_t src_snap_id = *snap_id_it;
cls::rbd::SnapshotNamespace snap_namespace;
- m_src_image_ctx->snap_lock.get_read();
+ m_src_image_ctx->image_lock.get_read();
int r = m_src_image_ctx->get_snap_namespace(src_snap_id, &snap_namespace);
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
if (r < 0) {
lderr(m_cct) << "failed to retrieve source snap namespace: "
<< m_snap_name << dendl;
m_prev_snap_id = *snap_id_it;
m_snap_name = get_snapshot_name(m_src_image_ctx, m_prev_snap_id);
- m_src_image_ctx->snap_lock.get_read();
+ m_src_image_ctx->image_lock.get_read();
auto snap_info_it = m_src_image_ctx->snap_info.find(m_prev_snap_id);
if (snap_info_it == m_src_image_ctx->snap_info.end()) {
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
lderr(m_cct) << "failed to retrieve source snap info: " << m_snap_name
<< dendl;
finish(-ENOENT);
parent_spec = m_dst_parent_spec;
parent_overlap = snap_info_it->second.parent.overlap;
}
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
ldout(m_cct, 20) << "snap_name=" << m_snap_name << ", "
<< "snap_id=" << m_prev_snap_id << ", "
for (; snap_id_it != m_src_snap_ids.end(); ++snap_id_it) {
librados::snap_t src_snap_id = *snap_id_it;
- m_src_image_ctx->snap_lock.get_read();
+ m_src_image_ctx->image_lock.get_read();
bool src_protected;
int r = m_src_image_ctx->is_snap_protected(src_snap_id, &src_protected);
if (r < 0) {
lderr(m_cct) << "failed to retrieve source snap protect status: "
<< cpp_strerror(r) << dendl;
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
finish(r);
return;
}
- m_src_image_ctx->snap_lock.put_read();
+ m_src_image_ctx->image_lock.put_read();
if (!src_protected) {
// snap is not protected -- check next snap
auto snap_seq_it = m_snap_seqs.find(src_snap_id);
ceph_assert(snap_seq_it != m_snap_seqs.end());
- m_dst_image_ctx->snap_lock.get_read();
+ m_dst_image_ctx->image_lock.get_read();
bool dst_protected;
r = m_dst_image_ctx->is_snap_protected(snap_seq_it->second, &dst_protected);
if (r < 0) {
lderr(m_cct) << "failed to retrieve destination snap protect status: "
<< cpp_strerror(r) << dendl;
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
finish(r);
return;
}
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
if (!dst_protected) {
break;
cls::rbd::ParentImageSpec parent_spec;
uint64_t parent_overlap = 0;
{
- RWLock::RLocker src_locker(m_src_image_ctx->snap_lock);
+ RWLock::RLocker src_locker(m_src_image_ctx->image_lock);
size = m_src_image_ctx->size;
if (!m_flatten) {
parent_spec = m_src_image_ctx->parent_md.spec;
if (m_snap_id_end == CEPH_NOSNAP &&
m_dst_image_ctx->test_features(RBD_FEATURE_OBJECT_MAP)) {
RWLock::RLocker owner_locker(m_dst_image_ctx->owner_lock);
- RWLock::RLocker snap_locker(m_dst_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_dst_image_ctx->image_lock);
if (m_dst_image_ctx->object_map != nullptr &&
Striper::get_num_objects(m_dst_image_ctx->layout,
int SnapshotCopyRequest<I>::validate_parent(I *image_ctx,
cls::rbd::ParentImageSpec *spec) {
RWLock::RLocker owner_locker(image_ctx->owner_lock);
- RWLock::RLocker snap_locker(image_ctx->snap_lock);
+ RWLock::RLocker image_locker(image_ctx->image_lock);
// ensure source image's parent specs are still consistent
*spec = image_ctx->parent_md.spec;
return;
}
- m_dst_image_ctx->snap_lock.get_read();
+ m_dst_image_ctx->image_lock.get_read();
auto snap_it = m_dst_image_ctx->snap_ids.find(
{cls::rbd::UserSnapshotNamespace(), m_snap_name});
if (snap_it == m_dst_image_ctx->snap_ids.end()) {
lderr(m_cct) << "failed to locate snap: " << m_snap_name << dendl;
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
finish(-ENOENT);
return;
}
librados::snap_t local_snap_id = snap_it->second;
- m_dst_image_ctx->snap_lock.put_read();
+ m_dst_image_ctx->image_lock.put_read();
std::string object_map_oid(librbd::ObjectMap<>::object_map_name(
m_dst_image_ctx->id, local_snap_id));
bool journal_enabled;
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
journal_enabled = (m_image_ctx.test_features(RBD_FEATURE_JOURNALING,
- m_image_ctx.snap_lock) &&
+ m_image_ctx.image_lock) &&
!m_image_ctx.get_journal_policy()->journal_disabled());
}
if (!journal_enabled) {
CephContext *cct = m_image_ctx.cct;
ldout(cct, 10) << dendl;
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
using klass = PostAcquireRequest<I>;
Context *ctx = create_context_callback<
klass, &klass::handle_allocate_journal_tag>(this);
template <typename I>
void PostAcquireRequest<I>::apply() {
{
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
ceph_assert(m_image_ctx.object_map == nullptr);
m_image_ctx.object_map = m_object_map;
template <typename I>
void PostAcquireRequest<I>::revert() {
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
m_image_ctx.object_map = nullptr;
m_image_ctx.journal = nullptr;
template <typename I>
void PreReleaseRequest<I>::send_close_journal() {
{
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
std::swap(m_journal, m_image_ctx.journal);
}
template <typename I>
void PreReleaseRequest<I>::send_close_object_map() {
{
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
std::swap(m_object_map, m_image_ctx.object_map);
}
bool snap_protected = false;
if (r == 0) {
- RWLock::RLocker snap_locker(m_parent_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_parent_image_ctx->image_lock);
r = m_parent_image_ctx->is_snap_protected(m_parent_snap_id,
&snap_protected);
}
return;
}
- m_parent_image_ctx->snap_lock.get_read();
+ m_parent_image_ctx->image_lock.get_read();
uint64_t p_features = m_parent_image_ctx->features;
m_size = m_parent_image_ctx->get_image_size(m_parent_image_ctx->snap_id);
bool snap_protected;
int r = m_parent_image_ctx->is_snap_protected(m_parent_image_ctx->snap_id, &snap_protected);
- m_parent_image_ctx->snap_lock.put_read();
+ m_parent_image_ctx->image_lock.put_read();
if ((p_features & RBD_FEATURE_LAYERING) != RBD_FEATURE_LAYERING) {
lderr(m_cct) << "parent image must support layering" << dendl;
Context *ctx = create_context_callback<
klass, &klass::handle_create_child>(this);
- RWLock::RLocker snap_locker(m_parent_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_parent_image_ctx->image_lock);
CreateRequest<I> *req = CreateRequest<I>::create(
m_config, m_ioctx, m_name, m_id, m_size, m_opts,
m_non_primary_global_image_id, m_primary_mirror_uuid, true,
m_exclusive_lock = m_image_ctx->exclusive_lock;
// if reading a snapshot -- possible object map is open
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
if (m_exclusive_lock == nullptr) {
delete m_image_ctx->object_map;
m_image_ctx->object_map = nullptr;
ceph_assert(m_image_ctx->exclusive_lock == nullptr);
// object map and journal closed during exclusive lock shutdown
- RWLock::RLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx->image_lock);
ceph_assert(m_image_ctx->journal == nullptr);
ceph_assert(m_image_ctx->object_map == nullptr);
}
template <typename I>
void DetachChildRequest<I>::send() {
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
// use oldest snapshot or HEAD for parent spec
uint64_t snap_id = CEPH_NOSNAP;
std::swap(m_image_ctx->open_snap_id, snap_id);
if (snap_id == CEPH_NOSNAP) {
- RWLock::RLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx->image_lock);
snap_id = m_image_ctx->get_snap_id(m_image_ctx->snap_namespace,
m_image_ctx->snap_name);
}
// do not attempt to open the journal when removing the image in case
// it's corrupt
if (m_image_ctx->test_features(RBD_FEATURE_JOURNALING)) {
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
m_image_ctx->set_journal_policy(new journal::DisabledPolicy());
}
auto cct = m_image_ctx->cct;
ldout(cct, 5) << dendl;
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
for (auto& snap_info : m_image_ctx->snap_info) {
if (auto_delete_snapshot(snap_info.second)) {
m_snap_infos.insert(snap_info);
} else {
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
ldout(cct, 5) << "image has snapshots - not removing" << dendl;
finish(-ENOTEMPTY);
return;
}
}
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
list_image_watchers();
}
bool RefreshParentRequest<I>::is_refresh_required(
I &child_image_ctx, const ParentImageInfo &parent_md,
const MigrationInfo &migration_info) {
- ceph_assert(child_image_ctx.snap_lock.is_locked());
+ ceph_assert(child_image_ctx.image_lock.is_locked());
ceph_assert(child_image_ctx.parent_lock.is_locked());
return (is_open_required(child_image_ctx, parent_md, migration_info) ||
is_close_required(child_image_ctx, parent_md, migration_info));
template <typename I>
void RefreshParentRequest<I>::apply() {
- ceph_assert(m_child_image_ctx.snap_lock.is_wlocked());
+ ceph_assert(m_child_image_ctx.image_lock.is_wlocked());
ceph_assert(m_child_image_ctx.parent_lock.is_wlocked());
std::swap(m_child_image_ctx.parent, m_parent_image_ctx);
}
uint64_t snap_id;
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
snap_id = m_image_ctx.snap_id;
}
template <typename I>
void RefreshRequest<I>::send_v2_refresh_parent() {
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
ParentImageInfo parent_md;
!m_image_ctx.exclusive_lock->is_lock_owner());
bool journal_disabled_by_policy;
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
journal_disabled_by_policy = (
!journal_disabled &&
m_image_ctx.get_journal_policy()->journal_disabled());
void RefreshRequest<I>::send_v2_block_writes() {
bool disabled_journaling = false;
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
disabled_journaling = ((m_features & RBD_FEATURE_EXCLUSIVE_LOCK) != 0 &&
(m_features & RBD_FEATURE_JOURNALING) == 0 &&
m_image_ctx.journal != nullptr);
RWLock::WLocker md_locker(m_image_ctx.md_lock);
{
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
RWLock::WLocker parent_locker(m_image_ctx.parent_lock);
m_image_ctx.size = m_size;
// handle dynamically enabled / disabled features
if (m_image_ctx.exclusive_lock != nullptr &&
!m_image_ctx.test_features(RBD_FEATURE_EXCLUSIVE_LOCK,
- m_image_ctx.snap_lock)) {
+ m_image_ctx.image_lock)) {
// disabling exclusive lock will automatically handle closing
// object map and journaling
ceph_assert(m_exclusive_lock == nullptr);
std::swap(m_exclusive_lock, m_image_ctx.exclusive_lock);
}
if (!m_image_ctx.test_features(RBD_FEATURE_JOURNALING,
- m_image_ctx.snap_lock)) {
+ m_image_ctx.image_lock)) {
if (!m_image_ctx.clone_copy_on_read && m_image_ctx.journal != nullptr) {
m_image_ctx.io_work_queue->set_require_lock(io::DIRECTION_READ,
false);
std::swap(m_journal, m_image_ctx.journal);
}
if (!m_image_ctx.test_features(RBD_FEATURE_OBJECT_MAP,
- m_image_ctx.snap_lock) ||
+ m_image_ctx.image_lock) ||
m_object_map != nullptr) {
std::swap(m_object_map, m_image_ctx.object_map);
}
CephContext *cct = m_image_ctx->cct;
ldout(cct, 20) << __func__ << dendl;
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
std::vector<uint64_t> snap_ids;
snap_ids.push_back(CEPH_NOSNAP);
for (auto it : m_image_ctx->snap_info) {
template <typename I>
void SetSnapRequest<I>::send_init_exclusive_lock() {
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
if (m_image_ctx.exclusive_lock != nullptr) {
ceph_assert(m_image_ctx.snap_id == CEPH_NOSNAP);
send_complete();
}
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
auto it = m_image_ctx.snap_info.find(m_snap_id);
if (it == m_image_ctx.snap_info.end()) {
ldout(cct, 5) << "failed to locate snapshot '" << m_snap_id << "'"
template <typename I>
Context *SetSnapRequest<I>::send_shut_down_exclusive_lock(int *result) {
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
m_exclusive_lock = m_image_ctx.exclusive_lock;
}
ParentImageInfo parent_md;
bool refresh_parent;
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
RWLock::RLocker parent_locker(m_image_ctx.parent_lock);
const auto parent_info = m_image_ctx.get_parent_info(m_snap_id);
ldout(cct, 10) << __func__ << dendl;
RWLock::WLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
RWLock::WLocker parent_locker(m_image_ctx.parent_lock);
if (m_snap_id != CEPH_NOSNAP) {
ceph_assert(m_image_ctx.exclusive_lock == nullptr);
void image_info(ImageCtx *ictx, image_info_t& info, size_t infosize)
{
int obj_order = ictx->order;
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
info.size = ictx->get_image_size(ictx->snap_id);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
info.obj_size = 1ULL << obj_order;
info.num_objs = Striper::get_num_objects(ictx->layout, info.size);
info.order = obj_order;
ictx->exclusive_lock->is_lock_owner());
C_SaferCond ctx;
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
operation::TrimRequest<> *req = operation::TrimRequest<>::create(
*ictx, &ctx, ictx->size, newsize, prog_ctx);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
req->send();
int r = ctx.wait();
return r;
}
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
snap_t snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(),
snap_name);
int r = ictx->state->refresh_if_required();
if (r < 0)
return r;
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
snap_t snap_id = ictx->get_snap_id(*snap_namespace, snap_name);
if (snap_id == CEPH_NOSNAP)
return -ENOENT;
if (r < 0)
return r;
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
snap_t snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), snap_name);
if (snap_id == CEPH_NOSNAP)
return -ENOENT;
int r = ictx->state->refresh_if_required();
if (r < 0)
return r;
- RWLock::RLocker l2(ictx->snap_lock);
+ RWLock::RLocker l2(ictx->image_lock);
*size = ictx->get_image_size(ictx->snap_id);
return 0;
}
int r = ictx->state->refresh_if_required();
if (r < 0)
return r;
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
*features = ictx->features;
return 0;
}
int r = ictx->state->refresh_if_required();
if (r < 0)
return r;
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
RWLock::RLocker l2(ictx->parent_lock);
return ictx->get_parent_overlap(ictx->snap_id, overlap);
}
return r;
}
- RWLock::RLocker l2(ictx->snap_lock);
+ RWLock::RLocker l2(ictx->image_lock);
return ictx->get_flags(ictx->snap_id, flags);
}
if (r < 0)
return r;
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
for (map<snap_t, SnapInfo>::iterator it = ictx->snap_info.begin();
it != ictx->snap_info.end(); ++it) {
snap_info_t info;
if (r < 0)
return r;
- RWLock::RLocker l(ictx->snap_lock);
+ RWLock::RLocker l(ictx->image_lock);
*exists = ictx->get_snap_id(snap_namespace, snap_name) != CEPH_NOSNAP;
return 0;
}
<< (src->snap_name.length() ? "@" + src->snap_name : "")
<< " -> " << destname << " opts = " << opts << dendl;
- src->snap_lock.get_read();
+ src->image_lock.get_read();
uint64_t features = src->features;
uint64_t src_size = src->get_image_size(src->snap_id);
- src->snap_lock.put_read();
+ src->image_lock.put_read();
uint64_t format = src->old_format ? 1 : 2;
if (opts.get(RBD_IMAGE_OPTION_FORMAT, &format) != 0) {
opts.set(RBD_IMAGE_OPTION_FORMAT, format);
int copy(ImageCtx *src, ImageCtx *dest, ProgressContext &prog_ctx, size_t sparse_size)
{
- src->snap_lock.get_read();
+ src->image_lock.get_read();
uint64_t src_size = src->get_image_size(src->snap_id);
- src->snap_lock.put_read();
+ src->image_lock.put_read();
- dest->snap_lock.get_read();
+ dest->image_lock.get_read();
uint64_t dest_size = dest->get_image_size(dest->snap_id);
- dest->snap_lock.put_read();
+ dest->image_lock.put_read();
CephContext *cct = src->cct;
if (dest_size < src_size) {
}
{
- RWLock::RLocker snap_locker(src->snap_lock);
+ RWLock::RLocker image_locker(src->image_lock);
if (src->object_map != nullptr) {
bool skip = true;
// each period is related to src->stripe_count objects, check them all
return r;
uint64_t mylen = len;
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
r = clip_io(ictx, off, &mylen);
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
if (r < 0)
return r;
// validate extent against image size; clip to image size if necessary
int clip_io(ImageCtx *ictx, uint64_t off, uint64_t *len)
{
- ceph_assert(ictx->snap_lock.is_locked());
+ ceph_assert(ictx->image_lock.is_locked());
uint64_t image_size = ictx->get_image_size(ictx->snap_id);
bool snap_exists = ictx->snap_exists;
return;
}
ictx->total_bytes_read += total_bytes;
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
uint64_t image_size = ictx->get_image_size(ictx->snap_id);
auto snap_id = ictx->snap_id;
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
ictx->md_lock.put_write();
pair<uint64_t, uint64_t> readahead_extent = ictx->readahead.update(image_extents, image_size);
}
ceph_assert(image_ctx.exclusive_lock->is_lock_owner());
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.object_map == nullptr) {
return 1;
}
int update_snapshot(uint64_t snap_id) {
auto& image_ctx = this->m_image_ctx;
uint8_t state = OBJECT_EXISTS;
- if (image_ctx.test_features(RBD_FEATURE_FAST_DIFF, image_ctx.snap_lock) &&
+ if (image_ctx.test_features(RBD_FEATURE_FAST_DIFF, image_ctx.image_lock) &&
(m_snap_id_idx > 0 || m_first_snap_is_clean)) {
// first snapshot should be exists+dirty since it contains
// the copyup data -- later snapshots inherit the data.
template <typename I>
void CopyupRequest<I>::read_from_parent() {
auto cct = m_image_ctx->cct;
- RWLock::RLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx->image_lock);
RWLock::RLocker parent_locker(m_image_ctx->parent_lock);
if (m_image_ctx->parent == nullptr) {
auto cct = m_image_ctx->cct;
ldout(cct, 20) << "oid=" << m_oid << ", r=" << r << dendl;
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
m_lock.Lock();
m_copyup_is_zero = m_copyup_data.is_zero();
m_copyup_required = is_copyup_required();
if (r < 0 && r != -ENOENT) {
m_lock.Unlock();
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
lderr(cct) << "error reading from parent: " << cpp_strerror(r) << dendl;
finish(r);
if (!m_copyup_required) {
m_lock.Unlock();
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
ldout(cct, 20) << "no-op, skipping" << dendl;
finish(0);
}
m_lock.Unlock();
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
update_object_maps();
}
template <typename I>
void CopyupRequest<I>::deep_copy() {
auto cct = m_image_ctx->cct;
- ceph_assert(m_image_ctx->snap_lock.is_locked());
+ ceph_assert(m_image_ctx->image_lock.is_locked());
ceph_assert(m_image_ctx->parent_lock.is_locked());
ceph_assert(m_image_ctx->parent != nullptr);
auto cct = m_image_ctx->cct;
ldout(cct, 20) << "oid=" << m_oid << ", r=" << r << dendl;
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
m_lock.Lock();
m_copyup_required = is_copyup_required();
if (r == -ENOENT && !m_flatten && m_copyup_required) {
m_lock.Unlock();
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
ldout(cct, 10) << "restart deep-copy with flatten" << dendl;
send();
if (r < 0 && r != -ENOENT) {
m_lock.Unlock();
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
lderr(cct) << "error encountered during deep-copy: " << cpp_strerror(r)
<< dendl;
if (!m_copyup_required && !is_update_object_map_required(r)) {
m_lock.Unlock();
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
if (r == -ENOENT) {
r = 0;
}
m_lock.Unlock();
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
update_object_maps();
}
template <typename I>
void CopyupRequest<I>::update_object_maps() {
RWLock::RLocker owner_locker(m_image_ctx->owner_lock);
- RWLock::RLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx->image_lock);
if (m_image_ctx->object_map == nullptr) {
- snap_locker.unlock();
+ image_locker.unlock();
owner_locker.unlock();
copyup();
uint8_t head_object_map_state = OBJECT_EXISTS;
if (copy_on_read && !m_snap_ids.empty() &&
m_image_ctx->test_features(RBD_FEATURE_FAST_DIFF,
- m_image_ctx->snap_lock)) {
+ m_image_ctx->image_lock)) {
// HEAD is non-dirty since data is tied to first snapshot
head_object_map_state = OBJECT_EXISTS_CLEAN;
}
m_snap_ids.push_back(CEPH_NOSNAP);
}
object_map_locker.unlock();
- snap_locker.unlock();
+ image_locker.unlock();
ceph_assert(m_image_ctx->exclusive_lock->is_lock_owner());
typename AsyncObjectThrottle<I>::ContextFactory context_factory(
template <typename I>
void CopyupRequest<I>::copyup() {
auto cct = m_image_ctx->cct;
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
auto snapc = m_image_ctx->snapc;
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
m_lock.Lock();
if (!m_copyup_required) {
template <typename I>
bool CopyupRequest<I>::is_deep_copy() const {
- ceph_assert(m_image_ctx->snap_lock.is_locked());
+ ceph_assert(m_image_ctx->image_lock.is_locked());
return !m_image_ctx->migration_info.empty();
}
template <typename I>
bool CopyupRequest<I>::is_update_object_map_required(int r) {
- ceph_assert(m_image_ctx->snap_lock.is_locked());
+ ceph_assert(m_image_ctx->image_lock.is_locked());
if (r < 0) {
return false;
template <typename I>
void CopyupRequest<I>::compute_deep_copy_snap_ids() {
- ceph_assert(m_image_ctx->snap_lock.is_locked());
+ ceph_assert(m_image_ctx->image_lock.is_locked());
// don't copy ids for the snaps updated by object deep copy or
// that don't overlap
template <typename I>
int ImageRequest<I>::clip_request() {
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
for (auto &image_extent : m_image_extents) {
auto clip_len = image_extent.second;
int r = clip_io(get_image_ctx(&m_image_ctx), image_extent.first, &clip_len);
{
// prevent image size from changing between computing clip and recording
// pending async operation
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
snap_id = image_ctx.snap_id;
// map image extents to object extents
{
// prevent image size from changing between computing clip and recording
// pending async operation
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.snap_id != CEPH_NOSNAP || image_ctx.read_only) {
aio_comp->fail(-EROFS);
return;
bool journaling = false;
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
journaling = (m_flush_source == FLUSH_SOURCE_USER &&
image_ctx.journal != nullptr &&
image_ctx.journal->is_journal_appending());
ldout(cct, 20) << "ictx=" << &m_image_ctx << ", off=" << off << ", "
<< "len = " << len << dendl;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
int r = clip_io(util::get_image_ctx(&m_image_ctx), off, &len);
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
if (r < 0) {
lderr(cct) << "invalid IO request: " << cpp_strerror(r) << dendl;
return r;
ldout(cct, 20) << "ictx=" << &m_image_ctx << ", off=" << off << ", "
<< "len = " << len << dendl;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
int r = clip_io(util::get_image_ctx(&m_image_ctx), off, &len);
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
if (r < 0) {
lderr(cct) << "invalid IO request: " << cpp_strerror(r) << dendl;
return r;
ldout(cct, 20) << "ictx=" << &m_image_ctx << ", off=" << off << ", "
<< "len = " << len << ", data_len " << bl.length() << dendl;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
int r = clip_io(util::get_image_ctx(&m_image_ctx), off, &len);
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
if (r < 0) {
lderr(cct) << "invalid IO request: " << cpp_strerror(r) << dendl;
return r;
ldout(cct, 20) << "compare_and_write ictx=" << &m_image_ctx << ", off="
<< off << ", " << "len = " << len << dendl;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
int r = clip_io(util::get_image_ctx(&m_image_ctx), off, &len);
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
if (r < 0) {
lderr(cct) << "invalid IO request: " << cpp_strerror(r) << dendl;
return r;
template <typename I>
inline bool is_copy_on_read(I *ictx, librados::snap_t snap_id) {
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
return (ictx->clone_copy_on_read &&
!ictx->read_only && snap_id == CEPH_NOSNAP &&
(ictx->exclusive_lock == nullptr ||
template <typename I>
bool ObjectRequest<I>::compute_parent_extents(Extents *parent_extents,
bool read_request) {
- ceph_assert(m_ictx->snap_lock.is_locked());
+ ceph_assert(m_ictx->image_lock.is_locked());
ceph_assert(m_ictx->parent_lock.is_locked());
m_has_parent = false;
void ObjectReadRequest<I>::read_object() {
I *image_ctx = this->m_ictx;
{
- RWLock::RLocker snap_locker(image_ctx->snap_lock);
+ RWLock::RLocker image_locker(image_ctx->image_lock);
if (image_ctx->object_map != nullptr &&
!image_ctx->object_map->object_may_exist(this->m_object_no)) {
image_ctx->op_work_queue->queue(new FunctionContext([this](int r) {
void ObjectReadRequest<I>::read_parent() {
I *image_ctx = this->m_ictx;
- RWLock::RLocker snap_locker(image_ctx->snap_lock);
+ RWLock::RLocker image_locker(image_ctx->image_lock);
RWLock::RLocker parent_locker(image_ctx->parent_lock);
// calculate reverse mapping onto the image
if (object_overlap == 0) {
parent_locker.unlock();
- snap_locker.unlock();
+ image_locker.unlock();
this->finish(-ENOENT);
return;
}
image_ctx->owner_lock.get_read();
- image_ctx->snap_lock.get_read();
+ image_ctx->image_lock.get_read();
image_ctx->parent_lock.get_read();
Extents parent_extents;
if (!this->compute_parent_extents(&parent_extents, true) ||
(image_ctx->exclusive_lock != nullptr &&
!image_ctx->exclusive_lock->is_lock_owner())) {
image_ctx->parent_lock.put_read();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
image_ctx->owner_lock.put_read();
this->finish(0);
return;
image_ctx->copyup_list[this->m_object_no] = new_req;
image_ctx->copyup_list_lock.Unlock();
image_ctx->parent_lock.put_read();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
new_req->send();
} else {
image_ctx->copyup_list_lock.Unlock();
image_ctx->parent_lock.put_read();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
}
image_ctx->owner_lock.put_read();
compute_parent_info();
- ictx->snap_lock.get_read();
+ ictx->image_lock.get_read();
if (!ictx->migration_info.empty()) {
m_guarding_migration_write = true;
}
- ictx->snap_lock.put_read();
+ ictx->image_lock.put_read();
}
template <typename I>
void AbstractObjectWriteRequest<I>::compute_parent_info() {
I *image_ctx = this->m_ictx;
- RWLock::RLocker snap_locker(image_ctx->snap_lock);
+ RWLock::RLocker image_locker(image_ctx->image_lock);
RWLock::RLocker parent_locker(image_ctx->parent_lock);
this->compute_parent_extents(&m_parent_extents, false);
void AbstractObjectWriteRequest<I>::add_write_hint(
librados::ObjectWriteOperation *wr) {
I *image_ctx = this->m_ictx;
- RWLock::RLocker snap_locker(image_ctx->snap_lock);
+ RWLock::RLocker image_locker(image_ctx->image_lock);
if (image_ctx->object_map == nullptr || !this->m_object_may_exist) {
ObjectRequest<I>::add_write_hint(*image_ctx, wr);
}
<< this->m_object_off << "~" << this->m_object_len
<< dendl;
{
- RWLock::RLocker snap_lock(image_ctx->snap_lock);
+ RWLock::RLocker image_lock(image_ctx->image_lock);
if (image_ctx->object_map == nullptr) {
m_object_may_exist = true;
} else {
void AbstractObjectWriteRequest<I>::pre_write_object_map_update() {
I *image_ctx = this->m_ictx;
- image_ctx->snap_lock.get_read();
+ image_ctx->image_lock.get_read();
if (image_ctx->object_map == nullptr || !is_object_map_update_enabled()) {
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
write_object();
return;
}
if (!m_object_may_exist && m_copyup_enabled) {
// optimization: copyup required
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
copyup();
return;
}
CEPH_NOSNAP, this->m_object_no, new_state, {}, this->m_trace, false,
this)) {
image_ctx->object_map_lock.put_write();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
return;
}
image_ctx->object_map_lock.put_write();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
write_object();
}
return;
}
} else if (r == -ERANGE && m_guarding_migration_write) {
- image_ctx->snap_lock.get_read();
+ image_ctx->image_lock.get_read();
m_guarding_migration_write = !image_ctx->migration_info.empty();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
if (m_guarding_migration_write) {
copyup();
void AbstractObjectWriteRequest<I>::post_write_object_map_update() {
I *image_ctx = this->m_ictx;
- image_ctx->snap_lock.get_read();
+ image_ctx->image_lock.get_read();
if (image_ctx->object_map == nullptr || !is_object_map_update_enabled() ||
!is_non_existent_post_write_object_map_state()) {
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
this->finish(0);
return;
}
CEPH_NOSNAP, this->m_object_no, OBJECT_NONEXISTENT, OBJECT_PENDING,
this->m_trace, false, this)) {
image_ctx->object_map_lock.put_write();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
return;
}
image_ctx->object_map_lock.put_write();
- image_ctx->snap_lock.put_read();
+ image_ctx->image_lock.put_read();
this->finish(0);
}
bool Replay<I>::clipped_io(uint64_t image_offset, io::AioCompletion *aio_comp) {
CephContext *cct = m_image_ctx.cct;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
size_t image_size = m_image_ctx.size;
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
if (image_offset >= image_size) {
// rbd-mirror image sync might race an IO event w/ associated resize between
uint64_t max_size = m_image_ctx->size;
{
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
m_snap_ids.push_back(CEPH_NOSNAP);
for (auto it : m_image_ctx->snap_info) {
max_size = std::max(max_size, it.second.size);
void InvalidateRequest<I>::send() {
I &image_ctx = this->m_image_ctx;
ceph_assert(image_ctx.owner_lock.is_locked());
- ceph_assert(image_ctx.snap_lock.is_wlocked());
+ ceph_assert(image_ctx.image_lock.is_wlocked());
uint64_t snap_flags;
int r = image_ctx.get_flags(m_snap_id, &snap_flags);
template <typename I>
void RefreshRequest<I>::send() {
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
m_object_count = Striper::get_num_objects(
m_image_ctx.layout, m_image_ctx.get_image_size(m_snap_id));
}
void RefreshRequest<I>::apply() {
uint64_t num_objs;
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
num_objs = Striper::get_num_objects(
m_image_ctx.layout, m_image_ctx.get_image_size(m_snap_id));
}
m_image_ctx, m_snap_id, true, ctx);
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
req->send();
}
m_image_ctx, m_snap_id, true, ctx);
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
req->send();
}
lderr(cct) << "object map too large: " << m_object_count << dendl;
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
req->send();
}
CephContext *cct = m_image_ctx->cct;
ldout(cct, 20) << __func__ << dendl;
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
std::vector<uint64_t> snap_ids;
snap_ids.push_back(CEPH_NOSNAP);
for (auto it : m_image_ctx->snap_info) {
m_state = STATE_INVALIDATE;
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
InvalidateRequest<> *req = new InvalidateRequest<>(m_image_ctx, m_snap_id,
true,
create_callback_context());
}
void SnapshotCreateRequest::send_read_map() {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
CephContext *cct = m_image_ctx.cct;
std::string oid(ObjectMap<>::object_map_name(m_image_ctx.id, CEPH_NOSNAP));
}
bool SnapshotCreateRequest::send_add_snapshot() {
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
if ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) == 0) {
return true;
}
}
void SnapshotCreateRequest::update_object_map() {
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
RWLock::WLocker object_map_locker(m_image_ctx.object_map_lock);
auto it = m_object_map.begin();
void SnapshotRemoveRequest::send() {
ceph_assert(m_image_ctx.owner_lock.is_locked());
- ceph_assert(m_image_ctx.snap_lock.is_wlocked());
+ ceph_assert(m_image_ctx.image_lock.is_wlocked());
if ((m_image_ctx.features & RBD_FEATURE_FAST_DIFF) != 0) {
int r = m_image_ctx.get_flags(m_snap_id, &m_flags);
<< cpp_strerror(r) << dendl;
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
invalidate_next_map();
return;
}
// snapshot object map exists on disk but is invalid. cannot clean fast-diff
// on next snapshot if current snapshot was invalid.
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
invalidate_next_map();
return;
}
<< cpp_strerror(r) << dendl;
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
invalidate_next_map();
return;
}
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
update_object_map();
remove_map();
}
void SnapshotRemoveRequest::invalidate_next_map() {
ceph_assert(m_image_ctx.owner_lock.is_locked());
- ceph_assert(m_image_ctx.snap_lock.is_wlocked());
+ ceph_assert(m_image_ctx.image_lock.is_wlocked());
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << dendl;
}
void SnapshotRemoveRequest::compute_next_snap_id() {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
m_next_snap_id = CEPH_NOSNAP;
std::map<librados::snap_t, SnapInfo>::const_iterator it =
}
void SnapshotRemoveRequest::update_object_map() {
- assert(m_image_ctx.snap_lock.is_locked());
+ assert(m_image_ctx.image_lock.is_locked());
RWLock::WLocker object_map_locker(m_image_ctx.object_map_lock);
if (m_next_snap_id == m_image_ctx.snap_id && m_next_snap_id == CEPH_NOSNAP) {
CephContext *cct = m_image_ctx.cct;
void SnapshotRollbackRequest::send_invalidate_map() {
RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
template <typename I>
void UpdateRequest<I>::update_object_map() {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert(m_image_ctx.object_map_lock.is_locked());
CephContext *cct = m_image_ctx.cct;
}
{
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
RWLock::WLocker object_map_locker(m_image_ctx.object_map_lock);
update_in_memory_object_map();
template <typename I>
void UpdateRequest<I>::update_in_memory_object_map() {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
ceph_assert(m_image_ctx.object_map_lock.is_locked());
// rebuilding the object map might update on-disk only
bool m_acquired_lock = false;
bool m_writes_blocked = false;
- bool m_snap_lock_acquired = false;
+ bool m_image_lock_acquired = false;
bool m_requests_blocked = false;
uint64_t m_new_features = 0;
}
{
- RWLock::RLocker snap_lock(image_ctx.snap_lock);
+ RWLock::RLocker image_lock(image_ctx.image_lock);
if (image_ctx.object_map != nullptr &&
!image_ctx.object_map->object_may_not_exist(m_object_no)) {
// can skip because the object already exists
// if there are no snaps, remove from the children object as well
// (if snapshots remain, they have their own parent info, and the child
// will be removed when the last snap goes away)
- image_ctx.snap_lock.get_read();
+ image_ctx.image_lock.get_read();
if ((image_ctx.features & RBD_FEATURE_DEEP_FLATTEN) == 0 &&
!image_ctx.snaps.empty()) {
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
detach_parent();
return;
}
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
ldout(cct, 5) << dendl;
auto ctx = create_context_callback<
bool is_within_overlap_bounds() {
I &image_ctx = this->m_image_ctx;
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
auto overlap = std::min(image_ctx.size, image_ctx.migration_info.overlap);
return overlap > 0 &&
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << dendl;
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
RWLock::RLocker parent_locker(image_ctx.parent_lock);
auto overlap = image_ctx.migration_info.overlap;
uint8_t get_object_state() {
I &image_ctx = this->m_image_ctx;
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
for (std::vector<librados::clone_info_t>::const_iterator r =
m_snap_set.clones.begin(); r != m_snap_set.clones.end(); ++r) {
librados::snap_t from_snap_id;
uint64_t next_valid_snap_id(uint64_t snap_id) {
I &image_ctx = this->m_image_ctx;
- ceph_assert(image_ctx.snap_lock.is_locked());
+ ceph_assert(image_ctx.image_lock.is_locked());
std::map<librados::snap_t, SnapInfo>::iterator it =
image_ctx.snap_info.lower_bound(snap_id);
ceph_assert(image_ctx.exclusive_lock == nullptr ||
image_ctx.exclusive_lock->is_lock_owner());
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
ceph_assert(image_ctx.object_map != nullptr);
RWLock::WLocker l(image_ctx.object_map_lock);
uint64_t snap_id;
uint64_t num_objects;
{
- RWLock::RLocker l(m_image_ctx.snap_lock);
+ RWLock::RLocker l(m_image_ctx.image_lock);
snap_id = m_image_ctx.snap_id;
num_objects = Striper::get_num_objects(m_image_ctx.layout,
m_image_ctx.get_image_size(snap_id));
template <typename I>
uint64_t ObjectMapIterateRequest<I>::get_image_size() const {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
if (m_image_ctx.snap_id == CEPH_NOSNAP) {
if (!m_image_ctx.resize_reqs.empty()) {
return m_image_ctx.resize_reqs.front()->get_image_size();
this->create_callback_context());
ceph_assert(m_image_ctx.owner_lock.is_locked());
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
req->send();
}
ceph_assert(m_image_ctx.owner_lock.is_locked());
CephContext *cct = m_image_ctx.cct;
- m_image_ctx.snap_lock.get_read();
+ m_image_ctx.image_lock.get_read();
ceph_assert(m_image_ctx.object_map != nullptr);
uint64_t size = get_image_size();
uint64_t num_objects = Striper::get_num_objects(m_image_ctx.layout, size);
if (m_image_ctx.object_map->size() == num_objects) {
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
send_verify_objects();
return;
}
m_image_ctx.object_map->aio_resize(size, OBJECT_NONEXISTENT,
this->create_callback_context());
- m_image_ctx.snap_lock.put_read();
+ m_image_ctx.image_lock.put_read();
}
template <typename I>
uint64_t new_size;
uint64_t orig_size;
{
- RWLock::RLocker l(m_image_ctx.snap_lock);
+ RWLock::RLocker l(m_image_ctx.image_lock);
ceph_assert(m_image_ctx.object_map != nullptr);
new_size = get_image_size();
ceph_assert(m_image_ctx.exclusive_lock == nullptr ||
m_image_ctx.exclusive_lock->is_lock_owner());
- RWLock::RLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx.image_lock);
ceph_assert(m_image_ctx.object_map != nullptr);
m_image_ctx.object_map->aio_save(this->create_callback_context());
}
ceph_assert(r == 0);
comp->release();
- RWLock::WLocker snap_locker(m_image_ctx.snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx.image_lock);
m_image_ctx.update_flags(m_image_ctx.snap_id, flags, false);
}
template <typename I>
uint64_t RebuildObjectMapRequest<I>::get_image_size() const {
- ceph_assert(m_image_ctx.snap_lock.is_locked());
+ ceph_assert(m_image_ctx.image_lock.is_locked());
if (m_image_ctx.snap_id == CEPH_NOSNAP) {
if (!m_image_ctx.resize_reqs.empty()) {
return m_image_ctx.resize_reqs.front()->get_image_size();
CephContext *cct = image_ctx.cct;
if (m_state == STATE_READ_SOURCE_HEADER && r == -ENOENT) {
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.name == m_dest_name) {
// signal that replay raced with itself
return -EEXIST;
I &image_ctx = this->m_image_ctx;
ceph_assert(image_ctx.owner_lock.is_locked());
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.journal != nullptr &&
image_ctx.journal->is_journal_appending()) {
append_op_event(util::create_context_callback<
template <typename I>
bool Request<I>::commit_op_event(int r) {
I &image_ctx = this->m_image_ctx;
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (!m_appended_op_event) {
return false;
void Request<I>::replay_op_ready(Context *on_safe) {
I &image_ctx = this->m_image_ctx;
ceph_assert(image_ctx.owner_lock.is_locked());
- ceph_assert(image_ctx.snap_lock.is_locked());
+ ceph_assert(image_ctx.image_lock.is_locked());
ceph_assert(m_op_tid != 0);
m_appended_op_event = true;
void Request<I>::append_op_event(Context *on_safe) {
I &image_ctx = this->m_image_ctx;
ceph_assert(image_ctx.owner_lock.is_locked());
- ceph_assert(image_ctx.snap_lock.is_locked());
+ ceph_assert(image_ctx.image_lock.is_locked());
CephContext *cct = image_ctx.cct;
ldout(cct, 10) << this << " " << __func__ << dendl;
ceph_assert(can_affect_io());
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.journal != nullptr) {
if (image_ctx.journal->is_journal_replaying()) {
Context *ctx = util::create_context_callback<T, MF>(request);
I &image_ctx = this->m_image_ctx;
ResizeRequest *next_req = NULL;
{
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
ceph_assert(m_xlist_item.remove_myself());
if (!image_ctx.resize_reqs.empty()) {
next_req = image_ctx.resize_reqs.front();
ceph_assert(image_ctx.owner_lock.is_locked());
{
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
if (!m_xlist_item.is_on_list()) {
image_ctx.resize_reqs.push_back(&m_xlist_item);
if (image_ctx.resize_reqs.front() != this) {
I &image_ctx = this->m_image_ctx;
{
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
m_shrink_size_visible = true;
}
image_ctx.io_work_queue->unblock_writes();
}
image_ctx.owner_lock.get_read();
- image_ctx.snap_lock.get_read();
+ image_ctx.image_lock.get_read();
if (image_ctx.object_map == nullptr) {
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
send_post_block_writes();
image_ctx.object_map->aio_resize(
m_new_size, OBJECT_NONEXISTENT, create_context_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_grow_object_map>(this));
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
return nullptr;
}
I &image_ctx = this->m_image_ctx;
image_ctx.owner_lock.get_read();
- image_ctx.snap_lock.get_read();
+ image_ctx.image_lock.get_read();
if (image_ctx.object_map == nullptr || m_new_size > m_original_size) {
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
update_size_and_overlap();
image_ctx.object_map->aio_resize(
m_new_size, OBJECT_NONEXISTENT, create_context_callback<
ResizeRequest<I>, &ResizeRequest<I>::handle_shrink_object_map>(this));
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
return nullptr;
}
void ResizeRequest<I>::update_size_and_overlap() {
I &image_ctx = this->m_image_ctx;
{
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
image_ctx.size = m_new_size;
RWLock::WLocker parent_locker(image_ctx.parent_lock);
ldout(cct, 5) << this << " " << __func__ << dendl;
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
RWLock::RLocker parent_locker(image_ctx.parent_lock);
// should have been canceled prior to releasing lock
Context *SnapshotCreateRequest<I>::send_create_object_map() {
I &image_ctx = this->m_image_ctx;
- image_ctx.snap_lock.get_read();
+ image_ctx.image_lock.get_read();
if (image_ctx.object_map == nullptr || m_skip_object_map) {
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
update_snap_context();
image_ctx.io_work_queue->unblock_writes();
SnapshotCreateRequest<I>,
&SnapshotCreateRequest<I>::handle_create_object_map>(this));
}
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
return nullptr;
}
I &image_ctx = this->m_image_ctx;
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
if (image_ctx.old_format) {
return;
}
{
RWLock::RLocker md_locker(image_ctx.md_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
librados::ObjectWriteOperation op;
cls_client::snapshot_set_limit(&op, m_snap_limit);
int SnapshotProtectRequest<I>::verify_and_send_protect_snap() {
I &image_ctx = this->m_image_ctx;
RWLock::RLocker md_locker(image_ctx.md_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
CephContext *cct = image_ctx.cct;
if ((image_ctx.features & RBD_FEATURE_LAYERING) == 0) {
ceph_assert(image_ctx.owner_lock.is_locked());
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
RWLock::RLocker object_map_locker(image_ctx.object_map_lock);
if (image_ctx.snap_info.find(m_snap_id) == image_ctx.snap_info.end()) {
lderr(cct) << "snapshot doesn't exist" << dendl;
bool detach_child = false;
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
RWLock::RLocker parent_locker(image_ctx.parent_lock);
cls::rbd::ParentImageSpec our_pspec;
{
RWLock::RLocker owner_lock(image_ctx.owner_lock);
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
RWLock::RLocker object_map_locker(image_ctx.object_map_lock);
if (image_ctx.object_map != nullptr) {
ldout(cct, 5) << dendl;
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << dendl;
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
image_ctx.rm_snap(m_snap_namespace, m_snap_name, m_snap_id);
}
int SnapshotRemoveRequest<I>::scan_for_parents(
cls::rbd::ParentImageSpec &pspec) {
I &image_ctx = this->m_image_ctx;
- ceph_assert(image_ctx.snap_lock.is_locked());
+ ceph_assert(image_ctx.image_lock.is_locked());
ceph_assert(image_ctx.parent_lock.is_locked());
if (pspec.pool_id != -1) {
template <typename I>
journal::Event SnapshotRenameRequest<I>::create_event(uint64_t op_tid) const {
I &image_ctx = this->m_image_ctx;
- ceph_assert(image_ctx.snap_lock.is_locked());
+ ceph_assert(image_ctx.image_lock.is_locked());
std::string src_snap_name;
auto snap_info_it = image_ctx.snap_info.find(m_snap_id);
I &image_ctx = this->m_image_ctx;
ceph_assert(image_ctx.owner_lock.is_locked());
RWLock::RLocker md_locker(image_ctx.md_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
CephContext *cct = image_ctx.cct;
ldout(cct, 5) << this << " " << __func__ << dendl;
<< m_object_num << dendl;
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (m_object_num < m_head_num_objects &&
m_snap_object_map != nullptr &&
!image_ctx.object_map->object_may_exist(m_object_num) &&
uint64_t current_size;
{
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
current_size = image_ctx.get_image_size(CEPH_NOSNAP);
}
CephContext *cct = image_ctx.cct;
{
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
object_map_enabled = (image_ctx.object_map != nullptr);
int r = image_ctx.get_flags(m_snap_id, &flags);
if (r < 0) {
{
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
RWLock::WLocker object_map_lock(image_ctx.object_map_lock);
if (image_ctx.object_map != nullptr) {
CephContext *cct = image_ctx.cct;
RWLock::RLocker owner_locker(image_ctx.owner_lock);
uint64_t num_objects;
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
num_objects = Striper::get_num_objects(image_ctx.layout,
image_ctx.get_current_size());
}
bool object_map_enabled;
{
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
object_map_enabled = (image_ctx.object_map != nullptr);
}
if (!object_map_enabled) {
I &image_ctx = this->m_image_ctx;
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::WLocker snap_locker(image_ctx.snap_lock);
+ RWLock::WLocker image_locker(image_ctx.image_lock);
if (image_ctx.object_map != nullptr) {
std::swap(m_object_map, image_ctx.object_map);
}
int SnapshotUnprotectRequest<I>::verify_and_send_unprotect_snap_start() {
I &image_ctx = this->m_image_ctx;
RWLock::RLocker md_locker(image_ctx.md_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
CephContext *cct = image_ctx.cct;
if ((image_ctx.features & RBD_FEATURE_LAYERING) == 0) {
}
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.object_map != nullptr &&
!image_ctx.object_map->object_may_exist(m_object_no)) {
// can skip because the object does not exist
ldout(m_cct, 20) << dendl;
image_ctx.owner_lock.get_read();
- image_ctx.snap_lock.get_read();
+ image_ctx.image_lock.get_read();
if (image_ctx.object_map == nullptr) {
// possible that exclusive lock was lost in background
lderr(m_cct) << "object map is not initialized" << dendl;
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
finish_op(-EINVAL);
return;
m_finish_op_ctx = image_ctx.exclusive_lock->start_op(&r);
if (m_finish_op_ctx == nullptr) {
lderr(m_cct) << "lost exclusive lock" << dendl;
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
finish_op(r);
return;
// NOTE: state machine might complete before we reach here
image_ctx.object_map_lock.put_write();
- image_ctx.snap_lock.put_read();
+ image_ctx.image_lock.put_read();
image_ctx.owner_lock.put_read();
if (!sent) {
finish_op(0);
bool sent;
{
RWLock::RLocker owner_locker(image_ctx.owner_lock);
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
assert(image_ctx.exclusive_lock->is_lock_owner());
assert(image_ctx.object_map != nullptr);
uint64_t objects = 0;
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
objects = image_ctx.get_object_count(CEPH_NOSNAP);
}
image_ctx.exclusive_lock->is_lock_owner());
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.object_map != nullptr &&
!image_ctx.object_map->object_may_exist(m_object_no)) {
return 1;
}
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.object_map != nullptr) {
ldout(image_ctx.cct, 5) << this << " send_pre_trim: "
<< " delete_start_min=" << m_delete_start_min
bool has_snapshots;
uint64_t parent_overlap;
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
RWLock::RLocker parent_locker(image_ctx.parent_lock);
snapc = image_ctx.snapc;
ceph_assert(image_ctx.owner_lock.is_locked());
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
if (image_ctx.object_map != nullptr) {
ldout(image_ctx.cct, 5) << this << " send_post_trim:"
<< " delete_start_min=" << m_delete_start_min
::SnapContext snapc;
{
- RWLock::RLocker snap_locker(image_ctx.snap_lock);
+ RWLock::RLocker image_locker(image_ctx.image_lock);
snapc = image_ctx.snapc;
}
Return(true)));
} else {
expect.WillOnce(DoAll(WithArg<7>(Invoke([&mock_image_ctx, snap_id, state](Context *ctx) {
- ceph_assert(mock_image_ctx.image_ctx->snap_lock.is_locked());
+ ceph_assert(mock_image_ctx.image_ctx->image_lock.is_locked());
ceph_assert(mock_image_ctx.image_ctx->object_map_lock.is_wlocked());
mock_image_ctx.image_ctx->object_map->aio_update<Context>(
snap_id, 0, 1, state, boost::none, {}, false, ctx);
MockJournal mock_journal;
MockJournalPolicy mock_journal_policy;
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, true);
+ mock_image_ctx.image_lock, true);
expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
expect_journal_disabled(mock_journal_policy, false);
expect_create_journal(mock_image_ctx, &mock_journal);
MockObjectMap mock_object_map;
expect_test_features(mock_image_ctx, RBD_FEATURE_OBJECT_MAP, false);
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, false);
+ mock_image_ctx.image_lock, false);
expect_handle_prepare_lock_complete(mock_image_ctx);
C_SaferCond acquire_ctx;
expect_open_object_map(mock_image_ctx, mock_object_map, 0);
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, false);
+ mock_image_ctx.image_lock, false);
expect_handle_prepare_lock_complete(mock_image_ctx);
C_SaferCond acquire_ctx;
MockJournal mock_journal;
MockJournalPolicy mock_journal_policy;
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, true);
+ mock_image_ctx.image_lock, true);
expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
expect_journal_disabled(mock_journal_policy, false);
expect_create_journal(mock_image_ctx, &mock_journal);
MockObjectMap mock_object_map;
expect_test_features(mock_image_ctx, RBD_FEATURE_OBJECT_MAP, false);
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, false);
+ mock_image_ctx.image_lock, false);
expect_handle_prepare_lock_complete(mock_image_ctx);
C_SaferCond acquire_ctx;
MockJournal *mock_journal = new MockJournal();
MockJournalPolicy mock_journal_policy;
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, true);
+ mock_image_ctx.image_lock, true);
expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
expect_journal_disabled(mock_journal_policy, false);
expect_create_journal(mock_image_ctx, mock_journal);
MockJournal *mock_journal = new MockJournal();
MockJournalPolicy mock_journal_policy;
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, true);
+ mock_image_ctx.image_lock, true);
expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
expect_journal_disabled(mock_journal_policy, false);
expect_create_journal(mock_image_ctx, mock_journal);
MockJournal mock_journal;
MockJournalPolicy mock_journal_policy;
expect_test_features(mock_image_ctx, RBD_FEATURE_JOURNALING,
- mock_image_ctx.snap_lock, true);
+ mock_image_ctx.image_lock, true);
expect_get_journal_policy(mock_image_ctx, mock_journal_policy);
expect_journal_disabled(mock_journal_policy, false);
expect_create_journal(mock_image_ctx, &mock_journal);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->snap_lock.get_write();
+ ictx->image_lock.get_write();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "2", 2, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {2, {2, 1}};
- ictx->snap_lock.put_write();
+ ictx->image_lock.put_write();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->snap_lock.get_write();
+ ictx->image_lock.get_write();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "1", 1, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {1, {1}};
- ictx->snap_lock.put_write();
+ ictx->image_lock.put_write();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->snap_lock.get_write();
+ ictx->image_lock.get_write();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "3", 3, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {3, {3, 2, 1}};
- ictx->snap_lock.put_write();
+ ictx->image_lock.put_write();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->snap_lock.get_write();
+ ictx->image_lock.get_write();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "4", 4, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {4, {4, 3, 2, 1}};
- ictx->snap_lock.put_write();
+ ictx->image_lock.put_write();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
librbd::ImageCtx *ictx;
ASSERT_EQ(0, open_image(m_image_name, &ictx));
- ictx->snap_lock.get_write();
+ ictx->image_lock.get_write();
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "1", 1, ictx->size,
ictx->parent_md, RBD_PROTECTION_STATUS_UNPROTECTED,
0, {});
ictx->snapc = {1, {1}};
- ictx->snap_lock.put_write();
+ ictx->image_lock.put_write();
MockTestImageCtx mock_parent_image_ctx(*ictx->parent);
MockTestImageCtx mock_image_ctx(*ictx, &mock_parent_image_ctx);
ASSERT_EQ(1, current_entry);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
ASSERT_NE(CEPH_NOSNAP, ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(),
"snap"));
}
"snap"));
uint64_t snap_id;
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap");
ASSERT_NE(CEPH_NOSNAP, snap_id);
}
"snap"));
uint64_t snap_id;
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap");
ASSERT_NE(CEPH_NOSNAP, snap_id);
}
ASSERT_EQ(0, ictx->state->refresh());
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(), "snap2");
ASSERT_NE(CEPH_NOSNAP, snap_id);
}
ASSERT_EQ(initial_entry + 2, current_entry);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
uint64_t snap_id = ictx->get_snap_id(cls::rbd::UserSnapshotNamespace(),
"snap");
ASSERT_EQ(CEPH_NOSNAP, snap_id);
lock_tag(image_ctx.lock_tag),
owner_lock(image_ctx.owner_lock),
md_lock(image_ctx.md_lock),
- snap_lock(image_ctx.snap_lock),
+ image_lock(image_ctx.image_lock),
timestamp_lock(image_ctx.timestamp_lock),
parent_lock(image_ctx.parent_lock),
object_map_lock(image_ctx.object_map_lock),
MOCK_CONST_METHOD1(test_features, bool(uint64_t test_features));
MOCK_CONST_METHOD2(test_features, bool(uint64_t test_features,
- const RWLock &in_snap_lock));
+ const RWLock &in_image_lock));
MOCK_CONST_METHOD1(test_op_features, bool(uint64_t op_features));
RWLock &owner_lock;
RWLock &md_lock;
- RWLock &snap_lock;
+ RWLock &image_lock;
RWLock ×tamp_lock;
RWLock &parent_lock;
RWLock &object_map_lock;
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
class TestMockObjectMapSnapshotCreateRequest : public TestMockFixture {
public:
void inject_snap_info(librbd::ImageCtx *ictx, uint64_t snap_id) {
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
RWLock::RLocker parent_locker(ictx->parent_lock);
ictx->add_snap(cls::rbd::UserSnapshotNamespace(), "snap name", snap_id,
ictx->size, ictx->parent_md,
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
AsyncRequest<> *request = new SnapshotCreateRequest(
*ictx, &object_map, snap_id, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
*ictx, &object_map, snap_id, &cond_ctx);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
*ictx, &object_map, snap_id, &cond_ctx);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
{
// shouldn't invalidate the HEAD revision when we fail to load
// the already deleted snapshot
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
uint64_t flags;
ASSERT_EQ(0, ictx->get_flags(CEPH_NOSNAP, &flags));
ASSERT_EQ(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
*ictx, &object_map, snap_id, &cond_ctx);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
*ictx, &object_map, snap_id, &cond_ctx);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
*ictx, &object_map, snap_id, &cond_ctx);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
*ictx, &object_map, snap_id, &cond_ctx);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx.wait());
*ictx, &object_map, snap_id, &cond_ctx);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(-EINVAL, cond_ctx.wait());
{
librbd::ObjectMap om(*ictx, ictx->snap_id);
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
om.set_object_map(object_map);
om.aio_save(&cond_ctx1);
}
*ictx, &object_map, snap_id, &cond_ctx2);
{
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
request->send();
}
ASSERT_EQ(0, cond_ctx2.wait());
ASSERT_EQ(0, cond_ctx.wait());
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
uint64_t flags;
ASSERT_EQ(0, ictx->get_flags(snap_id, &flags));
ASSERT_NE(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
ASSERT_EQ(0, cond_ctx.wait());
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
uint64_t flags;
ASSERT_EQ(0, ictx->get_flags(snap_id, &flags));
ASSERT_EQ(0U, flags & RBD_FLAG_OBJECT_MAP_INVALID);
*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
req->send();
}
*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
req->send();
}
*ictx, &object_map, snap_id, 0, object_map.size(), OBJECT_NONEXISTENT,
OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
req->send();
}
*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
req->send();
}
*ictx, &object_map, snap_id, 0, object_map.size(), OBJECT_EXISTS_CLEAN,
boost::optional<uint8_t>(), {}, false, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
req->send();
}
*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
OBJECT_EXISTS, {}, false, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
req->send();
}
*ictx, &object_map, CEPH_NOSNAP, 0, object_map.size(), OBJECT_NONEXISTENT,
OBJECT_EXISTS, {}, true, &cond_ctx);
{
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
req->send();
}
dst_snap_name));
uint64_t src_size, dst_size;
{
- RWLock::RLocker src_locker(m_src_ictx->snap_lock);
- RWLock::RLocker dst_locker(m_dst_ictx->snap_lock);
+ RWLock::RLocker src_locker(m_src_ictx->image_lock);
+ RWLock::RLocker dst_locker(m_dst_ictx->image_lock);
src_size = m_src_ictx->get_image_size(m_src_ictx->snap_id);
dst_size = m_dst_ictx->get_image_size(m_dst_ictx->snap_id);
}
if (m_dst_ictx->test_features(RBD_FEATURE_LAYERING)) {
bool flags_set;
- RWLock::RLocker dst_locker(m_dst_ictx->snap_lock);
+ RWLock::RLocker dst_locker(m_dst_ictx->image_lock);
EXPECT_EQ(0, m_dst_ictx->test_flags(m_dst_ictx->snap_id,
RBD_FLAG_OBJECT_MAP_INVALID,
- m_dst_ictx->snap_lock, &flags_set));
+ m_dst_ictx->image_lock, &flags_set));
EXPECT_FALSE(flags_set);
}
void test_stress() {
uint64_t initial_size, size;
{
- RWLock::RLocker src_locker(m_src_ictx->snap_lock);
+ RWLock::RLocker src_locker(m_src_ictx->image_lock);
size = initial_size = m_src_ictx->get_image_size(CEPH_NOSNAP);
}
std::cout << "resize: " << new_size << std::endl;
ASSERT_EQ(0, m_src_ictx->operations->resize(new_size, true, no_op));
{
- RWLock::RLocker src_locker(m_src_ictx->snap_lock);
+ RWLock::RLocker src_locker(m_src_ictx->image_lock);
size = m_src_ictx->get_image_size(CEPH_NOSNAP);
}
ASSERT_EQ(new_size, size);
librbd::ImageCtx *dst_ictx) {
uint64_t src_size, dst_size;
{
- RWLock::RLocker src_locker(src_ictx->snap_lock);
- RWLock::RLocker dst_locker(dst_ictx->snap_lock);
+ RWLock::RLocker src_locker(src_ictx->image_lock);
+ RWLock::RLocker dst_locker(dst_ictx->image_lock);
src_size = src_ictx->get_image_size(src_ictx->snap_id);
dst_size = dst_ictx->get_image_size(dst_ictx->snap_id);
}
if (dst_ictx->test_features(RBD_FEATURE_LAYERING)) {
bool flags_set;
- RWLock::RLocker dst_locker(dst_ictx->snap_lock);
+ RWLock::RLocker dst_locker(dst_ictx->image_lock);
EXPECT_EQ(0, dst_ictx->test_flags(dst_ictx->snap_id,
RBD_FLAG_OBJECT_MAP_INVALID,
- dst_ictx->snap_lock, &flags_set));
+ dst_ictx->image_lock, &flags_set));
EXPECT_FALSE(flags_set);
}
});
RWLock::RLocker owner_locker(ictx->owner_lock);
- RWLock::RLocker snap_locker(ictx->snap_lock);
+ RWLock::RLocker image_locker(ictx->image_lock);
RWLock::WLocker object_map_locker(ictx->object_map_lock);
ASSERT_TRUE(ictx->object_map != nullptr);
{
// hide the parent from the snapshot
- RWLock::WLocker snap_locker(ictx2->snap_lock);
+ RWLock::WLocker image_locker(ictx2->image_lock);
ictx2->snap_info.begin()->second.parent = librbd::ParentImageInfo();
}
{
// hide the parent from the snapshot
- RWLock::WLocker snap_locker(ictx2->snap_lock);
+ RWLock::WLocker image_locker(ictx2->image_lock);
ictx2->snap_info.begin()->second.parent = librbd::ParentImageInfo();
}
};
InSequence seq;
- RWLock::RLocker snap_locker(mock_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(mock_image_ctx.image_lock);
EXPECT_CALL(mock_image_ctx, get_journal_policy()).WillOnce(
Return(ictx->get_journal_policy()));
ASSERT_TRUE(mock_journal.is_journal_appending());
C_SaferCond update_ctx1;
C_SaferCond update_ctx2;
{
- RWLock::RLocker snap_locker(mock_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(mock_image_ctx.image_lock);
RWLock::WLocker object_map_locker(mock_image_ctx.object_map_lock);
mock_object_map.aio_update(CEPH_NOSNAP, 0, 1, {}, {}, false, &update_ctx1);
mock_object_map.aio_update(CEPH_NOSNAP, 1, 1, {}, {}, false, &update_ctx2);
C_SaferCond update_ctx3;
C_SaferCond update_ctx4;
{
- RWLock::RLocker snap_locker(mock_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(mock_image_ctx.image_lock);
RWLock::WLocker object_map_locker(mock_image_ctx.object_map_lock);
mock_object_map.aio_update(CEPH_NOSNAP, 1, 4, 1, {}, {}, false,
&update_ctx1);
TEST_F(TestMockImageDeleterSnapshotPurgeRequest, Success) {
{
- RWLock::WLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_local_image_ctx->image_lock);
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap1", 1,
0, {}, RBD_PROTECTION_STATUS_PROTECTED, 0, {});
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap2", 2,
TEST_F(TestMockImageDeleterSnapshotPurgeRequest, OpenError) {
{
- RWLock::WLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_local_image_ctx->image_lock);
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap1", 1,
0, {}, RBD_PROTECTION_STATUS_UNPROTECTED, 0,
{});
TEST_F(TestMockImageDeleterSnapshotPurgeRequest, AcquireLockError) {
{
- RWLock::WLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_local_image_ctx->image_lock);
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap1", 1,
0, {}, RBD_PROTECTION_STATUS_UNPROTECTED, 0,
{});
TEST_F(TestMockImageDeleterSnapshotPurgeRequest, SnapUnprotectBusy) {
{
- RWLock::WLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_local_image_ctx->image_lock);
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap1", 1,
0, {}, RBD_PROTECTION_STATUS_PROTECTED, 0, {});
}
TEST_F(TestMockImageDeleterSnapshotPurgeRequest, SnapUnprotectError) {
{
- RWLock::WLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_local_image_ctx->image_lock);
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap1", 1,
0, {}, RBD_PROTECTION_STATUS_PROTECTED, 0, {});
}
TEST_F(TestMockImageDeleterSnapshotPurgeRequest, SnapRemoveError) {
{
- RWLock::WLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_local_image_ctx->image_lock);
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap1", 1,
0, {}, RBD_PROTECTION_STATUS_UNPROTECTED, 0,
{});
TEST_F(TestMockImageDeleterSnapshotPurgeRequest, CloseError) {
{
- RWLock::WLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_local_image_ctx->image_lock);
m_local_image_ctx->add_snap(cls::rbd::UserSnapshotNamespace{}, "snap1", 1,
0, {}, RBD_PROTECTION_STATUS_UNPROTECTED, 0,
{});
false);
EXPECT_EQ(0, ictx->state->open(0));
{
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
ictx->set_journal_policy(new librbd::journal::DisabledPolicy());
}
false);
EXPECT_EQ(0, ictx->state->open(0));
{
- RWLock::WLocker snap_locker(ictx->snap_lock);
+ RWLock::WLocker image_locker(ictx->image_lock);
ictx->set_journal_policy(new librbd::journal::DisabledPolicy());
}
for (auto &snap_name : snap_names) {
uint64_t remote_snap_id;
{
- RWLock::RLocker remote_snap_locker(m_remote_image_ctx->snap_lock);
+ RWLock::RLocker remote_image_locker(m_remote_image_ctx->image_lock);
remote_snap_id = m_remote_image_ctx->get_snap_id(
cls::rbd::UserSnapshotNamespace{}, snap_name);
}
m_remote_image_ctx->state->snap_set(remote_snap_id, &ctx);
ASSERT_EQ(0, ctx.wait());
- RWLock::RLocker remote_snap_locker(m_remote_image_ctx->snap_lock);
+ RWLock::RLocker remote_image_locker(m_remote_image_ctx->image_lock);
remote_size = m_remote_image_ctx->get_image_size(
m_remote_image_ctx->snap_id);
}
uint64_t local_snap_id;
{
- RWLock::RLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_local_image_ctx->image_lock);
local_snap_id = m_local_image_ctx->get_snap_id(
cls::rbd::UserSnapshotNamespace{}, snap_name);
}
m_local_image_ctx->state->snap_set(local_snap_id, &ctx);
ASSERT_EQ(0, ctx.wait());
- RWLock::RLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_local_image_ctx->image_lock);
local_size = m_local_image_ctx->get_image_size(
m_local_image_ctx->snap_id);
bool flags_set;
ASSERT_EQ(0, m_local_image_ctx->test_flags(m_local_image_ctx->snap_id,
RBD_FLAG_OBJECT_MAP_INVALID,
- m_local_image_ctx->snap_lock,
+ m_local_image_ctx->image_lock,
&flags_set));
ASSERT_FALSE(flags_set);
}
ceph_assert(m_local_journal == nullptr);
{
- RWLock::RLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_local_image_ctx->image_lock);
if (m_local_image_ctx->journal != nullptr) {
m_local_journal = m_local_image_ctx->journal;
m_local_journal->add_listener(m_journal_listener);
bool update_status = false;
{
- RWLock::RLocker snap_locker(m_local_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_local_image_ctx->image_lock);
if (m_local_image_name != m_local_image_ctx->name) {
m_local_image_name = m_local_image_ctx->name;
update_status = true;
librbd::deep_copy::ObjectNumber object_number;
int r = 0;
{
- RWLock::RLocker snap_locker(m_remote_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_remote_image_ctx->image_lock);
ceph_assert(!m_client_meta->sync_points.empty());
auto &sync_point = m_client_meta->sync_points.front();
snap_id_end = m_remote_image_ctx->get_snap_id(
m_image_ctx = I::create("", m_image_id, nullptr, m_io_ctx, false);
{
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
m_image_ctx->set_journal_policy(new JournalPolicy());
}
}
{
- RWLock::RLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx->image_lock);
m_snaps = m_image_ctx->snaps;
}
snap_unprotect();
}
librados::snap_t snap_id = m_snaps.back();
- m_image_ctx->snap_lock.get_read();
+ m_image_ctx->image_lock.get_read();
int r = m_image_ctx->get_snap_namespace(snap_id, &m_snap_namespace);
if (r < 0) {
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
derr << "failed to get snap namespace: " << cpp_strerror(r) << dendl;
m_ret_val = r;
r = m_image_ctx->get_snap_name(snap_id, &m_snap_name);
if (r < 0) {
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
derr << "failed to get snap name: " << cpp_strerror(r) << dendl;
m_ret_val = r;
bool is_protected;
r = m_image_ctx->is_snap_protected(snap_id, &is_protected);
if (r < 0) {
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
derr << "failed to get snap protection status: " << cpp_strerror(r)
<< dendl;
close_image();
return;
}
- m_image_ctx->snap_lock.put_read();
+ m_image_ctx->image_lock.put_read();
if (!is_protected) {
snap_remove();
{
// avoid the need to refresh to delete the newly unprotected snapshot
- RWLock::RLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_image_ctx->image_lock);
librados::snap_t snap_id = m_snaps.back();
auto snap_info_it = m_image_ctx->snap_info.find(snap_id);
if (snap_info_it != m_image_ctx->snap_info.end()) {
{
// don't attempt to open the journal
- RWLock::WLocker snap_locker(m_image_ctx->snap_lock);
+ RWLock::WLocker image_locker(m_image_ctx->image_lock);
m_image_ctx->set_journal_policy(new JournalPolicy());
}
I *local_image_ctx = (*m_local_image_ctx);
{
- local_image_ctx->snap_lock.get_read();
+ local_image_ctx->image_lock.get_read();
if (local_image_ctx->journal == nullptr) {
- local_image_ctx->snap_lock.put_read();
+ local_image_ctx->image_lock.put_read();
derr << "local image does not support journaling" << dendl;
m_ret_val = -EINVAL;
r = (*m_local_image_ctx)->journal->is_resync_requested(m_do_resync);
if (r < 0) {
- local_image_ctx->snap_lock.put_read();
+ local_image_ctx->image_lock.put_read();
derr << "failed to check if a resync was requested" << dendl;
m_ret_val = r;
m_local_tag_data = local_image_ctx->journal->get_tag_data();
dout(10) << "local tag=" << m_local_tag_tid << ", "
<< "local tag data=" << m_local_tag_data << dendl;
- local_image_ctx->snap_lock.put_read();
+ local_image_ctx->image_lock.put_read();
}
if (m_local_tag_data.mirror_uuid != m_remote_mirror_uuid && !m_primary) {
dout(15) << "local_image_id=" << m_local_image_id << dendl;
update_progress("CREATE_LOCAL_IMAGE");
- m_remote_image_ctx->snap_lock.get_read();
+ m_remote_image_ctx->image_lock.get_read();
std::string image_name = m_remote_image_ctx->name;
- m_remote_image_ctx->snap_lock.put_read();
+ m_remote_image_ctx->image_lock.put_read();
Context *ctx = create_context_callback<
BootstrapRequest<I>, &BootstrapRequest<I>::handle_create_local_image>(
Context *ctx = create_context_callback<
klass, &klass::handle_create_image>(this);
- RWLock::RLocker snap_locker(m_remote_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_remote_image_ctx->image_lock);
auto& config{
reinterpret_cast<CephContext*>(m_local_io_ctx.cct())->_conf};
std::string snap_name;
cls::rbd::SnapshotNamespace snap_namespace;
{
- RWLock::RLocker remote_snap_locker(m_remote_parent_image_ctx->snap_lock);
+ RWLock::RLocker remote_image_locker(m_remote_parent_image_ctx->image_lock);
auto it = m_remote_parent_image_ctx->snap_info.find(
m_remote_parent_spec.snap_id);
if (it != m_remote_parent_image_ctx->snap_info.end()) {
template <typename I>
int CreateImageRequest<I>::validate_parent() {
RWLock::RLocker owner_locker(m_remote_image_ctx->owner_lock);
- RWLock::RLocker snap_locker(m_remote_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_remote_image_ctx->image_lock);
m_remote_parent_spec = m_remote_image_ctx->parent_md.spec;
bool EventPreprocessor<I>::prune_snap_map(SnapSeqs *snap_seqs) {
bool pruned = false;
- RWLock::RLocker snap_locker(m_local_image_ctx.snap_lock);
+ RWLock::RLocker image_locker(m_local_image_ctx.image_lock);
for (auto it = snap_seqs->begin(); it != snap_seqs->end(); ) {
auto current_it(it++);
if (m_local_image_ctx.snap_info.count(current_it->second) == 0) {
int r = -EROFS;
{
RWLock::RLocker owner_locker(image_ctx->owner_lock);
- RWLock::RLocker snap_locker(image_ctx->snap_lock);
+ RWLock::RLocker image_locker(image_ctx->image_lock);
if (image_ctx->journal == nullptr || image_ctx->journal->is_tag_owner()) {
r = 0;
}
m_local_io_ctx, false);
{
RWLock::WLocker owner_locker((*m_local_image_ctx)->owner_lock);
- RWLock::WLocker snap_locker((*m_local_image_ctx)->snap_lock);
+ RWLock::WLocker image_locker((*m_local_image_ctx)->image_lock);
(*m_local_image_ctx)->set_exclusive_lock_policy(
new MirrorExclusiveLockPolicy<I>(*m_local_image_ctx));
(*m_local_image_ctx)->set_journal_policy(
} else {
// if we have more than one sync point or invalid sync points,
// trim them off
- RWLock::RLocker snap_locker(m_remote_image_ctx->snap_lock);
+ RWLock::RLocker image_locker(m_remote_image_ctx->image_lock);
std::set<std::string> snap_names;
for (auto it = m_client_meta_copy.sync_points.rbegin();
it != m_client_meta_copy.sync_points.rend(); ++it) {
projects / ceph-ci.git / commitdiff